[BACK]Return to toolwin.cpp CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / win9x

Diff for /np2/win9x/toolwin.cpp between versions 1.11 and 1.16

version 1.11, 2003/11/01 22:23:04 version 1.16, 2005/02/07 14:46:14
Line 35  enum { Line 35  enum {
   
         IDC_BASE                                = 3000,          IDC_BASE                                = 3000,
   
         IDC_SKINSEL                             = 3100,          IDM_SKINSEL                             = 3100,
         IDC_SKINDEF                             = 3101,          IDM_SKINDEF                             = 3101,
         IDC_SKINMRU                             = 3102,          IDM_SKINMRU                             = 3102,
         IDC_TOOLCLOSE                   = IDC_SKINMRU + SKINMRU_MAX          IDM_TOOLCLOSE                   = IDM_SKINMRU + SKINMRU_MAX
 };  };
   
 enum {  enum {
Line 70  typedef struct { Line 70  typedef struct {
         HWND                    hwnd;          HWND                    hwnd;
         WINLOCEX                wlex;          WINLOCEX                wlex;
         HBITMAP                 hbmp;          HBITMAP                 hbmp;
         BYTE                    fddaccess[2];          UINT8                   fddaccess[2];
         BYTE                    hddaccess;          UINT8                   hddaccess;
         BYTE                    _padding;          UINT8                   _padding;
         int                             winflg;          int                             winflg;
         int                             wingx;          int                             wingx;
         int                             wingy;          int                             wingy;
Line 103  static TOOLWIN  toolwin; Line 103  static TOOLWIN  toolwin;
   
 typedef struct {  typedef struct {
         WORD    idc;          WORD    idc;
         BYTE    *counter;          UINT8   *counter;
 } DISKACC;  } DISKACC;
   
 static const BYTE fddlist[FDDLIST_DRV] = {  static const UINT8 fddlist[FDDLIST_DRV] = {
                                         IDC_TOOLFDD1LIST, IDC_TOOLFDD2LIST};                                          IDC_TOOLFDD1LIST, IDC_TOOLFDD2LIST};
   
 static const DISKACC diskacc[3] = {  static const DISKACC diskacc[3] = {
Line 129  static HBITMAP skinload(const char *path Line 129  static HBITMAP skinload(const char *path
         toolskin.color1 = 0x600000;          toolskin.color1 = 0x600000;
         toolskin.color2 = 0xff0000;          toolskin.color2 = 0xff0000;
         if (path) {          if (path) {
                 ini_read(path, skintitle, skinini1, sizeof(skinini1)/sizeof(INITBL));                  ini_read(path, skintitle, skinini1, NELEMENTS(skinini1));
         }          }
         if (toolskin.main[0]) {          if (toolskin.main[0]) {
                 ZeroMemory(subitem, sizeof(defsubitem));                  ZeroMemory(subitem, sizeof(defsubitem));
Line 142  static HBITMAP skinload(const char *path Line 142  static HBITMAP skinload(const char *path
                 CopyMemory(subitem, defsubitem, sizeof(defsubitem));                  CopyMemory(subitem, defsubitem, sizeof(defsubitem));
         }          }
         if (path) {          if (path) {
                 ini_read(path, skintitle, skinini2, sizeof(skinini2)/sizeof(INITBL));                  ini_read(path, skintitle, skinini2, NELEMENTS(skinini2));
         }          }
         if (toolskin.main[0]) {          if (toolskin.main[0]) {
                 milstr_ncpy(fname, path, sizeof(fname));                  milstr_ncpy(fname, path, sizeof(fname));
Line 180  static void calctextsize(char *path, int Line 180  static void calctextsize(char *path, int
         file_cutname(path);          file_cutname(path);
         file_cutseparator(path);          file_cutseparator(path);
         file_cutname(path);          file_cutname(path);
           file_cutseparator(path);
         l = strlen(path);          l = strlen(path);
         if (l > 1) {          work[0] = '\0';
                 l -= 1;          if (l) {
                 if (milstr_kanji2nd(p, l - 1)) {                  milstr_ncpy(work, str_browse, sizeof(work));
                         l--;  
                 }  
         }  
         else {  
                 l = 0;  
         }          }
         milstr_ncpy(work, str_browse, sizeof(work));  
         milstr_ncat(work, p + l, sizeof(work));          milstr_ncat(work, p + l, sizeof(work));
         GetTextExtentPoint32(hdc, work, strlen(work), &tail);          GetTextExtentPoint32(hdc, work, strlen(work), &tail);
         pos = 0;          pos = 0;
Line 305  static void remakefddlist(HWND hwnd, TOO Line 300  static void remakefddlist(HWND hwnd, TOO
         setlist(hwnd, fdd, sel);          setlist(hwnd, fdd, sel);
 }  }
   
 static void accdraw(HWND hWnd, BYTE count) {  static void accdraw(HWND hWnd, UINT8 count) {
   
         HDC                     hdc;          HDC                     hdc;
         PAINTSTRUCT     ps;          PAINTSTRUCT     ps;
Line 557  const char *base; Line 552  const char *base;
 const char      *file[SKINMRU_MAX];  const char      *file[SKINMRU_MAX];
   
         ret = CreatePopupMenu();          ret = CreatePopupMenu();
         AppendMenu(ret, MF_STRING, IDC_SKINSEL, str_skinsel);          AppendMenu(ret, MF_STRING, IDM_SKINSEL, str_skinsel);
         AppendMenu(ret, MF_SEPARATOR, 0, NULL);          AppendMenu(ret, MF_SEPARATOR, 0, NULL);
   
         base = np2tool.skin;          base = np2tool.skin;
         flag = (base[0] == '\0')?MF_CHECKED:0;          flag = (base[0] == '\0')?MF_CHECKED:0;
         AppendMenu(ret, MF_STRING + flag, IDC_SKINDEF, str_skindef);          AppendMenu(ret, MF_STRING + flag, IDM_SKINDEF, str_skindef);
         for (cnt=0; cnt<SKINMRU_MAX; cnt++) {          for (cnt=0; cnt<SKINMRU_MAX; cnt++) {
                 p = np2tool.skinmru[cnt];                  p = np2tool.skinmru[cnt];
                 if (p[0] == '\0') {                  if (p[0] == '\0') {
Line 583  const char *file[SKINMRU_MAX]; Line 578  const char *file[SKINMRU_MAX];
         for (i=0; i<cnt; i++) {          for (i=0; i<cnt; i++) {
                 j = id[i];                  j = id[i];
                 flag = (!file_cmpname(base, np2tool.skinmru[j]))?MF_CHECKED:0;                  flag = (!file_cmpname(base, np2tool.skinmru[j]))?MF_CHECKED:0;
                 AppendMenu(ret, MF_STRING + flag, IDC_SKINMRU + j, file[j]);                  AppendMenu(ret, MF_STRING + flag, IDM_SKINMRU + j, file[j]);
         }          }
         return(ret);          return(ret);
 }  }
Line 610  const char  *p; Line 605  const char  *p;
                 }                  }
                 file_cpyname(np2tool.skinmru[0], p, sizeof(np2tool.skinmru[0]));                  file_cpyname(np2tool.skinmru[0], p, sizeof(np2tool.skinmru[0]));
         }          }
           ModifyMenu(np2class_gethmenu(hWnd), 0, MF_BYPOSITION | MF_POPUP,
                                                                           (UINT)createskinmenu(), str_toolskin);
         ModifyMenu(GetSystemMenu(hWnd, FALSE), 0, MF_BYPOSITION | MF_POPUP,          ModifyMenu(GetSystemMenu(hWnd, FALSE), 0, MF_BYPOSITION | MF_POPUP,
                                                                         (UINT)createskinmenu(), str_toolskin);                                                                          (UINT)createskinmenu(), str_toolskin);
         DrawMenuBar(hWnd);          DrawMenuBar(hWnd);
         sysmng_update(SYS_UPDATEOSCFG);          sysmng_update(SYS_UPDATEOSCFG);
   
         wlex = np2_winlocexallwin(hWndMain);          wlex = np2_winlocexallwin(hWndMain);
           winlocex_setholdwnd(wlex, hWnd);
         toolwindestroy();          toolwindestroy();
         hbmp = skinload(np2tool.skin);          hbmp = skinload(np2tool.skin);
         if (hbmp == NULL) {          if (hbmp == NULL) {
Line 636  const char  *p; Line 634  const char  *p;
 static void openpopup(HWND hWnd, LPARAM lp) {  static void openpopup(HWND hWnd, LPARAM lp) {
   
         HMENU   hMenu;          HMENU   hMenu;
           HMENU   mainmenu;
         POINT   pt;          POINT   pt;
   
         hMenu = CreatePopupMenu();          hMenu = CreatePopupMenu();
           if (!winui_en) {
                   mainmenu = np2class_gethmenu(hWndMain);
                   menu_addmenubar(hMenu, mainmenu);
           }
         AppendMenu(hMenu, MF_POPUP, (UINT)createskinmenu(), str_toolskin);          AppendMenu(hMenu, MF_POPUP, (UINT)createskinmenu(), str_toolskin);
         AppendMenu(hMenu, MF_SEPARATOR, 0, NULL);          AppendMenu(hMenu, MF_SEPARATOR, 0, NULL);
         AppendMenu(hMenu, MF_STRING, IDC_TOOLCLOSE, str_toolclose);          AppendMenu(hMenu, MF_STRING, IDM_TOOLCLOSE, str_toolclose);
         pt.x = LOWORD(lp);          pt.x = LOWORD(lp);
         pt.y = HIWORD(lp);          pt.y = HIWORD(lp);
         ClientToScreen(hWnd, &pt);          ClientToScreen(hWnd, &pt);
         TrackPopupMenu(hMenu, TPM_LEFTALIGN, pt.x, pt.y, 0, hWnd, NULL);          TrackPopupMenu(hMenu, TPM_LEFTALIGN, pt.x, pt.y, 0, hWnd, NULL);
         ModifyMenu(hMenu, 0, MF_BYPOSITION | MF_POPUP, (UINT)0, str_toolskin);  
         DestroyMenu(hMenu);          DestroyMenu(hMenu);
 }  }
   
Line 659  static LRESULT CALLBACK twproc(HWND hWnd Line 661  static LRESULT CALLBACK twproc(HWND hWnd
   
         switch(msg) {          switch(msg) {
                 case WM_CREATE:                  case WM_CREATE:
                           np2class_wmcreate(hWnd);
                           ModifyMenu(np2class_gethmenu(hWnd), 0, MF_BYPOSITION | MF_POPUP,
                                                                           (UINT)createskinmenu(), str_toolskin);
                         hMenu = GetSystemMenu(hWnd, FALSE);                          hMenu = GetSystemMenu(hWnd, FALSE);
                         InsertMenu(hMenu, 0, MF_BYPOSITION | MF_POPUP,                          InsertMenu(hMenu, 0, MF_BYPOSITION | MF_POPUP,
                                                                         (UINT)createskinmenu(), str_toolskin);                                                                          (UINT)createskinmenu(), str_toolskin);
                         InsertMenu(hMenu, 1, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);                          InsertMenu(hMenu, 1, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
   
                         np2class_windowtype(hWnd, np2tool.type);                          np2class_windowtype(hWnd, (np2tool.type & 1) << 1);
                         toolwincreate(hWnd);                          toolwincreate(hWnd);
                         break;                          break;
   
                 case WM_SYSCOMMAND:                  case WM_SYSCOMMAND:
                         switch(wp) {                          switch(wp) {
                                 case IDC_SKINSEL:                                  case IDM_SKINSEL:
                                 case IDC_SKINDEF:                                  case IDM_SKINDEF:
                                 case IDC_SKINMRU + 0:                                  case IDM_SKINMRU + 0:
                                 case IDC_SKINMRU + 1:                                  case IDM_SKINMRU + 1:
                                 case IDC_SKINMRU + 2:                                  case IDM_SKINMRU + 2:
                                 case IDC_SKINMRU + 3:                                  case IDM_SKINMRU + 3:
                                         return(SendMessage(hWnd, WM_COMMAND, wp, lp));                                          return(SendMessage(hWnd, WM_COMMAND, wp, lp));
   
                                 default:                                  default:
Line 692  static LRESULT CALLBACK twproc(HWND hWnd Line 697  static LRESULT CALLBACK twproc(HWND hWnd
                                         break;                                          break;
   
                                 case IDC_BASE + IDC_TOOLFDD1BROWSE:                                  case IDC_BASE + IDC_TOOLFDD1BROWSE:
                                         soundmng_disable(SNDPROC_TOOL);                                          if (!winui_en) {
                                         dialog_changefdd(hWnd, 0);                                                  SendMessage(hWndMain, WM_COMMAND, IDM_FDD1OPEN, 0);
                                         soundmng_enable(SNDPROC_TOOL);                                          }
                                         break;                                          break;
   
                                 case IDC_BASE + IDC_TOOLFDD1EJECT:                                  case IDC_BASE + IDC_TOOLFDD1EJECT:
Line 709  static LRESULT CALLBACK twproc(HWND hWnd Line 714  static LRESULT CALLBACK twproc(HWND hWnd
                                         break;                                          break;
   
                                 case IDC_BASE + IDC_TOOLFDD2BROWSE:                                  case IDC_BASE + IDC_TOOLFDD2BROWSE:
                                         soundmng_disable(SNDPROC_TOOL);                                          if (!winui_en) {
                                         dialog_changefdd(hWnd, 1);                                                  SendMessage(hWndMain, WM_COMMAND, IDM_FDD2OPEN, 0);
                                         soundmng_enable(SNDPROC_TOOL);                                          }
                                         break;                                          break;
   
                                 case IDC_BASE + IDC_TOOLFDD2EJECT:                                  case IDC_BASE + IDC_TOOLFDD2EJECT:
Line 720  static LRESULT CALLBACK twproc(HWND hWnd Line 725  static LRESULT CALLBACK twproc(HWND hWnd
                                         break;                                          break;
   
                                 case IDC_BASE + IDC_TOOLRESET:                                  case IDC_BASE + IDC_TOOLRESET:
                                         SendMessage(hWndMain, WM_COMMAND, IDM_RESET, 0);                                          if (!winui_en) {
                                         SetForegroundWindow(hWndMain);                                                  SendMessage(hWndMain, WM_COMMAND, IDM_RESET, 0);
                                                   SetForegroundWindow(hWndMain);
                                           }
                                         break;                                          break;
   
                                 case IDC_BASE + IDC_TOOLPOWER:                                  case IDC_BASE + IDC_TOOLPOWER:
                                         SendMessage(hWndMain, WM_CLOSE, 0, 0L);                                          if (!winui_en) {
                                                   SendMessage(hWndMain, WM_CLOSE, 0, 0L);
                                           }
                                         break;                                          break;
   
                                 case IDC_SKINSEL:                                  case IDM_SKINSEL:
                                         soundmng_disable(SNDPROC_TOOL);                                          soundmng_disable(SNDPROC_TOOL);
                                         r = dlgs_selectfile(hWnd, &skinui, np2tool.skin,                                          r = dlgs_selectfile(hWnd, &skinui, np2tool.skin,
                                                                                         sizeof(np2tool.skin), NULL);                                                                                          sizeof(np2tool.skin), NULL);
Line 738  static LRESULT CALLBACK twproc(HWND hWnd Line 747  static LRESULT CALLBACK twproc(HWND hWnd
                                         }                                          }
                                         break;                                          break;
   
                                 case IDC_SKINDEF:                                  case IDM_SKINDEF:
                                         np2tool.skin[0] = '\0';                                          np2tool.skin[0] = '\0';
                                         skinchange(hWnd);                                          skinchange(hWnd);
                                         break;                                          break;
   
                                 case IDC_SKINMRU + 0:                                  case IDM_SKINMRU + 0:
                                 case IDC_SKINMRU + 1:                                  case IDM_SKINMRU + 1:
                                 case IDC_SKINMRU + 2:                                  case IDM_SKINMRU + 2:
                                 case IDC_SKINMRU + 3:                                  case IDM_SKINMRU + 3:
                                         file_cpyname(np2tool.skin,                                          file_cpyname(np2tool.skin,
                                                                         np2tool.skinmru[LOWORD(wp) - IDC_SKINMRU],                                                                          np2tool.skinmru[LOWORD(wp) - IDM_SKINMRU],
                                                                         sizeof(np2tool.skin));                                                                          sizeof(np2tool.skin));
                                         skinchange(hWnd);                                          skinchange(hWnd);
                                         break;                                          break;
   
                                 case IDC_TOOLCLOSE:                                  case IDM_TOOLCLOSE:
                                         SendMessage(hWnd, WM_CLOSE, 0, 0);                                          SendMessage(hWnd, WM_CLOSE, 0, 0);
                                         break;                                          break;
   
                                   default:
                                           if (!winui_en) {
                                                   return(SendMessage(hWndMain, msg, wp, lp));
                                           }
                                           break;
                         }                          }
                         break;                          break;
   
Line 767  static LRESULT CALLBACK twproc(HWND hWnd Line 782  static LRESULT CALLBACK twproc(HWND hWnd
                                 }                                  }
                                 return(0);                                  return(0);
                         }                          }
                         break;                          return(SendMessage(hWndMain, msg, wp, lp));
   
                   case WM_KEYUP:
                           if ((short)wp == VK_TAB) {
                                   return(0);
                           }
                           return(SendMessage(hWndMain, msg, wp, lp));
   
                 case WM_PAINT:                  case WM_PAINT:
                         toolwinpaint(hWnd);                          toolwinpaint(hWnd);
Line 819  static LRESULT CALLBACK twproc(HWND hWnd Line 840  static LRESULT CALLBACK twproc(HWND hWnd
                         break;                          break;
   
                 case WM_DESTROY:                  case WM_DESTROY:
                         np2class_destroymenu(hWnd);                          np2class_wmdestroy(hWnd);
                         toolwindestroy();                          toolwindestroy();
                         toolwin.hwnd = NULL;                          toolwin.hwnd = NULL;
                         break;                          break;
Line 837  static LRESULT CALLBACK twproc(HWND hWnd Line 858  static LRESULT CALLBACK twproc(HWND hWnd
                 case WM_LBUTTONDBLCLK:                  case WM_LBUTTONDBLCLK:
                         np2tool.type ^= 1;                          np2tool.type ^= 1;
                         wlex = np2_winlocexallwin(hWndMain);                          wlex = np2_winlocexallwin(hWndMain);
                         np2class_windowtype(hWnd, np2tool.type);                          winlocex_setholdwnd(wlex, hWnd);
                           np2class_windowtype(hWnd, (np2tool.type & 1) << 1);
                         winlocex_move(wlex);                          winlocex_move(wlex);
                         winlocex_destroy(wlex);                          winlocex_destroy(wlex);
                         sysmng_update(SYS_UPDATEOSCFG);                          sysmng_update(SYS_UPDATEOSCFG);
Line 861  BOOL toolwin_initapp(HINSTANCE hInstance Line 883  BOOL toolwin_initapp(HINSTANCE hInstance
         wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON2));          wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON2));
         wc.hCursor = LoadCursor(NULL, IDC_ARROW);          wc.hCursor = LoadCursor(NULL, IDC_ARROW);
         wc.hbrBackground = (HBRUSH)GetStockObject(NULL_BRUSH);          wc.hbrBackground = (HBRUSH)GetStockObject(NULL_BRUSH);
         wc.lpszMenuName = NULL;          wc.lpszMenuName = MAKEINTRESOURCE(IDR_TOOLWIN);
         wc.lpszClassName = np2toolclass;          wc.lpszClassName = np2toolclass;
         return(RegisterClass(&wc));          return(RegisterClass(&wc));
 }  }
Line 894  void toolwin_create(void) { Line 916  void toolwin_create(void) {
         }          }
         UpdateWindow(hWnd);          UpdateWindow(hWnd);
         ShowWindow(hWnd, SW_SHOWNOACTIVATE);          ShowWindow(hWnd, SW_SHOWNOACTIVATE);
           SetForegroundWindow(hWndMain);
         return;          return;
   
 twope_err2:  twope_err2:
Line 917  HWND toolwin_gethwnd(void) { Line 940  HWND toolwin_gethwnd(void) {
         return(toolwin.hwnd);          return(toolwin.hwnd);
 }  }
   
 void toolwin_setfdd(BYTE drv, const char *name) {  void toolwin_setfdd(UINT8 drv, const char *name) {
   
         TOOLFDD *fdd;          TOOLFDD *fdd;
         char    *q;          char    *q;
Line 960  void toolwin_setfdd(BYTE drv, const char Line 983  void toolwin_setfdd(BYTE drv, const char
         }          }
 }  }
   
 static void setdiskacc(UINT num, BYTE count) {  static void setdiskacc(UINT num, UINT8 count) {
   
 const DISKACC   *acc;  const DISKACC   *acc;
         HWND            sub;          HWND            sub;
Line 968  const DISKACC *acc; Line 991  const DISKACC *acc;
         if (toolwin.hwnd == NULL) {          if (toolwin.hwnd == NULL) {
                 return;                  return;
         }          }
         if (num < (sizeof(diskacc)/sizeof(DISKACC))) {          if (num < NELEMENTS(diskacc)) {
                 acc = diskacc + num;                  acc = diskacc + num;
                 sub = NULL;                  sub = NULL;
                 if (*(acc->counter) == 0) {                  if (*(acc->counter) == 0) {
Line 981  const DISKACC *acc; Line 1004  const DISKACC *acc;
         }          }
 }  }
   
 void toolwin_fddaccess(BYTE drv) {  void toolwin_fddaccess(UINT8 drv) {
   
         if (drv < 2) {          if (drv < 2) {
                 setdiskacc(drv, 20);                  setdiskacc(drv, 20);
         }          }
 }  }
   
 void toolwin_hddaccess(BYTE drv) {  void toolwin_hddaccess(UINT8 drv) {
   
         setdiskacc(2, 10);          setdiskacc(2, 10);
 }  }
   
 void toolwin_draw(BYTE frame) {  void toolwin_draw(UINT8 frame) {
   
 const DISKACC   *acc;  const DISKACC   *acc;
 const DISKACC   *accterm;  const DISKACC   *accterm;
         BYTE            counter;          UINT8           counter;
         HWND            sub;          HWND            sub;
   
         if (toolwin.hwnd == NULL) {          if (toolwin.hwnd == NULL) {
Line 1007  const DISKACC *accterm; Line 1030  const DISKACC *accterm;
                 frame = 1;                  frame = 1;
         }          }
         acc = diskacc;          acc = diskacc;
         accterm = acc + (sizeof(diskacc)/sizeof(DISKACC));          accterm = acc + NELEMENTS(diskacc);
         while(acc < accterm) {          while(acc < accterm) {
                 counter = *acc->counter;                  counter = *acc->counter;
                 if (counter) {                  if (counter) {
Line 1066  void toolwin_readini(void) { Line 1089  void toolwin_readini(void) {
         np2tool.posy = CW_USEDEFAULT;          np2tool.posy = CW_USEDEFAULT;
         np2tool.type = 1;          np2tool.type = 1;
         initgetfile(path, sizeof(path));          initgetfile(path, sizeof(path));
         ini_read(path, ini_title, iniitem, sizeof(iniitem)/sizeof(INITBL));          ini_read(path, ini_title, iniitem, NELEMENTS(iniitem));
 }  }
   
 void toolwin_writeini(void) {  void toolwin_writeini(void) {
Line 1074  void toolwin_writeini(void) { Line 1097  void toolwin_writeini(void) {
         char    path[MAX_PATH];          char    path[MAX_PATH];
   
         initgetfile(path, sizeof(path));          initgetfile(path, sizeof(path));
         ini_write(path, ini_title, iniitem, sizeof(iniitem)/sizeof(INITBL));          ini_write(path, ini_title, iniitem, NELEMENTS(iniitem));
 }  }
   
Removed from v.1.11  
changed lines
  Added in v.1.16

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