home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / C / BK-SC1_4.DMS / in.adf / MUIClass.Lha / Include / Classes / TWiMUI / String.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-06-16  |  5.2 KB  |  185 lines
  1. //
  2. //  $VER: String.h      1.0 (16 Jun 1996)
  3. //
  4. //    c 1996 Thomas Wilhelmi
  5. //
  6. //
  7. // Address : Taunusstrasse 14
  8. //           61138 Niederdorfelden
  9. //           Germany
  10. //
  11. //  E-Mail : willi@twi.rhein-main.de
  12. //
  13. //   Phone : +49 (0)6101 531060
  14. //   Fax   : +49 (0)6101 531061
  15. //
  16. //
  17. //  $HISTORY:
  18. //
  19. //  16 Jun 1996 :   1.0 : first public Release
  20. //
  21.  
  22. #ifndef CPP_TWIMUI_STRING_H
  23. #define CPP_TWIMUI_STRING_H
  24.  
  25. #ifndef CPP_TWIMUI_GADGET_H
  26. #include <classes/twimui/gadget.h>
  27. #endif
  28.  
  29. #ifndef CPP_TWIMUI_LABEL_H
  30. #include <classes/twimui/label.h>
  31. #endif
  32.  
  33. #ifndef UTILITY_HOOKS_H
  34. #include <utility/hooks.h>
  35. #endif
  36.  
  37. class MUIStringEditHook
  38.     {
  39.     private:
  40.         struct Hook edithook;
  41.         static void EditHookEntry(register __a0 struct Hook *, register __a2 struct SGWork *, register __a1 Msg);
  42.         virtual void EditHookFunc(struct Hook *, struct SGWork *, Msg);
  43.     protected:
  44.         MUIStringEditHook();
  45.         MUIStringEditHook(const MUIStringEditHook &p);
  46.         ~MUIStringEditHook();
  47.         MUIStringEditHook &operator= (const MUIStringEditHook &);
  48.     public:
  49.         struct Hook *edit() { return(&edithook); };
  50.     };
  51.  
  52. class MUIString
  53.     :   public MUIGadget,
  54.         public MUIStringEditHook
  55.     {
  56.     public:
  57.         MUIString(const struct TagItem *t)
  58.             :   MUIGadget(MUIC_String),
  59.                 MUIStringEditHook()
  60.             {
  61.             init(t);
  62.             };
  63.         MUIString(const Tag, ...);
  64.         MUIString(const STRPTR cont, const ULONG len)
  65.             :   MUIGadget(MUIC_String),
  66.                 MUIStringEditHook()
  67.             {
  68.             init(MUIA_String_Contents, cont,
  69.                 MUIA_String_MaxLen, len,
  70.                 MUIA_Frame, MUIV_Frame_String,
  71.                 TAG_DONE);
  72.             };
  73.         MUIString(const STRPTR cont, const ULONG len, const UBYTE cc)
  74.             :   MUIGadget(MUIC_String),
  75.                 MUIStringEditHook()
  76.             {
  77.             init(MUIA_String_Contents, cont,
  78.                 MUIA_String_MaxLen, len,
  79.                 MUIA_ControlChar, cc,
  80.                 MUIA_Frame, MUIV_Frame_String,
  81.                 TAG_DONE);
  82.             };
  83.         MUIString(const ULONG cont, const ULONG len)
  84.             :   MUIGadget(MUIC_String),
  85.                 MUIStringEditHook()
  86.             {
  87.             init(MUIA_String_Integer, cont,
  88.                 MUIA_String_Accept,"1234567890-+",
  89.                 MUIA_String_MaxLen, len,
  90.                 MUIA_Frame, MUIV_Frame_String,
  91.                 TAG_DONE);
  92.             };
  93.         MUIString(const ULONG len)
  94.             :   MUIGadget(MUIC_String),
  95.                 MUIStringEditHook()
  96.             {
  97.             init(MUIA_String_Accept,"1234567890-+",
  98.                 MUIA_String_MaxLen, len,
  99.                 MUIA_Frame, MUIV_Frame_String,
  100.                 TAG_DONE);
  101.             };
  102.         MUIString(const ULONG cont, const ULONG len, const UBYTE cc)
  103.             :   MUIGadget(MUIC_String),
  104.                 MUIStringEditHook()
  105.             {
  106.             init(MUIA_String_Integer, cont,
  107.                 MUIA_String_Accept,"1234567890-+",
  108.                 MUIA_String_MaxLen, len,
  109.                 MUIA_ControlChar, cc,
  110.                 MUIA_Frame, MUIV_Frame_String,
  111.                 TAG_DONE);
  112.             };
  113.         MUIString(const ULONG len, const UBYTE cc)
  114.             :   MUIGadget(MUIC_String),
  115.                 MUIStringEditHook()
  116.             {
  117.             init(MUIA_String_Accept,"1234567890-+",
  118.                 MUIA_String_MaxLen, len,
  119.                 MUIA_ControlChar, cc,
  120.                 MUIA_Frame, MUIV_Frame_String,
  121.                 TAG_DONE);
  122.             };
  123.         MUIString()
  124.             :   MUIGadget(MUIC_String),
  125.                 MUIStringEditHook()
  126.             { };
  127.         MUIString(MUIString &p)
  128.             :   MUIGadget(p),
  129.                 MUIStringEditHook(p)
  130.             { };
  131.         virtual ~MUIString();
  132.         MUIString &operator= (MUIString &);
  133.         void Accept(const STRPTR p) { set(MUIA_String_Accept,(ULONG)p); };
  134.         STRPTR Accept() const { return((STRPTR)get(MUIA_String_Accept,NULL)); };
  135.         STRPTR Acknowledge() const { return((STRPTR)get(MUIA_String_Acknowledge,NULL)); };
  136.         void AdvanceOnCR(const BOOL p) { set(MUIA_String_AdvanceOnCR,(ULONG)p); };
  137.         BOOL AdvanceOnCR() const { return((BOOL)get(MUIA_String_AdvanceOnCR,FALSE)); };
  138.         void BufferPos(const LONG p) { set(MUIA_String_BufferPos,(ULONG)p); };
  139.         void Contents(const STRPTR p) { set(MUIA_String_Contents,(ULONG)p); };
  140.         STRPTR Contents() const { return((STRPTR)get(MUIA_String_Contents,NULL)); };
  141.         void DisplayPos(const LONG p) { set(MUIA_String_DisplayPos,(ULONG)p); };
  142.         void EditHook(const struct Hook *p) { set(MUIA_String_EditHook,(ULONG)p); };
  143.         struct Hook *EditHook() const { return((struct Hook *)get(MUIA_String_EditHook)); };
  144.         LONG Format() const { return((LONG)get(MUIA_String_Format,0L)); };
  145.         void Integer(const ULONG p) { set(MUIA_String_Integer,p); };
  146.         ULONG Integer() const { return(get(MUIA_String_Integer,0L)); };
  147.         void LonelyEditHook(const BOOL p) { set(MUIA_String_LonelyEditHook,(ULONG)p); };
  148.         BOOL LonelyEditHook() const { return((BOOL)get(MUIA_String_LonelyEditHook,FALSE)); };
  149.         LONG MaxLen() const { return((LONG)get(MUIA_String_MaxLen,0L)); };
  150.         void Reject(const STRPTR p) { set(MUIA_String_Reject,(ULONG)p); };
  151.         STRPTR Reject() const { return((STRPTR)get(MUIA_String_Reject,NULL)); };
  152.         BOOL Secret() const { return((BOOL)get(MUIA_String_Secret,FALSE)); };
  153.     };
  154.  
  155. class MUILabString
  156.     :   public MUILabelHelp,
  157.         public MUIString
  158.     {
  159.     private:
  160.         MUIKeyLabel2 MUILab;
  161.     public:
  162.         MUILabString(const STRPTR lab, const STRPTR cont, const ULONG len)
  163.             :   MUILabelHelp(lab),
  164.                 MUIString(cont,len,MUILabelHelp::gCC()),
  165.                 MUILab(MUILabelHelp::gLab(),MUILabelHelp::gCC())
  166.             {
  167.             };
  168.         MUILabString(const STRPTR lab, const ULONG cont, const ULONG len)
  169.             :   MUILabelHelp(lab),
  170.                 MUIString(cont,len,MUILabelHelp::gCC()),
  171.                 MUILab(MUILabelHelp::gLab(),MUILabelHelp::gCC())
  172.             {
  173.             };
  174.         MUILabString(MUILabString &p)
  175.             :   MUILabelHelp(p),
  176.                 MUIString(p),
  177.                 MUILab(p.MUILab)
  178.             { };
  179.         virtual ~MUILabString();
  180.         MUILabString &operator= (MUILabString &);
  181.         Object *label() { return(MUILab); };
  182.     };
  183.  
  184. #endif
  185.