WindowsXP-SP1/windows/feime/chnuconv/chnuconv.c

1079 lines
32 KiB
C
Raw Normal View History

2001-01-01 00:00:00 +01:00
/**************************************************************************\
* 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;
}