home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / dtx9303 / metawin / bpwmfimp.pas next >
Encoding:
Pascal/Delphi Source File  |  1993-04-05  |  8.9 KB  |  257 lines
  1. {$define RETAIL_VERSION}
  2. {!define Win32}
  3. {***************************************************************************
  4.   Source File Name     :  BPWMFIMP.PAS
  5.   Autor                :  Mario M. Westphal
  6.   Erstellt am          :  13.02.1993
  7.  
  8.   Compiler             :  Borland Pascal for Windows 1.x
  9.   Betriebssystem       :  DOS 5.0, Windows 3.x
  10.   Compiler-Schalter    :  -
  11.  
  12.   Bemerkungen          :  -
  13.  
  14.   Beschreibung         :  Import-Unit fⁿr WMFIMP.DLL
  15.  
  16.   Revisionen           :  1.00 13.02.1993 created (MW)
  17.                                07.04.1993 revisited (MW)
  18. ****************************************************************************}
  19. {$M 8192,8192}
  20. {$A+,B-,D+,F-,G+,I+,L+,N-,R+,S+,V+,W-,X+,Q+}
  21.  
  22. {$ifdef RETAIL_VERSION}
  23.   {$D-,L-,S-,R-,Q-,I-}
  24. {$endif}
  25.  
  26. unit bpwmfimp;
  27.  
  28. INTERFACE
  29. uses
  30.   WinTypes,
  31.   WinProcs,
  32.   Objects,
  33.   Win31,
  34.   OWindows,
  35.   SysTools,
  36.   ExDlg,
  37.   Strings;
  38.  
  39. const
  40.   FNAMESIZE      = 255;                            { LΣnge Dateinamen incl. Directory }
  41.  
  42.   { BuiltPal-Codes }
  43.   bpNone         = 1;                              { Keine Palette aufbauen }
  44.   bpBuilt        = 2;                              { Alle Farben des Metafiles in die Palette }
  45.   bpOptimize     = 4;                              { Palette optimieren }
  46.  
  47. type
  48.   { Informationen ⁿber das geladene Metafile }
  49.   PFileInfo = ^TFileInfo;
  50.   TFileInfo = record
  51.     hMF     : THandle;                             { Globales Handle }
  52.     hPal    : HPalette;                            { Handle auf die Palette }
  53.     OwnPal  : Boolean;                             { Metafile verwendet eigene Palette }
  54.     lSize   : LongInt;                             { Gr÷▀e des Metafiles im globalen Heap }
  55.     rcBBox  : TRect;                               { Umgebendes Rechteck }
  56.     wInch   : Word;                                { Einheiten pro Zoll }
  57.   end;
  58.  
  59. type
  60.   { Struktur fⁿr LoadMetaFile }
  61.   PFileSpec = ^TFileSpec;
  62.   TFileSpec = record
  63.     Size      : Word;                              { Gr÷▀e der Struktur in Bytes }
  64.     FullName  : array[0..FNAMESIZE] of Char;       { Dateiname }
  65.     FHandle   : Integer;                           { File-Handle }
  66.     FMode     : Word;                              { Zugriffs-Modus }
  67.     FPos      : LongInt;                           { Aktuelle Position innerhalb der Datei }
  68.     FType     : Word;                              { Datei-Typ (APM, Windows-WMF) }
  69.     PalSpec   : Byte;                              { bpxxx-Konstanten }
  70.     FInfo     : TFileInfo;                         { Informationen ⁿber die geladene Datei }
  71.   end;
  72.  
  73. type
  74.   { Header einer APM (Placeable Metafile) - Datei }
  75.   TAPMFileHeader = record
  76.     dwKey      : LongInt;                          { Kennung }
  77.     hMF        : THandle;                          { Handle (Default = 0) }
  78.     rcBBox     : TRect;                            { Gr÷▀e der Grafik in logischen Einheiten }
  79.     wInch      : Word;                             { Punkte pro (logische) Zoll }
  80.     dwReserved : LongInt;                          { Reserved }
  81.     wChecksum  : Word;                             { Wordweise XOR-Prⁿfsumme die ersten 10 Words }
  82.   end;
  83.  
  84. type
  85.   { Prototypen fⁿr die in der DLL enthaltenen Funktionen }
  86.   TpfnGetFilterVersion  = function : Word;
  87.   TpfnLoadFile          = function (var FileSpec: TFileSpec) : Integer;
  88.  
  89.   { Routinen fⁿr den Umgang mit APM-Files }
  90.   function PlayMetaFileExtended (AParent: PWindowsObject; DC: HDC; hMF : THandle;
  91.                                  var NoRecs: LongInt) : Boolean;
  92.  
  93.  
  94. IMPLEMENTATION
  95.  
  96. var
  97.   pmfeCounter : LongInt;                           { Intern: PlayMetafileExtended }
  98.  
  99. {-------------------------------------------------------------------------------
  100.   Die Callback-Funktion fⁿr CountMetaRecords
  101.  
  102.   PARAMETER:
  103.     Die fⁿr ein Metafile-Callback ⁿblichen Parameter. lParam enthΣlt den
  104.     aktuellen ZΣhler.
  105.   ERGEBNIS:
  106.     Immer <> 0, damit die AufzΣhlung fortgesetzt wird.
  107. }
  108. function EnumMetaCount (DC: HDC; var lpHt: THandleTable; var lpMR: TMetaRecord;
  109.                         cObj: Integer; var lParam: LongInt) : Integer; EXPORT;
  110. begin
  111.   inc(lParam);
  112.   EnumMetaCount := 1;
  113. end;
  114.  
  115. {-------------------------------------------------------------------------------
  116.   ZΣhlt die im ⁿbergebenen Metafile enthaltenen Records. Benutzt dazu die
  117.   Funktion EnumMetaCount.
  118.  
  119.   PARAMETER:
  120.     AParent: Zeiger auf das Parent-Fenster
  121.     hMF    : Metafile-Handle
  122.   ERGEBNIS:
  123.     Liefert die Anzahl der Records im Metafile
  124. }
  125. function CountMetaRecords (AParent: PWindowsObject; hMF: THandle) : LongInt;
  126. var
  127.   EnumFunc : TFarProc;
  128.   l        : LongInt;
  129. begin
  130.   l := 0;
  131.   EnumFunc := MakeProcInstance(@EnumMetaCount,HInstance);
  132.   EnumMetaFile(0,hMF,EnumFunc,@l);
  133.   FreeProcInstance(EnumFunc);
  134.   CountMetaRecords := l;
  135. end;
  136.  
  137. {-------------------------------------------------------------------------------
  138.   Erzeugt ein Array aus Elementen des Typs THandle im globalen Speicher.
  139.   Diese Tabelle wird von PlayMetafileExtended verwendet, um fⁿr das Metafile
  140.   angelegte Objekte anzulegen und zu zerst÷ren.
  141.  
  142.   PARAMETER:
  143.     Size : Die Anzahl der Elemente im Array
  144.   ERGEBNIS:
  145.     Die Funktion liefert 0, wenn kein Speicher allokiert werden konnte.
  146. }
  147. function CreateHandleTable (Size: LongInt) : THandle;
  148. begin
  149.   CreateHandleTable := GlobalAlloc(GHND,Size*SizeOf(THandle));
  150. end;
  151.  
  152. {-------------------------------------------------------------------------------
  153.   Gibt die durch "lpH" refernzierte HandleTable wieder frei.
  154.  
  155.   PARAMETER:
  156.     lpH : Zeiger auf die freizugebende Handle-Tabelle
  157. }
  158. procedure FreeHandleTable (lpH: THandle);
  159. begin
  160.   GlobalFree(lpH);
  161. end;
  162.  
  163. {-------------------------------------------------------------------------------
  164.   Callback-Funktion fⁿr PlayMetafileExtended.
  165.  
  166.   PARAMETER:
  167.     Die fⁿr ein Metafile-Callback ⁿblichen Parameter. lParam enthΣlt den
  168.     Zeiger auf den Prozentbalken-Dialog. Der Prozentbalken wird automatisch
  169.     mitgefⁿhrt.
  170.   ERGEBNIS:
  171.     Immer <> 0, damit die AufzΣhlung fortgesetzt wird.
  172. }
  173. function EnumMetaFileFunc (DC: HDC; var lpHt: THandleTable; var lpMR: TMetaRecord;
  174.                            cObj: Integer; lParam: PPBarDialog) : Integer; EXPORT;
  175. begin
  176.   PlayMetaFileRecord(DC,lpHt,lpMR,cObj);
  177.   if lParam <> nil then
  178.   begin
  179.     inc(pmfeCounter);
  180.     lParam^.SetPos(pmfeCounter);
  181.   end;
  182.   { Arbeitet da noch jemand? Wenn ja, la▀t ihn auch mal 'ran }
  183.   KeepWindowsAlive;
  184.   EnumMetafileFunc := 1;
  185. end;
  186.  
  187. {-------------------------------------------------------------------------------
  188.   Diese Funktion ersetzt die API-Funktion PlaymetaFile. PlayMetafileExtended
  189.   benutzt eine Callback-Funktion um die einzelnen Metarecords abzuspielen.
  190.   Dadurch kann beim Abspielen eines gro▀en Metafiles die Rechenleistung an
  191.   andere Programme weitergegeben werden und zum Beispiel ein Prozentbalken
  192.   angezeigt werden.
  193.  
  194.   PARAMETER:
  195.     AParent: Zeiger auf das Parent-Fenster
  196.     DC     : GerΣtekontext zum Abspielen des Metafiles
  197.     hMF    : Metafile-Handle
  198.     NoRecs : Anzahl der Records im Metafile, oder 0, wenn unbekannt
  199.   ERGEBNIS:
  200.     Die Funktion liefert true, wenn das Metafile abgespielt werden konnte.
  201. }
  202. function PlayMetaFileExtended (AParent: PWindowsObject; DC: HDC; hMF : THandle;
  203.                                var NoRecs: LongInt) : Boolean;
  204. var
  205.   EnumFunc   : TFarProc;
  206.   DCSave     : Integer;
  207.   lpHT       : THandle;
  208.   Entrys     : LongInt;
  209.   Indicator  : PPBarDialog;
  210.  
  211. begin
  212.   { Handle-Tabelle aufbauen, in der die vom Metafile angelegten Objekte gespeichert werden. }
  213.   { Aufrufe der Funktion meta_DeleteObject referenzieren diese Handle-Tabelle, um Objekte   }
  214.   { wieder zu entfernen, die vom Metafile angelegt wurden.                                  }
  215.   lpHT := CreateHandleTable(MaxInt);
  216.  
  217.   if lpHT <> 0 then                         { Handle-Tabelle verfⁿgbar? }
  218.   begin
  219.     { Speichern des ⁿbergebenen DC's }
  220.     DCSave := SaveDC(DC);
  221.  
  222.     { ZΣhle die Anzahl der EintrΣge als Basis fⁿr den Prozentbalken }
  223.     if NoRecs = 0 then
  224.     begin
  225.       Entrys := CountMetaRecords(AParent,hMF);
  226.       { Merke die Anzahl fⁿr zukunftige Aufrufe }
  227.       NoRecs := Entrys;
  228.     end
  229.     else
  230.       Entrys := NoRecs;
  231.  
  232.     { Prozentbalken aufbauen, pmfeCounter ist die Nummer des aktuellen Records }
  233.     pmfeCounter := 0;
  234.     Indicator := PPBarDialog(Application^.MakeWindow(
  235.                  New(PPBarDialog,Init(AParent,'Metafile wird aufgebaut',Entrys,false))));
  236.  
  237.     { Keine Aktionen innerhalb der Anwendung erlauben! }
  238.     SetCapture(Indicator^.HWindow);
  239.  
  240.     { Metafile abspielen, Indikator mitfⁿhren }
  241.     EnumFunc := MakeProcInstance(@EnumMetaFileFunc,HInstance);
  242.     EnumMetaFile(DC,hMF,EnumFunc,Indicator);
  243.     FreeProcInstance(EnumFunc);
  244.  
  245.     { Indikator und Handle-Tabelle freigeben, DC wiederherstellen }
  246.     ReleaseCapture;
  247.     Dispose(Indicator,Done);
  248.     FreeHandleTable(lpHT);
  249.     RestoreDC(DC,DCSave);
  250.     PlayMetaFileExtended := true;
  251.   end
  252.   else
  253.     PlayMetaFileExtended := false;
  254. end;
  255.  
  256. END.
  257.