C++ nach Delphi übersetzen

[SnuffMaster23]

Hi,
ich brauche jemanden der mir ein wenig Code nach Delphi übersetzt, und zwar das BB-SDK.
Ist nicht viel, aber ich bin leider nur des QuickBASIC und Delphi mächtig.

MfG,
SnuffMaster23

[morp2]

Ach sind ja nur 1600 Zeilen. Mach ich gerne.

[Corpsman]

ich habe auch schon von c nach Pascal übersetzt ist gar net so arg schwer. Zumindest meistens.

Schau einfach mal HEX von meiner HP an. da ist der Delphi wie der Code dabei.

[SirThornberry]

es wäre das sinnvollste zu versuchen das selbst zu wandeln. Wenn es nur ein sdk ist handelt es sich ja im einfache Datentypen und strukturen. Ansonsten musst du immer wieder wenn dir c-code in die Finger fällt Hilfe aufsuchen. Und spätestens bei Benutzung des MSDN brauchst du die Kenntnisse.

[SnuffMaster23]

1600 Zeilen
da hab ich wohl was übersehen

Ok, ihr habt mich überzeugt, ich übersetz es selber, aber ein paar Basics wären nicht schlecht.
Beim MSDN bin ich immer am rumraten, auf Dauer ist das auch nichts

Was muss ich da denn genau übersetzen, für was sind z.B. die .def-files?
Reichen die .cpp und .h-files?

//Edit:
Was fang ich denn damit an? Brauch ich das überhaupt alles?
Ich nehm mal an den ersten Teil kann ich weglassen.
Welchen Units entsprechen windows.h (windows.pas?) und stdio.h?

Code:

//------------------------------------------
// Compiler specifics
//------------------------------------------

#ifdef __GNUC__
  #define _WIN32_IE 0x0500
  #ifndef __BBCORE__
   #define GetBlackboxPath _GetBlackboxPath
  #endif
#endif

#ifdef __BORLANDC__
  #define DLL_EXPORT
#endif

#ifndef DLL_EXPORT
  #define DLL_EXPORT __declspec(dllexport)
#endif

//------------------------------------------
// windows include:
//------------------------------------------

#define WIN32_LEAN_AND_MEAN
#define WINVER 0x0500

#include <windows.h>
#include <stdio.h>

[angos]

Zitat von SnuffMaster23:

1600 Zeilen
da hab ich wohl was übersehen

Ok, ihr habt mich überzeugt, ich übersetz es selber, aber ein paar Basics wären nicht schlecht.
Beim MSDN bin ich immer am rumraten, auf Dauer ist das auch nichts

Was muss ich da denn genau übersetzen, für was sind z.B. die .def-files?
Reichen die .cpp und .h-files?

//Edit:
Was fang ich denn damit an? Brauch ich das überhaupt alles?
Ich nehm mal an den ersten Teil kann ich weglassen.
Welchen Units entsprechen windows.h (windows.pas?) und stdio.h?

Code:

//------------------------------------------
// Compiler specifics
//------------------------------------------

#ifdef __GNUC__
  #define _WIN32_IE 0x0500
  #ifndef __BBCORE__
   #define GetBlackboxPath _GetBlackboxPath
  #endif
#endif

#ifdef __BORLANDC__
  #define DLL_EXPORT
#endif

#ifndef DLL_EXPORT
  #define DLL_EXPORT __declspec(dllexport)
#endif

//------------------------------------------
// windows include:
//------------------------------------------

#define WIN32_LEAN_AND_MEAN
#define WINVER 0x0500

#include <windows.h>
#include <stdio.h>

Also der erste Bereich sind scheinbar Compilerschalter, da musste mal schauen, ob du was in Delphi brauchst (AM Anfang eher nicht)

das zweite sind die genutzten Units. Da das C-Standardunits sind, werden die sich in Delphi definitiv ändern

[SnuffMaster23]

Tja, so weit war auch auch schon...

Und ich hab schon den nächsten Stolperstein:

Code:

   // BB_REDRAWGUI wParam bitflags:
     BBRG_TOOLBAR (1<<0)
     BBRG_MENU    (1<<1)
     BBRG_WINDOW  (1<<2)
     BBRG_DESK    (1<<3)
     BBRG_FOCUS   (1<<4)
     BBRG_PRESSED (1<<5)
     BBRG_STICKY  (1<<6)
     BBRG_FOLDER  (1<<7)

Da es um Flags geht nehm ich mal an dass << ein bitweiser Operator ist. Ist das in Delphi vielleicht shl?


//Edit:

Code:

typedef struct StyleItem
{
   int bevelstyle;
   int bevelposition;
.
.
.
   COLORREF bulletColor;
   //bool FontShadow; xoblite extension
} StyleItem;

Das gibt einen record-Typ denk ich, hat das eine Bedeutung dass da zweimal StyleItem steht?

Code:

char Font[256-20];        //steht innerhalb der typedef von oben
---------------

#define PicColor TextColor

class Menu;
class MenuItem;

Damit kann ich nichts anfangen...

[ste_ett]

Delphi-Quellcode:

const
  BBRG_TOOLBAR = (1 shl 0);
  BBRG_MENU    = (1 shl 1);
  BBRG_WINDOW  = (1 shl 2);
  BBRG_DESK    = (1 shl 3);
  BBRG_FOCUS   = (1 shl 4);
  BBRG_PRESSED = (1 shl 5);
  BBRG_STICKY  = (1 shl 6);
  BBRG_FOLDER  = (1 shl 7);

"shl" ist korrekt.

Das mit dem Namen ist korrekt so, der Name, der unten steht wird nach aussen bekannt gemacht.
Für Delphi ist das irrelevant.

Delphi-Quellcode:

TStyleItem = packed record
  bevelstyle,
  bevelposition: Integer;
.
.
.
   bulletColor: COLORREF;
end;

Array werden in C/C++ folgendermassen deklariert:
Typ Name[Anzahl]; // Index von 0 bis Anzahl-1

Delphi-Quellcode:

var
  Font: array[0..235] of Char; // 0..255-20

[SnuffMaster23]

Code:

//===========================================================================
// constants for GetSettingPtr(int index) -> returns:
enum {
   SN_STYLESTRUCT      = 0   , // StyleStruct *
   SN_TOOLBAR          = 1   , // StyleItem *
   SN_TOOLBARBUTTON          , // StyleItem *
.
.
.
   SN_MENUFRAME_DISABLECOLOR , // COLORREF *
   SN_LAST
};

Was ist das?

Und das nochmal, damits nicht untergeht:

Code:

#define PicColor TextColor

class Menu;
class MenuItem;

Mit denen kann ich auch nichts anfangen.
Wird da PicColor der Wert von TextColor zugewiesen?
Werden da zwei Konstanten definiert?
TextColor gibts garnicht, außer als Element von StyleItem

Leere Klassendefinitionen??

[ste_ett]

Das Enum ist nur dazu da, den Variablen einen Wert zu geben.
In Delphi kann man diesen Fall über "const" oder "type" regeln.
Wahlweise kann man auch jede Variable einzeln als Integer und Konstante deklarieren.

Delphi-Quellcode:

{$MINENUMSIZE 4} // WICHTIG, wenn man Enumerationen aus der "C/C++"-Welt übernimmt!
type
  TEnum = ( // In Delphi muss ein Name vergeben werden, der hier allerdings bedeutungslos ist.
    SN_STYLESTRUCT      = 0   , // StyleStruct *

    SN_TOOLBAR          = 1   , // StyleItem *
    SN_TOOLBARBUTTON          , // StyleItem *
    SN_TOOLBARBUTTONP         , // StyleItem *
    SN_TOOLBARLABEL           , // StyleItem *
    SN_TOOLBARWINDOWLABEL     , // StyleItem *
    SN_TOOLBARCLOCK           , // StyleItem *
    SN_MENUTITLE              , // StyleItem *
    SN_MENUFRAME              , // StyleItem *
    SN_MENUHILITE             , // StyleItem *

    SN_MENUBULLET             , // char *
    SN_MENUBULLETPOS          , // char *

    SN_BORDERWIDTH            , // int *
    SN_BORDERCOLOR            , // COLORREF *
    SN_BEVELWIDTH             , // int *
    SN_FRAMEWIDTH             , // int *
    SN_HANDLEWIDTH            , // int *
    SN_ROOTCOMMAND            , // char *

    SN_MENUALPHA              , // int *
    SN_TOOLBARALPHA           , // int *
    SN_METRICSUNIX            , // bool *
    SN_BULLETUNIX             , // bool *

    SN_WINFOCUS_TITLE         , // StyleItem *
    SN_WINFOCUS_LABEL         , // StyleItem *
    SN_WINFOCUS_HANDLE        , // StyleItem *
    SN_WINFOCUS_GRIP          , // StyleItem *
    SN_WINFOCUS_BUTTON        , // StyleItem *
    SN_WINFOCUS_BUTTONP       , // StyleItem *

    SN_WINUNFOCUS_TITLE       , // StyleItem *
    SN_WINUNFOCUS_LABEL       , // StyleItem *
    SN_WINUNFOCUS_HANDLE      , // StyleItem *
    SN_WINUNFOCUS_GRIP        , // StyleItem *
    SN_WINUNFOCUS_BUTTON      , // StyleItem *

    SN_WINFOCUS_FRAME_COLOR   , // COLORREF *
    SN_WINUNFOCUS_FRAME_COLOR , // COLORREF *
    SN_MENUFRAME_DISABLECOLOR , // COLORREF *
    SN_LAST
  );

Das "#define PicColor TextColor" muss im Zusammenhang mit der vorhergehenden Strukturdeklaration gesehen werden.
Dort ist das "TextColor" schon deklariert.
"PicColor" ist nur ein Präprozessormakro. Kann man als eine Art Platzhalter sehen.

Man muss wissen, dass "Typen" die unter C/C++ per "#define" definiert werden, vor dem Kompilieren umgeschrieben werden, d.h. aus jedem "PicColor" wird "TextColor", usw.
Deshalb kann man unter C/C++ folgendes schreiben:

Code:

  StyleItem si; // vorherige Struktur
  si.TextColor = 5;
  si.PicColor = 6;

Obwohl die Struktur kein "PicColor" besitzt, kann man die Variable so ansprechen, da vor dem Kompilieren "PicColor" in "TextColor" umgewandelt wird, was wiederrum einen gültigen Ausdruck erzeugt.

In Delphi gibt es sowas (zum Glück) nicht.
Die ggf. auftretenden Stellen musst du "PicColor" durch "TextColor" ersetzen und ggf. mit einem Kommentar versehen.


Die Klassendeklarationen machen nicht direkt Sinn, wenn man nur die Header-datei alleine betrachtet.
Der einzige Punkt, wo diese Klassen gebraucht werden ist ein Pointer auf diese Klassen als Rückgabewert mehrerer Funktionen, die weiter unter deklariert werden.
Ich denke mal, von diesen Klassen werden in anderen Dateien Klassen abgeleitet und die Funktion wurde so deklariert, damit man alle Klassen nutzen kann.