home *** CD-ROM | disk | FTP | other *** search
/ The Best of the Best / _.img / w037 / test.pas < prev    next >
Pascal/Delphi Source File  |  1992-08-16  |  15KB  |  472 lines
  1.  
  2. { Beispielprogramm fⁿr die Verwendung der Biblithek UNZIP100.DLL }
  3.  
  4. {$R TEST.RES}
  5.  
  6.  
  7. Uses
  8.   WinTypes,
  9.   WObjects,
  10.   WinProcs,
  11.   WinDOS,
  12.   Strings,
  13.   WUZHelp,      { Hilfsdialog zur Darstellung einer Balkenanzeige               }
  14.   WUZ;          { Diese Unit erm÷glicht den Zugriff auf UNZIP100.DLL            }
  15.  
  16.  
  17. Const
  18.   id_Start      = 110;
  19.   id_Abort      = 111;
  20.   id_Info       = 112;
  21.   id_OverWrite  = 120;
  22.   id_Quiet      = 121;
  23.   id_Time       = 122;
  24.  
  25. Const
  26.   OverWrite : Boolean = False;  { Bestehende Dateien werden nicht ⁿberschrieben }
  27.   Quiet     : Boolean = False;  { Das Entpacken der Dateien wird angezeigt.     }
  28.   Time      : Boolean = False;  { Die ben÷tigte Zeit wird nicht angezeigt.      }
  29.  
  30. Type
  31.   TApp = Object(TApplication)
  32.     Procedure  InitMainWindow; Virtual;
  33.   End;
  34.  
  35. Type
  36.   PUnzipDlg = ^TUnZipDlg;
  37.   TUnZipDlg = Object(TDlgWindow)
  38.     Worker    : PWorkingDlg;
  39.     Procedure Abort(Var Msg: TMessage); Virtual id_First + id_Abort;
  40.     Procedure DefWndProc(Var Msg: TMessage); Virtual;
  41.     Procedure Start(Var Msg: TMessage); Virtual id_First + id_Start;
  42.     Procedure Info(VAr Msg: TMessage); Virtual id_First + id_Info;
  43.     Procedure wmCommand(Var Msg : TMessage); Virtual wm_First + wm_Command;
  44.     Procedure wmLocalZIPFile(VAR Msg: TMessage);
  45.     Procedure wmPercentOne(Var Msg: TMessage);
  46.     Procedure wmPercentTen(Var Msg: TMessage);
  47.     Procedure wmWUZErrorStr(VAR Msg : TMessage);
  48.     Procedure wmWUZQuestion(VAR Msg : TMessage);
  49.     Procedure wmWUZUnzipThisFile(Var Msg: TMessage);
  50.   End;
  51.  
  52.  
  53.  
  54. Procedure TUnZipDlg.Abort;
  55. Begin
  56.   Cancel(Msg)
  57. End;
  58.  
  59.  
  60. Procedure TUnZipDlg.DefWndProc(VAR Msg: TMessage);
  61. Begin
  62.   TDlgWindow.DefWndProc(Msg);
  63.  
  64.   { DefWndProc fΣngt die fⁿr uns bestimmten Nachrichten ab                      }
  65.  
  66.   If Msg.Message = wm_PercentDoneOneStep
  67.   Then
  68.     wmPercentOne(Msg)
  69.   Else
  70.   If Msg.Message = wm_PercentDoneTenStep
  71.   Then
  72.     wmPercentTen(Msg)
  73.   Else
  74.   If Msg.Message = wm_NameOfLocalZIPFile
  75.   Then
  76.     wmLocalZIPFile(Msg)
  77.   Else
  78.   If Msg.Message = wm_WUZErrorStr
  79.   Then
  80.     wmWUZErrorStr(Msg)
  81.   Else
  82.   If Msg.Message = wm_WUZQuestionOverWrite
  83.   Then
  84.     wmWUZQuestion(Msg)
  85.   Else
  86.   If Msg.Message = wm_WUZUnzipThisFile
  87.   Then
  88.     wmWUZUnzipThisFile(Msg)
  89. End;
  90.  
  91.  
  92. Procedure TUnZipDlg.Start;
  93. { Diese Prozedur wickelt das gesamte Entpacken des Archives ab                  } 
  94. Var
  95.   ZIPArchive    : Array [0..128] Of Char;
  96.   UnZIPDir      : Array [0..128] Of Char;
  97.   StopperStart  : LongInt;
  98.   StopperEnd    : LongInt;
  99.   StopperDiv    : LongInt;
  100.   Buffer        : Array [0..55] Of Char;
  101. Begin
  102.  
  103.   { Soll die ben÷tigte Zeit angezeigt werden ?                                  }
  104.   If Time
  105.   Then
  106.     StopperStart := GetTickCount;
  107.  
  108.   { Archiv und Zielverzeichnis holen                                            }
  109.   GetDlgItemText(HWindow, 107, ZIPArchive, SizeOf(ZIPArchive));
  110.   GetDlgItemText(HWindow, 108, UnZIPDir,   SizeOf(UnZipDir));
  111.  
  112.  
  113.   { Soll das Entpacken des Archives angezeigt werden ?                          }
  114.   If Not Quiet
  115.   Then
  116.     Begin
  117.       { Hilfsfenster mit Balkenanzeige aktivieren                               }
  118.       Worker := New(PWorkingDlg, Init(@Self, PChar(10)));
  119.       { Achtung! Modale Dialoge verhindern eine Bearbeitung von Botschaften     }
  120.       Application^.MakeWindow(Worker);
  121.       { Balkenanzeige zurⁿcksetzen                                              }
  122.       Worker^.ClearMeter;
  123.     End;
  124.  
  125.   { UnzipDLL initialisieren und starten                                         }
  126.  
  127.   InitDll;
  128.  
  129.   { Sollen bestehende Dateien ⁿberschrieben werden ?                            }
  130.   If OverWrite
  131.   Then
  132.     WUZOverWriteAlways(True)
  133.   Else
  134.     WUZOverWriteAlways(False);
  135.  
  136.   { UNZIP100 den Betriebsmodus mitteilen                                        }
  137.   If Quiet
  138.   Then
  139.     WUZQuiet(True)
  140.   Else
  141.     WUZQuiet(False);
  142.  
  143.   { und los gehts ...                                                           }
  144.   ProzessUnzip(ZIPArchive, UnZIPDir);
  145.  
  146.   { Soll die ben÷tigte Zeit angezeigt werden ?                                  }
  147.   If Time
  148.   Then
  149.     Begin
  150.       { ben÷tigte Zeit anzeigen                                                 }
  151.       StopperEnd := GetTickCount;
  152.       StopperDiv := StopperEnd - StopperStart;
  153.       wvsPrintF(Buffer, '%li Millisekunden.', StopperDiv);
  154.       MessageBox(HWindow, Buffer, 'Zeitbedarf', mb_OK);
  155.     End;
  156.  
  157.   { Alles erledigt, aufrΣumen                                                   }
  158.  
  159.   DoneDLL;
  160.  
  161.   If Not Quiet
  162.   Then
  163.     Dispose(Worker, Done);
  164.  
  165.   { Focus auf das Hauptfenster                                                  }
  166.  
  167.   SetActiveWindow(HWindow);
  168.  
  169. End;
  170.  
  171.  
  172. Procedure TUnZipDlg.Info;
  173. {
  174.   Diese Prozedur demonstriert die M÷glichkeit gepackte Dateien "On the Fly" zu
  175.   entpacken und zu verwenden. Hierzu wird die Datei INFO.INF unter INFO.TMP
  176.   entpackt und in NOTEPAD geladen.
  177.   ACHTUNG : Die Prozedur sucht die Datei im eigenen Pfad. Wenn Sie TEST.PAS in
  178.   der IDE compilieren und ausfⁿhren, mu▀ die Datei INFO.INF in Ihrem EXE & TPU
  179.   Verzeichnis stehen !
  180. }
  181. Var
  182.   ZIPArchive    : Array [0..128] Of Char;
  183.   UnZIPDir      : Array [0..128] Of Char;
  184.   Buffer        : Array [0..128] Of Char;
  185.   Dummy         : String;
  186.   Dir           : Array [0..128] Of Char;
  187.   Name          : Array [0..fsFileName] Of Char;
  188.   Ext           : Array [0..fsExtension] Of Char;
  189. Begin
  190.  
  191.   StrPCopy(Buffer, ParamStr(0));
  192.   FileSplit(Buffer, Dir, Name, Ext);
  193.   StrCopy(UnZIPDir, Dir);
  194.   StrCat(Dir, 'INFO.INF');
  195.   StrCopy(ZIPArchive, Dir);
  196.  
  197.   {
  198.     UNZIP100 initialisieren und starten.
  199.  
  200.     Anstatt die DLL bei jedem Aufruf erneut zu initialisieren und anschlie▀end
  201.     wieder freizugeben, k÷nnen Sie die Methoden InitDLL und DoneDLL selbstver-
  202.     stΣndlich auch in den INIT und DONE Methoden Ihrer Applikation einbinden.
  203.     Sie sollten dann allerdings verhindern, das gleichzeitige Zugriffe auf die
  204.     DLL stattfinden ( UNZIP100.DLL kann immer nur eine Datei bearbeiten ! ).
  205.     Ein Vorteil dieser Vorgehensweise ist, das Sie das Copyrightfenster der
  206.     DLL dann nur ein einziges Mal angezeigt bekommen.
  207.   }
  208.  
  209.   InitDll;
  210.  
  211.   { bestehende Dateien ⁿberschreiben                                            }
  212.   WUZOverWriteAlways(True);
  213.  
  214.   { UNZIP100 den Betriebsmodus mitteilen                                        }
  215.   WUZQuiet(True);
  216.  
  217.   { und los gehts ...                                                           }
  218.   ProzessUnzip(ZIPArchive, UnZIPDir);
  219.  
  220.   StrCopy(Buffer, 'NOTEPAD.EXE ');
  221.   StrCat(Buffer, UnZipDir);
  222.   StrCat(Buffer, 'INFO.TMP');
  223.   WinExec(Buffer, sw_ShowMaximized);
  224.  
  225.   { UNZIP100 wieder Freigeben                                                   }
  226.   DoneDLL;
  227.  
  228.   {
  229.     WICHTIG: Dieses Demo verzichtet darauf, die Datei INFO.TMP nach dem Gebrauch
  230.     zu l÷schen. Ihre Applikation sollte dies tun und darⁿberhinaus das TEMP 
  231.     Verzeichnis verwenden - sonst geht der eigentliche Zweck des Entpackens
  232.     "On the Fly" verloren.
  233.   }
  234. End;
  235.  
  236.  
  237. Procedure TUnZipDlg.wmCommand;
  238.   Procedure   FlipFlop(Var Flipper : Boolean);
  239.   Begin
  240.     { Dreht den ⁿbergebenen Wert um ... }
  241.     If Flipper
  242.     Then
  243.       Flipper := False
  244.     Else
  245.       Flipper := True;
  246.   End;
  247. Begin
  248.   { Wurde ein Schalter im Dialogfenster gedrⁿckt ?                              }
  249.   Case HiWord(Msg.lParam) Of
  250.     bn_Clicked : Begin
  251.                    { Uns interessieren nur die Konfigurationsschalter           }
  252.                    Case Msg.wParam Of
  253.                      id_OverWrite : Begin
  254.                                       FlipFlop(OverWrite);
  255.                                       DefWndProc(Msg);
  256.                                     End;
  257.                      id_Quiet     : Begin
  258.                                       FlipFlop(Quiet);
  259.                                       DefWndProc(Msg);
  260.                                     End;
  261.                      id_Time      : Begin
  262.                                       FlipFlop(Time);
  263.                                       DefWndProc(Msg);
  264.                                     End;
  265.                      Else
  266.                        TDlgWindow.WMCommand(Msg)
  267.                    End
  268.                  End;
  269.   Else
  270.     TDlgWindow.WMCommand(Msg);
  271.   End;
  272. End;
  273.  
  274.  
  275. Procedure TUnZipDlg.wmLocalZIPFile;
  276. Var
  277.   wo : Array [0..1] Of Word;
  278.   s  : Array [0..128] Of Char;
  279. Begin
  280.   { Balkenanzeige zurⁿcksetzen }
  281.  
  282.   Worker^.ClearMeter;
  283.  
  284.   { Adresse mit Dateinamen einlesen.
  285.     Msg.wParam enthΣlt den Offset,
  286.     Msg.lParam das Segment des Strings im Speicher  }
  287.  
  288.   Wo[0] := Word(Msg.wParam);  { Offset des Strings  }
  289.   Wo[1] := Word(Msg.lParam);  { Segment des Strings }
  290.   wvsPrintF(s, '%s', wo);     { String formatieren  }
  291.   Worker^.SetWorkingFile(s);  { im Dialog ausgeben  }
  292.  
  293.   { Die Botschaften wm_LocalZIPFile, wm_PercentDoneTenStep und
  294.     wm_PercentDoneOneStep k÷nnen durch einen Aufruf der Procedure
  295.     WUZQuiet(TRUE) unterdrⁿckt werden. Durch dieses Vorgehen wird
  296.     das Entpacken beschleunigt, da UNZIP100.DLL auf das Versenden
  297.     von einigen hundert Botschaften verzichtet.
  298.   }
  299. End;
  300.  
  301.  
  302. Procedure TUnZipDlg.wmPercentOne;
  303. Begin
  304.   { Balkenanzeige um einen Schritt erh÷hen, Msg.wParam wird nicht ben÷tigt      }
  305.  
  306.   Worker^.IncMeter;
  307.  
  308.   {
  309.     Msg.wParam enthΣlt den aktuellen Prozentwert, es ist also
  310.     alternativ auch m÷glich den Prozentwert in Zahlen auszugeben
  311.   }
  312. End;
  313.  
  314.  
  315. Procedure TUnZipDlg.wmPercentTen;
  316. Var
  317.   d : String;
  318.   p : Array [0..4] Of Char;
  319. Begin
  320.   { Msg.wParam enthΣlt den aktuellen Prozentwert / 10                           }
  321.  
  322.   wvsPrintF(p, '%d', Msg.wParam);
  323.   Worker^.SetPercent(p);
  324. End;
  325.  
  326.  
  327. Procedure TUnzipDlg.wmWUZErrorStr;
  328. Var
  329.   wo : Array [0..1] Of Word;
  330.   s  : Array [0..128] Of Char;
  331. Begin
  332.   {
  333.     UNZIP100.DLL ⁿbergibt der Anwendung einen vollstΣndigen String
  334.     mit der Fehlerangabe. Diesen k÷nnen Sie einfach in einer
  335.     MessageBox oder einem selbst getalteten Dialogfenster ausgeben.
  336.  
  337.     Adresse mit Dateinamen einlesen. Msg.wParam enthΣlt den Offset,
  338.     Msg.lParam das Segment des Strings im Speicher
  339.   }
  340.   Wo[0] := Word(Msg.wParam);  { Offset des Strings                              }
  341.   Wo[1] := Word(Msg.lParam);  { Segment des Strings                             }
  342.   wvsPrintF(s, '%s', wo);     { String formatieren                              }
  343.  
  344.   MessageBox(HWindow, s, 'Fehler ...', mb_OK);
  345. End;
  346.  
  347.  
  348. Procedure TUnzipDlg.wmWUZQuestion;
  349. Var
  350.   wo : Array [0..1] Of Word;
  351.   s  : Array [0..128] Of Char;
  352.   Result : Word;
  353. Begin
  354.   {
  355.     Anfrage von UNZIP100.DLL an das aufrufende Programm, ob eine
  356.     bereits bestehende Datei ⁿberschrieben werden soll. 
  357.  
  358.     Adresse mit Dateinamen einlesen. Msg.wParam enthΣlt den Offset,
  359.     Msg.lParam das Segment des Strings im Speicher
  360.   }
  361.   Wo[0] := Word(Msg.wParam);  { Offset des Strings                              }
  362.   Wo[1] := Word(Msg.lParam);  { Segment des Strings                             }
  363.   wvsPrintF(s, '%s', wo);     { String formatieren                              }
  364.  
  365.   { Die Antwort auf die Frage wird in Msg.wParam festgehalten ...               }
  366.  
  367.   Msg.wParam := MessageBox(HWindow, s, 'Frage', mb_IconQuestion Or mb_YesNo);
  368.  
  369.   { ... und an UNZIP100.DLL zurⁿckgegeben }
  370.  
  371.   WUZReplyMessage(Msg.Message, Msg.wParam);
  372.  
  373.   {
  374.     Wenn Sie bereits bestehende Dateien grundsΣtzlich ⁿberschreiben
  375.     lassen wollen, k÷nnen Sie die Procedure WUZOverWriteAlways(TRUE)
  376.     aufrufen. In diesem Fall verzichtet die Bibliothek auf die Anfrage
  377.     ganz und ⁿberschreibt alle Dateien
  378.   }
  379. End;
  380.  
  381.  
  382. Procedure TUnzipDlg.wmWUZUnzipThisFile;
  383. Var
  384.   wo     : Array [0..1] Of Word;
  385.   s      : Array [0..128] Of Char;
  386.   Buffer : Array [0..128] Of Char;
  387.   SRec   : TSearchRec;
  388. Begin
  389.  
  390.   {
  391.     Diese Methode mⁿssen Sie auf jeden Fall in Ihr Programm aufnehmen.
  392.     Wenn Sie grundsΣtzlich jede Datei des Archivs entpacken wollen,
  393.     geben Sie in WUZReplyMessage als 2.Parameter immer id_Yes
  394.     zurⁿck.
  395.     WMWUZUnzipThisFile dient als Filter. Sie k÷nnen hier beliebige
  396.     Prⁿfroutinen einfⁿhren, z.B. bei einer Programminstallation fest-
  397.     stellen, ob sich die Datei BWCC.DLL im Windows\System Verzeichnis
  398.     befindet, ist dies der Fall, verzichten Sie auf das Entpacken,
  399.     ansonsten installieren Sie die Bibliothek.
  400.   }
  401.  
  402.   Wo[0] := Word(Msg.wParam);  { Offset des Strings                              }
  403.   Wo[1] := Word(Msg.lParam);  { Segment des Strings                             }
  404.   wvsPrintF(s, '%s', wo);     { String formatieren                              }
  405.  
  406.   {
  407.     Der von UNZIP100.DLL ⁿbergebene Dateiname befindet sich jetzt in
  408.     dem String "S".
  409.     Im Programmbeispiel ⁿberprⁿfen Wir das Entpacken nur fⁿr die
  410.     Bibliothek BWCC.DLL
  411.   }
  412.  
  413.   If StrPos(s, 'BWCC.DLL') <> NIL
  414.   Then
  415.     Begin
  416.       { Systemverzeichnis von Windows ermitteln                                 }
  417.       If GetSystemDirectory(Buffer, SizeOf(Buffer)) <> 0
  418.       Then
  419.         Begin
  420.           { BWCC.DLL an die Pfadangabe anhΣngen                                 }
  421.           StrCat(Buffer, '\BWCC.DLL');
  422.           { Prⁿfen ob sich BWCC.DLL im Pfad befindet                            }
  423.           FindFirst(Buffer, faAnyFile, SRec);
  424.           If DosError = 0
  425.           Then
  426.             {
  427.               BWCC.DLL befindet sich im Systemverzeichnis und mu▀
  428.               deshalb nicht noch einmal installiert werden.
  429.             }
  430.             Msg.wParam := id_No
  431.           Else
  432.             {
  433.               Befindet sich nicht im Systemverzeichnis, also wird
  434.               die Bibliothek BWCC.DLL installiert
  435.             }
  436.             Msg.wParam := id_Yes
  437.         End
  438.       Else
  439.         {
  440.           Systemverzeichnis konnte nicht ermittelt werden, also
  441.           entpacken wir vorsichtshalber BWCC.DLL
  442.         }
  443.         Msg.wParam := id_Yes;
  444.     End
  445.   Else
  446.     { Alle ⁿbrigen Dateien aus dem Archiv werden entpackt                       }
  447.  
  448.     Msg.wParam := id_Yes;
  449.  
  450.   {
  451.     Das Ergebnis der Filterfunktion mu▀ UNZIP100.DLL mitgeteilt werden.
  452.     Hierzu wird als 1.Parameter die bearbeitete Botschaft, und als
  453.     2.Parameter das Ergebnis (id_Yes oder id_No) angegeben
  454.   }
  455.   WUZReplyMessage(Msg.Message, Msg.wParam);
  456. End;
  457.  
  458.  
  459. Procedure TApp.InitMainWindow;
  460. Begin
  461.   MainWindow := New(PUnzipDlg,Init(NIL, PChar(102)));
  462. End;
  463.  
  464.  
  465. Var
  466.   WinUnZipApp : TApp;
  467.  
  468. Begin
  469.   WinUnZipApp.Init('UnZip for Windows');
  470.   WinUnZipApp.Run;
  471.   WinUnZipApp.Done;
  472. End.