[BACK]Return to mouseif.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / io

Diff for /np2/io/mouseif.c between versions 1.4 and 1.18

version 1.4, 2003/10/23 18:33:13 version 1.18, 2011/01/15 18:04:43
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        "mousemng.h"  #include        "mousemng.h"
 #include        "i286.h"  #include        "cpucore.h"
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
   #include        "keystat.h"
   
   
 // マウス ver0.28  // マウス ver0.28
Line 19  void mouseif_sync(void) { Line 20  void mouseif_sync(void) {
         // 今回の移動量を取得          // 今回の移動量を取得
         mouseif.b = mousemng_getstat(&mouseif.sx, &mouseif.sy, 1);          mouseif.b = mousemng_getstat(&mouseif.sx, &mouseif.sy, 1);
         if (np2cfg.KEY_MODE == 3) {          if (np2cfg.KEY_MODE == 3) {
                 mouseif.b &= keyext_getmouse(&mouseif.sx, &mouseif.sy);                  mouseif.b &= keystat_getmouse(&mouseif.sx, &mouseif.sy);
         }          }
         mouseif.rx = mouseif.sx;          mouseif.rx = mouseif.sx;
         mouseif.ry = mouseif.sy;          mouseif.ry = mouseif.sy;
   
         mouseif.lastc = I286_CLOCK + I286_BASECLOCK + I286_REMCLOCK;          mouseif.lastc = CPU_CLOCK + CPU_BASECLOCK + CPU_REMCLOCK;
 }  }
   
 static void calc_mousexy(void) {  static void calc_mousexy(void) {
   
         UINT32  clock;          UINT32  clk;
         SINT32  diff;          SINT32  diff;
   
         clock = I286_CLOCK + I286_BASECLOCK + I286_REMCLOCK;          clk = CPU_CLOCK + CPU_BASECLOCK + CPU_REMCLOCK;
         diff = clock - mouseif.lastc;          diff = clk - mouseif.lastc;
         if (diff >= 2000) {          if (diff >= 2000) {
                 SINT16 dx;                  SINT32 dx;
                 SINT16 dy;                  SINT32 dy;
                 mouseif.rapid ^= 0xa0;                  mouseif.rapid ^= 0xa0;
                 diff /= 1000;                  diff /= 1000;
                 dx = (SINT16)(mouseif.sx * diff / pc.frame1000);                  dx = mouseif.sx;
                 if (dx >= 0) {                                                                                  // 正                  if (dx > 0) {
                           dx = dx * diff / mouseif.moveclock;
                         if (dx > mouseif.rx) {                          if (dx > mouseif.rx) {
                                 dx = mouseif.rx;                                  dx = mouseif.rx;
                         }                          }
                 }                  }
                 else {                                                                                                  // 負                  else if (dx < 0) {
                           dx *= -1;
                           dx = dx * diff / mouseif.moveclock;
                           dx *= -1;
                         if (dx < mouseif.rx) {                          if (dx < mouseif.rx) {
                                 dx = mouseif.rx;                                  dx = mouseif.rx;
                         }                          }
                 }                  }
                 mouseif.x += dx;                  mouseif.x += dx;
                 mouseif.rx -= dx;                  mouseif.rx -= dx;
                 dy = (SINT16)(mouseif.sy * diff / pc.frame1000);  
                 if (dy >= 0) {                                                                                  // 正                  dy = mouseif.sy;
                   if (dy > 0) {
                           dy = dy * diff / mouseif.moveclock;
                         if (dy > mouseif.ry) {                          if (dy > mouseif.ry) {
                                 dy = mouseif.ry;                                  dy = mouseif.ry;
                         }                          }
                 }                  }
                 else {                                                                                                  // 負                  else if (dy < 0) {
                           dy *= -1;
                           dy = dy * diff / mouseif.moveclock;
                           dy *= -1;
                         if (dy < mouseif.ry) {                          if (dy < mouseif.ry) {
                                 dy = mouseif.ry;                                  dy = mouseif.ry;
                         }                          }
Line 72  static void calc_mousexy(void) { Line 82  static void calc_mousexy(void) {
 void mouseint(NEVENTITEM item) {  void mouseint(NEVENTITEM item) {
   
         if (item->flag & NEVENT_SETEVENT) {          if (item->flag & NEVENT_SETEVENT) {
                 if (!(mouseif.portc & 0x10)) {                  if (!(mouseif.upd8255.portc & 0x10)) {
                         pic_setirq(0x0d);                          pic_setirq(0x0d);
                         nevent_set(NEVENT_MOUSE, pc.mouseclock << mouseif.timing,                          nevent_set(NEVENT_MOUSE, mouseif.intrclock << mouseif.timing,
                                                                                                 mouseint, NEVENT_RELATIVE);                                                                                                  mouseint, NEVENT_RELATIVE);
                 }                  }
         }          }
 }  }
   
 static void setportc(BYTE value) {  static void setportc(REG8 value) {
   
         if ((value & 0x80) && (!(mouseif.portc & 0x80))) {          if ((value & 0x80) && (!(mouseif.upd8255.portc & 0x80))) {
                 calc_mousexy();                  calc_mousexy();
                 mouseif.latch_x = mouseif.x;                  mouseif.latch_x = mouseif.x;
                 mouseif.x = 0;                  mouseif.x = 0;
Line 101  static void setportc(BYTE value) { Line 111  static void setportc(BYTE value) {
                         mouseif.latch_y = -128;                          mouseif.latch_y = -128;
                 }                  }
         }          }
         if ((value ^ mouseif.portc) & 0x10) {          if ((value ^ mouseif.upd8255.portc) & 0x10) {
                 if (!(value & 0x10)) {                  if (!(value & 0x10)) {
                         if (!nevent_iswork(NEVENT_MOUSE)) {                          if (!nevent_iswork(NEVENT_MOUSE)) {
                                 nevent_set(NEVENT_MOUSE, pc.mouseclock << mouseif.timing,                                  // 割り込みを入れとく
                                   pic_setirq(0x0d);
                                   nevent_set(NEVENT_MOUSE, mouseif.intrclock << mouseif.timing,
                                                                                                 mouseint, NEVENT_ABSOLUTE);                                                                                                  mouseint, NEVENT_ABSOLUTE);
                         }                          }
                 }                  }
         }          }
         mouseif.portc = value;          mouseif.upd8255.portc = (UINT8)value;
 }  }
   
   
 // ---- I/O  // ---- I/O
   
 static void IOOUTCALL mouseif_o7fdd(UINT port, BYTE dat) {  static void IOOUTCALL mouseif_o7fd9(UINT port, REG8 dat) {
   
           mouseif.upd8255.porta = dat;
           (void)port;
   }
   
   static void IOOUTCALL mouseif_o7fdb(UINT port, REG8 dat) {
   
           mouseif.upd8255.portb = dat;
           (void)port;
   }
   
   static void IOOUTCALL mouseif_o7fdd(UINT port, REG8 dat) {
   
         setportc(dat);          setportc(dat);
         (void)port;          (void)port;
 }  }
   
 static void IOOUTCALL mouseif_o7fdf(UINT port, BYTE dat) {  static void IOOUTCALL mouseif_o7fdf(UINT port, REG8 dat) {
   
         if (dat & 0xf0) {          REG8    portc;
                 mouseif.mode = dat;          UINT    sft;
                 if (dat == 0x93) {  
                         setportc(0);          portc = 0;
                 }          if (dat & uPD8255_CTRL) {
                   mouseif.upd8255.mode = (UINT8)dat;
   #if 0
                   pic_resetirq(0x0d);
                   nevent_set(NEVENT_MOUSE, mouseif.intrclock << mouseif.timing,
                                                                                                   mouseint, NEVENT_ABSOLUTE);
   #endif
         }          }
         else {          else {
                 if (dat & 1) {                  sft = (dat >> 1) & 7;
                         setportc((BYTE)(mouseif.portc | (1 << (dat >> 1))));                  portc = mouseif.upd8255.portc;
                 }                  portc &= (~(1 << sft));
                 else {                  portc |= (dat & 1) << sft;
                         setportc((BYTE)(mouseif.portc & (~(1 << (dat >> 1)))));  
                 }  
         }          }
           setportc(portc);
         (void)port;          (void)port;
 }  }
   
 static BYTE IOINPCALL mouseif_i7fd9(UINT port) {  static REG8 IOINPCALL mouseif_i7fd9(UINT port) {
   
         SINT16  x;          SINT16  x;
         SINT16  y;          SINT16  y;
         BYTE    ret;          REG8    ret;
         BYTE    portc;          REG8    portc;
   
         calc_mousexy();          if (mouseif.upd8255.mode & uPD8255_PORTA) {
         ret = mouseif.b & 0xf0;                  calc_mousexy();
         if (np2cfg.MOUSERAPID) {                  ret = mouseif.b;
                 ret |= mouseif.rapid;                  if (np2cfg.MOUSERAPID) {
         }                          ret |= mouseif.rapid;
         ret |= 0x40;                  }
         portc = mouseif.portc;                  ret &= 0xf0;
         if (portc & 0x80) {  #if 1
                 x = mouseif.latch_x;                  ret |= 0x40;            // for shizuku
                 y = mouseif.latch_y;  #else
         }                  ret |= 0x50;
         else {  #endif
                 x = mouseif.x;                  portc = mouseif.upd8255.portc;
                 y = mouseif.y;                  if (portc & 0x80) {
         }                          x = mouseif.latch_x;
         if (portc & 0x40) {                          y = mouseif.latch_y;
                 x = y;                  }
         }                  else {
         if (!(portc & 0x20)) {                          x = mouseif.x;
                 ret |= x & 0x0f;                          y = mouseif.y;
                   }
                   if (portc & 0x40) {
                           x = y;
                   }
                   if (!(portc & 0x20)) {
                           ret |= x & 0x0f;
                   }
                   else {
                           ret |= (x >> 4) & 0x0f;
                   }
                   return(ret);
         }          }
         else {          else {
                 ret |= (x >> 4) & 0x0f;                  return(mouseif.upd8255.porta);
         }          }
         (void)port;          (void)port;
         return(ret);  
 }  }
   
 static BYTE IOINPCALL mouseif_i7fdb(UINT port) {  static REG8 IOINPCALL mouseif_i7fdb(UINT port) {
   
           if (mouseif.upd8255.mode & uPD8255_PORTB) {
                   return(0x40);
           }
           else {
                   return(mouseif.upd8255.portb);
           }
         (void)port;          (void)port;
         return(0x40);  
 }  }
   
 static BYTE IOINPCALL mouseif_i7fdd(UINT port) {  static REG8 IOINPCALL mouseif_i7fdd(UINT port) {
   
         BYTE    ret;          REG8    mode;
         BYTE    mode;          REG8    ret;
   
         ret = mouseif.portc;          mode = mouseif.upd8255.mode;
         mode = mouseif.mode;          ret = mouseif.upd8255.portc;
         if (mode & 8) {          if (mode & uPD8255_PORTCH) {
                 ret &= 0x1f;                  ret &= 0x1f;
         }          }
         if (mode & 1) {          if (mode & uPD8255_PORTCL) {
                 ret &= 0xf0;                  ret &= 0xf0;
                 ret |= 0x08;                  ret |= 0x08;
                 ret |= (np2cfg.dipsw[2] >> 5) & 0x04;                  ret |= (pccore.dipsw[2] >> 5) & 0x04;
                 ret |= ((~np2cfg.dipsw[0]) >> 4) & 0x03;                  ret |= ((~pccore.dipsw[0]) >> 4) & 0x03;
         }          }
         (void)port;          (void)port;
         return(ret);          return(ret);
 }  }
   
   static void IOOUTCALL mouseif_obfdb(UINT port, REG8 dat) {
 static void IOOUTCALL mouseif_obfdb(UINT port, BYTE dat) {  
   
         mouseif.timing = dat & 3;          mouseif.timing = dat & 3;
         (void)port;          (void)port;
Line 211  static void IOOUTCALL mouseif_obfdb(UINT Line 254  static void IOOUTCALL mouseif_obfdb(UINT
   
 // ---- I/F  // ---- I/F
   
 void mouseif_reset(void) {  void mouseif_reset(const NP2CFG *pConfig) {
   
         ZeroMemory(&mouseif, sizeof(mouseif));          ZeroMemory(&mouseif, sizeof(mouseif));
         mouseif.mode = 0x93;          mouseif.upd8255.porta = 0x00;
         mouseif.portc = 0x10;                                                                                   // ver0.28          mouseif.upd8255.portb = 0x00;
           mouseif.upd8255.portc = 0xf0;                                                                   // ver0.82
           mouseif.upd8255.mode = 0x93;
           mouseif.intrclock = pccore.realclock / 120;
           mouseif.moveclock = pccore.realclock / 56400;
           mouseif.latch_x = -1;
           mouseif.latch_y = -1;
   
           (void)pConfig;
 }  }
   
 void mouseif_bind(void) {  void mouseif_bind(void) {
   
           iocore_attachout(0x7fd9, mouseif_o7fd9);
           iocore_attachout(0x7fdb, mouseif_o7fdb);
         iocore_attachout(0x7fdd, mouseif_o7fdd);          iocore_attachout(0x7fdd, mouseif_o7fdd);
         iocore_attachout(0x7fdf, mouseif_o7fdf);          iocore_attachout(0x7fdf, mouseif_o7fdf);
         iocore_attachinp(0x7fd9, mouseif_i7fd9);          iocore_attachinp(0x7fd9, mouseif_i7fd9);
Removed from v.1.4  
changed lines
  Added in v.1.18

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