home *** CD-ROM | disk | FTP | other *** search
/ Amiga Times / AmigaTimes.iso / demos / programme / StormC / Mui-Class-Lib / Include / Classes / TWiMUI / List.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-10-06  |  8.7 KB  |  219 lines
  1. //
  2. //  $VER: List.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_LIST_H
  23. #define CPP_TWIMUI_LIST_H
  24.  
  25. #ifndef CPP_TWIMUI_AREA_H
  26. #include <classes/twimui/area.h>
  27. #endif
  28.  
  29. #ifndef UTILITY_HOOKS_H
  30. #include <utility/hooks.h>
  31. #endif
  32.  
  33. class MUIListCompareHook
  34.     {
  35.     private:
  36.         struct Hook comparehook;
  37.         static LONG CompareHookEntry(register __a0 struct Hook *, register __a2 APTR, register __a1 APTR);
  38.         virtual LONG CompareHookFunc(struct Hook *, APTR, APTR);
  39.     protected:
  40.         MUIListCompareHook();
  41.         MUIListCompareHook(const MUIListCompareHook &p);
  42.         ~MUIListCompareHook();
  43.         MUIListCompareHook &operator= (const MUIListCompareHook &);
  44.     public:
  45.         struct Hook *compare() { return(&comparehook); };
  46.     };
  47.  
  48. class MUIListConstructHook
  49.     {
  50.     private:
  51.         struct Hook constructhook;
  52.         static APTR ConstructHookEntry(register __a0 struct Hook *, register __a2 APTR, register __a1 APTR);
  53.         virtual APTR ConstructHookFunc(struct Hook *, APTR, APTR);
  54.     protected:
  55.         MUIListConstructHook();
  56.         MUIListConstructHook(const MUIListConstructHook &p);
  57.         ~MUIListConstructHook();
  58.         MUIListConstructHook &operator= (const MUIListConstructHook &);
  59.     public:
  60.         struct Hook *construct() { return(&constructhook); };
  61.     };
  62.  
  63. class MUIListDestructHook
  64.     {
  65.     private:
  66.         struct Hook destructhook;
  67.         static void DestructHookEntry(register __a0 struct Hook *, register __a2 APTR, register __a1 APTR);
  68.         virtual void DestructHookFunc(struct Hook *, APTR, APTR);
  69.     protected:
  70.         MUIListDestructHook();
  71.         MUIListDestructHook(const MUIListDestructHook &p);
  72.         ~MUIListDestructHook();
  73.         MUIListDestructHook &operator= (const MUIListDestructHook &);
  74.     public:
  75.         struct Hook *destruct() { return(&destructhook); };
  76.     };
  77.  
  78. class MUIListDisplayHook
  79.     {
  80.     private:
  81.         struct Hook displayhook;
  82.         static void DisplayHookEntry(register __a0 struct Hook *, register __a2 STRPTR *, register __a1 APTR);
  83.         virtual void DisplayHookFunc(struct Hook *, STRPTR *, APTR);
  84.     protected:
  85.         MUIListDisplayHook();
  86.         MUIListDisplayHook(const MUIListDisplayHook &p);
  87.         ~MUIListDisplayHook();
  88.         MUIListDisplayHook &operator= (const MUIListDisplayHook &);
  89.     public:
  90.         struct Hook *display() { return(&displayhook); };
  91.     };
  92.  
  93. class MUIListMultiTestHook
  94.     {
  95.     private:
  96.         struct Hook multitesthook;
  97.         static BOOL MultiTestHookEntry(register __a0 struct Hook *, register __a1 APTR);
  98.         virtual BOOL MultiTestHookFunc(struct Hook *, APTR);
  99.     protected:
  100.         MUIListMultiTestHook();
  101.         MUIListMultiTestHook(const MUIListMultiTestHook &p);
  102.         ~MUIListMultiTestHook();
  103.         MUIListMultiTestHook &operator= (const MUIListMultiTestHook &);
  104.     public:
  105.         struct Hook *multitest() { return(&multitesthook); };
  106.     };
  107.  
  108. class MUIList
  109.     :   public MUIArea,
  110.         public MUIListCompareHook,
  111.         public MUIListConstructHook,
  112.         public MUIListDestructHook,
  113.         public MUIListDisplayHook,
  114.         public MUIListMultiTestHook
  115.     {
  116.     protected:
  117.         MUIList(STRPTR cl)
  118.             :   MUIArea(cl),
  119.                 MUIListCompareHook(),
  120.                 MUIListConstructHook(),
  121.                 MUIListDestructHook(),
  122.                 MUIListDisplayHook(),
  123.                 MUIListMultiTestHook()
  124.             { };
  125.     public:
  126.         MUIList(const struct TagItem *t)
  127.             :   MUIArea(MUIC_List),
  128.                 MUIListCompareHook(),
  129.                 MUIListConstructHook(),
  130.                 MUIListDestructHook(),
  131.                 MUIListDisplayHook(),
  132.                 MUIListMultiTestHook()
  133.             {
  134.             init(t);
  135.             };
  136.         MUIList(const Tag, ...);
  137.         MUIList()
  138.             :   MUIArea(MUIC_List),
  139.                 MUIListCompareHook(),
  140.                 MUIListConstructHook(),
  141.                 MUIListDestructHook(),
  142.                 MUIListDisplayHook(),
  143.                 MUIListMultiTestHook()
  144.             { };
  145.         MUIList(MUIList &p)
  146.             :   MUIArea(p),
  147.                 MUIListCompareHook(),
  148.                 MUIListConstructHook(),
  149.                 MUIListDestructHook(),
  150.                 MUIListDisplayHook(),
  151.                 MUIListMultiTestHook()
  152.             { };
  153.         virtual ~MUIList();
  154.         MUIList &operator= (MUIList &);
  155.         void Active(const LONG p) { set(MUIA_List_Active,(ULONG)p); };
  156.         void ActiveOff() { set(MUIA_List_Active,MUIV_List_Active_Off); };
  157.         void ActiveTop() { set(MUIA_List_Active,MUIV_List_Active_Top); };
  158.         void ActiveBottom() { set(MUIA_List_Active,MUIV_List_Active_Bottom); };
  159.         void ActiveUp() { set(MUIA_List_Active,MUIV_List_Active_Up); };
  160.         void ActiveDown() { set(MUIA_List_Active,MUIV_List_Active_Down); };
  161.         void ActivePageUp() { set(MUIA_List_Active,MUIV_List_Active_PageUp); };
  162.         void ActivePageDown() { set(MUIA_List_Active,MUIV_List_Active_PageDown); };
  163.         LONG Active() const { return((LONG)get(MUIA_List_Active,MUIV_List_Active_Off)); };
  164.         void AutoVisible(const BOOL p) { set(MUIA_List_AutoVisible,(ULONG)p); };
  165.         BOOL AutoVisible() const { return((BOOL)get(MUIA_List_AutoVisible,FALSE)); };
  166.         void CompareHook(const struct Hook *p) { set(MUIA_List_CompareHook,(ULONG)p); };
  167.         void ConstructHook(const struct Hook *p) { set(MUIA_List_ConstructHook,(ULONG)p); };
  168.         void ConstructHookString() { set(MUIA_List_ConstructHook,MUIV_List_ConstructHook_String); };
  169.         void DestructHook(const struct Hook *p) { set(MUIA_List_DestructHook,(ULONG)p); };
  170.         void DestructHookString() { set(MUIA_List_DestructHook,MUIV_List_DestructHook_String); };
  171.         void DisplayHook(const struct Hook *p) { set(MUIA_List_DisplayHook,(ULONG)p); };
  172.         void DragSortable(const BOOL p) { set(MUIA_List_DragSortable,(ULONG)p); };
  173.         BOOL DragSortable() const { return((BOOL)get(MUIA_List_DragSortable,FALSE)); };
  174.         LONG DropMark() const { return((LONG)get(MUIA_List_DropMark,0L)); };
  175.         LONG Entries() const { return((LONG)get(MUIA_List_Entries,0L)); };
  176.         LONG First() const { return((LONG)get(MUIA_List_First,0L)); };
  177.         void Format(const STRPTR p) { set(MUIA_List_Format,(ULONG)p); };
  178.         STRPTR Format() const { return((STRPTR)get(MUIA_List_Format,NULL)); };
  179.         LONG InsertPosition() const { return((LONG)get(MUIA_List_InsertPosition,0L)); };
  180.         void MultiTestHook(const struct Hook *p) { set(MUIA_List_MultiTestHook,(ULONG)p); };
  181.         void Quiet(const BOOL p) { set(MUIA_List_Quiet,(ULONG)p); };
  182.         void ShowDropMarks(const BOOL p) { set(MUIA_List_ShowDropMarks,(ULONG)p); };
  183.         BOOL ShowDropMarks() const { return((BOOL)get(MUIA_List_ShowDropMarks,FALSE)); };
  184.         void Title(const STRPTR p) { set(MUIA_List_Title,(ULONG)p); };
  185.         STRPTR Title() const { return((STRPTR)get(MUIA_List_Title,NULL)); };
  186.         LONG Vivible() const { return((LONG)get(MUIA_List_Visible,0L)); };
  187.         void Clear() { dom(MUIM_List_Clear); };
  188.         APTR CreateImage(Object *p1, ULONG p2) { return((APTR)dom(MUIM_List_CreateImage,(ULONG)p1,(ULONG)p2)); };
  189.         void DeleteImage(APTR p) { dom(MUIM_List_DeleteImage,(ULONG)p); };
  190.         void Exchange(LONG p1, LONG p2) { dom(MUIM_List_Exchange,(ULONG)p1,(ULONG)p2); };
  191.         APTR GetEntry(LONG p) { APTR t; dom(MUIM_List_GetEntry,(ULONG)p,(ULONG)&t); return(t); };
  192.         APTR GetEntryActive() { APTR t; dom(MUIM_List_GetEntry,MUIV_List_GetEntry_Active,(ULONG)&t); return(t); };
  193.         void Insert(APTR *p1, LONG p2, LONG p3) { dom(MUIM_List_Insert,(ULONG)p1,(ULONG)p2,(ULONG)p3); };
  194.         void InsertTop(APTR *p1, LONG p2) { dom(MUIM_List_Insert,(ULONG)p1,(ULONG)p2,MUIV_List_Insert_Top); };
  195.         void InsertActive(APTR *p1, LONG p2) { dom(MUIM_List_Insert,(ULONG)p1,(ULONG)p2,MUIV_List_Insert_Active); };
  196.         void InsertSorted(APTR *p1, LONG p2) { dom(MUIM_List_Insert,(ULONG)p1,(ULONG)p2,MUIV_List_Insert_Sorted); };
  197.         void InsertBottom(APTR *p1, LONG p2) { dom(MUIM_List_Insert,(ULONG)p1,(ULONG)p2,MUIV_List_Insert_Bottom); };
  198.         void InsertSingle(APTR p1, LONG p2) { dom(MUIM_List_InsertSingle,(ULONG)p1,(ULONG)p2); };
  199. //      void InsertSingleTop(APTR p) { dom(MUIM_List_InsertSingle,(ULONG)p,MUIV_List_InsertSingle_Top); };
  200. //      void InsertSingleActive(APTR p) { dom(MUIM_List_InsertSingle,(ULONG)p,MUIV_List_InsertSingle_Active); };
  201. //      void InsertSingleSorted(APTR p) { dom(MUIM_List_InsertSingle,(ULONG)p,MUIV_List_InsertSingle_Sorted); };
  202. //      void InsertSingleBottom(APTR p) { dom(MUIM_List_InsertSingle,(ULONG)p,MUIV_List_InsertSingle_Bottom); };
  203.         void Jump(LONG p) { dom(MUIM_List_Jump,(ULONG)p); };
  204.         void Move(LONG p1, LONG p2) { dom(MUIM_List_Move,(ULONG)p1,(ULONG)p2); };
  205.         void NextSelected(LONG *p) { dom(MUIM_List_NextSelected,(ULONG)p); };
  206.         void Redraw(LONG p) { dom(MUIM_List_Redraw,(ULONG)p); };
  207.         void RedrawActive() { dom(MUIM_List_Redraw,MUIV_List_Redraw_Active); };
  208.         void RedrawAll() { dom(MUIM_List_Redraw,MUIV_List_Redraw_All); };
  209.         void Remove(LONG p) { dom(MUIM_List_Remove,(ULONG)p); };
  210.         void RemoveFirst() { dom(MUIM_List_Remove,MUIV_List_Remove_First); };
  211.         void RemoveActive() { dom(MUIM_List_Remove,MUIV_List_Remove_Active); };
  212.         void RemoveLast() { dom(MUIM_List_Remove,MUIV_List_Remove_Last); };
  213.         void Select(LONG p1, LONG p2, LONG *p3) { dom(MUIM_List_Select,(ULONG)p1,(ULONG)p2,(ULONG)p3); };
  214.         void Sort() { dom(MUIM_List_Sort); };
  215.         void TestPos(LONG p1, LONG p2, struct MUI_List_TestPos_Result *p3) { dom(MUIM_List_TestPos,(ULONG)p1,(ULONG)p2,(ULONG)p3); };
  216.     };
  217.  
  218. #endif
  219.