Übersetzung Class MagneticWindow

[EWeiss]

Wie in anderen Threads schon begonnen ..
Ich möchte meine Magnetic Class nach Delphi übersetzen um meinen
MediPlayer stück für stück nach Delphi zu konvertieren.

Die Classe emuliert die exakten Dockeigenschaften wie sie auch
in Winamp zur verfügung stehen.
Nach der Übersetzung werde ich sie hier zur verfügung stellen.

Meine aktuelle frage.

Code:

Vb:
Private Enum eMsgWhen
    [MSG_AFTER] = 1                                  
    [MSG_BEFORE] = 2                                 
    [MSG_BEFORE_AND_AFTER] = MSG_AFTER Or MSG_BEFORE 
End Enum

Wie wird in Delphi Enum declariert ?

gruß

[Muetze1]

Delphi-Quellcode:

Type
  eMsgWhen = ( MSG_AFTER, MSG_BEFORE, MSG_BEFORE_AND_AFTER );

Dabei wird aber die Wertbelegung anders gehandhabt. Das erste Element hat den Ordinalwert von 0, alle weiteren aufsteigend. Ich denke bei diesem Typ würde ein Set besser passen (vergleichbar mit einer Bitmaske):

Delphi-Quellcode:

Type
  eMsgWhen = Set Of ( MSG_AFTER, MSG_BEFORE );

Dann hast du die Möglichkeit die Typen zu kombinieren:

Beispiel:

Delphi-Quellcode:

Var
  lVar: eMsgWhen;
Begin
  lVar := []; // keins
  lVar := [MSG_AFTER, MSG_BEFORE]; // beide
  lVar := [MSG_AFTER]; // nur einer
End;

Zu dem Hinzufügen und Entfernen kannst du auch die Funktionen Include() und Exclude() nutzen. Abfragen ob ein Element in der Menge ist geschieht mit IN:

Delphi-Quellcode:

  If MSG_AFTER In lVar Then
    ShowMessage('jo, after');

[EWeiss]

Delphi-Quellcode:

Type 
  eMsgWhen = Set Of ( MSG_AFTER, MSG_BEFORE );

wenn ich das richtig verstanden habe kann man den wert nicht direkt zuweisen.
Würde bedeuten MSG_AFTER ist gleichzusetzen mit 0 ?

gruß

[Muetze1]

Zitat:

Zitat von EWeiss

Delphi-Quellcode:

Type 
  eMsgWhen = Set Of ( MSG_AFTER, MSG_BEFORE );

wenn ich das richtig verstanden habe kann man den wert nicht direkt zuweisen.
Würde bedeuten MSG_AFTER ist gleichzusetzen mit 0 ?

gruß

Ja, und MSG_BEFORE wäre mit dem Ordinalwert 1 gleich zu setzen.

Hinweis: Ich arbeite maximal mit Delphi 7, daher kann es gut sein, dass es in deiner Delphiversion die Möglichkeit der Wertzuweisung bei den Enum's gibt. Davon weiss ich aber nichts aus Ermangelung einer höheren Version. (Und ich weigere mich Dinge zu erlernen, die ich nicht praktisch anwenden kann...)

[EWeiss]

Zitat:

Hinweis: Ich arbeite maximal mit Delphi 7, daher kann es gut sein, dass es in deiner Delphiversion die Möglichkeit der Wertzuweisung bei den Enum's gibt. Davon weiss ich aber nichts aus Ermangelung einer höheren Version. (Und ich weigere mich Dinge zu erlernen, die ich nicht praktisch anwenden kann...)

Ich habe es mal getestet.
Es scheint so als wenn der compiler es annehmen würde.
Kommt zumindest kein Fehler.

Delphi-Quellcode:

Type
  eMsgWhen = Set Of (MSG_AFTER = 1, MSG_BEFORE = 2, MSG_BEFORE_AND_AFTER = MSG_AFTER Or MSG_BEFORE);
    // MSG_AFTER             Message calls back after the original (previous) WndProc
    // MSG_BEFORE            Message calls back before the original (previous) WndProc
    // MSG_BEFORE_AND_AFTER  Message calls back before and after the original (previous) WndProc

gruß

[EWeiss]

Code:

Private Const ALL_MESSAGES     As Long = -1          'All messages added or deleted
Private Const CODE_LEN         As Long = 197         'Length of the machine code in bytes
Private Const GWL_WNDPROC      As Long = -4          'Get/SetWindow offset to the WndProc procedure address
Private Const PATCH_04         As Long = 88          'Table B (before) address patch offset
Private Const PATCH_05         As Long = 93          'Table B (before) entry count patch offset
Private Const PATCH_08         As Long = 132         'Table A (after) address patch offset
Private Const PATCH_09         As Long = 137         'Table A (after) entry count patch offset

Delphi-Quellcode:

Const
ALL_MESSAGES     : Integer = -1;          //All messages added or deleted
CODE_LEN         : Integer = 197;         //Length of the machine code in bytes
GWL_WNDPROC      : Integer = -4;          //Get/SetWindow offset to the WndProc procedure address
PATCH_04         : Integer = 88;          //Table B (before) address patch offset
PATCH_05         : Integer = 93;          //Table B (before) entry count patch offset
PATCH_08         : Integer = 132;         //Table A (after) address patch offset
PATCH_09         : Integer = 137;         //Table A (after) entry count patch offset

Das dürfte wohl so stimmen, GWL_WNDPROC wird man wohl entfernen können
da die Const eigentlich in der Windows.pas vorhanden sein müßte.

Code:

Private Type tSubData                                'Subclass data type
    hwnd                       As Long               'Handle of the window being subclassed
    nAddrSub                   As Long               'The address of our new WndProc (allocated memory).
    nAddrOrig                  As Long               'The address of the pre-existing WndProc
    nMsgCntA                   As Long               'Msg after table entry count
    nMsgCntB                   As Long               'Msg before table entry count
    aMsgTblA()                 As Long               'Msg after table array
    aMsgTblB()                 As Long               'Msg Before table array
End Type

Hier bin ich nicht sicher wie ich mit dem Variablen array verfahren soll.

Edit:
Denke so gehts!

Delphi-Quellcode:

Type TSubData = ^SubData;                               //Subclass data type
    SubData = record
    hwnd                       : Integer;               //Handle of the window being subclassed
    nAddrSub                   : Integer;               //The address of our new WndProc (allocated memory).
    nAddrOrig                  : Integer;               //The address of the pre-existing WndProc
    nMsgCntA                   : Integer;               //Msg after table entry count
    nMsgCntB                   : Integer;               //Msg before table entry count
    aMsgTblA                   : array [] of Integer;   //Msg after table array
    aMsgTblB                   : array [] of Integer;   //Msg Before table array
End;

gruß

[Muetze1]

In der Standardeinstellung sind deine Konstanten nicht wirklich konstant: man kann ihnen Werte zuweisen. So sind es dann statische Variablen.

Warum definierst du einen Zeiger auf die Struktur? Im Normalfall wird mit Txxx eine Klasse oder eine Struktur gekennzeichnet. Einem Zeiger auf eine Struktur wird im Normalfall ein Pxxx anstatt einem Txxx vorangestellt.

Und die [] bei dem Array kannst du getrost weglassen...

[EWeiss]

Zitat:

Zitat von Muetze1

In der Standardeinstellung sind deine Konstanten nicht wirklich konstant: man kann ihnen Werte zuweisen. So sind es dann statische Variablen.

Warum definierst du einen Zeiger auf die Struktur? Im Normalfall wird mit Txxx eine Klasse oder eine Struktur gekennzeichnet. Einem Zeiger auf eine Struktur wird im Normalfall ein Pxxx anstatt einem Txxx vorangestellt.

Und die [] bei dem Array kannst du getrost weglassen...

Delphi-Quellcode:

Type PSubData = ^TSubData;                           //Subclass data type
    TSubData = record
    hwnd                       : Integer;            //Handle of the window being subclassed
    nAddrSub                   : Integer;            //The address of our new WndProc (allocated memory).
    nAddrOrig                  : Integer;            //The address of the pre-existing WndProc
    nMsgCntA                   : Integer;            //Msg after table entry count
    nMsgCntB                   : Integer;            //Msg before table entry count
    aMsgTblA                   : array of Integer;   //Msg after table array
    aMsgTblB                   : array of Integer;   //Msg Before table array
End;

Mit den Zeiger habe ich mir abgeschaut um die Leute hier nicht zu nerven :oops:
Wird hier kein zeiger benötigt? Und wenn warum ?

gruß

[himitsu]

Wenn möglich sollte man wohl bei Integer- und Stringkonstanten keinen Typ angeben

Delphi-Quellcode:

const
  abc = 123;
  def = 'xyz';

Das hat vorallem den Vorteil, daß der Typ nicht schon da festgelegt ist und dieser dann anhand des Wertes und bei direkter Übergabe anhand des dortigen Types vom Compiler festgelegt wird.

Speziell den String kann man dann auch als WideString/PWideChar übergeben, ohne daß es zu inkompatiblen Typen (AnsiString<>WideString und PAnsiChar<>PWideChar) kommt.

[EWeiss]

Zitat:

Zitat von himitsu

Wenn möglich sollte man wohl bei Integer- und Stringkonstanten keinen Typ angeben

Delphi-Quellcode:

const
  abc = 123;
  def = 'xyz';

Das hat vorallem den Vorteil, daß der Typ nicht schon da festgelegt ist und dieser dann anhand des Wertes und bei direkter Übergabe anhand des dortigen Types vom Compiler festgelegt wird.

Speziell den String kann man dann auch als WideString/PWideChar übergeben, ohne daß es zu inkompatiblen Typen (AnsiString<>WideString und PAnsiChar<>PWideChar) kommt.

Das ist allerdings ein argument.
Hab sowieso meine problem mit der konvertierung von einigen variablen.
Aber das kommt noch ;) Eile mit weile.

werd dann mal die integer alle löschen ;)


gruß

[Union]

Mal etwas ganz anderes - bei Deiner Kurzbeschreibung was Deine Magnetic-Klasse macht solltest Du vielleicht mal unter DockSite nachsehen. Vielleicht spart Dir das eine Menge Arbeit. Wenn Du die Umstellung der Klasse auf Delphi allerdings nur als Übung machen willst, halte ich es für den Einstieg vielleicht für ein wenig zu komplex.

[EWeiss]

Zitat:

Zitat von Union

Mal etwas ganz anderes - bei Deiner Kurzbeschreibung was Deine Magnetic-Klasse macht solltest Du vielleicht mal unter DockSite nachsehen. Vielleicht spart Dir das eine Menge Arbeit. Wenn Du die Umstellung der Klasse auf Delphi allerdings nur als Übung machen willst, halte ich es für den Einstieg vielleicht für ein wenig zu komplex.

Nein soll keine übung sein.

Bin mit dieser Klasse eigentlich bisher sehr gut gefahren mit meinen Player.
Möchte wenn möglich meinen Code(VB) so halbwegs erhalten.

Übung in soweit das wenn ich meinen Player umschreibe
ich auf die bisher gewonnenen Erkenntnisse zurückgreifen kann.

Werde mir das Projekt 'DockSite' wenn es eins ist trotzdem einmal anschauen ;)

EDIT;
Sehe gerade du meinst die Delphi Hilfe ..... :-D

gruß

[Union]

Zitat:

Werde mir das Projekt 'DockSite' wenn eins ist trotzdem einmal anschauen

Nein, das ist kein Projekt sondern eine Standard-Eigenschaft von Delphi. Die VCL-Komponenten sind von sich aus dockingfähig, da braucht man nur sehr wenig zu programmieren. Schau mal unter file://C:\Programme\Borland\BDS\4.0\Demos\DelphiWin32\VCL Win32\Docking nach, da ist ein Beispielprojekt.

[EWeiss]

Zitat:

Zitat von Union

Zitat:

Werde mir das Projekt 'DockSite' wenn eins ist trotzdem einmal anschauen

Nein, das ist kein Projekt sondern eine Standard-Eigenschaft von Delphi. Die VCL-Komponenten sind von sich aus dockingfähig, da braucht man nur sehr wenig zu programmieren. Schau mal unter file://C:\Programme\Borland\BDS\4.0\Demos\DelphiWin32\VCL Win32\Docking nach, da ist ein Beispielprojekt.

Habs mir mal angeschaut!
Nein das ist etwas komplett anderes da geht es um Docking in einer MDI Form
Komponente innerhalb einer Form andocken.

Bei mir docken alle übergebenen Fenster gegenseitig an
Und können über das Hauptfenster(Applikation) gleichzeitig verschoben werden.

EDIT:
Ich will aber niemanden nerven oder das Forum zumüllen. :roll:
Traue mich jetzt gar nicht mehr zu fragen :cry:

Gruß

[EWeiss]

Problem mit Property

Delphi-Quellcode:

Type TMagnetic = class
   constructor Create;
   constructor Destroy;
   private
    function GetSnapWidth: Integer;
    procedure SetSnapWidth(NewSnapWidth: Integer);
   public
    property SnapWidth: Integer read GetSnapWidth write SetSnapWidth;

Delphi-Quellcode:

function TMagnetic.GetSnapWidth: Integer;
begin
  Result := SnapWidth;
end;

procedure TMagnetic.SetSnapWidth(NewSnapWidth: Integer);
begin
  SnapWidth := NewSnapWidth;
end;

In Create wird die default SnapWidth zugewiesen.

Delphi-Quellcode:

constructor TMagnetic.create;
begin
  // Default snap width
  SnapWidth := 10;

  // Initialize array (handled windows info)
  m_lWndCount := 0;
end;

Hier kommt der Fehler!

Delphi-Quellcode:

                        Case True of
                          Abs(rcTmp.x1 - x1) < SnapWidth:
                           rcWnd.x1 := x1;
                          Abs(rcTmp.x1 - x2) < SnapWidth:
                           rcWnd.x1 := x2;
                        End;

Zitat:

[Pascal Error] Magnetic.pas(386): E2026 Constant expression expected

Wo liegt das Problem ?

gruß

[Union]

Delphi-Quellcode:

function TMagnetic.GetSnapWidth: Integer; 
begin 
  Result := SnapWidth; 
end; 

property SnapWidth: Integer read GetSnapWidth write SetSnapWidth;

Also diese Kombination ist schon mal tödlich, da rekursiv - der Getter ruft die Property auf, diese wieder den Getter... Du solltest ein internes Feld anlegen (FSnapWidth).

Delphi-Quellcode:

  TMagnetic = class
  private
    FSnapWidth: integer;
    procedure SetSnapWidth(const Value: integer);
  public
     Property SnapWidth : integer read FSnapWidth write SetSnapWidth;
  end;

Geht übrigens vollautomatisch, wenn Du auf der Zeile stehst...

Delphi-Quellcode:

Property SnapWidth : integer

... und dann Strg-Shift-C drückst!
Uups, sorry xaromz da war ich wohl wieder zu schnell...

[xaromz]

Hallo,

Zitat:

Zitat von EWeiss

Problem mit Property

Vorsicht! Hier

Delphi-Quellcode:

procedure TMagnetic.SetSnapWidth(NewSnapWidth: Integer);
begin
  SnapWidth := NewSnapWidth;
end;

hast Du eine Rekursion gebaut. Die Zuweisung ruft ja wieder SetSnapWidth auf!

Delphi-Quellcode:

                        Case True of
                          Abs(rcTmp.x1 - x1) < SnapWidth:
                           rcWnd.x1 := x1;
                          Abs(rcTmp.x1 - x2) < SnapWidth:
                           rcWnd.x1 := x2;
                        End;

Das Problem ist, dass die Werte, die bei case als Möglichkeiten angegeben werden, Konstanten sein müssen.
Du musst das also umformulieren:

Delphi-Quellcode:

case Abs(rcTmp.x1 - x1) < SnapWidth of
  True:
    rcWnd.x1 := x1;
  False:
    rcWnd.x1 := x2;
end;

Gruß
xaromz

[rayman]

Ich glaube er meint aber:

Delphi-Quellcode:

if (Abs(rcTmp.x1 - x1) < SnapWidth) then rcWnd.x1 := x1;
if (Abs(rcTmp.x1 - x2) < SnapWidth) then rcWnd.x1 := x2;

[EWeiss]

Zitat:

Zitat von rayman

Ich glaube er meint aber:

Delphi-Quellcode:

if (Abs(rcTmp.x1 - x1) < SnapWidth) then rcWnd.x1 := x1;
if (Abs(rcTmp.x1 - x2) < SnapWidth) then rcWnd.x1 := x2;

Nein..

Delphi-Quellcode:

                                
Case True of
   Abs(rcTmp.x1 - x1) < SnapWidth:
   Begin
   lOffx := x1 - rcTmp.x1;
   end;
   Abs(rcTmp.x1 - x2) < SnapWidth:
   Begin
   lOffx := x2 - rcTmp.x1;
   end;
   Abs(rcTmp.x2 - x1) < SnapWidth:
   begin
   lOffx := x1 - rcTmp.x2;
   end;
   Abs(rcTmp.x2 - x2) < SnapWidth:
   begin
   lOffx := x2 - rcTmp.x2;
   end;
End;

gruß

[EWeiss]

Zitat:

Geht übrigens vollautomatisch, wenn Du auf der Zeile stehst...

Habe ich genau nach deiner Anweisung von letztens versucht!
Bei dieser Kombination wir die procedure automatisch erstellt aber ohne Inhalt :)

Zitat:

(FSnapWidth).

Verstehe ich nicht dafür gibt es doch

Delphi-Quellcode:

function TMagnetic.GetSnapWidth: Integer;
begin
  Result := SnapWidth;
end;

gruß

[Union]

Genau das sorgt ja für die Rekursion. Die Property heisst SnapWidth. Der Getter heist GetSnapWidth. Wenn innerhalb des Getters wieder SnapWidth steht, wird die Property angesprochen. Diese ruft den Getter auf etc. Der ursprüngliche Tip mit der Klassenvervollständigung kam nicht von mir.

[EWeiss]

Zitat:

Zitat von Union

Genau das sorgt ja für die Rekursion. Die Property heisst SnapWidth. Der Getter heist GetSnapWidth. Wenn innerhalb des Getters wieder SnapWidth steht, wird die Property angesprochen. Diese ruft den Getter auf etc. Der ursprüngliche Tip mit der Klassenvervollständigung kam nicht von mir.

Ok verstehe.. obwohl igendwie nicht logisch! in Delphi ;)

Code:

Public Property Get SnapWidth() As Long
    SnapWidth = m_lSnapWidth
End Property

Public Property Let SnapWidth(ByVal New_SnapWidth As Long)
    m_lSnapWidth = New_SnapWidth
End Property

Bei Let wird der neue Wert m_lSnapWidth zugewiesen wenn
dieser übergeben wird ..

Code:

Private Sub Class_Initialize()
    
    '-- Default snap width
    m_lSnapWidth = 10  // Hier wird er übergeben beim initialisieren der klasse
    
    '-- Initialize array (handled windows info)
    ReDim m_uWndInfo(0) As WND_INFO
    m_lWndCount = 0
End Sub

und in der Public Variablen m_lSnapWidth gespeichert.
Über 'Get SnapWidth' kann ich die Variable abfragen welchen aktuellen wert sie hat.

Klappt in VB !:)

gruß

[xaromz]

Hallo,

Zitat:

Zitat von EWeiss

und in der Public Variablen m_lSnapWidth gespeichert.
Über 'Get SnapWidth' kann ich die Variable abfragen welchen aktuellen wert sie hat.

Klappt in VB !:)

Das klappt auch wunderbar in Delphi. Aber wo speicherst Du denn einen Wert in einer privaten Variablen? Da ist in Deinem Quelltext nichts zu finden.
In Delphi sehen Getter und Setter so aus:

Delphi-Quellcode:

function TMagnetic.GetSnapWidth: Integer; 
begin 
  Result := FSnapWidth; 
end;

procedure TMagnetic.SetSnapWidth(const Value: Integer); 
begin 
  FSnapWidth := Value;
end;

Zusätzlich wird unter private ein Feld FSnapWidth angelegt, in dem die Werte dann gespeichert werden.

Gruß
xaromz

[EWeiss]

So gehts !

Delphi-Quellcode:

WMSZ_LEFT, WMSZ_TOPLEFT, WMSZ_BOTTOMLEFT:
  begin
      case Abs(rcTmp.x1 - x1) < SnapWidth of True:
       rcWnd.x1 := x1;
      end;
      case Abs(rcTmp.x1 - x2) < SnapWidth of true:
       rcWnd.x1 := x2;
      End;
   End;

Danke.

Gruß

[EWeiss]

Zitat:

Zitat von xaromz

Hallo,

Zitat:

Zitat von EWeiss

und in der Public Variablen m_lSnapWidth gespeichert.
Über 'Get SnapWidth' kann ich die Variable abfragen welchen aktuellen wert sie hat.

Klappt in VB !:)

Das klappt auch wunderbar in Delphi. Aber wo speicherst Du denn einen Wert in einer privaten Variablen? Da ist in Deinem Quelltext nichts zu finden.
In Delphi sehen Getter und Setter so aus:

Delphi-Quellcode:

function TMagnetic.GetSnapWidth: Integer; 
begin 
  Result := FSnapWidth; 
end;

procedure TMagnetic.SetSnapWidth(const Value: Integer); 
begin 
  FSnapWidth := Value;
end;

Zusätzlich wird unter private ein Feld FSnapWidth angelegt, in dem die Werte dann gespeichert werden.

Gruß
xaromz

Eine Frage nur zum verständnis!
Warum wird dann in der procedure nicht auch GetSnapWidth übergeben

Delphi-Quellcode:

property SnapWidth: Integer read GetSnapWidth write SetSnapWidth;

anstatt

Delphi-Quellcode:

property SnapWidth: Integer read FSnapWidth write SetSnapWidth;

GetSnapWidth wird dann doch nirgends aufgerufen oder?

gruß

[Union]

Man kann beide Möglichkeiten verwenden. Solange der Getter nur einen Wert zurückliefert, kann man sich die Get-Funktion sparen und direkt den Wert über die read-Direktive ansprechen. Anders sieht es aus, wenn der Getter aktiv einen Wert ermittelt.

Und man sollte die Get/Set-Funktionen nur in der Deklaration anwenden. Entweder man spricht innerhalb derselben Klasse direkt die Variablen an (in Sonderfällen, wenn man z.B. Rekursion vermeiden will) oder über den Namen der Property. Innerhalb einer Klasse mit einfachen Set/Get gilt ja Property <=> Getter <=> Feld.

[EWeiss]

Schwierig!!

Dieser Hexadezimale String

Delphi-Quellcode:

sSubCode := '5589E583C4F85731C08945FC8945F8EB0EE80000000083F802742185C07424E830000000837DF800750AE838000000E84D0000005F8B
             45FCC9C21000E826000000EBF168000000006AFCFF7508E800000000EBE031D24ABF00000000B900000000E82D000000C3FF7514FF75
             10FF750CFF75086800000000E8000000008945FCC331D2BF00000000B900000000E801000000C3E32F09C978078B450CF2AF75248D451
             4508D4510508D450C508D4508508D45FC508D45F85052B800000000508B00FF501CC3'

wird über eine split function in Byte konvertiert
und in einen statischen Buffer kopiert.

Jetzt kommt in Delphi die meldung String zu lang!

EDIT: habs versucht mit WideString, PWChar usw ...

Hat sich erledigt!

Delphi-Quellcode:

    If (sc_aBuf[1] = 0) Then
     Begin
        //Build the hex pair subclass string
        sSubCode := '5589E583C4F85731' + 'C08945FC8945F8EB' +
                    '0EE80000000083F8' + '02742185C07424E8' +
                    '30000000837DF800' + '750AE838000000E8' +
                    '4D0000005F8B45FC' + 'C9C21000E8260000' +
                    '00EBF16800000000' + '6AFCFF7508E80000' +
                    '0000EBE031D24ABF' + '00000000B9000000' +
                    '00E82D000000C3FF' + '7514FF7510FF750C' +
                    'FF75086800000000' + 'E8000000008945FC' +
                    'C331D2BF00000000' + 'B900000000E80100' +
                    '0000C3E32F09C978' + '078B450CF2AF7524' +
                    '8D4514508D451050' + '8D450C508D450850' +
                    '8D45FC508D45F850' + '52B800000000508B' +
                    '00FF501CC3';

gruß

[Elvis]

Hm...
Erhlich gesagt finde ich, du solltest dich erstmal mit der Sprache auseinandersetzen.
Eine native, kompilierte, statisch geprüfte, objektorientierte Sprache verhält sich komplett einfach komplett[1] anders als ein interpretiertes Skript.

Es gibt einige Tutorials bei DSDT.de, sehr nett ist auch www.delphibasics.co.uk oder vllt das OO-Turial von [user]Luckie[user].
Was du da gerade machst ist ein VB "Programm" Stück für Stück zu Delphi rüberzufriemeln. Was am Ende dabei rauskommt ist dann ein VB Programm in Delphi-Syntax.
Wenn du es ganz locker angehst, und einfach mit der Sprache spielst(siehe Tutorials, Beispiele hinter den Links oben) bevor du eine wirkliche Anwendung baust/portierst, wirst du vllt schneller/besser die Eleganz hinter der Art & Weise entdecken in der Delphi Objektorientierung implementiert.
Order einfach die Tatsache, dass ein Stringliteral in Delphi max. 255 Zeichen lang ist. :zwinker:

Dass Problem wird wohl sein, dass je mehr Erfahrung man in VB hat, umso schwieriger wird es sein, seine Erfahrungen komplett wegzuwerfen und neu anzufangen. Genau das müsstest nämlich machen. ;)

[1]ich meine "komplett anders" im Sinne von "Ähnlichkeiten sind eher zufällig"

[EWeiss]

Zitat:

Dass Problem wird wohl sein, dass je mehr Erfahrung man in VB hat, umso schwieriger wird es sein, seine Erfahrungen komplett wegzuwerfen und neu anzufangen. Genau das müsstest nämlich machen. ;)

Ja ich weiß das du im grunde recht hast!
Aber warum soll man gute (bewährte klassen ) aus VB nciht nach Delphi portieren können.
Denke mal das man auch so lernen kann wenn auch etwas umständlicher. :?

Aber grundsätzlich gebe ich dir Recht! :-D

Zitat:

Order einfach die Tatsache, dass ein Stringliteral in Delphi max. 255 Zeichen lang ist.

Jo .. gibt aber immer eine möglichkeit dem aus dem wege zugehen auf die eine oder andere art.

EDIT:So unterschiedlich von der Syntax her ist VB/Delphi nun auch wieder nicht!
Wenn es dann mal übersetzt ist fragt niemand mehr auf welche weise dies geschehen ist
Wie willst du dann noch den ansatz oder ähnlichkeiten zu VB erkennen?

Wenn hier jemand einen Quelltext oder codeschnipsel aus den Forum verwendet interessiert es ihn auch nicht
wie der Author den erstellt hat.Für ihn zählt nur das er es verwenden kann.

Also! Am ende zählt das ergebniss wie man dahin gelangt ist letztendlich egal.

gruß

[Elvis]

Zitat:

Zitat von EWeiss

Zitat:

Dass Problem wird wohl sein, dass je mehr Erfahrung man in VB hat, umso schwieriger wird es sein, seine Erfahrungen komplett wegzuwerfen und neu anzufangen. Genau das müsstest nämlich machen. ;)

Ja ich weiß das du im grunde recht hast!
Aber warum soll man gute (bewährte klassen ) aus VB nciht nach Delphi portieren können.
Denke mal das man auch so lernen kann wenn auch etwas umständlicher. :?

Nunja, die meisten, die sich auf die Art etwas beibringen, können danach nur das was sie brauchten um X in Delphi umzusetzen. Und das auch noch direkt, ohne eine andere Implementierung erwägen zu können, auf die man erst kommt wenn man die Sprache fließend spricht. ;) Wie gesagt, deine VB-Vorgeschichte wird es dir definitiv nicht einfacher machen, ich glaube eher noch schwerer als wenn du noch nie vorher programmiert hättest. Aber nunja, mein Urteil mag da von meiner unheilbar chronischen Allergie gegen VB und diejenigen, die es tatsächlich benutzen, etwas beeinflusst werden. :mrgreen:
Ich sage nicht, dass es unmöglich ist. Ich habe mir bis jetzt jede Programmiersprache selbst beigebracht, aber ich gehöre auch eher zu den Masochisten. :mrgreen:

Zitat:

Aber grundsätzlich gebe ich dir Recht! :-D

;)

Zitat:

Zitat:

Order einfach die Tatsache, dass ein Stringliteral in Delphi max. 255 Zeichen lang ist.

Jo .. gibt aber immer eine möglichkeit dem aus dem wege zugehen auf die eine oder andere art.

Nicht wirklich, ein Stringliteral ist nunmal max. 255 Zeichen groß.
Was du oben gemacht hast ist einen String aus mehren Literalen zusammenzusetzen, die < 255 sind. ;)

Zitat:

EDIT:So unterschiedlich von der Syntax her ist VB/Delphi nun auch wieder nicht!

Aber das was in dem Binary landet bzw. zur Laufzeit passiert hat dem, was in einem interpretierten Skript passiert nichts bis überhaupt nichts zu tun. Das meinte ich mit "Ähnlichkeiten sind eher zufällig". ;)

[EWeiss]

Nur am Rande!

Nuja da sind wir wieder bei den leidigen Problem Delphi via Vb!
Von Delphi hat noch niemand gesprochen als die von dir so verspottete Sprache (Basic)-VB
schon aus den gröbsten raus war.
Bill Gates hat nicht umsonst solange an VB festgehalten oder wurde er mit Delphi reich?
Frag ihn mal wie es war als er mit Hilfe von Basic das erste Betriebssystem in seiner
Garage entwickelt hat.
Gehe mal davon aus das er dann auch zu denjenigen gehört welche von deiner unheilbar
chronischen Allergie betroffen sind. :?

Will damit nur sagen Basic war der anfang.. da kann sich Delphi winden wie es will!
Ich frage mich nur woher kommt die scriptsprache welche von Delphi verwendet wird ?
Ohhhh hat schon seinen grund das sie sich so ähnlich sind.

Aber trotzdem nur weil die Leute hier zuerst mit Delphi angefangen haben
muss ich noch lange keine Allergie gegen diese haben.
Mit meinen 48 beurteile ich die Menschen nach anderen Kriterien !
Und nicht nach einer Sprache die sie irgendwann benutzt haben oder noch benutzen.

gruß

[Union]

[OT]Es ist doch schön dass nicht jede Programmiersprache komplett unterschiedlich ist. BTW hat Bill Gates kein Betriebssystem geschrieben mit Basic. Er hat eins "weiterverkauft". Und Pascal gründet sich auf ALGOL und nicht auf Basic.[/OT]
Und kommen wir wieder zu etwas ganz anderem, nämlich Deiner TMagnetic-Klasse ;)

[Muetze1]

Noch ein Hinweis zu der Klasse auf Seite 1 auf den noch niemand hingewiesen hat: Der Destructor "Destroy" wird mit Destructor und nicht Constructor gekennzeichnet. Auch muss beim Destructor ein "Override;" hinter der Deklaration, da der Destructor als virtuell deklariert ist in TObject.

[EWeiss]

Zitat:

Zitat von Muetze1

Noch ein Hinweis zu der Klasse auf Seite 1 auf den noch niemand hingewiesen hat: Der Destructor "Destroy" wird mit Destructor und nicht Constructor gekennzeichnet. Auch muss beim Destructor ein "Override;" hinter der Deklaration, da der Destructor als virtuell deklariert ist in TObject.

Ich habe etwas gelernt bei den ganzen gefriemel :-D
Das von dir hier angesprochene Problem habe ich schon herausgefunden ;)

Trotzdem Danke.

[EWeiss]

Zitat:

Zitat von Union

[OT]Es ist doch schön dass nicht jede Programmiersprache komplett unterschiedlich ist. BTW hat Bill Gates kein Betriebssystem geschrieben mit Basic. Er hat eins "weiterverkauft". Und Pascal gründet sich auf ALGOL und nicht auf Basic.[/OT]
Und kommen wir wieder zu etwas ganz anderem, nämlich Deiner TMagnetic-Klasse ;)

NaJa wie dem auch sei.
Gefriemel hin gefriemel her..

Nichts ist unmöglich und was unmöglich ist das machen wir möglich! :-D

Gruß

[Elvis]

Zitat:

Zitat von EWeiss

Aber trotzdem nur weil die Leute hier zuerst mit Delphi angefangen haben
muss ich noch lange keine Allergie gegen diese haben.

Nana, du scheinst ja Delphi benutzen zu wollen. Somit fällst du aus der Allergie heraus. ;)
Nicht immer alles auf die schlimmstmögliche Art auslegen, sonst kriegst du noch grundlos Magengeschwüre. :zwinker:

[EWeiss]

Zitat:

Zitat von Elvis

Zitat:

Zitat von EWeiss

Aber trotzdem nur weil die Leute hier zuerst mit Delphi angefangen haben
muss ich noch lange keine Allergie gegen diese haben.

Nana, du scheinst ja Delphi benutzen zu wollen. Somit fällst du aus der Allergie heraus. ;)
Nicht immer alles auf die schlimmstmögliche Art auslegen, sonst kriegst du noch grundlos Magengeschwüre. :zwinker:

1. Habe mir nicht umsonst die Architect zugelegt ;)
Das hindert mich aber nicht daran es weiter zu versuchen.
Freue mich über jede Hilfe

2. War auch nicht auf dich bezogen .. du hast es nur angesprochen das Thema.

Habe ja schon eine kleine Anwendung geschrieben auch wenn es sich nur um
eine Design Studie handelt (Winamp Skin).

Dann lassen wir das Thema hat ja nichts mit dem Thread zu tun!;)

Gruß .. Nix für ungut

[EWeiss]

Neuer versuch nächstes Problem :-D

Delphi-Quellcode:

function TMagnetic.zIdx(lng_hWnd: Integer; bAdd: Boolean = False): Integer;
//Get the sc_aSubData() array index of the passed hWnd
//Get the upper bound of sc_aSubData()
//If you get an error here, you're probably Subclass_AddMsg-ing before Subclass_Start

begin
    zIdx := UBound(sc_aSubData);
     While zIdx >= 0 Do                 //Iterate through the existing sc_aSubData() elements
        With sc_aSubData[zIdx] do
        begin
            If (hwnd = lng_hWnd) Then   //If the hWnd of this element is the one we're looking for
            begin
              If (Not bAdd) Then        //If we're searching not adding
                Exit;                   //Found
              If (hwnd = 0) Then        //If this an element marked for reuse.
              begin
                If (bAdd) Then          //If we're adding
                    Exit;
              end;
            End;
        End;
        dec(zIdx);                      //Decrement the index

End;

Zitat:

zIdx := UBound(sc_aSubData);

UBound kennt Delphi nicht.
UBound-Funktion liefert den größten Index vom Array(sc_aSubData) zurück.
Wie kann ich unter Delphi den größten Index in einem Array ermitteln ?

Erledigt: zIdx := High(sc_aSubData);

Ebenso funktioniert diese abfrage nicht 'While zIdx >= 0 Do' Fehler meldung

Zitat:

[Pascal Error] Magnetic.pas(782): E2035 Not enough actual parameters

Warum muss hier noch das lng_hWnd als Parameter übergeben werden ?

Das scheint zu funktionieren zIdx := zIdx(lng_hWnd) - 1; aber irgendwie unlogisch.

gruß

[Union]

In der Standardkonfiguration heißt es result (extended Syntax). Das hat den Vorteil, dass man die Funktion umbenennen kann, ohne den evtl. verwendeten Namen 20 Mal ebenfalls ändern zu müssen. Und es ermöglicht Rekursion, wenn gewollt.

[Muetze1]

Du hast 100%ig zIdx nicht nochmal woanders verwendet bzw. deklariert? z.B. als Funktionsname?