Ich benutze eine Komponente Names TRichView, soweit so gut. Innerhalb dieser Komponente gibt es eine weitere PascalKomponente, mit deren Hilfe man innerhalb von TRichViews direkt mit Flash Dateien umgehen kann.

Nun zu meinem Problem. Das installieren dieser zweiten Komponente schlägt leider fehl, mit der Fehlermeldung "ShockwaveFlashObjects_TLB.dcu" nicht gefunden.

Flash habe ich zuvor brav per ActiveX, innerhalb meines Cbuilders importiert. und die Dateien ShockwaveFlashObjects_TLB.cpp und ShockwaveFlashObjects_TLB.h erhalten. Ebenso sind ShockwaveFlashObjects_OCX.opj, ShockwaveFlashObjects_OCX.cpp und ShockwaveFlashObjects_OCX.dcr neu.

Nur die besagte DCU ist leider Gottes nicht darunter, DCU müsste ja auch eigentlich eine Delphi Geschichte sein, insofern kann ich das sogar verstehen.

Meine Frage ist nun, wie kann ich dieses PRoblem trotzdem zum Erfolg führen?

Innerhalb der Pascal Datei tritt der Fehler hier auf.

unit MyShockwaveFlash;
interface
uses
Windows, Messages, SysUtils, Classes, Controls, OleCtrls,
ShockwaveFlashObjects_TLB; <<<<<< Da liegt der Hund begraben

Für Vorschläge bin ich sehr dankbar.

Gruss

Mirko

Ja klar ist die Pascal Datei dabei. Die macht ja auch die Schwierigkeiten.

Aus der Readme

3. Install component TMyShockwaveFlash from MyShockwaveFlash.pas.
   You'll see TMyShockwaveFlash on ActiveX page of the Component Palette.

Ergo, bin ich auf Komponente -> Komponente installieren gegangen Über suchen zur Pas Datei. die wollte sich dann in der dclusr verewigen, aber beim compilieren meckert er nach dieser komischen DCU Datei.

Da die PAscal Datei nicht wirklich gross ist. poste ich sie mal mit.

unit MyShockwaveFlash;

interface

uses
Windows, Messages, SysUtils, Classes, Controls, OleCtrls,
ShockwaveFlashObjects_TLB;

type
TMyShockwaveFlash = class(TShockwaveFlash)
private
{ Private declarations }
FStream: TMemoryStream;
FTmpFileName: String;
procedure WriteFlash(Stream: TStream);
procedure ReadFlash(Stream: TStream);
protected
{ Protected declarations }
procedure DefineProperties(Filer: TFiler); override;
procedure Loaded; override;
public
{ Public declarations }
constructor Create(AOwner: TComponent); override;
function LoadFlash(const FileName: String): Boolean;
function LoadFlashFromStream(Stream: TStream): Boolean;
procedure SaveFlash(const FileName: String);
procedure SaveFlashToStream(Stream: TStream);
procedure SetFlash(Source: TMyShockwaveFlash);
function InitFlash: Boolean;
procedure Reload;
procedure DoneFlash;
destructor Destroy; override;
published
{ Published declarations }
end;

procedure Register;

implementation

procedure Register;
begin
RegisterComponents('ActiveX', [TMyShockwaveFlash]);
end;

{ TMyShockwaveFlash }

constructor TMyShockwaveFlash.Create(AOwner: TComponent);
begin
inherited;
FStream := TMemoryStream.Create;
end;

destructor TMyShockwaveFlash.Destroy;
begin
DoneFlash;
FStream.Free;
inherited;
end;

function TMyShockwaveFlash.LoadFlash(const FileName: String): Boolean;
var fs: TFileStream;
begin
Result := False;
try
fs := TFileStream.Create(FileName, fmOpenRead);
FStream.SetSize(0);
FStream.CopyFrom(fs, fs.Size);
fs.Free;
Result := True;
except;
end;
end;

function TMyShockwaveFlash.LoadFlashFromStream(Stream: TStream): Boolean;
begin
Result := False;
try
FStream.SetSize(0);
Stream.Position := 0;
FStream.CopyFrom(Stream, Stream.Size);
Result := True;
except;
end;
end;

procedure TMyShockwaveFlash.SaveFlashToStream(Stream: TStream);
begin
FStream.Position := 0;
Stream.Size := 0;
Stream.CopyFrom(FStream, FStream.Size);
end;

procedure TMyShockwaveFlash.SetFlash(Source: TMyShockwaveFlash);
begin
FStream.SetSize(0);
Source.FStream.Position := 0;
FStream.CopyFrom(Source.FStream, Source.FStream.Size);
end;

procedure TMyShockwaveFlash.DefineProperties(Filer: TFiler);
begin
inherited;
Filer.DefineBinaryProperty('FlashMovie', ReadFlash, WriteFlash, FStream.Size>0);
end;

procedure TMyShockwaveFlash.ReadFlash(Stream: TStream);
var v: Integer;
begin
Stream.ReadBuffer(v, sizeof(v));
if v>0 then begin
FStream.SetSize(0);
FStream.CopyFrom(Stream, v);
end;
end;

procedure TMyShockwaveFlash.WriteFlash(Stream: TStream);
var v: Integer;
begin
v := FStream.Size;
Stream.WriteBuffer(v, sizeof(v));
FStream.Position := 0;
Stream.CopyFrom(FStream, v)
end;

function TMyShockwaveFlash.InitFlash: Boolean;
var l: Integer;
fs: TFileStream;
begin
Result := False;
try
SetLength(FTmpFileName, 1000);
l := GetTempPath(1000, PChar(FTmpFileName));
SetLength(FTmpFileName,l);
if (Length(FTmpFileName)>0) and (FTmpFileName[Length(FTmpFileName)]<>'\') then
FTmpFileName := FTmpFileName+'\';
l := Random(1000);
while FileExists(FTmpFileName+IntToStr(l)+'.swf') do
inc(l);
FTmpFileName := FTmpFileName+IntToStr(l)+'.swf';
fs := TFileStream.Create(FTmpFileName, fmCreate);
FStream.Position := 0;
fs.CopyFrom(FStream, FStream.Size);
fs.Free;
Movie := FTmpFileName;
Result := True;
except;
end;
end;

procedure TMyShockwaveFlash.DoneFlash;
begin
Stop;
DeleteFile(FTmpFileName);
FTmpFileName := '';
end;

procedure TMyShockwaveFlash.Loaded;
begin
inherited;
if FStream.Size>0 then
InitFlash;
end;

procedure TMyShockwaveFlash.SaveFlash(const FileName: String);
var fs: TFileStream;
begin
fs := TFileStream.Create(FileName, fmCreate);
try
FStream.Position := 0;
fs.CopyFrom(FStream, FStream.Size);
finally
fs.Free;
end;
end;

procedure TMyShockwaveFlash.Reload;
begin
Stop;
Movie := FTmpFileName;
if FTmpFileName<>'' then
Play;
end;

end.

gruss

Mirko

hats auch ne
ShockwaveFlashObjects_TLB.pas

Ist die Dabei? Die muss als Unit kompiliert werden - dabei entsteht eigentlich die DCU.

Ich beginne, glaube, zu verstehen, aber nein, leider nicht, die fehlt.

Hmmm. Wenn ich mal weiterdenke, könnte man über Delphi das Flash importieren, somit die pas Datei erhalten diese dann kompilieren und die Welt ist wieder rund?

Gruss
Mirko