Brauche hilfe bei übersetzung von C# in ObjectPascal (.Net)

[MaBuSE]

Zitat von Taladan:

Was dieser Barbelcodegenerator nicht kennt, lässt er scheinbar aus ohne eine Bemerkung.

Ich habe ja nicht gesagt, das BabelCode perfekt ist, man kann Ihn z.B. benutzen um die Codebeisp. in der MSDN zu übersetzen um sie besser zu verstehen.

Zitat von Taladan:

Leider stehen mir die Dinge wie das BDN nicht zur Verfügung. Ich nutze lediglich eine Personaledition

Die BDN ist kostenlos !!!

Einfach auf http://bdn.borland.com/delphi/ gehen und lesen.

Für einige Dinge brauchst Du eine kostenlose Registrierung.

Folgende Links solltest Du Dir mal anschauen:

• http://bdn.borland.com
• http://codecentral.borland.com
• http://newsgroups.borland.com/cgi-bi...borland.public.
• http://blogs.borland.com/
• http://qc.borland.com/
• http://support.borland.com/kbindex.jspa

um nur einige Links von Borland zu nennen...

[Robert_G]

Zitat von Taladan:

Ich habe lediglich eine Onlinehilfe bei meiner Delphiversion. Wo sollte ich diese Referenz finden?

Filter auf Delphi.Net setzen und Enumeration bzw. Aufzählung suchen.

Zitat:

Wenn ich nicht weiß, nach was ich suchen soll, dann ist das wie die berümte Nadel im Heuhaufen.

Das meinte ich mit flexibel, man tastet sich einfach heran, indem man sich Dinge sucht, die damit zu tun haben. In dem Fall wäre es das Wort enum in C# gewesen.
Mit den Infos wäre man zu Aufzählungen in D.Net gekommen.

Zitat:

(Davon mal abgesehen, das die deutschen MSDN stark zu Wünschen übrig lässt und die Suchfunktion schlechter ist, als die OH von Delphi, die (bei mir zumindest) zu 90% nichts auf Anhieb findet.

Öffne die Hilfe und suche dort. Dierekt aus D2005 findet sie bei mir deutlich weniger als 10%. Ist der Help Explorer einmal auf hat es zum Glück nicht mehr viel mit D2005 zu tun und funktioniert also auch ganz gut.
Die deutsche MSDN kenne ich nicht, die englische ist geradezu vollgestopft mit Infos.

Zitat:

Zitat von Robert_G:

Das sind Aufzählungstypen ähnlich zu denen aus Delphi32.

Meinst du damit Records oder Arrays?

Nix von beiden.
Aus Delphi kennst du doch sicher sowas:
type TAlign = (alClient, alTop,...); EineVariable.Allign := alClient; TAlign ist hier ein Aufzählungstyp (Enumeration). D.h: Es werden nur bestimmte Werte erlaubt.
In .Net würde man die Prefixe weglassen, da immer der Typ des Enums vorangestellt wird.
type Align = (Client, Top,...); EineVariable.Allign := Allign.Client; Aufzählung heißt hier soviel wie eine Aufzählung mehrerer möglicher Werte.

Zitat:

Zitat von Robert_G:

zweitens sind Auzählungen type safe.

was soll das heißen? (Das Safe sicher heißt ist mir klar )

[/quote]Rype safe heißt dass nur bestimmte werte zugewiesen werden können.
Rein numerische Konstanten sind es nicht, simit gibt es keine fehlermeldung wenn du eine Konstante zuweisen würdest, die überhaupt nix mit der Funktion zu tun hat, die du aufrufgen willst.

[Taladan]

Ich habe mich jetzt so ein wenig durchgewurschtelt. Compiliert wird der Code von Delphi. Das Elemement wird auch erstellt. Jedoch werden die erwünschten Links nicht als Link angezeigt, geschweige den, das sie als solche genutzt werden können

Delphi-Quellcode:

unit URichBoxHyperlink;

interface

uses
  System.Drawing, System.Collections, System.ComponentModel, System.Windows.Forms,
  System.Runtime.InteropServices;

type
    TArrayOfWideChar = array of WideChar;

    [StructLayout(LayoutKind.Sequential)]

    CHARFORMAT2_STRUCT = class
    public
      cbSize: UInt32;
      dwMask: UInt32;
      dwEffects: UInt32;
      yHeight: Int32;
      yOffset: Int32;
      crTextColor: Int32;
      bCharSet: Byte;
      bPitchAndFamily: Byte;
      szFaceName: TArrayOfWideChar;
      wWeight: UInt16;
      sSpacing: UInt16;
      crBackColor: Integer;
      lcid: Integer;
      dwReserved: Integer;
      sStyle: Int16;
      wKerning: Int16;
      bUnderlineType: Byte;
      bAnimation: Byte;
      bRevAuthor: Byte;
      bReserved1: Byte;
    end;

type
  RichTextBoxHyperlink = class(System.Windows.Forms.RichTextBox)
  strict private
    Components: System.ComponentModel.Container;
    WM_USER: Integer;
    EM_GETCHARFORMAT: Integer;
    EM_SETCHARFORMAT: Integer;
    SCF_SELECTION: Integer;
    SCF_WORD: Integer;
    SCF_ALL: Integer;
    CFE_BOLD: UInt32;
    CFE_ITALIC: UInt32;
    CFE_UNDERLINE: UInt32;
    CFE_STRIKEOUT: UInt32;
    CFE_PROTECTED: UInt32;
    CFE_LINK: UInt32;
    CFE_AUTOCOLOR: UInt32;
    CFE_SUBSCRIPT: UInt32;
    CFE_SUPERSCRIPT: UInt32;
    CFM_SMALLCAPS: Integer;
    CFM_ALLCAPS: Integer;
    CFM_HIDDEN: Integer;
    CFM_OUTLINE: Integer;
    CFM_SHADOW: Integer;
    CFM_EMBOSS: Integer;
    CFM_IMPRINT: Integer;
    CFM_DISABLED: Integer;
    CFM_REVISED: Integer;
    CFM_BACKCOLOR: Integer;
    CFM_LCID: Integer;
    CFM_UNDERLINETYPE: Integer;
    CFM_WEIGHT: Integer;
    CFM_SPACING: Integer;
    CFM_KERNING: Integer;
    CFM_STYLE: Integer;
    CFM_ANIMATION: Integer;
    CFM_REVAUTHOR: Integer;
    CFM_BOLD: UInt32;
    CFM_ITALIC: UInt32;
    CFM_UNDERLINE: UInt32;
    CFM_STRIKEOUT: UInt32;
    CFM_PROTECTED: UInt32;
    CFM_LINK: UInt32;
    CFM_SIZE: UInt32;
    CFM_COLOR: UInt32;
    CFM_FACE: UInt32;
    CFM_OFFSET: UInt32;
    CFM_CHARSET: UInt32;
    CFM_SUBSCRIPT: UInt32;
    CFM_SUPERSCRIPT: UInt32;
    CFU_UNDERLINENONE: Byte;
    CFU_UNDERLINE: Byte;
    CFU_UNDERLINEWORD: Byte;
    CFU_UNDERLINEDOUBLE: Byte;
    CFU_UNDERLINEDOTTED: Byte;
    CFU_UNDERLINEDASH: Byte;
    CFU_UNDERLINEDASHDOT: Byte;
    CFU_UNDERLINEDASHDOTDOT: Byte;
    CFU_UNDERLINEWAVE: Byte;
    CFU_UNDERLINETHICK: Byte;
    CFU_UNDERLINEHAIRLINE: Byte;
    [DllImport('user32.dll', CharSet=CharSet.Auto)]
    class function SendMessage(hWnd: IntPtr; msg: Integer; wParam: IntPtr; lParam: IntPtr): IntPtr;static;
    procedure SetSelectionStyle(mask: UInt32; effect: UInt32);
    function GetSelectionStyle(mask: UInt32; effect: UInt32): Integer;
    procedure InitializeComponent;
  strict protected
    /// <summary>
    /// Ressourcen nach der Verwendung bereinigen
    /// </summary>
    procedure Dispose(Disposing: Boolean); override;
  public
    constructor Create; overload;
    constructor Create(Container: System.ComponentModel.IContainer); overload;
    function get_DetectUrls: Boolean; reintroduce;
    procedure set_DetectUrls(Value: Boolean); reintroduce;
    [DefaultValue(False)]
    property DetectUrls: Boolean read get_DetectUrls write set_DetectUrls;
    procedure InsertLink(text: string); overload;
    procedure InsertLink(text: string; position: Integer); overload;
    procedure InsertLink(text: string; hyperlink: string); overload;
    procedure InsertLink(text: string; hyperlink: string; position: Integer); overload;
    procedure SetSelectionLink(link: Boolean);
    function GetSelectionLink: Integer;
  end;

implementation

uses
  System.Globalization;
{$AUTOBOX ON}
procedure RichTextBoxHyperlink.InitializeComponent;
begin
  Self.Components := System.ComponentModel.Container.Create;
end;
{$HINTS OFF}
{$WARNINGS OFF}

constructor RichTextBoxHyperlink.Create;
begin
  inherited Create;
  Self.DetectUrls := False;
end;

constructor RichTextBoxHyperlink.Create(Container: System.ComponentModel.IContainer);
begin
  inherited Create;
  //
  // Erforderlich für die Unterstützung des Windows Forms-Designers
  //
  Container.Add(Self);
  InitializeComponent;
  //
  // TODO: Fügen Sie nach dem Aufruf von InitializeComponent Konstruktorcode hinzu.
  //
end;

procedure RichTextBoxHyperlink.Dispose(Disposing: Boolean);
begin
  if Disposing then
  begin
    if Components <> nil then
      Components.Dispose();
  end;
  inherited Dispose(Disposing);
end;
function RichTextBoxHyperlink.get_DetectUrls: Boolean;
begin
  Result := inherited DetectUrls;
end;

procedure RichTextBoxHyperlink.set_DetectUrls(Value: Boolean);
begin
  inherited DetectUrls := value;
end;

class function RichTextBoxHyperlink.SendMessage(hWnd: IntPtr; msg: Integer; wParam: IntPtr;
  lParam: IntPtr): IntPtr;
begin
end;

procedure RichTextBoxHyperlink.InsertLink(text: string);
begin
  InsertLink(text, Self.SelectionStart);
end;

procedure RichTextBoxHyperlink.InsertLink(text: string; position: Integer);
begin
  if ((position < 0) or (position > Self.Text.Length)) then
    raise ArgumentOutOfRangeException.Create('position');
  Self.SelectionStart := position;
  Self.SelectedText := text;
  Self.Select(position, text.Length);
  Self.SetSelectionLink(True);
  Self.Select((position + text.Length), 0);
end;

procedure RichTextBoxHyperlink.InsertLink(text: string; hyperlink: string);
begin
  InsertLink(text, hyperlink, Self.SelectionStart);
end;

procedure RichTextBoxHyperlink.InsertLink(text: string; hyperlink: string; position: Integer);
begin
  if ((position < 0) or (position > Self.Text.Length)) then
    raise ArgumentOutOfRangeException.Create('position');
  Self.SelectionStart := position;
  Self.SelectedRtf := (((('{\rtf1\ansi ' + text) + '\v #') + hyperlink) + '\v0}');
  Self.Select(position, ((text.Length + hyperlink.Length) + 1));
  Self.SetSelectionLink(True);
  Self.Select((((position + text.Length) + hyperlink.Length) + 1), 0);
end;

procedure RichTextBoxHyperlink.SetSelectionLink(link: Boolean);
begin
  if link then begin
    CFE_Link := 0;
    SetSelectionStyle(CFM_LINK, CFE_Link);
  end;
end;

function RichTextBoxHyperlink.GetSelectionLink: Integer;
begin
  Result := GetSelectionStyle(CFM_LINK, CFE_LINK);
end;

procedure RichTextBoxHyperlink.SetSelectionStyle(mask: UInt32; effect: UInt32);
var
  res: IntPtr;
  lpar: IntPtr;
  wpar: IntPtr;
  cf: CHARFORMAT2_STRUCT;
begin
  cf := CHARFORMAT2_STRUCT.Create;
  cf.cbSize := (UInt32(Marshal.SizeOf(cf)));
  cf.dwMask := mask;
  cf.dwEffects := effect;
  wpar := IntPtr.Create(SCF_SELECTION);
  lpar := Marshal.AllocCoTaskMem(Marshal.SizeOf(cf));
  Marshal.StructureToPtr(cf, lpar, False);
  res := SendMessage(Self.Handle, EM_SETCHARFORMAT, wpar, lpar);
  Marshal.FreeCoTaskMem(lpar);
end;

function RichTextBoxHyperlink.GetSelectionStyle(mask: UInt32; effect: UInt32): Integer;
var
  state: Integer;
  res: IntPtr;
  lpar: IntPtr;
  wpar: IntPtr;
  cf: CHARFORMAT2_STRUCT;
begin
  cf := CHARFORMAT2_STRUCT.Create;
  cf.cbSize := (UInt32(Marshal.SizeOf(cf)));
  cf.szFaceName := New(TArrayOfWideChar, 32);
  wpar := IntPtr.Create(SCF_SELECTION);
  lpar := Marshal.AllocCoTaskMem(Marshal.SizeOf(cf));
  Marshal.StructureToPtr(cf, lpar, False);
  res := SendMessage(Self.Handle, EM_GETCHARFORMAT, wpar, lpar);
  cf := (CHARFORMAT2_STRUCT(Marshal.PtrToStructure(lpar, TypeOf(CHARFORMAT2_STRUCT))));
  
  if ((cf.dwMask and mask) = mask) then
    if ((cf.dwEffects and effect) = effect) then
      state := 1
    else
      state := 0
  else
    state := -1;
  Marshal.FreeCoTaskMem(lpar);
  Result := state;
end;

end.

Und hier noch der Quellcode

Delphi-Quellcode:

using System;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;
using System.Runtime.InteropServices;

namespace RichTextBoxLinks
{
   public class RichTextBoxEx : RichTextBox
   {
      #region Interop-Defines
      [ StructLayout( LayoutKind.Sequential )]
      private struct CHARFORMAT2_STRUCT
      {
         public UInt32   cbSize; 
         public UInt32   dwMask; 
         public UInt32   dwEffects; 
         public Int32    yHeight; 
         public Int32    yOffset; 
         public Int32   crTextColor; 
         public byte     bCharSet; 
         public byte     bPitchAndFamily; 
         [MarshalAs(UnmanagedType.ByValArray, SizeConst=32)]
         public char[]   szFaceName; 
         public UInt16   wWeight;
         public UInt16   sSpacing;
         public int      crBackColor; // Color.ToArgb() -> int
         public int      lcid;
         public int      dwReserved;
         public Int16   sStyle;
         public Int16   wKerning;
         public byte      bUnderlineType;
         public byte      bAnimation;
         public byte      bRevAuthor;
         public byte      bReserved1;
      }

      [DllImport("user32.dll", CharSet=CharSet.Auto)]
      private static extern IntPtr SendMessage(IntPtr hWnd, int msg, IntPtr wParam, IntPtr lParam);

      private const int WM_USER          = 0x0400;
      private const int EM_GETCHARFORMAT    = WM_USER+58;
      private const int EM_SETCHARFORMAT    = WM_USER+68;

      private const int SCF_SELECTION   = 0x0001;
      private const int SCF_WORD      = 0x0002;
      private const int SCF_ALL      = 0x0004;

      #region CHARFORMAT2 Flags
      private const UInt32 CFE_BOLD      = 0x0001;
      private const UInt32 CFE_ITALIC      = 0x0002;
      private const UInt32 CFE_UNDERLINE   = 0x0004;
      private const UInt32 CFE_STRIKEOUT   = 0x0008;
      private const UInt32 CFE_PROTECTED   = 0x0010;
      private const UInt32 CFE_LINK      = 0x0020;
      private const UInt32 CFE_AUTOCOLOR   = 0x40000000;
      private const UInt32 CFE_SUBSCRIPT   = 0x00010000;      /* Superscript and subscript are */
      private const UInt32 CFE_SUPERSCRIPT= 0x00020000;      /*  mutually exclusive          */

      private const int CFM_SMALLCAPS      = 0x0040;         /* (*)   */
      private const int CFM_ALLCAPS      = 0x0080;         /* Displayed by 3.0   */
      private const int CFM_HIDDEN      = 0x0100;         /* Hidden by 3.0 */
      private const int CFM_OUTLINE      = 0x0200;         /* (*)   */
      private const int CFM_SHADOW      = 0x0400;         /* (*)   */
      private const int CFM_EMBOSS      = 0x0800;         /* (*)   */
      private const int CFM_IMPRINT      = 0x1000;         /* (*)   */
      private const int CFM_DISABLED      = 0x2000;
      private const int CFM_REVISED      = 0x4000;

      private const int CFM_BACKCOLOR      = 0x04000000;
      private const int CFM_LCID         = 0x02000000;
      private const int CFM_UNDERLINETYPE   = 0x00800000;      /* Many displayed by 3.0 */
      private const int CFM_WEIGHT      = 0x00400000;
      private const int CFM_SPACING      = 0x00200000;      /* Displayed by 3.0   */
      private const int CFM_KERNING      = 0x00100000;      /* (*)   */
      private const int CFM_STYLE         = 0x00080000;      /* (*)   */
      private const int CFM_ANIMATION      = 0x00040000;      /* (*)   */
      private const int CFM_REVAUTHOR      = 0x00008000;


      private const UInt32 CFM_BOLD      = 0x00000001;
      private const UInt32 CFM_ITALIC      = 0x00000002;
      private const UInt32 CFM_UNDERLINE   = 0x00000004;
      private const UInt32 CFM_STRIKEOUT   = 0x00000008;
      private const UInt32 CFM_PROTECTED   = 0x00000010;
      private const UInt32 CFM_LINK      = 0x00000020;
      private const UInt32 CFM_SIZE      = 0x80000000;
      private const UInt32 CFM_COLOR      = 0x40000000;
      private const UInt32 CFM_FACE      = 0x20000000;
      private const UInt32 CFM_OFFSET      = 0x10000000;
      private const UInt32 CFM_CHARSET   = 0x08000000;
      private const UInt32 CFM_SUBSCRIPT   = CFE_SUBSCRIPT | CFE_SUPERSCRIPT;
      private const UInt32 CFM_SUPERSCRIPT= CFM_SUBSCRIPT;

      private const byte CFU_UNDERLINENONE      = 0x00000000;
      private const byte CFU_UNDERLINE         = 0x00000001;
      private const byte CFU_UNDERLINEWORD      = 0x00000002; /* (*) displayed as ordinary underline   */
      private const byte CFU_UNDERLINEDOUBLE      = 0x00000003; /* (*) displayed as ordinary underline   */
      private const byte CFU_UNDERLINEDOTTED      = 0x00000004;
      private const byte CFU_UNDERLINEDASH      = 0x00000005;
      private const byte CFU_UNDERLINEDASHDOT      = 0x00000006;
      private const byte CFU_UNDERLINEDASHDOTDOT   = 0x00000007;
      private const byte CFU_UNDERLINEWAVE      = 0x00000008;
      private const byte CFU_UNDERLINETHICK      = 0x00000009;
      private const byte CFU_UNDERLINEHAIRLINE   = 0x0000000A; /* (*) displayed as ordinary underline   */

      #endregion

      #endregion

      public RichTextBoxEx()
      {
         // Otherwise, non-standard links get lost when user starts typing
         // next to a non-standard link
         this.DetectUrls = false;
      }

      [DefaultValue(false)]
      public new bool DetectUrls
      {
         get { return base.DetectUrls; }
         set { base.DetectUrls = value; }
      }

      /// <summary>
      /// Insert a given text as a link into the RichTextBox at the current insert position.
      /// </summary>
      /// <param name="text">Text to be inserted</param>
      public void InsertLink(string text)
      {
         InsertLink(text, this.SelectionStart);
      }

      /// <summary>
      /// Insert a given text at a given position as a link. 
      /// </summary>
      /// <param name="text">Text to be inserted</param>
      /// <param name="position">Insert position</param>
      public void InsertLink(string text, int position)
      {
         if (position < 0 || position > this.Text.Length)
            throw new ArgumentOutOfRangeException("position");

         this.SelectionStart = position;
         this.SelectedText = text;
         this.Select(position, text.Length);
         this.SetSelectionLink(true);
         this.Select(position + text.Length, 0);
      }
      
      /// <summary>
      /// Insert a given text at at the current input position as a link.
      /// The link text is followed by a hash (#) and the given hyperlink text, both of
      /// them invisible.
      /// When clicked on, the whole link text and hyperlink string are given in the
      /// LinkClickedEventArgs.
      /// </summary>
      /// <param name="text">Text to be inserted</param>
      /// <param name="hyperlink">Invisible hyperlink string to be inserted</param>
      public void InsertLink(string text, string hyperlink)
      {
         InsertLink(text, hyperlink, this.SelectionStart);
      }

      /// <summary>
      /// Insert a given text at a given position as a link. The link text is followed by
      /// a hash (#) and the given hyperlink text, both of them invisible.
      /// When clicked on, the whole link text and hyperlink string are given in the
      /// LinkClickedEventArgs.
      /// </summary>
      /// <param name="text">Text to be inserted</param>
      /// <param name="hyperlink">Invisible hyperlink string to be inserted</param>
      /// <param name="position">Insert position</param>
      public void InsertLink(string text, string hyperlink, int position)
      {
         if (position < 0 || position > this.Text.Length)
            throw new ArgumentOutOfRangeException("position");

         this.SelectionStart = position;
         this.SelectedRtf = @"{\rtf1\ansi "+text+@"\v #"+hyperlink+@"\v0}";
         this.Select(position, text.Length + hyperlink.Length + 1);
         this.SetSelectionLink(true);
         this.Select(position + text.Length + hyperlink.Length + 1, 0);
      }

      /// <summary>
      /// Set the current selection's link style
      /// </summary>
      /// <param name="link">true: set link style, false: clear link style</param>
      public void SetSelectionLink(bool link)
      {
         SetSelectionStyle(CFM_LINK, link ? CFE_LINK : 0);
      }
      /// <summary>
      /// Get the link style for the current selection
      /// </summary>
      /// <returns>0: link style not set, 1: link style set, -1: mixed</returns>
      public int GetSelectionLink()
      {
         return GetSelectionStyle(CFM_LINK, CFE_LINK);
      }


      private void SetSelectionStyle(UInt32 mask, UInt32 effect)
      {
         CHARFORMAT2_STRUCT cf = new CHARFORMAT2_STRUCT();
         cf.cbSize = (UInt32)Marshal.SizeOf(cf);
         cf.dwMask = mask;
         cf.dwEffects = effect;

         IntPtr wpar = new IntPtr(SCF_SELECTION);
         IntPtr lpar = Marshal.AllocCoTaskMem( Marshal.SizeOf( cf ) ); 
         Marshal.StructureToPtr(cf, lpar, false);

         IntPtr res = SendMessage(Handle, EM_SETCHARFORMAT, wpar, lpar);

         Marshal.FreeCoTaskMem(lpar);
      }

      private int GetSelectionStyle(UInt32 mask, UInt32 effect)
      {
         CHARFORMAT2_STRUCT cf = new CHARFORMAT2_STRUCT();
         cf.cbSize = (UInt32)Marshal.SizeOf(cf);
         cf.szFaceName = new char[32];

         IntPtr wpar = new IntPtr(SCF_SELECTION);
         IntPtr lpar =    Marshal.AllocCoTaskMem( Marshal.SizeOf( cf ) ); 
         Marshal.StructureToPtr(cf, lpar, false);

         IntPtr res = SendMessage(Handle, EM_GETCHARFORMAT, wpar, lpar);

         cf = (CHARFORMAT2_STRUCT)Marshal.PtrToStructure(lpar, typeof(CHARFORMAT2_STRUCT));

         int state;
         // dwMask holds the information which properties are consistent throughout the selection:
         if ((cf.dwMask & mask) == mask) 
         {
            if ((cf.dwEffects & effect) == effect)
               state = 1;
            else
               state = 0;
         }
         else
         {
            state = -1;
         }
         
         Marshal.FreeCoTaskMem(lpar);
         return state;
      }
   }
}

Ich muß zugeben, das ich die Methoden SetSelectionStyle und GetSelectionStyle nicht so ganz verstehe auch wenn ich sie (vielleicht) richtig übersetzt haben sollte.

Das liegt daran, das ich nirgends eine Erklärung finde, was zum ein Marschall ist und Delphis OH bei allen passenden Links mir eine fehlerhafte Seite darstellt

[Robert_G]

Zitat von Taladan:

Ich habe mich jetzt so ein wenig durchgewurschtelt. Compiliert wird der Code von Delphi. Das Elemement wird auch erstellt. Jedoch werden die erwünschten Links nicht als Link angezeigt, geschweige den, das sie als solche genutzt werden können

Warum nimmst du nicht den C# Code als Vorlage, den ich für dich auf das nötige reduziert habe?
Warum machst du aus Konstanten[1] Felder deiner Klasse? Die haben doch jetzt gar nicht mehr die Werte, die du an die API Funktionen übergeben musst...

Zitat von Taladan:

Das liegt daran, das ich nirgends eine Erklärung finde, was zum ein Marschall ist und Delphis OH bei allen passenden Links mir eine fehlerhafte Seite darstellt

Dann vergesse einfach die "OH" von Delphi! Im Startmenü findest du das .Net SDK, dort eine blaue Verknüpfung mit einem Fragezeichen. Das ist die richitge .Net Doku und die zeigt dir auch was du sie fragst...


[1]*brrr* über num. Konstanten in .Net habe ich mich oben ausgelassen und im Code auch eine alternative gezeigt

[Taladan]

Das war nicht dein Code?
Mist und ich dachte ich bearbeite die ganze Zeit deinen. Arg ok... noch mal von vorn...