Logo Search packages:      
Sourcecode: pacman version File versions  Download package

usrinter.cc

#include"usrinter.h"
#include<stdio.h>
#include"gpacman.h"
#include"colour.h"
#include<stdlib.h>
#include"arg.h"
#include"pac.h"
#include<string.h>
#include"board.h"

static GC back;

inp_type UserInterface::in=Keyboard;      //initializers
int UserInterface::x=0;
int UserInterface::y=0;
int UserInterface::last_x=0;
int UserInterface::last_y=0;

UserInterface* UserInterface::_instance=0;

//returns the pointer to the instance
UserInterface* UserInterface::instance(inp_type inp) {
 if (_instance==0) 
  _instance=new UserInterface;
 in=inp;
 return _instance;
}

inline void UserInterface::setinp(inp_type i) { in=i; }

#ifdef XWIN                   //for X-Win only
Display* UserInterface::mydisplay=0;      //more initializers
Window UserInterface::mywindow=0;
GC UserInterface::mygc=0;
XEvent UserInterface::myevent={0};
KeySym UserInterface::mykey=0;
XSizeHints UserInterface::myhint={0};
XWMHints UserInterface::mywmhint={0};
int UserInterface::myscreen=0;
unsigned long UserInterface::myforeground=0;
unsigned long UserInterface::mybackground=0;
Font UserInterface::font=0;

#elif defined MSWIN                 //for MS-Win only
int UserInterface::quit=0;          //even more initializers
HANDLE UserInterface::my_hInst=0;
HWND UserInterface::my_hwnd=0;    
HFONT UserInterface::hfont=0; 
HFONT UserInterface::hfontOld=0;
int UserInterface::MapModePrevious=0;
HANDLE UserInterface::my_hInstance=0;
HANDLE UserInterface::my_hPrevInstance=0;
LPSTR UserInterface::my_lpCmdLine=0;
int UserInterface::my_nCmdShow=0;
HDC UserInterface::hdcMemory=0;
HBRUSH UserInterface::back=0;
static UserInterface *ui=0;
#endif 
   
#ifdef XWIN                   //for X-Win only
UserInterface::UserInterface() {    //constructor
setinp(in);                   //sets the input type
mydisplay = XOpenDisplay("");       //connects to a display
if (!mydisplay) pacexit("no display possible"); //if it was not possible, exit
myscreen = DefaultScreen(mydisplay);      //get the default screen
Colour(this);                       //initialize the colours
mybackground=Colour::MYBACKGROUND;  //set background colour
myforeground=Colour::MYFOREGROUND;  //set foreground colour
myhint.x=WINSTARTX; myhint.y=WINSTARTY;   //set window's initial coordinates
myhint.width=WINWIDTH;              //set window's width and height
myhint.height=WINHEIGHT;
//myhint.width_inc=100;
//myhint.height_inc=100;
//myhint.base_height=WINWIDTH;
//myhint.base_width=WINHEIGHT;
myhint.min_width=WINWIDTH;                //set window's width and height
myhint.min_height=WINHEIGHT;
myhint.max_width=WINWIDTH;                //set window's width and height
myhint.max_height=WINHEIGHT;
myhint.flags=PPosition|PSize|PMinSize|PMaxSize;//|PResizeInc|PBaseSize;       //what myhint members were set
mywmhint.flags=InputHint;//|StateHint;          //say we want to have input
mywmhint.input=True;                //that we set inputflag
mywmhint.initial_state=NormalState;
mywindow=XCreateSimpleWindow(mydisplay, DefaultRootWindow(mydisplay),
           myhint.x,myhint.y,myhint.width,myhint.height,5,
           myforeground,mybackground);
                              //created the window
XSetStandardProperties(mydisplay,mywindow,PACTITLE,PACTITLE,None,Argument::args,Argument::argc,&myhint);
                              //some properties were set
XSetWMHints(mydisplay,mywindow,&mywmhint);      //give window manager hints
mygc=XCreateGC(mydisplay,mywindow,0,0);         //create a graphic context
XSetBackground(mydisplay,mygc,mybackground);    //set window background
XSetForeground(mydisplay,mygc,myforeground);    //set window foreground
font=XLoadFont(mydisplay,FONT1);    //load the font
if (!font) font=XLoadFont(mydisplay,FONT2);
XSetFont(mydisplay,mygc,font);            //set the font
XSelectInput(mydisplay,mywindow,ExposureMask);//|VisibilityChangeMask);//,ButtonPressMask|KeyPressMask|ExposureMask|VisibilityChangeMask);
                              //select what we want as input
XSetGraphicsExposures(mydisplay,mygc,False);
XMapRaised(mydisplay,mywindow);           //raise the window, that is, show it
do XNextEvent(mydisplay,&myevent);  //wait until window is exposed
while (myevent.type!=Expose);

Window root,child;int dumx,dumy;unsigned int keys_buttons;  //dummies
XQueryPointer(mydisplay,mywindow,&root,&child,&dumx,&dumy,&x,&y,&keys_buttons);
                              //get the initial mouse coordinates
XSelectInput(mydisplay,mywindow,ExposureMask|VisibilityChangeMask);//,ButtonPressMask|KeyPressMask|ExposureMask|VisibilityChangeMask);
                              //select what we want as input
}

UserInterface::~UserInterface(void) {     //destructor
XUnloadFont(mydisplay,font);        //unload the font
XFreeGC(mydisplay, mygc);           //destroy gc
XDestroyWindow(mydisplay, mywindow);      //destroy window
XCloseDisplay(mydisplay);           //close the display connection
}

void UserInterface::waitsync(void) {
XSync(mydisplay,0);     //returns when output complete: synchronized
}

int UserInterface::getinput(void) { //get input whether quit or not,
                              //it may also change input type
if (QLength(mydisplay)>0) {
XNextEvent(mydisplay, &myevent);    //get next event from the queue
//printf("%d \n",myevent.type);
switch (myevent.type) {             //what kind of event was it?
 case Expose: {
//  Window root,child;int dumx,dumy;unsigned int keys_buttons;    //dummies
//  if (myevent.xexpose.count==0)   //if this is first expose
//   XQueryPointer(mydisplay,mywindow,&root,&child,&dumx,&dumy,&x,&y,&keys_buttons);
//                            //get the initial mouse coordinates
// XRaiseWindow(mydisplay,mywindow);      //let window stay on top
#ifdef XPOSSE
 writetext();
 Board::instance()->draw();
// printf("XPOSSE\n");
 waitsync(); 
#endif
 }
 break;
#ifdef RAISE
 case VisibilityNotify:
  if (myevent.xvisibility.state!=VisibilityUnobscured) 
   XRaiseWindow(mydisplay,mywindow);      //let window stay on top
 break;
#endif
 case MappingNotify:                //something about the keyboard mapping
  XRefreshKeyboardMapping(&myevent.xmapping);
 break;
 case MapNotify:
//   XRaiseWindow(mydisplay,mywindow);    //let window stay on top
 break;
 }

}

if (in==Mouse) {              //if input is from mouse
 Window root,child;int dumx,dumy,xx,yy; //dummies
 unsigned int keys_buttons;         //what keys/buttons hit/pressed
 XQueryPointer(mydisplay,mywindow,&root,&child,&dumx,&dumy,&xx,&yy,&keys_buttons);
 if (keys_buttons & Button1Mask)    //if left mouse button down 
  in=Keyboard;                      //input type is keyboard
 if ((keys_buttons & Button2Mask) || (keys_buttons & Button3Mask)) 
  return 1;                   //if middle or right is down quit
} else {                      //else if input is from keyboard
 char key_vector[32];               //denotes 256 possible keys
 XQueryKeymap(mydisplay,key_vector);      //queries and gets data for all keys
//int kkk; for (kkk=0;kkk<32;kkk++)
//printf("%x ",key_vector[kkk]);
//printf("\n");
 if (check(key_vector,XK_m))        //if m is pressed input type is mouse
  { in=Mouse; return 0; }
 if (check(key_vector,XK_M))        //if m is pressed input is keyboard
  { in=Mouse; return 0; }
 if (check(key_vector,XK_Q)) return 1;    //if q is pressed quit
 if (check(key_vector,XK_q)) return 1;    //if q is pressed quit
}
//}
return 0;
}

//checks whether certain key is pressed
int UserInterface::check(char key_vector[32], KeySym key) {
unsigned int byteindex, bitindex;   //byte and bit number 
KeyCode code;                       //keykode
code=XKeysymToKeycode(mydisplay,key);     //get the code of the wanted key
if (code==NoSymbol) pacexit("NoSymbol\n");      //if no such, exit
byteindex=(code/8);                       //what's it's index number
bitindex=code & 7;                        //what's it's bit number
return (1 & (key_vector[byteindex]>>bitindex)); //has it been hit?
}

direction UserInterface::stick(void) {
if (in==Mouse) {                                //mouse input
Window root,child;int dumx,dumy; unsigned int keys_buttons; //dummies
 last_x=x; last_y=y;                            //present is past
XQueryPointer(mydisplay,mywindow,&root,&child,&dumx,&dumy,&x,&y,&keys_buttons);
                                    //get new coordinates
if (x==last_x && y==last_y) return none;  //if not moved then none
int dx=x-last_x;int dy=y-last_y;          //get changes of coordinates
if (dx>=dy && dx>-dy) return right;       //destine directions
if (dx>=dy && dx<=-dy) return up;
if (dx<dy && dx>-dy) return down;
if (dx<dy && dx<=-dy) return left;
pacwarning("errorstick\n");   //give warning if not all directons covered
} else {                //if input comes from keyboard
char key_vector[32];          //denotes 256 possible keys
XQueryKeymap(mydisplay,key_vector); //queries and gets data for all keys
if (check(key_vector,XK_Up)) return up;         //if up key pressed, up
if (check(key_vector,XK_Down)) return down;     //etc
if (check(key_vector,XK_Left)) return left;
if (check(key_vector,XK_Right)) return right;
return none;                              //if none of these, then none
}
}

//write string at x,y
void UserInterface::write(int x,int y,char* str) {
 XDrawImageString(mydisplay,mywindow, mygc,TEXTWIDTH*x,TEXTHEIGHT*y,str, strlen(str));
}

//write number long int at x,y format z
void UserInterface::write(int x,int y,long int v,int l) {
 char*  str;
 str = (char*) malloc (l+1);
 sprintf (str, "%.*d", l,v);
 XDrawImageString(mydisplay,mywindow, mygc,TEXTWIDTH*x,TEXTHEIGHT*y,str, strlen(str));
}

#elif defined MSWIN                             //for MS-Win only
void UserInterface::sethInstance(HANDLE h) {my_hInstance=h; }     //setters
void UserInterface::sethPrevInstance(HANDLE h) {my_hPrevInstance=h; }
void UserInterface::setlpCmdLine(LPSTR l) {my_lpCmdLine=l; }
void UserInterface::setnCmdShow(int i) {my_nCmdShow=i; }
HANDLE UserInterface::gethInstance(void) {return my_hInstance; }//getters
HANDLE UserInterface::gethPrevInstance(void) {return my_hPrevInstance; }
LPSTR UserInterface::getlpCmdLine(void) {return my_lpCmdLine; }
int UserInterface::getnCmdShow(void) {return my_nCmdShow; }
HWND UserInterface::gethwnd(void) {return my_hwnd;}
HDC UserInterface::gethdcmem(void) {return hdcMemory; }

UserInterface::UserInterface() {    //constructor
HDC my_hdc,                   //handle to device context
    my_hdcMemory;             //handle to memory device context
setinp(in);                   //sets input type
Colour(this);                 //initializing colours
ui=this;                      //set userinterface ui variable
 if (!my_hPrevInstance)             //if no previous application instance
  if (!InitApplication(my_hInstance))     //then try to initialize application
   pacexit("FALSE");                //if error do an exit
 if (!InitInstance(my_hInstance, my_nCmdShow))  //try to initialize an instance
  pacexit("FALSE");                 //if error do an exit
EnableWindow(my_hwnd,TRUE);         //enables mouse/keyboard input
my_hdc=GetDC(my_hwnd);              //get the device context
if (!my_hdc) {                      //if none such then exit
 exit(1);
}           
hdcMemory = CreateCompatibleDC(my_hdc);   //create a compatible device context
int iPtSize = TEXTHEIGHT;           //specify height of text
PSTR pszFace = 0;//*"MS Serif"; */; //default face/font
MapModePrevious = SetMapMode(my_hdc, MM_TEXT);  //setting of mapping mode
hfont = CreateFont(-iPtSize, TEXTWIDTH, 0, 0, 0, /* specify pt size    */
    0, 0, 0, 0, 0, 0, 0, FF_MODERN | FIXED_PITCH, pszFace); //creates a font
hfontOld = SelectObject(my_hdc, hfont);   //selects a font and returns old
SetBkMode(my_hdc,OPAQUE);           //set background mode
SetBkColor(my_hdc,Colour::MYBACKGROUND);  //set background colour
SetTextColor(my_hdc,Colour::MYFOREGROUND);      //sets text colour
MoveTo(my_hdc,0,0);                 //move to coordinates 0,0
ReleaseDC(my_hwnd,my_hdc);          //release the device context
}

UserInterface::~UserInterface(void) {
HDC my_hdc,my_hdcMemory;            //for ordinary and memory dc
my_hdc=GetDC(my_hwnd);              //get the device context
SetMapMode(my_hdc, MapModePrevious);      //set mapping mode to the previous
SelectObject(my_hdc, hfontOld);           //select back the old font
DeleteObject(hfont);                //delete the games font
ReleaseDC(my_hwnd,my_hdc);          //release the device context
DeleteObject(back);                 //delete the background colour brush
}

void UserInterface::waitsync(void) {      //returns when output synchronized
}                             //not necessary here, automatic

direction UserInterface::stick(void) {    //returns the inputted direction
if (in==Mouse) {              //if input is from mouse
last_x=x; last_y=y;                 //present is past
POINT p;                      //a point
GetCursorPos(&p);             //get position of mouse cursor
x=p.x; y=p.y;                       //set current coordinates to these
if (x==last_x && y==last_y) return none;//if not moved then none
int dx=x-last_x; int dy=y-last_y;   //get changes of coordinates
if (dx>=dy && dx>-dy) return right; //destine directions
if (dx>=dy && dx<=-dy) return up;
if (dx<dy && dx>-dy) return down;
if (dx<dy && dx<=-dy) return left;
pacwarning("errorstick\n");   //give warning if not all directons covered
} else {                //if input comes from keyboard
if (GetAsyncKeyState(VK_UP)<0) return up; //if up key pressed, up
if (GetAsyncKeyState(VK_DOWN)<0) return down;   //etc
if (GetAsyncKeyState(VK_LEFT)<0) return left;
if (GetAsyncKeyState(VK_RIGHT)<0) return right;
return none;                              //if none of these, then none
}                   
return none;                              //if none of these, then none
}

//write string at x,y
void UserInterface::write(int x,int y,char* str) {
HDC my_hdc,my_hdcMemory;            //for ordinary and memory dc
my_hdc=GetDC(my_hwnd);              //get device context
 TextOut(my_hdc,TEXTWIDTH*x,TEXTHEIGHT*y,str, strlen(str)); //outputting
ReleaseDC(my_hwnd,my_hdc);          //release device context
}

//write number long int at x,y format z
void UserInterface::write(int x,int y,long int v,int l) {
 HDC my_hdc,my_hdcMemory;           //for ordinary and memory dc
 char*  str;                        //string
 my_hdc=GetDC(my_hwnd);             //get device context
 str = (char*) malloc (l+1);        //allocate memory for string
 sprintf (str, "%.*d", l,v);              //formatted print to string
 TextOut(my_hdc,TEXTHEIGHT*x,TEXTHEIGHT*y,str, strlen(str));      //outputting
 free(str);                                     //free memory
 ReleaseDC(my_hwnd,my_hdc);         //release device context
}
     
int UserInterface::getinput(void) { //get input whether quit or not,
                              //it may also change input type
 MSG msg;    
 if (!PeekMessage(&msg, NULL, NULL, NULL,PM_NOREMOVE))
  return 0;             //just return if there wasn't a message
 quit=!GetMessage(&msg, NULL, NULL, NULL);      //quit if GetMessage says so
 if (quit) return 1;                      //do the quit
 TranslateMessage(&msg);                  //else tranlate and
 DispatchMessage(&msg);                   //dispatch the message
                                    //control now goes to
                                    //a WNDPROC MainWndProc
 return quit;                       //return whether quit
}

void UserInterface::do_inp(char wParam) { //processes input from keyboard
 if (in==Keyboard) {
  if (wParam=='M')  in=Mouse;             //if m pressed input type is now mouse
  if (wParam=='Q')  quit=1;         //if q is pressed then set quit
 }       
}

void UserInterface::do_inp(char *s) {           //processes input from mouse
 if (in==Mouse) {
  if (!strcmp(s,"LEFT")) 
   ui->setinp(Keyboard);            //if left button input type is keyboard
  if (!strcmp(s,"RIGHT")) quit=1;   //if right butten, set quit   
 }
}

void UserInterface::start(int xx,int yy) {
 x=xx;   y=yy;                //setting current mouse coordinates and telling
 SetFocus(my_hwnd);           //MS-Win to take input from our window
}

void UserInterface::setquit(void) { quit=1; }   //set quit
             
static long FAR PASCAL MainWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
 switch (message)    {        //what type of message it is
  case WM_CREATE: {           // message: create window
   POINT p;             //a point
   GetCursorPos(&p);          //get position of mouse cursor
   ui->start(p.x,p.y);        //initialize userinterface with that point
  } break;
  case WM_LBUTTONDOWN:  {     // message: left mouse button pressed 
   ui->do_inp("LEFT");        //process code for left mouse button
  }  break;
  case WM_RBUTTONDOWN: {      // message: right mouse button pressed
   ui->do_inp("RIGHT");       //process code for left mouse button
  } break;
  case WM_KEYDOWN : {         // message: keys pressed
   ui->do_inp(wParam);        //process code for keyboard keys
  } break;
  case WM_DESTROY: {          // message: destroy from window manager
   ui->setquit();       //set quit
   PostQuitMessage(0); }      //post a message that says we quit
  break;
  default:
   return (DefWindowProc(hWnd, message, wParam, lParam));
                        //message must be processed
 }
 return (NULL);               //or whatever, just a return value
}

/****************************************************************************

    FUNCTION: InitApplication(HANDLE)

    PURPOSE: Initializes window data and registers window class

****************************************************************************/

BOOL UserInterface::InitApplication(HANDLE hInstance)
{
    WNDCLASS  wc;                   //a window class (not oo)
    back=CreateSolidBrush(Colour::MYBACKGROUND);//background brush
    wc.style = CS_BYTEALIGNWINDOW | CS_CLASSDC | CS_VREDRAW | CS_HREDRAW;
    wc.lpfnWndProc = MainWndProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = hInstance;
    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = back;/*COLOR_BACKGROUND+1;*/
    wc.lpszMenuName =  "PacmanMenu";            //name
    wc.lpszClassName = "PacmanWClass";          //name
    return (RegisterClass(&wc));          //try to register and
                                    //return success boolean
}


/****************************************************************************

    FUNCTION:  InitInstance(HANDLE, int)

    PURPOSE:  Saves instance handle and creates main window

****************************************************************************/

BOOL UserInterface::InitInstance(HANDLE hInstance, int nCmdShow)
{
    HWND            hwnd;                 //handle to window

    my_hInst = hInstance;                 //sets handle to instance

    hwnd = CreateWindow("PacmanWClass",
                  PACTITLE,
                  WS_OVERLAPPEDWINDOW,
                  WINSTARTX,
                  WINSTARTY,
                  WINWIDTH,
                  WINHEIGHT,
                  NULL,
                  NULL,
                  hInstance,
                  NULL
                   );               //creates the window
    if (!hwnd)                            //if no handle return error
      return (FALSE);
    ShowWindow(hwnd, nCmdShow);                 //show and
    UpdateWindow(hwnd);                   //update window
    my_hwnd=hwnd;                   //set the handle
    return (TRUE);                        //return ok
}

#elif defined VTX             //vt??? unix only

UserInterface::UserInterface() {    //constructor
setinp(in=Keyboard);                //set input type
stdscr=initscr();             //initialize screen
raw();                              //an input mode
cbreak();                     //set to break mode
noecho();                     //don't cho to screen
nonl();                             //no newline
intrflush(stdscr,FALSE);            //flushing mode
keypad(stdscr,TRUE);                //keypadding
nodelay(stdscr,TRUE);               //no input delay
clear();                      //clear screen
Colour(this);                       //initialize colours
}

UserInterface::~UserInterface(void) {     //destructor
clear();                      //clear screen
refresh();                    //refresh it
endwin();                     //end it
}

void UserInterface::waitsync(void) {      //returns when output completed
move(0,0);                    //move to 0,0
refresh();                    //refresh screen
}

int UserInterface::getinput(void) { //get input whether quit or not,
                              //it may also change input type
int c;
(c=(getch())); 
 if (c=='Q' || c=='q') return 1;    //if q pressed then do quit
return 0;
}

direction UserInterface::stick(void) {    //get inputted direction
int key=0,i;
key=getch();                        //get input character
if (key==/*ACS_UARROW*/KEY_UP) return up; //if up key pressed, up
if (key==/*ACS_DARROW*/KEY_DOWN) return down;   //etc
if (key==/*ACS_LARROW*/KEY_LEFT) return left;
if (key==/*ACS_RARROW*/KEY_RIGHT) return right;
return none;                              //if none of these, then none
}

//write string at x,y
void UserInterface::write(int x,int y,char* str) {
 mvaddstr(TEXTHEIGHT*y,TEXTWIDTH*x,str);//outputting
}

//write number long int at x,y format z
void UserInterface::write(int x,int y,long int v,int l) {
 char*  str;                        //string
 str = (char*) malloc (l+1);        //allocate memory for string
 sprintf (str, "%.*d", l,v);        //formatted print to string
 mvaddstr(TEXTHEIGHT*y,TEXTWIDTH*x,str);//outputting
}

#endif
       

Generated by  Doxygen 1.6.0   Back to index