home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1997 #3 / amigaacscoverdisc / utilities / commercialdemos / stormwizard-demo2.0 / example-source / c / manager / manager.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-01-20  |  19.7 KB  |  657 lines
  1. #include    <stdio.h>
  2. #include    <stdlib.h>
  3. #include    <string.h>
  4.  
  5. #include    <clib/alib_protos.h>
  6. #include    <pragma/dos_lib.h>
  7. #include    <pragma/exec_lib.h>
  8. #include    <pragma/intuition_lib.h>
  9. #include    <pragma/utility_lib.h>
  10. #include    <pragma/wizard_lib.h>
  11.  
  12. #include    <exec/exec.h>
  13. #include    <exec/memory.h>
  14. #include    <intuition/gadgetclass.h>
  15. #include    <intuition/intuition.h>
  16. #include    <utility/utility.h>
  17. #include    <libraries/wizard.h>
  18.  
  19. #include    "manager.h"
  20.  
  21. struct Library *UtilityBase;
  22. struct Library *WizardBase;
  23.  
  24. APTR    MySurface;
  25. struct Screen *MyScreen;
  26.  
  27. struct Gadget *MyGadgets[WINDOW_GADGETS];
  28. struct WizardWindowHandle *MyWinHandle;
  29. struct Window *MyWindow;
  30.  
  31. struct MyWinExtension
  32. {
  33. };
  34.  
  35. /* Diese Struktur wird für dann beim SF_AllocWindowHandle angelegt        **
  36. ** und im Feld UserData eingetragen !  Wenn die Größe allerdings            **
  37. ** NULL ist, dann darf dieser Zeiger nicht benutzt werden     !!!                **
  38. ** Sie könnten zum Beispiel eine Node-Struktur einbauen und damit     **
  39. ** ihre Fensterhandles verketten.                                                                            */
  40.  
  41. #define DIRTYPE        0
  42. #define FILETYPE    1
  43.  
  44. struct MyListNode
  45. {
  46.     struct WizardDefaultNode WNode;
  47.     struct WizardNodeEntry Entry2;
  48.  
  49.     int Type;
  50.     char FileName[256];
  51.  
  52.     STRPTR    Format;
  53.     ULONG        FileSize;
  54.  
  55. };
  56. /* Diese Liste beinhaltet alle wichtigen Daten für einen Eintrag und    **
  57. ** besitzt gleichzeitig die WizardListNode, die von den ListView`s         **
  58. ** bzw. in unserem Fall den MultiListViews verlangt wird.                            */
  59.  
  60. struct MinList DummyList;
  61. struct MinList LeftList;
  62. struct MinList RightList;
  63.  
  64. struct MinList *QuellList;
  65. struct MinList *ZielList;
  66.  
  67. struct Gadget *QuellGadget;
  68. struct Gadget *ZielGadget;
  69.  
  70. struct Gadget *QuellStringGadget;
  71. struct Gadget *ZielStringGadget;
  72.  
  73. struct Gadget    *QuellToggleGadget;
  74. struct Gadget *ZielToggleGadget;
  75.  
  76. unsigned long QuellAnzeigeWert,ZielAnzeigeWert;
  77.  
  78. char QString[256];
  79. char ZString[256];
  80.  
  81. char *QuellAnzeige=QString;
  82. char *ZielAnzeige=ZString;
  83.  
  84. struct FileInfoBlock fib;
  85.  
  86.  
  87. /* Picture Daten */
  88.  
  89. struct WizardNewImage *newimage;
  90.  
  91. struct BitMap *bm,*sbm;
  92. UBYTE Pens[256],SPens[256];
  93.  
  94. void ReadDirectoryList(STRPTR device,BOOL newKopf)
  95. {
  96.     BPTR mylock;
  97.  
  98.     WZ_LockWindow(MyWinHandle);
  99.  
  100.     if (mylock=Lock(device,SHARED_LOCK))
  101.     {
  102.         if (Examine(mylock,&fib))
  103.         {
  104.             QuellAnzeigeWert=0;
  105.  
  106.             if (newKopf)
  107.                 sprintf(QuellAnzeige,"%s: ( %ldk )",&fib.fib_FileName,fib.fib_Size>>10);
  108.  
  109.             SetGadgetAttrs(QuellGadget,MyWindow,0L,
  110.                                                                             WLISTVIEWA_List,&DummyList,
  111.                                                                             WLISTVIEWA_Top,0,
  112.                                                                             TAG_DONE);
  113.  
  114.  
  115.             while (QuellList->mlh_Head->mln_Succ)
  116.             {
  117.                 struct MinNode *t=QuellList->mlh_Head;
  118.  
  119.                 Remove((struct Node *)t);
  120.                 FreeVec(t);
  121.             }; /* die alte geschichte löschen */
  122.  
  123.  
  124.             while (ExNext(mylock,&fib))
  125.             {
  126.                 struct MyListNode *NewNode;
  127.  
  128.                 if (NewNode=AllocVec(sizeof(MyListNode),MEMF_CLEAR|MEMF_PUBLIC))
  129.                 {
  130.                     BOOL    Ready=FALSE;
  131.  
  132.                     struct MyListNode *PredNode=(struct MyListNode *)QuellList->mlh_Head;
  133.  
  134.                     strcpy(NewNode->FileName,fib.fib_FileName);
  135.  
  136.                     WZ_InitNode(&NewNode->WNode.WizardNode,2,TAG_DONE);
  137.  
  138.                     if (fib.fib_DirEntryType>=0)
  139.                     {
  140.                         NewNode->FileSize=0;
  141.                         NewNode->Type=DIRTYPE;
  142.  
  143.                         WZ_InitNodeEntry(&NewNode->WNode.WizardNode,0,WENTRYA_Type,WNE_TEXT,
  144.                                                                                             WENTRYA_TextPen,WZRD_HIGHLIGHTTEXTPEN,
  145.                                                                                             WENTRYA_TextSPen,WZRD_HIGHLIGHTTEXTPEN,
  146.                                                                                             WENTRYA_TextStyle,FS_NORMAL,
  147.                                                                                             WENTRYA_TextSStyle,FS_NORMAL,
  148.                                                                                             WENTRYA_TextString,NewNode->FileName,
  149.                                                                                             TAG_DONE);
  150.                         WZ_InitNodeEntry(&NewNode->WNode.WizardNode,1,WENTRYA_Type,WNE_IMAGE,
  151.                                                                                             WENTRYA_ImageBitmap,bm,
  152.                                                                                             WENTRYA_ImageSBitmap,sbm,
  153.                                                                                             WENTRYA_ImageWidth,newimage->Width,
  154.                                                                                             WENTRYA_ImageHeight,newimage->Height,
  155.                                                                                             TAG_DONE);
  156.  
  157.  
  158.                     }
  159.                     else
  160.                     {
  161.                         NewNode->FileSize=fib.fib_Size;
  162.                         NewNode->Type=FILETYPE;
  163.  
  164.                         NewNode->Format="%ld";
  165.  
  166.                         WZ_InitNodeEntry(&NewNode->WNode.WizardNode,0,WENTRYA_Type,WNE_TEXT,
  167.                                                                                             WENTRYA_TextPen,WZRD_TEXTPEN,
  168.                                                                                             WENTRYA_TextSPen,WZRD_FILLTEXTPEN,
  169.                                                                                             WENTRYA_TextStyle,FS_NORMAL,
  170.                                                                                             WENTRYA_TextSStyle,FS_NORMAL,
  171.                                                                                             WENTRYA_TextString,NewNode->FileName,
  172.                                                                                             TAG_DONE);
  173.  
  174.                         WZ_InitNodeEntry(&NewNode->WNode.WizardNode,1,WENTRYA_Type,WNE_FORMAT,
  175.                                                                                             WENTRYA_FormatStruct,&NewNode->Format,
  176.                                                                                             WENTRYA_FormatJustification,WZRDPLACE_RIGHT,
  177.                                                                                             TAG_DONE);
  178.  
  179.                     };
  180.  
  181.                     while (!Ready && PredNode->WNode.WizardNode.Node.mln_Succ)
  182.                     {
  183.                         if (NewNode->Type>=PredNode->Type)
  184.                         {
  185.                             if (NewNode->Type==PredNode->Type)
  186.                             {
  187.                                 if (Stricmp(NewNode->FileName,PredNode->FileName)<0)
  188.                                 {
  189.                                     PredNode=(struct MyListNode *)PredNode->WNode.WizardNode.Node.mln_Pred    ;
  190.                                     Ready=TRUE;
  191.                                 }
  192.                                 else
  193.                                     PredNode=(struct MyListNode *)PredNode->WNode.WizardNode.Node.mln_Succ;
  194.                             }
  195.                             else
  196.                                 PredNode=(struct MyListNode *)PredNode->WNode.WizardNode.Node.mln_Succ;
  197.                         }
  198.                         else
  199.                         {
  200.                             PredNode=(struct MyListNode *)PredNode->WNode.WizardNode.Node.mln_Pred;
  201.                             Ready=TRUE;
  202.                         }
  203.                     };
  204.  
  205.                     Insert((struct List *)QuellList,(struct Node *)NewNode,(struct Node *)PredNode);
  206.  
  207.                 }
  208.             };
  209.  
  210.             SetGadgetAttrs(QuellGadget,MyWindow,0L,WLISTVIEWA_List,QuellList,
  211.                                                                                         WLISTVIEWA_Columns,2,
  212.                                                                                         WLISTVIEWA_Top,0,
  213.                                                                                         TAG_DONE);
  214.         }
  215.  
  216.         if (newKopf)
  217.             SetGadgetAttrs(QuellToggleGadget,MyWindow,0L,WTOGGLEA_Label,QuellAnzeige,
  218.                                                                             TAG_DONE);
  219.  
  220.         SetGadgetAttrs(QuellStringGadget,MyWindow,0L,WSTRINGA_String,device,
  221.                                                                             TAG_DONE);
  222.  
  223.         SetGadgetAttrs(MyGadgets[86],MyWindow,0L,WARGSA_Arg0,0,TAG_DONE);
  224.  
  225.         UnLock(mylock);
  226.     }
  227.     WZ_UnlockWindow(MyWinHandle);
  228. }
  229.  
  230.  
  231. void GoToDir(STRPTR addpath)
  232. {
  233.     char *Dir;
  234.     char NewDir[256];
  235.  
  236.     if (GetAttr(WSTRINGA_String,QuellStringGadget,(ULONG *)&Dir))
  237.     {
  238.         strcpy(NewDir,Dir);
  239.         AddPart(NewDir,addpath,256);
  240.  
  241.         ReadDirectoryList(NewDir,FALSE);
  242.     }
  243.  
  244. }
  245.  
  246. struct WizardDefaultNode    MyHeaderNode;
  247.  
  248. /* Main - Programm */
  249.  
  250. main()
  251. {
  252.     struct NewWindow *MyNewWindow;
  253.  
  254.     struct IntuiMessage *msg;
  255.  
  256.     ULONG MsgClass;
  257.     UWORD MsgGadgetID;
  258.  
  259.     APTR    GadgetHelpIAddress;
  260.     struct WizardWindowHandle *GadgetHelpWinHandle;
  261.  
  262.     struct DateStamp MyDateStamp;
  263.     struct ClockData MyClockData;
  264.  
  265.     ULONG FreeChip;
  266.     ULONG FreeFast;
  267.  
  268.     NewList((struct List *)&LeftList);
  269.     NewList((struct List *)&RightList);
  270.     NewList((struct List *)&DummyList);
  271.  
  272.     if (UtilityBase=OpenLibrary("utility.library",0L))
  273.     {
  274.         if (WizardBase=OpenLibrary("wizard.library",0L))
  275.         {
  276.             if (MyScreen=LockPubScreen(0L))
  277.             {
  278.                 if (MySurface=WZ_OpenSurface("manager.wizard",0L,TAG_DONE))
  279.                 {
  280.                         if (MyWinHandle=WZ_AllocWindowHandle(MyScreen,
  281.                                                                                                 sizeof(MyWinExtension),
  282.                                                                                                 MySurface,TAG_DONE))
  283.                         {
  284.                             if (MyNewWindow=WZ_CreateWindowObj(MyWinHandle,WINDOW,WWH_GadgetArray,MyGadgets,
  285.                                                                                                                                 WWH_GadgetArraySize,sizeof(MyGadgets),
  286.                                                                                                                                 TAG_DONE))
  287.                             {
  288.                                 QuellList=&LeftList;
  289.                                 ZielList=&RightList;
  290.  
  291.                                 FreeChip=AvailMem(MEMF_CHIP)>>10;
  292.                                 FreeFast=AvailMem(MEMF_FAST)>>10;
  293.  
  294.                                 DateStamp(&MyDateStamp);
  295.                                 Amiga2Date(MyDateStamp.ds_Days*24*3600+MyDateStamp.ds_Minute*60+MyDateStamp.ds_Tick/50,&MyClockData);
  296.  
  297.                                 SetGadgetAttrs(MyGadgets[StatusID],0L,0L,WARGSA_Arg0,FreeChip,
  298.                                                                             WARGSA_Arg1,FreeFast,
  299.                                                                             WARGSA_Arg2,FreeChip+FreeFast,
  300.                                                                             WARGSA_Arg3,MyClockData.mday,
  301.                                                                             WARGSA_Arg4,MyClockData.month,
  302.                                                                             WARGSA_Arg5,MyClockData.year,
  303.                                                                             WARGSA_Arg6,MyClockData.hour,
  304.                                                                             WARGSA_Arg7,MyClockData.min,
  305.                                                                             WARGSA_Arg8,MyClockData.sec,
  306.                                                                             TAG_DONE);
  307.                                 SetGadgetAttrs(MyGadgets[LViewID],0L,0L,WLISTVIEWA_List,QuellList,
  308.                                                                                         TAG_DONE);
  309.                                 SetGadgetAttrs(MyGadgets[RViewID],0L,0L,WLISTVIEWA_List,ZielList,
  310.                                                                                         TAG_DONE);
  311.  
  312.                                 QuellGadget=MyGadgets[LViewID];
  313.                                 ZielGadget=MyGadgets[RViewID];
  314.  
  315.                                 QuellStringGadget=MyGadgets[LStringID];
  316.                                 ZielStringGadget=MyGadgets[RStringID];
  317.  
  318.                                 QuellToggleGadget=MyGadgets[LToggleID];
  319.                                 ZielToggleGadget=MyGadgets[RToggleID];
  320.  
  321.                                 MyNewWindow->LeftEdge=0;
  322.                                 MyNewWindow->TopEdge=MyScreen->BarHeight;
  323.                                 MyNewWindow->Width=MyScreen->Width;
  324.                                 MyNewWindow->Height=MyScreen->Height-MyScreen->BarHeight;
  325.  
  326.  
  327.                                 if ((newimage=(struct WizardNewImage *)WZ_GetDataAddress(MySurface,WDATA_IMAGE,IMAGE_WIZARD)))
  328.                                 {
  329.                                     if ((bm=WZ_CreateImageBitMap(0,MyWinHandle->DrawInfo,newimage,MyScreen,Pens)))
  330.                                     {
  331.                                         if ((sbm=WZ_CreateImageBitMap(WZRD_FILLPEN,MyWinHandle->DrawInfo,newimage,MyScreen,SPens)))
  332.                                         {
  333.  
  334.                                             if (MyWindow=WZ_OpenWindow(MyWinHandle,MyNewWindow,WA_AutoAdjust ,TRUE,
  335.                                                                                                                                                 WA_MenuHelp,TRUE,
  336.                                                                                                                                                 TAG_DONE))
  337.                                             {
  338.                                                 MyWindow->UserData=(BYTE *)MyWinHandle;
  339.                                                 /* Wir wollen es uns schliesslich einfach machen oder ? */
  340.  
  341.                                                 HelpControl(MyWindow,HC_GADGETHELP);
  342.  
  343.                                                 do
  344.                                                 {
  345.                                                     WaitPort(MyWindow->UserPort); /* Auf CloseWindow warten*/
  346.  
  347.                                                     if (msg=(struct IntuiMessage *)GetMsg(MyWindow->UserPort))
  348.                                                     {
  349.                                                         MsgClass=msg->Class;
  350.  
  351.                                                         switch (MsgClass)
  352.                                                         {
  353.                                                             case IDCMP_IDCMPUPDATE:
  354.                                                                 switch (MsgGadgetID=GetTagData(GA_ID,0,(struct TagItem *)msg->IAddress))
  355.                                                                 {
  356.                                                                     unsigned long TWert;
  357.                                                                     struct MyListNode *SelNode;
  358.  
  359.                                                                     case 30:        /* die ganzen Laufwerksknöpfe */
  360.                                                                     case 31:
  361.                                                                     case 32:
  362.                                                                     case 33:
  363.                                                                     case 34:
  364.                                                                     case 35:
  365.                                                                     case 36:
  366.                                                                     case 37:
  367.                                                                     case 38:
  368.                                                                     case 39:
  369.                                                                     case 40:
  370.                                                                         ReadDirectoryList(WZ_GadgetConfig(MyWinHandle,MyGadgets[MsgGadgetID]),TRUE);
  371.                                                                         break;
  372.  
  373.                                                                     case LToggleID:              /* linkes Toggle */
  374.                                                                         {
  375.                                                                             STRPTR s;
  376.                                                                             GetAttr(WSTRINGA_String,MyGadgets[LToggleID],(ULONG *) &s);
  377.                                                                         }
  378.                                                                         TWert=ZielAnzeigeWert;
  379.                                                                         ZielAnzeigeWert=QuellAnzeigeWert;
  380.                                                                         QuellAnzeigeWert=TWert;
  381.  
  382.                                                                         QuellList=&LeftList;
  383.                                                                         ZielList=&RightList;
  384.  
  385.                                                                         QuellGadget=MyGadgets[LViewID];
  386.                                                                         ZielGadget=MyGadgets[RViewID];
  387.  
  388.                                                                         QuellStringGadget=MyGadgets[LStringID];
  389.                                                                         ZielStringGadget=MyGadgets[RStringID];
  390.  
  391.                                                                         QuellToggleGadget=MyGadgets[LToggleID];
  392.                                                                         ZielToggleGadget=MyGadgets[RToggleID];
  393.  
  394.                                                                         QuellAnzeige=QString;
  395.                                                                         ZielAnzeige=ZString;
  396.  
  397.                                                                         SetGadgetAttrs(MyGadgets[86],MyWindow,0L,
  398.                                                                             WARGSA_Arg0,QuellAnzeigeWert,TAG_DONE);
  399.                                                                         break;
  400.  
  401.                                                                     case RToggleID:                        /* rechtes Toogle */
  402.                                                                         TWert=ZielAnzeigeWert;
  403.                                                                         ZielAnzeigeWert=QuellAnzeigeWert;
  404.                                                                         QuellAnzeigeWert=TWert;
  405.  
  406.                                                                         ZielList=&LeftList;
  407.                                                                         QuellList=&RightList;
  408.  
  409.                                                                         ZielGadget=MyGadgets[LViewID];
  410.                                                                         QuellGadget=MyGadgets[RViewID];
  411.  
  412.                                                                         ZielStringGadget=MyGadgets[LStringID];
  413.                                                                         QuellStringGadget=MyGadgets[RStringID];
  414.  
  415.                                                                         ZielToggleGadget=MyGadgets[LToggleID];
  416.                                                                         QuellToggleGadget=MyGadgets[RToggleID];
  417.  
  418.                                                                         ZielAnzeige=QString;
  419.                                                                         QuellAnzeige=ZString;
  420.  
  421.                                                                         SetGadgetAttrs(MyGadgets[AnzeigeID],MyWindow,0L,
  422.                                                                             WARGSA_Arg0,QuellAnzeigeWert,TAG_DONE);
  423.                                                                         break;
  424.  
  425.                                                                     case LViewID:                                        /* linkes MultiView */
  426.                                                                         if (QuellList!=&LeftList)
  427.                                                                         {
  428.                                                                             TWert=ZielAnzeigeWert;
  429.                                                                             ZielAnzeigeWert=QuellAnzeigeWert;
  430.                                                                             QuellAnzeigeWert=TWert;
  431.  
  432.                                                                             QuellList=&LeftList;
  433.                                                                             ZielList=&RightList;
  434.  
  435.                                                                             QuellGadget=MyGadgets[LViewID];
  436.                                                                             ZielGadget=MyGadgets[RViewID];
  437.  
  438.                                                                             QuellStringGadget=MyGadgets[LStringID];
  439.                                                                             ZielStringGadget=MyGadgets[RStringID];
  440.  
  441.                                                                             QuellToggleGadget=MyGadgets[LToggleID];
  442.                                                                             ZielToggleGadget=MyGadgets[RToggleID];
  443.  
  444.                                                                             QuellAnzeige=QString;
  445.                                                                             ZielAnzeige=ZString;
  446.  
  447.                                                                             SetGadgetAttrs(QuellToggleGadget,MyWindow,0L,
  448.                                                                                 WTOGGLEA_Checked,TRUE,TAG_DONE);
  449.  
  450.                                                                             SetGadgetAttrs(ZielToggleGadget,MyWindow,0L,
  451.                                                                                 WTOGGLEA_Checked,FALSE,TAG_DONE);
  452.  
  453.                                                                             SetGadgetAttrs(MyGadgets[AnzeigeID],MyWindow,0L,
  454.                                                                                 WARGSA_Arg0,QuellAnzeigeWert,TAG_DONE);
  455.                                                                         }
  456.  
  457.                                                                         SelNode=(struct MyListNode *)
  458.                                                                             WZ_GetNode(QuellList,GetTagData(WLISTVIEWA_Selected,0,msg->IAddress));
  459.  
  460.                                                                         if (!GetTagData(WLISTVIEWA_DoubleClick,FALSE,msg->IAddress))
  461.                                                                         {
  462.                                                                             if (SelNode->Type==FILETYPE)
  463.                                                                             {
  464.                                                                                 if (SelNode->WNode.WizardNode.Flags&WNF_SELECTED)
  465.                                                                                     QuellAnzeigeWert+=SelNode->FileSize;
  466.                                                                                 else
  467.                                                                                     QuellAnzeigeWert-=SelNode->FileSize;
  468.  
  469.                                                                                     SetGadgetAttrs(MyGadgets[AnzeigeID],MyWindow,0L,
  470.                                                                                         WARGSA_Arg0,QuellAnzeigeWert,TAG_DONE);
  471.                                                                             }
  472.                                                                         }
  473.                                                                         else
  474.                                                                             if (SelNode->Type==DIRTYPE)
  475.                                                                                 GoToDir(SelNode->FileName);
  476.  
  477.                                                                         break;
  478.  
  479.                                                                     case RViewID:                                    /*rechtes MultiView */
  480.                                                                         if (QuellList!=&RightList)
  481.                                                                         {
  482.                                                                             TWert=ZielAnzeigeWert;
  483.                                                                             ZielAnzeigeWert=QuellAnzeigeWert;
  484.                                                                             QuellAnzeigeWert=TWert;
  485.  
  486.                                                                             ZielList=&LeftList;
  487.                                                                             QuellList=&RightList;
  488.  
  489.                                                                             ZielGadget=MyGadgets[LViewID];
  490.                                                                             QuellGadget=MyGadgets[RViewID];
  491.  
  492.                                                                             ZielStringGadget=MyGadgets[LStringID];
  493.                                                                             QuellStringGadget=MyGadgets[RStringID];
  494.  
  495.                                                                             ZielToggleGadget=MyGadgets[LToggleID];
  496.                                                                             QuellToggleGadget=MyGadgets[RToggleID];
  497.  
  498.                                                                             ZielAnzeige=QString;
  499.                                                                             QuellAnzeige=ZString;
  500.  
  501.                                                                             SetGadgetAttrs(QuellToggleGadget,MyWindow,0L,WTOGGLEA_Checked,TRUE,
  502.                                                                                                                                                     TAG_DONE);
  503.                                                                             SetGadgetAttrs(ZielToggleGadget,MyWindow,0L,WTOGGLEA_Checked,FALSE,
  504.                                                                                                                                                     TAG_DONE);
  505.                                                                             SetGadgetAttrs(MyGadgets[AnzeigeID],MyWindow,0L,
  506.                                                                                 WARGSA_Arg0,QuellAnzeigeWert,TAG_DONE);
  507.                                                                         }
  508.  
  509.                                                                         SelNode=(struct MyListNode *)
  510.                                                                             WZ_GetNode(QuellList,GetTagData(WLISTVIEWA_Selected,0,msg->IAddress));
  511.  
  512.                                                                         if (!GetTagData(WLISTVIEWA_DoubleClick,FALSE,msg->IAddress))
  513.                                                                         {
  514.                                                                             if (SelNode->Type==FILETYPE)
  515.                                                                             {
  516.                                                                                 if (SelNode->WNode.WizardNode.Flags&WNF_SELECTED)
  517.                                                                                     QuellAnzeigeWert+=SelNode->FileSize;
  518.                                                                                 else
  519.                                                                                     QuellAnzeigeWert-=SelNode->FileSize;
  520.  
  521.                                                                                     SetGadgetAttrs(MyGadgets[AnzeigeID],MyWindow,0L,
  522.                                                                                         WARGSA_Arg0,QuellAnzeigeWert,TAG_DONE);
  523.                                                                             }
  524.                                                                         }
  525.                                                                         else
  526.                                                                             if (SelNode->Type==DIRTYPE)
  527.                                                                                 GoToDir(SelNode->FileName);
  528.  
  529.                                                                         break;
  530.  
  531.                                                                     case ParentID:
  532.                                                                         {
  533.                                                                             char NewDir[256],*Dir;
  534.  
  535.                                                                             if (GetAttr(WSTRINGA_String,QuellStringGadget,(ULONG *)&Dir))
  536.                                                                                 {
  537.                                                                                     strcpy(NewDir,Dir);
  538.  
  539.                                                                                     *(PathPart(NewDir))=0;
  540.                                                                                     ReadDirectoryList(NewDir,FALSE);
  541.  
  542.                                                                                     WZ_InitNode((struct WizardNode *)&MyHeaderNode,1,TAG_DONE);
  543.                                                                                     WZ_InitNodeEntry((struct WizardNode *)&MyHeaderNode,0,
  544.                                                                                             WENTRYA_Type,WNE_TEXT,
  545.                                                                                             WENTRYA_TextString,"Das ist der Header",
  546.                                                                                             TAG_DONE);
  547.                                                                                     SetGadgetAttrs(MyGadgets[LViewID],MyWindow,0,
  548.                                                                                             WLISTVIEWA_HeaderNode,&MyHeaderNode,
  549.                                                                                             TAG_DONE);
  550.                                                                                 }
  551.                                                                         }
  552.                                                                         break
  553.                                                                 }
  554.                                                                 break;
  555.  
  556.                                                             case IDCMP_MENUPICK:
  557.  
  558.                                                                 switch(msg->Code)
  559.                                                                 {
  560.                                                                     case FULLMENUNUM(0,0,-1):
  561.                                                                         {
  562.                                                                             ULONG Dummy;
  563.  
  564.                                                                             WZ_LockWindow(MyWinHandle);
  565.  
  566.                                                                             WZ_EasyRequestArgs(MySurface,MyWindow,REQ_ABOUT,&Dummy);
  567.  
  568.                                                                             WZ_UnlockWindow(MyWinHandle);
  569.                                                                         }
  570.                                                                         break;
  571.  
  572.                                                                     case FULLMENUNUM(0,2,-1):
  573.                                                                         MsgClass=IDCMP_CLOSEWINDOW;
  574.                                                                         break;
  575.                                                                 }
  576.                                                                 break;
  577.  
  578.                                                             case IDCMP_MENUHELP :
  579.                                                                 SetWindowTitles(MyWindow,WZ_MenuHelp(MyWinHandle,msg->Code),(char *)-1L);
  580.                                                                 Delay(50L);
  581.                                                                 break;
  582.  
  583.                                                             case IDCMP_GADGETHELP:
  584.                                                                 if (msg->IAddress)
  585.                                                                 {
  586.                                                                         SetWindowTitles(MyWindow,WZ_GadgetHelp(MyWinHandle,msg->IAddress),(char *)-1L);
  587.                                                                 }
  588.                                                                 break;
  589.                                                             case IDCMP_MOUSEMOVE:
  590.                                                                 /* Falls wir unter 2.0 oder 2.1 laufen !!! */
  591.                                                                 if (WZ_GadgetHelpMsg(MyWinHandle,&GadgetHelpWinHandle,&GadgetHelpIAddress,msg->MouseX,msg->MouseY,0))
  592.                                                                     {
  593.                                                                         SetWindowTitles(MyWindow,WZ_GadgetHelp(GadgetHelpWinHandle,GadgetHelpIAddress),(char *)-1L);
  594.                                                                     }
  595.                                                                 break;
  596.                                                             case IDCMP_INTUITICKS:
  597.  
  598.                                                                         FreeChip=AvailMem(MEMF_CHIP)>>10;
  599.                                                                         FreeFast=AvailMem(MEMF_FAST)>>10;
  600.  
  601.                                                                         DateStamp(&MyDateStamp);
  602.                                                                         Amiga2Date(MyDateStamp.ds_Days*24*3600+MyDateStamp.ds_Minute*60+(MyDateStamp.ds_Tick/50),&MyClockData);
  603.  
  604.                                                                         SetGadgetAttrs(MyGadgets[StatusID],MyWindow,0L,
  605.                                                                                         WARGSA_Arg0,FreeChip,
  606.                                                                                         WARGSA_Arg1,FreeFast,
  607.                                                                                         WARGSA_Arg2,FreeChip+FreeFast,
  608.                                                                                         WARGSA_Arg3,MyClockData.mday,
  609.                                                                                         WARGSA_Arg4,MyClockData.month,
  610.                                                                                         WARGSA_Arg5,MyClockData.year,
  611.                                                                                         WARGSA_Arg6,MyClockData.hour,
  612.                                                                                         WARGSA_Arg7,MyClockData.min,
  613.                                                                                         WARGSA_Arg8,MyClockData.sec,
  614.                                                                                         TAG_DONE);
  615.                                                                         break;
  616.  
  617.                                                         }
  618.                                                         ReplyMsg((struct Message *)msg);
  619.                                                     }
  620.                                                 } while (MsgClass != IDCMP_CLOSEWINDOW);
  621.  
  622.                                             WZ_CloseWindow(MyWinHandle);
  623.                                         }
  624.                                         WZ_DeleteImageBitMap(sbm,newimage,MyScreen,SPens);
  625.                                     }
  626.                                     WZ_DeleteImageBitMap(bm,newimage,MyScreen,Pens);
  627.                                 }
  628.                             }
  629.  
  630.                             while (QuellList->mlh_Head->mln_Succ)
  631.                             {
  632.                                 struct MinNode *t=QuellList->mlh_Head;
  633.  
  634.                                 Remove((struct Node *)t);
  635.                                 FreeVec(t);
  636.                             };
  637.  
  638.                             while (ZielList->mlh_Head->mln_Succ)
  639.                             {
  640.                                 struct MinNode *t=ZielList->mlh_Head;
  641.  
  642.                                 Remove((struct Node *)t);
  643.                                 FreeVec(t);
  644.                             };
  645.                         }
  646.                         WZ_FreeWindowHandle(MyWinHandle)
  647.                     }
  648.                     WZ_CloseSurface(MySurface);
  649.                 }
  650.                 UnlockPubScreen(0L,MyScreen);
  651.             }
  652.             CloseLibrary(WizardBase);
  653.         }
  654.         CloseLibrary(UtilityBase);
  655.     }
  656. }
  657.