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 / Label.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-06-16  |  17.1 KB  |  726 lines
  1. //
  2. //  $VER: Label.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_LABEL_H
  23. #define CPP_TWIMUI_LABEL_H
  24.  
  25. #ifndef CPP_TWIMUI_TEXT_H
  26. #include <classes/twimui/text.h>
  27. #endif
  28.  
  29. class MUILabel : public MUIText
  30.     {
  31.     public:
  32.         MUILabel(const STRPTR lab)
  33.             :   MUIText(
  34.                     MUIA_Text_Contents, lab,
  35.                     MUIA_Weight, 0,
  36.                     MUIA_InnerLeft, 0,
  37.                     MUIA_InnerRight, 0,
  38.                     MUIA_FramePhantomHoriz, TRUE,
  39.                     MUIA_Text_PreParse, MUIX_R,
  40.                     TAG_DONE)
  41.             { };
  42.         MUILabel(MUILabel &p) : MUIText(p) { };
  43.         virtual ~MUILabel();
  44.         MUILabel &operator= (MUILabel &);
  45.     };
  46.  
  47. class MUILabel1 : public MUIText
  48.     {
  49.     public:
  50.         MUILabel1(const STRPTR lab)
  51.             :   MUIText(
  52.                     MUIA_Text_Contents, lab,
  53.                     MUIA_Weight, 0,
  54.                     MUIA_InnerLeft, 0,
  55.                     MUIA_InnerRight, 0,
  56.                     MUIA_FramePhantomHoriz, TRUE,
  57.                     MUIA_Frame, MUIV_Frame_Button,
  58.                     MUIA_Text_PreParse, MUIX_R,
  59.                     TAG_DONE)
  60.             { };
  61.         MUILabel1(MUILabel1 &p) : MUIText(p) { };
  62.         virtual ~MUILabel1();
  63.         MUILabel1 &operator= (MUILabel1 &);
  64.     };
  65.  
  66. class MUILabel2 : public MUIText
  67.     {
  68.     public:
  69.         MUILabel2(const STRPTR lab)
  70.             :   MUIText(
  71.                     MUIA_Text_Contents, lab,
  72.                     MUIA_Weight, 0,
  73.                     MUIA_InnerLeft, 0,
  74.                     MUIA_InnerRight, 0,
  75.                     MUIA_FramePhantomHoriz, TRUE,
  76.                     MUIA_Frame, MUIV_Frame_String,
  77.                     MUIA_Text_PreParse, MUIX_R,
  78.                     TAG_DONE)
  79.             { };
  80.         MUILabel2(MUILabel2 &p) : MUIText(p) { };
  81.         virtual ~MUILabel2();
  82.         MUILabel2 &operator= (MUILabel2 &);
  83.     };
  84.  
  85. class MUILLabel : public MUIText
  86.     {
  87.     public:
  88.         MUILLabel(const STRPTR lab)
  89.             :   MUIText(
  90.                     MUIA_Text_Contents, lab,
  91.                     MUIA_Weight, 0,
  92.                     MUIA_InnerLeft, 0,
  93.                     MUIA_InnerRight, 0,
  94.                     MUIA_FramePhantomHoriz, TRUE,
  95.                     TAG_DONE)
  96.             { };
  97.         MUILLabel(MUILLabel &p) : MUIText(p) { };
  98.         virtual ~MUILLabel();
  99.         MUILLabel &operator= (MUILLabel &);
  100.     };
  101.  
  102. class MUILLabel1 : public MUIText
  103.     {
  104.     public:
  105.         MUILLabel1(const STRPTR lab)
  106.             :   MUIText(
  107.                     MUIA_Text_Contents, lab,
  108.                     MUIA_Weight, 0,
  109.                     MUIA_InnerLeft, 0,
  110.                     MUIA_InnerRight, 0,
  111.                     MUIA_FramePhantomHoriz, TRUE,
  112.                     MUIA_Frame, MUIV_Frame_Button,
  113.                     TAG_DONE)
  114.             { };
  115.         MUILLabel1(MUILLabel1 &p) : MUIText(p) { };
  116.         virtual ~MUILLabel1();
  117.         MUILLabel1 &operator= (MUILLabel1 &);
  118.     };
  119.  
  120. class MUILLabel2 : public MUIText
  121.     {
  122.     public:
  123.         MUILLabel2(const STRPTR lab)
  124.             :   MUIText(
  125.                     MUIA_Text_Contents, lab,
  126.                     MUIA_Weight, 0,
  127.                     MUIA_InnerLeft, 0,
  128.                     MUIA_InnerRight, 0,
  129.                     MUIA_FramePhantomHoriz, TRUE,
  130.                     MUIA_Frame, MUIV_Frame_String,
  131.                     TAG_DONE)
  132.             { };
  133.         MUILLabel2(MUILLabel2 &p) : MUIText(p) { };
  134.         virtual ~MUILLabel2();
  135.         MUILLabel2 &operator= (MUILLabel2 &);
  136.     };
  137.  
  138. class MUICLabel : public MUIText
  139.     {
  140.     public:
  141.         MUICLabel(const STRPTR lab)
  142.             :   MUIText(
  143.                     MUIA_Text_Contents, lab,
  144.                     MUIA_Weight, 0,
  145.                     MUIA_InnerLeft, 0,
  146.                     MUIA_InnerRight, 0,
  147.                     MUIA_FramePhantomHoriz, TRUE,
  148.                     MUIA_Text_PreParse, MUIX_C,
  149.                     TAG_DONE)
  150.             { };
  151.         MUICLabel(MUICLabel &p) : MUIText(p) { };
  152.         virtual ~MUICLabel();
  153.         MUICLabel &operator= (MUICLabel &);
  154.     };
  155.  
  156. class MUICLabel1 : public MUIText
  157.     {
  158.     public:
  159.         MUICLabel1(const STRPTR lab)
  160.             :   MUIText(
  161.                     MUIA_Text_Contents, lab,
  162.                     MUIA_Weight, 0,
  163.                     MUIA_InnerLeft, 0,
  164.                     MUIA_InnerRight, 0,
  165.                     MUIA_FramePhantomHoriz, TRUE,
  166.                     MUIA_Text_PreParse, MUIX_C,
  167.                     MUIA_Frame, MUIV_Frame_Button,
  168.                     TAG_DONE)
  169.             { };
  170.         MUICLabel1(MUICLabel1 &p) : MUIText(p) { };
  171.         virtual ~MUICLabel1();
  172.         MUICLabel1 &operator= (MUICLabel1 &);
  173.     };
  174.  
  175. class MUICLabel2 : public MUIText
  176.     {
  177.     public:
  178.         MUICLabel2(const STRPTR lab)
  179.             :   MUIText(
  180.                     MUIA_Text_Contents, lab,
  181.                     MUIA_Weight, 0,
  182.                     MUIA_InnerLeft, 0,
  183.                     MUIA_InnerRight, 0,
  184.                     MUIA_FramePhantomHoriz, TRUE,
  185.                     MUIA_Text_PreParse, MUIX_C,
  186.                     MUIA_Frame, MUIV_Frame_String,
  187.                     TAG_DONE)
  188.             { };
  189.         MUICLabel2(MUICLabel2 &p) : MUIText(p) { };
  190.         virtual ~MUICLabel2();
  191.         MUICLabel2 &operator= (MUICLabel2 &);
  192.     };
  193.  
  194. class MUIKeyLabel : public MUIText
  195.     {
  196.     public:
  197.         MUIKeyLabel(const STRPTR lab, const UBYTE hichar)
  198.             :   MUIText(
  199.                     MUIA_Text_Contents, lab,
  200.                     MUIA_Weight, 0,
  201.                     MUIA_InnerLeft, 0,
  202.                     MUIA_InnerRight, 0,
  203.                     MUIA_FramePhantomHoriz, TRUE,
  204.                     MUIA_Text_HiChar, hichar,
  205.                     MUIA_Text_PreParse, MUIX_R,
  206.                     TAG_DONE)
  207.             { };
  208.         MUIKeyLabel(MUIKeyLabel &p) : MUIText(p) { };
  209.         virtual ~MUIKeyLabel();
  210.         MUIKeyLabel &operator= (MUIKeyLabel &);
  211.     };
  212.  
  213. class MUIKeyLabel1 : public MUIText
  214.     {
  215.     public:
  216.         MUIKeyLabel1(const STRPTR lab, const UBYTE hichar)
  217.             :   MUIText(
  218.                     MUIA_Text_Contents, lab,
  219.                     MUIA_Weight, 0,
  220.                     MUIA_InnerLeft, 0,
  221.                     MUIA_InnerRight, 0,
  222.                     MUIA_FramePhantomHoriz, TRUE,
  223.                     MUIA_Text_HiChar, hichar,
  224.                     MUIA_Frame, MUIV_Frame_Button,
  225.                     MUIA_Text_PreParse, MUIX_R,
  226.                     TAG_DONE)
  227.             { };
  228.         MUIKeyLabel1(MUIKeyLabel1 &p) : MUIText(p) { };
  229.         virtual ~MUIKeyLabel1();
  230.         MUIKeyLabel1 &operator= (MUIKeyLabel1 &);
  231.     };
  232.  
  233. class MUIKeyLabel2 : public MUIText
  234.     {
  235.     public:
  236.         MUIKeyLabel2(const STRPTR lab, const UBYTE hichar)
  237.             :   MUIText(
  238.                     MUIA_Text_Contents, lab,
  239.                     MUIA_Weight, 0,
  240.                     MUIA_InnerLeft, 0,
  241.                     MUIA_InnerRight, 0,
  242.                     MUIA_FramePhantomHoriz, TRUE,
  243.                     MUIA_Text_HiChar, hichar,
  244.                     MUIA_Frame, MUIV_Frame_String,
  245.                     MUIA_Text_PreParse, MUIX_R,
  246.                     TAG_DONE)
  247.             { };
  248.         MUIKeyLabel2(MUIKeyLabel2 &p) : MUIText(p) { };
  249.         virtual ~MUIKeyLabel2();
  250.         MUIKeyLabel2 &operator= (MUIKeyLabel2 &);
  251.     };
  252.  
  253. class MUIKeyLLabel : public MUIText
  254.     {
  255.     public:
  256.         MUIKeyLLabel(const STRPTR lab, const UBYTE hichar)
  257.             :   MUIText(
  258.                     MUIA_Text_Contents, lab,
  259.                     MUIA_Weight, 0,
  260.                     MUIA_InnerLeft, 0,
  261.                     MUIA_InnerRight, 0,
  262.                     MUIA_FramePhantomHoriz, TRUE,
  263.                     MUIA_Text_HiChar, hichar,
  264.                     TAG_DONE)
  265.             { };
  266.         MUIKeyLLabel(MUIKeyLLabel &p) : MUIText(p) { };
  267.         virtual ~MUIKeyLLabel();
  268.         MUIKeyLLabel &operator= (MUIKeyLLabel &);
  269.     };
  270.  
  271. class MUIKeyLLabel1 : public MUIText
  272.     {
  273.     public:
  274.         MUIKeyLLabel1(const STRPTR lab, const UBYTE hichar)
  275.             :   MUIText(
  276.                     MUIA_Text_Contents, lab,
  277.                     MUIA_Weight, 0,
  278.                     MUIA_InnerLeft, 0,
  279.                     MUIA_InnerRight, 0,
  280.                     MUIA_FramePhantomHoriz, TRUE,
  281.                     MUIA_Text_HiChar, hichar,
  282.                     MUIA_Frame, MUIV_Frame_Button,
  283.                     TAG_DONE)
  284.             { };
  285.         MUIKeyLLabel1(MUIKeyLLabel1 &p) : MUIText(p) { };
  286.         virtual ~MUIKeyLLabel1();
  287.         MUIKeyLLabel1 &operator= (MUIKeyLLabel1 &);
  288.     };
  289.  
  290. class MUIKeyLLabel2 : public MUIText
  291.     {
  292.     public:
  293.         MUIKeyLLabel2(const STRPTR lab, const UBYTE hichar)
  294.             :   MUIText(
  295.                     MUIA_Text_Contents, lab,
  296.                     MUIA_Weight, 0,
  297.                     MUIA_InnerLeft, 0,
  298.                     MUIA_InnerRight, 0,
  299.                     MUIA_FramePhantomHoriz, TRUE,
  300.                     MUIA_Text_HiChar, hichar,
  301.                     MUIA_Frame, MUIV_Frame_String,
  302.                     TAG_DONE)
  303.             { };
  304.         MUIKeyLLabel2(MUIKeyLLabel2 &p) : MUIText(p) { };
  305.         virtual ~MUIKeyLLabel2();
  306.         MUIKeyLLabel2 &operator= (MUIKeyLLabel2 &);
  307.     };
  308.  
  309. class MUIKeyCLabel : public MUIText
  310.     {
  311.     public:
  312.         MUIKeyCLabel(const STRPTR lab, const UBYTE hichar)
  313.             :   MUIText(
  314.                     MUIA_Text_Contents, lab,
  315.                     MUIA_Weight, 0,
  316.                     MUIA_InnerLeft, 0,
  317.                     MUIA_InnerRight, 0,
  318.                     MUIA_FramePhantomHoriz, TRUE,
  319.                     MUIA_Text_HiChar, hichar,
  320.                     MUIA_Text_PreParse, MUIX_C,
  321.                     TAG_DONE)
  322.             { };
  323.         MUIKeyCLabel(MUIKeyCLabel &p) : MUIText(p) { };
  324.         virtual ~MUIKeyCLabel();
  325.         MUIKeyCLabel &operator= (MUIKeyCLabel &);
  326.     };
  327.  
  328. class MUIKeyCLabel1 : public MUIText
  329.     {
  330.     public:
  331.         MUIKeyCLabel1(const STRPTR lab, const UBYTE hichar)
  332.             :   MUIText(
  333.                     MUIA_Text_Contents, lab,
  334.                     MUIA_Weight, 0,
  335.                     MUIA_InnerLeft, 0,
  336.                     MUIA_InnerRight, 0,
  337.                     MUIA_FramePhantomHoriz, TRUE,
  338.                     MUIA_Text_HiChar, hichar,
  339.                     MUIA_Text_PreParse, MUIX_C,
  340.                     MUIA_Frame, MUIV_Frame_Button,
  341.                     TAG_DONE)
  342.             { };
  343.         MUIKeyCLabel1(MUIKeyCLabel1 &p) : MUIText(p) { };
  344.         virtual ~MUIKeyCLabel1();
  345.         MUIKeyCLabel1 &operator= (MUIKeyCLabel1 &);
  346.     };
  347.  
  348. class MUIKeyCLabel2 : public MUIText
  349.     {
  350.     public:
  351.         MUIKeyCLabel2(const STRPTR lab, const UBYTE hichar)
  352.             :   MUIText(
  353.                     MUIA_Text_Contents, lab,
  354.                     MUIA_Weight, 0,
  355.                     MUIA_InnerLeft, 0,
  356.                     MUIA_InnerRight, 0,
  357.                     MUIA_FramePhantomHoriz, TRUE,
  358.                     MUIA_Text_HiChar, hichar,
  359.                     MUIA_Text_PreParse, MUIX_C,
  360.                     MUIA_Frame, MUIV_Frame_String,
  361.                     TAG_DONE)
  362.             { };
  363.         MUIKeyCLabel2(MUIKeyCLabel2 &p) : MUIText(p) { };
  364.         virtual ~MUIKeyCLabel2();
  365.         MUIKeyCLabel2 &operator= (MUIKeyCLabel2 &);
  366.     };
  367.  
  368. class MUIFreeLabel : public MUIText
  369.     {
  370.     public:
  371.         MUIFreeLabel(const STRPTR lab)
  372.             :   MUIText(
  373.                     MUIA_Text_Contents, lab,
  374.                     MUIA_Weight, 0,
  375.                     MUIA_InnerLeft, 0,
  376.                     MUIA_InnerRight, 0,
  377.                     MUIA_FramePhantomHoriz, TRUE,
  378.                     MUIA_Text_SetVMax, FALSE,
  379.                     MUIA_Text_PreParse, MUIX_R,
  380.                     TAG_DONE)
  381.             { };
  382.         MUIFreeLabel(MUIFreeLabel &p) : MUIText(p) { };
  383.         virtual ~MUIFreeLabel();
  384.         MUIFreeLabel &operator= (MUIFreeLabel &);
  385.     };
  386.  
  387. class MUIFreeLabel1 : public MUIText
  388.     {
  389.     public:
  390.         MUIFreeLabel1(const STRPTR lab)
  391.             :   MUIText(
  392.                     MUIA_Text_Contents, lab,
  393.                     MUIA_Weight, 0,
  394.                     MUIA_InnerLeft, 0,
  395.                     MUIA_InnerRight, 0,
  396.                     MUIA_FramePhantomHoriz, TRUE,
  397.                     MUIA_Text_SetVMax, FALSE,
  398.                     MUIA_Frame, MUIV_Frame_Button,
  399.                     MUIA_Text_PreParse, MUIX_R,
  400.                     TAG_DONE)
  401.             { };
  402.         MUIFreeLabel1(MUIFreeLabel1 &p) : MUIText(p) { };
  403.         virtual ~MUIFreeLabel1();
  404.         MUIFreeLabel1 &operator= (MUIFreeLabel1 &);
  405.     };
  406.  
  407. class MUIFreeLabel2 : public MUIText
  408.     {
  409.     public:
  410.         MUIFreeLabel2(const STRPTR lab)
  411.             :   MUIText(
  412.                     MUIA_Text_Contents, lab,
  413.                     MUIA_Weight, 0,
  414.                     MUIA_InnerLeft, 0,
  415.                     MUIA_InnerRight, 0,
  416.                     MUIA_FramePhantomHoriz, TRUE,
  417.                     MUIA_Text_SetVMax, FALSE,
  418.                     MUIA_Frame, MUIV_Frame_String,
  419.                     MUIA_Text_PreParse, MUIX_R,
  420.                     TAG_DONE)
  421.             { };
  422.         MUIFreeLabel2(MUIFreeLabel2 &p) : MUIText(p) { };
  423.         virtual ~MUIFreeLabel2();
  424.         MUIFreeLabel2 &operator= (MUIFreeLabel2 &);
  425.     };
  426.  
  427. class MUIFreeLLabel : public MUIText
  428.     {
  429.     public:
  430.         MUIFreeLLabel(const STRPTR lab)
  431.             :   MUIText(
  432.                     MUIA_Text_Contents, lab,
  433.                     MUIA_Weight, 0,
  434.                     MUIA_InnerLeft, 0,
  435.                     MUIA_InnerRight, 0,
  436.                     MUIA_FramePhantomHoriz, TRUE,
  437.                     MUIA_Text_SetVMax, FALSE,
  438.                     TAG_DONE)
  439.             { };
  440.         MUIFreeLLabel(MUIFreeLLabel &p) : MUIText(p) { };
  441.         virtual ~MUIFreeLLabel();
  442.         MUIFreeLLabel &operator= (MUIFreeLLabel &);
  443.     };
  444.  
  445. class MUIFreeLLabel1 : public MUIText
  446.     {
  447.     public:
  448.         MUIFreeLLabel1(const STRPTR lab)
  449.             :   MUIText(
  450.                     MUIA_Text_Contents, lab,
  451.                     MUIA_Weight, 0,
  452.                     MUIA_InnerLeft, 0,
  453.                     MUIA_InnerRight, 0,
  454.                     MUIA_FramePhantomHoriz, TRUE,
  455.                     MUIA_Text_SetVMax, FALSE,
  456.                     MUIA_Frame, MUIV_Frame_Button,
  457.                     TAG_DONE)
  458.             { };
  459.         MUIFreeLLabel1(MUIFreeLLabel1 &p) : MUIText(p) { };
  460.         virtual ~MUIFreeLLabel1();
  461.         MUIFreeLLabel1 &operator= (MUIFreeLLabel1 &);
  462.     };
  463.  
  464. class MUIFreeLLabel2 : public MUIText
  465.     {
  466.     public:
  467.         MUIFreeLLabel2(const STRPTR lab)
  468.             :   MUIText(
  469.                     MUIA_Text_Contents, lab,
  470.                     MUIA_Weight, 0,
  471.                     MUIA_InnerLeft, 0,
  472.                     MUIA_InnerRight, 0,
  473.                     MUIA_FramePhantomHoriz, TRUE,
  474.                     MUIA_Text_SetVMax, FALSE,
  475.                     MUIA_Frame, MUIV_Frame_String,
  476.                     TAG_DONE)
  477.             { };
  478.         MUIFreeLLabel2(MUIFreeLLabel2 &p) : MUIText(p) { };
  479.         virtual ~MUIFreeLLabel2();
  480.         MUIFreeLLabel2 &operator= (MUIFreeLLabel2 &);
  481.     };
  482.  
  483. class MUIFreeCLabel : public MUIText
  484.     {
  485.     public:
  486.         MUIFreeCLabel(const STRPTR lab)
  487.             :   MUIText(
  488.                     MUIA_Text_Contents, lab,
  489.                     MUIA_Weight, 0,
  490.                     MUIA_InnerLeft, 0,
  491.                     MUIA_InnerRight, 0,
  492.                     MUIA_FramePhantomHoriz, TRUE,
  493.                     MUIA_Text_SetVMax, FALSE,
  494.                     MUIA_Text_PreParse, MUIX_C,
  495.                     TAG_DONE)
  496.             { };
  497.         MUIFreeCLabel(MUIFreeCLabel &p) : MUIText(p) { };
  498.         virtual ~MUIFreeCLabel();
  499.         MUIFreeCLabel &operator= (MUIFreeCLabel &);
  500.     };
  501.  
  502. class MUIFreeCLabel1 : public MUIText
  503.     {
  504.     public:
  505.         MUIFreeCLabel1(const STRPTR lab)
  506.             :   MUIText(
  507.                     MUIA_Text_Contents, lab,
  508.                     MUIA_Weight, 0,
  509.                     MUIA_InnerLeft, 0,
  510.                     MUIA_InnerRight, 0,
  511.                     MUIA_FramePhantomHoriz, TRUE,
  512.                     MUIA_Text_SetVMax, FALSE,
  513.                     MUIA_Text_PreParse, MUIX_C,
  514.                     MUIA_Frame, MUIV_Frame_Button,
  515.                     TAG_DONE)
  516.             { };
  517.         MUIFreeCLabel1(MUIFreeCLabel1 &p) : MUIText(p) { };
  518.         virtual ~MUIFreeCLabel1();
  519.         MUIFreeCLabel1 &operator= (MUIFreeCLabel1 &);
  520.     };
  521.  
  522. class MUIFreeCLabel2 : public MUIText
  523.     {
  524.     public:
  525.         MUIFreeCLabel2(const STRPTR lab)
  526.             :   MUIText(
  527.                     MUIA_Text_Contents, lab,
  528.                     MUIA_Weight, 0,
  529.                     MUIA_InnerLeft, 0,
  530.                     MUIA_InnerRight, 0,
  531.                     MUIA_FramePhantomHoriz, TRUE,
  532.                     MUIA_Text_SetVMax, FALSE,
  533.                     MUIA_Text_PreParse, MUIX_C,
  534.                     MUIA_Frame, MUIV_Frame_String,
  535.                     TAG_DONE)
  536.             { };
  537.         MUIFreeCLabel2(MUIFreeCLabel2 &p) : MUIText(p) { };
  538.         virtual ~MUIFreeCLabel2();
  539.         MUIFreeCLabel2 &operator= (MUIFreeCLabel2 &);
  540.     };
  541.  
  542. class MUIFreeKeyLabel : public MUIText
  543.     {
  544.     public:
  545.         MUIFreeKeyLabel(const STRPTR lab, const UBYTE hichar)
  546.             :   MUIText(
  547.                     MUIA_Text_Contents, lab,
  548.                     MUIA_Weight, 0,
  549.                     MUIA_InnerLeft, 0,
  550.                     MUIA_InnerRight, 0,
  551.                     MUIA_FramePhantomHoriz, TRUE,
  552.                     MUIA_Text_SetVMax, FALSE,
  553.                     MUIA_Text_HiChar, hichar,
  554.                     MUIA_Text_PreParse, MUIX_R,
  555.                     TAG_DONE)
  556.             { };
  557.         MUIFreeKeyLabel(MUIFreeKeyLabel &p) : MUIText(p) { };
  558.         virtual ~MUIFreeKeyLabel();
  559.         MUIFreeKeyLabel &operator= (MUIFreeKeyLabel &);
  560.     };
  561.  
  562. class MUIFreeKeyLabel1 : public MUIText
  563.     {
  564.     public:
  565.         MUIFreeKeyLabel1(const STRPTR lab, const UBYTE hichar)
  566.             :   MUIText(
  567.                     MUIA_Text_Contents, lab,
  568.                     MUIA_Weight, 0,
  569.                     MUIA_InnerLeft, 0,
  570.                     MUIA_InnerRight, 0,
  571.                     MUIA_FramePhantomHoriz, TRUE,
  572.                     MUIA_Text_SetVMax, FALSE,
  573.                     MUIA_Text_HiChar, hichar,
  574.                     MUIA_Frame, MUIV_Frame_Button,
  575.                     MUIA_Text_PreParse, MUIX_R,
  576.                     TAG_DONE)
  577.             { };
  578.         MUIFreeKeyLabel1(MUIFreeKeyLabel1 &p) : MUIText(p) { };
  579.         virtual ~MUIFreeKeyLabel1();
  580.         MUIFreeKeyLabel1 &operator= (MUIFreeKeyLabel1 &);
  581.     };
  582.  
  583. class MUIFreeKeyLabel2 : public MUIText
  584.     {
  585.     public:
  586.         MUIFreeKeyLabel2(const STRPTR lab, const UBYTE hichar)
  587.             :   MUIText(
  588.                     MUIA_Text_Contents, lab,
  589.                     MUIA_Weight, 0,
  590.                     MUIA_InnerLeft, 0,
  591.                     MUIA_InnerRight, 0,
  592.                     MUIA_FramePhantomHoriz, TRUE,
  593.                     MUIA_Text_SetVMax, FALSE,
  594.                     MUIA_Text_HiChar, hichar,
  595.                     MUIA_Frame, MUIV_Frame_String,
  596.                     MUIA_Text_PreParse, MUIX_R,
  597.                     TAG_DONE)
  598.             { };
  599.         MUIFreeKeyLabel2(MUIFreeKeyLabel2 &p) : MUIText(p) { };
  600.         virtual ~MUIFreeKeyLabel2();
  601.         MUIFreeKeyLabel2 &operator= (MUIFreeKeyLabel2 &);
  602.     };
  603.  
  604. class MUIFreeKeyLLabel : public MUIText
  605.     {
  606.     public:
  607.         MUIFreeKeyLLabel(const STRPTR lab, const UBYTE hichar)
  608.             :   MUIText(
  609.                     MUIA_Text_Contents, lab,
  610.                     MUIA_Weight, 0,
  611.                     MUIA_InnerLeft, 0,
  612.                     MUIA_InnerRight, 0,
  613.                     MUIA_FramePhantomHoriz, TRUE,
  614.                     MUIA_Text_SetVMax, FALSE,
  615.                     MUIA_Text_HiChar, hichar,
  616.                     TAG_DONE)
  617.             { };
  618.         MUIFreeKeyLLabel(MUIFreeKeyLLabel &p) : MUIText(p) { };
  619.         virtual ~MUIFreeKeyLLabel();
  620.         MUIFreeKeyLLabel &operator= (MUIFreeKeyLLabel &);
  621.     };
  622.  
  623. class MUIFreeKeyLLabel1 : public MUIText
  624.     {
  625.     public:
  626.         MUIFreeKeyLLabel1(const STRPTR lab, const UBYTE hichar)
  627.             :   MUIText(
  628.                     MUIA_Text_Contents, lab,
  629.                     MUIA_Weight, 0,
  630.                     MUIA_InnerLeft, 0,
  631.                     MUIA_InnerRight, 0,
  632.                     MUIA_FramePhantomHoriz, TRUE,
  633.                     MUIA_Text_SetVMax, FALSE,
  634.                     MUIA_Text_HiChar, hichar,
  635.                     MUIA_Frame, MUIV_Frame_Button,
  636.                     TAG_DONE)
  637.             { };
  638.         MUIFreeKeyLLabel1(MUIFreeKeyLLabel1 &p) : MUIText(p) { };
  639.         virtual ~MUIFreeKeyLLabel1();
  640.         MUIFreeKeyLLabel1 &operator= (MUIFreeKeyLLabel1 &);
  641.     };
  642.  
  643. class MUIFreeKeyLLabel2 : public MUIText
  644.     {
  645.     public:
  646.         MUIFreeKeyLLabel2(const STRPTR lab, const UBYTE hichar)
  647.             :   MUIText(
  648.                     MUIA_Text_Contents, lab,
  649.                     MUIA_Weight, 0,
  650.                     MUIA_InnerLeft, 0,
  651.                     MUIA_InnerRight, 0,
  652.                     MUIA_FramePhantomHoriz, TRUE,
  653.                     MUIA_Text_SetVMax, FALSE,
  654.                     MUIA_Text_HiChar, hichar,
  655.                     MUIA_Frame, MUIV_Frame_String,
  656.                     TAG_DONE)
  657.             { };
  658.         MUIFreeKeyLLabel2(MUIFreeKeyLLabel2 &p) : MUIText(p) { };
  659.         virtual ~MUIFreeKeyLLabel2();
  660.         MUIFreeKeyLLabel2 &operator= (MUIFreeKeyLLabel2 &);
  661.     };
  662.  
  663. class MUIFreeKeyCLabel : public MUIText
  664.     {
  665.     public:
  666.         MUIFreeKeyCLabel(const STRPTR lab, const UBYTE hichar)
  667.             :   MUIText(
  668.                     MUIA_Text_Contents, lab,
  669.                     MUIA_Weight, 0,
  670.                     MUIA_InnerLeft, 0,
  671.                     MUIA_InnerRight, 0,
  672.                     MUIA_FramePhantomHoriz, TRUE,
  673.                     MUIA_Text_SetVMax, FALSE,
  674.                     MUIA_Text_HiChar, hichar,
  675.                     MUIA_Text_PreParse, MUIX_C,
  676.                     TAG_DONE)
  677.             { };
  678.         MUIFreeKeyCLabel(MUIFreeKeyCLabel &p) : MUIText(p) { };
  679.         virtual ~MUIFreeKeyCLabel();
  680.         MUIFreeKeyCLabel &operator= (MUIFreeKeyCLabel &);
  681.     };
  682.  
  683. class MUIFreeKeyCLabel1 : public MUIText
  684.     {
  685.     public:
  686.         MUIFreeKeyCLabel1(const STRPTR lab, const UBYTE hichar)
  687.             :   MUIText(
  688.                     MUIA_Text_Contents, lab,
  689.                     MUIA_Weight, 0,
  690.                     MUIA_InnerLeft, 0,
  691.                     MUIA_InnerRight, 0,
  692.                     MUIA_FramePhantomHoriz, TRUE,
  693.                     MUIA_Text_SetVMax, FALSE,
  694.                     MUIA_Text_HiChar, hichar,
  695.                     MUIA_Text_PreParse, MUIX_C,
  696.                     MUIA_Frame, MUIV_Frame_Button,
  697.                     TAG_DONE)
  698.             { };
  699.         MUIFreeKeyCLabel1(MUIFreeKeyCLabel1 &p) : MUIText(p) { };
  700.         virtual ~MUIFreeKeyCLabel1();
  701.         MUIFreeKeyCLabel1 &operator= (MUIFreeKeyCLabel1 &);
  702.     };
  703.  
  704. class MUIFreeKeyCLabel2 : public MUIText
  705.     {
  706.     public:
  707.         MUIFreeKeyCLabel2(const STRPTR lab, const UBYTE hichar)
  708.             :   MUIText(
  709.                     MUIA_Text_Contents, lab,
  710.                     MUIA_Weight, 0,
  711.                     MUIA_InnerLeft, 0,
  712.                     MUIA_InnerRight, 0,
  713.                     MUIA_FramePhantomHoriz, TRUE,
  714.                     MUIA_Text_SetVMax, FALSE,
  715.                     MUIA_Text_HiChar, hichar,
  716.                     MUIA_Text_PreParse, MUIX_C,
  717.                     MUIA_Frame, MUIV_Frame_String,
  718.                     TAG_DONE)
  719.             { };
  720.         MUIFreeKeyCLabel2(MUIFreeKeyCLabel2 &p) : MUIText(p) { };
  721.         virtual ~MUIFreeKeyCLabel2();
  722.         MUIFreeKeyCLabel2 &operator= (MUIFreeKeyCLabel2 &);
  723.     };
  724.  
  725. #endif
  726.