windows-xp/Source/XPSP1/NT/windows/feime/chnuconv/tgtproc.c

/*************************************************
 *  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;

}