home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c083 / 19.ddi / DIAGXPRT.PAK / SETUP.H < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-02  |  10.2 KB  |  385 lines
  1. //----------------------------------------------------------------------------
  2. // ObjectWindows - (C) Copyright 1991, 1993 by Borland International
  3. //----------------------------------------------------------------------------
  4.  
  5. #include  <owl\scrollba.h>
  6. #include  <owl\button.h>
  7. #include  <owl\listbox.h>
  8. #include  <owl\checkbox.h>
  9. #include  <owl\radiobut.h>
  10. #include  <owl\edit.h>
  11. #include  <owl\static.h>
  12. #include  <classlib\arrays.h>
  13.  
  14. class TDiagEnable;
  15. class TSizableDialog;
  16. class TSetupDialog;
  17.  
  18. class TSetupItem;
  19. class TSysItem;
  20. class TUsrItem;
  21.  
  22. class TBaseSetupWindow;
  23. class TSysWindow;
  24. class TUsrWindow;
  25.  
  26. class TGroup;
  27. class TSysGroup;
  28. class TUsrGroup;
  29. class TGroupScroll;
  30.  
  31. #define SYS_INI "owl.ini"
  32. #define SYS_CLS "Diagnostics"
  33. #define SYS_DSC "Diagnostics Descriptions"
  34. #define USR_INI "owl.ini"
  35. #define USR_CLS "Diagnostics"
  36. #define USR_DSC "Users Diagnostics Descriptions"
  37.  
  38.  
  39. class TDiagEnable : public TCheckBox {
  40.   public:
  41.     TDiagEnable(TWindow* parent, int id, TWindow* w0, TWindow* w1)
  42.       : W0(w0), W1(w1), S0(0), S1(0), TCheckBox(parent, id) {}
  43.     TDiagEnable(TWindow* parent, int id, TGroup* s0, TGroup* s1)
  44.       : W0(0), W1(0), S0(s0), S1(s1), TCheckBox(parent, id) {}
  45.     void  BNClicked();
  46.     BOOL  EnableWindow(BOOL enable);
  47.  
  48.   protected:
  49.     TGroup*  S0;
  50.     TGroup*  S1;
  51.     TWindow* W0;
  52.     TWindow* W1;
  53.  
  54.   DECLARE_RESPONSE_TABLE(TDiagEnable);
  55. };
  56.  
  57.  
  58. class TUsrEnable : public TDiagEnable {
  59.   public:
  60.     TUsrEnable(TWindow *w, int nID, TWindow *w0, TWindow *w1, TWindow *B) :
  61.       Ntf(B), TDiagEnable(w, nID, w0, w1) {}
  62.  
  63.     void  EvSetFocus(HWND h) {
  64.       if (Ntf && !Ntf->IsWindowEnabled()) Ntf->EnableWindow(TRUE);
  65.       TDiagEnable::EvSetFocus(h);
  66.     }
  67.     void  EvKillFocus(HWND h) {
  68.       if (Ntf && Ntf->IsWindowEnabled()) Ntf->EnableWindow(FALSE);
  69.       TDiagEnable::EvKillFocus(h);
  70.     }
  71.  
  72.   private:
  73.     TWindow* Ntf;
  74.  
  75.     DECLARE_RESPONSE_TABLE(TUsrEnable);
  76. };
  77.  
  78.  
  79. class TMainEnable : public TDiagEnable {
  80.   public:
  81.     TMainEnable(TWindow* parent, int id, TGroup* g0, TGroup* g1);
  82.     void Load();
  83.     void Save();
  84.  
  85.   private:
  86.     static char* Class;
  87. };
  88.  
  89. class TSetupItem {
  90.   public:
  91.     TSetupItem(char *Class, char *Descr);
  92.     virtual ~TSetupItem() { delete Enable; }
  93.  
  94.     virtual char*  GetIniFile() = 0;
  95.     virtual char*  GetSection() = 0;
  96.     virtual char*  GetSectionDesc() = 0;
  97.     const char*    GetDescr() { return Descr.c_str(); }
  98.     const char*    GetClass() { return Class.c_str(); }
  99.     void           SetClass(char* c) { Class = c; }
  100.     void           SetDescr(char* d) { Descr = d; }
  101.     virtual void operator =(TBaseSetupWindow& w);
  102.     virtual void   Load();
  103.     virtual void   Save();
  104.     BOOL           GetEnable() { return bEnable; }
  105.     int            GetLevel()  { return level; }
  106.     void           SetEnable(BOOL bS) { bEnable = bS; }
  107.     void           SetLevel(int n) { level = n; }
  108.  
  109.   protected:
  110.     TDiagEnable*   Enable;
  111.     string         Class, Descr;
  112.  
  113.   private:
  114.     BOOL    bEnable;
  115.     int     level;
  116. };
  117.  
  118. class TSysItem : public TSetupItem {
  119.   public:
  120.     TSysItem(char* Class, char* Descr = 0) : TSetupItem(Class, Descr) {}
  121.     virtual char*  GetIniFile() { return SYS_INI; }
  122.     virtual char*  GetSection() { return SYS_CLS; }
  123.     virtual char*  GetSectionDesc() { return SYS_DSC; }
  124. };
  125.  
  126. class TUsrItem : public TSetupItem {
  127.   public:
  128.     TUsrItem(char* Class, char* Descr = 0) : TSetupItem(Class, Descr) {}
  129.     virtual char*  GetIniFile() { return USR_INI; }
  130.     virtual char*  GetSection() { return USR_CLS; }
  131.     virtual char*  GetSectionDesc() { return USR_DSC; }
  132. };
  133.  
  134. class TBaseSetupWindow {
  135.   public:
  136.     TBaseSetupWindow() : Enable(0) {}
  137.     virtual BOOL  GetEnable() { CHECK(Enable!=0); return Enable->GetCheck(); }
  138.     virtual void  SetEnable(BOOL bE) { CHECK(Enable!=0); Enable->SetCheck(bE); }
  139.     virtual void  EnableWindow(BOOL bE) = 0;
  140.     virtual int   GetLevel() = 0;
  141.     virtual void  SetLevel(int level) = 0;
  142.     virtual void  operator = (TSetupItem &it) = 0;
  143.     virtual void  operator = (int) = 0;
  144.   protected:
  145.     TDiagEnable* Enable;
  146. };
  147.  
  148. template <class C1,class C2>
  149. class TSetupWindow : public TBaseSetupWindow {
  150.   public:
  151.     virtual int   GetLevel() = 0;
  152.     virtual void  SetLevel(int level) = 0;
  153.   
  154.     virtual void  EnableWindow(BOOL e) {
  155.               Enable->EnableWindow(e);
  156.               if (e) e = Enable->GetCheck();
  157.               Child1->EnableWindow(e);
  158.               Child2->EnableWindow(e);
  159.             }
  160.     virtual void operator = (TSetupItem &it) {
  161.               SetEnable(it.GetEnable());
  162.               SetLevel(it.GetLevel());
  163.               Enable->SetWindowText(it.GetDescr());
  164.               Enable->ShowWindow(SW_SHOW);
  165.               Child1->ShowWindow(SW_SHOW);
  166.               Child2->ShowWindow(SW_SHOW);
  167.             }
  168.     virtual void  operator = (int) {
  169.               Enable->ShowWindow(SW_HIDE);
  170.               Child1->ShowWindow(SW_HIDE);
  171.               Child2->ShowWindow(SW_HIDE);
  172.             }
  173.  
  174.   protected:
  175.     C1* Child1;
  176.     C2* Child2;
  177. };
  178.  
  179. class TSysWindow : public TSetupWindow<TRadioButton,TRadioButton> {
  180.   public:
  181.     TSysWindow(TWindow* w, int i) {
  182.               Child1 = new TRadioButton(w, i + 1, 0);
  183.               Child1->Create();
  184.               Child2 = new TRadioButton(w, i + 2, 0);
  185.               Child2->Create();
  186.               Enable = new TDiagEnable(w, i, Child1, Child2);
  187.               Enable->Create();
  188.             }
  189.     virtual int   GetLevel() { return Child1->GetCheck() ? 1 : 0; }
  190.     virtual void  SetLevel(int level) {
  191.               if (level)
  192.                 Child1->SetCheck(1);
  193.               else
  194.                 Child2->SetCheck(1);
  195.             }
  196. };
  197.  
  198. class TUsrWindow : public TSetupWindow<TStatic, TEdit> {
  199.   public:
  200.     TUsrWindow(TWindow* w, int i) {
  201.       Child1 = new TStatic(w, i + 1, 20); Child1->Create();
  202.       Child2 = new TEdit(w, i + 2); Child2->Create();
  203.       Enable = new TDiagEnable(w, i, Child1, Child2); Enable->Create();
  204.     }
  205.     virtual int GetLevel() {
  206.       char b[6];
  207.       Child2->GetWindowText(b, sizeof(b));
  208.       return atoi(b);
  209.     }
  210.     virtual void  SetLevel(int level) {
  211.       char b[6];
  212.       wsprintf(b, "%d", level);
  213.       Child2->SetWindowText(b);
  214.     }
  215. };
  216.  
  217. class TItemsArray : public TArrayAsVector<TSetupItem *> {
  218.   public:
  219.     TItemsArray() : TArrayAsVector<TSetupItem *>(10, 0, 4) {}
  220. };
  221.  
  222. class TWindowArray : public TArrayAsVector<TBaseSetupWindow *> {
  223.   public:
  224.     TWindowArray() : TArrayAsVector<TBaseSetupWindow *>(10, 0, 4) {}
  225. };
  226.  
  227. class TGroup {
  228.   public:
  229.     enum { MapToTop = 0, MapToBottom = 0x7fff, MapAsBefore = 0x7ffe };
  230.  
  231.     TWindowArray Windows;
  232.     TItemsArray Items;
  233.  
  234.     virtual void  SetMainSwitch(TCheckBox* c) { Switch = c; }
  235.     virtual BOOL  IsEnable() { return Switch ? Switch->GetCheck() : 1; }
  236.     virtual void  EnableWindow(BOOL enable);
  237.     virtual void  Load();
  238.     virtual void  Save();
  239.     virtual void  Cleanup() = 0;
  240.     virtual int   Map(int x);
  241.     virtual int   UnMap();
  242.     virtual ~TGroup() { Windows.Flush(); Items.Flush(); }
  243.  
  244.   private:
  245.     int        scrollPos;
  246.     TCheckBox* Switch;
  247. };
  248.  
  249. class TSysGroup : public TGroup {
  250.   public:
  251.     TSysGroup(TWindow* dialog, int firstID);
  252.     void  Cleanup();
  253. };
  254.  
  255. class TUsrGroup : public TGroup {
  256.   public:
  257.     TUsrGroup(TWindow* dialog, int firstID);
  258.     void  Cleanup();
  259. };
  260.  
  261. class TSizableDialog : public TDialog {
  262.   public:
  263.     TSizableDialog(TWindow* parent, int dlgID, int boxID) : nBoxID(boxID),
  264.                    TDialog(parent, dlgID) {}
  265.     enum { t_minmax, t_min, t_max };
  266.     virtual void  Toggle(int type = t_minmax);
  267.     BOOL    IsMaximized() { return bMaximized; }
  268.  
  269.   protected:
  270.     virtual void  SetupWindow();
  271.     virtual void  EnableControls();
  272.     void  Center();
  273.     void  AdjustPos();
  274.  
  275.   private:
  276.     int   nBoxID;
  277.     TSize small;
  278.     TSize large;
  279.     BOOL  bMaximized;
  280.     int   tSize;
  281. };
  282.  
  283. class TSetupDialog : public TSizableDialog {
  284.   public:
  285.     TSetupDialog(TWindow* p):TSizableDialog(p, DG_OPTIONS, ID_BOX) {}
  286.     void  SetupWindow();
  287.     void  CleanupWindow();
  288.     void  UpdateButtons();
  289.     void  CmOk();
  290.     void  CmAddUsr();
  291.     void  CmDelUsr();
  292.     void  CmEdtUsr();
  293.     void  CmZoom();
  294.  
  295.   private:
  296.     TSysGroup*    SysGroup;
  297.     TUsrGroup*    UsrGroup;
  298.     TMainEnable*  MainEnable;
  299.     TGroupScroll* SysScroll;
  300.     TGroupScroll* UsrScroll;
  301.     TButton*      pDel;
  302.     TButton*      pEdt;
  303.  
  304.   DECLARE_RESPONSE_TABLE(TSetupDialog);
  305. };
  306.  
  307. class TGroupScroll : public TScrollBar {
  308.   public:
  309.     TGroupScroll(TWindow *W, int id, TGroup *group);
  310.     void  Initialize(int pos);
  311.     void  EvVScroll(UINT code, UINT pos, HWND hCtl);
  312.     void  SetPosition(int pos);
  313.     void  EndScroll();
  314.  
  315.   private:
  316.     int     x;
  317.     int     min;
  318.     int     max;
  319.     TGroup* group;
  320.  
  321.   DECLARE_RESPONSE_TABLE(TGroupScroll);
  322. };
  323.  
  324. //
  325. //  class TAddUsrDialog
  326. //
  327. class TAddUsrDialog : public TDialog {
  328.   public:
  329.     char Class[80], Descr[80];
  330.     TAddUsrDialog(TWindow* p): TDialog(p, DG_ADD_CUSTOM) {}
  331.     void CmOk();
  332.  
  333.   DECLARE_RESPONSE_TABLE(TAddUsrDialog);
  334. };
  335.  
  336. //
  337. //  class TItemsDialog
  338. //
  339. class TItemsDialog : public TDialog {
  340.   public:
  341.     TItemsDialog(TWindow* p, int id, TItemsArray* it): items(it), TDialog(p, id) {}
  342.     ~TItemsDialog();
  343.  
  344.     virtual BOOL  IsValid() { return TRUE; }
  345.     virtual void  SetupWindow();
  346.     virtual void  CmOk() { if (IsValid()) TDialog::CmOk(); }
  347.     virtual void  LBDblClk() {}
  348.     virtual void  LBSelChange() {}
  349.  
  350.     TItemsArray* items;
  351.     int          nSel;
  352.  
  353.   protected:
  354.     TListBox*  pList;
  355.  
  356.   DECLARE_RESPONSE_TABLE(TItemsDialog);
  357. };
  358.  
  359. //
  360. //  class TDelUsrDialog
  361. //
  362. class TDelUsrDialog : public TItemsDialog {
  363.   public:
  364.     TDelUsrDialog(TWindow* p, TItemsArray* it): TItemsDialog(p, DG_DEL_CUSTOM, it) {}
  365.     virtual void  CmOk();
  366.     virtual void  LBDblClk() { CmOk(); }
  367. };
  368.  
  369. //
  370. //  class TEdtUsrDialog
  371. //
  372. class TEdtUsrDialog : public TItemsDialog {
  373.   public:
  374.     TEdtUsrDialog(TWindow* p, TItemsArray* it)
  375.         : nPrevSel(LB_ERR), TItemsDialog(p, DG_EDT_CUSTOM, it) {}
  376.     virtual void  LBSelChange();
  377.     virtual void  CmOk();
  378.  
  379.   private:
  380.     int   nPrevSel;
  381.     static  char*  Template;
  382.  
  383.   DECLARE_RESPONSE_TABLE(TEdtUsrDialog);
  384. };
  385.