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