[Mplayer-cvslog] CVS: main/Gui/wm widget.h,NONE,1.1 ws.c,NONE,1.1 ws.h,NONE,1.1 wsconv.c,NONE,1.1 wsconv.h,NONE,1.1 wskeys.h,NONE,1.1 wsmkeys.h,NONE,1.1

Arpi of Ize arpi at mplayer.dev.hu
Sat Aug 25 23:04:33 CEST 2001


Update of /cvsroot/mplayer/main/Gui/wm
In directory mplayer:/var/tmp.root/cvs-serv13203/wm

Added Files:
	widget.h ws.c ws.h wsconv.c wsconv.h wskeys.h wsmkeys.h 
Log Message:
GUI version n-1

--- NEW FILE ---

#define wgIsRect( X,Y,tX,tY,bX,bY ) ( ( X > tX )&&( Y > tY )&&( X < bX )&&( Y < bY ) )
--- NEW FILE ---

// --------------------------------------------------------------------------
//  AutoSpace Window System for Linux/Win32 v0.85
//   Writed by pontscho/fresh!mindworkz
// --------------------------------------------------------------------------

#include <X11/Xlib.h>
#include <X11/Xproto.h>
#include <X11/Xutil.h>
#include <X11/keysym.h>
#include <X11/Xatom.h>
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>

#include "ws.h"
#include "wsconv.h"
#include "../../config.h"

[...1038 lines suppressed...]
      dpms_disabled=1;
      stat=DPMSDisable( mDisplay );  // monitor powersave off
      fprintf( stderr,"stat: %d.\n",stat );
   }
  }
 XGetScreenSaver( mDisplay,&timeout_save,&interval,&prefer_blank,&allow_exp );
 if ( timeout_save ) XSetScreenSaver( mDisplay,0,interval,prefer_blank,allow_exp ); // turning off screensaver
}

void wsSetShape( wsTWindow * win,char * data )
{
#ifdef HAVE_XSHAPE
 if ( ( !wsUseXShape )||( !data ) ) return;
 win->Mask=XCreateBitmapFromData( wsDisplay,win->WindowID,data,win->Width,win->Height );
 XShapeCombineMask( wsDisplay,win->WindowID,ShapeBounding,0,0,win->Mask,ShapeSet );
 XFreePixmap( wsDisplay,win->Mask );
#endif
}

#include "wsmkeys.h"

--- NEW FILE ---

// ----------------------------------------------------------------------------------------------
//  AutoSpace Window System for Linux/Win32 v0.61
//   Writed by pontscho / fresh!mindworkz
// ----------------------------------------------------------------------------------------------

#ifndef __MY_WS
#define __MY_WS

#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/keysym.h>
#include <X11/Xatom.h>
#include <X11/extensions/XShm.h>
#include <X11/extensions/dpms.h>

#define  wsKeyReleased   0
#define  wsKeyPressed    1

#define  wsShift        (1L<<0)
#define  wsLock         (1L<<1)
#define  wsCtrl         (1L<<2)
#define  wsAlt          (1L<<3)

#define  wsPLMouseButton 1
#define  wsPMMouseButton 2
#define  wsPRMouseButton 3
#define  wsRLMouseButton 1 + 128
#define  wsRMMouseButton 2 + 128
#define  wsRRMouseButton 3 + 128
#define  wsEnterWindow   253
#define  wsLeaveWindow   254
#define  wsMoveMouse     255

#define  wsShowMouseCursor   1
#define  wsMouse             1
#define  wsHideMouseCursor   0
#define  wsNoMouse           0
#define  wsHandleMouseButton 2
#define  wsHandleMouseMove   4

#define  wsHideFrame    0
#define  wsNoFrame      0
#define  wsShowFrame    1
#define  wsFrame        1
#define  wsMaxSize      2
#define  wsMinSize      4
#define  wsShowWindow   8
#define  wsHideWindow   16
#define  wsOverredirect 32

#define  wsNoBorder 0

#define  wsSysName "AutoSpace Window System LiTe"

#define wsRGB32 1
#define wsBGR32 2
#define wsRGB24 3
#define wsBGR24 4
#define wsRGB16 5
#define wsBGR16 6
#define wsRGB15 7
#define wsBGR15 8

#define wsWindowVisible          1
#define wsWindowPartialVisible   2
#define wsWindowNotVisible       4
#define wsWindowMapped           8
#define wsWindowUnmapped        16
#define wsWindowFocusIn         32
#define wsWindowFocusOut        64
#define wsWindowExpose         128
#define wsWindowRolled         256

#define wsNone       0
#define wsMapped     1
#define wsFocused    2
#define wsVisible    3
#define wsNotVisible 4
#define wsPVisible   5
#define wsRolled     6

#define wsParamDisplay Display *dpy,Window w

typedef   void (*wsTReDraw)( wsParamDisplay );
typedef   void (*wsTReSize)( unsigned int X,unsigned int Y,unsigned int width,unsigned int height );
typedef   void (*wsTIdle)( void );
typedef   void (*wsTKeyHandler)( int State,int Type,int Key );
typedef   void (*wsTMouseHandler)( int Button,int X,int Y,int RX,int RY  );
typedef   void (*wsRemoteHandler)( char * str );

typedef struct
{
 Window               WindowID;
 Window               Parent;
 int                  X,Y,Width,Height;
 int                  OldX,OldY,OldWidth,OldHeight;
 int                  MaxX,MaxY;
 int                  isFullScreen;
 int                  BorderWidth;
 int                  Property;
 unsigned char *      bImage;
 XImage        *      xImage;
 Pixmap               Mask;
 int                  Decorations;

 int                  State;
 int                  Visible;
 int                  Mapped;
 int                  Focused;
 int                  Rolled;

 wsTReDraw            ReDraw;
 wsTReSize            ReSize;
 wsTIdle              Idle;
 wsTKeyHandler        KeyHandler;
 wsTMouseHandler      MouseHandler;
 wsRemoteHandler      RemoteHandler;

 int                  Alt;
 int                  Shift;
 int                  Control;
 int                  NumLock;
 int                  CapsLock;
// --- Misc -------------------------------------------------------------------------------------

 Atom                 AtomDeleteWindow;
 Atom                 AtomTakeFocus;
 Atom                 AtomRolle;
 Atom                 AtomProtocols;
 Atom                 AtomsProtocols[3];
 Atom                 AtomLeaderClient;
 Atom                 AtomRemote;

 XShmSegmentInfo      Shminfo;
 unsigned char      * ImageData;
 unsigned short int * ImageDataw;
 unsigned int       * ImageDatadw;
 GC                   wGC;
 XGCValues            wGCV;
 unsigned long        WindowMask;
 XVisualInfo          VisualInfo;
 XWindowAttributes    Attribs;
 XSetWindowAttributes WindowAttrib;
 XSizeHints           SizeHint;
 XWMHints             WMHints;

 XFontStruct        * Font;
 int                  FontHeight;

 Cursor               wsCursor;
 char                 wsCursorData[1];
 Pixmap               wsCursorPixmap;
 int                  wsMouseEventType;
 XColor               wsColor;
} wsTWindow;

extern unsigned int         wsMaxX;
extern unsigned int         wsMaxY;

extern Display            * wsDisplay;
extern int                  wsScreen;
extern Window               wsRootWin;

extern unsigned char      * wsImageData;

extern XEvent               wsEvent;

extern int                  wsDepthOnScreen;
extern int                  wsRedMask;
extern int                  wsGreenMask;
extern int                  wsBlueMask;

extern int                  wsUseXShm;
extern int                  wsUseDGA;

// ----------------------------------------------------------------------------------------------
//  wsKeyTable
// ----------------------------------------------------------------------------------------------
extern unsigned long        wsKeyTable[512];

extern void wsXDone( void );
extern void wsXInit( void );

extern int wsGetDepthOnScreen( void );

extern void wsDoExit( void );
extern void wsMainLoop( void );

// ----------------------------------------------------------------------------------------------
//  wsCrateWindow: create a new window on the screen.
//   X,Y   : window position
//   wX,hY : window size
//   bW    : window frame size
//   cV    : mouse cursor visible
//   D     : "decoration", visible titlebar, etc ...
// ----------------------------------------------------------------------------------------------
extern void wsCreateWindow( wsTWindow * win,int X,int Y,int wX,int hY,int bW,int cV,unsigned char D,char * label );
extern void wsDestroyWindow( wsTWindow * win );
extern void wsMoveWindow( wsTWindow * win,int x, int y );
extern void wsResizeWindow( wsTWindow * win,int sx, int sy );
extern void wsIconify( wsTWindow win );
extern void wsMoveTopWindow( wsTWindow * win );
extern void wsSetBackground( wsTWindow * win,int color );
extern void wsSetBackgroundRGB( wsTWindow * win,int r,int g,int b );
#define wsClearWindow( win ); XClearWindow( wsDisplay,win.WindowID );
extern void wsSetTitle( wsTWindow * win,char * name );
extern void wsVisibleWindow( wsTWindow * win,int show );
extern void wsWindowDecoration( wsTWindow * win,long d );
extern void wsFullScreen( wsTWindow * win );
extern void wsPostRedisplay( wsTWindow * win );
extern void wsSetShape( wsTWindow * win,char * data );

// ----------------------------------------------------------------------------------------------
//    Draw string at x,y with fc ( foreground color ) and bc ( background color ).
// ----------------------------------------------------------------------------------------------
extern void wsDrawString( wsTWindow win,int x,int y,char * str,int fc,int bc );
extern int  wsTextWidth( wsTWindow win,char * str );

// ----------------------------------------------------------------------------------------------
//    Show / hide mouse cursor.
// ----------------------------------------------------------------------------------------------
extern void wsVisibleMouse( wsTWindow * win,int m );
extern void wsSetMousePosition( wsTWindow * win,int x, int y );

// ----------------------------------------------------------------------------------------------
// Image handling
// ----------------------------------------------------------------------------------------------
extern void wsCreateImage( wsTWindow * win );
extern void wsConvert( wsTWindow * win,unsigned char * Image,unsigned int Size );
extern void wsPutImage( wsTWindow * win );
extern void wsResizeImage( wsTWindow * win );
extern void wsDestroyImage( wsTWindow * win );
extern int  wsGetOutMask( void );

extern void wsScreenSaverOn( Display *mDisplay );
extern void wsScreenSaverOff( Display * mDisplay );

#endif
--- NEW FILE ---

#include <stdlib.h>
#include <stdio.h>

#include "../../config.h"
#ifdef xHAVE_MMX
 #include "../../main/libvo/mmx.h"
 #include "../../main/libvo/fastmemcpy.h"
#endif
#include "wsconv.h"

wsTConvFunc wsConvFunc = NULL;

// ---

#define COPY_RGB_24(src,dst) dst[0]=src[0];dst[1]=src[1];dst[2]=src[2]

#define SWAP_RGB_24(src,dst) dst[1]=src[0];dst[1]=src[1];dst[2]=src[0]

void BGR8880_to_RGB555_c( unsigned char * in_pixels, unsigned char * out_pixels, int num_pixels)
{
 unsigned short pixel;
 int i;
 for(i = 0; i < num_pixels; i++)
  {
   PACK_RGB15(in_pixels[0],in_pixels[1],in_pixels[2],pixel);
   *(unsigned short*)out_pixels = pixel;
   in_pixels += 4;
   out_pixels += 2;
  }
}

void BGR8880_to_BGR555_c( unsigned char * in_pixels, unsigned char * out_pixels, int num_pixels)
{
 unsigned short pixel;
 int i;
 for(i = 0; i < num_pixels; i++)
  {
   PACK_RGB15(in_pixels[2],in_pixels[1],in_pixels[0],pixel);
   *(unsigned short*)out_pixels = pixel;
   in_pixels += 4;
   out_pixels += 2;
  }
}

void BGR8880_to_RGB565_c( unsigned char * in_pixels, unsigned char * out_pixels, int num_pixels)
{
 unsigned short pixel;
 int i;
 for(i = 0; i < num_pixels; i++)
  {
   PACK_RGB16(in_pixels[0],in_pixels[1],in_pixels[2],pixel);
   *(unsigned short*)out_pixels = pixel;
   in_pixels += 4;
   out_pixels += 2;
  }
}

void BGR8880_to_BGR565_c( unsigned char * in_pixels, unsigned char * out_pixels, int num_pixels)
{
 unsigned short pixel;
 int i;
 for(i = 0; i < num_pixels; i++)
  {
   PACK_RGB16(in_pixels[2],in_pixels[1],in_pixels[0],pixel);
   *(unsigned short*)out_pixels = pixel;
   in_pixels += 4;
   out_pixels += 2;
  }
}

void BGR8880_to_RGB888_c( unsigned char * in_pixels, unsigned char * out_pixels,int num_pixels )
{
 int i;
 for(i = 0; i < num_pixels; i++)
  {
   COPY_RGB_24(in_pixels,out_pixels);
   in_pixels += 4;
   out_pixels += 3;
  }
}

void BGR8880_to_BGR888_c( unsigned char * in_pixels, unsigned char * out_pixels,int num_pixels )
{
 int i;
 for(i = 0; i < num_pixels; i++)
  {
   SWAP_RGB_24(in_pixels,out_pixels);
   in_pixels += 4;
   out_pixels += 3;
  }
}

void BGR8880_to_BGR8880_c( unsigned char * in_pixels, unsigned char * out_pixels,int num_pixels )
{
 int i;
 for(i = 0; i < num_pixels; i++)
  {
   SWAP_RGB_24(in_pixels,out_pixels);
   in_pixels += 4;
   out_pixels += 4;
  }
}

void BGR8880_to_RGB8880_c( unsigned char * in_pixels, unsigned char * out_pixels,int num_pixels )
{ memcpy( out_pixels,in_pixels,num_pixels * 4 ); }

/*

unsigned char * map_5_to_8[32];
unsigned char * map_6_to_8[64];

#define POINTER_TO_GUINT16(a) *((unsigned short*)a)
#define RGB16_TO_R(pixel) map_5_to_8[pixel & RGB16_LOWER_MASK]
#define RGB16_TO_G(pixel) map_6_to_8[(pixel & RGB16_MIDDLE_MASK)>>5]
#define RGB16_TO_B(pixel) map_5_to_8[(pixel & RGB16_UPPER_MASK)>>11]
#define RGB16_LOWER_MASK  0x001f
#define RGB16_MIDDLE_MASK 0x07e0
#define RGB16_UPPER_MASK  0xf800

void RGB565_to_RGB888_c( unsigned char * in_pixels, unsigned char * out_pixels,int num_pixels)
{
 unsigned short in_pixel;
 int i;
 for(i = 0; i < num_pixels; i++)
  {
   in_pixel = POINTER_TO_GUINT16(in_pixels);
   out_pixels[0] = RGB16_TO_R(in_pixel);
   out_pixels[1] = RGB16_TO_G(in_pixel);
   out_pixels[2] = RGB16_TO_B(in_pixel);
   in_pixels += 2;
   out_pixels += 3;
  }
}

*/

// ---

#ifdef xHAVE_MMX

#define LOAD_32(in) movq_m2r(*in, mm0); in += 8;\
                    movq_m2r(*in, mm1); in += 8

#define PACK_32_TO_24 movq_r2r(mm0, mm2);\
                      pand_m2r(rgb32_l_mask,mm0);\
                      pand_m2r(rgb32_u_mask,mm2);\
                      psrlq_i2r(8, mm2);\
                      por_r2r(mm2,mm0);\
                      movq_r2r(mm1, mm2);\
                      pand_m2r(rgb32_l_mask,mm1);\
                      pand_m2r(rgb32_u_mask,mm2);\
                      psrlq_i2r(8, mm2);\
                      por_r2r(mm2,mm1);

#define WRITE_24(out) movq_r2m(mm0, *out); out+=6;\
                      movq_r2m(mm1, *out); out+=6;

#define WRITE_16(out) movq_r2m(mm0, *out); out+=8;

static mmx_t rgb32_l_mask; // Mask for the lower of  2 RGB24 pixels
static mmx_t rgb32_u_mask; // Mask for the upper of  2 RGB24 pixels

static mmx_t rgb32_r_mask; // Mask for the reds of   2 RGB32 pixels
static mmx_t rgb32_g_mask; // Mask for the greens of 2 RGB32 pixels
static mmx_t rgb32_b_mask; // Mask for the blues  of 2 RGB32 pixels

static mmx_t lower_dword_mask; // Mask for the lower doublewords
static mmx_t upper_dword_mask; // Mask for the upper doublewords

void BGR8880_to_RGB888_mmx(unsigned char * in_pixels,unsigned char * out_pixels,int num_pixels)
{
 int imax = num_pixels/4;
 int i;

 for(i = 0; i < imax; i++)
  {
   LOAD_32(in_pixels);
   PACK_32_TO_24;
   WRITE_24(out_pixels);
  }
 emms();
}

#endif

// ---

void initConverter( void )
{
#ifdef xHAVE_MMX
// int i;

// for(i = 0; i < 64; i++) map_6_to_8[i] = (unsigned char)((float)i/63.0*255.0+0.5);
// for(i = 0; i < 32; i++) map_5_to_8[i] = (unsigned char)((float)i/31.0*255.0+0.5);

 rgb32_l_mask.q = 0x0000000000FFFFFFLL; // Mask for the lower of 2 RGB32 pixels
 rgb32_u_mask.q = 0x00FFFFFF00000000LL; // Mask for the upper of 2 RGB32 pixels

 rgb32_r_mask.q = 0x000000FF000000FFLL; // Mask for the reds of   2 RGB32 pixels
 rgb32_g_mask.q = 0x0000FF000000FF00LL; // Mask for the greens of 2 RGB32 pixels
 rgb32_b_mask.q = 0x00FF000000FF0000LL; // Mask for the blues  of 2 RGB32 pixels
#endif
}
--- NEW FILE ---

#ifndef __WSCONV_H
#define __WSCONV_H

#include "../../config.h"

#define PACK_RGB16(r,g,b,pixel) pixel=(b>>3);\
                                pixel<<=6;\
                                pixel|=(g>>2);\
                                pixel<<=5;\
                                pixel|=(r>>3)

#define PACK_RGB15(r,g,b,pixel) pixel=(b>>3);\
                                pixel<<=5;\
                                pixel|=(g>>3);\
                                pixel<<=5;\
                                pixel|=(r>>3)

typedef void(*wsTConvFunc)( unsigned char * in_pixels, unsigned char * out_pixels, int num_pixels );
extern wsTConvFunc wsConvFunc;

extern void BGR8880_to_RGB555_c( unsigned char * in_pixels, unsigned char * out_pixels, int num_pixels );
extern void BGR8880_to_BGR555_c( unsigned char * in_pixels, unsigned char * out_pixels, int num_pixels );
extern void BGR8880_to_RGB565_c( unsigned char * in_pixels, unsigned char * out_pixels, int num_pixels );
extern void BGR8880_to_BGR565_c( unsigned char * in_pixels, unsigned char * out_pixels, int num_pixels );
extern void BGR8880_to_RGB888_c( unsigned char * in_pixels, unsigned char * out_pixels,int num_pixels );
extern void BGR8880_to_BGR888_c( unsigned char * in_pixels, unsigned char * out_pixels,int num_pixels );
extern void BGR8880_to_BGR8880_c( unsigned char * in_pixels, unsigned char * out_pixels,int num_pixels );
extern void BGR8880_to_RGB8880_c( unsigned char * in_pixels, unsigned char * out_pixels,int num_pixels );

#ifdef xHAVE_MMX
 extern void BGR8880_to_RGB888_mmx(unsigned char * in_pixels,unsigned char * out_pixels,int num_pixels);
#endif

extern void RGB565_to_RGB888_c( unsigned char * in_pixels, unsigned char * out_pixels,int num_pixels);

extern void initConverter( void );

#endif
--- NEW FILE ---

#ifndef _MY_WSKEY
#define _MY_WSKEY

#define wsKeyNone -1

#define wsosbrackets '['
#define wscsbrackets ']'
#define wsomore      '<'
#define wscmore      '>'

#define wsq 'q'
#define wsa 'a'
#define wsz 'z'
#define wsw 'w'
#define wss 's'
#define wsx 'x'
#define wse 'e'
#define wsd 'd'
#define wsr 'r'
#define wsf 'f'
#define wsv 'v'
#define wst 't'
#define wsg 'g'
#define wsb 'b'
#define wsy 'y'
#define wsh 'h'
#define wsn 'n'
#define wsu 'u'
#define wsj 'j'
#define wsm 'm'
#define wsi 'i'
#define wsk 'k'
#define wso 'o'
#define wsl 'l'
#define wsp 'p'
#define wsc 'c'

#define wsQ 'Q'
#define wsA 'A'
#define wsZ 'Z'
#define wsW 'W'
#define wsS 'S'
#define wsX 'X'
#define wsE 'E'
#define wsD 'D'
#define wsR 'R'
#define wsF 'F'
#define wsV 'V'
#define wsT 'T'
#define wsG 'G'
#define wsB 'B'
#define wsY 'Y'
#define wsH 'H'
#define wsN 'N'
#define wsU 'U'
#define wsJ 'J'
#define wsM 'M'
#define wsI 'I'
#define wsK 'K'
#define wsO 'O'
#define wsL 'L'
#define wsP 'P'
#define wsC 'C'

#define ws0 '0'
#define ws1 '1'
#define ws2 '2'
#define ws3 '3'
#define ws4 '4'
#define ws5 '5'
#define ws6 '6'
#define ws7 '7'
#define ws8 '8'
#define ws9 '9'

#define wsSpace ' '

#define wsUp            0x52 + 256
#define wsDown          0x54 + 256
#define wsLeft          0x51 + 256
#define wsRight         0x53 + 256
#define wsLeftCtrl      0xe3 + 256
#define wsRightCtrl     0xe4 + 256
#define wsLeftAlt       0xe9 + 256
#define wsRightAlt      0x7e + 256
#define wsLeftShift     0xe1 + 256
#define wsRightShift    0xe2 + 256
#define wsEnter         0x0d + 256
#define wsBackSpace     0x08 + 256
#define wsCapsLock      0xe5 + 256
#define wsTab           0x09 + 256
#define wsF1            0xbe + 256
#define wsF2            0xbf + 256
#define wsF3            0xc0 + 256
#define wsF4            0xc1 + 256
#define wsF5            0xc2 + 256
#define wsF6            0xc3 + 256
#define wsF7            0xc4 + 256
#define wsF8            0xc5 + 256
#define wsF9            0xc6 + 256
#define wsF10           0xc7 + 256
#define wsInsert        0x63 + 256
#define wsDelete        0xff + 256
#define wsHome          0x50 + 256
#define wsEnd           0x57 + 256
#define wsPageUp        0x55 + 256
#define wsPageDown      0x56 + 256
#define wsNumLock       0x7f + 256
#define wsEscape        0x1b + 256
#define wsGrayEnter     0x8d + 256
#define wsGrayPlus      0xab + 256
#define wsGrayMinus     0xad + 256
#define wsGrayMul       0xaa + 256
#define wsGrayDiv       0xaf + 256

#define wsGrayInsert    0xb0 + 256
#define wsGrayDelete    0xae + 256
#define wsGrayEnd       0xb1 + 256
#define wsGrayDown      0xb2 + 256
#define wsGrayPageDown  0xb3 + 256
#define wsGrayLeft      0xb4 + 256
#define wsGray5         0xb5 + 256
#define wsGrayRight     0xb6 + 256
#define wsGrayHome      0xb7 + 256
#define wsGrayUp        0xb8 + 256
#define wsGrayPageUp    0xb9 + 256

#define wsKeyNumber 116

typedef struct
{
 int    code;
 char * name;
} TwsKeyNames;

extern TwsKeyNames wsKeyNames[ wsKeyNumber ];

#endif


--- NEW FILE ---

#include "wskeys.h"

TwsKeyNames wsKeyNames[ wsKeyNumber ] =
 {
  { wsq, "q" }, { wsa, "a" }, { wsz, "z" }, { wsw, "w" }, { wss, "s" }, { wsx, "x" },
  { wse, "e" }, { wsd, "d" }, { wsr, "r" }, { wsf, "f" }, { wsv, "v" }, { wst, "t" },
  { wsg, "g" }, { wsb, "b" }, { wsy, "y" }, { wsh, "h" }, { wsn, "n" }, { wsu, "u" },
  { wsj, "j" }, { wsm, "m" }, { wsi, "i" }, { wsk, "k" }, { wso, "o" }, { wsl, "l" },
  { wsp, "p" }, { wsc, "c" },

  { wsQ, "Q" }, { wsA, "A" }, { wsZ, "Z" }, { wsW, "W" }, { wsS, "S" }, { wsX, "X" },
  { wsE, "E" }, { wsD, "D" }, { wsR, "R" }, { wsF, "F" }, { wsV, "V" }, { wsT, "T" },
  { wsG, "G" }, { wsB, "B" }, { wsY, "Y" }, { wsH, "H" }, { wsN, "N" }, { wsU, "U" },
  { wsJ, "J" }, { wsM, "M" }, { wsI, "I" }, { wsK, "K" }, { wsO, "O" }, { wsL, "L" },
  { wsP, "P" }, { wsC, "C" },

  { wsUp,         "Up"    }, { wsDown,       "Down"  }, { wsLeft,        "Left"  },
  { wsRight,      "Right" }, { wsPageUp,    "PageUp" }, { wsPageDown, "PageDown" },

  { wsLeftCtrl,   "LeftCtrl" }, { wsRightCtrl,  "RightCtrl" }, { wsLeftAlt,    "LeftAlt"    },
  { wsRightAlt,   "RightAlt" }, { wsLeftShift,  "LeftShift" }, { wsRightShift, "RightShift" },


  { wsBackSpace,  "BackSpace" },
  { wsCapsLock,   "CapsLock" },
  { wsNumLock,    "NumLock" },

  { wsF1, "F1" }, { wsF2, "F2" }, { wsF3, "F3" }, { wsF4, "F4" }, { wsF5,   "F5" },
  { wsF6, "F6" }, { wsF7, "F7" }, { wsF8, "F8" }, { wsF9, "F9" }, { wsF10, "F10" },

  { wsEnter,         "Enter" }, { wsTab,             "Tab" }, { wsSpace,         "Space" },
  { wsInsert,       "Insert" }, { wsDelete,       "Delete" }, { wsHome,           "Home" },
  { wsEnd,             "End" }, { wsEscape,       "Escape" },

  { wsosbrackets, "[" }, { wscsbrackets, "]" },
  { wsomore,      "<" }, { wscmore,      ">" },

  { ws0, "0" }, { ws1, "1" }, { ws2, "2" }, { ws3, "3" }, { ws4, "4" },
  { ws5, "5" }, { ws6, "6" }, { ws7, "7" }, { ws8, "8" }, { ws9, "9" },

  { wsGrayEnter,       "GrayEnter" }, { wsGrayPlus,         "GrayPlus" },
  { wsGrayMinus,       "GrayMinus" }, { wsGrayMul,           "GrayMul" },
  { wsGrayDiv,           "GrayDiv" }, { wsGrayInsert,     "GrayInsert" },
  { wsGrayDelete,     "GrayDelete" }, { wsGrayEnd,           "GrayEnd" },
  { wsGrayDown,         "GrayDown" }, { wsGrayPageDown, "GrayPageDown" },
  { wsGrayLeft,         "GrayLeft" }, { wsGray5,               "Gray5" },
  { wsGrayRight,       "GrayRight" }, { wsGrayHome,         "GrayHome" },
  { wsGrayUp,             "GrayUp" }, { wsGrayPageUp,     "GrayPageUp" },

  { wsKeyNone, "None" }
 };




More information about the MPlayer-cvslog mailing list