mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1078 lines
31 KiB
1078 lines
31 KiB
/**************************************************************************\
|
|
* chsuconv.c -- convert to/from unicode using
|
|
* MulitByteToWideChar & WideCharToMulitByte
|
|
*
|
|
* Steve Firebaugh
|
|
* Microsoft Developer Support
|
|
* Copyright (C) 1992-1999 Microsoft Inc.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
#include "chnuconv.h"
|
|
#include "resource.h"
|
|
|
|
|
|
/**************************************************************************\
|
|
* Global Data Items
|
|
\**************************************************************************/
|
|
|
|
/* Global variables storing the source and destination "type" information.
|
|
*
|
|
* used to communicate between main wnd proc, and *OptionsProc.
|
|
*
|
|
* gTypeSource - stores the type interpretation of the source data
|
|
* (and implicitly the destination data.)
|
|
* TYPEUNKNOWN: indeterminant... not set. Can not do conversion.
|
|
* TYPEUNICODE: source unicode & destination giDestinationCodePage.
|
|
* TYPECODEPAGE: source giSourceCodePage & destination unicode.
|
|
*
|
|
* giSourceCodePage stores valid source code page iff gTypeSource == TRUE
|
|
* giDestinationCodePage stores valid destination code page iff gTypeSource == FALSE
|
|
*
|
|
*/
|
|
int gTypeSource;
|
|
int gTypeSourceID;
|
|
UINT giSourceCodePage;
|
|
int gTypeDest;
|
|
int gTypeDestID;
|
|
UINT giDestinationCodePage;
|
|
int giRBInit;
|
|
TCHAR szDataOptionsDlg[40];
|
|
|
|
/* Pointers to the source and destination data, and the
|
|
* count of bytes in each of the buffers.
|
|
*/
|
|
PBYTE pSourceData = NULL;
|
|
PBYTE pDestinationData = NULL;
|
|
PBYTE pTempData1 = NULL;
|
|
int nBytesSource = NODATA;
|
|
int nBytesDestination = NODATA;
|
|
PBYTE pTempData = NULL;
|
|
PBYTE pViewSourceData = NULL;
|
|
int nBytesTemp = NODATA;
|
|
|
|
BOOL gSourceSwapped=FALSE;
|
|
BOOL gDestSwapped=FALSE;
|
|
|
|
/* Conversion Options variables. */
|
|
DWORD gMBFlags = MB_PRECOMPOSED;
|
|
DWORD gWCFlags = 0;
|
|
char glpDefaultChar[4] = "?"; // what is max size of multibyte character?
|
|
BOOL gUsedDefaultChar = FALSE;
|
|
|
|
DWORD gTCSCMapStatus = DONOTMAP; //simplified and traditional Chinese mapping
|
|
DWORD gFWHWMapStatus = DONOTMAP; //full width and half width mapping
|
|
/* Handling the Byte Order Mark (BOM).
|
|
*
|
|
* If the input file begins with a BOM, then we know it is unicode,
|
|
* we skip over the BOM and decrement the size of data by SIZEOFBOM.
|
|
*
|
|
*
|
|
* Before writing data that we know is unicode, write the szBOM string
|
|
* to the file.
|
|
*
|
|
* Notice that this means that the file sizes we show in the window
|
|
* do NOT include the BOM.
|
|
*/
|
|
|
|
char szBOM[] = "\377\376"; // 0xFF, 0xFE // leave off TEXT() macro.
|
|
char szRBOM[] = "\376\377"; // 0xFF, 0xFE // leave off TEXT() macro.
|
|
|
|
UINT MBFlags = MB_OK | MB_ICONEXCLAMATION;
|
|
TCHAR MBTitle[40];
|
|
TCHAR MBMessage[EXTENSION_LENGTH];
|
|
TCHAR szBlank[] = TEXT("");
|
|
TCHAR szNBytes[40];
|
|
TCHAR szFilter[MAX_PATH];
|
|
TCHAR szHelpPathName[] = TEXT("chnuconv.chm");
|
|
DLGTEMPLATE * dlgtSourceTab;
|
|
DLGTEMPLATE * dlgtOptionTab;
|
|
|
|
|
|
|
|
HGLOBAL hglbMem;
|
|
PBYTE p;
|
|
int NumCodePage;
|
|
UINT uCodepage[]={ 0,//UNICODE
|
|
936, //GB
|
|
950,//BIG5
|
|
20000,//CNS
|
|
20001,//TCA
|
|
20002,//ETEN
|
|
20003,//IBM5
|
|
20004,//TELE
|
|
20005//WANG
|
|
};
|
|
|
|
|
|
//
|
|
// Module handle.
|
|
//
|
|
|
|
HANDLE _hModule;
|
|
|
|
//
|
|
// Application's icon handle.
|
|
//
|
|
|
|
HANDLE _hIcon;
|
|
|
|
|
|
//
|
|
// Main window handle.
|
|
//
|
|
|
|
HANDLE _hWndMain;
|
|
HANDLE hMainTabControl;
|
|
HANDLE hWndDisplay;
|
|
HANDLE hWndTab[NUMBER_OF_PAGES];
|
|
|
|
//
|
|
// Application's accelerator table handle.
|
|
//
|
|
|
|
HANDLE _hAccel;
|
|
|
|
BOOL InitializeApplication( HINSTANCE hInstance, HINSTANCE hPrevInstance);
|
|
BOOL MakeTabs( IN HWND hWnd, IN HWND hMainTabControl );
|
|
VOID AdjustSelectTab ( IN HWND hWnd, IN HWND hMainTabControl );
|
|
LRESULT APIENTRY MainWndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam );
|
|
VOID CreateFilter(PTCHAR);
|
|
|
|
|
|
|
|
|
|
|
|
int APIENTRY
|
|
WinMain(
|
|
HINSTANCE hInstance,
|
|
HINSTANCE hPrevInstance,
|
|
LPSTR lpCmdLine,
|
|
int nCmdShow)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Main is the entry point for Code Converter. It initializes the application
|
|
and manages the message pump. When the message pump quits, main performs
|
|
some global cleanup.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
int - Returns the result of the PostQuitMessgae API or -1 if
|
|
initialization failed.
|
|
|
|
--*/
|
|
|
|
{
|
|
MSG msg;
|
|
BOOL bHandled=FALSE;
|
|
|
|
UNREFERENCED_PARAMETER( lpCmdLine );
|
|
UNREFERENCED_PARAMETER( nCmdShow );
|
|
|
|
|
|
if( InitializeApplication(hInstance, hPrevInstance)) {
|
|
|
|
while( GetMessage( &msg, NULL, 0, 0 )) {
|
|
|
|
bHandled = TranslateAccelerator( _hWndMain, _hAccel, &msg );
|
|
|
|
if (bHandled==FALSE)
|
|
{
|
|
bHandled = TranslateAccelerator(hWndDisplay, _hAccel, &msg);
|
|
if (bHandled == FALSE && IsDialogMessage(_hWndMain, &msg)==FALSE)
|
|
{
|
|
TranslateMessage(&msg); // Translates virtual key codes
|
|
|
|
DispatchMessage(&msg); // Dispatches message to window
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return (int)msg.wParam;
|
|
}
|
|
|
|
//
|
|
// Initialization failed.
|
|
//
|
|
return -1;
|
|
}
|
|
|
|
|
|
BOOL
|
|
InitializeApplication(
|
|
HINSTANCE hInstance,
|
|
HINSTANCE hPrevInstance
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
InitializeApplication does just what its name implies. It initializes
|
|
global varaibles, sets up global state (e.g. 3D-Controls), registers window
|
|
classes and creates and shows the application's main window.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
BOOL - Returns TRUE if the application succesfully initialized.
|
|
|
|
--*/
|
|
|
|
{
|
|
WNDCLASS Wc;
|
|
TCHAR szBuffer[MAX_PATH];
|
|
TCHAR szBuf[400];
|
|
int i;
|
|
//
|
|
// Get the application's module (instance) handle.
|
|
//
|
|
|
|
InitCommonControls();
|
|
|
|
//_hModule = hInstance;
|
|
_hModule = GetModuleHandle( NULL );
|
|
if( _hModule == NULL ) {
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Load the application's main icon resource.
|
|
//
|
|
|
|
_hIcon = LoadIcon( _hModule, MAKEINTRESOURCE( IDI_CHNUCONV ));
|
|
if( _hIcon == NULL ) {
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Load the application's accelerator table.
|
|
//
|
|
|
|
_hAccel = LoadAccelerators( _hModule, MAKEINTRESOURCE( IDA_CHNUCONV ));
|
|
if( _hAccel == NULL ) {
|
|
return FALSE;
|
|
}
|
|
//
|
|
// Register the window class for the application.
|
|
//
|
|
if (!hPrevInstance){
|
|
Wc.style = CS_HREDRAW
|
|
| CS_OWNDC
|
|
| CS_SAVEBITS
|
|
| CS_VREDRAW;
|
|
Wc.lpfnWndProc = MainWndProc;
|
|
Wc.cbClsExtra = 0;
|
|
Wc.cbWndExtra = DLGWINDOWEXTRA;
|
|
Wc.hInstance = _hModule;
|
|
Wc.hIcon = _hIcon;
|
|
Wc.hCursor = LoadCursor( NULL, IDC_ARROW );
|
|
Wc.hbrBackground = ( HBRUSH ) ( COLOR_BTNFACE + 1 );
|
|
Wc.lpszMenuName = NULL;
|
|
Wc.lpszClassName = L"Converter";
|
|
|
|
if (!RegisterClass( &Wc ))
|
|
return FALSE;
|
|
}
|
|
|
|
for(i=0;i<NumCodePage;i++)
|
|
LoadString(_hModule,IDS_STRUNICODE+i,gszCodePage[i], EXTENSION_LENGTH);
|
|
|
|
// For different locale we will have different default initial code page
|
|
// and differnt source and dest. dialog box.
|
|
|
|
switch(GetACP())
|
|
{
|
|
case 936:
|
|
giRBInit=IDC_RBGB;
|
|
NumCodePage=3;
|
|
break;
|
|
case 950:
|
|
giRBInit=IDC_RBBIG5;
|
|
NumCodePage=9;
|
|
break;
|
|
default:
|
|
giRBInit=IDC_RBBIG5;
|
|
NumCodePage=9;
|
|
}
|
|
|
|
|
|
dlgtSourceTab=DoLockDlgRes(MAKEINTRESOURCE(IDD_SOURCE_TAB));
|
|
dlgtOptionTab=DoLockDlgRes(MAKEINTRESOURCE(IDD_OPTION_TAB));
|
|
|
|
//
|
|
// Create the main window.
|
|
//
|
|
|
|
|
|
|
|
_hWndMain = CreateDialog ( _hModule,
|
|
MAKEINTRESOURCE( IDD_CHNUCONV ),
|
|
NULL,
|
|
(DLGPROC) MainWndProc,
|
|
);
|
|
|
|
if( _hWndMain == NULL ) {
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Set the window title.
|
|
//
|
|
|
|
LoadString(_hModule, IDS_APPLICATION_NAME, szBuffer, EXTENSION_LENGTH);
|
|
lstrcpy(MBTitle, szBuffer);
|
|
LoadString(_hModule, IDS_NBYTES,szNBytes, EXTENSION_LENGTH);
|
|
CreateFilter(szFilter);
|
|
|
|
SetWindowText(_hWndMain, szBuffer);
|
|
ShowWindow( _hWndMain, SW_SHOW );
|
|
|
|
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
LRESULT
|
|
MainWndProc(
|
|
HWND hWnd,
|
|
UINT message,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
TCHAR szBuffer[MAX_PATH];
|
|
|
|
switch( message ) {
|
|
case WM_PAINT:
|
|
{
|
|
PAINTSTRUCT ps;
|
|
RECT rc;
|
|
|
|
//
|
|
// Don't waste our time if we're minimized
|
|
//
|
|
|
|
if (FALSE == IsIconic(hWnd))
|
|
{
|
|
BeginPaint(hWnd, &ps);
|
|
GetClientRect(hWnd, &rc);
|
|
|
|
//
|
|
// Draw an edge just below menu bar
|
|
//
|
|
|
|
DrawEdge(ps.hdc, &rc, EDGE_ETCHED, BF_TOP);
|
|
EndPaint(hWnd, &ps);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
case WM_CREATE:
|
|
{
|
|
int ScreenHeight;
|
|
int ScreenWidth;
|
|
//
|
|
// Display the main window in the center of the screen.
|
|
//
|
|
|
|
ScreenWidth = GetSystemMetrics( SM_CXSCREEN );
|
|
ScreenHeight = GetSystemMetrics( SM_CYSCREEN );
|
|
|
|
if(SetWindowPos(
|
|
hWnd,
|
|
NULL,
|
|
( ScreenWidth - (( LPCREATESTRUCT ) lParam )->cx )/2,
|
|
( ScreenHeight - (( LPCREATESTRUCT ) lParam )->cy )/2,
|
|
0,
|
|
0,
|
|
SWP_NOSIZE
|
|
| SWP_NOREDRAW
|
|
| SWP_NOZORDER
|
|
))
|
|
|
|
return 0;
|
|
}
|
|
|
|
case WM_INITDIALOG:
|
|
{
|
|
//
|
|
// Get the handle of the tab control
|
|
//
|
|
hMainTabControl = GetDlgItem( hWnd, IDC_MAIN_TAB );
|
|
|
|
//
|
|
// Fill out tab control with appropriate tabs
|
|
//
|
|
MakeTabs( hWnd, hMainTabControl );
|
|
|
|
|
|
hWndTab[0] = CreateDialogIndirect(
|
|
_hModule,
|
|
dlgtSourceTab,
|
|
hWnd,
|
|
SourceTabProc
|
|
);
|
|
|
|
hWndTab[1]= CreateDialogIndirect(
|
|
_hModule,
|
|
dlgtSourceTab,
|
|
hWnd,
|
|
TargetTabProc
|
|
);
|
|
|
|
hWndTab[2] = CreateDialogIndirect(
|
|
_hModule,
|
|
dlgtOptionTab,
|
|
hWnd,
|
|
OptionTabProc
|
|
);
|
|
|
|
hWndDisplay=hWndTab[0];
|
|
ShowWindow(hWndDisplay, SW_SHOW);
|
|
return( TRUE );
|
|
}
|
|
case WM_COMMAND:
|
|
{
|
|
switch (LOWORD(wParam)) {
|
|
/******************************************************************\
|
|
* WM_COMMAND, IDC_PUSH_CONVERT
|
|
*
|
|
* This is where the conversion actually takes place.
|
|
* In either case, make the call twice. Once to determine how
|
|
* much memory is needed, allocate space, and then make the call again.
|
|
*
|
|
* If conversion succeeds, it fills pDestinationData.
|
|
\******************************************************************/
|
|
case IDC_PUSH_CONVERT: {
|
|
int nBytesNeeded, nWCharNeeded, nWCharSource;
|
|
TCHAR szSourceName[256];
|
|
int ConfirmMap;
|
|
int i;
|
|
|
|
GetSettings();
|
|
|
|
SwapSource(FALSE);
|
|
|
|
if (nBytesSource == NODATA ) {
|
|
LoadString(_hModule,IDS_NOTEXTCONVERT,MBMessage,EXTENSION_LENGTH);
|
|
MessageBox (hWnd, MBMessage,MBTitle, MBFlags);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* Converting UNICODE -> giDestinationCodePage*/
|
|
if (gTypeSource == TYPEUNICODE) {
|
|
|
|
nWCharSource = nBytesSource/2;
|
|
|
|
/* Allocate the required amount of space, including trailing NULL */
|
|
pTempData1= ManageMemory (MMALLOC, MMDESTINATION,
|
|
nBytesSource, pTempData1);
|
|
|
|
// Map string if we need to do TC-SC conversion.
|
|
if (gTCSCMapStatus != DONOTMAP){
|
|
LCMapString (GetUserDefaultLCID(),gTCSCMapStatus,
|
|
(LPWSTR)pSourceData,nWCharSource,
|
|
(LPWSTR)pTempData1,nWCharSource);
|
|
}else{
|
|
// no conversion, just copy things over.
|
|
memcpy(pTempData1,pSourceData,nBytesSource);
|
|
}
|
|
|
|
// Map string if we need to do FW-HW conversion.
|
|
if (gFWHWMapStatus != DONOTMAP){
|
|
pTempData= ManageMemory (MMALLOC, MMDESTINATION,
|
|
nBytesSource, pTempData);
|
|
|
|
LCMapString (GetUserDefaultLCID(),gFWHWMapStatus,
|
|
(LPWSTR)pTempData1,nWCharSource,
|
|
(LPWSTR)pTempData,nWCharSource);
|
|
|
|
memcpy(pTempData1,pTempData,nBytesSource);
|
|
}
|
|
|
|
/*TS/SC mapping could happen between Unicode */
|
|
if (gTypeDest == TYPEUNICODE){
|
|
pDestinationData= ManageMemory (MMALLOC, MMDESTINATION,
|
|
nBytesSource+2, pDestinationData);
|
|
//put mapped unicode buffer to destination buffer.
|
|
memcpy(pDestinationData,pTempData1,nBytesSource);
|
|
nBytesDestination=nBytesSource;
|
|
|
|
/* Unicode Null terminate string. */
|
|
pDestinationData[nBytesDestination] = 0;
|
|
pDestinationData[nBytesDestination+1] = 0;
|
|
|
|
}else{
|
|
giDestinationCodePage=uCodepage[gTypeDestID];
|
|
|
|
/*Query the number of bytes required to store the Dest string */
|
|
nBytesNeeded = WideCharToMultiByte(giDestinationCodePage,
|
|
gWCFlags, (LPWSTR)pTempData1, nWCharSource,
|
|
NULL, 0,
|
|
glpDefaultChar, &gUsedDefaultChar);
|
|
pDestinationData= ManageMemory (MMALLOC, MMDESTINATION,
|
|
nBytesNeeded +1, pDestinationData);
|
|
/* Do the conversion */
|
|
nBytesDestination = WideCharToMultiByte(giDestinationCodePage,
|
|
gWCFlags, (LPWSTR)pTempData1, nWCharSource,
|
|
(LPSTR)pDestinationData, nBytesNeeded,
|
|
glpDefaultChar, &gUsedDefaultChar);
|
|
/* Null terminate string. */
|
|
pDestinationData[nBytesDestination] = 0;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/* converting giSourceCodePage -> UNICODE */
|
|
else if (gTypeSource == TYPECODEPAGE && gTypeDest == TYPEUNICODE) {
|
|
|
|
giSourceCodePage=uCodepage[gTypeSourceID];
|
|
|
|
/* Query the number of WChar required to store the Dest string */
|
|
nWCharNeeded = MultiByteToWideChar(giSourceCodePage, gMBFlags,
|
|
pSourceData, nBytesSource, NULL, 0 );
|
|
|
|
/* Allocate the required amount of space, including trailing NULL */
|
|
pDestinationData= ManageMemory (MMALLOC, MMDESTINATION, (nWCharNeeded +1)*2, pDestinationData);
|
|
|
|
/* Do the conversion */
|
|
nWCharNeeded = MultiByteToWideChar(giSourceCodePage, gMBFlags,
|
|
pSourceData, nBytesSource,
|
|
(LPWSTR)pDestinationData, nWCharNeeded);
|
|
|
|
/* MultiByteToWideChar returns # WCHAR, so multiply by 2 */
|
|
nBytesDestination = 2*nWCharNeeded ;
|
|
|
|
// Decide if we need to do TC-SC conversion.
|
|
if (gTCSCMapStatus != DONOTMAP) {
|
|
pTempData1= ManageMemory (MMALLOC, MMDESTINATION, nBytesDestination, pTempData1);
|
|
LCMapString (GetUserDefaultLCID(),gTCSCMapStatus,
|
|
(LPWSTR)pDestinationData,nWCharNeeded,
|
|
(LPWSTR)pTempData1,nWCharNeeded);
|
|
memcpy(pDestinationData,pTempData1,nBytesDestination);
|
|
}
|
|
|
|
if (gFWHWMapStatus != DONOTMAP) {
|
|
pTempData1= ManageMemory (MMALLOC, MMDESTINATION, nBytesDestination, pTempData1);
|
|
LCMapString (GetUserDefaultLCID(),gFWHWMapStatus,
|
|
(LPWSTR)pDestinationData,nWCharNeeded,
|
|
(LPWSTR)pTempData1,nWCharNeeded);
|
|
memcpy(pDestinationData,pTempData1,nBytesDestination);
|
|
}
|
|
/* Null terminate string. */
|
|
pDestinationData[nBytesDestination] = 0; // UNICODE_NULL
|
|
pDestinationData[nBytesDestination+1] = 0;
|
|
|
|
|
|
|
|
/* converting giSourceCodePage -> giDestinationCodePage */
|
|
} else if(gTypeSourceID < NumCodePage && gTypeDestID < NumCodePage){
|
|
|
|
giSourceCodePage=uCodepage[gTypeSourceID];
|
|
/* Query the number of WChar required to store the Dest string */
|
|
nWCharNeeded = MultiByteToWideChar(giSourceCodePage, gMBFlags,
|
|
pSourceData, nBytesSource, NULL, 0 );
|
|
/* Allocate the required amount of space, including trailing NULL */
|
|
pTempData= ManageMemory (MMALLOC, MMDESTINATION, (nWCharNeeded +1)*2, pTempData);
|
|
/* Do the conversion */
|
|
nWCharNeeded = MultiByteToWideChar(giSourceCodePage, gMBFlags,
|
|
pSourceData, nBytesSource,
|
|
(LPWSTR)pTempData, nWCharNeeded);
|
|
/* MultiByteToWideChar returns # WCHAR, so multiply by 2 */
|
|
nBytesTemp = 2*nWCharNeeded ;
|
|
|
|
// Decide if we need to do TC-SC conversion.
|
|
if (gTCSCMapStatus != DONOTMAP) {
|
|
pTempData1= ManageMemory (MMALLOC, MMDESTINATION, nBytesTemp, pTempData1);
|
|
LCMapString (GetUserDefaultLCID(),gTCSCMapStatus,
|
|
(LPWSTR)pTempData,nWCharNeeded,
|
|
(LPWSTR)pTempData1,nWCharNeeded);
|
|
memcpy(pTempData,pTempData1,nBytesTemp);
|
|
}
|
|
|
|
if (gFWHWMapStatus != DONOTMAP) {
|
|
pTempData1= ManageMemory (MMALLOC, MMDESTINATION, nBytesTemp, pTempData1);
|
|
LCMapString (GetUserDefaultLCID(),gFWHWMapStatus,
|
|
(LPWSTR)pTempData,nWCharNeeded,
|
|
(LPWSTR)pTempData1,nWCharNeeded);
|
|
memcpy(pTempData,pTempData1,nBytesTemp);
|
|
}
|
|
|
|
/* Null terminate string. */
|
|
pTempData[nBytesTemp] = 0; // UNICODE_NULL
|
|
pTempData[nBytesTemp+1] = 0;
|
|
|
|
giDestinationCodePage=uCodepage[gTypeDestID];
|
|
nWCharSource = nBytesTemp/2;
|
|
|
|
|
|
/* Query the number of bytes required to store the Dest string */
|
|
nBytesNeeded = WideCharToMultiByte(giDestinationCodePage, gWCFlags,
|
|
(LPWSTR)pTempData, nWCharSource,
|
|
NULL, 0,
|
|
glpDefaultChar, &gUsedDefaultChar);
|
|
|
|
/* Allocate the required amount of space, including trailing NULL */
|
|
pDestinationData= ManageMemory (MMALLOC, MMDESTINATION, nBytesNeeded +1, pDestinationData);
|
|
|
|
/* Do the conversion */
|
|
nBytesDestination = WideCharToMultiByte(giDestinationCodePage, gWCFlags,
|
|
(LPWSTR)pTempData, nWCharSource,
|
|
pDestinationData, nBytesNeeded, glpDefaultChar, &gUsedDefaultChar);
|
|
|
|
/* Null terminate string. */
|
|
pDestinationData[nBytesDestination] = 0;
|
|
|
|
} else {
|
|
LoadString(_hModule,IDS_STYPEUNKNOWN,MBMessage,EXTENSION_LENGTH);
|
|
MessageBox (hWnd, MBMessage,MBTitle, MBFlags);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* code common to all conversions... */
|
|
LoadString(_hModule, IDS_NOTSAVEYET, szBuffer, 50);
|
|
|
|
|
|
TabCtrl_SetCurSel(hMainTabControl, 1);
|
|
AdjustSelectTab(hWnd, hMainTabControl);
|
|
|
|
SetDlgItemText (hWndTab[1], IDC_NAMETEXT, szBuffer);
|
|
|
|
wsprintf (szBuffer, szNBytes, nBytesDestination);
|
|
SetDlgItemText (hWndTab[1], IDC_SIZETEXT, szBuffer);
|
|
EnableControl(hWndTab[1], IDC_OPENORSAVEAS, TRUE);
|
|
EnableControl(hWndTab[1], IDC_VIEW, TRUE);
|
|
EnableControl(hWndTab[1], IDC_PASTEORCOPY, TRUE);
|
|
EnableControl(hWndTab[1], IDC_CLEAR, TRUE);
|
|
EnableControl(hWndTab[1], IDC_SWAPHIGHLOW, TRUE);
|
|
EnableMenuItem (GetMenu (_hWndMain),IDM_FILE_SAVEAS,MF_ENABLED);
|
|
|
|
|
|
break; // end case IDC_PUSH_CONVERT
|
|
}
|
|
case IDM_HELP_CONTENT:
|
|
case IDC_PUSH_HELP:
|
|
{
|
|
HtmlHelp(hWnd,szHelpPathName, HH_DISPLAY_TOPIC, (DWORD_PTR) NULL );
|
|
break;
|
|
}
|
|
case IDM_HELP_ABOUT:
|
|
{
|
|
LoadString(_hModule, IDS_APPLICATION_NAME,szBuffer,
|
|
EXTENSION_LENGTH);
|
|
ShellAbout (hWnd, szBuffer, TEXT(""), _hIcon );
|
|
break;
|
|
}
|
|
break;
|
|
case IDM_FILE_OPEN:
|
|
{
|
|
SendMessage(hWndTab[0], WM_COMMAND, IDC_OPENORSAVEAS,0);
|
|
break;
|
|
}
|
|
|
|
case IDM_FILE_SAVEAS:
|
|
{
|
|
SendMessage(hWndTab[1], WM_COMMAND, IDC_OPENORSAVEAS,0);
|
|
break;
|
|
}
|
|
|
|
case IDM_FILE_EXIT:
|
|
case IDOK:
|
|
PostMessage(hWnd, WM_CLOSE, 0, 0L);
|
|
break;
|
|
default:
|
|
return FALSE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case WM_NOTIFY:
|
|
{
|
|
static
|
|
int nPreviousTab = 1;
|
|
|
|
// switch on notification code
|
|
|
|
switch ( ((LPNMHDR)lParam)->code ) {
|
|
|
|
case TCN_SELCHANGE:
|
|
{
|
|
|
|
AdjustSelectTab(hWnd, hMainTabControl);
|
|
return(TRUE);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case WM_CLOSE:
|
|
{
|
|
DestroyWindow( hWnd );
|
|
break;
|
|
}
|
|
case WM_DESTROY:
|
|
{
|
|
// WinHelp( hwnd, szHelpPathName, (UINT) HELP_QUIT, (DWORD) NULL );
|
|
ManageMemory (MMFREE, MMDESTINATION, 0, pTempData1);
|
|
ManageMemory (MMFREE, MMSOURCE, 0, pSourceData);
|
|
ManageMemory (MMFREE, MMDESTINATION, 0, pDestinationData);
|
|
ManageMemory (MMFREE, MMSOURCE, 0, pViewSourceData);
|
|
ManageMemory (MMFREE, MMDESTINATION, 0, pTempData);
|
|
GlobalUnlock(hglbMem);
|
|
GlobalFree(hglbMem);
|
|
|
|
|
|
//
|
|
// Destroy the application.
|
|
//
|
|
PostQuitMessage(0);
|
|
return 0;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return DefWindowProc( hWnd, message, wParam, lParam );
|
|
}
|
|
|
|
|
|
INT_PTR
|
|
OptionTabProc(
|
|
HWND hWnd,
|
|
UINT message,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
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 );
|
|
|
|
SendDlgItemMessage(hWnd, IDC_NOSCTCMAP, BM_SETCHECK, 1, 0);
|
|
SendDlgItemMessage(hWnd, IDC_NOHWFWMAP, BM_SETCHECK, 1, 0);
|
|
|
|
return(FALSE);
|
|
}
|
|
case WM_COMMAND:
|
|
{
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDC_RESET :
|
|
{
|
|
SendDlgItemMessage(hWnd, IDC_NOSCTCMAP, BM_SETCHECK, 1, 0);
|
|
SendDlgItemMessage(hWnd, IDC_SCTCMAP, BM_SETCHECK, 0, 0);
|
|
SendDlgItemMessage(hWnd, IDC_TCSCMAP, BM_SETCHECK, 0, 0);
|
|
SendDlgItemMessage(hWnd, IDC_NOHWFWMAP, BM_SETCHECK, 1, 0);
|
|
SendDlgItemMessage(hWnd, IDC_HWFWMAP, BM_SETCHECK, 0, 0);
|
|
SendDlgItemMessage(hWnd, IDC_FWHWMAP, BM_SETCHECK, 0, 0);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return DefWindowProc( hWnd, message, wParam, lParam );
|
|
}
|
|
VOID
|
|
GetSettings()
|
|
{
|
|
int i;
|
|
gTypeSource = TYPEUNKNOWN;
|
|
|
|
//Get source settings.
|
|
for(i=0;i<NumCodePage;i++)
|
|
if (SendDlgItemMessage(hWndTab[0],IDC_RBUNICODE1+i,
|
|
BM_GETCHECK, 0,0))
|
|
{
|
|
gTypeSourceID = IDC_RBUNICODE1+i-CODEPAGEBASE;
|
|
if(i==0)
|
|
gTypeSource = TYPEUNICODE;
|
|
else
|
|
gTypeSource = TYPECODEPAGE;
|
|
break;
|
|
}
|
|
|
|
//Get target settings.
|
|
for(i=0;i<NumCodePage;i++)
|
|
if (SendDlgItemMessage(hWndTab[1],IDC_RBUNICODE1+i,
|
|
BM_GETCHECK, 0,0))
|
|
{
|
|
gTypeDestID = IDC_RBUNICODE1+i-CODEPAGEBASE;
|
|
if(i==0)
|
|
gTypeDest = TYPEUNICODE;
|
|
else
|
|
gTypeDest = TYPECODEPAGE;
|
|
break;
|
|
}
|
|
|
|
|
|
//Get Option settings,
|
|
for (i=0; i<= 2; i++)
|
|
if (SendDlgItemMessage(hWndTab[2],IDC_NOSCTCMAP+i,
|
|
BM_GETCHECK, 0,0))
|
|
{
|
|
switch (i) {
|
|
case 1:
|
|
gTCSCMapStatus = LCMAP_SIMPLIFIED_CHINESE;
|
|
break;
|
|
case 2:
|
|
gTCSCMapStatus = LCMAP_TRADITIONAL_CHINESE;
|
|
break;
|
|
default:
|
|
gTCSCMapStatus = DONOTMAP;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
for (i=0; i<= 2; i++)
|
|
if (SendDlgItemMessage(hWndTab[2],IDC_NOHWFWMAP+i,
|
|
BM_GETCHECK, 0,0))
|
|
{
|
|
switch (i) {
|
|
case 1:
|
|
gFWHWMapStatus = LCMAP_FULLWIDTH;
|
|
break;
|
|
case 2:
|
|
gFWHWMapStatus = LCMAP_HALFWIDTH;
|
|
break;
|
|
default:
|
|
gFWHWMapStatus = DONOTMAP;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(gTypeSourceID==gTypeDestID &&
|
|
gTCSCMapStatus==DONOTMAP &&
|
|
gFWHWMapStatus==DONOTMAP)
|
|
|
|
if(gTypeSource == TYPEUNICODE){
|
|
gTypeDest = TYPECODEPAGE;
|
|
gTypeDestID = giRBInit-CODEPAGEBASE;
|
|
}else{
|
|
gTypeDest = TYPEUNICODE;
|
|
gTypeDestID = IDC_RBUNICODE1-CODEPAGEBASE;
|
|
}
|
|
}
|
|
VOID
|
|
AdjustSelectTab(
|
|
HWND hWnd,
|
|
HWND hMainTabControl
|
|
)
|
|
{
|
|
TC_ITEM tci;
|
|
int iSel;
|
|
|
|
|
|
iSel = TabCtrl_GetCurSel( hMainTabControl );
|
|
|
|
//
|
|
//get the proper index to the appropriate procs
|
|
//that were set in MakeTabs
|
|
//
|
|
tci.mask = TCIF_PARAM;
|
|
TabCtrl_GetItem(hMainTabControl, iSel, &tci);
|
|
|
|
// Create the new child dialog box.
|
|
ShowWindow(hWndDisplay, SW_HIDE);
|
|
ShowWindow(hWndTab[iSel], SW_SHOW);
|
|
if (iSel==1)
|
|
AdjustTargetTab();
|
|
hWndDisplay=hWndTab[iSel];
|
|
}
|
|
|
|
BOOL
|
|
MakeTabs(
|
|
HWND hWnd,
|
|
HWND hMainTabControl
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
MakeTabs fills out the Main Tab Control with appropriate tabs
|
|
|
|
Arguments:
|
|
|
|
HWND hWnd - handle of main window
|
|
HWND hMainTabControl - handle to the tab control
|
|
|
|
Return Value:
|
|
|
|
BOOL - Returns TRUE if successful.
|
|
|
|
--*/
|
|
{
|
|
TC_ITEM tci;
|
|
TCHAR pszTabText[30];
|
|
int i;
|
|
|
|
|
|
tci.mask = TCIF_TEXT | TCIF_PARAM;
|
|
tci.pszText = pszTabText;
|
|
tci.cchTextMax = sizeof( pszTabText );
|
|
for (i = 0; i < NUMBER_OF_PAGES; i++) {
|
|
|
|
// Get the Tab title, the current index + the strind ID
|
|
LoadString(_hModule, i + IDS_FIRST_TAB, tci.pszText, EXTENSION_LENGTH);
|
|
|
|
// store the index to the procs
|
|
tci.lParam = i;
|
|
|
|
// insert the tab
|
|
TabCtrl_InsertItem( hMainTabControl, i + 1, &tci );
|
|
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
DLGTEMPLATE * WINAPI
|
|
DoLockDlgRes(LPWSTR lpszResName)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
DoLockDlgRes - loads and locks a dialog template resource.
|
|
|
|
Arguments:
|
|
|
|
lpszResName - name of the resource
|
|
|
|
Return Value:
|
|
|
|
Returns a pointer to the locked resource.
|
|
|
|
--*/
|
|
{
|
|
|
|
HRSRC hrsrc = FindResource(NULL, lpszResName, RT_DIALOG);
|
|
HGLOBAL hglb = LoadResource(_hModule, hrsrc);
|
|
return (DLGTEMPLATE *) LockResource(hglb);
|
|
|
|
}
|
|
/**************************************************************************\
|
|
*
|
|
* function: IsUnicode()
|
|
*
|
|
* HACK... eventually use a proper function for IsUnicode
|
|
* Use function from unipad?
|
|
*
|
|
\**************************************************************************/
|
|
BOOL IsUnicode (PBYTE pb)
|
|
{
|
|
return (IsBOM (pb));
|
|
}
|
|
|
|
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* function: IsBOM()
|
|
*
|
|
* true iff pb points to a Byte Order Mark.
|
|
*
|
|
\**************************************************************************/
|
|
BOOL IsBOM (PBYTE pb)
|
|
{
|
|
if ((*pb == 0xFF) & (*(pb+1) == 0xFE)) // BOM
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* function: IsRBOM()
|
|
*
|
|
* true iff pb points to a reversed Byte Order Mark.
|
|
*
|
|
\**************************************************************************/
|
|
BOOL IsRBOM (PBYTE pb)
|
|
{
|
|
if ((*pb == 0xFE) & (*(pb+1) == 0xFF)) // RBOM
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
VOID CreateFilter(PTCHAR szFilterSpec )
|
|
{
|
|
PTCHAR pszFilterSpec;
|
|
|
|
TCHAR szAnsiText[EXTENSION_LENGTH], szAllFiles[EXTENSION_LENGTH];
|
|
/* construct default filter string in the required format for
|
|
* the new FileOpen and FileSaveAs dialogs
|
|
* if you add to this, make sure CCHFILTERMAX is large enough.
|
|
*/
|
|
|
|
LoadString(_hModule, IDS_ANSITEXT, szAnsiText, EXTENSION_LENGTH);
|
|
LoadString(_hModule, IDS_ALLFILES, szAllFiles, EXTENSION_LENGTH);
|
|
// .txt first for compatibility
|
|
pszFilterSpec= szFilterSpec;
|
|
lstrcpy( pszFilterSpec, szAnsiText );
|
|
pszFilterSpec += lstrlen( pszFilterSpec ) + 1;
|
|
|
|
lstrcpy( pszFilterSpec, TEXT("*.txt"));
|
|
pszFilterSpec += lstrlen( pszFilterSpec ) + 1;
|
|
|
|
// and last, all files
|
|
lstrcpy( pszFilterSpec, szAllFiles );
|
|
pszFilterSpec += lstrlen( pszFilterSpec ) + 1;
|
|
|
|
lstrcpy(pszFilterSpec, TEXT("*.*") );
|
|
pszFilterSpec += lstrlen( pszFilterSpec ) + 1;
|
|
|
|
*pszFilterSpec = TEXT('\0');
|
|
|
|
}
|
|
|
|
LPVOID ManageMemory (UINT message, UINT sourcedestination, DWORD nBytes, LPVOID p)
|
|
{
|
|
switch (message) {
|
|
case MMFREE :
|
|
if (p != NULL) GlobalFree (GlobalHandle (p));
|
|
return NULL;
|
|
break;
|
|
|
|
case MMALLOC :
|
|
if (p != NULL) GlobalFree (GlobalHandle (p));
|
|
p = (LPVOID) GlobalAlloc (GPTR, nBytes);
|
|
return p;
|
|
break;
|
|
|
|
} /* end switch (message) */
|
|
return NULL;
|
|
}
|