rosapps/winfile/main.c

   1 /*
   2  *  ReactOS winfile
   3  *
   4  *  main.c
   5  *
   6  *  Copyright (C) 2002  Robert Dickenson <robd@reactos.org>
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21  */
  22
  23 #ifdef _MSC_VER
  24 #include "stdafx.h"
  25 #else
  26 #define WIN32_LEAN_AND_MEAN     // Exclude rarely-used stuff from Windows headers
  27 #include <windows.h>
  28 #include <commctrl.h>
  29 #include <stdlib.h>
  30 #include <malloc.h>
  31 #include <memory.h>
  32 #include <tchar.h>
  33 #include <process.h>
  34 #include <stdio.h>
  35 #endif
  36
  37 #include "main.h"
  38 #include "settings.h"
  39 #include "framewnd.h"
  40 #include "childwnd.h"
  41
  42
  43 ////////////////////////////////////////////////////////////////////////////////
  44 // Global Variables:
  45 //
  46 UINT OemCodePage;
  47 UINT AnsiCodePage;
  48 LCID UserDefaultLCID;
  49
  50 HINSTANCE hInst;
  51 #ifdef USE_GLOBAL_STRUCT
  52 WINFILE_GLOBALS Globals;
  53 #else
  54 HINSTANCE   hInstance;
  55 HACCEL      hAccel;
  56 HWND            hMainWnd;
  57 HMENU           hMenuFrame;
  58 HMENU           hWindowsMenu;
  59 HMENU           hLanguageMenu;
  60 HMENU           hMenuView;
  61 HMENU           hMenuOptions;
  62 HWND            hMDIClient;
  63 HWND            hStatusBar;
  64 HWND            hToolBar;
  65 HWND            hDriveBar;
  66 HFONT           hFont;
  67
  68 TCHAR           num_sep;
  69 SIZE            spaceSize;
  70 HIMAGELIST  himl;
  71
  72 TCHAR           drives[BUFFER_LEN];
  73 BOOL            prescan_node;   //TODO
  74
  75 LPCSTR      lpszLanguage;
  76 UINT            wStringTableOffset;
  77 #endif
  78
  79 TCHAR szTitle[MAX_LOADSTRING];
  80 TCHAR szFrameClass[MAX_LOADSTRING];
  81 TCHAR szChildClass[MAX_LOADSTRING];
  82
  83
  84 ////////////////////////////////////////////////////////////////////////////////
  85 //
  86 //
  87 //   FUNCTION: InitInstance(HANDLE, int)
  88 //
  89 //   PURPOSE: Saves instance handle and creates main window
  90 //
  91 //   COMMENTS:
  92 //
  93 //        In this function, we save the instance handle in a global variable and
  94 //        create and display the main program window.
  95 //
  96 BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
  97 {
  98 //    char TCHAR[MAX_PATH];
  99 //    int nParts[4];
 100 //    ChildWnd* child;
 101
 102         WNDCLASSEX wcFrame = {
 103                 sizeof(WNDCLASSEX),
 104                 CS_HREDRAW | CS_VREDRAW/*style*/,
 105                 FrameWndProc,
 106                 0/*cbClsExtra*/,
 107                 0/*cbWndExtra*/,
 108                 hInstance,
 109                 LoadIcon(hInstance, MAKEINTRESOURCE(IDI_WINFILE)),
 110                 LoadCursor(0, IDC_ARROW),
 111                 0/*hbrBackground*/,
 112                 0/*lpszMenuName*/,
 113                 szFrameClass,
 114                 (HICON)LoadImage(hInstance, MAKEINTRESOURCE(IDI_WINFILE), IMAGE_ICON,
 115                         GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_SHARED)
 116         };
 117         ATOM hFrameWndClass = RegisterClassEx(&wcFrame); // register frame window class
 118
 119         WNDCLASS wcChild = {
 120                 CS_CLASSDC|CS_DBLCLKS|CS_VREDRAW,
 121                 ChildWndProc,
 122                 0/*cbClsExtra*/,
 123                 0/*cbWndExtra*/,
 124                 hInstance,
 125                 0/*hIcon*/,
 126                 LoadCursor(0, IDC_ARROW),
 127                 0/*hbrBackground*/,
 128                 0/*lpszMenuName*/,
 129                 szChildClass
 130         };
 131
 132         ATOM hChildClass = RegisterClass(&wcChild); // register child windows class
 133
 134         HMENU hMenuFrame = LoadMenu(hInstance, MAKEINTRESOURCE(IDC_WINFILE));
 135         HMENU hMenuWindow = GetSubMenu(hMenuFrame, GetMenuItemCount(hMenuFrame)-2);
 136
 137         CLIENTCREATESTRUCT ccs = {
 138                 hMenuWindow, IDW_FIRST_CHILD
 139         };
 140
 141         INITCOMMONCONTROLSEX icc = {
 142                 sizeof(INITCOMMONCONTROLSEX),
 143                 ICC_BAR_CLASSES
 144         };
 145
 146 //      TCHAR path[MAX_PATH];
 147
 148         HDC hdc = GetDC(0);
 149
 150 //      hMenuFrame = hMenuFrame;
 151         Globals.hMenuView = GetSubMenu(hMenuFrame, 3);
 152         Globals.hMenuOptions = GetSubMenu(hMenuFrame, 4);
 153         Globals.hAccel = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_WINFILE));
 154         Globals.hFont = CreateFont(-MulDiv(8,GetDeviceCaps(hdc,LOGPIXELSY),72), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _T("MS Sans Serif"));
 155         ReleaseDC(0, hdc);
 156
 157         Globals.hMainWnd = CreateWindowEx(0, (LPCTSTR)(int)hFrameWndClass, szTitle,
 158                             WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
 159                                         CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
 160                                         0/*hWndParent*/, hMenuFrame, hInstance, 0/*lpParam*/);
 161     if (!Globals.hMainWnd) {
 162         return FALSE;
 163     }
 164
 165     if (InitCommonControlsEx(&icc))     {
 166 //              TBBUTTON drivebarBtn = {0, 0, TBSTATE_ENABLED, TBSTYLE_SEP};
 167                 TBBUTTON drivebarBtn = {0, 0, TBSTATE_ENABLED, TBSTYLE_SEP};
 168                 int btn = 1;
 169                 PTSTR p;
 170
 171         Globals.hDriveBar = CreateToolbarEx(Globals.hMainWnd,
 172                                 WS_CHILD|WS_VISIBLE|CCS_NOMOVEY|TBSTYLE_FLAT|TBSTYLE_LIST|TBSTYLE_WRAPABLE,
 173 //                    WS_CHILD|WS_VISIBLE|CCS_NOMOVEY|TBSTYLE_LIST|TBSTYLE_TRANSPARENT|TBSTYLE_WRAPABLE,
 174                                         IDW_DRIVEBAR, 2, hInstance, IDB_DRIVEBAR,
 175                                         &drivebarBtn, 1/*iNumButtons*/,
 176                                         25/*dxButton*/, 16/*dyButton*/,
 177                                         0/*dxBitmap*/, 0/*dyBitmap*/, sizeof(TBBUTTON));
 178 //                                      16/*dxButton*/, 13/*dyButton*/,
 179 //                                      16/*dxBitmap*/, 13/*dyBitmap*/, sizeof(TBBUTTON));
 180                 CheckMenuItem(Globals.hMenuOptions, ID_OPTIONS_DRIVEBAR, MF_BYCOMMAND|MF_CHECKED);
 181                 GetLogicalDriveStrings(BUFFER_LEN, Globals.drives);
 182                 drivebarBtn.fsStyle = TBSTYLE_BUTTON;
 183 #ifndef _NO_EXTENSIONS
 184                  // register windows drive root strings
 185                 SendMessage(Globals.hDriveBar, TB_ADDSTRING, 0, (LPARAM)Globals.drives);
 186 #endif
 187                 drivebarBtn.idCommand = ID_DRIVE_FIRST;
 188                 for (p = Globals.drives; *p;) {
 189 #ifdef _NO_EXTENSIONS
 190                          // insert drive letter
 191                         TCHAR b[3] = { tolower(*p) };
 192                         SendMessage(Globals.hDriveBar, TB_ADDSTRING, 0, (LPARAM)b);
 193 #endif
 194                         switch(GetDriveType(p)) {
 195                         case DRIVE_REMOVABLE:   drivebarBtn.iBitmap = 1;        break;
 196                         case DRIVE_CDROM:               drivebarBtn.iBitmap = 3;        break;
 197                         case DRIVE_REMOTE:              drivebarBtn.iBitmap = 4;        break;
 198                         case DRIVE_RAMDISK:             drivebarBtn.iBitmap = 5;        break;
 199                         default:/*DRIVE_FIXED*/ drivebarBtn.iBitmap = 2;
 200                         }
 201                         SendMessage(Globals.hDriveBar, TB_INSERTBUTTON, btn++, (LPARAM)&drivebarBtn);
 202                         drivebarBtn.idCommand++;
 203                         drivebarBtn.iString++;
 204                         while(*p++);
 205                 }
 206                 {
 207
 208 #define DRIVEBOX_WIDTH  200
 209 #define DRIVEBOX_HEIGHT 8
 210
 211                 TBBUTTON toolbarBtns[] = {
 212                         {DRIVEBOX_WIDTH+10, 0, 0, TBSTYLE_SEP},
 213                         {0, 0, 0, TBSTYLE_SEP},
 214
 215 //                      {1, ID_FILE_OPEN, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, ID_FILE_OPEN },
 216                         {2, ID_FILE_MOVE, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, ID_FILE_MOVE},
 217                         {3, ID_FILE_COPY, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, ID_FILE_COPY},
 218                         {4, ID_FILE_COPY_CLIPBOARD, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, ID_FILE_COPY_CLIPBOARD},
 219                         {5, ID_FILE_DELETE, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, ID_FILE_DELETE},
 220                         {6, ID_FILE_RENAME, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 221                         {7, ID_FILE_PROPERTIES, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 222                         {8, ID_FILE_COMPRESS, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 223                         {9, ID_FILE_UNCOMPRESS, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 224 //                      {10, ID_FILE_RUN, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 225                         {10, ID_FILE_PRINT, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 226                         {11, ID_FILE_ASSOCIATE, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 227                         {12, ID_FILE_CREATE_DIRECTORY, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 228                         {13, ID_FILE_SEARCH, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 229                         {14, ID_FILE_SELECT_FILES, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 230 //                      {16, ID_FILE_EXIT, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 231                         {15, ID_DISK_COPY_DISK, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 232                         {16, ID_DISK_LABEL_DISK, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 233                         {17, ID_DISK_FORMAT_DISK, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 234                         {18, ID_DISK_CONNECT_NETWORK_DRIVE, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 235                         {19, ID_DISK_DISCONNECT_NETWORK_DRIVE, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 236                         {20, ID_DISK_SHARE_AS, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 237                         {21, ID_DISK_STOP_SHARING, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 238 //                      {24, ID_DISK_SELECT_DRIVE, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 239 //                      {25, ID_TREE_EXPAND_ONE_LEVEL, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 240 //                      {26, ID_TREE_EXPAND_BRANCH, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 241 //                      {27, ID_TREE_EXPAND_ALL, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 242 //                      {28, ID_TREE_COLLAPSE_BRANCH, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 243                         {22, ID_TREE_INDICATE_EXPANDABLE_BRANCHES, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 244 //                      {30, ID_VIEW_TREE_DIRECTORY, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 245 //                      {31, ID_VIEW_TREE_ONLY, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 246 //                      {32, ID_VIEW_DIRECTORY_ONLY, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 247 //                      {33, ID_VIEW_SPLIT, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 248                         {23, ID_VIEW_NAME, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 249                         {24, ID_VIEW_ALL_FILE_DETAILS, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 250                         {25, ID_VIEW_PARTIAL_DETAILS, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 251 //                      {37, ID_VIEW_SORT_BY_NAME, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 252 //                      {38, ID_VIEW_SORT_BY_TYPE, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 253 //                      {39, ID_VIEW_SORT_BY_SIZE, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 254 //                      {40, ID_VIEW_SORT_BY_DATE, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 255                         {26, ID_VIEW_BY_FILE_TYPE, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 256                         {27, ID_OPTIONS_CONFIRMATION, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 257                         {28, ID_OPTIONS_FONT, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 258                         {29, ID_OPTIONS_CUSTOMISE_TOOLBAR, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 259 //                      {45, ID_OPTIONS_TOOLBAR, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 260 //                      {46, ID_OPTIONS_DRIVEBAR, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 261 //                      {47, ID_OPTIONS_STATUSBAR, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 262                         {30, ID_OPTIONS_OPEN_NEW_WINDOW_ON_CONNECT, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 263                         {31, ID_OPTIONS_MINIMISE_ON_USE, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 264                         {32, ID_OPTIONS_SAVE_ON_EXIT, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 265                         {33, ID_SECURITY_PERMISSIONS, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 266                         {34, ID_SECURITY_AUDITING, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 267                         {35, ID_SECURITY_OWNER, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 268                         {36, ID_WINDOW_NEW_WINDOW, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 269                         {37, ID_WINDOW_CASCADE, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 270                         {38, ID_WINDOW_TILE_HORZ, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 271                         {39, ID_WINDOW_TILE_VERT, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 272                         {40, ID_WINDOW_ARRANGE_ICONS, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 273                         {41, ID_WINDOW_REFRESH, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 274                         {42, ID_HELP_CONTENTS, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 275 //                      {61, ID_HELP_SEARCH_HELP, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 276 //                      {62, ID_HELP_HOW_TO_USE_HELP, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 277 //                      {63, ID_HELP_ABOUT, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 278
 279
 280 //                      {0, ID_WINDOW_NEW_WINDOW, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 281 //                      {1, ID_WINDOW_CASCADE, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 282 //                      {2, ID_WINDOW_TILE_HORZ, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 283 //                      {3, ID_WINDOW_TILE_VERT, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 284 //                      {4, 2/*TODO: ID_...*/, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 285 //                      {5, 2/*TODO: ID_...*/, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 286                 };
 287
 288 //              Globals.hToolBar = CreateToolbarEx(Globals.hMainWnd, WS_CHILD|WS_VISIBLE|TBSTYLE_TOOLTIPS|TBSTYLE_FLAT,
 289                 Globals.hToolBar = CreateToolbarEx(Globals.hMainWnd, WS_CHILD|WS_VISIBLE|TBSTYLE_TOOLTIPS|CCS_ADJUSTABLE,
 290                         IDW_TOOLBAR, 2, hInstance, IDB_TOOLBAR, toolbarBtns,
 291                         sizeof(toolbarBtns)/sizeof(TBBUTTON), 16, 15, 16, 15, sizeof(TBBUTTON));
 292                 CheckMenuItem(Globals.hMenuOptions, ID_OPTIONS_TOOLBAR, MF_BYCOMMAND|MF_CHECKED);
 293
 294         {
 295 // Create the edit control. Notice that hWndParent, parent of
 296 // the toolbar, is used as the parent of the edit control.
 297
 298 //HWND hWndEdit = CreateWindowEx(0L, WC_COMBOBOXEX, NULL, WS_CHILD | WS_BORDER | WS_VISIBLE
 299 HWND hWndEdit = CreateWindowEx(0L, "ComboBox", NULL, WS_CHILD | WS_BORDER | WS_VISIBLE
 300    | CBS_DROPDOWN | ES_LEFT | ES_AUTOVSCROLL | ES_MULTILINE,
 301    10, 0, DRIVEBOX_WIDTH, DRIVEBOX_HEIGHT, Globals.hMainWnd, (HMENU)IDW_DRIVEBOX, hInstance, 0);
 302
 303 // Set the toolbar window as the parent of the edit control
 304 // window. You must set the toolbar as the parent of the edit
 305 // control for it to appear embedded in the toolbar.
 306 SetParent (hWndEdit, Globals.hToolBar);
 307         }
 308
 309
 310
 311                 }
 312         }
 313
 314     // Create the status bar
 315     Globals.hStatusBar = CreateStatusWindow(WS_VISIBLE|WS_CHILD|WS_CLIPSIBLINGS|SBT_NOBORDERS,
 316                                     _T(""), Globals.hMainWnd, IDW_STATUS_WINDOW);
 317     if (!Globals.hStatusBar)
 318         return FALSE;
 319         CheckMenuItem(Globals.hMenuOptions, ID_OPTIONS_STATUSBAR, MF_BYCOMMAND|MF_CHECKED);
 320
 321     // Create the status bar panes
 322         SetupStatusBar(FALSE);
 323 /*
 324     nParts[0] = 250;
 325     nParts[1] = 220;
 326     nParts[2] = 100;
 327     nParts[3] = 100;
 328     SendMessage(Globals.hStatusBar, SB_SETPARTS, 4, (long)nParts);
 329  */
 330 #if 0
 331         //Globals.hstatusbar = CreateStatusWindow(WS_CHILD|WS_VISIBLE, 0, Globals.Globals.hMainWnd, IDW_STATUSBAR);
 332         //CheckMenuItem(Globals.Globals.hMenuOptions, ID_OPTIONS_STATUSBAR, MF_BYCOMMAND|MF_CHECKED);
 333 /* CreateStatusWindow does not accept WS_BORDER */
 334 /* Globals.hstatusbar = CreateWindowEx(WS_EX_NOPARENTNOTIFY, STATUSCLASSNAME, 0,
 335                                         WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS|WS_BORDER|CCS_NODIVIDER, 0,0,0,0,
 336                                         Globals.Globals.hMainWnd, (HMENU)IDW_STATUSBAR, hinstance, 0);*/
 337     //TODO: read paths and window placements from registry
 338         GetCurrentDirectory(MAX_PATH, path);
 339         child = alloc_child_window(path);
 340         child->pos.showCmd = SW_SHOWMAXIMIZED;
 341         child->pos.rcNormalPosition.left = 0;
 342         child->pos.rcNormalPosition.top = 0;
 343         child->pos.rcNormalPosition.right = 320;
 344         child->pos.rcNormalPosition.bottom = 280;
 345         if (!create_child_window(child))
 346                 free(child);
 347         SetWindowPlacement(child->hWnd, &child->pos);
 348         Globals.himl = ImageList_LoadBitmap(Globals.hInstance, MAKEINTRESOURCE(IDB_IMAGES), 16, 0, RGB(0,255,0));
 349         Globals.prescan_node = FALSE;
 350 #endif
 351
 352     ShowWindow(Globals.hMainWnd, nCmdShow);
 353     UpdateWindow(Globals.hMainWnd);
 354         UpdateStatusBar();
 355     return TRUE;
 356 }
 357
 358 /*
 359         Globals.hMDIClient = CreateWindowEx(0, _T("MDICLIENT"), NULL,
 360 //      Globals.hMDIClient = CreateWindowEx(0, (LPCTSTR)(int)hChildClass, NULL,
 361                                         WS_CHILD|WS_CLIPCHILDREN|WS_VSCROLL|WS_HSCROLL|WS_VISIBLE|WS_BORDER,
 362                                         0, 0, 0, 0,
 363                                         Globals.hMainWnd, 0, hInstance, &ccs);
 364     if (!Globals.hMDIClient) {
 365         return FALSE;
 366     }
 367  */
 368
 369 void SetupStatusBar(BOOL bResize)
 370 {
 371     int nParts[4];
 372 //              int parts[] = {300, 500};
 373 //              SendMessage(Globals.hStatusBar, WM_SIZE, 0, 0);
 374 //              SendMessage(Globals.hStatusBar, SB_SETPARTS, 2, (LPARAM)&parts);
 375
 376     // Create the status bar panes
 377     nParts[0] = 350;
 378     nParts[1] = 700;
 379     nParts[2] = 800;
 380     nParts[3] = 900;
 381
 382         if (bResize)
 383                 SendMessage(Globals.hStatusBar, WM_SIZE, 0, 0);
 384     SendMessage(Globals.hStatusBar, SB_SETPARTS, 4, (long)nParts);
 385 }
 386
 387 void UpdateStatusBar(void)
 388 {
 389 //  TCHAR text[260];
 390 //      DWORD size;
 391
 392 //      size = sizeof(text)/sizeof(TCHAR);
 393 //      GetUserName(text, &size);
 394 //  SendMessage(Globals.hStatusBar, SB_SETTEXT, 0, (LPARAM)text);
 395 //      size = sizeof(text)/sizeof(TCHAR);
 396 //      GetComputerName(text, &size);
 397 //  SendMessage(Globals.hStatusBar, SB_SETTEXT, 1, (LPARAM)text);
 398 }
 399
 400
 401 static int g_foundPrevInstance = 0;
 402
 403 // search for already running instances
 404 static BOOL CALLBACK EnumWndProc(HWND hWnd, LPARAM lparam)
 405 {
 406         TCHAR cls[128];
 407
 408         GetClassName(hWnd, cls, 128);
 409         if (!lstrcmp(cls, (LPCTSTR)lparam)) {
 410                 g_foundPrevInstance++;
 411         SetForegroundWindow(hWnd);
 412                 return FALSE;
 413         }
 414         return TRUE;
 415 }
 416
 417
 418 void ExitInstance(void)
 419 {
 420     if (Globals.himl)
 421             ImageList_Destroy(Globals.himl);
 422 }
 423
 424 /*
 425 struct _cpinfo {
 426   UINT MaxCharSize;
 427   BYTE DefaultChar[MAX_DEFAULTCHAR];
 428   BYTE LeadByte[MAX_LEADBYTES];
 429 } CPINFO, *LPCPINFO;
 430  */
 431
 432 int APIENTRY WinMain(HINSTANCE hInstance,
 433                      HINSTANCE hPrevInstance,
 434                      LPSTR     lpCmdLine,
 435                      int       nCmdShow)
 436 {
 437     MSG msg;
 438     HACCEL hAccel;
 439     HWND hMDIClient;
 440
 441     CPINFO CPinfo;
 442
 443     OemCodePage = GetOEMCP();
 444     AnsiCodePage = GetACP();
 445     UserDefaultLCID = GetUserDefaultLCID();
 446     if (GetCPInfo(UserDefaultLCID, &CPinfo)) {
 447
 448     }
 449
 450     // Initialize global strings
 451     LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
 452     LoadString(hInstance, IDC_WINFILE, szFrameClass, MAX_LOADSTRING);
 453     LoadString(hInstance, IDC_WINFILE_CHILD, szChildClass, MAX_LOADSTRING);
 454
 455         // Allow only one running instance
 456     EnumWindows(EnumWndProc, (LPARAM)szFrameClass);
 457     if (g_foundPrevInstance) {
 458                 return 1;
 459     }
 460
 461     // Store instance handle in our global variable
 462     hInst = hInstance;
 463
 464     LoadSettings();
 465
 466     // Perform application initialization:
 467     if (!InitInstance(hInstance, nCmdShow)) {
 468         return FALSE;
 469     }
 470
 471 //    hAccel = LoadAccelerators(hInstance, (LPCTSTR)IDC_WINFILE);
 472     hAccel = LoadAccelerators(hInstance, (LPCTSTR)IDR_ACCELERATOR1);
 473
 474     hMDIClient = GetWindow(Globals.hMainWnd, GW_CHILD);
 475
 476     // Main message loop:
 477         while (GetMessage(&msg, (HWND)NULL, 0, 0)) {
 478         if (!TranslateMDISysAccel(hMDIClient, &msg) &&
 479             !TranslateAccelerator(Globals.hMainWnd/*hwndFrame*/, hAccel, &msg)) {
 480             TranslateMessage(&msg);
 481             DispatchMessage(&msg);
 482                 }
 483         }
 484
 485     SaveSettings();
 486         ExitInstance();
 487     return msg.wParam;
 488 }
 489
 490 void _GetFreeSpaceEx(void)
 491 {
 492    BOOL fResult;
 493    TCHAR szDrive[MAX_PATH];
 494    ULARGE_INTEGER i64FreeBytesToCaller;
 495    ULARGE_INTEGER i64TotalBytes;
 496    ULARGE_INTEGER i64FreeBytes;
 497
 498    fResult = GetDiskFreeSpaceEx(szDrive,
 499                 (PULARGE_INTEGER)&i64FreeBytesToCaller,
 500                 (PULARGE_INTEGER)&i64TotalBytes,
 501                 (PULARGE_INTEGER)&i64FreeBytes);
 502 }