/************************************************* * tgtproc.c * * * * Copyright (C) 1992-1999 Microsoft Inc. * * * *************************************************/ #include "chnuconv.h" #include "resource.h" INT_PTR TargetTabProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam ) { TCHAR szBuffer[MAX_PATH]; int i; switch( message ) { case WM_INITDIALOG: { RECT rcTab; //GetTab window size // first get the size of the tab control if (GetWindowRect( hMainTabControl, &rcTab )){ // adjust it to compensate for the tabs TabCtrl_AdjustRect( hMainTabControl, FALSE , &rcTab); // convert the screen coordinates to client coordinates MapWindowPoints( HWND_DESKTOP, GetParent(hMainTabControl), (LPPOINT)&rcTab, 2); } SetWindowPos(hWnd, HWND_TOP, rcTab.left, rcTab.top, rcTab.right - rcTab.left, rcTab.bottom - rcTab.top, SWP_NOACTIVATE ); LoadString(_hModule, IDS_BUT_SAVEAS, szBuffer, EXTENSION_LENGTH); SetDlgItemText(hWnd,IDC_OPENORSAVEAS, szBuffer); LoadString(_hModule, IDS_BUT_TOCLIPBOARD,szBuffer,EXTENSION_LENGTH); SetDlgItemText(hWnd, IDC_PASTEORCOPY, szBuffer); for (i=0;i<NumCodePage;i++) { LoadString(_hModule, IDS_CTLUNICODE+i,szBuffer,EXTENSION_LENGTH); ShowWindow(GetDlgItem(hWnd, IDC_RBUNICODE1+i), SW_SHOW); SetDlgItemText(hWnd, IDC_RBUNICODE1+i, szBuffer); } SendMessage(hWnd, WM_COMMAND, IDC_CLEAR, 0); return(FALSE); } case WM_COMMAND: { switch(wParam){ /******************************************************************\ * WM_COMMAND, IDC_OPENORSAVEAS * * Put up common dialog, try to open file, and write data to it. \******************************************************************/ case IDC_OPENORSAVEAS: { HANDLE hFile; DWORD nBytesRead; TCHAR szFile[MAX_PATH],szFileTitle[MAX_PATH]; TCHAR szDefExt[4]; OPENFILENAME OpenFileName; /* buffers for the file names. */ if (nBytesDestination == NODATA ) { LoadString(_hModule,IDS_NOTEXTSAVE,MBMessage,EXTENSION_LENGTH); MessageBox (hWnd, MBMessage,MBTitle, MBFlags); return 0; } //see if user selects swap destination SwapDest(FALSE); /* Set up the structure for the GetSaveFileName * common dialog. */ lstrcpy(szDefExt, TEXT("txt") ); wsprintf (szFile, szBlank); wsprintf (szFileTitle, szBlank); OpenFileName.lStructSize = sizeof(OPENFILENAME); OpenFileName.hwndOwner = hWnd; OpenFileName.hInstance = (HANDLE) _hModule; OpenFileName.lpstrFilter = szFilter; OpenFileName.lpstrCustomFilter = NULL; OpenFileName.nMaxCustFilter = 0L; OpenFileName.nFilterIndex = 1L; OpenFileName.lpstrFile = szFile; OpenFileName.nMaxFile = MAX_PATH; OpenFileName.lpstrFileTitle = szFileTitle; OpenFileName.nMaxFileTitle = MAX_PATH; OpenFileName.lpstrInitialDir = NULL; LoadString(_hModule, IDS_SAVEAS, szBuffer, 50); OpenFileName.lpstrTitle = szBuffer; OpenFileName.nFileOffset = 0; OpenFileName.nFileExtension = 0; OpenFileName.lpstrDefExt = szDefExt; OpenFileName.lCustData = 0; OpenFileName.lpfnHook = NULL; OpenFileName.lpTemplateName = NULL; OpenFileName.Flags = OFN_HIDEREADONLY; if (!GetSaveFileName(&OpenFileName)) return 0; /* User has filled in the file information. * Try to open that file for writing. */ hFile = CreateFile(szFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (hFile == INVALID_HANDLE_VALUE) { LoadString(_hModule,IDS_CREATEERROR,MBMessage,EXTENSION_LENGTH); MessageBox (hWnd, MBMessage,MBTitle, MBFlags); return 0; } /* if destination is unicode, try to write BOM first. * unless the bytes have been swapped * (criterion: hwndByteOrder contains text) * in which case, write a Reverse Byte Order Mark. */ if (gTypeDest == TYPEUNICODE) if (!SendDlgItemMessage(hWndTab[1],IDC_SWAPHIGHLOW, BM_GETCHECK, 0, 0)){ if (!WriteFile (hFile, szBOM, SIZEOFBOM, &nBytesRead, NULL)) { LoadString(_hModule,IDS_WRITEERROR,MBMessage,EXTENSION_LENGTH); MessageBox (hWnd, MBMessage,MBTitle, MBFlags); CloseHandle (hFile); return 0; } } else { if (!WriteFile (hFile, szRBOM, SIZEOFBOM, &nBytesRead, NULL)) { LoadString(_hModule,IDS_WRITEERROR,MBMessage,EXTENSION_LENGTH); MessageBox (hWnd, MBMessage,MBTitle, MBFlags); CloseHandle (hFile); return 0; } } /* try to write all of it into memory */ if (!WriteFile (hFile, pDestinationData,nBytesDestination, &nBytesRead, NULL)) { LoadString(_hModule,IDS_WRITEERROR,MBMessage,EXTENSION_LENGTH); MessageBox (hWnd, MBMessage,MBTitle, MBFlags); CloseHandle (hFile); return 0; } SetDlgItemText (hWnd,IDC_NAMETEXT,szFile); CloseHandle (hFile); break; } case IDC_VIEW: { SwapDest(FALSE); if (gTypeDest == TYPEUNICODE) DialogBoxW (_hModule, MAKEINTRESOURCEW(IDD_SHOWTEXT), hWnd, ViewTargetProc); else DialogBoxA (_hModule, MAKEINTRESOURCEA(IDD_SHOWTEXT), hWnd, ViewTargetProc); break; } /**********************************************************************\ * WM_COMMAND, IDC_CLEAR * * Clear the SOURCE information. May cause data to be lost. \**********************************************************************/ case IDC_CLEAR: { int i; SetDlgItemText (hWnd, IDC_NAMETEXT, szBlank); SetDlgItemText (hWnd, IDC_SIZETEXT, szBlank); for(i=0;i<NumCodePage;i++) SendDlgItemMessage(hWnd,IDC_RBUNICODE1+i, BM_SETCHECK, 0,0); pDestinationData= ManageMemory (MMFREE, MMSOURCE, 0, pDestinationData); nBytesDestination=0; pTempData1= ManageMemory (MMFREE, MMDESTINATION, 0, pTempData1); EnableControl(hWnd, IDC_VIEW, FALSE); EnableControl(hWnd, IDC_PASTEORCOPY, FALSE); EnableControl(hWnd, IDC_OPENORSAVEAS, FALSE); EnableControl(hWnd, IDC_CLEAR, FALSE); EnableControl(hWnd, IDC_SWAPHIGHLOW, FALSE); SendDlgItemMessage (hWnd,IDC_SWAPHIGHLOW, BM_SETCHECK, 0, 0); // set gDestSwapped as FALSE gDestSwapped = FALSE; EnableMenuItem (GetMenu (_hWndMain),IDM_FILE_SAVEAS,MF_GRAYED); break; } /**********************************************************************\ * WM_COMMAND, IDC_PASTEORCOPY * * Copy destination data to the clipboard. \**********************************************************************/ case IDC_PASTEORCOPY: { int i; if (pDestinationData == NULL) return FALSE; //see if user selects swap hi-low byte order SwapDest(FALSE); OpenClipboard (hWnd); if( EmptyClipboard() ) { GlobalUnlock(hglbMem); GlobalFree(hglbMem); hglbMem = GlobalAlloc (GMEM_MOVEABLE | GMEM_DDESHARE, nBytesDestination+40); p=(PBYTE)GlobalLock(hglbMem); for(i=0;i<nBytesDestination;i++) *(p+i)=*(pDestinationData+i); *(p+i)=0; //if source NOT unicode, destination is, else look at dest CP if (gTypeDest == TYPEUNICODE) { *(p+i+1)=0; GlobalUnlock(hglbMem); SetClipboardData (CF_UNICODETEXT, hglbMem); } else { GlobalUnlock(hglbMem); if (gTypeDestID == giRBInit-CODEPAGEBASE) SetClipboardData (CF_TEXT, hglbMem); else SetClipboardData (CF_OEMTEXT, hglbMem); } } CloseClipboard (); } break; } } default: break; } return DefWindowProc( hWnd, message, wParam, lParam ); } /***************************************************************************\ * FUNCTION: ViewTargetProc * * Fill Text, Name, and Type information into the dialog. * Set a proper font to display the text depending on what type it is. * \***************************************************************************/ INT_PTR ViewTargetProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam ) { RECT rect; switch (message) { /******************************************************************\ * WM_INITDIALOG \******************************************************************/ case WM_INITDIALOG: { GetSettings(); // Text is unicode... use *W() variants of functions. if (gTypeDest == TYPEUNICODE) { WCHAR szBuffer[MAX_PATH]; SetDlgItemTextW (hWnd, IDC_SHOWTEXT_EDIT, (LPCWSTR)pDestinationData); GetDlgItemTextW (hWndTab[1], IDC_NAMETEXT, szBuffer, MAX_PATH); SetDlgItemTextW (hWnd, IDC_SHOWTEXT_NAME, szBuffer); LoadStringW(_hModule, gTypeDestID+STRCODEPAGEBASE, szBuffer,EXTENSION_LENGTH); SetDlgItemTextW (hWnd, IDC_SHOWTEXT_TYPE, szBuffer); // Text is codepage... use *A() variants of functions. } else { char szBuffer[MAX_PATH]; SetDlgItemTextA (hWnd, IDC_SHOWTEXT_EDIT, (LPCSTR)pDestinationData); GetDlgItemTextA (hWndTab[1], IDC_NAMETEXT, szBuffer, MAX_PATH); SetDlgItemTextA (hWnd, IDC_SHOWTEXT_NAME, szBuffer); LoadStringA(_hModule, gTypeDestID+STRCODEPAGEBASE, szBuffer,EXTENSION_LENGTH); SetDlgItemTextA (hWnd, IDC_SHOWTEXT_TYPE, szBuffer); } LoadString(_hModule, IDS_VIEWTARGET, &gszExtensions[11][0], EXTENSION_LENGTH); SetWindowText (hWnd,&gszExtensions[11][0] ); GetClientRect (hWnd, &rect); SendMessage (hWnd, WM_SIZE, 0, MAKELPARAM ((rect.right - rect.left), (rect.bottom - rect.top))); return TRUE; } case WM_SIZE: { HWND hwndText; HWND hwndNotice; RECT rc; POINT pt; hwndNotice = GetDlgItem (hWnd,IDC_SHOWTEXT_FONT); GetWindowRect(hwndNotice,&rc); pt.x = 0; pt.y = rc.bottom; ScreenToClient(hWnd, &pt); hwndText = GetDlgItem (hWnd, IDC_SHOWTEXT_EDIT); MoveWindow (hwndText, DLGBORDER, pt.y+5, (int) LOWORD(lParam) - 2*DLGBORDER, (int) HIWORD(lParam) - (pt.y+5) - DLGBORDER , TRUE); } break; case WM_COMMAND: switch (LOWORD (wParam)) { case IDCANCEL: case IDOK: EndDialog (hWnd, TRUE); } break; /* end WM_COMMAND */ case WM_SYSCOMMAND: if (LOWORD (wParam) == SC_CLOSE) EndDialog (hWnd, FALSE); break; } /* end switch */ return FALSE; } BOOL SwapDest( BOOL bForceSwap ) { int i, end; BYTE temp; if (pDestinationData == NULL) return FALSE; //Is the Destination already swapped? if (SendDlgItemMessage(hWndTab[1], IDC_SWAPHIGHLOW, BM_GETCHECK,0,0) == gDestSwapped && !bForceSwap) return FALSE; end = nBytesDestination - 2; for (i = 0; i<= end; i+=2) { temp = pDestinationData[i]; pDestinationData[i] = pDestinationData[i+1]; pDestinationData[i+1] = temp; } //set flag that source has been swapped; gDestSwapped = 1 - gDestSwapped; return TRUE; } VOID AdjustTargetTab() { int i; GetSettings(); //if user change swap option in source tab, we'd better reset dest. if (SendDlgItemMessage(hWndTab[0], IDC_SWAPHIGHLOW, BM_GETCHECK, 0,0) != gSourceSwapped) SendMessage(hWndTab[1], WM_COMMAND, IDC_CLEAR,0); //Do we have a source yet? if(IsWindowEnabled(GetDlgItem(hWndTab[0], IDC_VIEW))){ for (i=0;i<NumCodePage;i++){ EnableControl(hWndTab[1], i+CODEPAGEBASE, TRUE); SendDlgItemMessage (hWndTab[1],i+CODEPAGEBASE, BM_SETCHECK, 0, 0); } if (gTCSCMapStatus==DONOTMAP && gFWHWMapStatus==DONOTMAP) EnableControl(hWndTab[1], gTypeSourceID+CODEPAGEBASE,FALSE); SendDlgItemMessage (hWndTab[1],gTypeDestID+CODEPAGEBASE, BM_SETCHECK, 1, 0); } } BOOL EnableControl( IN HWND hWnd, IN int ControlId, IN BOOL Enable ) /*++ Routine Description: Enable or diable the specified control based on the supplied flag. Arguments: hWnd - Supplies the window (dialog box) handle that contains the control. ControlId - Supplies the control id. Enable - Supplies a flag which if TRUE causes the control to be enabled and disables the control if FALSE. Return Value: BOOL - Returns TRUE if the control is succesfully enabled / disabled. --*/ { HWND hWndControl; BOOL Success; hWndControl = GetDlgItem( hWnd, ControlId ); if( hWndControl == NULL ) { return FALSE; } if( Enable == IsWindowEnabled( hWndControl )) { return TRUE; } Success = EnableWindow( hWndControl, Enable ); return TRUE; }