ich hab da ein paar kleine problemchen:

ich habe eine rc datei, die als unicode-textdatei gespeichert ist, mit etwa folgendem inhalt:

markieren

Code:

STRINGTABLE
BEGIN
  1, "Unicodetext"
END

umgewandelt wird das ganze mit:

markieren

Code:

@rc /fo language.res language.rc

ausgelesen mit:

zusammenfalten · markieren

Delphi-Quellcode:

function GetStringFromRessource(ID, Offset: Integer): string;
var
  p: PChar;
begin
  p := StrAlloc(256);
  try
    if LoadString(hInstance, ID + Offset, p, 255) <> 0 then
      Result := p
    else
      Result := '';
  finally
    StrDispose(p);
  end;
end;

[...]
const Offset = 0;
[...]

tntLabel1.Caption := GetStringFromRessource(1, Offset);

das klappt mit normalem text prima, bis unicodezeichen dargestellt werden müssen. dann kommen nur fragezeichen. (in den TntWare Delphi Unicode Controls)
ich hoffe, dass das problem gelöst ist, sobald die GetStringFromRessource funktion richtig umgestellt ist. (die res datei sollte doch hoffentlich richtig erstellt werden)
): string; -> ): Widestring;
p: PChar; -> p: PWideChar;
LoadString -> LoadStringW
StrAlloc -> ?
StrDispose -> ?

zu den letzten beiden befehlen bräuchte ich die entsprechenden widechar-befehle. habe aber keine ahnung, welche das sind. StrDisposeW und StrAllocW sind es schon mal nicht (außer es gibt da ne extra unit dafür )

danke

Hallo,

Zitat von CodeX:

StrAlloc -> ?
StrDispose -> ?

zu den letzten beiden befehlen bräuchte ich die entsprechenden widechar-befehle. habe aber keine ahnung, welche das sind. StrDisposeW und StrAllocW sind es schon mal nicht ;) (außer es gibt da ne extra unit dafür :roll: )

danke :)

Für die beiden Befehle gibt es keine Entsprechung. Du musst also einfach StrAlloc und StrDispose nehmen.
Einen WideString allokierst Du dann so:
P := StrAlloc((10 + 1) * SizeOf(WideChar)); Damit erstellst Du einen PWideChar der Länge 10 (plus Nullbyte).

StrDispose kannst Du einfach weiterbenutzen.

Gruß
xaromz

Mahlzeit,

folgenden code hab ich aus der advanced demo von TVirtualTree, wenn du mit unicode arbeitest solltest du die kompo auf alle fälle mal ansehen (wenn du das nicht schon gemacht hast )

zusammenfalten · markieren

Delphi-Quellcode:

procedure LoadUnicodeStrings(Name: string; var Strings: array of WideString);

// Loads the Unicode strings from the resource.

var
  Stream: TResourceStream;
  Head, Tail: PWideChar;
  I: Integer;
                              
begin
  Stream := TResourceStream.Create(0, Name, 'Unicode');
  try
    Head := Stream.Memory;
    // Skip byte order mark.
    Inc(Head);
    Tail := Head;
    for I := 0 to High(Strings) do
    begin
      Head := Tail;
      while not (Tail^ in [WideChar(#0), WideChar(#13)]) do
        Inc(Tail);
      SetString(Strings[I], Head, Tail - Head);
      // Skip carriage return and linefeed.
      Inc(Tail, 2);
    end;
  finally
    Stream.Free;
  end;
end;

sollte eigentlich das sein was du suchst

Zitat von xaromz:

Für die beiden Befehle gibt es keine Entsprechung. Du musst also einfach StrAlloc und StrDispose nehmen.
Einen WideString allokierst Du dann so:
P := StrAlloc((10 + 1) * SizeOf(WideChar)); Damit erstellst Du einen PWideChar der Länge 10 (plus Nullbyte).

StrDispose kannst Du einfach weiterbenutzen.

P := StrAlloc((10 + 1) * SizeOf(WideChar)); funktioniert nicht so einfach
StrAlloc liefert eben einen PAnsiChar zurück. und delphi meckert beim kompilieren da dran rum. (Inkompatible Typen: Char und WideChar).
das selbe nochmals bei StrDispose. da wird eben ein PAnsiChar als parameter erwartet.
und ich muss p als PWideChar definieren, da sonst LoadStringW nicht funktioniert.

@andy
sieht interessant aus, aber irgendwie nicht danach, als wärs richtig für mich. da werden die strings in einem stream ausgelesen und das auch noch ohne rückgabewert.
ich hätte das schon gerne so, wie das jetzt ist, dass ich an jeder beliebeigen stelle einen bestimmten text auslesen kann.

juhu!
soeben hier gefunden, getestet und für super befunden

zusammenfalten · markieren

Delphi-Quellcode:

function StrAllocW(Size: Cardinal): PWideChar;
begin
  Size := SizeOf(Cardinal) + (Size * SizeOf(WideChar));
  GetMem(Result, Size);
  PCardinal(Result)^ := Size;
  Inc(PAnsiChar(Result), SizeOf(Cardinal));
end;

procedure StrDisposeW(Str: PWideChar);
begin
  if Str <> nil then
  begin
    Dec(PAnsiChar(Str), SizeOf(Cardinal));
    FreeMem(Str, Cardinal(Pointer(Str)^));
  end;
end;

damit habe ich meine deinen fehlenden funktionen und damit geht das auch wirklich. *freu*