home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / BC_502 / INTLDEMO.PAK / INTLDEMO.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-06  |  25.7 KB  |  846 lines
  1. //----------------------------------------------------------------------------
  2. // ObjectWindows - (C) Copyright 1991, 1996 by Borland International
  3. //   intldemo.cpp
  4. //
  5. //  Program to demonstrate much of the functionality afforded with the
  6. //  setlocale function and the locale libraries. Also demonstrates programming
  7. //  a UI to be language-independent, and allow switching of the language at
  8. //  run-time.
  9. //----------------------------------------------------------------------------
  10. #include <owl\pch.h>
  11. #include <owl\decframe.h>
  12. #include <owl\statusba.h>
  13. #include <owl\dialog.h>
  14. #include <owl\applicat.h>
  15. #include <owl\dc.h>
  16. #include <owl\menu.h>
  17. #include <owl\olefacto.h>
  18. #include <ocf/pch.h>
  19. #include <ocf/ocreg.h>
  20. #include <ocf\automacr.h>
  21. #include <locale.h>
  22. #include <string.h>
  23. #include <stdlib.h>
  24. #include <stdio.h>
  25. #include <ctype.h>
  26. #include <bwcc.h>
  27. #include <cstring.h>
  28.  
  29. #include "intldemo.h"
  30. #include "intldemo.hh"
  31. #include "filelist.h"
  32.  
  33. TLangId TLocaleString::NativeLangId=MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US);
  34.  
  35. // override string's comparison routines
  36. int string::compare(const string& s) const throw()
  37. {
  38.   return strcoll(c_str(), s.c_str());
  39. }
  40.  
  41. // pointer to functions such as isalpha, isalnum etc.
  42. typedef int (*ClassMacro)(int);
  43.  
  44. //
  45. // class TLocaleValueWindow
  46. // ----- ------------------
  47. //
  48. // Popup window displaying the current locale values. Note that the locale or
  49. // language can be changed from the main window while we are being displayed,
  50. // and we will update accordingly.
  51. //
  52. class TLocaleValueWindow : public TFrameWindow
  53. {
  54.   public:
  55.     TLocaleValueWindow(lconv *conv, short charWidth, short charHeight, TModule* resModule,
  56.                TWindow* parent, LPSTR title = 0);
  57.  
  58.     // Called by the parent after the language or locale has been changed to keep
  59.     // us in synch
  60.     void ResetValues(lconv *conv, short charWidth, short charHeight, TModule* resModule);
  61.  
  62.   protected:
  63.     void SetupWindow();
  64.     int Max(int a, int b);
  65.     void EvClose();
  66.     void Paint(TDC&, bool, TRect&);
  67.  
  68.   private:
  69.     TModule* ResourceModule;         // Module containing localized resources
  70.     short CharWidth;                 // Width of a character
  71.     short CharHeight;                // Height of a character
  72.     lconv* Conv;                     // Locale settings struct
  73.  
  74.   DECLARE_RESPONSE_TABLE(TLocaleValueWindow);
  75. };
  76.  
  77. DEFINE_RESPONSE_TABLE1(TLocaleValueWindow, TFrameWindow)
  78.   EV_WM_CLOSE,
  79. END_RESPONSE_TABLE;
  80.  
  81. TLocaleValueWindow::TLocaleValueWindow(lconv *conv, short charWidth, short charHeight, TModule* resModule,
  82.                        TWindow* parent, LPSTR title) : TFrameWindow(parent, title)
  83. {
  84.   Conv = conv;
  85.   CharWidth = charWidth;
  86.   CharHeight = charHeight;
  87.   ResourceModule = resModule;
  88.  
  89.   Attr.H = CharHeight * 22;
  90.   Attr.W = CharWidth * 70;
  91.   Attr.Style = Attr.Style | WS_THICKFRAME | WS_SYSMENU;
  92. }
  93.  
  94. inline int TLocaleValueWindow::Max(int a, int b)
  95. {
  96.   return (a > b) ? a : b;
  97. }
  98.  
  99. void TLocaleValueWindow::EvClose()
  100. {
  101.   // Tell the parent that we're finished.
  102.   Parent -> SendMessage(WM_VALWNDCLOSE, 0, 0);
  103.   TFrameWindow::EvClose();
  104. }
  105.  
  106. void TLocaleValueWindow::SetupWindow()
  107. {
  108.   TFrameWindow::SetupWindow();
  109.  
  110.   char title[100];
  111.   ResourceModule -> LoadString(IDS_LOCALETITLE, title, sizeof(title));
  112.   SetCaption(title);
  113. }
  114.  
  115. void TLocaleValueWindow::ResetValues(lconv *conv, short charWidth, short charHeight,
  116.                                                  TModule* resModule)
  117. {
  118.   Conv = conv;
  119.   CharWidth = charWidth;
  120.   CharHeight = charHeight;
  121.   ResourceModule = resModule;
  122.   char title[100];
  123.   ResourceModule -> LoadString(IDS_LOCALETITLE, title, sizeof(title));
  124.   SetCaption(title);
  125. }
  126.  
  127. void TLocaleValueWindow::Paint(TDC& hdc, bool, TRect&)
  128. {
  129.   char buf[100];
  130.   int maxWidth = 0;
  131.   char yesStr[10], noStr[10], notDefined[20];
  132.  
  133.   hdc.SelectStockObject ( SYSTEM_FIXED_FONT );
  134.   hdc.SetTextColor(TColor(0,0,255));
  135.  
  136.   for (short t = IDS_DECIMALPOINT, i = 1; t <= IDS_N_SIGN_POSN; t++, i++) {
  137.     ResourceModule -> LoadString(t, buf, sizeof(buf));
  138.     hdc.TextOut(CharWidth + 10, CharHeight * i, buf, strlen(buf));
  139.     maxWidth = Max(maxWidth, strlen(buf));
  140.   }
  141.  
  142.   ResourceModule->LoadString(IDS_YES, yesStr, sizeof(yesStr));
  143.   ResourceModule->LoadString(IDS_NO, noStr, sizeof(noStr));
  144.   ResourceModule->LoadString(IDS_NOT_DEFINED, notDefined, sizeof(notDefined));
  145.  
  146.   hdc.SetTextColor(TColor(255,0,0));
  147.   maxWidth *= CharWidth;
  148.   maxWidth += (5 * CharWidth);
  149.   short i = 1;
  150.   hdc.TextOut(maxWidth, CharHeight * i++, Conv->decimal_point, strlen(Conv->decimal_point));
  151.   hdc.TextOut(maxWidth, CharHeight * i++, Conv->thousands_sep, strlen(Conv->thousands_sep));
  152.   sprintf(buf, "%d", *Conv->grouping);
  153.   hdc.TextOut(maxWidth, CharHeight * i++, buf, strlen(buf));
  154.   hdc.TextOut(maxWidth, CharHeight * i++, Conv->int_curr_symbol, strlen(Conv->int_curr_symbol));
  155.   hdc.TextOut(maxWidth, CharHeight * i++, Conv->currency_symbol, strlen(Conv->currency_symbol));
  156.   hdc.TextOut(maxWidth, CharHeight * i++, Conv->mon_decimal_point, strlen(Conv->mon_decimal_point));
  157.   hdc.TextOut(maxWidth, CharHeight * i++, Conv->mon_thousands_sep, strlen(Conv->mon_thousands_sep));
  158.   sprintf(buf, "%d", *Conv->mon_grouping);
  159.   hdc.TextOut(maxWidth, CharHeight * i++, buf, strlen(buf));
  160.   hdc.TextOut(maxWidth, CharHeight * i++, Conv->positive_sign, strlen(Conv->positive_sign));
  161.   hdc.TextOut(maxWidth, CharHeight * i++, Conv->negative_sign, strlen(Conv->negative_sign));
  162.  
  163.   char scratch[20];
  164.   sprintf(buf, "%s", (Conv->int_frac_digits == CHAR_MAX) ? notDefined :
  165.                             itoa(Conv->int_frac_digits, scratch, 10));
  166.   hdc.TextOut(maxWidth, CharHeight * i++, buf, strlen(buf));
  167.   sprintf(buf, "%s", (Conv->frac_digits == CHAR_MAX) ? notDefined :
  168.                             itoa(Conv->frac_digits, scratch, 10));
  169.   hdc.TextOut(maxWidth, CharHeight * i++, buf, strlen(buf));
  170.   sprintf(buf, "%s", (Conv->p_cs_precedes == CHAR_MAX) ? notDefined :
  171.                             (Conv->p_cs_precedes == 1) ? yesStr : noStr);
  172.   hdc.TextOut(maxWidth, CharHeight * i++, buf, strlen(buf));
  173.   sprintf(buf, "%s", (Conv->p_sep_by_space == CHAR_MAX) ? notDefined :
  174.                             (Conv->p_sep_by_space == 1) ? yesStr : noStr);
  175.   hdc.TextOut(maxWidth, CharHeight * i++, buf, strlen(buf));
  176.   sprintf(buf, "%s", (Conv->n_cs_precedes == CHAR_MAX) ? notDefined :
  177.                             (Conv->n_cs_precedes == 1) ? yesStr : noStr);
  178.   hdc.TextOut(maxWidth, CharHeight * i++, buf, strlen(buf));
  179.   sprintf(buf, "%s", (Conv->n_sep_by_space == CHAR_MAX) ? notDefined :
  180.                             (Conv->n_sep_by_space == 1) ? yesStr : noStr);
  181.   hdc.TextOut(maxWidth, CharHeight * i++, buf, strlen(buf));
  182.   sprintf(buf, "%s", (Conv->p_sign_posn == CHAR_MAX) ? notDefined :
  183.                             itoa(Conv->p_sign_posn, scratch, 10));
  184.   hdc.TextOut(maxWidth, CharHeight * i++, buf, strlen(buf));
  185.   sprintf(buf, "%s", (Conv->n_sign_posn == CHAR_MAX) ? notDefined :
  186.                             itoa(Conv->n_sign_posn, scratch, 10));
  187.   hdc.TextOut(maxWidth, CharHeight * i++, buf, strlen(buf));
  188. }
  189.  
  190. //
  191. // class TLocaleWindow
  192. // ----- -------------
  193. //
  194. // Main window, containing a display of all 256 ANSI chars highlighted according
  195. // to the current classification function.
  196. //
  197.  
  198. class TLocaleWindow : public TWindow
  199. {
  200.   public:
  201.     TLocaleWindow(TWindow* parent = 0, const char* title = 0);
  202.  
  203.     enum classifications {alnum = CM_ISALNUM, alpha, ascii, cntrl, digit, graph, lower, print, punct, space, upper, xdigit};
  204.     void ChangeUI(TModule *pResModule);
  205.  
  206.   protected:
  207.     void CmIsAlnum();
  208.     void CmIsAlpha();
  209.     void CmIsAscii();
  210.     void CmIsCntrl();
  211.     void CmIsDigit();
  212.     void CmIsGraph();
  213.     void CmIsLower();
  214.     void CmIsPrint();
  215.     void CmIsPunct();
  216.     void CmIsSpace();
  217.     void CmIsUpper();
  218.     void CmIsXDigit();
  219.  
  220.     void Paint(TDC&, bool, TRect&);
  221.     void SetupWindow();
  222.     void EvMouseMove(uint /*modKeys*/, TPoint &point);
  223.  
  224.     int ChangeClassification(classifications newClassification);
  225.     int TrueColor(TDC& hdc);
  226.     int FalseColor(TDC& hdc);
  227.  
  228.   private:
  229.     classifications Classification;
  230.  
  231.     short CharWidth;
  232.     short CharHeight;
  233.     int CellWidth;
  234.     int CellHeight;
  235.     TPoint BoxTopLeft;
  236.     TPoint BoxBottomRight;
  237.  
  238.     static const ClassMacro ClassificationMacros[];
  239.     static const char* MacroNames[];
  240.     char CharacterString[20];
  241.  
  242.   DECLARE_AUTOCLASS(TLocaleWindow)
  243.     AUTOFUNC0V(IsAlnum, CmIsAlnum, )
  244.     AUTOFUNC0V(IsAlpha, CmIsAlpha, )
  245.     AUTOFUNC0V(IsAscii, CmIsAscii, )
  246.     AUTOFUNC0V(IsCntrl, CmIsCntrl, )
  247.     AUTOFUNC0V(IsDigit, CmIsDigit, )
  248.     AUTOFUNC0V(IsGraph, CmIsGraph, )
  249.     AUTOFUNC0V(IsLower, CmIsLower, )
  250.     AUTOFUNC0V(IsPrint, CmIsPrint, )
  251.     AUTOFUNC0V(IsPunct, CmIsPunct, )
  252.     AUTOFUNC0V(IsSpace, CmIsSpace, )
  253.     AUTOFUNC0V(IsUpper, CmIsUpper, )
  254.     AUTOFUNC0V(IsXDigit, CmIsXDigit, )
  255.  
  256.   DECLARE_RESPONSE_TABLE(TLocaleWindow);
  257. };
  258.  
  259. DEFINE_AUTOCLASS(TLocaleWindow)
  260.   EXPOSE_METHOD(IsAlnum, TAutoVoid, "IsAlnum", "IsAlnum", HC_CLIENT_ISALNUM)
  261.   EXPOSE_METHOD(IsAlpha, TAutoVoid, "IsAlpha", "IsAlpha", HC_CLIENT_ISALPHA)
  262.   EXPOSE_METHOD(IsAscii, TAutoVoid, "IsAscii", "IsAscii", HC_CLIENT_ISASCII)
  263.   EXPOSE_METHOD(IsCntrl, TAutoVoid, "IsCntrl", "IsCntrl", HC_CLIENT_ISCNTRL)
  264.   EXPOSE_METHOD(IsDigit, TAutoVoid, "IsDigit", "IsDigit", HC_CLIENT_ISDIGIT)
  265.   EXPOSE_METHOD(IsGraph, TAutoVoid, "IsGraph", "IsGraph", HC_CLIENT_ISGRAPH)
  266.   EXPOSE_METHOD(IsLower, TAutoVoid, "IsLower", "IsLower", HC_CLIENT_ISLOWER)
  267.   EXPOSE_METHOD(IsPrint, TAutoVoid, "IsPrint", "IsPrint", HC_CLIENT_ISPRINT)
  268.   EXPOSE_METHOD(IsPunct, TAutoVoid, "IsPunct", "IsPunct", HC_CLIENT_ISPUNCT)
  269.   EXPOSE_METHOD(IsSpace, TAutoVoid, "IsSpace", "IsSpace", HC_CLIENT_ISSPACE)
  270.   EXPOSE_METHOD(IsUpper, TAutoVoid, "IsUpper", "IsUpper", HC_CLIENT_ISUPPER)
  271.   EXPOSE_METHOD(IsXDigit, TAutoVoid, "IsXDigit", "IsXDigit", HC_CLIENT_ISXDIGIT)
  272. END_AUTOCLASS(TLocaleWindow, tfNormal, "TLocaleWindow", "@TLocaleWindow_", HC_FRAME_WINDOW);
  273.  
  274. DEFINE_RESPONSE_TABLE1(TLocaleWindow, TWindow)
  275.   EV_WM_MOUSEMOVE,
  276.   EV_COMMAND(CM_ISALNUM, CmIsAlnum),
  277.   EV_COMMAND(CM_ISALPHA, CmIsAlpha),
  278.   EV_COMMAND(CM_ISASCII, CmIsAscii),
  279.   EV_COMMAND(CM_ISCNTRL, CmIsCntrl),
  280.   EV_COMMAND(CM_ISDIGIT, CmIsDigit),
  281.   EV_COMMAND(CM_ISGRAPH, CmIsGraph),
  282.   EV_COMMAND(CM_ISLOWER, CmIsLower),
  283.   EV_COMMAND(CM_ISPRINT, CmIsPrint),
  284.   EV_COMMAND(CM_ISPUNCT, CmIsPunct),
  285.   EV_COMMAND(CM_ISSPACE, CmIsSpace),
  286.   EV_COMMAND(CM_ISUPPER, CmIsUpper),
  287.   EV_COMMAND(CM_ISXDIGIT, CmIsXDigit),
  288. END_RESPONSE_TABLE;
  289.  
  290. TLocaleWindow::TLocaleWindow(TWindow* parent, const char* title)
  291.   : TWindow(parent, title)
  292. {
  293.   Attr.Id = ID_LOCALEWINDOW;
  294.   Classification = alpha;
  295. }
  296.  
  297. const ClassMacro TLocaleWindow::ClassificationMacros[] = 
  298.   { isalnum, isalpha, isascii, iscntrl, isdigit, isgraph,
  299.     islower, isprint, ispunct, isspace, isupper, isxdigit };
  300.  
  301. const char* TLocaleWindow::MacroNames[] =
  302. { "isalnum()", "isalpha()", "isascii()", "iscntrl()",
  303.   "isdigit()", "isgraph()", "islower()", "isprint()", 
  304.   "ispunct()", "isspace()", "isupper()", "isxdigit()" };
  305.  
  306. void TLocaleWindow::SetupWindow()
  307. {
  308.   TWindow::SetupWindow();
  309.   TWindowDC dc(HWindow);
  310.   dc.SelectStockObject(SYSTEM_FIXED_FONT);
  311.   TEXTMETRIC tm;
  312.   dc.GetTextMetrics (tm);
  313.   CharWidth = short(tm.tmAveCharWidth);
  314.   CharHeight = short(tm.tmHeight + tm.tmExternalLeading);
  315.   SetFocus();
  316. }
  317.  
  318. int TLocaleWindow::TrueColor(TDC& hdc)
  319. // Sets colour to display characters for which the classification function
  320. // returns TRUE
  321. {
  322.   hdc.SetTextColor(TColor(255, 0, 255));
  323.   hdc.SetBkColor(TColor(0, 220, 0));
  324.   return 0;
  325. }
  326.  
  327. int TLocaleWindow::FalseColor(TDC& hdc)
  328. // Sets colour to display characters for which the classification function
  329. // returns FALSE
  330. {
  331.   hdc.SetTextColor(TColor(200, 200, 200));
  332.   hdc.SetBkColor(TColor::White);
  333.   return 0;
  334. }
  335.  
  336. void TLocaleWindow::Paint(TDC& hdc, bool, TRect&)
  337. {
  338.   char buf[100];
  339.   int maxWidth;
  340.  
  341.   hdc.SelectStockObject(SYSTEM_FIXED_FONT);
  342.  
  343.   hdc.SetTextColor(TColor::Black);
  344.   hdc.TextOut((30 * CharWidth), (CharHeight / 2), MacroNames[Classification - alnum], strlen(MacroNames[Classification - CM_ISALNUM]));
  345.   maxWidth = (10 * CharWidth);
  346.  
  347.   const int columns=16;
  348.   const int rows=16;
  349.   const char hexChars[16] = {'0', '1', '2', '3', '4', '5', '6', '7', 
  350.                  '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
  351.  
  352.   //Display the codepoint values around the character set.
  353.   for (int i = 0; i < rows; i++) {
  354.     sprintf(buf, "%c", hexChars[i]);
  355.     hdc.TextOut(maxWidth + ((i * 3) * CharWidth), CharHeight * 2 , buf, 1);
  356.     hdc.TextOut((maxWidth - (3 * CharWidth)), CharHeight * (i + 3), buf, 1);
  357.   }
  358.  
  359.   // display the character set in a ROWS x COLUMNS grid, with colours set by
  360.   // trueColor() and falseColor() according to the return value of the current
  361.   // classification function.
  362.   for (int i = 0; i < rows; i++)
  363.     for (int j = 0; j < columns; j++) {
  364.       int c = ((i * columns) + j);
  365.       sprintf(buf, "%c",  c);
  366.       ClassificationMacros[Classification - alnum](c) ? TrueColor(hdc) : FalseColor(hdc);
  367.       if (c < 256) // in case we use different values for row/column.
  368.     hdc.TextOut(maxWidth + ((j * 3) * CharWidth), CharHeight * (i + 3), buf, 1);
  369.     }
  370.  
  371.  
  372.   // Draw a box round the characters.
  373.   const int x1 = maxWidth - 6;
  374.   const int y1 = (3 * CharHeight) - 2;
  375.   const int x2 = (maxWidth - 2) + (CharWidth * (columns * 3));
  376.   const int y2 = ((3 * CharHeight) - 2) + (CharHeight  * rows);
  377.  
  378.   BoxTopLeft.x = x1;
  379.   BoxTopLeft.y = y1;
  380.   BoxBottomRight.x = x2 - x1;
  381.   BoxBottomRight.y = y2 - y1;
  382.  
  383.   CellWidth = (BoxBottomRight.x / columns);
  384.   CellHeight = (BoxBottomRight.y / rows);
  385.  
  386.   hdc.SelectObject(TPen(TColor(0, 127, 127)));
  387.  
  388.   hdc.MoveTo(x1, y1);
  389.   hdc.LineTo(x1, y2);
  390.   hdc.LineTo(x2, y2);
  391.   hdc.LineTo(x2, y1);
  392.   hdc.LineTo(x1, y1);
  393.  
  394.   for (int i = 0; i < rows; i++) {
  395.     hdc.MoveTo(x1, y1 + (i * CharHeight));
  396.     hdc.LineTo(x2, y1 + (i * CharHeight));
  397.   }
  398.  
  399.   for (int i = 0; i < columns; i++) {
  400.     hdc.MoveTo(x1 + ((i * 3) * CharWidth), y1);
  401.     hdc.LineTo(x1 + ((i * 3) * CharWidth), y2);
  402.   }
  403.   hdc.RestorePen();
  404. }
  405.  
  406. int TLocaleWindow::ChangeClassification(classifications newClassification)
  407. {
  408.   CheckMenuItem(Parent -> GetMenu(), Classification, MF_UNCHECKED);
  409.   Classification = newClassification;
  410.   CheckMenuItem(Parent -> GetMenu(), Classification, MF_CHECKED);
  411.  
  412.   Invalidate(TRUE);
  413.   return 0;
  414. }
  415.  
  416. void TLocaleWindow::ChangeUI(TModule* resModule)
  417. {
  418.   CheckMenuItem(Parent -> GetMenu(), Classification, MF_CHECKED);
  419.   resModule -> LoadString(IDS_CHARACTER, CharacterString, sizeof(CharacterString));
  420. }
  421.  
  422. void TLocaleWindow::EvMouseMove(UINT /*modKeys*/, TPoint& point)
  423. {
  424.   char buf[50];
  425.   point.x -= BoxTopLeft.x;
  426.   point.y -= BoxTopLeft.y;
  427.   if (((point.x > 0) && (point.x < BoxBottomRight.x - 4))
  428.     && ((point.y > 0) && (point.y < BoxBottomRight.y))) {
  429.     int ch = (((point.y / CellHeight) * 16) + (point.x /CellWidth));
  430.     sprintf(buf, "%s %4d  :  %4c  :  %#x", CharacterString, ch, (ch == 0) ? 1 : ch, ch, ch);
  431.   }
  432.   else {
  433.     buf[0] = 0;
  434.   }
  435.   TYPESAFE_DOWNCAST(Parent->ChildWithId(IDW_STATUSBAR), TStatusBar)->SetText(buf);
  436. }
  437.  
  438. void TLocaleWindow::CmIsAlnum()
  439. {
  440.   if (Classification != alnum)
  441.     ChangeClassification(alnum);
  442. }
  443.  
  444. void TLocaleWindow::CmIsAlpha()
  445. {
  446.   if (Classification != alpha)
  447.     ChangeClassification(alpha);
  448. }
  449.  
  450. void TLocaleWindow::CmIsAscii()
  451. {
  452.   if (Classification != ascii)
  453.     ChangeClassification(ascii);
  454. }
  455.  
  456. void TLocaleWindow::CmIsCntrl()
  457. {
  458.   if (Classification != cntrl)
  459.     ChangeClassification(cntrl);
  460. }
  461.  
  462. void TLocaleWindow::CmIsDigit()
  463. {
  464.   if (Classification != digit)
  465.     ChangeClassification(digit);
  466. }
  467.  
  468. void TLocaleWindow::CmIsGraph()
  469. {
  470.   if (Classification != graph)
  471.     ChangeClassification(graph);
  472. }
  473.  
  474. void TLocaleWindow::CmIsLower()
  475. {
  476.   if (Classification != lower)
  477.     ChangeClassification(lower);
  478. }
  479.  
  480. void TLocaleWindow::CmIsPrint()
  481. {
  482.   if (Classification != print)
  483.     ChangeClassification(print);
  484. }
  485.  
  486. void TLocaleWindow::CmIsPunct()
  487. {
  488.   if (Classification != punct)
  489.     ChangeClassification(punct);
  490. }
  491.  
  492. void TLocaleWindow::CmIsSpace()
  493. {
  494.   if (Classification != space)
  495.     ChangeClassification(space);
  496. }
  497.  
  498. void TLocaleWindow::CmIsUpper()
  499. {
  500.   if (Classification != upper)
  501.     ChangeClassification(upper);
  502. }
  503.  
  504. void TLocaleWindow::CmIsXDigit()
  505. {
  506.   if (Classification != xdigit)
  507.     ChangeClassification(xdigit);
  508. }
  509.  
  510. //
  511. // class TLocaleFrame
  512. // ----- ------------
  513. //
  514. class TLocaleFrame : public TDecoratedFrame
  515. {
  516.   enum languages {langEnglish = CM_LANGUAGEENGLISH, langFrench, langGerman};
  517.   enum locales {locC = CM_LOCALEC, locUS, locUK, locFrench, locGerman};
  518.  
  519.   public:
  520.     TLocaleFrame(TWindow* client);
  521.     virtual ~TLocaleFrame();
  522.  
  523.   protected:
  524.     void SetupWindow();
  525.     void EvEnterIdle(UINT source, HWND hWndDlg);
  526.     void CmEnglishLanguage();
  527.     void CmFrenchLanguage();
  528.     void CmGermanLanguage();
  529.     void CmFileList();
  530.     void CmCLocale();
  531.     void CmUSLocale();
  532.     void CmUKLocale();
  533.     void CmFrenchLocale();
  534.     void CmGermanLocale();
  535.     void CmShowValues();
  536.     LRESULT WMValWndClose(WPARAM, LPARAM);
  537.     TLocaleWindow& GetWindow();
  538.     int ChangeUI(char* DLLName, languages newLanguage, UINT countryCode);
  539.     char* ChangeLocale(int category, char* localeType, locales newLocale);
  540.     void RedrawValueWindow();
  541.  
  542.   private:
  543.     languages Language;
  544.     locales   Locale;
  545.     TModule*  ResourceModule;
  546.     TMenu*    Menu;
  547.     TLocaleValueWindow* ValueWin;
  548.     short     CharWidth, CharHeight, ScrX, ScrY;
  549.     lconv*    Conv;
  550.  
  551.   DECLARE_AUTOCLASS(TLocaleFrame)
  552.     AUTODETACH
  553.     AUTOPROPRO(Window,  GetWindow, TAutoObject<TLocaleWindow>,  )
  554.     AUTOFUNC0V(CLocale, CmCLocale, )
  555.     AUTOFUNC0V(USLocale, CmUSLocale, )
  556.     AUTOFUNC0V(UKLocale, CmUKLocale, )
  557.     AUTOFUNC0V(FrenchLocale, CmFrenchLocale, )
  558.     AUTOFUNC0V(GermanLocale, CmGermanLocale, )
  559.     AUTOFUNC0V(EnglishLanguage, CmEnglishLanguage, )
  560.     AUTOFUNC0V(FrenchLanguage, CmFrenchLanguage, )
  561.     AUTOFUNC0V(GermanLanguage, CmGermanLanguage, )
  562.  
  563.   DECLARE_RESPONSE_TABLE(TLocaleFrame);
  564. };
  565.  
  566. DEFINE_AUTOCLASS(TLocaleFrame)
  567.   EXPOSE_PROPRO(Window, TLocaleWindow, "@Wnd", "@wnd_", HC_FRAME_WINDOW)
  568.   EXPOSE_METHOD(CLocale, TAutoVoid, "!CLocale", "@CLocale_", HC_FRAME_CLOCALE)
  569.   EXPOSE_METHOD(USLocale, TAutoVoid, "!USLocale", "@USLocale_", HC_FRAME_USLOCALE)
  570.   EXPOSE_METHOD(UKLocale, TAutoVoid, "!UKLocale", "@UKLocale_", HC_FRAME_UKLOCALE)
  571.   EXPOSE_METHOD(FrenchLocale, TAutoVoid, "!FrenchLocale", "@FrenchLocale_", HC_FRAME_FRALOCALE)
  572.   EXPOSE_METHOD(GermanLocale, TAutoVoid, "!GermanLocale", "@GermanLocale_", HC_FRAME_GERLOCALE)
  573.   EXPOSE_METHOD(EnglishLanguage, TAutoVoid, "!EnglishLanguage", "@EnglishLanguage_", HC_FRAME_ENGLANG)
  574.   EXPOSE_METHOD(FrenchLanguage, TAutoVoid, "!FrenchLanguage", "@FrenchLanguage_", HC_FRAME_FRALANG)
  575.   EXPOSE_METHOD(GermanLanguage, TAutoVoid, "!GermanLanguage", "@GermanLanguage_", HC_FRAME_GERLANG)
  576. END_AUTOCLASS(TLocaleFrame, tfNormal, "TLocaleFrame", "@TLocaleFrame_", HC_APP_WINDOW);
  577.  
  578. DEFINE_RESPONSE_TABLE1(TLocaleFrame, TDecoratedFrame)
  579.   EV_WM_ENTERIDLE,
  580.   EV_COMMAND(CM_FILELIST, CmFileList),
  581.   EV_COMMAND(CM_LOCALEC, CmCLocale),
  582.   EV_COMMAND(CM_LOCALEUS, CmUSLocale),
  583.   EV_COMMAND(CM_LOCALEUK, CmUKLocale),
  584.   EV_COMMAND(CM_LOCALEFRENCH, CmFrenchLocale),
  585.   EV_COMMAND(CM_LOCALEGERMAN, CmGermanLocale),
  586.   EV_COMMAND(CM_LANGUAGEENGLISH, CmEnglishLanguage),
  587.   EV_COMMAND(CM_LANGUAGEFRENCH, CmFrenchLanguage),
  588.   EV_COMMAND(CM_LANGUAGEGERMAN, CmGermanLanguage),
  589.   EV_COMMAND(CM_SHOWVALUES, CmShowValues),
  590.   EV_MESSAGE(WM_VALWNDCLOSE, WMValWndClose),
  591. END_RESPONSE_TABLE;
  592.  
  593. TLocaleFrame::TLocaleFrame(TWindow* client)
  594.   :TDecoratedFrame((TWindow*)0, (char*)0, client, TRUE)
  595. {
  596.   ResourceModule = new TModule("APIENG.DLL");
  597.  
  598. #if 1
  599.   Menu = new TMenu(ResourceModule->LoadMenu("MAINMENU"), NoAutoDelete);
  600.   if (!HMENU(*Menu))
  601.     throw "Error loading menu";
  602. #else
  603.   Menu = new TMenu(*ResourceModule, "MAINMENU");
  604. #endif
  605.  
  606.   ValueWin = 0;
  607.   Locale = locC;
  608.   Language = langEnglish;
  609.  
  610.   TWindowDC dc(HWindow);
  611.   dc.SelectStockObject(SYSTEM_FIXED_FONT);
  612.   TEXTMETRIC tm;
  613.   dc.GetTextMetrics (tm);
  614.   CharWidth = short(tm.tmAveCharWidth);
  615.   CharHeight = short(tm.tmHeight + tm.tmExternalLeading);
  616.   Attr.H = (CharHeight * 25);
  617.   Attr.W = (CharWidth * 80);
  618. }
  619.  
  620. TLocaleFrame::~TLocaleFrame()
  621. {
  622.   delete Menu;
  623.   delete ResourceModule;
  624. }
  625.  
  626. void TLocaleFrame::SetupWindow()
  627. {
  628.   TDecoratedFrame::SetupWindow();
  629.  
  630.   char title[100];
  631.   ResourceModule->LoadString(IDS_APPNAME, title, sizeof(title));
  632.   SetCaption(title);
  633.   SetMenu(*Menu);
  634.   Menu->CheckMenuItem(Locale, MF_CHECKED);
  635.   Menu->CheckMenuItem(Language, MF_CHECKED);
  636.   TYPESAFE_DOWNCAST(GetClientWindow(), TLocaleWindow)->ChangeUI(ResourceModule);
  637.   Conv = localeconv();
  638. }
  639.  
  640. void TLocaleFrame::EvEnterIdle(UINT source, HWND hWndDlg)
  641. {
  642.   //TDecoratedFrame::EvEnterIdle loads the help hint string, so
  643.   // we change the instance here so it gets it from pResourceModule
  644.   TModule* module = GetModule();
  645.   SetModule(ResourceModule);
  646.   TDecoratedFrame::EvEnterIdle(source, hWndDlg);
  647.   SetModule(module);
  648. }
  649.  
  650. void TLocaleFrame::CmEnglishLanguage()
  651. {
  652.   ChangeUI("apieng.dll", langEnglish, LANG_ENGLISH);
  653. }
  654.  
  655. void TLocaleFrame::CmFrenchLanguage()
  656. {
  657.   ChangeUI("apifra.dll", langFrench, LANG_FRENCH);
  658. }
  659.  
  660. void TLocaleFrame::CmGermanLanguage()
  661. {
  662.   ChangeUI("apiger.dll", langGerman, LANG_GERMAN);
  663. }
  664.  
  665. void TLocaleFrame::CmFileList()
  666. {
  667.   TFileListDialog(this, ResourceModule).Execute();
  668. }
  669.  
  670. void TLocaleFrame::CmCLocale()
  671. {
  672.   if (Locale != locC)
  673.     ChangeLocale(LC_ALL, "C", locC);
  674. }
  675.  
  676. void TLocaleFrame::CmUSLocale()
  677. {
  678.   if (Locale != locUS)
  679.     ChangeLocale(LC_ALL, "en_US.WIN1252", locUS);
  680. }
  681.  
  682. void TLocaleFrame::CmUKLocale()
  683. {
  684.   if (Locale != locUK)
  685.     ChangeLocale(LC_ALL, "en_GB.WIN1252", locUK);
  686. }
  687.  
  688. void TLocaleFrame::CmFrenchLocale()
  689. {
  690.   if (Locale != locFrench)
  691.     ChangeLocale(LC_ALL, "fr_FR.WIN1252", locFrench);
  692. }
  693.  
  694. void TLocaleFrame::CmGermanLocale()
  695. {
  696.   if (Locale != locGerman)
  697.     ChangeLocale(LC_ALL, "de_DE.WIN1252", locGerman);
  698. }
  699.  
  700. void TLocaleFrame::CmShowValues()
  701. {
  702.   if (!ValueWin) {
  703.     ValueWin = new TLocaleValueWindow(Conv, CharWidth, CharHeight, ResourceModule, this);
  704.     ValueWin->Create();
  705.     ValueWin->Show(SW_SHOW);
  706.   }
  707.   else
  708.     ValueWin->SetFocus();
  709. }
  710.  
  711. LRESULT TLocaleFrame::WMValWndClose(WPARAM, LPARAM)
  712. {
  713.   ValueWin = 0;
  714.   return 0;
  715. }
  716.  
  717. TLocaleWindow& TLocaleFrame::GetWindow() 
  718. {
  719.   TLocaleWindow* localeWin = TYPESAFE_DOWNCAST(GetClientWindow(), TLocaleWindow);
  720.   return *localeWin;
  721. }
  722.  
  723. int TLocaleFrame::ChangeUI(char* dllName, languages newLanguage, UINT countryCode)
  724. {
  725.   delete ResourceModule;
  726.   ResourceModule = new TModule(dllName);
  727.   delete Menu;
  728.   Menu = new TMenu(ResourceModule->LoadMenu("MAINMENU"), NoAutoDelete);
  729.   SetMenu(*Menu);
  730.   Menu->CheckMenuItem(Locale, MF_CHECKED);
  731.   TYPESAFE_DOWNCAST(GetClientWindow(), TLocaleWindow)->ChangeUI(ResourceModule);
  732.  
  733.   char title[100];
  734.   ResourceModule->LoadString(IDS_APPNAME, title, sizeof(title));
  735.   SetCaption(title);
  736.  
  737.   Invalidate(TRUE);
  738.   RedrawValueWindow();
  739.   Menu->CheckMenuItem(Language, MF_UNCHECKED);
  740.   Language = newLanguage;
  741.   Menu->CheckMenuItem(Language, MF_CHECKED);
  742.  
  743.   TBwccDll* bwcc = GetApplication()->GetBWCCModule();
  744.   bwcc->IntlTerm();
  745.   bwcc->IntlInit(countryCode);
  746.   return 1;
  747. }
  748.  
  749. char* TLocaleFrame::ChangeLocale(int category, char *localeType, locales newLocale)
  750. {
  751.   Menu->CheckMenuItem(Locale, MF_UNCHECKED);
  752.   Locale = newLocale;
  753.   Menu->CheckMenuItem(Locale, MF_CHECKED);
  754.  
  755.   char* c = setlocale(category, localeType);
  756.   Conv = localeconv();
  757.   Invalidate(TRUE);
  758.   RedrawValueWindow();
  759.   ChildWithId(ID_LOCALEWINDOW)->Invalidate(TRUE);
  760.   return c;
  761. }
  762.  
  763. void TLocaleFrame::RedrawValueWindow()
  764. {
  765.   if (ValueWin) {
  766.     ValueWin->ResetValues(Conv, CharWidth, CharHeight, ResourceModule);
  767.     ValueWin->Invalidate(TRUE);
  768.   }
  769. }
  770.  
  771. //
  772. // class TLocaleApplication
  773. // ----- ------------------
  774. //
  775. class TLocaleApplication : public TApplication
  776. {
  777.   public:
  778.     TLocaleApplication():TApplication("Intl demo program") {}
  779.  
  780.     void InitMainWindow();
  781.     TLocaleFrame& GetWindow();
  782.  
  783.   DECLARE_AUTOCLASS(TLocaleApplication)
  784.     AUTODETACH
  785.     AUTOPROPRO(Window,  GetWindow, TAutoObject<TLocaleFrame>,  )
  786. };
  787.  
  788. DEFINE_AUTOCLASS(TLocaleApplication)
  789.   EXPOSE_APPLICATION(TLocaleApplication, "!Application", "@appobj_", HC_APP_APPLICATION)
  790.   EXPOSE_QUIT("!Quit", "@quitapp_", HC_APP_QUIT)
  791.   EXPOSE_PROPRO(Window, TLocaleFrame, "!Window", "@window_", HC_APP_WINDOW)
  792. END_AUTOCLASS(TLocaleApplication, tfAppObject | tfCanCreate, "TLocaleApplication", "@TLocaleApp_", HC_APP_APPLICATION);
  793.  
  794. void TLocaleApplication::InitMainWindow()
  795. {
  796.   try
  797.   {
  798.     nCmdShow = SW_SHOWNORMAL;
  799.     TLocaleFrame* frame = new TLocaleFrame(new TLocaleWindow);
  800.     TStatusBar* sb = new TStatusBar(frame, TGadget::Recessed);
  801.     frame->Insert(*sb, TDecoratedFrame::Bottom);
  802.     MainWindow = frame;
  803.     MainWindow->SetIcon(this, "World_Icon");
  804.     EnableBWCC(TRUE, LANG_ENGLISH);
  805.   }
  806.   catch(xmsg& x)
  807.   {
  808.     MessageBox(0, x.why().c_str(), "Intldemo", MB_OK);
  809.   }
  810. }
  811.  
  812. TLocaleFrame& TLocaleApplication::GetWindow() 
  813. {
  814.   TLocaleFrame* frame = TYPESAFE_DOWNCAST(GetMainWindow(), TLocaleFrame);
  815.   return *frame;
  816. }
  817.  
  818. DEFINE_APP_DICTIONARY(AppDictionary);
  819. static TPointer<TRegistrar> Registrar;
  820.  
  821. REGISTRATION_FORMAT_BUFFER(100)
  822.  
  823. BEGIN_REGISTRATION(ApplicationReg)
  824.   REGDATA(clsid, "{ABA228C0-BD21-101C-AF42-040224009C00}")
  825.   REGDATA(progid, "Locale.Application")
  826.   REGDATA(appname, "@appname")
  827.   REGDATA(description, "@Desc")
  828.   REGDATA(cmdline, "/Automation")
  829.   REGDATA(typehelp, "@typehelp")
  830. END_REGISTRATION
  831.  
  832. int OwlMain(int /*argc*/, char* /*argv*/ [])
  833. {
  834.   try {
  835.     ::Registrar = new TRegistrar(::ApplicationReg, TAutoFactory<TLocaleApplication>(), TApplication::GetCmdLine(), _hInstance);
  836.     if (::Registrar->IsOptionSet(amAnyRegOption))
  837.       return 0;
  838.  
  839.     return ::Registrar->Run();
  840.   }
  841.   catch (xmsg& x) {
  842.     GetApplicationObject()->MessageBox(0, x.why().c_str(), "Exception", MB_OK);
  843.   }
  844.   return -1;
  845. }
  846.