// // Enable/disable media write protection // DWORD CVfdShExt::DoVfdProtect( HWND hParent) { HANDLE hDevice; DWORD ret; UNREFERENCED_PARAMETER(hParent); VFDTRACE(0, ("CVfdShExt::DoVfdProtect()\n")); hDevice = VfdOpenDevice(m_nDevice); if (hDevice == INVALID_HANDLE_VALUE) { return GetLastError(); } ret = VfdGetMediaState(hDevice); if (ret == ERROR_SUCCESS) { ret = VfdWriteProtect(hDevice, TRUE); } else if (ret == ERROR_WRITE_PROTECT) { ret = VfdWriteProtect(hDevice, FALSE); } if (ret == ERROR_SUCCESS) { ret = VfdGetMediaState(hDevice); } CloseHandle(hDevice); return ret; }
// // protect button is clicked // void OnProtectClicked(HWND hDlg, HWND hButton) { HANDLE hDevice; DWORD ret; hDevice = VfdOpenDevice( GetWindowLong(hDlg, GWL_USERDATA)); if (hDevice != INVALID_HANDLE_VALUE) { if (SendMessage(hButton, BM_GETCHECK, 0, 0) == BST_CHECKED) { ret = VfdWriteProtect(hDevice, TRUE); } else { ret = VfdWriteProtect(hDevice, FALSE); } CloseHandle(hDevice); } else { ret = GetLastError(); } if (ret != ERROR_SUCCESS) { AppendLogMessage(ret, MSG_ERR_CHANGE_PROTECT); } }
// // Close the current image and open the new image // void CommandLine() { ULONG target = '0'; PSTR file_name = NULL; VFD_DISKTYPE disk_type = VFD_DISKTYPE_FILE; VFD_MEDIA media_type = VFD_MEDIA_NONE; VFD_FLAGS image_flags = 0; VFD_FILETYPE file_type; BOOL five_inch = FALSE; CHAR protect = 0; BOOL open_folder = TRUE; BOOL close_only = FALSE; HANDLE hDevice; CHAR letter; DWORD driver_state; DWORD ret; // // process command line parameters // while (*(++__argv)) { // Open switch if (_stricmp(*__argv, VFD_OPEN_SWITCH) == 0) { close_only = FALSE; } // Close switch else if (_stricmp(*__argv, "/close") == 0) { close_only = TRUE; } // Quiet mode switch else if (stricmp(*__argv, "/q") == 0) { open_folder = FALSE; } // Disk type options else if (_stricmp(*__argv, "/ram") == 0) { disk_type = VFD_DISKTYPE_RAM; } // Protect options else if (_stricmp(*__argv, "/p") == 0 || _stricmp(*__argv, "/w") == 0) { protect = (CHAR)toupper(*(*__argv + 1)); } // media type options /*else if (strcmp(*__argv, "/160") == 0) { media_type = VFD_MEDIA_F5_160; } else if (strcmp(*__argv, "/180") == 0) { media_type = VFD_MEDIA_F5_180; } else if (strcmp(*__argv, "/320") == 0) { media_type = VFD_MEDIA_F5_320; } else if (strcmp(*__argv, "/360") == 0) { media_type = VFD_MEDIA_F5_360; } else if (strcmp(*__argv, "/640") == 0) { media_type = VFD_MEDIA_F3_640; }*/ else if (strcmp(*__argv, "/720") == 0) { media_type = VFD_MEDIA_F3_720; } /*else if (strcmp(*__argv, "/820") == 0) { media_type = VFD_MEDIA_F3_820; } else if (strcmp(*__argv, "/120") == 0 || strcmp(*__argv, "/1.20") == 0) { media_type = VFD_MEDIA_F3_1P2; }*/ else if (strcmp(*__argv, "/144") == 0 || strcmp(*__argv, "/1.44") == 0) { media_type = VFD_MEDIA_F3_1P4; } /*else if (strcmp(*__argv, "/168") == 0 || strcmp(*__argv, "/1.68") == 0) { media_type = VFD_MEDIA_F3_1P6; } else if (strcmp(*__argv, "/172") == 0 || strcmp(*__argv, "/1.72") == 0) { media_type = VFD_MEDIA_F3_1P7; } else if (strcmp(*__argv, "/288") == 0 || strcmp(*__argv, "/2.88") == 0) { media_type = VFD_MEDIA_F3_2P8; }*/ // 5.25 inch else if (strcmp(*__argv, "/5") == 0 || strcmp(*__argv, "/525") == 0 || strcmp(*__argv, "/5.25") == 0) { five_inch = TRUE; } // target drive else if (isalnum(**__argv) && *(*__argv + 1) == ':' && *(*__argv + 2) == '\0') { target = toupper(**__argv); } else if (**__argv == '*' && *(*__argv + 1) == ':' && *(*__argv + 2) == '\0') { target = (ULONG)-1; } // image filename else if (**__argv != '/') { file_name = *__argv; if (*file_name == '\"' && *(file_name + strlen(file_name) - 1) == '\"') { // remove quote characters if the path is quoted *(file_name + strlen(file_name) - 1) = '\0'; file_name++; } } // unknown options else { ShowErrorMessage(0, MSG_ERR_INVALID_PARAM, *__argv); return; } } // check parameter consistency if (target == (ULONG)-1 && !close_only) { ShowErrorMessage(0, MSG_ERR_INVALID_PARAM, "*:"); return; } // Get the current driver state ret = VfdGetDriverState(&driver_state); if (ret != ERROR_SUCCESS) { ShowErrorMessage(ret, MSG_ERR_APP_INTERNAL); return; } if (close_only && driver_state != SERVICE_RUNNING) { // nothing to do... return; } // ensure that the driver is running if (driver_state == VFD_NOT_INSTALLED) { ret = VfdInstallDriver(NULL, SERVICE_DEMAND_START); if (ret != ERROR_SUCCESS) { ShowErrorMessage(ret, MSG_ERR_DRIVER_INSTALL); return; } } // ensure that the driver is started if (driver_state != SERVICE_RUNNING) { ret = VfdStartDriver(&driver_state); if (ret != ERROR_SUCCESS || driver_state != SERVICE_RUNNING) { ShowErrorMessage(ret, MSG_ERR_DRIVER_START); return; } } // // close the current image (if any) // if (target == (ULONG)-1) { int i; for (i = 0; i < VFD_MAXIMUM_DEVICES; i++) { ret = VfdGuiClose(NULL, i); if (ret != ERROR_SUCCESS && ret != ERROR_NOT_READY) { ShowErrorMessage(ret, MSG_ERR_IMAGE_CLOSE, i + '0'); } } return; } ret = VfdGuiClose(NULL, target); if (ret != ERROR_SUCCESS && ret != ERROR_NOT_READY) { ShowErrorMessage(ret, MSG_ERR_IMAGE_CLOSE, target); return; } if (close_only) { return; } // // check target image file // if (file_name) { DWORD file_attr; ULONG image_size; ret = VfdCheckImageFile( file_name, &file_attr, &file_type, &image_size); if (ret == ERROR_FILE_NOT_FOUND) { // If file does not exist, create a new image file if (media_type == VFD_MEDIA_NONE) { media_type = VFD_MEDIA_F3_1P4; } ret = VfdCreateImageFile( file_name, media_type, VFD_FILETYPE_RAW, FALSE); if (ret != ERROR_SUCCESS) { ShowErrorMessage(ret, MSG_ERR_FILE_CREATE, file_name); return; } ret = VfdCheckImageFile( file_name, &file_attr, &file_type, &image_size); if (ret != ERROR_SUCCESS) { ShowErrorMessage(ret, MSG_ERR_FILE_OPEN, file_name); return; } } else if (ret == ERROR_SUCCESS) { // check file size / media size ULONG media_size; VFD_MEDIA def_media; media_size = VfdGetMediaSize(media_type); if (media_size > image_size) { ShowErrorMessage(0, MSG_ERR_IMAGE_TOO_SMALL); return; } def_media = VfdLookupMedia(image_size); if (def_media == VFD_MEDIA_NONE) { ShowErrorMessage(0, MSG_ERR_IMAGE_TOO_SMALL); return; } if (media_type == VFD_MEDIA_NONE) { media_type = def_media; } // check file type if (file_type == VFD_FILETYPE_ZIP || (file_attr & (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_COMPRESSED | FILE_ATTRIBUTE_ENCRYPTED))) { disk_type = VFD_DISKTYPE_RAM; } } else { ShowErrorMessage(ret, MSG_ERR_FILE_OPEN, file_name); return; } if (disk_type != VFD_DISKTYPE_FILE) { if (protect != 'W') { protect = 'P'; } } } else { disk_type = VFD_DISKTYPE_RAM; if (media_type == VFD_MEDIA_NONE) { media_type = VFD_MEDIA_F3_1P4; } } if (protect == 'P') { image_flags |= VFD_FLAG_WRITE_PROTECTED; } if (five_inch && VfdGetMediaSize(media_type) == VfdGetMediaSize((VFD_MEDIA)(media_type + 1))) { media_type = (VFD_MEDIA)(media_type + 1); } // Open the target device hDevice = VfdOpenDevice(target); if (hDevice == INVALID_HANDLE_VALUE) { ShowErrorMessage(GetLastError(), MSG_ERR_DEVICE_OPEN, target); return; } // assign a drive letter if the drive has none VfdGetGlobalLink(hDevice, &letter); if (!isalpha(letter)) { VfdGetLocalLink(hDevice, &letter); } if (!isalpha(letter)) { letter = VfdChooseLetter(); VfdSetLocalLink(hDevice, letter); } // Open the image file ret = VfdOpenImage(hDevice, file_name, disk_type, media_type, image_flags); CloseHandle(hDevice); if (ret != ERROR_SUCCESS) { ShowErrorMessage(ret, MSG_ERR_FILE_OPEN, file_name ? file_name : "<RAM>"); return; } // // Unless otherwise specified, open the drive // if (open_folder && isalpha(letter)) { CHAR drive[] = "A:\\"; CHAR verb[20] = {0}; LONG size = sizeof(verb); drive[0] = (CHAR)toupper(letter); // get the default verb for folder object from the registry RegQueryValue(HKEY_CLASSES_ROOT, "Folder\\shell", verb, &size); ret = (DWORD)ShellExecute( NULL, verb[0] ? verb : NULL, drive, NULL, NULL, SW_SHOWNORMAL); if (ret <= 32) { VFDTRACE(0, ("OpenImage : ShellExecute - %s", GetSystemMessage(GetLastError()))); } } return; }
// // FUNCTION: CVfdShExt::QueryContextMenu(HMENU, UINT, UINT, UINT, UINT) // // PURPOSE: Called by the shell just before the context menu is displayed. // This is where you add your specific menu items. // // PARAMETERS: // hMenu - Handle to the context menu // indexMenu - Index of where to begin inserting menu items // idCmdFirst - Lowest value for new menu ID's // idCmtLast - Highest value for new menu ID's // uFlags - Specifies the context of the menu event // STDMETHODIMP CVfdShExt::QueryContextMenu( HMENU hMenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags) { UNREFERENCED_PARAMETER(idCmdLast); VFDTRACE(0, ("CVfdShExt::QueryContextMenu()\n")); // // Check if menu items should be added // if ((CMF_DEFAULTONLY & uFlags) || !m_pDataObj || m_nDevice == (ULONG)-1) { VFDTRACE(0, ("Don't add any items.\n")); return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 0); } // // Drag & Drop handler? // if (m_bDragDrop) { VFDTRACE(0, ("Invoked as the Drop handler.\n")); if (GetFileAttributes(m_sTarget) & FILE_ATTRIBUTE_DIRECTORY) { // if the dropped item is a directory, nothing to do here VFDTRACE(0, ("Dropped object is a directory.\n")); return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 0); } // Add a drop context menu item AddMenuItem( hMenu, indexMenu, MF_BYPOSITION | MF_STRING, idCmdFirst + VFD_CMD_DROP, g_VfdMenu[VFD_CMD_DROP].textid); return MAKE_HRESULT(SEVERITY_SUCCESS, 0, VFD_CMD_DROP + 1); } // // Context menu handler // VFDTRACE(0, ("Invoked as the context menu handler.\n")); // // Get the VFD media state // HANDLE hDevice = VfdOpenDevice(m_nDevice); if (hDevice == INVALID_HANDLE_VALUE) { VFDTRACE(0, ("device open failed.\n")); return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 0); } DWORD status = VfdGetMediaState(hDevice); CloseHandle(hDevice); // // Add context menu items // InsertMenu(hMenu, indexMenu++, MF_BYPOSITION | MF_SEPARATOR, 0, NULL); if (status == ERROR_SUCCESS || status == ERROR_WRITE_PROTECT) { // An image is opened // insert the "save" menu item AddMenuItem( hMenu, indexMenu++, MF_BYPOSITION | MF_STRING, idCmdFirst + VFD_CMD_SAVE, g_VfdMenu[VFD_CMD_SAVE].textid); // insert the "close" menu item AddMenuItem( hMenu, indexMenu++, MF_BYPOSITION | MF_STRING, idCmdFirst + VFD_CMD_CLOSE, g_VfdMenu[VFD_CMD_CLOSE].textid); // insert the "protect" menu item AddMenuItem( hMenu, indexMenu++, MF_BYPOSITION | MF_STRING, idCmdFirst + VFD_CMD_PROTECT, g_VfdMenu[VFD_CMD_PROTECT].textid); // check "protect" menu item if (status == ERROR_WRITE_PROTECT) { CheckMenuItem(hMenu, indexMenu - 1, MF_BYPOSITION | MF_CHECKED); } } else { // The drive is empty // insert the "open" menu item AddMenuItem( hMenu, indexMenu++, MF_BYPOSITION | MF_STRING, idCmdFirst + VFD_CMD_OPEN, g_VfdMenu[VFD_CMD_OPEN].textid); } // Insert the "proterty" menu item AddMenuItem( hMenu, indexMenu++, MF_BYPOSITION | MF_STRING, idCmdFirst + VFD_CMD_PROP, g_VfdMenu[VFD_CMD_PROP].textid); // Insert a separator InsertMenu(hMenu, indexMenu, MF_BYPOSITION | MF_SEPARATOR, 0, NULL); return MAKE_HRESULT(SEVERITY_SUCCESS, 0, VFD_CMD_PROP + 1); }
// // Open dropped file with VFD // DWORD CVfdShExt::DoVfdDrop( HWND hParent) { HANDLE hDevice; DWORD file_attr; ULONG file_size; VFD_FILETYPE file_type; VFD_DISKTYPE disk_type; VFD_MEDIA media_type; DWORD ret; VFDTRACE(0, ("CVfdShExt::DoVfdDropOpen()\n")); // check if dropped file is a valid image ret = VfdCheckImageFile( m_sTarget, &file_attr, &file_type, &file_size); if (ret != ERROR_SUCCESS) { return ret; } // check file size media_type = VfdLookupMedia(file_size); if (!media_type) { PSTR msg = ModuleMessage(MSG_FILE_TOO_SMALL); MessageBox(hParent, msg ? msg : "Bad size", VFD_MSGBOX_TITLE, MB_ICONSTOP); if (msg) { LocalFree(msg); } return ERROR_CANCELLED; } if ((file_type == VFD_FILETYPE_ZIP) || (file_attr & (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_COMPRESSED | FILE_ATTRIBUTE_ENCRYPTED))) { disk_type = VFD_DISKTYPE_RAM; } else { disk_type = VFD_DISKTYPE_FILE; } // close current image (if opened) ret = DoVfdClose(hParent); if (ret != ERROR_SUCCESS && ret != ERROR_NOT_READY) { return ret; } // open dropped file hDevice = VfdOpenDevice(m_nDevice); if (hDevice == INVALID_HANDLE_VALUE) { return GetLastError(); } ret = VfdOpenImage( hDevice, m_sTarget, disk_type, media_type, FALSE); CloseHandle(hDevice); return ret; }
// // OK button is clicked // void OnLetterOK(HWND hDlg) { HANDLE hDevice; ULONG letter; BOOL persistent; CHAR buf[10]; DWORD ret = ERROR_SUCCESS; // Get combo box selection if (!GetDlgItemText(hDlg, IDC_DRIVE_LETTER, buf, sizeof(buf))) { ShowErrorMessage(GetLastError(), MSG_ERR_APP_INTERNAL); return; } // Get persistent button state persistent = (IsDlgButtonChecked(hDlg, IDC_PERSISTENT) == BST_CHECKED); // Get the original drive letter letter = GetWindowLong(hDlg, DWL_USER); // Open the VFD drive hDevice = VfdOpenDevice( GetWindowLong(hDlg, GWL_USERDATA)); if (hDevice == INVALID_HANDLE_VALUE) { ShowErrorMessage(GetLastError(), MSG_ERR_APP_INTERNAL); return; } if (isalpha(LOWORD(letter))) { // delete the original drive letter if (HIWORD(letter)) { ret = VfdSetGlobalLink(hDevice, 0); } else { ret = VfdSetLocalLink(hDevice, 0); } } if (ret == ERROR_SUCCESS && isalpha(buf[0])) { // create a new drive letter if (persistent) { ret = VfdSetGlobalLink(hDevice, buf[0]); } else { ret = VfdSetLocalLink(hDevice, buf[0]); } } CloseHandle(hDevice); if (ret != ERROR_SUCCESS) { ShowErrorMessage(GetLastError(), MSG_ERR_APP_INTERNAL); return; } }
// // initialize the drive letter dialog // BOOL OnLetterInit(HWND hDlg, ULONG nDevice) { HANDLE hDevice; CHAR buf[20]; HWND hCombo; DWORD logical; BOOL persistent; // // setup controls text // SetControlText(hDlg, 0, MSG_LETTER_TITLE); SetControlText(hDlg, IDC_LETTER_LABEL, MSG_LETTER_LABEL); SetControlText(hDlg, IDC_PERSISTENT, MSG_PERSISTENT); SetControlText(hDlg, IDOK, MSG_OK_BUTTON); SetControlText(hDlg, IDCANCEL, MSG_CANCEL_BUTTON); // // setup the drive letter combo box // hCombo = GetDlgItem(hDlg, IDC_DRIVE_LETTER); if (hCombo == NULL) { ShowErrorMessage(GetLastError(), 0); return FALSE; } // initialize the list SendMessage(hCombo, CB_RESETCONTENT, 0, 0); // add <none> if (!GetLocalMessage(MSG_GENERIC_NONE, buf, sizeof(buf))) { strcpy(buf, "(none)"); } SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM)buf); // add unused drive letters logical = GetLogicalDrives(); if (logical == 0) { ShowErrorMessage(GetLastError(), 0); return FALSE; } strcpy(buf, "A:"); while (buf[0] <= 'Z') { if (!(logical & 0x01)) { SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM)buf); } logical >>= 1; buf[0]++; } SendMessage(hCombo, CB_SETCURSEL, 0, 0); // Get the drive letter of the VFD drive hDevice = VfdOpenDevice(nDevice); if (hDevice == INVALID_HANDLE_VALUE) { ShowErrorMessage(GetLastError(), MSG_ERR_APP_INTERNAL); return FALSE; } persistent = TRUE; VfdGetGlobalLink(hDevice, &buf[0]); if (!isalpha(buf[0])) { if (VfdGetLocalLink(hDevice, &buf[0]) == ERROR_SUCCESS && isalpha(buf[0])) { persistent = FALSE; } } CloseHandle(hDevice); if (isalpha(buf[0])) { SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM)buf); SendMessage(hCombo, CB_SELECTSTRING, (WPARAM)-1, (LPARAM)buf); } // set the persistent button state CheckDlgButton(hDlg, IDC_PERSISTENT, persistent ? BST_CHECKED : BST_UNCHECKED); // store the device number SetWindowLong(hDlg, GWL_USERDATA, nDevice); // store the current drive letter SetWindowLong(hDlg, DWL_USER, MAKELONG(buf[0], persistent)); return TRUE; }
// // Refresh the Drive dialog // void OnRefreshDialog(HWND hDlg) { DWORD state; HANDLE hDevice; CHAR buf[MAX_PATH]; VFD_DISKTYPE disk_type; VFD_MEDIA media_type; VFD_FLAGS media_flags; VFD_FILETYPE file_type; ULONG image_size; CHAR letter; DWORD attrib; DWORD ret; // get the driver state ret = VfdGetDriverState(&state); if (ret != ERROR_SUCCESS) { return; } if (state != SERVICE_RUNNING) { // the driver is not running // clear all information and disable controls SetDlgItemText(hDlg, IDC_DRIVE_LETTER, NULL); SetDlgItemText(hDlg, IDC_IMAGEFILE, NULL); SetDlgItemText(hDlg, IDC_MEDIATYPE, NULL); EnableWindow(GetDlgItem(hDlg, IDC_CHANGE), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_OPEN), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_SAVE), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_CLOSE), FALSE); return; } // open the device hDevice = VfdOpenDevice(GetWindowLong(hDlg, GWL_USERDATA)); if (hDevice == INVALID_HANDLE_VALUE) { AppendLogMessage(GetLastError(), 0); return; } // get the current drive letter VfdGetGlobalLink(hDevice, &letter); buf[0] = '\0'; if (isalpha(letter)) { sprintf(buf, "%c (", letter); GetLocalMessage(MSG_PERSISTENT, &buf[3], sizeof(buf) - 3); strcat(buf, ")"); } else { VfdGetLocalLink(hDevice, &letter); if (isalpha(letter)) { sprintf(buf, "%c (", letter); GetLocalMessage(MSG_EPHEMERAL, &buf[3], sizeof(buf) - 3); strcat(buf, ")"); } } SetDlgItemText(hDlg, IDC_DRIVE_LETTER, buf); EnableWindow(GetDlgItem(hDlg, IDC_CHANGE), TRUE); // get the current image information ret = VfdGetImageInfo(hDevice, buf, &disk_type, &media_type, &media_flags, &file_type, &image_size); CloseHandle(hDevice); if (ret != ERROR_SUCCESS) { AppendLogMessage(ret, 0); return; } if (media_type == VFD_MEDIA_NONE) { // no media SetDlgItemText(hDlg, IDC_IMAGEFILE, NULL); SetDlgItemText(hDlg, IDC_DESCRIPTION, NULL); SetDlgItemText(hDlg, IDC_MEDIATYPE, NULL); EnableWindow(GetDlgItem(hDlg, IDC_OPEN), TRUE); EnableWindow(GetDlgItem(hDlg, IDC_SAVE), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_CLOSE), FALSE); SendMessage(GetDlgItem(hDlg, IDC_OPEN), BM_SETSTYLE, BS_DEFPUSHBUTTON, TRUE); return; } // set image file name if (buf[0]) { attrib = GetFileAttributes(buf); if (attrib == INVALID_FILE_ATTRIBUTES) { attrib = 0; } } else { if (disk_type != VFD_DISKTYPE_FILE) { strcpy(buf, "<RAM>"); } file_type = VFD_FILETYPE_NONE; attrib = 0; } SetDlgItemText(hDlg, IDC_IMAGEFILE, buf); // set description VfdMakeFileDesc(buf, sizeof(buf), file_type, image_size, attrib); SetDlgItemText(hDlg, IDC_DESCRIPTION, buf); // set disk type text // set media type text SetDlgItemText(hDlg, IDC_MEDIATYPE, VfdMediaTypeName(media_type)); // set write protected state // // enable / disable appropriate buttons // EnableWindow(GetDlgItem(hDlg, IDC_OPEN), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_SAVE), TRUE); EnableWindow(GetDlgItem(hDlg, IDC_CLOSE), TRUE); SendMessage(GetDlgItem(hDlg, IDC_CLOSE), BM_SETSTYLE, BS_DEFPUSHBUTTON, TRUE); }