2011-11-13 20:53:23 +00:00
|
|
|
/*
|
2011-12-05 11:36:02 +00:00
|
|
|
* Rufus: The Reliable USB Formatting Utility
|
2014-01-02 23:21:30 +00:00
|
|
|
* Copyright © 2011-2014 Pete Batard <pete@akeo.ie>
|
2013-12-27 16:06:59 +00:00
|
|
|
*
|
2011-11-13 20:53:23 +00:00
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2011-11-21 20:12:23 +00:00
|
|
|
/* Memory leaks detection - define _CRTDBG_MAP_ALLOC as preprocessor macro */
|
|
|
|
#ifdef _CRTDBG_MAP_ALLOC
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <crtdbg.h>
|
|
|
|
#endif
|
|
|
|
|
2011-11-13 20:53:23 +00:00
|
|
|
#include <windows.h>
|
|
|
|
#include <windowsx.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
2011-11-24 02:24:50 +00:00
|
|
|
#include <math.h>
|
2011-11-13 20:53:23 +00:00
|
|
|
#include <commctrl.h>
|
2011-11-17 01:43:06 +00:00
|
|
|
#include <setupapi.h>
|
2011-11-20 02:34:15 +00:00
|
|
|
#include <winioctl.h>
|
2013-12-20 18:32:10 +00:00
|
|
|
#include <shlobj.h>
|
2011-11-27 23:40:28 +00:00
|
|
|
#include <process.h>
|
2011-11-26 00:25:04 +00:00
|
|
|
#include <dbt.h>
|
2013-02-04 01:14:28 +00:00
|
|
|
#include <io.h>
|
|
|
|
#include <getopt.h>
|
2011-11-20 22:49:55 +00:00
|
|
|
|
2011-11-13 20:53:23 +00:00
|
|
|
#include "msapi_utf8.h"
|
|
|
|
#include "resource.h"
|
2011-11-19 19:08:23 +00:00
|
|
|
#include "rufus.h"
|
2014-01-05 01:39:41 +00:00
|
|
|
#include "drive.h"
|
2012-11-22 01:52:33 +00:00
|
|
|
#include "registry.h"
|
2013-10-15 21:58:27 +00:00
|
|
|
#include "localization.h"
|
2011-11-13 20:53:23 +00:00
|
|
|
|
2013-06-03 23:44:49 +00:00
|
|
|
/* Redefinitions for WDK and MinGW */
|
2012-03-29 17:16:06 +00:00
|
|
|
#ifndef PBM_SETSTATE
|
|
|
|
#define PBM_SETSTATE (WM_USER+16)
|
|
|
|
#endif
|
|
|
|
#ifndef PBST_NORMAL
|
|
|
|
#define PBST_NORMAL 1
|
|
|
|
#endif
|
|
|
|
#ifndef PBST_ERROR
|
|
|
|
#define PBST_ERROR 2
|
|
|
|
#endif
|
|
|
|
#ifndef PBST_PAUSED
|
|
|
|
#define PBST_PAUSED 3
|
|
|
|
#endif
|
2012-05-16 22:38:39 +00:00
|
|
|
#ifndef BUTTON_IMAGELIST_ALIGN_CENTER
|
|
|
|
#define BUTTON_IMAGELIST_ALIGN_CENTER 4
|
|
|
|
#endif
|
|
|
|
#ifndef BCM_SETIMAGELIST
|
|
|
|
#define BCM_SETIMAGELIST 0x1602
|
|
|
|
#endif
|
2013-06-03 23:44:49 +00:00
|
|
|
#ifndef DBT_CUSTOMEVENT
|
|
|
|
#define DBT_CUSTOMEVENT 0x8006
|
|
|
|
#endif
|
2012-05-16 22:38:39 +00:00
|
|
|
|
2013-12-20 18:32:10 +00:00
|
|
|
// MinGW fails to link those...
|
2012-05-16 22:38:39 +00:00
|
|
|
typedef HIMAGELIST (WINAPI *ImageList_Create_t)(
|
|
|
|
int cx,
|
|
|
|
int cy,
|
|
|
|
UINT flags,
|
|
|
|
int cInitial,
|
|
|
|
int cGrow
|
|
|
|
);
|
|
|
|
ImageList_Create_t pImageList_Create = NULL;
|
|
|
|
typedef int (WINAPI *ImageList_ReplaceIcon_t)(
|
|
|
|
HIMAGELIST himl,
|
|
|
|
int i,
|
|
|
|
HICON hicon
|
|
|
|
);
|
|
|
|
ImageList_ReplaceIcon_t pImageList_ReplaceIcon = NULL;
|
|
|
|
struct {
|
|
|
|
HIMAGELIST himl;
|
|
|
|
RECT margin;
|
|
|
|
UINT uAlign;
|
2013-10-24 21:57:34 +00:00
|
|
|
} bi_iso = {0}, bi_up = {0}, bi_down = {0}, bi_lang = {0}; // BUTTON_IMAGELIST
|
2012-03-29 17:16:06 +00:00
|
|
|
|
2013-12-20 18:32:10 +00:00
|
|
|
// ...and MinGW doesn't know these.
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
LPCITEMIDLIST pidl;
|
|
|
|
BOOL fRecursive;
|
|
|
|
} MY_SHChangeNotifyEntry;
|
|
|
|
|
|
|
|
typedef BOOL (WINAPI *SHChangeNotifyDeregister_t)(
|
|
|
|
ULONG ulID
|
|
|
|
);
|
|
|
|
typedef ULONG (WINAPI *SHChangeNotifyRegister_t)(
|
|
|
|
HWND hwnd,
|
|
|
|
int fSources,
|
|
|
|
LONG fEvents,
|
|
|
|
UINT wMsg,
|
|
|
|
int cEntries,
|
|
|
|
const MY_SHChangeNotifyEntry *pshcne
|
|
|
|
);
|
|
|
|
|
2014-03-29 00:22:54 +00:00
|
|
|
const char* FileSystemLabel[FS_MAX] = { "FAT", "FAT32", "NTFS", "UDF", "exFAT", "ReFS" };
|
2013-07-08 23:14:29 +00:00
|
|
|
// Number of steps for each FS for FCC_STRUCTURE_PROGRESS
|
|
|
|
const int nb_steps[FS_MAX] = { 5, 5, 12, 1, 10 };
|
2013-01-22 02:40:43 +00:00
|
|
|
static const char* PartitionTypeLabel[2] = { "MBR", "GPT" };
|
2012-02-07 16:17:14 +00:00
|
|
|
static BOOL existing_key = FALSE; // For LGP set/restore
|
2013-07-05 22:58:04 +00:00
|
|
|
static BOOL size_check = TRUE;
|
2012-05-30 23:32:25 +00:00
|
|
|
static BOOL log_displayed = FALSE;
|
2013-02-04 01:14:28 +00:00
|
|
|
static BOOL iso_provided = FALSE;
|
2013-12-28 01:27:09 +00:00
|
|
|
static BOOL user_notified = FALSE;
|
2013-10-24 21:57:34 +00:00
|
|
|
static BOOL relaunch = FALSE;
|
2014-01-31 02:51:28 +00:00
|
|
|
extern BOOL force_large_fat32, enable_joliet, enable_rockridge, enable_ntfs_compression;
|
2014-02-04 20:01:28 +00:00
|
|
|
extern const char* old_c32_name[NB_OLD_C32];
|
2012-03-03 23:12:48 +00:00
|
|
|
static int selection_default;
|
2013-10-15 21:58:27 +00:00
|
|
|
static loc_cmd* selected_locale = NULL;
|
2013-10-24 21:57:34 +00:00
|
|
|
static UINT_PTR UM_LANGUAGE_MENU_MAX = UM_LANGUAGE_MENU;
|
|
|
|
static RECT relaunch_rc = { -65536, -65536, 0, 0};
|
2014-03-14 23:13:04 +00:00
|
|
|
static UINT uBootChecked = BST_CHECKED, uQFChecked = BST_CHECKED, uMBRChecked = BST_UNCHECKED;
|
2013-10-15 21:58:27 +00:00
|
|
|
char ClusterSizeLabel[MAX_CLUSTER_SIZES][64];
|
2013-06-15 16:31:55 +00:00
|
|
|
char msgbox[1024], msgbox_title[32];
|
2011-12-01 02:56:44 +00:00
|
|
|
|
2011-11-13 20:53:23 +00:00
|
|
|
/*
|
|
|
|
* Globals
|
|
|
|
*/
|
2011-11-21 17:06:17 +00:00
|
|
|
HINSTANCE hMainInstance;
|
|
|
|
HWND hMainDialog;
|
2012-05-30 23:32:25 +00:00
|
|
|
char szFolderPath[MAX_PATH], app_dir[MAX_PATH];
|
2012-02-07 02:05:58 +00:00
|
|
|
char* iso_path = NULL;
|
2011-11-21 17:06:17 +00:00
|
|
|
float fScale = 1.0f;
|
2011-12-01 15:01:10 +00:00
|
|
|
int default_fs;
|
2013-10-31 22:59:53 +00:00
|
|
|
uint32_t dur_mins, dur_secs;
|
2013-01-24 21:30:11 +00:00
|
|
|
HWND hDeviceList, hPartitionScheme, hFileSystem, hClusterSize, hLabel, hBootType, hNBPasses, hLog = NULL;
|
2012-05-30 23:32:25 +00:00
|
|
|
HWND hISOProgressDlg = NULL, hLogDlg = NULL, hISOProgressBar, hISOFileName, hDiskID;
|
2012-12-15 03:27:14 +00:00
|
|
|
BOOL use_own_c32[NB_OLD_C32] = {FALSE, FALSE}, detect_fakes = TRUE, mbr_selected_by_user = FALSE;
|
2014-01-24 02:46:06 +00:00
|
|
|
BOOL iso_op_in_progress = FALSE, format_op_in_progress = FALSE, right_to_left_mode = FALSE;
|
2013-11-14 01:21:50 +00:00
|
|
|
BOOL enable_HDDs = FALSE, advanced_mode = TRUE, force_update = FALSE;
|
2012-12-07 00:54:40 +00:00
|
|
|
int dialog_showing = 0;
|
2014-01-21 17:08:41 +00:00
|
|
|
uint16_t rufus_version[4], embedded_sl_version[2];
|
2014-01-24 19:59:23 +00:00
|
|
|
char embedded_sl_version_str[2][12] = { "?.??", "?.??" };
|
2012-12-07 00:54:40 +00:00
|
|
|
RUFUS_UPDATE update = { {0,0,0,0}, {0,0}, NULL, NULL};
|
2012-02-15 00:52:40 +00:00
|
|
|
extern char szStatusMessage[256];
|
2011-11-17 01:43:06 +00:00
|
|
|
|
2012-02-07 02:05:58 +00:00
|
|
|
static HANDLE format_thid = NULL;
|
2013-01-24 21:30:11 +00:00
|
|
|
static HWND hProgress = NULL, hBoot = NULL, hSelectISO = NULL;
|
2013-10-24 21:57:34 +00:00
|
|
|
static HICON hIconDisc, hIconDown, hIconUp, hIconLang;
|
2011-12-01 17:20:52 +00:00
|
|
|
static StrArray DriveID, DriveLabel;
|
2012-02-07 02:05:58 +00:00
|
|
|
static char szTimer[12] = "00:00:00";
|
2011-12-08 12:14:21 +00:00
|
|
|
static unsigned int timer;
|
2012-02-07 16:17:14 +00:00
|
|
|
static int64_t last_iso_blocking_status;
|
2011-11-23 12:27:51 +00:00
|
|
|
|
2011-12-09 01:39:13 +00:00
|
|
|
/*
|
|
|
|
* The following is used to allocate slots within the progress bar
|
|
|
|
* 0 means unused (no operation or no progress allocated to it)
|
2013-06-20 14:41:22 +00:00
|
|
|
* +n means allocate exactly n bars (n percent of the progress bar)
|
2011-12-09 01:39:13 +00:00
|
|
|
* -n means allocate a weighted slot of n from all remaining
|
|
|
|
* bars. Eg if 80 slots remain and the sum of all negative entries
|
|
|
|
* is 10, -4 will allocate 4/10*80 = 32 bars (32%) for OP progress
|
|
|
|
*/
|
|
|
|
static int nb_slots[OP_MAX];
|
|
|
|
static float slot_end[OP_MAX+1]; // shifted +1 so that we can substract 1 to OP indexes
|
2012-11-03 17:40:33 +00:00
|
|
|
static float previous_end;
|
2011-12-09 01:39:13 +00:00
|
|
|
|
2013-06-13 22:19:20 +00:00
|
|
|
// TODO: Remember to update copyright year in both license.h and the RC when the year changes!
|
2013-12-19 23:56:40 +00:00
|
|
|
// Also localization_data.sh
|
2011-11-18 21:46:34 +00:00
|
|
|
|
2011-12-01 02:56:44 +00:00
|
|
|
#define KB 1024LL
|
|
|
|
#define MB 1048576LL
|
|
|
|
#define GB 1073741824LL
|
|
|
|
#define TB 1099511627776LL
|
2013-10-15 21:58:27 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Fill in the cluster size names
|
|
|
|
*/
|
|
|
|
static void SetClusterSizeLabels(void)
|
|
|
|
{
|
|
|
|
unsigned int i, j, k;
|
|
|
|
safe_sprintf(ClusterSizeLabel[0], 64, lmprintf(MSG_029));
|
|
|
|
for (i=512, j=1, k=MSG_026; j<MAX_CLUSTER_SIZES; i<<=1, j++) {
|
|
|
|
if (i > 8192) {
|
|
|
|
i /= 1024;
|
|
|
|
k++;
|
|
|
|
}
|
|
|
|
safe_sprintf(ClusterSizeLabel[j], 64, "%d %s", i, lmprintf(k));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-12-27 16:06:59 +00:00
|
|
|
/*
|
2011-12-01 15:01:10 +00:00
|
|
|
* Set cluster size values according to http://support.microsoft.com/kb/140365
|
|
|
|
* this call will return FALSE if we can't find a supportable FS for the drive
|
|
|
|
*/
|
2011-12-01 02:56:44 +00:00
|
|
|
static BOOL DefineClusterSizes(void)
|
|
|
|
{
|
|
|
|
LONGLONG i;
|
2011-12-01 15:01:10 +00:00
|
|
|
int fs;
|
|
|
|
BOOL r = FALSE;
|
2014-01-24 02:46:06 +00:00
|
|
|
char tmp[128] = "", *entry;
|
2011-12-01 15:01:10 +00:00
|
|
|
|
|
|
|
default_fs = FS_UNKNOWN;
|
2011-12-01 02:56:44 +00:00
|
|
|
memset(&SelectedDrive.ClusterSize, 0, sizeof(SelectedDrive.ClusterSize));
|
|
|
|
if (SelectedDrive.DiskSize < 8*MB) {
|
2013-07-05 22:58:04 +00:00
|
|
|
uprintf("Device was eliminated because it is smaller than 8 MB\n");
|
2011-12-01 15:01:10 +00:00
|
|
|
goto out;
|
2011-12-01 02:56:44 +00:00
|
|
|
}
|
|
|
|
|
2011-12-13 02:10:27 +00:00
|
|
|
/*
|
2012-11-03 17:40:33 +00:00
|
|
|
* The following are MS's allowed cluster sizes for FAT16 and FAT32:
|
2011-12-13 02:10:27 +00:00
|
|
|
*
|
|
|
|
* FAT16
|
|
|
|
* 31M : 512 - 4096
|
|
|
|
* 63M : 1024 - 8192
|
|
|
|
* 127M : 2048 - 16k
|
|
|
|
* 255M : 4096 - 32k
|
|
|
|
* 511M : 8192 - 64k
|
|
|
|
* 1023M: 16k - 64k
|
|
|
|
* 2047M: 32k - 64k
|
|
|
|
* 4095M: 64k
|
|
|
|
* 4GB+ : N/A
|
|
|
|
*
|
|
|
|
* FAT32
|
|
|
|
* 31M : N/A
|
|
|
|
* 63M : N/A (NB unlike MS, we're allowing 512-512 here - UNTESTED)
|
|
|
|
* 127M : 512 - 1024
|
|
|
|
* 255M : 512 - 2048
|
|
|
|
* 511M : 512 - 4096
|
|
|
|
* 1023M: 512 - 8192
|
|
|
|
* 2047M: 512 - 16k
|
|
|
|
* 4095M: 1024 - 32k
|
|
|
|
* 7GB : 2048 - 64k
|
|
|
|
* 15GB : 4096 - 64k
|
2012-11-03 17:40:33 +00:00
|
|
|
* 31GB : 8192 - 64k This is as far as Microsoft's FormatEx goes...
|
|
|
|
* 63GB : 16k - 64k ...but we can go higher using fat32format from RidgeCrop.
|
|
|
|
* 2TB+ : N/A
|
2011-12-13 02:10:27 +00:00
|
|
|
*/
|
|
|
|
|
2011-12-01 02:56:44 +00:00
|
|
|
// FAT 16
|
|
|
|
if (SelectedDrive.DiskSize < 4*GB) {
|
2011-12-13 02:10:27 +00:00
|
|
|
SelectedDrive.ClusterSize[FS_FAT16].Allowed = 0x00001E00;
|
2011-12-01 02:56:44 +00:00
|
|
|
for (i=32; i<=4096; i<<=1) { // 8 MB -> 4 GB
|
|
|
|
if (SelectedDrive.DiskSize < i*MB) {
|
|
|
|
SelectedDrive.ClusterSize[FS_FAT16].Default = 16*(ULONG)i;
|
|
|
|
break;
|
|
|
|
}
|
2011-12-13 02:10:27 +00:00
|
|
|
SelectedDrive.ClusterSize[FS_FAT16].Allowed <<= 1;
|
2011-12-01 02:56:44 +00:00
|
|
|
}
|
2011-12-13 02:10:27 +00:00
|
|
|
SelectedDrive.ClusterSize[FS_FAT16].Allowed &= 0x0001FE00;
|
2011-12-01 02:56:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// FAT 32
|
2013-06-20 14:41:22 +00:00
|
|
|
// > 32GB FAT32 is not supported by MS and FormatEx but is achieved using fat32format
|
2011-12-13 02:10:27 +00:00
|
|
|
// See: http://www.ridgecrop.demon.co.uk/index.htm?fat32format.htm
|
2012-11-03 17:40:33 +00:00
|
|
|
// < 32 MB FAT32 is not allowed by FormatEx, so we don't bother
|
2013-09-22 02:28:56 +00:00
|
|
|
if ((SelectedDrive.DiskSize >= 32*MB) && (1.0f*SelectedDrive.DiskSize < 1.0f*MAX_FAT32_SIZE*TB)) {
|
2011-12-13 02:10:27 +00:00
|
|
|
SelectedDrive.ClusterSize[FS_FAT32].Allowed = 0x000001F8;
|
|
|
|
for (i=32; i<=(32*1024); i<<=1) { // 32 MB -> 32 GB
|
2011-12-01 02:56:44 +00:00
|
|
|
if (SelectedDrive.DiskSize < i*MB) {
|
|
|
|
SelectedDrive.ClusterSize[FS_FAT32].Default = 8*(ULONG)i;
|
|
|
|
break;
|
|
|
|
}
|
2011-12-13 02:10:27 +00:00
|
|
|
SelectedDrive.ClusterSize[FS_FAT32].Allowed <<= 1;
|
2011-12-01 02:56:44 +00:00
|
|
|
}
|
2011-12-13 02:10:27 +00:00
|
|
|
SelectedDrive.ClusterSize[FS_FAT32].Allowed &= 0x0001FE00;
|
|
|
|
|
|
|
|
// Default cluster sizes in the 256MB to 32 GB range do not follow the rule above
|
2012-11-03 17:40:33 +00:00
|
|
|
if ((SelectedDrive.DiskSize >= 256*MB) && (SelectedDrive.DiskSize < 32*GB)) {
|
2011-12-13 02:10:27 +00:00
|
|
|
for (i=8; i<=32; i<<=1) { // 256 MB -> 32 GB
|
|
|
|
if (SelectedDrive.DiskSize < i*GB) {
|
|
|
|
SelectedDrive.ClusterSize[FS_FAT32].Default = ((ULONG)i/2)*1024;
|
|
|
|
break;
|
|
|
|
}
|
2011-12-01 02:56:44 +00:00
|
|
|
}
|
|
|
|
}
|
2012-11-03 17:40:33 +00:00
|
|
|
// More adjustments for large drives
|
|
|
|
if (SelectedDrive.DiskSize >= 32*GB) {
|
|
|
|
SelectedDrive.ClusterSize[FS_FAT32].Allowed &= 0x0001C000;
|
|
|
|
SelectedDrive.ClusterSize[FS_FAT32].Default = 0x00008000;
|
|
|
|
}
|
2011-12-01 02:56:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (SelectedDrive.DiskSize < 256*TB) {
|
2013-07-08 23:14:29 +00:00
|
|
|
// NTFS
|
2011-12-01 02:56:44 +00:00
|
|
|
SelectedDrive.ClusterSize[FS_NTFS].Allowed = 0x0001FE00;
|
|
|
|
for (i=16; i<=256; i<<=1) { // 7 MB -> 256 TB
|
|
|
|
if (SelectedDrive.DiskSize < i*TB) {
|
|
|
|
SelectedDrive.ClusterSize[FS_NTFS].Default = ((ULONG)i/4)*1024;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-08 23:14:29 +00:00
|
|
|
// exFAT (requires KB955704 installed on XP => don't bother)
|
|
|
|
if (nWindowsVersion > WINDOWS_XP) {
|
|
|
|
SelectedDrive.ClusterSize[FS_EXFAT].Allowed = 0x03FFFE00;
|
|
|
|
if (SelectedDrive.DiskSize < 256*MB) // < 256 MB
|
|
|
|
SelectedDrive.ClusterSize[FS_EXFAT].Default = 4*1024;
|
|
|
|
else if (SelectedDrive.DiskSize < 32*GB) // < 32 GB
|
|
|
|
SelectedDrive.ClusterSize[FS_EXFAT].Default = 32*1024;
|
|
|
|
else
|
|
|
|
SelectedDrive.ClusterSize[FS_EXFAT].Default = 28*1024;
|
|
|
|
}
|
|
|
|
|
|
|
|
// UDF (only supported for Vista and later)
|
|
|
|
if (nWindowsVersion >= WINDOWS_VISTA) {
|
|
|
|
SelectedDrive.ClusterSize[FS_UDF].Allowed = 0x00000100;
|
|
|
|
SelectedDrive.ClusterSize[FS_UDF].Default = 1;
|
|
|
|
}
|
2014-03-29 00:22:54 +00:00
|
|
|
|
|
|
|
// ReFS (only supported for Windows 8.1 and later and for fixed disks)
|
|
|
|
if ((nWindowsVersion >= WINDOWS_8_1_OR_LATER) && (SelectedDrive.Geometry.MediaType == FixedMedia)) {
|
|
|
|
SelectedDrive.ClusterSize[FS_REFS].Allowed = 0x00000100;
|
|
|
|
SelectedDrive.ClusterSize[FS_REFS].Default = 1;
|
|
|
|
}
|
2011-12-01 02:56:44 +00:00
|
|
|
}
|
|
|
|
|
2011-12-01 15:01:10 +00:00
|
|
|
out:
|
|
|
|
// Only add the filesystems we can service
|
|
|
|
for (fs=0; fs<FS_MAX; fs++) {
|
|
|
|
if (SelectedDrive.ClusterSize[fs].Allowed != 0) {
|
2013-01-09 23:24:31 +00:00
|
|
|
tmp[0] = 0;
|
|
|
|
// Tell the user if we're going to use Large FAT32 or regular
|
2013-11-25 22:34:26 +00:00
|
|
|
if ((fs == FS_FAT32) && ((SelectedDrive.DiskSize > LARGE_FAT32_SIZE) || (force_large_fat32)))
|
2013-01-09 23:24:31 +00:00
|
|
|
safe_strcat(tmp, sizeof(tmp), "Large ");
|
|
|
|
safe_strcat(tmp, sizeof(tmp), FileSystemLabel[fs]);
|
2011-12-01 15:01:10 +00:00
|
|
|
if (default_fs == FS_UNKNOWN) {
|
2013-10-15 21:58:27 +00:00
|
|
|
entry = lmprintf(MSG_030, tmp);
|
2011-12-01 15:01:10 +00:00
|
|
|
default_fs = fs;
|
2013-10-15 21:58:27 +00:00
|
|
|
} else {
|
|
|
|
entry = tmp;
|
2011-12-01 15:01:10 +00:00
|
|
|
}
|
2013-12-27 16:06:59 +00:00
|
|
|
IGNORE_RETVAL(ComboBox_SetItemData(hFileSystem,
|
2013-10-15 21:58:27 +00:00
|
|
|
ComboBox_AddStringU(hFileSystem, entry), fs));
|
2011-12-01 15:01:10 +00:00
|
|
|
r = TRUE;
|
|
|
|
}
|
|
|
|
}
|
2011-12-01 02:56:44 +00:00
|
|
|
|
2011-12-01 15:01:10 +00:00
|
|
|
return r;
|
2011-12-01 02:56:44 +00:00
|
|
|
}
|
|
|
|
#undef KB
|
|
|
|
#undef MB
|
|
|
|
#undef GB
|
|
|
|
#undef TB
|
|
|
|
|
2011-12-01 17:54:35 +00:00
|
|
|
/*
|
|
|
|
* Populate the Allocation unit size field
|
|
|
|
*/
|
2011-12-01 15:01:10 +00:00
|
|
|
static BOOL SetClusterSizes(int FSType)
|
2011-11-28 20:05:34 +00:00
|
|
|
{
|
2013-10-15 21:58:27 +00:00
|
|
|
char* szClustSize;
|
2011-12-13 02:10:27 +00:00
|
|
|
int i, k, default_index = 0;
|
2011-12-01 02:56:44 +00:00
|
|
|
ULONG j;
|
|
|
|
|
2011-11-28 20:05:34 +00:00
|
|
|
IGNORE_RETVAL(ComboBox_ResetContent(hClusterSize));
|
2011-12-01 02:56:44 +00:00
|
|
|
|
2011-12-01 15:01:10 +00:00
|
|
|
if ((FSType < 0) || (FSType >= FS_MAX)) {
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2011-12-01 02:56:44 +00:00
|
|
|
if ( (SelectedDrive.ClusterSize[FSType].Allowed == 0)
|
|
|
|
|| (SelectedDrive.ClusterSize[FSType].Default == 0) ) {
|
|
|
|
uprintf("The drive is incompatible with FS type #%d\n", FSType);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2013-07-08 23:14:29 +00:00
|
|
|
for(i=0,j=0x100,k=0;j<0x10000000;i++,j<<=1) {
|
2011-12-01 02:56:44 +00:00
|
|
|
if (j & SelectedDrive.ClusterSize[FSType].Allowed) {
|
2011-12-04 20:13:51 +00:00
|
|
|
if (j == SelectedDrive.ClusterSize[FSType].Default) {
|
2013-10-15 21:58:27 +00:00
|
|
|
szClustSize = lmprintf(MSG_030, ClusterSizeLabel[i]);
|
2011-12-13 02:10:27 +00:00
|
|
|
default_index = k;
|
2013-10-15 21:58:27 +00:00
|
|
|
} else {
|
|
|
|
szClustSize = ClusterSizeLabel[i];
|
2011-12-04 20:13:51 +00:00
|
|
|
}
|
|
|
|
IGNORE_RETVAL(ComboBox_SetItemData(hClusterSize, ComboBox_AddStringU(hClusterSize, szClustSize), j));
|
2011-12-13 02:10:27 +00:00
|
|
|
k++;
|
2011-12-01 02:56:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-04 20:13:51 +00:00
|
|
|
IGNORE_RETVAL(ComboBox_SetCurSel(hClusterSize, default_index));
|
2011-12-01 02:56:44 +00:00
|
|
|
return TRUE;
|
2011-11-28 20:05:34 +00:00
|
|
|
}
|
|
|
|
|
2011-11-18 21:46:34 +00:00
|
|
|
/*
|
2011-11-24 02:24:50 +00:00
|
|
|
* Fill the drive properties (size, FS, etc)
|
2011-11-18 21:46:34 +00:00
|
|
|
*/
|
2014-03-01 00:09:40 +00:00
|
|
|
static BOOL SetDriveInfo(int ComboIndex)
|
2011-11-18 21:46:34 +00:00
|
|
|
{
|
2013-01-24 21:30:11 +00:00
|
|
|
DWORD i;
|
2014-03-01 00:09:40 +00:00
|
|
|
int pt, bt;
|
2013-01-24 21:30:11 +00:00
|
|
|
char fs_type[32];
|
2011-11-18 21:46:34 +00:00
|
|
|
|
2013-01-20 22:46:11 +00:00
|
|
|
memset(&SelectedDrive, 0, sizeof(SelectedDrive));
|
2013-01-22 02:40:43 +00:00
|
|
|
SelectedDrive.DeviceNumber = (DWORD)ComboBox_GetItemData(hDeviceList, ComboIndex);
|
2011-11-18 21:46:34 +00:00
|
|
|
|
2014-01-14 20:17:07 +00:00
|
|
|
SelectedDrive.nPartitions = GetDrivePartitionData(SelectedDrive.DeviceNumber, fs_type, sizeof(fs_type));
|
2011-11-18 21:46:34 +00:00
|
|
|
|
2011-12-01 15:01:10 +00:00
|
|
|
if (!DefineClusterSizes()) {
|
2013-06-06 22:40:37 +00:00
|
|
|
uprintf("No file system is selectable for this drive\n");
|
2011-12-01 15:01:10 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
2011-11-25 01:30:41 +00:00
|
|
|
|
2011-12-01 15:01:10 +00:00
|
|
|
// re-select existing FS if it's one we know
|
2013-01-24 21:30:11 +00:00
|
|
|
SelectedDrive.FSType = FS_UNKNOWN;
|
|
|
|
if (safe_strlen(fs_type) != 0) {
|
2011-12-01 15:01:10 +00:00
|
|
|
for (SelectedDrive.FSType=FS_MAX-1; SelectedDrive.FSType>=0; SelectedDrive.FSType--) {
|
|
|
|
if (safe_strcmp(fs_type, FileSystemLabel[SelectedDrive.FSType]) == 0) {
|
2011-11-24 23:49:42 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2011-12-01 15:01:10 +00:00
|
|
|
} else {
|
|
|
|
SelectedDrive.FSType = FS_UNKNOWN;
|
2011-11-19 01:30:20 +00:00
|
|
|
}
|
|
|
|
|
2011-12-01 15:01:10 +00:00
|
|
|
for (i=0; i<ComboBox_GetCount(hFileSystem); i++) {
|
|
|
|
if (ComboBox_GetItemData(hFileSystem, i) == SelectedDrive.FSType) {
|
|
|
|
IGNORE_RETVAL(ComboBox_SetCurSel(hFileSystem, i));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i == ComboBox_GetCount(hFileSystem)) {
|
|
|
|
// failed to reselect => pick default
|
|
|
|
for (i=0; i<ComboBox_GetCount(hFileSystem); i++) {
|
|
|
|
if (ComboBox_GetItemData(hFileSystem, i) == default_fs) {
|
|
|
|
IGNORE_RETVAL(ComboBox_SetCurSel(hFileSystem, i));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-01 00:09:40 +00:00
|
|
|
for (i=0; i<3; i++) {
|
|
|
|
// Populate MBR/BIOS, MBR/UEFI and GPT/UEFI targets, with an exception
|
|
|
|
// for XP, as it doesn't support GPT at all
|
|
|
|
if ((i == 2) && (nWindowsVersion <= WINDOWS_XP))
|
|
|
|
continue;
|
|
|
|
bt = (i==0)?BT_BIOS:BT_UEFI;
|
|
|
|
pt = (i==2)?PARTITION_STYLE_GPT:PARTITION_STYLE_MBR;
|
|
|
|
IGNORE_RETVAL(ComboBox_SetItemData(hPartitionScheme, ComboBox_AddStringU(hPartitionScheme,
|
|
|
|
lmprintf((i==0)?MSG_031:MSG_033, PartitionTypeLabel[pt])), (bt<<16)|pt));
|
|
|
|
}
|
|
|
|
|
2011-12-01 15:01:10 +00:00
|
|
|
// At least one filesystem is go => enable formatting
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_START), TRUE);
|
|
|
|
|
|
|
|
return SetClusterSizes((int)ComboBox_GetItemData(hFileSystem, ComboBox_GetCurSel(hFileSystem)));
|
2011-11-18 21:46:34 +00:00
|
|
|
}
|
|
|
|
|
2012-02-16 11:37:59 +00:00
|
|
|
static void SetFSFromISO(void)
|
|
|
|
{
|
2012-03-03 23:12:48 +00:00
|
|
|
int i, fs, selected_fs = FS_UNKNOWN;
|
|
|
|
uint32_t fs_mask = 0;
|
2013-01-20 22:46:11 +00:00
|
|
|
int bt = GETBIOSTYPE((int)ComboBox_GetItemData(hPartitionScheme, ComboBox_GetCurSel(hPartitionScheme)));
|
2012-02-16 11:37:59 +00:00
|
|
|
|
|
|
|
if (iso_path == NULL)
|
|
|
|
return;
|
|
|
|
|
2012-03-03 23:12:48 +00:00
|
|
|
// Create a mask of all the FS's available
|
|
|
|
for (i=0; i<ComboBox_GetCount(hFileSystem); i++) {
|
2012-02-16 23:40:31 +00:00
|
|
|
fs = (int)ComboBox_GetItemData(hFileSystem, i);
|
2012-03-03 23:12:48 +00:00
|
|
|
fs_mask |= 1<<fs;
|
|
|
|
}
|
|
|
|
|
2013-01-20 22:46:11 +00:00
|
|
|
// Syslinux and EFI have precedence over bootmgr (unless the user selected BIOS as target type)
|
2014-01-21 17:08:41 +00:00
|
|
|
if ((HAS_SYSLINUX(iso_report)) || (IS_REACTOS(iso_report)) || ( (IS_EFI(iso_report)) && (bt == BT_UEFI))) {
|
2012-03-03 23:12:48 +00:00
|
|
|
if (fs_mask & (1<<FS_FAT32)) {
|
|
|
|
selected_fs = FS_FAT32;
|
|
|
|
} else if (fs_mask & (1<<FS_FAT16)) {
|
|
|
|
selected_fs = FS_FAT16;
|
|
|
|
}
|
2012-03-27 22:31:58 +00:00
|
|
|
} else if ((iso_report.has_bootmgr) || (IS_WINPE(iso_report.winpe))) {
|
2012-03-03 23:12:48 +00:00
|
|
|
if (fs_mask & (1<<FS_NTFS)) {
|
|
|
|
selected_fs = FS_NTFS;
|
2012-02-16 11:37:59 +00:00
|
|
|
}
|
|
|
|
}
|
2012-03-03 23:12:48 +00:00
|
|
|
|
|
|
|
// Try to select the FS
|
|
|
|
for (i=0; i<ComboBox_GetCount(hFileSystem); i++) {
|
|
|
|
fs = (int)ComboBox_GetItemData(hFileSystem, i);
|
|
|
|
if (fs == selected_fs)
|
|
|
|
IGNORE_RETVAL(ComboBox_SetCurSel(hFileSystem, i));
|
|
|
|
}
|
|
|
|
|
2012-02-16 11:37:59 +00:00
|
|
|
SendMessage(hMainDialog, WM_COMMAND, (CBN_SELCHANGE<<16) | IDC_FILESYSTEM,
|
|
|
|
ComboBox_GetCurSel(hFileSystem));
|
|
|
|
}
|
|
|
|
|
2013-02-04 23:15:11 +00:00
|
|
|
static void SetMBRProps(void)
|
2012-05-16 22:38:39 +00:00
|
|
|
{
|
2012-11-03 17:40:33 +00:00
|
|
|
int fs = (int)ComboBox_GetItemData(hFileSystem, ComboBox_GetCurSel(hFileSystem));
|
2013-01-24 21:30:11 +00:00
|
|
|
int dt = (int)ComboBox_GetItemData(hBootType, ComboBox_GetCurSel(hBootType));
|
2012-05-25 16:54:06 +00:00
|
|
|
BOOL needs_masquerading = (IS_WINPE(iso_report.winpe) && (!iso_report.uses_minint));
|
2012-05-16 22:38:39 +00:00
|
|
|
|
2012-05-25 16:54:06 +00:00
|
|
|
if ((!mbr_selected_by_user) && ((iso_path == NULL) || (dt != DT_ISO) || (fs != FS_NTFS))) {
|
2012-05-16 22:38:39 +00:00
|
|
|
CheckDlgButton(hMainDialog, IDC_RUFUS_MBR, BST_UNCHECKED);
|
|
|
|
IGNORE_RETVAL(ComboBox_SetCurSel(hDiskID, 0));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-03-14 23:13:04 +00:00
|
|
|
uMBRChecked = (needs_masquerading || iso_report.has_bootmgr || mbr_selected_by_user)?BST_CHECKED:BST_UNCHECKED;
|
|
|
|
if (IsWindowEnabled(GetDlgItem(hMainDialog, IDC_RUFUS_MBR)))
|
|
|
|
CheckDlgButton(hMainDialog, IDC_RUFUS_MBR, uMBRChecked);
|
2012-05-16 22:38:39 +00:00
|
|
|
IGNORE_RETVAL(ComboBox_SetCurSel(hDiskID, needs_masquerading?1:0));
|
|
|
|
}
|
|
|
|
|
2014-03-15 14:14:10 +00:00
|
|
|
static void EnableAdvancedBootOptions(BOOL enable, BOOL remove_checkboxes)
|
2012-05-25 16:54:06 +00:00
|
|
|
{
|
2013-02-04 23:15:11 +00:00
|
|
|
int bt = GETBIOSTYPE((int)ComboBox_GetItemData(hPartitionScheme, ComboBox_GetCurSel(hPartitionScheme)));
|
2014-03-15 14:14:10 +00:00
|
|
|
BOOL actual_enable = ((bt==BT_UEFI)||(selection_default>=DT_IMG)||!IsChecked(IDC_BOOT))?FALSE:enable;
|
2014-03-14 23:13:04 +00:00
|
|
|
static UINT uXPartChecked = BST_UNCHECKED;
|
|
|
|
|
2014-03-15 14:14:10 +00:00
|
|
|
if (remove_checkboxes) {
|
|
|
|
// Store/Restore the checkbox states
|
|
|
|
if (IsWindowEnabled(GetDlgItem(hMainDialog, IDC_RUFUS_MBR)) && !actual_enable) {
|
|
|
|
uMBRChecked = IsChecked(IDC_RUFUS_MBR);
|
|
|
|
CheckDlgButton(hMainDialog, IDC_RUFUS_MBR, BST_UNCHECKED);
|
|
|
|
uXPartChecked = IsChecked(IDC_EXTRA_PARTITION);
|
|
|
|
CheckDlgButton(hMainDialog, IDC_EXTRA_PARTITION, BST_UNCHECKED);
|
|
|
|
} else if (!IsWindowEnabled(GetDlgItem(hMainDialog, IDC_RUFUS_MBR)) && actual_enable) {
|
|
|
|
CheckDlgButton(hMainDialog, IDC_RUFUS_MBR, uMBRChecked);
|
|
|
|
CheckDlgButton(hMainDialog, IDC_EXTRA_PARTITION, uXPartChecked);
|
|
|
|
}
|
2014-03-14 23:13:04 +00:00
|
|
|
}
|
2013-02-04 23:15:11 +00:00
|
|
|
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_EXTRA_PARTITION), actual_enable);
|
2014-03-14 23:13:04 +00:00
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_RUFUS_MBR), actual_enable);
|
2013-02-04 23:15:11 +00:00
|
|
|
EnableWindow(hDiskID, actual_enable);
|
|
|
|
}
|
|
|
|
|
2014-03-15 14:14:10 +00:00
|
|
|
static void EnableBootOptions(BOOL enable, BOOL remove_checkboxes)
|
2013-02-04 23:15:11 +00:00
|
|
|
{
|
|
|
|
int fs = (int)ComboBox_GetItemData(hFileSystem, ComboBox_GetCurSel(hFileSystem));
|
2014-03-14 23:13:04 +00:00
|
|
|
BOOL actual_enable = ((fs != FS_FAT16) && (fs != FS_FAT32) && (fs != FS_NTFS) && (selection_default == DT_IMG))?FALSE:enable;
|
2013-02-04 23:15:11 +00:00
|
|
|
|
|
|
|
EnableWindow(hBoot, actual_enable);
|
|
|
|
EnableWindow(hBootType, actual_enable);
|
|
|
|
EnableWindow(hSelectISO, actual_enable);
|
2014-03-15 14:14:10 +00:00
|
|
|
EnableAdvancedBootOptions(actual_enable, remove_checkboxes);
|
2012-05-25 16:54:06 +00:00
|
|
|
}
|
|
|
|
|
2013-01-27 01:40:09 +00:00
|
|
|
static void SetPartitionSchemeTooltip(void)
|
|
|
|
{
|
2014-03-14 23:13:04 +00:00
|
|
|
int bt = GETBIOSTYPE((int)ComboBox_GetItemData(hPartitionScheme, ComboBox_GetCurSel(hPartitionScheme)));
|
|
|
|
int pt = GETPARTTYPE((int)ComboBox_GetItemData(hPartitionScheme, ComboBox_GetCurSel(hPartitionScheme)));
|
2013-01-27 01:40:09 +00:00
|
|
|
if (bt == BT_BIOS) {
|
2013-10-15 21:58:27 +00:00
|
|
|
CreateTooltip(hPartitionScheme, lmprintf(MSG_150), 15000);
|
2013-01-27 01:40:09 +00:00
|
|
|
} else {
|
|
|
|
if (pt == PARTITION_STYLE_MBR) {
|
2013-10-15 21:58:27 +00:00
|
|
|
CreateTooltip(hPartitionScheme, lmprintf(MSG_151), 15000);
|
2013-01-27 01:40:09 +00:00
|
|
|
} else {
|
2013-10-15 21:58:27 +00:00
|
|
|
CreateTooltip(hPartitionScheme, lmprintf(MSG_152), 15000);
|
2013-01-27 01:40:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-12-22 20:48:57 +00:00
|
|
|
static void SetTargetSystem(void)
|
|
|
|
{
|
|
|
|
int ts;
|
|
|
|
|
|
|
|
if (SelectedDrive.PartitionType == PARTITION_STYLE_GPT) {
|
|
|
|
ts = 2; // GPT/UEFI
|
|
|
|
} else if (SelectedDrive.has_protective_mbr || SelectedDrive.has_mbr_uefi_marker || (IS_EFI(iso_report) &&
|
2014-01-21 17:08:41 +00:00
|
|
|
(!HAS_SYSLINUX(iso_report)) && (!iso_report.has_bootmgr) && (!IS_WINPE(iso_report.winpe))) ) {
|
2013-12-22 20:48:57 +00:00
|
|
|
ts = 1; // MBR/UEFI
|
|
|
|
} else {
|
|
|
|
ts = 0; // MBR/BIOS|UEFI
|
|
|
|
}
|
|
|
|
IGNORE_RETVAL(ComboBox_SetCurSel(hPartitionScheme, ts));
|
|
|
|
SetPartitionSchemeTooltip();
|
|
|
|
}
|
|
|
|
|
2011-11-21 17:06:17 +00:00
|
|
|
/*
|
|
|
|
* Populate the UI properties
|
|
|
|
*/
|
2011-11-24 02:24:50 +00:00
|
|
|
static BOOL PopulateProperties(int ComboIndex)
|
2011-11-18 21:46:34 +00:00
|
|
|
{
|
2014-03-01 00:09:40 +00:00
|
|
|
const char no_label[] = STR_NO_LABEL;
|
2013-11-30 17:39:38 +00:00
|
|
|
char* device_tooltip;
|
2011-11-18 21:46:34 +00:00
|
|
|
|
2013-01-18 01:39:24 +00:00
|
|
|
IGNORE_RETVAL(ComboBox_ResetContent(hPartitionScheme));
|
2011-11-19 01:30:20 +00:00
|
|
|
IGNORE_RETVAL(ComboBox_ResetContent(hFileSystem));
|
2011-11-28 20:05:34 +00:00
|
|
|
IGNORE_RETVAL(ComboBox_ResetContent(hClusterSize));
|
2011-12-01 15:01:10 +00:00
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_START), FALSE);
|
2011-11-24 02:24:50 +00:00
|
|
|
SetWindowTextA(hLabel, "");
|
|
|
|
memset(&SelectedDrive, 0, sizeof(SelectedDrive));
|
|
|
|
|
2012-05-25 16:54:06 +00:00
|
|
|
if (ComboIndex < 0)
|
2011-11-18 23:41:28 +00:00
|
|
|
return TRUE;
|
|
|
|
|
2014-03-01 00:09:40 +00:00
|
|
|
if (!SetDriveInfo(ComboIndex)) // This also populates FS
|
2011-11-18 21:46:34 +00:00
|
|
|
return FALSE;
|
2013-12-22 20:48:57 +00:00
|
|
|
SetTargetSystem();
|
|
|
|
SetFSFromISO();
|
2014-03-15 14:14:10 +00:00
|
|
|
EnableBootOptions(TRUE, TRUE);
|
2011-11-24 20:02:14 +00:00
|
|
|
|
2012-02-21 19:46:28 +00:00
|
|
|
// Set a proposed label according to the size (eg: "256MB", "8GB")
|
2014-03-01 00:09:40 +00:00
|
|
|
safe_sprintf(SelectedDrive.proposed_label, sizeof(SelectedDrive.proposed_label),
|
|
|
|
SizeToHumanReadable(SelectedDrive.DiskSize, FALSE, TRUE));
|
2012-02-21 19:46:28 +00:00
|
|
|
|
2013-11-30 17:39:38 +00:00
|
|
|
// Add a tooltip (with the size of the device in parenthesis)
|
2014-03-01 00:09:40 +00:00
|
|
|
device_tooltip = (char*) malloc(safe_strlen(DriveID.String[ComboIndex]) + 16);
|
|
|
|
if (device_tooltip != NULL) {
|
|
|
|
safe_sprintf(device_tooltip, safe_strlen(DriveID.String[ComboIndex]) + 16, "%s (%s)",
|
|
|
|
DriveID.String[ComboIndex], SizeToHumanReadable(SelectedDrive.DiskSize, FALSE, FALSE));
|
2013-11-30 17:39:38 +00:00
|
|
|
CreateTooltip(hDeviceList, device_tooltip, -1);
|
2014-03-01 00:09:40 +00:00
|
|
|
free(device_tooltip);
|
|
|
|
}
|
2013-11-30 17:39:38 +00:00
|
|
|
|
2012-02-16 11:37:59 +00:00
|
|
|
// If no existing label is available and no ISO is selected, propose one according to the size (eg: "256MB", "8GB")
|
|
|
|
if ((iso_path == NULL) || (iso_report.label[0] == 0)) {
|
2014-01-22 01:28:25 +00:00
|
|
|
if ( (safe_stricmp(no_label, DriveLabel.String[ComboIndex]) == 0)
|
|
|
|
|| (safe_stricmp(lmprintf(MSG_207), DriveLabel.String[ComboIndex]) == 0) ) {
|
2012-02-21 19:46:28 +00:00
|
|
|
SetWindowTextU(hLabel, SelectedDrive.proposed_label);
|
2011-11-24 20:02:14 +00:00
|
|
|
} else {
|
2014-01-22 01:28:25 +00:00
|
|
|
SetWindowTextU(hLabel, DriveLabel.String[ComboIndex]);
|
2011-11-24 02:24:50 +00:00
|
|
|
}
|
|
|
|
} else {
|
2012-02-16 11:37:59 +00:00
|
|
|
SetWindowTextU(hLabel, iso_report.label);
|
2011-11-24 02:24:50 +00:00
|
|
|
}
|
|
|
|
|
2011-11-18 21:46:34 +00:00
|
|
|
return TRUE;
|
2011-11-17 01:43:06 +00:00
|
|
|
}
|
2011-11-13 20:53:23 +00:00
|
|
|
|
|
|
|
/*
|
2011-11-21 17:06:17 +00:00
|
|
|
* Refresh the list of USB devices
|
2011-11-13 20:53:23 +00:00
|
|
|
*/
|
2012-02-16 23:40:31 +00:00
|
|
|
static BOOL GetUSBDevices(DWORD devnum)
|
2011-11-17 01:43:06 +00:00
|
|
|
{
|
2014-01-07 21:21:45 +00:00
|
|
|
// The first two are standard Microsoft drivers (including the Windows 8 UASP one).
|
|
|
|
// The rest are the vendor UASP drivers I know of so far - list may be incomplete!
|
|
|
|
const char* usbstor_name[] = { "USBSTOR", "UASPSTOR", "VUSBSTOR", "EtronSTOR" };
|
|
|
|
const char* scsi_name = "SCSI";
|
2014-01-14 20:17:07 +00:00
|
|
|
char letter_name[] = " (?:)";
|
2014-02-25 19:13:49 +00:00
|
|
|
BOOL found = FALSE, is_SCSI, is_UASP;
|
2011-11-17 01:43:06 +00:00
|
|
|
HDEVINFO dev_info = NULL;
|
|
|
|
SP_DEVINFO_DATA dev_info_data;
|
|
|
|
SP_DEVICE_INTERFACE_DATA devint_data;
|
|
|
|
PSP_DEVICE_INTERFACE_DETAIL_DATA_A devint_detail_data;
|
2013-11-13 00:14:03 +00:00
|
|
|
DEVINST parent_inst, device_inst;
|
2013-11-17 01:39:43 +00:00
|
|
|
DWORD size, i, j, k, datatype, drive_index;
|
2014-01-07 21:21:45 +00:00
|
|
|
ULONG list_size[ARRAYSIZE(usbstor_name)], full_list_size;
|
2011-11-17 01:43:06 +00:00
|
|
|
HANDLE hDrive;
|
2012-03-01 19:19:12 +00:00
|
|
|
LONG maxwidth = 0;
|
|
|
|
RECT rect;
|
2014-02-27 19:53:53 +00:00
|
|
|
int s, score, drive_number;
|
2014-01-14 20:17:07 +00:00
|
|
|
char drive_letters[27], *devid, *devid_list = NULL, entry_msg[128];
|
2013-11-13 00:14:03 +00:00
|
|
|
char *label, *entry, buffer[MAX_PATH], str[sizeof("0000:0000")+1];
|
|
|
|
uint16_t vid, pid;
|
2011-12-02 00:14:09 +00:00
|
|
|
GUID _GUID_DEVINTERFACE_DISK = // only known to some...
|
|
|
|
{ 0x53f56307L, 0xb6bf, 0x11d0, {0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b} };
|
2011-11-17 01:43:06 +00:00
|
|
|
|
|
|
|
IGNORE_RETVAL(ComboBox_ResetContent(hDeviceList));
|
2011-11-21 20:12:23 +00:00
|
|
|
StrArrayClear(&DriveID);
|
2011-11-24 02:24:50 +00:00
|
|
|
StrArrayClear(&DriveLabel);
|
2012-03-01 19:19:12 +00:00
|
|
|
GetClientRect(hDeviceList, &rect);
|
2011-11-17 01:43:06 +00:00
|
|
|
|
2011-12-02 00:14:09 +00:00
|
|
|
dev_info = SetupDiGetClassDevsA(&_GUID_DEVINTERFACE_DISK, NULL, NULL, DIGCF_PRESENT|DIGCF_DEVICEINTERFACE);
|
2011-11-17 01:43:06 +00:00
|
|
|
if (dev_info == INVALID_HANDLE_VALUE) {
|
2012-03-09 01:38:52 +00:00
|
|
|
uprintf("SetupDiGetClassDevs (Interface) failed: %s\n", WindowsErrorString());
|
2011-11-17 01:43:06 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2014-01-07 21:21:45 +00:00
|
|
|
full_list_size = 0;
|
|
|
|
for (s=0; s<ARRAYSIZE(usbstor_name); s++) {
|
|
|
|
// Get a list of hardware IDs for all USB storage devices
|
|
|
|
// This will be used to retrieve the VID:PID of our devices
|
|
|
|
CM_Get_Device_ID_List_SizeA(&list_size[s], usbstor_name[s], CM_GETIDLIST_FILTER_SERVICE);
|
|
|
|
if (list_size[s] != 0)
|
|
|
|
full_list_size += list_size[s]-1; // remove extra NUL terminator
|
|
|
|
}
|
|
|
|
full_list_size += 1; // add extra NUL terminator
|
|
|
|
if (full_list_size < 2)
|
2013-11-13 00:14:03 +00:00
|
|
|
return FALSE;
|
2014-01-07 21:21:45 +00:00
|
|
|
devid_list = (char*)malloc(full_list_size);
|
2013-11-13 00:14:03 +00:00
|
|
|
if (devid_list == NULL) {
|
|
|
|
uprintf("Could not allocate Dev ID list\n");
|
|
|
|
return FALSE;
|
|
|
|
}
|
2014-01-07 21:21:45 +00:00
|
|
|
|
|
|
|
// Build a single list from all the storage enumerators we know of
|
|
|
|
for (s=0, i=0; s<ARRAYSIZE(usbstor_name); s++) {
|
|
|
|
if (list_size[s] > 1) {
|
|
|
|
CM_Get_Device_ID_ListA(usbstor_name[s], &devid_list[i], list_size[s], CM_GETIDLIST_FILTER_SERVICE);
|
|
|
|
i += list_size[s]-1;
|
|
|
|
}
|
|
|
|
}
|
2013-11-13 00:14:03 +00:00
|
|
|
|
2011-11-17 01:43:06 +00:00
|
|
|
dev_info_data.cbSize = sizeof(dev_info_data);
|
|
|
|
for (i=0; SetupDiEnumDeviceInfo(dev_info, i, &dev_info_data); i++) {
|
|
|
|
memset(buffer, 0, sizeof(buffer));
|
|
|
|
if (!SetupDiGetDeviceRegistryPropertyA(dev_info, &dev_info_data, SPDRP_ENUMERATOR_NAME,
|
|
|
|
&datatype, (LPBYTE)buffer, sizeof(buffer), &size)) {
|
2012-03-09 01:38:52 +00:00
|
|
|
uprintf("SetupDiGetDeviceRegistryProperty (Enumerator Name) failed: %s\n", WindowsErrorString());
|
2011-11-17 01:43:06 +00:00
|
|
|
continue;
|
|
|
|
}
|
2014-01-07 21:21:45 +00:00
|
|
|
// UASP drives are listed under SCSI (along with regular SYSTEM drives => "DANGER, WILL ROBINSON!!!")
|
|
|
|
is_SCSI = (safe_stricmp(buffer, scsi_name) == 0);
|
|
|
|
if ((safe_stricmp(buffer, usbstor_name[0]) != 0) && (!is_SCSI))
|
2011-11-17 01:43:06 +00:00
|
|
|
continue;
|
|
|
|
memset(buffer, 0, sizeof(buffer));
|
2013-11-13 00:14:03 +00:00
|
|
|
vid = 0; pid = 0;
|
2014-01-07 21:21:45 +00:00
|
|
|
is_UASP = FALSE;
|
2011-11-17 01:43:06 +00:00
|
|
|
if (!SetupDiGetDeviceRegistryPropertyA(dev_info, &dev_info_data, SPDRP_FRIENDLYNAME,
|
|
|
|
&datatype, (LPBYTE)buffer, sizeof(buffer), &size)) {
|
2012-03-09 01:38:52 +00:00
|
|
|
uprintf("SetupDiGetDeviceRegistryProperty (Friendly Name) failed: %s\n", WindowsErrorString());
|
2013-11-13 00:14:03 +00:00
|
|
|
// We can afford a failure on this call - just replace the name with "USB Storage Device (Generic)"
|
2013-10-15 21:58:27 +00:00
|
|
|
safe_strcpy(buffer, sizeof(buffer), lmprintf(MSG_045));
|
2013-11-13 00:14:03 +00:00
|
|
|
} else {
|
|
|
|
// Get the VID:PID of the device. We could avoid doing this lookup every time by keeping
|
|
|
|
// a lookup table, but there shouldn't be that many USB storage devices connected...
|
2013-11-14 01:21:50 +00:00
|
|
|
for (devid = devid_list; *devid; devid += strlen(devid) + 1) {
|
2013-11-13 00:14:03 +00:00
|
|
|
if ( (CM_Locate_DevNodeA(&parent_inst, devid, 0) == 0)
|
|
|
|
&& (CM_Get_Child(&device_inst, parent_inst, 0) == 0)
|
|
|
|
&& (device_inst == dev_info_data.DevInst) ) {
|
2014-01-07 21:21:45 +00:00
|
|
|
BOOL post_backslash = FALSE;
|
|
|
|
// If we're not dealing with the USBSTOR part of our list, then this is an UASP device
|
|
|
|
is_UASP = ((((uintptr_t)devid)+2) >= ((uintptr_t)devid_list)+list_size[0]);
|
2013-11-13 00:14:03 +00:00
|
|
|
for (j=0, k=0; (j<strlen(devid))&&(k<2); j++) {
|
2014-01-07 21:21:45 +00:00
|
|
|
// The ID is in the form USB_VENDOR_BUSID\VID_xxxx&PID_xxxx\...
|
|
|
|
if (devid[j] == '\\')
|
|
|
|
post_backslash = TRUE;
|
|
|
|
if (!post_backslash)
|
|
|
|
continue;
|
2013-11-13 00:14:03 +00:00
|
|
|
if (devid[j] == '_') {
|
|
|
|
pid = (uint16_t)strtoul(&devid[j+1], NULL, 16);
|
|
|
|
// We could have used a vid_pid[] table, but keeping vid/pid separate is clearer
|
|
|
|
if (k++==0) vid = pid;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-11-17 01:43:06 +00:00
|
|
|
}
|
2014-01-07 21:21:45 +00:00
|
|
|
if ((vid == 0) && (pid == 0)) {
|
|
|
|
if (is_SCSI) {
|
|
|
|
// If we have an SCSI drive and couldn't get a VID:PID, we are most likely
|
|
|
|
// dealing with a system drive => eliminate it!
|
|
|
|
continue;
|
|
|
|
}
|
2013-11-13 00:14:03 +00:00
|
|
|
safe_strcpy(str, sizeof(str), "????:????"); // Couldn't figure VID:PID
|
2014-01-07 21:21:45 +00:00
|
|
|
} else {
|
2013-11-13 00:14:03 +00:00
|
|
|
safe_sprintf(str, sizeof(str), "%04X:%04X", vid, pid);
|
2014-01-07 21:21:45 +00:00
|
|
|
}
|
|
|
|
uprintf("Found %s device '%s' (%s)\n", is_UASP?"UAS":"USB", buffer, str);
|
2011-11-17 01:43:06 +00:00
|
|
|
|
|
|
|
devint_data.cbSize = sizeof(devint_data);
|
2011-11-18 01:58:08 +00:00
|
|
|
hDrive = INVALID_HANDLE_VALUE;
|
2011-11-17 01:43:06 +00:00
|
|
|
devint_detail_data = NULL;
|
2011-11-18 01:58:08 +00:00
|
|
|
for (j=0; ;j++) {
|
|
|
|
safe_closehandle(hDrive);
|
|
|
|
safe_free(devint_detail_data);
|
|
|
|
|
2011-12-02 00:14:09 +00:00
|
|
|
if (!SetupDiEnumDeviceInterfaces(dev_info, &dev_info_data, &_GUID_DEVINTERFACE_DISK, j, &devint_data)) {
|
2011-11-17 01:43:06 +00:00
|
|
|
if(GetLastError() != ERROR_NO_MORE_ITEMS) {
|
2011-11-21 17:06:17 +00:00
|
|
|
uprintf("SetupDiEnumDeviceInterfaces failed: %s\n", WindowsErrorString());
|
2013-04-07 23:10:58 +00:00
|
|
|
} else {
|
2013-11-14 01:21:50 +00:00
|
|
|
uprintf("A device was eliminated because it didn't report itself as a disk\n");
|
2011-11-17 01:43:06 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!SetupDiGetDeviceInterfaceDetailA(dev_info, &devint_data, NULL, 0, &size, NULL)) {
|
|
|
|
if(GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
|
|
|
|
devint_detail_data = (PSP_DEVICE_INTERFACE_DETAIL_DATA_A)calloc(1, size);
|
|
|
|
if (devint_detail_data == NULL) {
|
2013-06-06 22:40:37 +00:00
|
|
|
uprintf("Unable to allocate data for SP_DEVICE_INTERFACE_DETAIL_DATA\n");
|
2011-11-17 01:43:06 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
devint_detail_data->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A);
|
|
|
|
} else {
|
2011-11-21 17:06:17 +00:00
|
|
|
uprintf("SetupDiGetDeviceInterfaceDetail (dummy) failed: %s\n", WindowsErrorString());
|
2011-11-17 01:43:06 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2013-01-09 21:54:28 +00:00
|
|
|
if (devint_detail_data == NULL) {
|
|
|
|
uprintf("SetupDiGetDeviceInterfaceDetail (dummy) - no data was allocated\n");
|
|
|
|
continue;
|
|
|
|
}
|
2011-11-17 01:43:06 +00:00
|
|
|
if(!SetupDiGetDeviceInterfaceDetailA(dev_info, &devint_data, devint_detail_data, size, &size, NULL)) {
|
2011-11-21 17:06:17 +00:00
|
|
|
uprintf("SetupDiGetDeviceInterfaceDetail (actual) failed: %s\n", WindowsErrorString());
|
2011-11-17 01:43:06 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
hDrive = CreateFileA(devint_detail_data->DevicePath, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
|
|
|
|
if(hDrive == INVALID_HANDLE_VALUE) {
|
2013-12-27 16:06:59 +00:00
|
|
|
uprintf("Could not open '%s': %s\n", devint_detail_data->DevicePath, WindowsErrorString());
|
2011-11-17 01:43:06 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2014-02-27 19:53:53 +00:00
|
|
|
drive_number = GetDriveNumber(hDrive, devint_detail_data->DevicePath);
|
|
|
|
if (drive_number < 0)
|
2011-11-18 01:58:08 +00:00
|
|
|
continue;
|
2013-02-10 21:54:47 +00:00
|
|
|
|
2014-02-27 19:53:53 +00:00
|
|
|
drive_index = drive_number + DRIVE_INDEX_MIN;
|
2013-12-20 18:32:10 +00:00
|
|
|
if (!IsMediaPresent(drive_index)) {
|
|
|
|
uprintf("Device eliminated because it appears to contain no media\n");
|
|
|
|
safe_closehandle(hDrive);
|
|
|
|
safe_free(devint_detail_data);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2014-01-14 20:17:07 +00:00
|
|
|
if (GetDriveLabel(drive_index, drive_letters, &label)) {
|
2013-11-17 01:39:43 +00:00
|
|
|
if ((!enable_HDDs) && ((score = IsHDD(drive_index, vid, pid, buffer)) > 0)) {
|
2013-11-15 21:39:40 +00:00
|
|
|
uprintf("Device eliminated because it was detected as an USB Hard Drive (score %d > 0)\n", score);
|
|
|
|
uprintf("If this device is not an USB Hard Drive, please e-mail the author of this application\n");
|
2014-01-07 21:21:45 +00:00
|
|
|
uprintf("NOTE: You can enable the listing of USB Hard Drives in 'Advanced Options' (after clicking the white triangle)");
|
2013-11-14 01:21:50 +00:00
|
|
|
safe_closehandle(hDrive);
|
|
|
|
safe_free(devint_detail_data);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2014-01-14 20:17:07 +00:00
|
|
|
// The empty string is returned for drives that don't have any volumes assigned
|
|
|
|
if (drive_letters[0] == 0) {
|
2014-03-01 00:09:40 +00:00
|
|
|
entry = lmprintf(MSG_046, label, drive_number, SizeToHumanReadable(GetDriveSize(drive_index), FALSE, TRUE));
|
2013-02-10 21:54:47 +00:00
|
|
|
} else {
|
2014-01-14 20:17:07 +00:00
|
|
|
// We have multiple volumes assigned to the same device (multiple partitions)
|
|
|
|
// If that is the case, use "Multiple Volumes" instead of the label
|
|
|
|
safe_strcpy(entry_msg, sizeof(entry_msg), ((drive_letters[0] != 0) && (drive_letters[1] != 0))?
|
|
|
|
lmprintf(MSG_047):label);
|
|
|
|
for (k=0; drive_letters[k]; k++) {
|
|
|
|
// Append all the drive letters we detected
|
|
|
|
letter_name[2] = drive_letters[k];
|
2014-01-24 02:46:06 +00:00
|
|
|
if (right_to_left_mode)
|
|
|
|
safe_strcat(entry_msg, sizeof(entry_msg), RIGHT_TO_LEFT_MARK);
|
2014-01-14 20:17:07 +00:00
|
|
|
safe_strcat(entry_msg, sizeof(entry_msg), letter_name);
|
|
|
|
if (drive_letters[k] == app_dir[0]) break;
|
|
|
|
}
|
|
|
|
// Repeat as we need to break the outside loop
|
|
|
|
if (drive_letters[k] == app_dir[0]) {
|
|
|
|
uprintf("Removing %c: from the list: This is the disk from which " APPLICATION_NAME " is running!\n", app_dir[0]);
|
2013-06-15 21:43:45 +00:00
|
|
|
safe_closehandle(hDrive);
|
|
|
|
safe_free(devint_detail_data);
|
|
|
|
break;
|
|
|
|
}
|
2014-03-01 00:09:40 +00:00
|
|
|
safe_sprintf(&entry_msg[strlen(entry_msg)], sizeof(entry_msg) - strlen(entry_msg),
|
|
|
|
" [%s]", SizeToHumanReadable(GetDriveSize(drive_index), FALSE, TRUE));
|
2014-01-14 20:17:07 +00:00
|
|
|
entry = entry_msg;
|
2013-02-10 21:54:47 +00:00
|
|
|
}
|
2013-11-30 17:39:38 +00:00
|
|
|
|
|
|
|
// Must ensure that the combo box is UNSORTED for indexes to be the same
|
|
|
|
StrArrayAdd(&DriveID, buffer);
|
|
|
|
StrArrayAdd(&DriveLabel, label);
|
|
|
|
|
2014-02-27 19:53:53 +00:00
|
|
|
IGNORE_RETVAL(ComboBox_SetItemData(hDeviceList, ComboBox_AddStringU(hDeviceList, entry), drive_index));
|
2012-03-01 19:19:12 +00:00
|
|
|
maxwidth = max(maxwidth, GetEntryWidth(hDeviceList, entry));
|
2011-11-24 02:24:50 +00:00
|
|
|
safe_closehandle(hDrive);
|
|
|
|
safe_free(devint_detail_data);
|
|
|
|
break;
|
2011-11-17 01:43:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-12-11 23:38:16 +00:00
|
|
|
SetupDiDestroyDeviceInfoList(dev_info);
|
2012-02-16 23:40:31 +00:00
|
|
|
|
2012-03-01 19:19:12 +00:00
|
|
|
// Adjust the Dropdown width to the maximum text size
|
|
|
|
SendMessage(hDeviceList, CB_SETDROPPEDWIDTH, (WPARAM)maxwidth, 0);
|
|
|
|
|
2012-02-16 23:40:31 +00:00
|
|
|
if (devnum >= DRIVE_INDEX_MIN) {
|
|
|
|
for (i=0; i<ComboBox_GetCount(hDeviceList); i++) {
|
|
|
|
if ((DWORD)ComboBox_GetItemData(hDeviceList, i) == devnum) {
|
|
|
|
found = TRUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!found)
|
|
|
|
i = 0;
|
|
|
|
IGNORE_RETVAL(ComboBox_SetCurSel(hDeviceList, i));
|
2011-11-29 20:25:29 +00:00
|
|
|
SendMessage(hMainDialog, WM_COMMAND, (CBN_SELCHANGE<<16) | IDC_DEVICE, 0);
|
2011-12-09 12:57:32 +00:00
|
|
|
SendMessage(hMainDialog, WM_COMMAND, (CBN_SELCHANGE<<16) | IDC_FILESYSTEM,
|
|
|
|
ComboBox_GetCurSel(hFileSystem));
|
2013-11-13 00:14:03 +00:00
|
|
|
safe_free(devid_list);
|
2011-11-17 01:43:06 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2011-12-09 01:39:13 +00:00
|
|
|
/*
|
|
|
|
* Set up progress bar real estate allocation
|
|
|
|
*/
|
|
|
|
static void InitProgress(void)
|
|
|
|
{
|
2014-02-09 02:54:07 +00:00
|
|
|
int i, fs;
|
2011-12-09 01:39:13 +00:00
|
|
|
float last_end = 0.0f, slots_discrete = 0.0f, slots_analog = 0.0f;
|
|
|
|
|
2012-03-29 19:27:53 +00:00
|
|
|
fs = (int)ComboBox_GetItemData(hFileSystem, ComboBox_GetCurSel(hFileSystem));
|
2011-12-09 01:39:13 +00:00
|
|
|
memset(&nb_slots, 0, sizeof(nb_slots));
|
|
|
|
memset(&slot_end, 0, sizeof(slot_end));
|
|
|
|
previous_end = 0.0f;
|
|
|
|
|
2012-11-03 17:40:33 +00:00
|
|
|
memset(nb_slots, 0, sizeof(nb_slots));
|
|
|
|
memset(slot_end, 0, sizeof(slot_end));
|
|
|
|
previous_end = 0.0f;
|
|
|
|
|
2013-04-07 23:10:58 +00:00
|
|
|
nb_slots[OP_ANALYZE_MBR] = 1;
|
2011-12-09 01:39:13 +00:00
|
|
|
if (IsChecked(IDC_BADBLOCKS)) {
|
|
|
|
nb_slots[OP_BADBLOCKS] = -1;
|
|
|
|
}
|
2013-01-24 21:30:11 +00:00
|
|
|
if (IsChecked(IDC_BOOT)) {
|
2011-12-25 22:24:38 +00:00
|
|
|
// 1 extra slot for PBR writing
|
2014-02-09 02:54:07 +00:00
|
|
|
switch (selection_default) {
|
2012-01-12 02:52:40 +00:00
|
|
|
case DT_WINME:
|
2012-03-29 19:27:53 +00:00
|
|
|
nb_slots[OP_DOS] = 3+1;
|
2012-01-12 02:52:40 +00:00
|
|
|
break;
|
|
|
|
case DT_FREEDOS:
|
2012-03-29 19:27:53 +00:00
|
|
|
nb_slots[OP_DOS] = 5+1;
|
|
|
|
break;
|
2014-02-09 02:54:07 +00:00
|
|
|
case DT_IMG:
|
|
|
|
nb_slots[OP_DOS] = 0;
|
|
|
|
break;
|
2012-03-29 19:27:53 +00:00
|
|
|
case DT_ISO:
|
|
|
|
nb_slots[OP_DOS] = -1;
|
2012-01-12 02:52:40 +00:00
|
|
|
break;
|
|
|
|
default:
|
2012-03-29 19:27:53 +00:00
|
|
|
nb_slots[OP_DOS] = 2+1;
|
2012-01-12 02:52:40 +00:00
|
|
|
break;
|
|
|
|
}
|
2011-12-09 01:39:13 +00:00
|
|
|
}
|
2014-02-09 02:54:07 +00:00
|
|
|
if (selection_default == DT_IMG) {
|
2011-12-09 12:57:32 +00:00
|
|
|
nb_slots[OP_FORMAT] = -1;
|
2014-02-09 02:54:07 +00:00
|
|
|
} else {
|
|
|
|
nb_slots[OP_ZERO_MBR] = 1;
|
|
|
|
nb_slots[OP_PARTITION] = 1;
|
|
|
|
nb_slots[OP_FIX_MBR] = 1;
|
|
|
|
nb_slots[OP_CREATE_FS] =
|
|
|
|
nb_steps[ComboBox_GetItemData(hFileSystem, ComboBox_GetCurSel(hFileSystem))];
|
|
|
|
if ( (!IsChecked(IDC_QUICKFORMAT))
|
|
|
|
|| ((fs == FS_FAT32) && ((SelectedDrive.DiskSize >= LARGE_FAT32_SIZE) || (force_large_fat32))) ) {
|
|
|
|
nb_slots[OP_FORMAT] = -1;
|
|
|
|
}
|
|
|
|
nb_slots[OP_FINALIZE] = ((selection_default == DT_ISO) && (fs == FS_NTFS))?3:2;
|
2011-12-09 01:39:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i=0; i<OP_MAX; i++) {
|
|
|
|
if (nb_slots[i] > 0) {
|
|
|
|
slots_discrete += nb_slots[i]*1.0f;
|
|
|
|
}
|
|
|
|
if (nb_slots[i] < 0) {
|
|
|
|
slots_analog += nb_slots[i]*1.0f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i=0; i<OP_MAX; i++) {
|
|
|
|
if (nb_slots[i] == 0) {
|
|
|
|
slot_end[i+1] = last_end;
|
|
|
|
} else if (nb_slots[i] > 0) {
|
|
|
|
slot_end[i+1] = last_end + (1.0f * nb_slots[i]);
|
|
|
|
} else if (nb_slots[i] < 0) {
|
|
|
|
slot_end[i+1] = last_end + (( (100.0f-slots_discrete) * nb_slots[i]) / slots_analog);
|
|
|
|
}
|
|
|
|
last_end = slot_end[i+1];
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Is there's no analog, adjust our discrete ends to fill the whole bar */
|
|
|
|
if (slots_analog == 0.0f) {
|
|
|
|
for (i=0; i<OP_MAX; i++) {
|
|
|
|
slot_end[i+1] *= 100.0f / slots_discrete;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Position the progress bar within each operation range
|
|
|
|
*/
|
|
|
|
void UpdateProgress(int op, float percent)
|
|
|
|
{
|
|
|
|
int pos;
|
|
|
|
|
|
|
|
if ((op < 0) || (op > OP_MAX)) {
|
2013-01-27 20:56:57 +00:00
|
|
|
duprintf("UpdateProgress: invalid op %d\n", op);
|
2011-12-09 01:39:13 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (percent > 100.1f) {
|
2013-01-27 20:56:57 +00:00
|
|
|
duprintf("UpdateProgress(%d): invalid percentage %0.2f\n", op, percent);
|
2011-12-09 01:39:13 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if ((percent < 0.0f) && (nb_slots[op] <= 0)) {
|
2013-01-27 20:56:57 +00:00
|
|
|
duprintf("UpdateProgress(%d): error negative percentage sent for negative slot value\n", op);
|
2011-12-09 01:39:13 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (nb_slots[op] == 0)
|
|
|
|
return;
|
|
|
|
if (previous_end < slot_end[op]) {
|
|
|
|
previous_end = slot_end[op];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (percent < 0.0f) {
|
|
|
|
// Negative means advance one slot (1.0%) - requires a positive slot allocation
|
|
|
|
previous_end += (slot_end[op+1] - slot_end[op]) / (1.0f * nb_slots[op]);
|
|
|
|
pos = (int)(previous_end / 100.0f * MAX_PROGRESS);
|
|
|
|
} else {
|
|
|
|
pos = (int)((previous_end + ((slot_end[op+1] - previous_end) * (percent / 100.0f))) / 100.0f * MAX_PROGRESS);
|
|
|
|
}
|
|
|
|
if (pos > MAX_PROGRESS) {
|
2013-01-27 20:56:57 +00:00
|
|
|
duprintf("UpdateProgress(%d): rounding error - pos %d is greater than %d\n", op, pos, MAX_PROGRESS);
|
2011-12-09 01:39:13 +00:00
|
|
|
pos = MAX_PROGRESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
SendMessage(hProgress, PBM_SETPOS, (WPARAM)pos, 0);
|
2012-03-29 17:16:06 +00:00
|
|
|
SetTaskbarProgressValue(pos, MAX_PROGRESS);
|
2011-12-09 01:39:13 +00:00
|
|
|
}
|
|
|
|
|
2013-12-27 16:06:59 +00:00
|
|
|
/*
|
2011-12-01 17:54:35 +00:00
|
|
|
* Toggle controls according to operation
|
|
|
|
*/
|
2011-11-28 01:32:18 +00:00
|
|
|
static void EnableControls(BOOL bEnable)
|
|
|
|
{
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_DEVICE), bEnable);
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_START), bEnable);
|
2014-02-09 02:54:07 +00:00
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_ABOUT), bEnable);
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_BADBLOCKS), bEnable);
|
2014-03-15 14:14:10 +00:00
|
|
|
EnableBootOptions(bEnable, FALSE);
|
2012-05-16 22:38:39 +00:00
|
|
|
EnableWindow(hSelectISO, bEnable);
|
|
|
|
EnableWindow(hNBPasses, bEnable);
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_ADVANCED), bEnable);
|
2013-10-24 21:57:34 +00:00
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_LANG), bEnable);
|
2014-02-09 02:54:07 +00:00
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_ENABLE_FIXED_DISKS), bEnable);
|
2013-10-15 21:58:27 +00:00
|
|
|
SetDlgItemTextU(hMainDialog, IDCANCEL, lmprintf(bEnable?MSG_006:MSG_007));
|
2014-02-09 02:54:07 +00:00
|
|
|
if (selection_default == DT_IMG)
|
|
|
|
return;
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_PARTITION_TYPE), bEnable);
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_FILESYSTEM), bEnable);
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_CLUSTERSIZE), bEnable);
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_LABEL), bEnable);
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_QUICKFORMAT), bEnable);
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_SET_ICON), bEnable);
|
2011-11-28 01:32:18 +00:00
|
|
|
}
|
|
|
|
|
2012-05-30 23:32:25 +00:00
|
|
|
/* Callback for the log window */
|
2013-12-27 16:06:59 +00:00
|
|
|
BOOL CALLBACK LogProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
|
2012-05-30 23:32:25 +00:00
|
|
|
{
|
|
|
|
HDC hdc;
|
|
|
|
HFONT hf;
|
|
|
|
long lfHeight;
|
|
|
|
DWORD log_size;
|
2012-11-30 00:18:28 +00:00
|
|
|
char *log_buffer = NULL, *filepath;
|
2012-05-30 23:32:25 +00:00
|
|
|
|
|
|
|
switch (message) {
|
|
|
|
case WM_INITDIALOG:
|
2013-10-15 21:58:27 +00:00
|
|
|
apply_localization(IDD_LOG, hDlg);
|
2012-05-30 23:32:25 +00:00
|
|
|
hLog = GetDlgItem(hDlg, IDC_LOG_EDIT);
|
|
|
|
// Increase the size of our log textbox to MAX_LOG_SIZE (unsigned word)
|
|
|
|
PostMessage(hLog, EM_LIMITTEXT, MAX_LOG_SIZE , 0);
|
|
|
|
// Set the font to Unicode so that we can display anything
|
|
|
|
hdc = GetDC(NULL);
|
|
|
|
lfHeight = -MulDiv(8, GetDeviceCaps(hdc, LOGPIXELSY), 72);
|
|
|
|
ReleaseDC(NULL, hdc);
|
|
|
|
hf = CreateFontA(lfHeight, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE,
|
|
|
|
DEFAULT_CHARSET, 0, 0, PROOF_QUALITY, 0, "Arial Unicode MS");
|
|
|
|
SendDlgItemMessageA(hDlg, IDC_LOG_EDIT, WM_SETFONT, (WPARAM)hf, TRUE);
|
|
|
|
return TRUE;
|
2013-12-27 16:06:59 +00:00
|
|
|
case WM_COMMAND:
|
2012-05-30 23:32:25 +00:00
|
|
|
switch (LOWORD(wParam)) {
|
|
|
|
case IDCANCEL:
|
|
|
|
ShowWindow(hDlg, SW_HIDE);
|
|
|
|
log_displayed = FALSE;
|
|
|
|
return TRUE;
|
|
|
|
case IDC_LOG_CLEAR:
|
|
|
|
SetWindowTextA(hLog, "");
|
|
|
|
return TRUE;
|
|
|
|
case IDC_LOG_SAVE:
|
|
|
|
log_size = GetWindowTextLengthU(hLog);
|
2013-06-30 01:31:52 +00:00
|
|
|
if (log_size <= 0)
|
|
|
|
break;
|
|
|
|
log_buffer = (char*)malloc(log_size);
|
2012-05-30 23:32:25 +00:00
|
|
|
if (log_buffer != NULL) {
|
|
|
|
log_size = GetDlgItemTextU(hDlg, IDC_LOG_EDIT, log_buffer, log_size);
|
2013-06-06 22:40:37 +00:00
|
|
|
if (log_size != 0) {
|
|
|
|
log_size--; // remove NUL terminator
|
2014-03-17 20:42:10 +00:00
|
|
|
filepath = FileDialog(TRUE, app_dir, "rufus.log", "log", lmprintf(MSG_108), 0);
|
2012-05-30 23:32:25 +00:00
|
|
|
if (filepath != NULL) {
|
|
|
|
FileIO(TRUE, filepath, &log_buffer, &log_size);
|
|
|
|
}
|
|
|
|
safe_free(filepath);
|
|
|
|
}
|
|
|
|
safe_free(log_buffer);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case WM_CLOSE:
|
|
|
|
ShowWindow(hDlg, SW_HIDE);
|
2013-10-15 21:58:27 +00:00
|
|
|
reset_localization(IDD_LOG);
|
2012-05-30 23:32:25 +00:00
|
|
|
log_displayed = FALSE;
|
|
|
|
return TRUE;
|
|
|
|
}
|
2013-12-27 16:06:59 +00:00
|
|
|
return FALSE;
|
2012-05-30 23:32:25 +00:00
|
|
|
}
|
|
|
|
|
2011-12-08 12:14:21 +00:00
|
|
|
/*
|
|
|
|
* Timer in the right part of the status area
|
|
|
|
*/
|
|
|
|
static void CALLBACK ClockTimer(HWND hWnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
|
|
|
|
{
|
|
|
|
timer++;
|
|
|
|
safe_sprintf(szTimer, sizeof(szTimer), "%02d:%02d:%02d",
|
|
|
|
timer/3600, (timer%3600)/60, timer%60);
|
|
|
|
SendMessageA(GetDlgItem(hWnd, IDC_STATUS), SB_SETTEXTA, SBT_OWNERDRAW | 1, (LPARAM)szTimer);
|
|
|
|
}
|
|
|
|
|
2013-02-10 21:54:47 +00:00
|
|
|
/*
|
|
|
|
* Device Refresh Timer
|
|
|
|
*/
|
|
|
|
static void CALLBACK RefreshTimer(HWND hWnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
|
|
|
|
{
|
2014-02-09 02:54:07 +00:00
|
|
|
// DO NOT USE WM_DEVICECHANGE - IT MAY BE FILTERED OUT BY WINDOWS!
|
|
|
|
SendMessage(hWnd, UM_MEDIA_CHANGE, 0, 0);
|
2013-02-10 21:54:47 +00:00
|
|
|
}
|
|
|
|
|
2012-02-07 16:17:14 +00:00
|
|
|
/*
|
|
|
|
* Detect and notify about a blocking operation during ISO extraction cancellation
|
|
|
|
*/
|
|
|
|
static void CALLBACK BlockingTimer(HWND hWnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
|
|
|
|
{
|
|
|
|
if (iso_blocking_status < 0) {
|
|
|
|
KillTimer(hMainDialog, TID_BLOCKING_TIMER);
|
|
|
|
user_notified = FALSE;
|
|
|
|
uprintf("Killed blocking I/O timer\n");
|
|
|
|
} else if(!user_notified) {
|
|
|
|
if (last_iso_blocking_status == iso_blocking_status) {
|
2014-01-24 02:46:06 +00:00
|
|
|
// A write or close operation hasn't made any progress since our last check
|
|
|
|
user_notified = TRUE;
|
|
|
|
uprintf("Blocking I/O operation detected\n");
|
|
|
|
MessageBoxU(hMainDialog, lmprintf(MSG_080), lmprintf(MSG_048), MB_OK|MB_ICONINFORMATION|MB_IS_RTL);
|
2012-02-07 16:17:14 +00:00
|
|
|
} else {
|
|
|
|
last_iso_blocking_status = iso_blocking_status;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-04 01:47:45 +00:00
|
|
|
/* Callback for the modeless ISO extraction progress, and other progress dialogs */
|
2013-12-27 16:06:59 +00:00
|
|
|
BOOL CALLBACK ISOProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
|
2012-02-01 14:26:36 +00:00
|
|
|
{
|
|
|
|
switch (message) {
|
|
|
|
case WM_INITDIALOG:
|
2013-10-15 21:58:27 +00:00
|
|
|
apply_localization(IDD_ISO_EXTRACT, hDlg);
|
2012-12-06 01:40:44 +00:00
|
|
|
hISOProgressBar = GetDlgItem(hDlg, IDC_PROGRESS);
|
2012-02-01 14:26:36 +00:00
|
|
|
hISOFileName = GetDlgItem(hDlg, IDC_ISO_FILENAME);
|
|
|
|
// Use maximum granularity for the progress bar
|
2013-01-09 21:54:28 +00:00
|
|
|
SendMessage(hISOProgressBar, PBM_SETRANGE, 0, (MAX_PROGRESS<<16) & 0xFFFF0000);
|
2012-02-01 14:26:36 +00:00
|
|
|
return TRUE;
|
2012-12-04 01:47:45 +00:00
|
|
|
case UM_ISO_INIT:
|
|
|
|
iso_op_in_progress = TRUE;
|
2013-12-27 16:06:59 +00:00
|
|
|
EnableWindow(GetDlgItem(hISOProgressDlg, IDC_ISO_ABORT), TRUE);
|
2012-12-04 01:47:45 +00:00
|
|
|
CenterDialog(hDlg);
|
|
|
|
ShowWindow(hDlg, SW_SHOW);
|
|
|
|
UpdateWindow(hDlg);
|
|
|
|
return TRUE;
|
2012-02-01 14:26:36 +00:00
|
|
|
case UM_ISO_EXIT:
|
2013-06-20 14:41:22 +00:00
|
|
|
// Just hide and recenter the dialog
|
2012-12-04 01:47:45 +00:00
|
|
|
ShowWindow(hDlg, SW_HIDE);
|
|
|
|
iso_op_in_progress = FALSE;
|
2012-02-01 14:26:36 +00:00
|
|
|
return TRUE;
|
2013-12-27 16:06:59 +00:00
|
|
|
case WM_COMMAND:
|
2012-02-01 14:26:36 +00:00
|
|
|
switch (LOWORD(wParam)) {
|
|
|
|
case IDC_ISO_ABORT:
|
|
|
|
FormatStatus = ERROR_SEVERITY_ERROR|FAC(FACILITY_STORAGE)|ERROR_CANCELLED;
|
2013-12-19 23:56:40 +00:00
|
|
|
PrintStatus(0, FALSE, MSG_201);
|
2012-02-07 16:17:14 +00:00
|
|
|
uprintf("Cancelling (from ISO proc.)\n");
|
|
|
|
EnableWindow(GetDlgItem(hISOProgressDlg, IDC_ISO_ABORT), FALSE);
|
2012-03-11 01:55:25 +00:00
|
|
|
if (format_thid != NULL)
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDCANCEL), FALSE);
|
2012-02-07 16:17:14 +00:00
|
|
|
// Start a timer to detect blocking operations during ISO file extraction
|
|
|
|
if (iso_blocking_status >= 0) {
|
|
|
|
last_iso_blocking_status = iso_blocking_status;
|
|
|
|
SetTimer(hMainDialog, TID_BLOCKING_TIMER, 5000, BlockingTimer);
|
|
|
|
}
|
2012-02-01 14:26:36 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
case WM_CLOSE: // prevent closure using Alt-F4
|
|
|
|
return TRUE;
|
|
|
|
}
|
2013-12-27 16:06:59 +00:00
|
|
|
return FALSE;
|
2012-03-11 01:55:25 +00:00
|
|
|
}
|
2012-02-01 14:26:36 +00:00
|
|
|
|
2014-02-09 02:54:07 +00:00
|
|
|
BOOL IsImage(const char* src_img)
|
|
|
|
{
|
|
|
|
HANDLE handle = INVALID_HANDLE_VALUE;
|
|
|
|
LARGE_INTEGER liImageSize;
|
|
|
|
|
|
|
|
handle = CreateFileU(src_img, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
|
|
|
|
if (handle == INVALID_HANDLE_VALUE) {
|
|
|
|
uprintf("Could not open image '%s'", src_img);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
iso_report.is_bootable_img = AnalyzeMBR(handle, "Image");
|
|
|
|
|
|
|
|
if (!GetFileSizeEx(handle, &liImageSize)) {
|
|
|
|
uprintf("Could not get image size: %s", WindowsErrorString());
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
iso_report.projected_size = (uint64_t)liImageSize.QuadPart;
|
|
|
|
|
|
|
|
if (iso_report.is_bootable_img) {
|
|
|
|
uprintf("Using bootable disk image: '%s'", src_img);
|
|
|
|
selection_default = DT_IMG;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
safe_closehandle(handle);
|
|
|
|
return iso_report.is_bootable_img;
|
|
|
|
}
|
|
|
|
|
2012-02-01 14:26:36 +00:00
|
|
|
// The scanning process can be blocking for message processing => use a thread
|
2012-02-07 02:05:58 +00:00
|
|
|
DWORD WINAPI ISOScanThread(LPVOID param)
|
2012-02-01 14:26:36 +00:00
|
|
|
{
|
2012-02-07 16:17:14 +00:00
|
|
|
int i;
|
2013-12-27 16:06:59 +00:00
|
|
|
BOOL r;
|
2014-01-21 17:08:41 +00:00
|
|
|
char isolinux_str[16] = "No";
|
2012-02-07 16:17:14 +00:00
|
|
|
|
|
|
|
if (iso_path == NULL)
|
|
|
|
goto out;
|
2013-12-19 23:56:40 +00:00
|
|
|
PrintStatus(0, TRUE, MSG_202);
|
2013-12-28 01:27:09 +00:00
|
|
|
user_notified = FALSE;
|
2013-12-27 16:06:59 +00:00
|
|
|
EnableControls(FALSE);
|
2014-02-09 02:54:07 +00:00
|
|
|
r = ExtractISO(iso_path, "", TRUE) || IsImage(iso_path);
|
2013-12-27 16:06:59 +00:00
|
|
|
EnableControls(TRUE);
|
|
|
|
if (!r) {
|
2012-03-11 01:55:25 +00:00
|
|
|
SendMessage(hISOProgressDlg, UM_ISO_EXIT, 0, 0);
|
2013-12-19 23:56:40 +00:00
|
|
|
PrintStatus(0, TRUE, MSG_203);
|
2012-02-16 11:37:59 +00:00
|
|
|
safe_free(iso_path);
|
2012-02-07 02:05:58 +00:00
|
|
|
goto out;
|
|
|
|
}
|
2014-02-09 02:54:07 +00:00
|
|
|
|
|
|
|
if (!iso_report.is_bootable_img) {
|
|
|
|
if (HAS_SYSLINUX(iso_report)) {
|
|
|
|
safe_sprintf(isolinux_str, sizeof(isolinux_str), "Yes (%s)", iso_report.sl_version_str);
|
|
|
|
}
|
2014-02-13 21:25:34 +00:00
|
|
|
uprintf("ISO label: '%s'\r\n Size: %lld bytes\r\n Has a >64 chars filename: %s\r\n Has Symlinks: %s\r\n Has a >4GB file: %s\r\n"
|
2014-02-09 02:54:07 +00:00
|
|
|
" ReactOS: %s\r\n Uses EFI: %s%s\r\n Uses Bootmgr: %s\r\n Uses WinPE: %s%s\r\n Uses isolinux: %s\r\n",
|
2014-02-13 21:25:34 +00:00
|
|
|
iso_report.label, iso_report.projected_size, iso_report.has_long_filename?"Yes":"No", iso_report.has_symlinks?"Yes":"No",
|
|
|
|
iso_report.has_4GB_file?"Yes":"No", IS_REACTOS(iso_report)?"Yes":"No", (iso_report.has_efi || iso_report.has_win7_efi)?"Yes":"No",
|
2014-02-09 02:54:07 +00:00
|
|
|
(iso_report.has_win7_efi && (!iso_report.has_efi))?" (win7_x64)":"", iso_report.has_bootmgr?"Yes":"No",
|
|
|
|
IS_WINPE(iso_report.winpe)?"Yes":"No", (iso_report.uses_minint)?" (with /minint)":"", isolinux_str);
|
|
|
|
if (HAS_SYSLINUX(iso_report) && (SL_MAJOR(iso_report.sl_version) < 5)) {
|
|
|
|
for (i=0; i<NB_OLD_C32; i++) {
|
|
|
|
uprintf(" With an old %s: %s\n", old_c32_name[i], iso_report.has_old_c32[i]?"Yes":"No");
|
|
|
|
}
|
2012-12-15 03:27:14 +00:00
|
|
|
}
|
|
|
|
}
|
2014-01-21 17:08:41 +00:00
|
|
|
if ( (!iso_report.has_bootmgr) && (!HAS_SYSLINUX(iso_report)) && (!IS_WINPE(iso_report.winpe))
|
2014-02-09 02:54:07 +00:00
|
|
|
&& (!iso_report.has_efi) && (!IS_REACTOS(iso_report) && (!iso_report.is_bootable_img)) ) {
|
2014-01-24 02:46:06 +00:00
|
|
|
MessageBoxU(hMainDialog, lmprintf(MSG_082), lmprintf(MSG_081), MB_OK|MB_ICONINFORMATION|MB_IS_RTL);
|
2012-02-07 02:05:58 +00:00
|
|
|
safe_free(iso_path);
|
2012-05-16 22:38:39 +00:00
|
|
|
SetMBRProps();
|
2014-02-09 02:54:07 +00:00
|
|
|
} else {
|
2013-12-22 20:48:57 +00:00
|
|
|
// Enable bootable and set Target System and FS accordingly
|
2013-01-24 21:30:11 +00:00
|
|
|
CheckDlgButton(hMainDialog, IDC_BOOT, BST_CHECKED);
|
2014-02-09 02:54:07 +00:00
|
|
|
if (!iso_report.is_bootable_img) {
|
|
|
|
SetTargetSystem();
|
|
|
|
SetFSFromISO();
|
|
|
|
SetMBRProps();
|
|
|
|
// Some Linux distros, such as Arch Linux, require the USB drive to have
|
|
|
|
// a specific label => copy the one we got from the ISO image
|
|
|
|
if (iso_report.label[0] != 0) {
|
|
|
|
SetWindowTextU(hLabel, iso_report.label);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
SendMessage(hMainDialog, WM_COMMAND, (CBN_SELCHANGE<<16) | IDC_FILESYSTEM,
|
|
|
|
ComboBox_GetCurSel(hFileSystem));
|
|
|
|
}
|
2012-02-07 16:17:14 +00:00
|
|
|
for (i=(int)safe_strlen(iso_path); (i>0)&&(iso_path[i]!='\\'); i--);
|
2013-12-19 23:56:40 +00:00
|
|
|
PrintStatus(0, TRUE, MSG_205, &iso_path[i+1]);
|
2012-02-16 11:37:59 +00:00
|
|
|
// Lose the focus on the select ISO (but place it on Close)
|
|
|
|
SendMessage(hMainDialog, WM_NEXTDLGCTL, (WPARAM)FALSE, 0);
|
|
|
|
// Lose the focus from Close and set it back to Start
|
|
|
|
SendMessage(hMainDialog, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hMainDialog, IDC_START), TRUE);
|
2012-02-07 02:05:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
2012-03-11 01:55:25 +00:00
|
|
|
SendMessage(hISOProgressDlg, UM_ISO_EXIT, 0, 0);
|
2012-02-07 02:05:58 +00:00
|
|
|
ExitThread(0);
|
2012-02-01 14:26:36 +00:00
|
|
|
}
|
|
|
|
|
2013-10-15 21:58:27 +00:00
|
|
|
// Move a control along the Y axis according to the advanced mode setting
|
|
|
|
void MoveCtrlY(HWND hDlg, int nID, float vertical_shift) {
|
|
|
|
ResizeMoveCtrl(hDlg, GetDlgItem(hDlg, nID), 0,
|
|
|
|
(int)(advanced_mode?vertical_shift:-vertical_shift), 0, 0);
|
2012-05-16 22:38:39 +00:00
|
|
|
}
|
|
|
|
|
2013-01-25 01:38:10 +00:00
|
|
|
void SetPassesTooltip(void)
|
|
|
|
{
|
2013-10-15 21:58:27 +00:00
|
|
|
const unsigned char pattern[] = BADBLOCK_PATTERNS;
|
|
|
|
CreateTooltip(hNBPasses, lmprintf(MSG_153 + ComboBox_GetCurSel(hNBPasses),
|
|
|
|
pattern[0], pattern[1], pattern[2], pattern[3]), -1);
|
2013-01-25 01:38:10 +00:00
|
|
|
}
|
|
|
|
|
2012-05-16 22:38:39 +00:00
|
|
|
// Toggle "advanced" mode
|
|
|
|
void ToggleAdvanced(void)
|
|
|
|
{
|
2013-06-03 20:32:22 +00:00
|
|
|
float dialog_shift = 80.0f;
|
2012-05-16 22:38:39 +00:00
|
|
|
RECT rect;
|
|
|
|
POINT point;
|
|
|
|
int toggle;
|
|
|
|
|
|
|
|
advanced_mode = !advanced_mode;
|
|
|
|
|
|
|
|
// Increase or decrease the Window size
|
|
|
|
GetWindowRect(hMainDialog, &rect);
|
|
|
|
point.x = (rect.right - rect.left);
|
|
|
|
point.y = (rect.bottom - rect.top);
|
|
|
|
MoveWindow(hMainDialog, rect.left, rect.top, point.x,
|
|
|
|
point.y + (int)(fScale*(advanced_mode?dialog_shift:-dialog_shift)), TRUE);
|
|
|
|
|
|
|
|
// Move the status bar up or down
|
2013-10-15 21:58:27 +00:00
|
|
|
MoveCtrlY(hMainDialog, IDC_STATUS, dialog_shift);
|
|
|
|
MoveCtrlY(hMainDialog, IDC_START, dialog_shift);
|
|
|
|
MoveCtrlY(hMainDialog, IDC_PROGRESS, dialog_shift);
|
|
|
|
MoveCtrlY(hMainDialog, IDC_ABOUT, dialog_shift);
|
|
|
|
MoveCtrlY(hMainDialog, IDC_LOG, dialog_shift);
|
|
|
|
MoveCtrlY(hMainDialog, IDCANCEL, dialog_shift);
|
2012-05-30 23:32:25 +00:00
|
|
|
#ifdef RUFUS_TEST
|
2013-10-15 21:58:27 +00:00
|
|
|
MoveCtrlY(hMainDialog, IDC_TEST, dialog_shift);
|
2012-05-30 23:32:25 +00:00
|
|
|
#endif
|
2012-05-16 22:38:39 +00:00
|
|
|
|
2013-06-03 20:32:22 +00:00
|
|
|
// And do the same for the log dialog while we're at it
|
|
|
|
GetWindowRect(hLogDlg, &rect);
|
|
|
|
point.x = (rect.right - rect.left);
|
|
|
|
point.y = (rect.bottom - rect.top);
|
|
|
|
MoveWindow(hLogDlg, rect.left, rect.top, point.x,
|
|
|
|
point.y + (int)(fScale*(advanced_mode?dialog_shift:-dialog_shift)), TRUE);
|
2013-10-15 21:58:27 +00:00
|
|
|
MoveCtrlY(hLogDlg, IDC_LOG_CLEAR, dialog_shift);
|
|
|
|
MoveCtrlY(hLogDlg, IDC_LOG_SAVE, dialog_shift);
|
|
|
|
MoveCtrlY(hLogDlg, IDCANCEL, dialog_shift);
|
2013-06-03 20:32:22 +00:00
|
|
|
GetWindowRect(hLog, &rect);
|
|
|
|
point.x = (rect.right - rect.left);
|
|
|
|
point.y = (rect.bottom - rect.top) + (int)(fScale*(advanced_mode?dialog_shift:-dialog_shift));
|
|
|
|
SetWindowPos(hLog, 0, 0, 0, point.x, point.y, 0);
|
|
|
|
// Don't forget to scroll the edit to the bottom after resize
|
|
|
|
SendMessage(hLog, EM_LINESCROLL, 0, SendMessage(hLog, EM_GETLINECOUNT, 0, 0));
|
|
|
|
|
2012-05-16 22:38:39 +00:00
|
|
|
// Hide or show the various advanced options
|
|
|
|
toggle = advanced_mode?SW_SHOW:SW_HIDE;
|
2013-06-03 20:32:22 +00:00
|
|
|
ShowWindow(GetDlgItem(hMainDialog, IDC_ENABLE_FIXED_DISKS), toggle);
|
2012-05-16 22:38:39 +00:00
|
|
|
ShowWindow(GetDlgItem(hMainDialog, IDC_EXTRA_PARTITION), toggle);
|
|
|
|
ShowWindow(GetDlgItem(hMainDialog, IDC_RUFUS_MBR), toggle);
|
|
|
|
ShowWindow(GetDlgItem(hMainDialog, IDC_DISK_ID), toggle);
|
2013-10-15 21:58:27 +00:00
|
|
|
ShowWindow(GetDlgItem(hMainDialog, IDS_ADVANCED_OPTIONS_GRP), toggle);
|
2012-05-16 22:38:39 +00:00
|
|
|
|
|
|
|
// Toggle the up/down icon
|
|
|
|
SendMessage(GetDlgItem(hMainDialog, IDC_ADVANCED), BCM_SETIMAGELIST, 0, (LPARAM)(advanced_mode?&bi_up:&bi_down));
|
|
|
|
}
|
|
|
|
|
2014-02-09 02:54:07 +00:00
|
|
|
// Toggle DD Image mode
|
|
|
|
void ToggleImage(BOOL enable)
|
|
|
|
{
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_QUICKFORMAT), enable);
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_PARTITION_TYPE), enable);
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_FILESYSTEM), enable);
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_CLUSTERSIZE), enable);
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_LABEL), enable);
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_QUICKFORMAT), enable);
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_SET_ICON), enable);
|
|
|
|
}
|
|
|
|
|
2013-01-25 01:38:10 +00:00
|
|
|
static BOOL BootCheck(void)
|
|
|
|
{
|
2014-01-21 17:08:41 +00:00
|
|
|
int i, fs, bt, dt, r;
|
2013-06-15 16:31:55 +00:00
|
|
|
FILE* fd;
|
2014-02-04 20:01:28 +00:00
|
|
|
DWORD len;
|
2014-03-13 22:13:46 +00:00
|
|
|
BOOL in_files_dir = FALSE;
|
2014-01-21 17:08:41 +00:00
|
|
|
const char* ldlinux = "ldlinux";
|
|
|
|
const char* syslinux = "syslinux";
|
|
|
|
const char* ldlinux_ext[3] = { "sys", "bss", "c32" };
|
|
|
|
char tmp[MAX_PATH];
|
2013-01-25 01:38:10 +00:00
|
|
|
|
2014-01-21 17:08:41 +00:00
|
|
|
syslinux_ldlinux_len[0] = 0; syslinux_ldlinux_len[1] = 0;
|
2013-06-15 16:31:55 +00:00
|
|
|
dt = (int)ComboBox_GetItemData(hBootType, ComboBox_GetCurSel(hBootType));
|
2014-02-09 02:54:07 +00:00
|
|
|
if ((dt == DT_ISO) || (dt == DT_IMG)) {
|
2013-01-25 01:38:10 +00:00
|
|
|
if (iso_path == NULL) {
|
2013-10-31 22:59:53 +00:00
|
|
|
// Please click on the disc button to select a bootable ISO
|
2014-01-24 02:46:06 +00:00
|
|
|
MessageBoxU(hMainDialog, lmprintf(MSG_087), lmprintf(MSG_086), MB_OK|MB_ICONERROR|MB_IS_RTL);
|
2013-01-25 01:38:10 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
2013-07-05 22:58:04 +00:00
|
|
|
if ((size_check) && (iso_report.projected_size > (uint64_t)SelectedDrive.DiskSize)) {
|
2013-10-31 22:59:53 +00:00
|
|
|
// This ISO image is too big for the selected target
|
2014-01-24 02:46:06 +00:00
|
|
|
MessageBoxU(hMainDialog, lmprintf(MSG_089), lmprintf(MSG_088), MB_OK|MB_ICONERROR|MB_IS_RTL);
|
2013-01-25 01:38:10 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
2014-02-09 02:54:07 +00:00
|
|
|
if (dt == DT_IMG) {
|
|
|
|
if (!iso_report.is_bootable_img)
|
|
|
|
// The selected image doesn't match the boot option selected.
|
|
|
|
MessageBoxU(hMainDialog, lmprintf(MSG_188), lmprintf(MSG_187), MB_OK|MB_ICONERROR|MB_IS_RTL);
|
|
|
|
return (iso_report.is_bootable_img);
|
|
|
|
}
|
2013-01-25 01:38:10 +00:00
|
|
|
fs = (int)ComboBox_GetItemData(hFileSystem, ComboBox_GetCurSel(hFileSystem));
|
|
|
|
bt = GETBIOSTYPE((int)ComboBox_GetItemData(hPartitionScheme, ComboBox_GetCurSel(hPartitionScheme)));
|
|
|
|
if (bt == BT_UEFI) {
|
|
|
|
if (!IS_EFI(iso_report)) {
|
2013-10-31 22:59:53 +00:00
|
|
|
// Unsupported ISO
|
2014-01-24 02:46:06 +00:00
|
|
|
MessageBoxU(hMainDialog, lmprintf(MSG_091), lmprintf(MSG_090), MB_OK|MB_ICONERROR|MB_IS_RTL);
|
2013-01-25 01:38:10 +00:00
|
|
|
return FALSE;
|
2013-12-11 19:00:57 +00:00
|
|
|
}
|
|
|
|
if ((iso_report.has_win7_efi) && (!WimExtractCheck())) {
|
|
|
|
// Your platform cannot extract files from WIM archives => download 7-zip?
|
2014-01-24 02:46:06 +00:00
|
|
|
if (MessageBoxU(hMainDialog, lmprintf(MSG_102), lmprintf(MSG_101), MB_YESNO|MB_ICONERROR|MB_IS_RTL) == IDYES)
|
2013-12-11 19:00:57 +00:00
|
|
|
ShellExecuteA(hMainDialog, "open", SEVENZIP_URL, NULL, NULL, SW_SHOWNORMAL);
|
2013-01-25 01:38:10 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
} else if ((fs == FS_NTFS) && (!iso_report.has_bootmgr) && (!IS_WINPE(iso_report.winpe))) {
|
2014-01-21 17:08:41 +00:00
|
|
|
if (HAS_SYSLINUX(iso_report)) {
|
2013-10-31 22:59:53 +00:00
|
|
|
// Only FAT/FAT32 is supported for this type of ISO
|
2014-01-24 02:46:06 +00:00
|
|
|
MessageBoxU(hMainDialog, lmprintf(MSG_096), lmprintf(MSG_092), MB_OK|MB_ICONERROR|MB_IS_RTL);
|
2013-01-25 01:38:10 +00:00
|
|
|
} else {
|
2013-10-31 22:59:53 +00:00
|
|
|
// Only 'bootmgr' or 'WinPE' based ISO images can currently be used with NTFS
|
2014-01-24 02:46:06 +00:00
|
|
|
MessageBoxU(hMainDialog, lmprintf(MSG_097), lmprintf(MSG_090), MB_OK|MB_ICONERROR|MB_IS_RTL);
|
2013-01-25 01:38:10 +00:00
|
|
|
}
|
|
|
|
return FALSE;
|
2014-01-21 17:08:41 +00:00
|
|
|
} else if (((fs == FS_FAT16)||(fs == FS_FAT32)) && (!HAS_SYSLINUX(iso_report)) && (!IS_REACTOS(iso_report))) {
|
2013-10-31 22:59:53 +00:00
|
|
|
// FAT/FAT32 can only be used for isolinux based ISO images or when the Target Type is UEFI
|
2014-01-24 02:46:06 +00:00
|
|
|
MessageBoxU(hMainDialog, lmprintf(MSG_098), lmprintf(MSG_090), MB_OK|MB_ICONERROR|MB_IS_RTL);
|
2013-06-16 21:49:06 +00:00
|
|
|
return FALSE;
|
2013-12-11 19:00:57 +00:00
|
|
|
}
|
|
|
|
if (((fs == FS_FAT16)||(fs == FS_FAT32)) && (iso_report.has_4GB_file)) {
|
2013-10-31 22:59:53 +00:00
|
|
|
// This ISO image contains a file larger than 4GB file (FAT32)
|
2014-01-24 02:46:06 +00:00
|
|
|
MessageBoxU(hMainDialog, lmprintf(MSG_100), lmprintf(MSG_099), MB_OK|MB_ICONERROR|MB_IS_RTL);
|
2013-01-25 01:38:10 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
2014-02-04 20:01:28 +00:00
|
|
|
|
|
|
|
if (HAS_SYSLINUX(iso_report)) {
|
|
|
|
if (SL_MAJOR(iso_report.sl_version) < 5) {
|
|
|
|
IGNORE_RETVAL(_chdirU(app_dir));
|
|
|
|
for (i=0; i<NB_OLD_C32; i++) {
|
|
|
|
if (iso_report.has_old_c32[i]) {
|
2014-03-13 22:13:46 +00:00
|
|
|
if (!in_files_dir) {
|
2014-02-04 20:01:28 +00:00
|
|
|
IGNORE_RETVAL(_mkdir(FILES_DIR));
|
|
|
|
IGNORE_RETVAL(_chdir(FILES_DIR));
|
2014-03-13 22:13:46 +00:00
|
|
|
in_files_dir = TRUE;
|
2014-02-04 20:01:28 +00:00
|
|
|
}
|
|
|
|
static_sprintf(tmp, "%s-%s/%s", syslinux, embedded_sl_version_str[0], old_c32_name[i]);
|
|
|
|
fd = fopen(tmp, "rb");
|
|
|
|
if (fd != NULL) {
|
|
|
|
// If a file already exists in the current directory, use that one
|
2014-03-13 22:13:46 +00:00
|
|
|
uprintf("Will replace obsolete '%s' from ISO with the one found in './" FILES_DIR "/%s'\n", old_c32_name[i], tmp);
|
2014-02-04 20:01:28 +00:00
|
|
|
fclose(fd);
|
|
|
|
use_own_c32[i] = TRUE;
|
|
|
|
} else {
|
|
|
|
PrintStatus(0, FALSE, MSG_204, old_c32_name[i]);
|
|
|
|
if (MessageBoxU(hMainDialog, lmprintf(MSG_084, old_c32_name[i], old_c32_name[i]),
|
|
|
|
lmprintf(MSG_083, old_c32_name[i]), MB_YESNO|MB_ICONWARNING|MB_IS_RTL) == IDYES) {
|
|
|
|
static_sprintf(tmp, "%s-%s", syslinux, embedded_sl_version_str[0]);
|
|
|
|
IGNORE_RETVAL(_mkdir(tmp));
|
|
|
|
SetWindowTextU(hISOProgressDlg, lmprintf(MSG_085, old_c32_name[i]));
|
|
|
|
static_sprintf(tmp, "%s/%s-%s/%s", FILES_URL, syslinux, embedded_sl_version_str[0], old_c32_name[i]);
|
|
|
|
SetWindowTextU(hISOFileName, tmp);
|
|
|
|
len = DownloadFile(tmp, &tmp[sizeof(FILES_URL)], hISOProgressDlg);
|
|
|
|
if (len == 0) {
|
|
|
|
uprintf("Couldn't download the files - cancelling\n");
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
use_own_c32[i] = TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-01-21 17:08:41 +00:00
|
|
|
}
|
2014-02-04 20:01:28 +00:00
|
|
|
} else if (iso_report.sl_version != embedded_sl_version[1]) {
|
|
|
|
// Unlike what was the case for v4 and earlier, Syslinux v5+ versions are INCOMPATIBLE with one another!
|
|
|
|
IGNORE_RETVAL(_chdirU(app_dir));
|
|
|
|
IGNORE_RETVAL(_mkdir(FILES_DIR));
|
|
|
|
IGNORE_RETVAL(_chdir(FILES_DIR));
|
2014-01-21 17:08:41 +00:00
|
|
|
for (i=0; i<2; i++) {
|
2014-02-04 20:01:28 +00:00
|
|
|
// Check if we already have the relevant ldlinux_v#.##.sys & ldlinux_v#.##.bss files
|
|
|
|
static_sprintf(tmp, "%s-%s/%s.%s", syslinux, iso_report.sl_version_str, ldlinux, ldlinux_ext[i]);
|
|
|
|
fd = fopen(tmp, "rb");
|
|
|
|
if (fd != NULL) {
|
|
|
|
fseek(fd, 0, SEEK_END);
|
|
|
|
syslinux_ldlinux_len[i] = (DWORD)ftell(fd);
|
|
|
|
fclose(fd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ((syslinux_ldlinux_len[0] != 0) && (syslinux_ldlinux_len[1] != 0)) {
|
2014-03-13 22:13:46 +00:00
|
|
|
uprintf("Will reuse '%s.%s' and '%s.%s' from './" FILES_DIR "/%s/%s-%s/' for Syslinux installation\n",
|
2014-02-04 20:01:28 +00:00
|
|
|
ldlinux, ldlinux_ext[0], ldlinux, ldlinux_ext[1], FILES_DIR, syslinux, iso_report.sl_version_str);
|
|
|
|
} else {
|
|
|
|
r = MessageBoxU(hMainDialog, lmprintf(MSG_114, iso_report.sl_version_str, embedded_sl_version_str[1]),
|
|
|
|
lmprintf(MSG_115), MB_YESNO|MB_ICONWARNING|MB_IS_RTL);
|
|
|
|
if (r != IDYES)
|
2014-01-21 17:08:41 +00:00
|
|
|
return FALSE;
|
2014-02-04 20:01:28 +00:00
|
|
|
for (i=0; i<2; i++) {
|
|
|
|
static_sprintf(tmp, "%s-%s", syslinux, iso_report.sl_version_str);
|
|
|
|
IGNORE_RETVAL(_mkdir(tmp));
|
|
|
|
static_sprintf(tmp, "%s.%s %s", ldlinux, ldlinux_ext[i], iso_report.sl_version_str);
|
|
|
|
SetWindowTextU(hISOProgressDlg, lmprintf(MSG_085, tmp));
|
|
|
|
static_sprintf(tmp, "%s/%s-%s/%s.%s", FILES_URL, syslinux, iso_report.sl_version_str, ldlinux, ldlinux_ext[i]);
|
|
|
|
SetWindowTextU(hISOFileName, tmp);
|
|
|
|
syslinux_ldlinux_len[i] = DownloadFile(tmp, &tmp[sizeof(FILES_URL)], hISOProgressDlg);
|
|
|
|
if (syslinux_ldlinux_len[i] == 0) {
|
|
|
|
uprintf("Couldn't download the files - cancelling\n");
|
|
|
|
return FALSE;
|
|
|
|
}
|
2014-01-21 17:08:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-06-15 16:31:55 +00:00
|
|
|
} else if (dt == DT_SYSLINUX_V5) {
|
2014-01-14 20:17:07 +00:00
|
|
|
IGNORE_RETVAL(_chdirU(app_dir));
|
|
|
|
IGNORE_RETVAL(_mkdir(FILES_DIR));
|
|
|
|
IGNORE_RETVAL(_chdir(FILES_DIR));
|
2014-01-24 19:59:23 +00:00
|
|
|
static_sprintf(tmp, "%s-%s/%s.%s", syslinux, embedded_sl_version_str[1], ldlinux, ldlinux_ext[2]);
|
2014-01-21 17:08:41 +00:00
|
|
|
fd = fopenU(tmp, "rb");
|
2013-06-15 16:31:55 +00:00
|
|
|
if (fd != NULL) {
|
2014-01-21 17:08:41 +00:00
|
|
|
uprintf("Will reuse './%s/%s' for Syslinux installation\n", FILES_DIR, tmp);
|
2013-06-15 16:31:55 +00:00
|
|
|
fclose(fd);
|
|
|
|
} else {
|
2014-01-21 17:08:41 +00:00
|
|
|
static_sprintf(tmp, "%s.%s", ldlinux, ldlinux_ext[2]);
|
|
|
|
PrintStatus(0, FALSE, MSG_206, tmp);
|
|
|
|
// MSG_104: "Syslinux v5.0 or later requires a '%s' file to be installed"
|
|
|
|
r = MessageBoxU(hMainDialog, lmprintf(MSG_104, tmp, tmp),
|
2014-01-24 02:46:06 +00:00
|
|
|
lmprintf(MSG_103, tmp), MB_YESNOCANCEL|MB_ICONWARNING|MB_IS_RTL);
|
2013-12-27 16:06:59 +00:00
|
|
|
if (r == IDCANCEL)
|
2013-06-15 16:31:55 +00:00
|
|
|
return FALSE;
|
|
|
|
if (r == IDYES) {
|
2014-01-24 19:59:23 +00:00
|
|
|
static_sprintf(tmp, "%s-%s", syslinux, embedded_sl_version_str[1]);
|
2014-01-14 20:17:07 +00:00
|
|
|
IGNORE_RETVAL(_mkdir(tmp));
|
2014-01-24 19:59:23 +00:00
|
|
|
static_sprintf(tmp, "%s/%s-%s/%s.%s", FILES_URL, syslinux, embedded_sl_version_str[1], ldlinux, ldlinux_ext[2]);
|
2014-01-21 17:08:41 +00:00
|
|
|
SetWindowTextU(hISOProgressDlg, lmprintf(MSG_085, tmp));
|
|
|
|
SetWindowTextU(hISOFileName, tmp);
|
|
|
|
DownloadFile(tmp, &tmp[sizeof(FILES_URL)], hISOProgressDlg);
|
2013-06-15 16:31:55 +00:00
|
|
|
}
|
|
|
|
}
|
2013-10-31 22:59:53 +00:00
|
|
|
} else if (dt == DT_WINME) {
|
|
|
|
if ((size_check) && (ComboBox_GetItemData(hClusterSize, ComboBox_GetCurSel(hClusterSize)) >= 65536)) {
|
|
|
|
// MS-DOS cannot boot from a drive using a 64 kilobytes Cluster size
|
2014-01-24 02:46:06 +00:00
|
|
|
MessageBoxU(hMainDialog, lmprintf(MSG_110), lmprintf(MSG_111), MB_OK|MB_ICONERROR|MB_IS_RTL);
|
2013-10-31 22:59:53 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
2013-01-25 01:38:10 +00:00
|
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-02 13:16:49 +00:00
|
|
|
void InitDialog(HWND hDlg)
|
|
|
|
{
|
|
|
|
HINSTANCE hDllInst;
|
2014-01-21 17:08:41 +00:00
|
|
|
DWORD len;
|
2012-02-02 13:16:49 +00:00
|
|
|
HDC hDC;
|
2013-01-20 23:34:13 +00:00
|
|
|
int i, i16, s16;
|
2014-01-21 17:08:41 +00:00
|
|
|
char tmp[128], *token, *buf;
|
|
|
|
static char* resource[2] = { MAKEINTRESOURCEA(IDR_SL_LDLINUX_V4_SYS), MAKEINTRESOURCEA(IDR_SL_LDLINUX_V5_SYS) };
|
2012-02-02 13:16:49 +00:00
|
|
|
|
2012-02-07 02:05:58 +00:00
|
|
|
#ifdef RUFUS_TEST
|
|
|
|
ShowWindow(GetDlgItem(hDlg, IDC_TEST), SW_SHOW);
|
|
|
|
#endif
|
|
|
|
|
2012-02-02 13:16:49 +00:00
|
|
|
// Quite a burden to carry around as parameters
|
|
|
|
hMainDialog = hDlg;
|
|
|
|
hDeviceList = GetDlgItem(hDlg, IDC_DEVICE);
|
2013-10-15 21:58:27 +00:00
|
|
|
hPartitionScheme = GetDlgItem(hDlg, IDC_PARTITION_TYPE);
|
2012-02-02 13:16:49 +00:00
|
|
|
hFileSystem = GetDlgItem(hDlg, IDC_FILESYSTEM);
|
|
|
|
hClusterSize = GetDlgItem(hDlg, IDC_CLUSTERSIZE);
|
|
|
|
hLabel = GetDlgItem(hDlg, IDC_LABEL);
|
|
|
|
hProgress = GetDlgItem(hDlg, IDC_PROGRESS);
|
2013-01-24 21:30:11 +00:00
|
|
|
hBoot = GetDlgItem(hDlg, IDC_BOOT);
|
|
|
|
hBootType = GetDlgItem(hDlg, IDC_BOOTTYPE);
|
2012-02-02 13:16:49 +00:00
|
|
|
hSelectISO = GetDlgItem(hDlg, IDC_SELECT_ISO);
|
|
|
|
hNBPasses = GetDlgItem(hDlg, IDC_NBPASSES);
|
2012-05-16 22:38:39 +00:00
|
|
|
hDiskID = GetDlgItem(hDlg, IDC_DISK_ID);
|
2012-02-02 13:16:49 +00:00
|
|
|
|
|
|
|
// High DPI scaling
|
|
|
|
i16 = GetSystemMetrics(SM_CXSMICON);
|
|
|
|
hDC = GetDC(hDlg);
|
|
|
|
fScale = GetDeviceCaps(hDC, LOGPIXELSX) / 96.0f;
|
|
|
|
ReleaseDC(hDlg, hDC);
|
2012-06-04 16:35:32 +00:00
|
|
|
// Adjust icon size lookup
|
|
|
|
s16 = i16;
|
|
|
|
if (s16 >= 54)
|
|
|
|
s16 = 64;
|
|
|
|
else if (s16 >= 40)
|
|
|
|
s16 = 48;
|
|
|
|
else if (s16 >= 28)
|
|
|
|
s16 = 32;
|
|
|
|
else if (s16 >= 20)
|
|
|
|
s16 = 24;
|
2012-02-02 13:16:49 +00:00
|
|
|
|
|
|
|
// Create the title bar icon
|
2012-12-05 01:53:10 +00:00
|
|
|
SetTitleBarIcon(hDlg);
|
2012-03-11 01:55:25 +00:00
|
|
|
GetWindowTextA(hDlg, tmp, sizeof(tmp));
|
|
|
|
// Count of Microsoft for making it more attractive to read a
|
|
|
|
// version using strtok() than using GetFileVersionInfo()
|
2014-01-24 19:59:23 +00:00
|
|
|
token = strtok(tmp, " ");
|
2012-03-11 01:55:25 +00:00
|
|
|
for (i=0; (i<4) && ((token = strtok(NULL, ".")) != NULL); i++)
|
2012-12-07 00:54:40 +00:00
|
|
|
rufus_version[i] = (uint16_t)atoi(token);
|
2014-01-24 19:59:23 +00:00
|
|
|
if (right_to_left_mode) {
|
|
|
|
static_sprintf(tmp, "%d.%d.%d.%d " APPLICATION_NAME, rufus_version[0], rufus_version[1], rufus_version[2], rufus_version[3]);
|
|
|
|
SetWindowTextU(hDlg, tmp);
|
|
|
|
}
|
|
|
|
uprintf(APPLICATION_NAME " version: %d.%d.%d.%d\n", rufus_version[0], rufus_version[1], rufus_version[2], rufus_version[3]);
|
2014-01-21 17:08:41 +00:00
|
|
|
for (i=0; i<ARRAYSIZE(resource); i++) {
|
|
|
|
buf = (char*)GetResource(hMainInstance, resource[i], _RT_RCDATA, "ldlinux_sys", &len, FALSE);
|
|
|
|
if ((buf == NULL) || (len < 16)) {
|
|
|
|
uprintf("Warning: could not read embedded Syslinux v%d version", i+4);
|
|
|
|
} else {
|
|
|
|
embedded_sl_version[i] = (((uint8_t)strtoul(&buf[0xb], &token, 10))<<8) + (uint8_t)strtoul(&token[1], NULL, 10);
|
2014-01-24 19:59:23 +00:00
|
|
|
static_sprintf(embedded_sl_version_str[i], "%d.%02d", SL_MAJOR(embedded_sl_version[i]), SL_MINOR(embedded_sl_version[i]));
|
2014-01-21 17:08:41 +00:00
|
|
|
}
|
|
|
|
}
|
2014-01-24 19:59:23 +00:00
|
|
|
uprintf("Syslinux versions: %s, %s", embedded_sl_version_str[0], embedded_sl_version_str[1]);
|
|
|
|
uprintf("Windows version: %s\n", WindowsVersionStr);
|
|
|
|
uprintf("Locale ID: 0x%04X\n", GetUserDefaultUILanguage());
|
2013-10-15 21:58:27 +00:00
|
|
|
|
|
|
|
SetClusterSizeLabels();
|
|
|
|
|
2012-03-28 18:50:21 +00:00
|
|
|
// Prefer FreeDOS to MS-DOS
|
|
|
|
selection_default = DT_FREEDOS;
|
2012-03-29 17:16:06 +00:00
|
|
|
// Create the status line and initialize the taskbar icon for progress overlay
|
2012-02-02 13:16:49 +00:00
|
|
|
CreateStatusBar();
|
2012-03-29 17:16:06 +00:00
|
|
|
CreateTaskbarList();
|
|
|
|
SetTaskbarProgressState(TASKBAR_NORMAL);
|
|
|
|
|
2012-02-02 13:16:49 +00:00
|
|
|
// Use maximum granularity for the progress bar
|
2013-01-09 21:54:28 +00:00
|
|
|
SendMessage(hProgress, PBM_SETRANGE, 0, (MAX_PROGRESS<<16) & 0xFFFF0000);
|
2012-02-02 13:16:49 +00:00
|
|
|
// Fill up the passes
|
2013-01-25 01:38:10 +00:00
|
|
|
for (i=0; i<4; i++) {
|
2013-10-15 21:58:27 +00:00
|
|
|
IGNORE_RETVAL(ComboBox_AddStringU(hNBPasses, lmprintf((i==0)?MSG_034:MSG_035, i+1)));
|
2013-01-25 01:38:10 +00:00
|
|
|
}
|
2012-02-02 13:16:49 +00:00
|
|
|
IGNORE_RETVAL(ComboBox_SetCurSel(hNBPasses, 1));
|
2013-01-25 01:38:10 +00:00
|
|
|
SetPassesTooltip();
|
2012-02-02 13:16:49 +00:00
|
|
|
// Fill up the DOS type dropdown
|
2013-01-24 21:30:11 +00:00
|
|
|
IGNORE_RETVAL(ComboBox_SetItemData(hBootType, ComboBox_AddStringU(hBootType, "MS-DOS"), DT_WINME));
|
|
|
|
IGNORE_RETVAL(ComboBox_SetItemData(hBootType, ComboBox_AddStringU(hBootType, "FreeDOS"), DT_FREEDOS));
|
2013-10-15 21:58:27 +00:00
|
|
|
IGNORE_RETVAL(ComboBox_SetItemData(hBootType, ComboBox_AddStringU(hBootType, lmprintf(MSG_036)), DT_ISO));
|
2013-01-24 21:30:11 +00:00
|
|
|
IGNORE_RETVAL(ComboBox_SetCurSel(hBootType, selection_default));
|
2012-05-22 11:30:22 +00:00
|
|
|
// Fill up the MBR masqueraded disk IDs ("8 disks should be enough for anybody")
|
2013-10-15 21:58:27 +00:00
|
|
|
IGNORE_RETVAL(ComboBox_SetItemData(hDiskID, ComboBox_AddStringU(hDiskID, lmprintf(MSG_030, "0x80")), 0x80));
|
2012-05-25 16:54:06 +00:00
|
|
|
for (i=1; i<=7; i++) {
|
2013-10-15 21:58:27 +00:00
|
|
|
IGNORE_RETVAL(ComboBox_SetItemData(hDiskID, ComboBox_AddStringU(hDiskID, lmprintf(MSG_109, 0x80+i, i+1)), 0x80+i));
|
2012-05-16 22:38:39 +00:00
|
|
|
}
|
|
|
|
IGNORE_RETVAL(ComboBox_SetCurSel(hDiskID, 0));
|
|
|
|
|
2012-02-02 13:16:49 +00:00
|
|
|
// Create the string array
|
|
|
|
StrArrayCreate(&DriveID, MAX_DRIVES);
|
|
|
|
StrArrayCreate(&DriveLabel, MAX_DRIVES);
|
2012-05-16 22:38:39 +00:00
|
|
|
// Set various checkboxes
|
2012-02-02 13:16:49 +00:00
|
|
|
CheckDlgButton(hDlg, IDC_QUICKFORMAT, BST_CHECKED);
|
2013-01-24 21:30:11 +00:00
|
|
|
CheckDlgButton(hDlg, IDC_BOOT, BST_CHECKED);
|
2012-02-21 19:46:28 +00:00
|
|
|
CheckDlgButton(hDlg, IDC_SET_ICON, BST_CHECKED);
|
2012-02-02 13:16:49 +00:00
|
|
|
|
|
|
|
// Load system icons (NB: Use the excellent http://www.nirsoft.net/utils/iconsext.html to find icon IDs)
|
|
|
|
hDllInst = LoadLibraryA("shell32.dll");
|
2012-06-04 16:35:32 +00:00
|
|
|
hIconDisc = (HICON)LoadImage(hDllInst, MAKEINTRESOURCE(12), IMAGE_ICON, s16, s16, LR_DEFAULTCOLOR|LR_SHARED);
|
2013-10-24 21:57:34 +00:00
|
|
|
hIconLang = (HICON)LoadImage(hDllInst, MAKEINTRESOURCE(244), IMAGE_ICON, s16, s16, LR_DEFAULTCOLOR|LR_SHARED);
|
2012-05-16 22:38:39 +00:00
|
|
|
if (nWindowsVersion >= WINDOWS_VISTA) {
|
2012-06-04 16:35:32 +00:00
|
|
|
hIconDown = (HICON)LoadImage(hDllInst, MAKEINTRESOURCE(16750), IMAGE_ICON, s16, s16, LR_DEFAULTCOLOR|LR_SHARED);
|
|
|
|
hIconUp = (HICON)LoadImage(hDllInst, MAKEINTRESOURCE(16749), IMAGE_ICON, s16, s16, LR_DEFAULTCOLOR|LR_SHARED);
|
2012-05-16 22:38:39 +00:00
|
|
|
} else {
|
|
|
|
hIconDown = (HICON)LoadImage(hMainInstance, MAKEINTRESOURCE(IDI_DOWN), IMAGE_ICON, 16, 16, 0);
|
|
|
|
hIconUp = (HICON)LoadImage(hMainInstance, MAKEINTRESOURCE(IDI_UP), IMAGE_ICON, 16, 16, 0);
|
|
|
|
}
|
2012-02-02 13:16:49 +00:00
|
|
|
|
2012-05-16 22:38:39 +00:00
|
|
|
// Set the icons on the the buttons
|
2012-02-02 13:16:49 +00:00
|
|
|
pImageList_Create = (ImageList_Create_t) GetProcAddress(GetDLLHandle("Comctl32.dll"), "ImageList_Create");
|
|
|
|
pImageList_ReplaceIcon = (ImageList_ReplaceIcon_t) GetProcAddress(GetDLLHandle("Comctl32.dll"), "ImageList_ReplaceIcon");
|
|
|
|
|
2012-05-16 22:38:39 +00:00
|
|
|
bi_iso.himl = pImageList_Create(i16, i16, ILC_COLOR32 | ILC_MASK, 1, 0);
|
|
|
|
pImageList_ReplaceIcon(bi_iso.himl, -1, hIconDisc);
|
|
|
|
SetRect(&bi_iso.margin, 0, 1, 0, 0);
|
|
|
|
bi_iso.uAlign = BUTTON_IMAGELIST_ALIGN_CENTER;
|
2013-10-24 21:57:34 +00:00
|
|
|
bi_lang.himl = pImageList_Create(i16, i16, ILC_COLOR32 | ILC_MASK, 1, 0);
|
|
|
|
pImageList_ReplaceIcon(bi_lang.himl, -1, hIconLang);
|
|
|
|
SetRect(&bi_lang.margin, 0, 1, 0, 0);
|
|
|
|
bi_lang.uAlign = BUTTON_IMAGELIST_ALIGN_CENTER;
|
2012-05-16 22:38:39 +00:00
|
|
|
bi_down.himl = pImageList_Create(i16, i16, ILC_COLOR32 | ILC_MASK, 1, 0);
|
|
|
|
pImageList_ReplaceIcon(bi_down.himl, -1, hIconDown);
|
|
|
|
SetRect(&bi_down.margin, 0, 0, 0, 0);
|
|
|
|
bi_down.uAlign = BUTTON_IMAGELIST_ALIGN_CENTER;
|
|
|
|
bi_up.himl = pImageList_Create(i16, i16, ILC_COLOR32 | ILC_MASK, 1, 0);
|
|
|
|
pImageList_ReplaceIcon(bi_up.himl, -1, hIconUp);
|
|
|
|
SetRect(&bi_up.margin, 0, 0, 0, 0);
|
|
|
|
bi_up.uAlign = BUTTON_IMAGELIST_ALIGN_CENTER;
|
|
|
|
|
|
|
|
SendMessage(hSelectISO, BCM_SETIMAGELIST, 0, (LPARAM)&bi_iso);
|
2013-10-24 21:57:34 +00:00
|
|
|
SendMessage(GetDlgItem(hDlg, IDC_LANG), BCM_SETIMAGELIST, 0, (LPARAM)&bi_lang);
|
2012-05-16 22:38:39 +00:00
|
|
|
SendMessage(GetDlgItem(hDlg, IDC_ADVANCED), BCM_SETIMAGELIST, 0, (LPARAM)&bi_down);
|
2012-05-22 11:30:22 +00:00
|
|
|
|
|
|
|
// Set the various tooltips
|
2013-10-15 21:58:27 +00:00
|
|
|
CreateTooltip(hFileSystem, lmprintf(MSG_157), -1);
|
|
|
|
CreateTooltip(hClusterSize, lmprintf(MSG_158), -1);
|
|
|
|
CreateTooltip(hLabel, lmprintf(MSG_159), -1);
|
|
|
|
CreateTooltip(GetDlgItem(hDlg, IDC_ADVANCED), lmprintf(MSG_160), -1);
|
|
|
|
CreateTooltip(GetDlgItem(hDlg, IDC_BADBLOCKS), lmprintf(MSG_161), -1);
|
|
|
|
CreateTooltip(GetDlgItem(hDlg, IDC_QUICKFORMAT), lmprintf(MSG_162), -1);
|
|
|
|
CreateTooltip(hBoot, lmprintf(MSG_163), -1);
|
|
|
|
CreateTooltip(hBootType, lmprintf(MSG_164), -1);
|
|
|
|
CreateTooltip(hSelectISO, lmprintf(MSG_165), -1);
|
|
|
|
CreateTooltip(GetDlgItem(hDlg, IDC_SET_ICON), lmprintf(MSG_166), 10000);
|
|
|
|
CreateTooltip(GetDlgItem(hDlg, IDC_RUFUS_MBR), lmprintf(MSG_167), 10000);
|
|
|
|
CreateTooltip(hDiskID, lmprintf(MSG_168), 10000);
|
|
|
|
CreateTooltip(GetDlgItem(hDlg, IDC_EXTRA_PARTITION), lmprintf(MSG_169), -1);
|
|
|
|
CreateTooltip(GetDlgItem(hDlg, IDC_ENABLE_FIXED_DISKS), lmprintf(MSG_170), -1);
|
|
|
|
CreateTooltip(GetDlgItem(hDlg, IDC_START), lmprintf(MSG_171), -1);
|
|
|
|
CreateTooltip(GetDlgItem(hDlg, IDC_ABOUT), lmprintf(MSG_172), -1);
|
|
|
|
// TODO: add new tooltips
|
2012-05-16 22:38:39 +00:00
|
|
|
|
|
|
|
ToggleAdvanced(); // We start in advanced mode => go to basic mode
|
2013-02-04 01:14:28 +00:00
|
|
|
|
|
|
|
// Process commandline parameters
|
|
|
|
if (iso_provided) {
|
|
|
|
// Simulate a button click for ISO selection
|
|
|
|
PostMessage(hDlg, WM_COMMAND, IDC_SELECT_ISO, 0);
|
|
|
|
}
|
2012-02-02 13:16:49 +00:00
|
|
|
}
|
|
|
|
|
2013-06-03 20:32:22 +00:00
|
|
|
static void PrintStatus2000(const char* str, BOOL val)
|
|
|
|
{
|
2013-12-19 23:56:40 +00:00
|
|
|
PrintStatus(2000, FALSE, (val)?MSG_250:MSG_251, str);
|
2013-06-03 20:32:22 +00:00
|
|
|
}
|
|
|
|
|
2013-10-24 21:57:34 +00:00
|
|
|
void ShowLanguageMenu(HWND hDlg)
|
|
|
|
{
|
|
|
|
POINT pt;
|
|
|
|
HMENU menu;
|
|
|
|
loc_cmd* lcmd = NULL;
|
2014-01-24 02:46:06 +00:00
|
|
|
char lang[256];
|
|
|
|
char *search = "()";
|
|
|
|
char *l, *r, *dup;
|
2013-10-24 21:57:34 +00:00
|
|
|
|
2014-01-24 02:46:06 +00:00
|
|
|
UM_LANGUAGE_MENU_MAX = UM_LANGUAGE_MENU;
|
2013-10-24 21:57:34 +00:00
|
|
|
menu = CreatePopupMenu();
|
|
|
|
list_for_each_entry(lcmd, &locale_list, loc_cmd, list) {
|
2014-01-24 02:46:06 +00:00
|
|
|
// The appearance of LTR languages must be fixed for RTL menus
|
|
|
|
if ((right_to_left_mode) && (!(lcmd->ctrl_id & LOC_RIGHT_TO_LEFT))) {
|
|
|
|
dup = safe_strdup(lcmd->txt[1]);
|
|
|
|
l = strtok(dup, search);
|
|
|
|
r = strtok(NULL, search);
|
|
|
|
static_sprintf(lang, LEFT_TO_RIGHT_MARK "(%s) " LEFT_TO_RIGHT_MARK "%s", r, l);
|
|
|
|
safe_free(dup);
|
|
|
|
} else {
|
|
|
|
safe_strcpy(lang, sizeof(lang), lcmd->txt[1]);
|
|
|
|
}
|
|
|
|
InsertMenuU(menu, -1, MF_BYPOSITION|((selected_locale == lcmd)?MF_CHECKED:0), UM_LANGUAGE_MENU_MAX++, lang);
|
2013-10-24 21:57:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
SetForegroundWindow(hDlg);
|
|
|
|
GetCursorPos(&pt);
|
|
|
|
TrackPopupMenu(menu, TPM_TOPALIGN|TPM_RIGHTALIGN, pt.x, pt.y, 0, hMainDialog, NULL);
|
|
|
|
DestroyMenu(menu);
|
|
|
|
}
|
2013-10-15 21:58:27 +00:00
|
|
|
|
2014-02-09 02:54:07 +00:00
|
|
|
void SetBoot(int fs, int bt)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
IGNORE_RETVAL(ComboBox_ResetContent(hBootType));
|
|
|
|
if ((bt == BT_BIOS) && ((fs == FS_FAT16) || (fs == FS_FAT32))) {
|
|
|
|
IGNORE_RETVAL(ComboBox_SetItemData(hBootType, ComboBox_AddStringU(hBootType, "MS-DOS"), DT_WINME));
|
|
|
|
IGNORE_RETVAL(ComboBox_SetItemData(hBootType, ComboBox_AddStringU(hBootType, "FreeDOS"), DT_FREEDOS));
|
|
|
|
}
|
|
|
|
IGNORE_RETVAL(ComboBox_SetItemData(hBootType, ComboBox_AddStringU(hBootType, lmprintf(MSG_036)), DT_ISO));
|
|
|
|
IGNORE_RETVAL(ComboBox_SetItemData(hBootType, ComboBox_AddStringU(hBootType, lmprintf(MSG_095)), DT_IMG));
|
|
|
|
// If needed (advanced mode) also append a Syslinux option
|
|
|
|
if ( (bt == BT_BIOS) && (((fs == FS_FAT16) || (fs == FS_FAT32)) && (advanced_mode)) ) {
|
|
|
|
IGNORE_RETVAL(ComboBox_SetItemData(hBootType, ComboBox_AddStringU(hBootType, "Syslinux 4"), DT_SYSLINUX_V4));
|
|
|
|
IGNORE_RETVAL(ComboBox_SetItemData(hBootType, ComboBox_AddStringU(hBootType, "Syslinux 5"), DT_SYSLINUX_V5));
|
|
|
|
IGNORE_RETVAL(ComboBox_SetItemData(hBootType, ComboBox_AddStringU(hBootType, "ReactOS"), DT_REACTOS));
|
|
|
|
}
|
|
|
|
if ((!advanced_mode) && (selection_default >= DT_SYSLINUX_V4)) {
|
|
|
|
selection_default = DT_FREEDOS;
|
|
|
|
CheckDlgButton(hMainDialog, IDC_DISK_ID, BST_UNCHECKED);
|
|
|
|
}
|
|
|
|
for (i=0; i<ComboBox_GetCount(hBootType); i++) {
|
|
|
|
if (ComboBox_GetItemData(hBootType, i) == selection_default) {
|
|
|
|
IGNORE_RETVAL(ComboBox_SetCurSel(hBootType, i));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (i == ComboBox_GetCount(hBootType))
|
|
|
|
IGNORE_RETVAL(ComboBox_SetCurSel(hBootType, 0));
|
|
|
|
|
|
|
|
if (!IsWindowEnabled(hBoot)) {
|
|
|
|
EnableWindow(hBoot, TRUE);
|
|
|
|
EnableWindow(hBootType, TRUE);
|
|
|
|
EnableWindow(hSelectISO, TRUE);
|
2014-03-14 23:13:04 +00:00
|
|
|
CheckDlgButton(hMainDialog, IDC_BOOT, uBootChecked);
|
2014-02-09 02:54:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-11-17 01:43:06 +00:00
|
|
|
/*
|
2011-11-21 17:06:17 +00:00
|
|
|
* Main dialog callback
|
|
|
|
*/
|
2011-11-18 01:58:08 +00:00
|
|
|
static INT_PTR CALLBACK MainCallback(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
|
2011-11-13 20:53:23 +00:00
|
|
|
{
|
2011-12-08 12:14:21 +00:00
|
|
|
DRAWITEMSTRUCT* pDI;
|
2012-05-30 23:32:25 +00:00
|
|
|
POINT Point;
|
|
|
|
RECT DialogRect, DesktopRect;
|
2013-10-24 21:57:34 +00:00
|
|
|
int nDeviceIndex, fs, bt, i, nWidth, nHeight, nb_devices, selected_language;
|
2013-02-10 21:54:47 +00:00
|
|
|
static DWORD DeviceNum = 0, LastRefresh = 0;
|
2013-10-15 21:58:27 +00:00
|
|
|
char tmp[128];
|
2012-11-04 21:39:25 +00:00
|
|
|
static BOOL first_log_display = TRUE, user_changed_label = FALSE;
|
2013-12-20 18:32:10 +00:00
|
|
|
static ULONG ulRegister = 0;
|
|
|
|
static LPITEMIDLIST pidlDesktop = NULL;
|
|
|
|
static MY_SHChangeNotifyEntry NotifyEntry;
|
2013-10-24 21:57:34 +00:00
|
|
|
loc_cmd* lcmd = NULL;
|
2013-12-20 18:32:10 +00:00
|
|
|
PF_DECL(SHChangeNotifyRegister);
|
|
|
|
PF_DECL(SHChangeNotifyDeregister);
|
2011-11-21 17:06:17 +00:00
|
|
|
|
2011-11-13 20:53:23 +00:00
|
|
|
switch (message) {
|
|
|
|
|
2013-12-20 18:32:10 +00:00
|
|
|
case UM_MEDIA_CHANGE:
|
|
|
|
wParam = DBT_CUSTOMEVENT;
|
|
|
|
// Fall through
|
2011-11-13 20:53:23 +00:00
|
|
|
case WM_DEVICECHANGE:
|
2013-02-10 21:54:47 +00:00
|
|
|
// The Windows hotplug subsystem sucks. Among other things, if you insert a GPT partitioned
|
|
|
|
// USB drive with zero partitions, the only device messages you will get are a stream of
|
|
|
|
// DBT_DEVNODES_CHANGED and that's it. But those messages are also issued when you get a
|
|
|
|
// DBT_DEVICEARRIVAL and DBT_DEVICEREMOVECOMPLETE, and there's a whole slew of them so we
|
|
|
|
// can't really issue a refresh for each one we receive
|
|
|
|
// What we do then is arm a timer on DBT_DEVNODES_CHANGED, if it's been more than 1 second
|
|
|
|
// since last refresh/arm timer, and have that timer send DBT_CUSTOMEVENT when it expires.
|
2014-02-09 02:54:07 +00:00
|
|
|
// DO *NOT* USE WM_DEVICECHANGE AS THE MESSAGE FROM THE TIMER PROC, as it may be filtered!
|
|
|
|
// For instance filtering will occur when (un)plugging in a FreeBSD UFD on Windows 8.
|
|
|
|
// Intead, use a custom user message, such as UM_MEDIA_CHANGE, to set DBT_CUSTOMEVENT.
|
2013-02-10 21:54:47 +00:00
|
|
|
if (format_thid == NULL) {
|
|
|
|
switch (wParam) {
|
|
|
|
case DBT_DEVICEARRIVAL:
|
|
|
|
case DBT_DEVICEREMOVECOMPLETE:
|
2013-12-20 18:32:10 +00:00
|
|
|
case DBT_CUSTOMEVENT: // Sent by our timer refresh function or for card reader media change
|
2013-02-10 21:54:47 +00:00
|
|
|
LastRefresh = GetTickCount(); // Don't care about 49.7 days rollback of GetTickCount()
|
|
|
|
KillTimer(hMainDialog, TID_REFRESH_TIMER);
|
|
|
|
GetUSBDevices((DWORD)ComboBox_GetItemData(hDeviceList, ComboBox_GetCurSel(hDeviceList)));
|
|
|
|
user_changed_label = FALSE;
|
|
|
|
return (INT_PTR)TRUE;
|
|
|
|
case DBT_DEVNODES_CHANGED:
|
|
|
|
// If it's been more than a second since last device refresh, arm a refresh timer
|
|
|
|
if (GetTickCount() > LastRefresh + 1000) {
|
|
|
|
LastRefresh = GetTickCount();
|
|
|
|
SetTimer(hMainDialog, TID_REFRESH_TIMER, 1000, RefreshTimer);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2011-11-26 00:25:04 +00:00
|
|
|
}
|
|
|
|
break;
|
2011-11-13 20:53:23 +00:00
|
|
|
|
|
|
|
case WM_INITDIALOG:
|
2013-12-20 18:32:10 +00:00
|
|
|
PF_INIT(SHChangeNotifyRegister, shell32);
|
2013-10-15 21:58:27 +00:00
|
|
|
apply_localization(IDD_DIALOG, hDlg);
|
2012-12-02 03:50:08 +00:00
|
|
|
SetUpdateCheck();
|
2013-10-24 21:57:34 +00:00
|
|
|
advanced_mode = TRUE;
|
2012-05-30 23:32:25 +00:00
|
|
|
// Create the log window (hidden)
|
2013-10-24 21:57:34 +00:00
|
|
|
first_log_display = TRUE;
|
|
|
|
log_displayed = FALSE;
|
2014-01-24 02:46:06 +00:00
|
|
|
hLogDlg = CreateDialogW(hMainInstance, MAKEINTRESOURCEW(IDD_LOG + IDD_IS_RTL), hDlg, (DLGPROC)LogProc);
|
2012-02-02 13:16:49 +00:00
|
|
|
InitDialog(hDlg);
|
2012-02-16 23:40:31 +00:00
|
|
|
GetUSBDevices(0);
|
2012-12-06 01:40:44 +00:00
|
|
|
CheckForUpdates(FALSE);
|
2013-12-20 18:32:10 +00:00
|
|
|
// Register MEDIA_INSERTED/MEDIA_REMOVED notifications for card readers
|
|
|
|
if ((pfSHChangeNotifyRegister != NULL) && (SUCCEEDED(SHGetSpecialFolderLocation(0, CSIDL_DESKTOP, &pidlDesktop)))) {
|
|
|
|
NotifyEntry.pidl = pidlDesktop;
|
|
|
|
NotifyEntry.fRecursive = TRUE;
|
|
|
|
// NB: The following only works if the media is already formatted.
|
|
|
|
// If you insert a blank card, notifications will not be sent... :(
|
|
|
|
ulRegister = pfSHChangeNotifyRegister(hDlg, 0x0001|0x0002|0x8000,
|
|
|
|
SHCNE_MEDIAINSERTED|SHCNE_MEDIAREMOVED, UM_MEDIA_CHANGE, 1, &NotifyEntry);
|
|
|
|
}
|
2012-12-04 01:47:45 +00:00
|
|
|
PostMessage(hMainDialog, UM_ISO_CREATE, 0, 0);
|
2011-11-13 20:53:23 +00:00
|
|
|
return (INT_PTR)TRUE;
|
|
|
|
|
2012-02-15 00:52:40 +00:00
|
|
|
// The things one must do to get an ellipsis on the status bar...
|
2011-12-08 12:14:21 +00:00
|
|
|
case WM_DRAWITEM:
|
|
|
|
if (wParam == IDC_STATUS) {
|
|
|
|
pDI = (DRAWITEMSTRUCT*)lParam;
|
|
|
|
pDI->rcItem.top += (int)(2.0f * fScale);
|
|
|
|
pDI->rcItem.left += (int)(4.0f * fScale);
|
2012-02-15 00:52:40 +00:00
|
|
|
SetBkMode(pDI->hDC, TRANSPARENT);
|
|
|
|
switch(pDI->itemID) {
|
|
|
|
case 0: // left part
|
|
|
|
DrawTextExU(pDI->hDC, szStatusMessage, -1, &pDI->rcItem,
|
2012-05-30 23:32:25 +00:00
|
|
|
DT_LEFT|DT_END_ELLIPSIS|DT_PATH_ELLIPSIS, NULL);
|
2012-02-15 00:52:40 +00:00
|
|
|
return (INT_PTR)TRUE;
|
|
|
|
case 1: // right part
|
|
|
|
SetTextColor(pDI->hDC, GetSysColor(COLOR_3DSHADOW));
|
|
|
|
DrawTextExA(pDI->hDC, szTimer, -1, &pDI->rcItem, DT_LEFT, NULL);
|
|
|
|
return (INT_PTR)TRUE;
|
|
|
|
}
|
2011-12-08 12:14:21 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2011-11-13 20:53:23 +00:00
|
|
|
case WM_COMMAND:
|
2013-10-24 21:57:34 +00:00
|
|
|
if ((LOWORD(wParam) >= UM_LANGUAGE_MENU) && (LOWORD(wParam) < UM_LANGUAGE_MENU_MAX)) {
|
|
|
|
selected_language = LOWORD(wParam) - UM_LANGUAGE_MENU;
|
|
|
|
i = 0;
|
|
|
|
list_for_each_entry(lcmd, &locale_list, loc_cmd, list) {
|
|
|
|
if (i++ == selected_language) {
|
|
|
|
if (selected_locale != lcmd) {
|
|
|
|
selected_locale = lcmd;
|
|
|
|
relaunch = TRUE;
|
|
|
|
PostMessage(hDlg, WM_COMMAND, IDCANCEL, 0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-11-13 20:53:23 +00:00
|
|
|
switch(LOWORD(wParam)) {
|
2011-11-21 20:12:23 +00:00
|
|
|
case IDOK: // close application
|
|
|
|
case IDCANCEL:
|
2013-12-20 18:32:10 +00:00
|
|
|
PF_INIT(SHChangeNotifyDeregister, shell32);
|
2012-02-07 16:17:14 +00:00
|
|
|
EnableWindow(GetDlgItem(hISOProgressDlg, IDC_ISO_ABORT), FALSE);
|
|
|
|
EnableWindow(GetDlgItem(hDlg, IDCANCEL), FALSE);
|
2012-02-07 02:05:58 +00:00
|
|
|
if (format_thid != NULL) {
|
2013-10-15 21:58:27 +00:00
|
|
|
if (MessageBoxU(hMainDialog, lmprintf(MSG_105), lmprintf(MSG_049),
|
2014-01-24 02:46:06 +00:00
|
|
|
MB_YESNO|MB_ICONWARNING|MB_IS_RTL) == IDYES) {
|
2011-11-28 12:37:58 +00:00
|
|
|
// Operation may have completed in the meantime
|
2012-02-07 02:05:58 +00:00
|
|
|
if (format_thid != NULL) {
|
2011-11-28 12:37:58 +00:00
|
|
|
FormatStatus = ERROR_SEVERITY_ERROR|FAC(FACILITY_STORAGE)|ERROR_CANCELLED;
|
2013-12-19 23:56:40 +00:00
|
|
|
PrintStatus(0, FALSE, MSG_201);
|
2012-02-07 16:17:14 +00:00
|
|
|
uprintf("Cancelling (from main app)\n");
|
|
|
|
// Start a timer to detect blocking operations during ISO file extraction
|
|
|
|
if (iso_blocking_status >= 0) {
|
|
|
|
last_iso_blocking_status = iso_blocking_status;
|
|
|
|
SetTimer(hMainDialog, TID_BLOCKING_TIMER, 3000, BlockingTimer);
|
|
|
|
}
|
2011-11-28 01:32:18 +00:00
|
|
|
}
|
2012-02-07 16:17:14 +00:00
|
|
|
} else {
|
|
|
|
EnableWindow(GetDlgItem(hISOProgressDlg, IDC_ISO_ABORT), TRUE);
|
|
|
|
EnableWindow(GetDlgItem(hDlg, IDCANCEL), TRUE);
|
2011-11-28 01:32:18 +00:00
|
|
|
}
|
|
|
|
return (INT_PTR)TRUE;
|
|
|
|
}
|
2013-12-20 18:32:10 +00:00
|
|
|
if ((pfSHChangeNotifyDeregister != NULL) && (ulRegister != 0))
|
|
|
|
pfSHChangeNotifyDeregister(ulRegister);
|
2011-11-21 20:12:23 +00:00
|
|
|
PostQuitMessage(0);
|
|
|
|
StrArrayDestroy(&DriveID);
|
2011-11-24 02:24:50 +00:00
|
|
|
StrArrayDestroy(&DriveLabel);
|
2011-11-21 20:25:32 +00:00
|
|
|
DestroyAllTooltips();
|
2013-10-24 21:57:34 +00:00
|
|
|
DestroyWindow(hLogDlg);
|
|
|
|
GetWindowRect(hDlg, &relaunch_rc);
|
2011-11-21 20:12:23 +00:00
|
|
|
EndDialog(hDlg, 0);
|
|
|
|
break;
|
2011-11-21 17:06:17 +00:00
|
|
|
case IDC_ABOUT:
|
|
|
|
CreateAboutBox();
|
|
|
|
break;
|
2012-05-30 23:32:25 +00:00
|
|
|
case IDC_LOG:
|
2014-01-24 02:46:06 +00:00
|
|
|
// Place the log Window to the right (or left for RTL) of our dialog on first display
|
2012-05-30 23:32:25 +00:00
|
|
|
if (first_log_display) {
|
|
|
|
GetClientRect(GetDesktopWindow(), &DesktopRect);
|
|
|
|
GetWindowRect(hLogDlg, &DialogRect);
|
|
|
|
nWidth = DialogRect.right - DialogRect.left;
|
|
|
|
nHeight = DialogRect.bottom - DialogRect.top;
|
|
|
|
GetWindowRect(hDlg, &DialogRect);
|
2014-01-24 02:46:06 +00:00
|
|
|
if (right_to_left_mode)
|
|
|
|
Point.x = max(DialogRect.left - GetSystemMetrics(SM_CXSIZEFRAME)-(int)(2.0f * fScale) - nWidth, 0);
|
|
|
|
else
|
|
|
|
Point.x = min(DialogRect.right + GetSystemMetrics(SM_CXSIZEFRAME)+(int)(2.0f * fScale), DesktopRect.right - nWidth);
|
|
|
|
|
2012-05-30 23:32:25 +00:00
|
|
|
Point.y = max(DialogRect.top, DesktopRect.top - nHeight);
|
|
|
|
MoveWindow(hLogDlg, Point.x, Point.y, nWidth, nHeight, FALSE);
|
2014-01-24 02:46:06 +00:00
|
|
|
// The log may have been recentered to fit the screen, in which case, try to shift our main dialog left (or right for RTL)
|
2013-06-25 21:50:22 +00:00
|
|
|
nWidth = DialogRect.right - DialogRect.left;
|
|
|
|
nHeight = DialogRect.bottom - DialogRect.top;
|
2014-01-24 02:46:06 +00:00
|
|
|
if (right_to_left_mode) {
|
|
|
|
Point.x = DialogRect.left;
|
|
|
|
GetWindowRect(hLogDlg, &DialogRect);
|
|
|
|
Point.x = max(Point.x, DialogRect.right - DialogRect.left + GetSystemMetrics(SM_CXSIZEFRAME) + (int)(2.0f * fScale));
|
|
|
|
} else {
|
|
|
|
Point.x = max((DialogRect.left<0)?DialogRect.left:0,
|
|
|
|
Point.x - nWidth - GetSystemMetrics(SM_CXSIZEFRAME) - (int)(2.0f * fScale));
|
|
|
|
}
|
|
|
|
MoveWindow(hDlg, Point.x, Point.y, nWidth, nHeight, TRUE);
|
2012-05-30 23:32:25 +00:00
|
|
|
first_log_display = FALSE;
|
|
|
|
}
|
|
|
|
// Display the log Window
|
|
|
|
log_displayed = !log_displayed;
|
2012-05-31 12:05:12 +00:00
|
|
|
if (IsShown(hISOProgressDlg))
|
|
|
|
SetFocus(hISOProgressDlg);
|
2012-05-30 23:32:25 +00:00
|
|
|
// Set focus on the start button
|
|
|
|
SendMessage(hMainDialog, WM_NEXTDLGCTL, (WPARAM)FALSE, 0);
|
|
|
|
SendMessage(hMainDialog, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hMainDialog, IDC_START), TRUE);
|
2013-06-25 21:50:22 +00:00
|
|
|
// Must come last for the log window to get focus
|
|
|
|
ShowWindow(hLogDlg, log_displayed?SW_SHOW:SW_HIDE);
|
2012-05-30 23:32:25 +00:00
|
|
|
break;
|
2012-02-01 14:26:36 +00:00
|
|
|
#ifdef RUFUS_TEST
|
2012-01-31 01:40:22 +00:00
|
|
|
case IDC_TEST:
|
|
|
|
break;
|
2012-02-01 14:26:36 +00:00
|
|
|
#endif
|
2013-10-24 21:57:34 +00:00
|
|
|
case IDC_LANG:
|
|
|
|
ShowLanguageMenu(GetDlgItem(hDlg, IDC_LANG));
|
|
|
|
break;
|
2012-05-16 22:38:39 +00:00
|
|
|
case IDC_ADVANCED:
|
|
|
|
ToggleAdvanced();
|
|
|
|
SendMessage(hMainDialog, WM_COMMAND, (CBN_SELCHANGE<<16) | IDC_FILESYSTEM,
|
|
|
|
ComboBox_GetCurSel(hFileSystem));
|
|
|
|
break;
|
2012-11-04 21:39:25 +00:00
|
|
|
case IDC_LABEL:
|
|
|
|
if (HIWORD(wParam) == EN_CHANGE)
|
|
|
|
user_changed_label = TRUE;
|
|
|
|
break;
|
2011-11-24 02:24:50 +00:00
|
|
|
case IDC_DEVICE:
|
2012-03-03 23:12:48 +00:00
|
|
|
if (HIWORD(wParam) != CBN_SELCHANGE)
|
2011-11-18 23:41:28 +00:00
|
|
|
break;
|
2013-10-15 21:58:27 +00:00
|
|
|
nb_devices = ComboBox_GetCount(hDeviceList);
|
2013-12-19 23:56:40 +00:00
|
|
|
PrintStatus(0, TRUE, (nb_devices==1)?MSG_208:MSG_209, nb_devices);
|
2012-03-03 23:12:48 +00:00
|
|
|
PopulateProperties(ComboBox_GetCurSel(hDeviceList));
|
2012-11-03 17:40:33 +00:00
|
|
|
SendMessage(hMainDialog, WM_COMMAND, (CBN_SELCHANGE<<16) | IDC_FILESYSTEM,
|
|
|
|
ComboBox_GetCurSel(hFileSystem));
|
2011-11-27 23:40:28 +00:00
|
|
|
break;
|
2012-02-07 23:16:15 +00:00
|
|
|
case IDC_NBPASSES:
|
2012-03-03 23:12:48 +00:00
|
|
|
if (HIWORD(wParam) != CBN_SELCHANGE)
|
|
|
|
break;
|
2013-01-25 01:38:10 +00:00
|
|
|
SetPassesTooltip();
|
2012-02-07 23:16:15 +00:00
|
|
|
break;
|
2013-10-15 21:58:27 +00:00
|
|
|
case IDC_PARTITION_TYPE:
|
2013-01-27 01:40:09 +00:00
|
|
|
if (HIWORD(wParam) != CBN_SELCHANGE)
|
|
|
|
break;
|
|
|
|
SetPartitionSchemeTooltip();
|
|
|
|
SetFSFromISO();
|
|
|
|
// fall-through
|
2011-12-01 02:56:44 +00:00
|
|
|
case IDC_FILESYSTEM:
|
2012-02-02 13:16:49 +00:00
|
|
|
if (HIWORD(wParam) != CBN_SELCHANGE)
|
|
|
|
break;
|
|
|
|
fs = (int)ComboBox_GetItemData(hFileSystem, ComboBox_GetCurSel(hFileSystem));
|
2013-01-20 22:46:11 +00:00
|
|
|
bt = GETBIOSTYPE((int)ComboBox_GetItemData(hPartitionScheme, ComboBox_GetCurSel(hPartitionScheme)));
|
2014-03-15 14:14:10 +00:00
|
|
|
if ((selection_default == DT_IMG) && IsChecked(IDC_BOOT)) {
|
2014-02-09 02:54:07 +00:00
|
|
|
ToggleImage(FALSE);
|
2014-03-15 14:14:10 +00:00
|
|
|
EnableAdvancedBootOptions(FALSE, TRUE);
|
2014-02-09 02:54:07 +00:00
|
|
|
SetBoot(fs, bt);
|
|
|
|
break;
|
|
|
|
}
|
2012-02-02 13:16:49 +00:00
|
|
|
SetClusterSizes(fs);
|
2014-03-29 00:22:54 +00:00
|
|
|
// Disable/restore the quick format control depending on large FAT32 or ReFS
|
|
|
|
if ( ((fs == FS_FAT32) && ((SelectedDrive.DiskSize > LARGE_FAT32_SIZE) || (force_large_fat32))) || (fs == FS_REFS) ) {
|
2014-03-14 23:13:04 +00:00
|
|
|
if (IsWindowEnabled(GetDlgItem(hMainDialog, IDC_QUICKFORMAT))) {
|
2014-03-15 14:14:10 +00:00
|
|
|
uQFChecked = IsChecked(IDC_QUICKFORMAT);
|
2014-03-14 23:13:04 +00:00
|
|
|
CheckDlgButton(hMainDialog, IDC_QUICKFORMAT, BST_CHECKED);
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_QUICKFORMAT), FALSE);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (!IsWindowEnabled(GetDlgItem(hMainDialog, IDC_QUICKFORMAT))) {
|
|
|
|
CheckDlgButton(hMainDialog, IDC_QUICKFORMAT, uQFChecked);
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDC_QUICKFORMAT), TRUE);
|
|
|
|
}
|
|
|
|
}
|
2012-05-25 16:54:06 +00:00
|
|
|
if (fs < 0) {
|
2014-03-15 14:14:10 +00:00
|
|
|
EnableBootOptions(TRUE, TRUE);
|
2012-05-25 16:54:06 +00:00
|
|
|
SetMBRProps();
|
2014-01-05 01:39:41 +00:00
|
|
|
// Remove the SysLinux and ReactOS options if they exists
|
|
|
|
if (ComboBox_GetItemData(hBootType, ComboBox_GetCount(hBootType)-1) == (DT_MAX-1)) {
|
|
|
|
for (i=DT_SYSLINUX_V4; i<DT_MAX; i++)
|
|
|
|
IGNORE_RETVAL(ComboBox_DeleteString(hBootType, ComboBox_GetCount(hBootType)-1));
|
2013-01-24 21:30:11 +00:00
|
|
|
IGNORE_RETVAL(ComboBox_SetCurSel(hBootType, 1));
|
2012-05-25 16:54:06 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2014-03-29 00:22:54 +00:00
|
|
|
if ((fs == FS_EXFAT) || (fs == FS_UDF) || (fs == FS_REFS)) {
|
2014-03-14 23:13:04 +00:00
|
|
|
if (IsWindowEnabled(hBoot)) {
|
|
|
|
// unlikely to be supported by BIOSes => don't bother
|
|
|
|
IGNORE_RETVAL(ComboBox_SetCurSel(hBootType, 0));
|
2014-03-15 14:14:10 +00:00
|
|
|
uBootChecked = IsChecked(IDC_BOOT);
|
2014-03-14 23:13:04 +00:00
|
|
|
CheckDlgButton(hDlg, IDC_BOOT, BST_UNCHECKED);
|
2014-03-15 14:14:10 +00:00
|
|
|
EnableBootOptions(FALSE, TRUE);
|
|
|
|
} else if (IsChecked(IDC_BOOT)) {
|
2014-03-14 23:13:04 +00:00
|
|
|
uBootChecked = TRUE;
|
|
|
|
CheckDlgButton(hDlg, IDC_BOOT, BST_UNCHECKED);
|
|
|
|
}
|
2012-05-16 22:38:39 +00:00
|
|
|
SetMBRProps();
|
2012-02-02 13:16:49 +00:00
|
|
|
break;
|
|
|
|
}
|
2014-03-15 14:14:10 +00:00
|
|
|
EnableAdvancedBootOptions(TRUE, TRUE);
|
2014-02-09 02:54:07 +00:00
|
|
|
SetBoot(fs, bt);
|
2012-05-16 22:38:39 +00:00
|
|
|
SetMBRProps();
|
2012-02-16 11:37:59 +00:00
|
|
|
break;
|
2014-03-14 23:13:04 +00:00
|
|
|
case IDC_BOOT:
|
2014-03-15 14:14:10 +00:00
|
|
|
EnableAdvancedBootOptions(TRUE, TRUE);
|
2014-03-14 23:13:04 +00:00
|
|
|
if (selection_default == DT_IMG)
|
2014-03-15 14:14:10 +00:00
|
|
|
ToggleImage(!IsChecked(IDC_BOOT));
|
2014-03-14 23:13:04 +00:00
|
|
|
break;
|
2013-01-24 21:30:11 +00:00
|
|
|
case IDC_BOOTTYPE:
|
2012-02-07 23:16:15 +00:00
|
|
|
if (HIWORD(wParam) != CBN_SELCHANGE)
|
|
|
|
break;
|
2013-01-24 21:30:11 +00:00
|
|
|
selection_default = (int) ComboBox_GetItemData(hBootType, ComboBox_GetCurSel(hBootType));
|
2014-03-15 14:14:10 +00:00
|
|
|
EnableAdvancedBootOptions(TRUE, TRUE);
|
|
|
|
ToggleImage(!IsChecked(IDC_BOOT) || (selection_default != DT_IMG));
|
2014-02-09 02:54:07 +00:00
|
|
|
if ((selection_default == DT_ISO) || (selection_default == DT_IMG)) {
|
2012-02-22 00:23:17 +00:00
|
|
|
if ((iso_path == NULL) || (iso_report.label[0] == 0)) {
|
|
|
|
// Set focus to the Select ISO button
|
|
|
|
SendMessage(hMainDialog, WM_NEXTDLGCTL, (WPARAM)FALSE, 0);
|
|
|
|
SendMessage(hMainDialog, WM_NEXTDLGCTL, (WPARAM)hSelectISO, TRUE);
|
|
|
|
} else {
|
2012-11-04 21:39:25 +00:00
|
|
|
// Some distros (eg. Arch Linux) want to see a specific label => ignore user one
|
2012-02-22 00:23:17 +00:00
|
|
|
SetWindowTextU(hLabel, iso_report.label);
|
|
|
|
}
|
2012-02-16 23:40:31 +00:00
|
|
|
} else {
|
2012-02-22 00:23:17 +00:00
|
|
|
// Set focus on the start button
|
|
|
|
SendMessage(hMainDialog, WM_NEXTDLGCTL, (WPARAM)FALSE, 0);
|
2012-02-16 23:40:31 +00:00
|
|
|
SendMessage(hMainDialog, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hMainDialog, IDC_START), TRUE);
|
2012-11-04 21:39:25 +00:00
|
|
|
// For non ISO, if the user manually set a label, try to preserve it
|
|
|
|
if (!user_changed_label)
|
|
|
|
SetWindowTextU(hLabel, SelectedDrive.proposed_label);
|
2012-05-16 22:38:39 +00:00
|
|
|
// Reset disk ID to 0x80 if Rufus MBR is used
|
|
|
|
IGNORE_RETVAL(ComboBox_SetCurSel(hDiskID, 0));
|
2011-12-01 02:56:44 +00:00
|
|
|
}
|
2012-02-16 11:37:59 +00:00
|
|
|
return (INT_PTR)TRUE;
|
2012-02-02 13:16:49 +00:00
|
|
|
case IDC_SELECT_ISO:
|
2013-02-04 01:14:28 +00:00
|
|
|
if (iso_provided) {
|
2014-02-09 02:54:07 +00:00
|
|
|
uprintf("Commandline Image provided: '%s'\n", iso_path);
|
2013-02-04 01:14:28 +00:00
|
|
|
iso_provided = FALSE; // One off thing...
|
|
|
|
} else {
|
|
|
|
safe_free(iso_path);
|
2014-02-09 02:54:07 +00:00
|
|
|
if (selection_default == DT_IMG)
|
2014-03-17 20:42:10 +00:00
|
|
|
iso_path = FileDialog(FALSE, NULL, "*.img", "img", "DD Image", 0);
|
2014-02-09 02:54:07 +00:00
|
|
|
else
|
2014-03-17 20:42:10 +00:00
|
|
|
iso_path = FileDialog(FALSE, NULL, "*.iso", "iso", lmprintf(MSG_036), 0);
|
2013-02-04 01:14:28 +00:00
|
|
|
if (iso_path == NULL) {
|
2013-10-15 21:58:27 +00:00
|
|
|
CreateTooltip(hSelectISO, lmprintf(MSG_173), -1);
|
2013-02-04 01:14:28 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-02-02 13:16:49 +00:00
|
|
|
}
|
2012-03-03 23:12:48 +00:00
|
|
|
selection_default = DT_ISO;
|
2012-05-21 10:11:42 +00:00
|
|
|
CreateTooltip(hSelectISO, iso_path, -1);
|
2012-02-02 13:16:49 +00:00
|
|
|
FormatStatus = 0;
|
2012-12-06 01:40:44 +00:00
|
|
|
if (CreateThread(NULL, 0, ISOScanThread, NULL, 0, NULL) == NULL) {
|
2012-02-02 13:16:49 +00:00
|
|
|
uprintf("Unable to start ISO scanning thread");
|
|
|
|
FormatStatus = ERROR_SEVERITY_ERROR|FAC(FACILITY_STORAGE)|APPERR(ERROR_CANT_START_THREAD);
|
|
|
|
}
|
|
|
|
break;
|
2012-05-25 16:54:06 +00:00
|
|
|
case IDC_RUFUS_MBR:
|
|
|
|
if ((HIWORD(wParam)) == BN_CLICKED)
|
|
|
|
mbr_selected_by_user = IsChecked(IDC_RUFUS_MBR);
|
|
|
|
break;
|
2013-06-03 20:32:22 +00:00
|
|
|
case IDC_ENABLE_FIXED_DISKS:
|
|
|
|
if ((HIWORD(wParam)) == BN_CLICKED) {
|
2013-11-14 01:21:50 +00:00
|
|
|
enable_HDDs = !enable_HDDs;
|
|
|
|
PrintStatus2000(lmprintf(MSG_253), enable_HDDs);
|
2013-06-03 20:32:22 +00:00
|
|
|
GetUSBDevices(0);
|
|
|
|
}
|
|
|
|
break;
|
2011-11-23 12:27:51 +00:00
|
|
|
case IDC_START:
|
2012-02-07 02:05:58 +00:00
|
|
|
if (format_thid != NULL) {
|
2011-11-27 23:40:28 +00:00
|
|
|
return (INT_PTR)TRUE;
|
|
|
|
}
|
2012-02-01 14:26:36 +00:00
|
|
|
FormatStatus = 0;
|
2012-12-04 01:47:45 +00:00
|
|
|
format_op_in_progress = TRUE;
|
2012-03-29 19:27:53 +00:00
|
|
|
// Reset all progress bars
|
|
|
|
SendMessage(hProgress, PBM_SETSTATE, (WPARAM)PBST_NORMAL, 0);
|
|
|
|
SetTaskbarProgressState(TASKBAR_NORMAL);
|
|
|
|
SetTaskbarProgressValue(0, MAX_PROGRESS);
|
|
|
|
SendMessage(hProgress, PBM_SETPOS, 0, 0);
|
2014-02-09 02:54:07 +00:00
|
|
|
selection_default = (int)ComboBox_GetItemData(hBootType, ComboBox_GetCurSel(hBootType));
|
2011-11-23 12:27:51 +00:00
|
|
|
nDeviceIndex = ComboBox_GetCurSel(hDeviceList);
|
|
|
|
if (nDeviceIndex != CB_ERR) {
|
2013-06-15 16:31:55 +00:00
|
|
|
if ((IsChecked(IDC_BOOT)) && (!BootCheck())) {
|
|
|
|
format_op_in_progress = FALSE;
|
2013-01-25 01:38:10 +00:00
|
|
|
break;
|
2013-06-15 16:31:55 +00:00
|
|
|
}
|
2013-10-31 22:59:53 +00:00
|
|
|
|
|
|
|
// Display a warning about UDF formatting times
|
|
|
|
fs = (int)ComboBox_GetItemData(hFileSystem, ComboBox_GetCurSel(hFileSystem));
|
|
|
|
if (fs == FS_UDF) {
|
|
|
|
dur_secs = (uint32_t)(((double)SelectedDrive.DiskSize)/1073741824.0f/UDF_FORMAT_SPEED);
|
|
|
|
if (dur_secs > UDF_FORMAT_WARN) {
|
|
|
|
dur_mins = dur_secs/60;
|
|
|
|
dur_secs -= dur_mins*60;
|
2014-01-24 02:46:06 +00:00
|
|
|
MessageBoxU(hMainDialog, lmprintf(MSG_112, dur_mins, dur_secs), lmprintf(MSG_113), MB_OK|MB_ICONASTERISK|MB_IS_RTL);
|
2013-10-31 22:59:53 +00:00
|
|
|
} else {
|
|
|
|
dur_secs = 0;
|
|
|
|
dur_mins = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-08 00:59:34 +00:00
|
|
|
GetWindowTextU(hDeviceList, tmp, ARRAYSIZE(tmp));
|
2013-10-15 21:58:27 +00:00
|
|
|
if (MessageBoxU(hMainDialog, lmprintf(MSG_003, tmp),
|
2014-01-24 02:46:06 +00:00
|
|
|
APPLICATION_NAME, MB_OKCANCEL|MB_ICONWARNING|MB_IS_RTL) == IDCANCEL) {
|
2013-06-15 16:31:55 +00:00
|
|
|
format_op_in_progress = FALSE;
|
|
|
|
break;
|
|
|
|
}
|
2014-01-14 20:17:07 +00:00
|
|
|
if ((SelectedDrive.nPartitions > 1) && (MessageBoxU(hMainDialog, lmprintf(MSG_093),
|
2014-01-24 02:46:06 +00:00
|
|
|
lmprintf(MSG_094), MB_OKCANCEL|MB_ICONWARNING|MB_IS_RTL) == IDCANCEL)) {
|
2014-01-14 20:17:07 +00:00
|
|
|
format_op_in_progress = FALSE;
|
|
|
|
break;
|
|
|
|
}
|
2013-06-15 16:31:55 +00:00
|
|
|
|
|
|
|
// Disable all controls except cancel
|
|
|
|
EnableControls(FALSE);
|
|
|
|
DeviceNum = (DWORD)ComboBox_GetItemData(hDeviceList, nDeviceIndex);
|
|
|
|
FormatStatus = 0;
|
|
|
|
InitProgress();
|
|
|
|
format_thid = CreateThread(NULL, 0, FormatThread, (LPVOID)(uintptr_t)DeviceNum, 0, NULL);
|
|
|
|
if (format_thid == NULL) {
|
|
|
|
uprintf("Unable to start formatting thread");
|
|
|
|
FormatStatus = ERROR_SEVERITY_ERROR|FAC(FACILITY_STORAGE)|APPERR(ERROR_CANT_START_THREAD);
|
|
|
|
PostMessage(hMainDialog, UM_FORMAT_COMPLETED, 0, 0);
|
2011-11-24 02:24:50 +00:00
|
|
|
}
|
2013-06-15 16:31:55 +00:00
|
|
|
uprintf("\r\nFormat operation started");
|
2013-12-19 23:56:40 +00:00
|
|
|
PrintStatus(0, FALSE, -1);
|
2013-06-15 16:31:55 +00:00
|
|
|
timer = 0;
|
|
|
|
safe_sprintf(szTimer, sizeof(szTimer), "00:00:00");
|
|
|
|
SendMessageA(GetDlgItem(hMainDialog, IDC_STATUS), SB_SETTEXTA,
|
|
|
|
SBT_OWNERDRAW | 1, (LPARAM)szTimer);
|
|
|
|
SetTimer(hMainDialog, TID_APP_TIMER, 1000, ClockTimer);
|
2011-11-23 12:27:51 +00:00
|
|
|
}
|
2012-12-04 01:47:45 +00:00
|
|
|
if (format_thid == NULL)
|
|
|
|
format_op_in_progress = FALSE;
|
2011-11-27 23:40:28 +00:00
|
|
|
break;
|
2011-11-13 20:53:23 +00:00
|
|
|
default:
|
|
|
|
return (INT_PTR)FALSE;
|
|
|
|
}
|
|
|
|
return (INT_PTR)TRUE;
|
|
|
|
|
|
|
|
case WM_CLOSE:
|
2012-02-07 02:05:58 +00:00
|
|
|
if (format_thid != NULL) {
|
2011-11-28 01:32:18 +00:00
|
|
|
return (INT_PTR)TRUE;
|
|
|
|
}
|
2011-11-13 20:53:23 +00:00
|
|
|
PostQuitMessage(0);
|
|
|
|
break;
|
|
|
|
|
2012-12-04 01:47:45 +00:00
|
|
|
case UM_ISO_CREATE:
|
|
|
|
// You'd think that Windows would let you instantiate a modeless dialog wherever
|
|
|
|
// but you'd be wrong. It must be done in the main callback, hence the custom message.
|
|
|
|
if (!IsWindow(hISOProgressDlg)) {
|
2014-01-24 02:46:06 +00:00
|
|
|
hISOProgressDlg = CreateDialogW(hMainInstance, MAKEINTRESOURCEW(IDD_ISO_EXTRACT + IDD_IS_RTL),
|
2013-12-27 16:06:59 +00:00
|
|
|
hDlg, (DLGPROC)ISOProc);
|
|
|
|
|
2012-12-04 01:47:45 +00:00
|
|
|
// The window is not visible by default but takes focus => restore it
|
|
|
|
SetFocus(hDlg);
|
2013-12-27 16:06:59 +00:00
|
|
|
}
|
2012-12-04 01:47:45 +00:00
|
|
|
return (INT_PTR)TRUE;
|
|
|
|
|
2011-11-27 23:40:28 +00:00
|
|
|
case UM_FORMAT_COMPLETED:
|
2012-02-07 02:05:58 +00:00
|
|
|
format_thid = NULL;
|
2011-12-08 12:14:21 +00:00
|
|
|
// Stop the timer
|
2011-12-09 01:39:13 +00:00
|
|
|
KillTimer(hMainDialog, TID_APP_TIMER);
|
2012-02-07 16:17:14 +00:00
|
|
|
// Close the cancel MessageBox and Blocking notification if active
|
2013-10-15 21:58:27 +00:00
|
|
|
SendMessage(FindWindowA(MAKEINTRESOURCEA(32770), lmprintf(MSG_049)), WM_COMMAND, IDNO, 0);
|
|
|
|
SendMessage(FindWindowA(MAKEINTRESOURCEA(32770), lmprintf(MSG_049)), WM_COMMAND, IDYES, 0);
|
2012-02-07 16:17:14 +00:00
|
|
|
EnableWindow(GetDlgItem(hISOProgressDlg, IDC_ISO_ABORT), TRUE);
|
|
|
|
EnableWindow(GetDlgItem(hMainDialog, IDCANCEL), TRUE);
|
2011-11-28 01:32:18 +00:00
|
|
|
EnableControls(TRUE);
|
2013-06-03 18:55:23 +00:00
|
|
|
uprintf("\r\n");
|
2012-02-16 23:40:31 +00:00
|
|
|
GetUSBDevices(DeviceNum);
|
2011-12-04 19:47:27 +00:00
|
|
|
if (!IS_ERROR(FormatStatus)) {
|
2013-07-05 22:58:04 +00:00
|
|
|
// This is the only way to achieve instantaneous progress transition to 100%
|
2013-01-09 21:54:28 +00:00
|
|
|
SendMessage(hProgress, PBM_SETRANGE, 0, ((MAX_PROGRESS+1)<<16) & 0xFFFF0000);
|
2012-03-29 17:16:06 +00:00
|
|
|
SendMessage(hProgress, PBM_SETPOS, (MAX_PROGRESS+1), 0);
|
2013-01-09 21:54:28 +00:00
|
|
|
SendMessage(hProgress, PBM_SETRANGE, 0, (MAX_PROGRESS<<16) & 0xFFFF0000);
|
2012-03-29 17:16:06 +00:00
|
|
|
SetTaskbarProgressState(TASKBAR_NOPROGRESS);
|
2013-12-19 23:56:40 +00:00
|
|
|
PrintStatus(0, FALSE, MSG_210);
|
2011-12-04 19:47:27 +00:00
|
|
|
} else if (SCODE_CODE(FormatStatus) == ERROR_CANCELLED) {
|
2012-03-29 17:16:06 +00:00
|
|
|
SendMessage(hProgress, PBM_SETSTATE, (WPARAM)PBST_PAUSED, 0);
|
|
|
|
SetTaskbarProgressState(TASKBAR_PAUSED);
|
2013-12-19 23:56:40 +00:00
|
|
|
PrintStatus(0, FALSE, MSG_211);
|
2013-10-15 21:58:27 +00:00
|
|
|
Notification(MSG_INFO, NULL, lmprintf(MSG_211), lmprintf(MSG_041));
|
2011-12-04 19:47:27 +00:00
|
|
|
} else {
|
2012-03-29 17:16:06 +00:00
|
|
|
SendMessage(hProgress, PBM_SETSTATE, (WPARAM)PBST_ERROR, 0);
|
|
|
|
SetTaskbarProgressState(TASKBAR_ERROR);
|
2013-12-19 23:56:40 +00:00
|
|
|
PrintStatus(0, FALSE, MSG_212);
|
|
|
|
Notification(MSG_ERROR, NULL, lmprintf(MSG_042), lmprintf(MSG_043, StrError(FormatStatus, FALSE)), StrError(FormatStatus, FALSE));
|
2011-12-04 19:47:27 +00:00
|
|
|
}
|
2012-12-04 01:47:45 +00:00
|
|
|
FormatStatus = 0;
|
|
|
|
format_op_in_progress = FALSE;
|
2011-11-27 23:40:28 +00:00
|
|
|
return (INT_PTR)TRUE;
|
2011-11-13 20:53:23 +00:00
|
|
|
}
|
|
|
|
return (INT_PTR)FALSE;
|
|
|
|
}
|
|
|
|
|
2013-02-04 01:14:28 +00:00
|
|
|
static void PrintUsage(char* appname)
|
|
|
|
{
|
|
|
|
char fname[_MAX_FNAME];
|
|
|
|
|
|
|
|
_splitpath(appname, NULL, NULL, fname, NULL);
|
2013-02-04 23:15:11 +00:00
|
|
|
printf("\nUsage: %s [-h] [-i PATH] [-w TIMEOUT]\n", fname);
|
|
|
|
printf(" -i PATH, --iso=PATH\n");
|
|
|
|
printf(" Select the ISO image pointed by PATH to be used on startup\n");
|
|
|
|
printf(" -w TIMEOUT, --wait=TIMEOUT\n");
|
|
|
|
printf(" Wait TIMEOUT tens of a second for the global application mutex to be released.\n");
|
|
|
|
printf(" Used when launching a newer version of " APPLICATION_NAME " from a running application.\n");
|
|
|
|
printf(" -h, --help\n");
|
|
|
|
printf(" This usage guide.\n");
|
2013-02-04 01:14:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* There's a massive annoyance when taking over the console in a win32 app
|
|
|
|
* in that it doesn't return the prompt on app exit. So we must handle that
|
|
|
|
* manually, but the *ONLY* frigging way to achieve it is by simulating a
|
|
|
|
* keypress... which means we first need to bring our console back on top.
|
|
|
|
* And people wonder why developing elegant Win32 apps takes forever...
|
|
|
|
*/
|
|
|
|
static void DetachConsole(void)
|
|
|
|
{
|
|
|
|
INPUT input;
|
|
|
|
HWND hWnd;
|
|
|
|
|
|
|
|
hWnd = GetConsoleWindow();
|
|
|
|
SetWindowPos(hWnd, HWND_TOP, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);
|
|
|
|
FreeConsole();
|
|
|
|
memset(&input, 0, sizeof(input));
|
|
|
|
input.type = INPUT_KEYBOARD;
|
|
|
|
input.ki.wVk = VK_RETURN;
|
|
|
|
SendInput(1, &input, sizeof(input));
|
|
|
|
input.ki.dwFlags = KEYEVENTF_KEYUP;
|
|
|
|
SendInput(1, &input, sizeof(input));
|
|
|
|
}
|
|
|
|
|
2011-11-13 20:53:23 +00:00
|
|
|
/*
|
|
|
|
* Application Entrypoint
|
|
|
|
*/
|
2013-02-04 01:14:28 +00:00
|
|
|
typedef int (CDECL *__wgetmainargs_t)(int*, wchar_t***, wchar_t***, int, int*);
|
2013-01-09 21:54:28 +00:00
|
|
|
#if defined(_MSC_VER) && (_MSC_VER >= 1600)
|
|
|
|
int WINAPI WinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPSTR lpCmdLine, _In_ int nShowCmd)
|
|
|
|
#else
|
2011-11-13 20:53:23 +00:00
|
|
|
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
|
2013-01-09 21:54:28 +00:00
|
|
|
#endif
|
2011-11-13 20:53:23 +00:00
|
|
|
{
|
2013-02-04 01:14:28 +00:00
|
|
|
const char* old_wait_option = "/W";
|
2014-01-05 01:39:41 +00:00
|
|
|
const char* rufus_loc = "rufus.loc";
|
2013-12-20 02:59:44 +00:00
|
|
|
int i, opt, option_index = 0, argc = 0, si = 0, lcid = GetUserDefaultUILanguage();
|
2013-12-28 16:48:02 +00:00
|
|
|
BOOL attached_console = FALSE, external_loc_file = FALSE, lgp_set = FALSE;
|
2013-10-15 21:58:27 +00:00
|
|
|
BYTE* loc_data;
|
|
|
|
DWORD loc_size, Size;
|
2014-01-05 01:39:41 +00:00
|
|
|
char tmp_path[MAX_PATH] = "", loc_file[MAX_PATH] = "", *tmp, *locale_name = NULL;
|
2013-02-04 01:14:28 +00:00
|
|
|
char** argv = NULL;
|
|
|
|
wchar_t **wenv, **wargv;
|
|
|
|
PF_DECL(__wgetmainargs);
|
2013-10-15 21:58:27 +00:00
|
|
|
HANDLE mutex = NULL, hFile = NULL;
|
2011-11-13 20:53:23 +00:00
|
|
|
HWND hDlg = NULL;
|
|
|
|
MSG msg;
|
2012-12-06 01:40:44 +00:00
|
|
|
int wait_for_mutex = 0;
|
2013-02-04 01:14:28 +00:00
|
|
|
struct option long_options[] = {
|
|
|
|
{"help", no_argument, NULL, 'h'},
|
|
|
|
{"iso", required_argument, NULL, 'i'},
|
|
|
|
{"wait", required_argument, NULL, 'w'},
|
|
|
|
{0, 0, NULL, 0}
|
|
|
|
};
|
2011-11-13 20:53:23 +00:00
|
|
|
|
2013-06-06 22:40:37 +00:00
|
|
|
uprintf("*** " APPLICATION_NAME " init ***\n");
|
|
|
|
|
2013-02-04 01:14:28 +00:00
|
|
|
// Reattach the console, if we were started from commandline
|
|
|
|
if (AttachConsole(ATTACH_PARENT_PROCESS) != 0) {
|
|
|
|
attached_console = TRUE;
|
2013-02-04 23:15:11 +00:00
|
|
|
IGNORE_RETVAL(freopen("CONIN$", "r", stdin));
|
|
|
|
IGNORE_RETVAL(freopen("CONOUT$", "w", stdout));
|
|
|
|
IGNORE_RETVAL(freopen("CONOUT$", "w", stderr));
|
2013-02-04 01:14:28 +00:00
|
|
|
_flushall();
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
|
2013-12-15 21:27:25 +00:00
|
|
|
// Use the Locale specified in the registry, if any
|
|
|
|
tmp = ReadRegistryKeyStr(REGKEY_HKCU, REGKEY_LOCALE);
|
|
|
|
if (tmp[0] != 0) {
|
|
|
|
locale_name = safe_strdup(tmp);
|
|
|
|
uprintf("found registry locale '%s'", locale_name);
|
|
|
|
}
|
|
|
|
|
2013-10-15 21:58:27 +00:00
|
|
|
// We have to process the arguments before we acquire the lock and process the locale
|
2013-02-04 01:14:28 +00:00
|
|
|
PF_INIT(__wgetmainargs, msvcrt);
|
|
|
|
if (pf__wgetmainargs != NULL) {
|
|
|
|
pf__wgetmainargs(&argc, &wargv, &wenv, 1, &si);
|
|
|
|
argv = (char**)calloc(argc, sizeof(char*));
|
|
|
|
for (i=0; i<argc; i++) {
|
|
|
|
argv[i] = wchar_to_utf8(wargv[i]);
|
2013-02-04 23:15:11 +00:00
|
|
|
// Check for "/W" (wait for mutex release for pre 1.3.3 versions)
|
2013-02-04 01:14:28 +00:00
|
|
|
if (safe_strcmp(argv[i], old_wait_option) == 0)
|
|
|
|
wait_for_mutex = 150; // Try to acquire the mutex for 15 seconds
|
|
|
|
}
|
|
|
|
|
2013-10-15 21:58:27 +00:00
|
|
|
while ((opt = getopt_long(argc, argv, "?fhi:w:l:", long_options, &option_index)) != EOF)
|
2013-02-04 01:14:28 +00:00
|
|
|
switch (opt) {
|
2013-06-25 01:55:25 +00:00
|
|
|
case 'f':
|
2013-11-14 01:21:50 +00:00
|
|
|
enable_HDDs = TRUE;
|
2013-06-25 01:55:25 +00:00
|
|
|
break;
|
2013-02-04 01:14:28 +00:00
|
|
|
case 'i':
|
|
|
|
if (_access(optarg, 0) != -1) {
|
|
|
|
iso_path = safe_strdup(optarg);
|
|
|
|
iso_provided = TRUE;
|
|
|
|
} else {
|
|
|
|
printf("Could not find ISO image '%s'\n", optarg);
|
|
|
|
}
|
|
|
|
break;
|
2013-10-15 21:58:27 +00:00
|
|
|
case 'l':
|
2013-10-16 19:45:34 +00:00
|
|
|
if (isdigitU(optarg[0])) {
|
|
|
|
lcid = (int)strtol(optarg, NULL, 0);
|
|
|
|
} else {
|
2013-12-15 21:27:25 +00:00
|
|
|
safe_free(locale_name);
|
|
|
|
locale_name =safe_strdup(optarg);
|
2013-10-16 19:45:34 +00:00
|
|
|
}
|
2013-10-15 21:58:27 +00:00
|
|
|
break;
|
2013-02-04 01:14:28 +00:00
|
|
|
case 'w':
|
|
|
|
wait_for_mutex = atoi(optarg);
|
|
|
|
break;
|
|
|
|
case '?':
|
|
|
|
case 'h':
|
|
|
|
default:
|
|
|
|
PrintUsage(argv[0]);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
uprintf("unable to access UTF-16 args");
|
|
|
|
}
|
2012-12-06 01:40:44 +00:00
|
|
|
|
2013-10-15 21:58:27 +00:00
|
|
|
// Retrieve the current application directory
|
|
|
|
GetCurrentDirectoryU(MAX_PATH, app_dir);
|
|
|
|
|
|
|
|
// Init localization
|
|
|
|
init_localization();
|
|
|
|
// Seek for a loc file in the current directory
|
2014-01-05 01:39:41 +00:00
|
|
|
if (GetFileAttributesU(rufus_loc) == INVALID_FILE_ATTRIBUTES) {
|
2013-10-15 21:58:27 +00:00
|
|
|
uprintf("loc file not found in current directory - embedded one will be used");
|
|
|
|
|
2013-11-01 19:17:46 +00:00
|
|
|
loc_data = (BYTE*)GetResource(hMainInstance, MAKEINTRESOURCEA(IDR_LC_RUFUS_LOC), _RT_RCDATA, "embedded.loc", &loc_size, FALSE);
|
2014-01-05 01:39:41 +00:00
|
|
|
if ( (GetTempPathU(sizeof(tmp_path), tmp_path) == 0)
|
|
|
|
|| (GetTempFileNameU(tmp_path, APPLICATION_NAME, 0, loc_file) == 0)
|
|
|
|
|| (loc_file[0] == 0) ) {
|
|
|
|
// Last ditch effort to get a loc file - just extract it to the current directory
|
|
|
|
safe_strcpy(loc_file, sizeof(loc_file), rufus_loc);
|
|
|
|
}
|
2013-10-15 21:58:27 +00:00
|
|
|
|
|
|
|
hFile = CreateFileU(loc_file, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
|
|
|
|
NULL, CREATE_ALWAYS, 0, 0);
|
2014-01-05 01:39:41 +00:00
|
|
|
if ((hFile == INVALID_HANDLE_VALUE) || (!WriteFile(hFile, loc_data, loc_size, &Size, 0)) || (loc_size != Size)) {
|
2013-10-15 21:58:27 +00:00
|
|
|
uprintf("localization: unable to extract '%s': %s.\n", loc_file, WindowsErrorString());
|
|
|
|
safe_closehandle(hFile);
|
2014-01-05 01:39:41 +00:00
|
|
|
goto out;
|
2013-10-15 21:58:27 +00:00
|
|
|
}
|
2014-01-05 01:39:41 +00:00
|
|
|
uprintf("localization: extracted data to '%s'\n", loc_file);
|
|
|
|
safe_closehandle(hFile);
|
2013-10-15 21:58:27 +00:00
|
|
|
} else {
|
2014-01-05 01:39:41 +00:00
|
|
|
safe_sprintf(loc_file, sizeof(loc_file), "%s\\%s", app_dir, rufus_loc);
|
2013-10-16 19:45:34 +00:00
|
|
|
external_loc_file = TRUE;
|
2013-10-15 21:58:27 +00:00
|
|
|
uprintf("using external loc file '%s'", loc_file);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( (!get_supported_locales(loc_file))
|
2013-10-18 22:08:49 +00:00
|
|
|
|| ((selected_locale = ((locale_name == NULL)?get_locale_from_lcid(lcid, TRUE):get_locale_from_name(locale_name, TRUE))) == NULL) ) {
|
2013-10-15 21:58:27 +00:00
|
|
|
uprintf("FATAL: Could not access locale!\n");
|
2014-01-24 02:46:06 +00:00
|
|
|
MessageBoxU(NULL, "The locale data is missing or invalid. This application will now exit.", "Fatal error", MB_ICONSTOP|MB_IS_RTL);
|
2013-10-15 21:58:27 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-12-06 01:40:44 +00:00
|
|
|
// Prevent 2 applications from running at the same time, unless "/W" is passed as an option
|
|
|
|
// in which case we wait for the mutex to be relinquished
|
|
|
|
if ((safe_strlen(lpCmdLine)==2) && (lpCmdLine[0] == '/') && (lpCmdLine[1] == 'W'))
|
|
|
|
wait_for_mutex = 150; // Try to acquire the mutex for 15 seconds
|
2013-06-06 22:40:37 +00:00
|
|
|
mutex = CreateMutexA(NULL, TRUE, "Global/" APPLICATION_NAME);
|
2012-12-06 01:40:44 +00:00
|
|
|
for (;(wait_for_mutex>0) && (mutex != NULL) && (GetLastError() == ERROR_ALREADY_EXISTS); wait_for_mutex--) {
|
|
|
|
CloseHandle(mutex);
|
|
|
|
Sleep(100);
|
2013-06-06 22:40:37 +00:00
|
|
|
mutex = CreateMutexA(NULL, TRUE, "Global/" APPLICATION_NAME);
|
2012-12-06 01:40:44 +00:00
|
|
|
}
|
|
|
|
if ((mutex == NULL) || (GetLastError() == ERROR_ALREADY_EXISTS)) {
|
2013-10-29 01:40:00 +00:00
|
|
|
// Load the translation before we print the error
|
2013-12-19 23:56:40 +00:00
|
|
|
get_loc_data_file(loc_file, selected_locale);
|
2014-01-24 02:46:06 +00:00
|
|
|
MessageBoxU(NULL, lmprintf(MSG_002), lmprintf(MSG_001), MB_ICONSTOP|MB_IS_RTL);
|
2013-02-04 23:15:11 +00:00
|
|
|
goto out;
|
2011-11-13 20:53:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Save instance of the application for further reference
|
2011-11-18 23:41:28 +00:00
|
|
|
hMainInstance = hInstance;
|
2011-11-13 20:53:23 +00:00
|
|
|
|
|
|
|
// Initialize COM for folder selection
|
2013-01-09 21:54:28 +00:00
|
|
|
IGNORE_RETVAL(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED));
|
2011-11-13 20:53:23 +00:00
|
|
|
|
2012-11-29 02:59:52 +00:00
|
|
|
// Some dialogs have Rich Edit controls and won't display without this
|
|
|
|
if (LoadLibraryA("Riched20.dll") == NULL) {
|
|
|
|
uprintf("Could not load RichEdit library - some dialogs may not display: %s\n", WindowsErrorString());
|
|
|
|
}
|
|
|
|
|
2012-12-02 03:50:08 +00:00
|
|
|
// Set the Windows version
|
2013-11-05 02:16:49 +00:00
|
|
|
GetWindowsVersion();
|
2012-12-02 03:50:08 +00:00
|
|
|
|
2011-12-11 23:38:16 +00:00
|
|
|
// We use local group policies rather than direct registry manipulation
|
|
|
|
// 0x9e disables removable and fixed drive notifications
|
2013-12-28 16:48:02 +00:00
|
|
|
lgp_set = SetLGP(FALSE, &existing_key, "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer", "NoDriveTypeAutorun", 0x9e);
|
2013-12-19 23:56:40 +00:00
|
|
|
|
2013-10-24 21:57:34 +00:00
|
|
|
relaunch:
|
|
|
|
uprintf("localization: using locale '%s'\n", selected_locale->txt[0]);
|
2014-01-24 02:46:06 +00:00
|
|
|
right_to_left_mode = ((selected_locale->ctrl_id) & LOC_RIGHT_TO_LEFT);
|
|
|
|
SetProcessDefaultLayout(right_to_left_mode?LAYOUT_RTL:0);
|
2013-12-22 18:28:38 +00:00
|
|
|
if (get_loc_data_file(loc_file, selected_locale))
|
|
|
|
WriteRegistryKeyStr(REGKEY_HKCU, REGKEY_LOCALE, selected_locale->txt[0]);
|
2013-10-24 21:57:34 +00:00
|
|
|
|
2013-12-27 16:06:59 +00:00
|
|
|
// Destroy the ISO progress window, if it exists
|
|
|
|
if (hISOProgressDlg != NULL) {
|
|
|
|
DestroyWindow(hISOProgressDlg);
|
|
|
|
hISOProgressDlg = NULL;
|
|
|
|
}
|
|
|
|
|
2014-01-24 02:46:06 +00:00
|
|
|
/*
|
|
|
|
* Create the main Window
|
|
|
|
*
|
|
|
|
* Oh yeah, thanks to Microsoft limitations for dialog boxes this is SUPER SUCKY:
|
|
|
|
* As per the MSDN [http://msdn.microsoft.com/en-ie/goglobal/bb688119.aspx], "The only way
|
|
|
|
* to switch between mirrored and nonmirrored dialog resources at run time is to have two
|
|
|
|
* sets of dialog resources: one mirrored and one nonmirrored."
|
|
|
|
* Unfortunately, this limitation is VERY REAL, so that's what we have to go through, and
|
|
|
|
* furthermore, trying to switch part of the dialogs back to LTR is also a major exercise
|
2014-01-24 19:59:23 +00:00
|
|
|
* in frustration, because it's next to impossible to figure out which combination of
|
|
|
|
* WS_EX_RTLREADING, WS_EX_RIGHT, WS_EX_LAYOUTRTL, WS_EX_LEFTSCROLLBAR and ES_RIGHT will
|
|
|
|
* work... and there's no way to toggle ES_RIGHT at runtime anyway.
|
2014-01-24 02:46:06 +00:00
|
|
|
* So, just like Microsoft advocates, we go through a massive duplication of all our RC
|
|
|
|
* dialogs (our RTL dialogs having their IDD's offset by +100 - see IDD_IS_RTL), just to
|
2014-01-24 19:59:23 +00:00
|
|
|
* add a handful of stupid flags. And of course, we also have to go through a whole other
|
|
|
|
* exercise just so that our RTL and non RTL duplicated dialogs are kept in sync...
|
2014-01-24 02:46:06 +00:00
|
|
|
*/
|
|
|
|
hDlg = CreateDialogW(hInstance, MAKEINTRESOURCEW(IDD_DIALOG + IDD_IS_RTL), NULL, MainCallback);
|
2013-10-15 21:58:27 +00:00
|
|
|
if (hDlg == NULL) {
|
2014-01-24 02:46:06 +00:00
|
|
|
MessageBoxU(NULL, "Could not create Window", "DialogBox failure", MB_ICONSTOP|MB_IS_RTL);
|
2011-11-13 20:53:23 +00:00
|
|
|
goto out;
|
|
|
|
}
|
2013-10-24 21:57:34 +00:00
|
|
|
if ((relaunch_rc.left > -65536) && (relaunch_rc.top > -65536))
|
|
|
|
SetWindowPos(hDlg, HWND_TOP, relaunch_rc.left, relaunch_rc.top, 0, 0, SWP_NOSIZE);
|
2011-11-13 20:53:23 +00:00
|
|
|
ShowWindow(hDlg, SW_SHOWNORMAL);
|
|
|
|
UpdateWindow(hDlg);
|
|
|
|
|
2011-12-30 17:58:18 +00:00
|
|
|
// Do our own event processing and process "magic" commands
|
2011-11-13 20:53:23 +00:00
|
|
|
while(GetMessage(&msg, NULL, 0, 0)) {
|
2012-02-01 14:26:36 +00:00
|
|
|
// The following ensures the processing of the ISO progress window messages
|
|
|
|
if (!IsWindow(hISOProgressDlg) || !IsDialogMessage(hISOProgressDlg, &msg)) {
|
2012-11-22 01:52:33 +00:00
|
|
|
// Alt-S => Disable size limit for ISOs
|
2013-12-27 16:06:59 +00:00
|
|
|
// By default, Rufus will not copy ISOs that are larger than in size than
|
2012-11-22 01:52:33 +00:00
|
|
|
// the target USB drive. If this is enabled, the size check is disabled.
|
2012-02-07 16:17:14 +00:00
|
|
|
if ((msg.message == WM_SYSKEYDOWN) && (msg.wParam == 'S')) {
|
2013-07-05 22:58:04 +00:00
|
|
|
size_check = !size_check;
|
2013-10-15 21:58:27 +00:00
|
|
|
PrintStatus2000(lmprintf(MSG_252), size_check);
|
2013-07-05 22:58:04 +00:00
|
|
|
GetUSBDevices(0);
|
2012-02-07 16:17:14 +00:00
|
|
|
continue;
|
|
|
|
}
|
2013-11-17 22:24:50 +00:00
|
|
|
// Alt-F => Toggle detection of USB HDDs
|
|
|
|
// By default Rufus does not list USB HDDs. This is a safety feature aimed at avoiding
|
2013-11-25 22:34:26 +00:00
|
|
|
// unintentional formatting of backup drives instead of USB keys.
|
2013-11-17 22:24:50 +00:00
|
|
|
// When enabled, Rufus will list and allow the formatting of USB HDDs.
|
2012-03-01 19:19:12 +00:00
|
|
|
if ((msg.message == WM_SYSKEYDOWN) && (msg.wParam == 'F')) {
|
2013-11-14 01:21:50 +00:00
|
|
|
enable_HDDs = !enable_HDDs;
|
|
|
|
PrintStatus2000(lmprintf(MSG_253), enable_HDDs);
|
2012-03-01 19:19:12 +00:00
|
|
|
GetUSBDevices(0);
|
2013-11-25 22:34:26 +00:00
|
|
|
CheckDlgButton(hMainDialog, IDC_ENABLE_FIXED_DISKS, enable_HDDs?BST_CHECKED:BST_UNCHECKED);
|
2012-03-01 19:19:12 +00:00
|
|
|
continue;
|
|
|
|
}
|
2013-04-07 23:10:58 +00:00
|
|
|
// Alt-L => Force Large FAT32 format to be used on < 32 GB drives
|
|
|
|
if ((msg.message == WM_SYSKEYDOWN) && (msg.wParam == 'L')) {
|
|
|
|
force_large_fat32 = !force_large_fat32;
|
2013-10-15 21:58:27 +00:00
|
|
|
PrintStatus2000(lmprintf(MSG_254), force_large_fat32);
|
2013-11-25 22:34:26 +00:00
|
|
|
GetUSBDevices(0);
|
2013-04-07 23:10:58 +00:00
|
|
|
continue;
|
|
|
|
}
|
2012-02-01 14:26:36 +00:00
|
|
|
// Alt-D => Delete the NoDriveTypeAutorun key on exit (useful if the app crashed)
|
2012-11-22 01:52:33 +00:00
|
|
|
// This key is used to disable Windows popup messages when an USB drive is plugged in.
|
2012-02-01 14:26:36 +00:00
|
|
|
if ((msg.message == WM_SYSKEYDOWN) && (msg.wParam == 'D')) {
|
2013-12-19 23:56:40 +00:00
|
|
|
PrintStatus(2000, FALSE, MSG_255);
|
2012-02-01 14:26:36 +00:00
|
|
|
existing_key = FALSE;
|
|
|
|
continue;
|
|
|
|
}
|
2013-10-13 23:02:32 +00:00
|
|
|
// Alt J => Toggle Joliet support for ISO9660 images
|
|
|
|
// Some ISOs (Ubuntu) have Joliet extensions but expect applications not to use them,
|
|
|
|
// due to their reliance on filenames that are > 64 chars (the Joliet max length for
|
|
|
|
// a file name). This option allows users to ignore Joliet when using such images.
|
|
|
|
if ((msg.message == WM_SYSKEYDOWN) && (msg.wParam == 'J')) {
|
|
|
|
enable_joliet = !enable_joliet;
|
2013-10-15 21:58:27 +00:00
|
|
|
PrintStatus2000(lmprintf(MSG_257), enable_joliet);
|
2013-10-13 23:02:32 +00:00
|
|
|
continue;
|
|
|
|
}
|
2013-10-15 21:58:27 +00:00
|
|
|
// Alt K => Toggle Rock Ridge support for ISO9660 images
|
2013-10-13 23:02:32 +00:00
|
|
|
if ((msg.message == WM_SYSKEYDOWN) && (msg.wParam == 'K')) {
|
|
|
|
enable_rockridge = !enable_rockridge;
|
2013-10-15 21:58:27 +00:00
|
|
|
PrintStatus2000(lmprintf(MSG_258), enable_rockridge);
|
2013-10-13 23:02:32 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
// Alt L => Toggle fake drive detection during bad blocks check
|
2013-12-27 16:06:59 +00:00
|
|
|
// By default, Rufus will check for fake USB flash drives that mistakenly present
|
2012-11-22 01:52:33 +00:00
|
|
|
// more capacity than they already have by looping over the flash. This check which
|
|
|
|
// is enabled by default is performed by writing the block number sequence and reading
|
|
|
|
// it back during the bad block check.
|
2013-10-13 23:02:32 +00:00
|
|
|
if ((msg.message == WM_SYSKEYDOWN) && (msg.wParam == 'L')) {
|
2012-05-16 22:38:39 +00:00
|
|
|
detect_fakes = !detect_fakes;
|
2013-10-15 21:58:27 +00:00
|
|
|
PrintStatus2000(lmprintf(MSG_256), detect_fakes);
|
2012-03-27 22:31:58 +00:00
|
|
|
continue;
|
|
|
|
}
|
2014-01-31 02:51:28 +00:00
|
|
|
// Alt N => Enable NTFS compression
|
|
|
|
if ((msg.message == WM_SYSKEYDOWN) && (msg.wParam == 'N')) {
|
|
|
|
enable_ntfs_compression = !enable_ntfs_compression;
|
|
|
|
PrintStatus2000(lmprintf(MSG_260), enable_ntfs_compression);
|
|
|
|
continue;
|
|
|
|
}
|
2012-11-29 02:59:52 +00:00
|
|
|
// Alt-R => Remove all the registry keys created by Rufus
|
2012-11-22 01:52:33 +00:00
|
|
|
if ((msg.message == WM_SYSKEYDOWN) && (msg.wParam == 'R')) {
|
2013-12-19 23:56:40 +00:00
|
|
|
PrintStatus(2000, FALSE, DeleteRegistryKey(REGKEY_HKCU, COMPANY_NAME "\\" APPLICATION_NAME)?MSG_248:MSG_249);
|
2012-11-22 01:52:33 +00:00
|
|
|
// Also try to delete the upper key (company name) if it's empty (don't care about the result)
|
2013-02-02 16:57:46 +00:00
|
|
|
DeleteRegistryKey(REGKEY_HKCU, COMPANY_NAME);
|
2012-11-22 01:52:33 +00:00
|
|
|
continue;
|
|
|
|
}
|
2013-10-22 21:46:59 +00:00
|
|
|
// Alt U => Force the update check to be successful
|
|
|
|
// This will set the reported current version of Rufus to 0.0.0.0 when performing an update
|
|
|
|
// check, so that it always succeeds. This is useful for translators.
|
|
|
|
if ((msg.message == WM_SYSKEYDOWN) && (msg.wParam == 'U')) {
|
|
|
|
force_update = !force_update;
|
|
|
|
PrintStatus2000(lmprintf(MSG_259), force_update);
|
|
|
|
continue;
|
|
|
|
}
|
2012-02-01 14:26:36 +00:00
|
|
|
TranslateMessage(&msg);
|
|
|
|
DispatchMessage(&msg);
|
|
|
|
}
|
2011-11-13 20:53:23 +00:00
|
|
|
}
|
2013-10-24 21:57:34 +00:00
|
|
|
if (relaunch) {
|
|
|
|
relaunch = FALSE;
|
|
|
|
reinit_localization();
|
|
|
|
goto relaunch;
|
|
|
|
}
|
2011-11-13 20:53:23 +00:00
|
|
|
|
|
|
|
out:
|
2013-10-16 19:45:34 +00:00
|
|
|
if ((!external_loc_file) && (loc_file[0] != 0))
|
2013-10-15 21:58:27 +00:00
|
|
|
DeleteFileU(loc_file);
|
2012-02-07 02:05:58 +00:00
|
|
|
DestroyAllTooltips();
|
2013-10-15 21:58:27 +00:00
|
|
|
exit_localization();
|
2012-02-07 02:05:58 +00:00
|
|
|
safe_free(iso_path);
|
2013-12-15 21:27:25 +00:00
|
|
|
safe_free(locale_name);
|
2012-12-07 00:54:40 +00:00
|
|
|
safe_free(update.download_url);
|
|
|
|
safe_free(update.release_notes);
|
2013-02-04 01:14:28 +00:00
|
|
|
if (argv != NULL) {
|
|
|
|
for (i=0; i<argc; i++) safe_free(argv[i]);
|
|
|
|
safe_free(argv);
|
|
|
|
}
|
2013-12-28 16:48:02 +00:00
|
|
|
if (lgp_set)
|
|
|
|
SetLGP(TRUE, &existing_key, "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer", "NoDriveTypeAutorun", 0);
|
2013-02-04 01:14:28 +00:00
|
|
|
if (attached_console)
|
|
|
|
DetachConsole();
|
2011-11-13 20:53:23 +00:00
|
|
|
CloseHandle(mutex);
|
2013-06-06 22:40:37 +00:00
|
|
|
uprintf("*** " APPLICATION_NAME " exit ***\n");
|
2011-11-21 20:12:23 +00:00
|
|
|
#ifdef _CRTDBG_MAP_ALLOC
|
|
|
|
_CrtDumpMemoryLeaks();
|
|
|
|
#endif
|
|
|
|
|
2011-11-13 20:53:23 +00:00
|
|
|
return 0;
|
|
|
|
}
|