programm problem mit code

Alexander Kempf

Nash schrieb:

Wenn dann so :

Wenn ich das richtig sehe, dann bekommt man mit Controls[] nur die untergeordneten Controls - also Controls, deren
Parent-Eigenschaft in diesem Fall das Formular ist. Willst Du aber auch einen Button, der auf einem Panel liegt und
dann folglich als Parent eben dieses Panel hat, erreichen musst Du die gesamte Control-Hierarchie durchschreiten.
Mit Components bekommt man automatisch alle Komponenten, die auf dem Formular liegen. Hat man - wie in diesem Fall -
den Namen der Komponente zur Hand, dürfte FindComponent() der einfachste Weg sein, auch wenn man casten muss, um
an die gewünschten Eigenschaften zu kommen.
Interessant in dem Zusammenhang könnte außerdem noch ControlAtPos() sein (wieder nur für Unter-Controls), womit man
das Control anhand der Maus-Position ermitteln kann. Das könnte für Verschiebezwecke ganz praktisch sein.

gerd01 schrieb:

wenn man die components durchläuft muss man einen abziehen, steht zumindest im beispielcode der hilfe

Die Hilfe bezieht sich doch nur auf die (beinahe schon triviale) Eigenart, dass der erste Index bei 0 und nicht bei
1 beginnt. Was hast Du denn jetzt gemacht?

Gruß,

Alexander

gerd01

die for-schleife mit "componentcount-1" laufen lassen, und schon klappt alles! er hatte an dieser stelle dann den index überschritten, aber dein casting vefahren habe ich eingebunden, scheint zu funzen. danke.

gruß gerd

Nash

Hallo,

Oops...
Das kommt davon, wenn man das nicht selber ausprobiert und mal schnell zwischendurch antwortet. Natürlich immer bis Count minus 1.

[cpp]TControl *ChildControl;
for (int i=0; i < ControlCount - 1; i++)
{
ChildControl = Controls[i];
if (ChildControl->Visible)
ListBox1->Items->Add(ChildControl->Name);
}[/cpp]

Bis dann denn,

Nash

Alexander Kempf

Ich verstehe nicht dieses Problem mit ComponentCount - 1 bzw. ControlCount - 1.
So wie von Nash vorgeschlagen...

Nash schrieb:

[cpp]TControl *ChildControl;
for (int i=0; i < ControlCount - 1; i++)
{
ChildControl = Controls[i];
if (ChildControl->Visible)
ListBox1->Items->Add(ChildControl->Name);
}[/cpp]

... wird doch wohl ein Control unterschlagen?

Zum Test habe ich mal einfach eine neue Anwendung erstellt, ein Panel (Panel1) darauf platziert und
auf diesem wiederum (nur zum Test) ein Label (Label1) und einen Button (Button1). Außerdem liegt
direkt auf dem Form noch ein Memo (Memo1) und ein weiterer Button (Button2), in dessen OnClick-Ereignis
ich folgendes geschrieben habe:

void __fastcall TForm1::Button2Click(TObject *Sender)
{
   Memo1->Lines->Clear();
   Memo1->Lines->Add("List of components");
   Memo1->Lines->Add("---------------------------");
   for (int i = 0; i < ComponentCount; ++i)
   {
      Memo1->Lines->Add(Components[i]->Name);
   }
   Memo1->Lines->Add("");
   Memo1->Lines->Add("List of controls");
   Memo1->Lines->Add("---------------------------");
   for (int i = 0; i < ControlCount; ++i)
   {
      Memo1->Lines->Add(Controls[i]->Name);
   }
}

Es gibt hier keinerlei Exceptions o.ä. und im Memo steht nach Anklicken des Button2:

List of components
---------------------------
Panel1
Label1
Button1
Memo1
Button2

List of controls
---------------------------
Panel1
Memo1
Button2

Wie man erkennt werden - korrekterweise - insgesamt die vorher erwähnten fünf Komponenten aufgelistet
und die 3 Unter-Controls des Formulars. Da Label1 und Button1 auf dem Panel1 liegen erscheinen sie
nicht in der Controls-Auflistung des Formulars.

Was passiert denn da bei Euch?

Gruß,

Alexander

gerd01

stimmt, die minus eins ist nicht entscheident, irgenwie hakt mein proggie immer noch, wenn ich zu schnell ein andere control wähle!

mache ich es langsam, dann klappt auch! *wunder* *kopfkratz*

gruß gerd

gerd01

also ich raffe es nicht, sollte doch jetzt eigentlich funzen, nur irgendwie bekomme ich immer nen komisches fenster unter winxp, erst ist der rahmen des fensters normal, dann ändert er sich irgendwann. auch wenn ich langsam klicke?!

hier nochmal mein kompletter quellcode

header:

//---------------------------------------------------------------------------

#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// Von der IDE verwaltete Komponenten
    TListBox *ListBox1;
    TListBox *ListBox2;
    TLabel *Label1;
    TLabel *Label2;
    TCheckBox *CheckBox1;
    TButton *Button1;
    TEdit *Edit1;
    TGroupBox *GroupBox1;
    TPanel *p;
    TListBox *ListBox3;
    TShape *Shape1;
    void __fastcall ListBox1Click(TObject *Sender);
    void __fastcall FormCreate(TObject *Sender);
    void __fastcall FormMouseDown(TObject *Sender, TMouseButton Button,
          TShiftState Shift, int X, int Y);
    void __fastcall FormMouseMove(TObject *Sender, TShiftState Shift,
          int X, int Y);
    void __fastcall FormMouseUp(TObject *Sender, TMouseButton Button,
          TShiftState Shift, int X, int Y);
    void __fastcall pMouseDown(TObject *Sender, TMouseButton Button,
          TShiftState Shift, int X, int Y);
private:	// Anwender-Deklarationen
public:		// Anwender-Deklarationen
    __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

quellcode:

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
bool Start=false; // im moment unwichtig
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::ListBox1Click(TObject *Sender)
{
    ListBox2->Items->Clear();
    TControl* ctrl;
    // Objekte mit Panel durchlaufen
    for( int i = 0 ; i < p->ControlCount ; i++ )
    {
        ctrl = dynamic_cast<TControl*> ( FindComponent( p->Controls[i]->Name ) );
        if( ctrl->HasParent() && ctrl != 0 )
        {
            p->Controls[i]->Left = p->Left + 5;
            p->Controls[i]->Top = p->Top + 5;
            p->Controls[i]->Parent = this;
            p->Left += 5;
            p->Top += 5;
            p->Width -= 5;
            p->Height -= 5;
        }
    }
    ctrl = dynamic_cast<TControl*> (FindComponent(ListBox1->Items->Strings[ListBox1->ItemIndex]));
    // Objekt mit Panel hinterlegen
    if ( ctrl != 0 )
    {
        ListBox2->Items->Add(ctrl->Name);
        p->Left = ctrl->Left - 5;
        p->Top = ctrl->Top - 5;
        p->Width = ctrl->Width + 10;
        p->Height = ctrl->Height + 10;
        ctrl->Parent = p;
        ctrl->Left = 5;
        ctrl->Top = 5;
        ctrl->Width = p->Width - 10;
        ctrl->Height = p->Height - 10;
        p->Visible = true;
    }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
    for( int i=0; i < this->ControlCount ; i++ )
    {
        if( this->Controls[i]->Visible )
            ListBox1->Items->Add( this->Controls[i]->Name );
        this->Controls[i]->Visible = true;
    }
    Shape1->Visible = false;
    p->Visible = false;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormMouseDown(TObject *Sender, TMouseButton Button,
      TShiftState Shift, int X, int Y)
{
//    Start = true;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormMouseMove(TObject *Sender, TShiftState Shift,
      int X, int Y)
{
/*    if(Start)
    {
        //Shape1->Width = X - Shape1->Left;
        //Shape1->Height = Y - Shape1->Top;
    }*/
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormMouseUp(TObject *Sender, TMouseButton Button,
      TShiftState Shift, int X, int Y)
{
/*    ListBox2->Items->Clear();
    TRect rectc,rects;
    for( int i=0; i < this->ControlCount; i++ )
    {
        if( this->Controls[i]->Name != "Shape1" )
        {
            rectc = this->Controls[i]->BoundsRect;
            rects = Shape1->BoundsRect;
            if (rectc.Left >= rects.Left && rectc.right <= rects.right && rectc.Bottom <= rects.bottom && rectc.top >= rects.top)
                ListBox2->Items->Add(this->Controls[i]->Name);
        }
    }
    Start=false;*/
}
//---------------------------------------------------------------------------
void __fastcall TForm1::pMouseDown(TObject *Sender, TMouseButton Button,
      TShiftState Shift, int X, int Y)
{
    ReleaseCapture();
    SendMessage(dynamic_cast <TPanel*>(Sender)->Handle,WM_SYSCOMMAND, SC_MOVE + HTCAPTION, 0);
}
//---------------------------------------------------------------------------

vielleicht noch ne idee?

gruß gerd

Alexander Kempf

Was veranstaltest Du denn in ListBox1Click()?
Vielleicht kannst Du davon mal eine kommentierte Version posten.

Es wäre bestimmt sehr hilfreich (nicht nur für außenstehende), den Variablen aussagekräftigere Namen als
Listbox1 oder p zu geben. Dann würde sich der Code wie normaler Text lesen lassen. Man könnte auch sagen:

Jetzt ist es Quell-Code, dann wäre es (vielleicht) Quell-Text.

Vielleicht würdest Du dann auch selbst besser erkennen, wo Dein(e) Fehler liegt/liegen.

Aber ein heißer Kandidat scheint mir auf jeden Fall ListBox1Click() zu sein. Versuche doch mal die Routine
in zusammengehörige Blöcke zu zerlegen und diese Blöcke zu beschreiben.

Gruß,

Alexander

gerd01

hi, ich finde es eigentlich sehr logisch?! du nicht?

// Zur weiteren Darstellung erstmal leeren    
    ListBox2->Items->Clear();
    // Zeiger für Objektreferenz holen
    TControl* ctrl;
    /* Objekte auf dem Panel durchlaufen und schauen, ob Objekt vorhanden,
       wenn ja, dann die Position des Objektes zurückholen durch Panelposition,
       und Form wieder zum parent des objektes machen.*/
    for( int i = 0 ; i < p->ControlCount ; i++ )
    {

        ctrl = dynamic_cast<TControl*> ( FindComponent( p->Controls[i]->Name ) );
        // hat die kompo eine elternkompo
        if( ctrl->HasParent() && ctrl != 0 )
        {
            // wenn ja pos setzen und elternkompo auf form setzen
            p->Controls[i]->Left = p->Left + 5;
            p->Controls[i]->Top = p->Top + 5;
            p->Controls[i]->Parent = this;
            // rahmenbreite zurücksetzen falls element zweimal ausgeählt wird.
            p->Left += 5;
            p->Top += 5;
            p->Width -= 5;
            p->Height -= 5;
        }
    }
    // gewähltes element aus liste wählen
    ctrl = dynamic_cast<TControl*> (FindComponent(ListBox1->Items->Strings[ListBox1->ItemIndex]));
    // Objekt mit Panel hinterlegen
    if ( ctrl != 0 )
    {
        // Namen schreiben
        ListBox2->Items->Add(ctrl->Name);
        // Panelgröße und pos anpassen
        p->Left = ctrl->Left - 5;
        p->Top = ctrl->Top - 5;
        p->Width = ctrl->Width + 10;
        p->Height = ctrl->Height + 10;

/* Panel wird elternkompo des objektes, damit dahinter ein panel liegt, wegen dem benötigten handle in "OnpMouseDown(..)" */

        ctrl->Parent = p;

        //Da Panelbereich überall 5px überstehen soll, hier neu pos setzen
        ctrl->Left = 5;
        ctrl->Top = 5;
        ctrl->Width = p->Width - 10;
        ctrl->Height = p->Height - 10;
        p->Visible = true;
    }

Nash

Hallo,

Oops...
Das kommt davon, wenn man das nicht selber ausprobiert und mal schnell zwischendurch antwortet.

Na toll... und Fernsehen sollte man auch nicht. Sorry...

TControl *ChildControl;
for (int i=0; i < ControlCount; i++) 
{ 
  ChildControl = Controls[i]; 
  if (ChildControl->Visible) 
    ListBox1->Items->Add(ChildControl->Name); 
}

Schonmal getestet, ob der Sender hier gültig ist :

SendMessage(dynamic_cast <TPanel*>(Sender)->Handle,WM_SYSCOMMAND, SC_MOVE + HTCAPTION, 0);

Probier mal die Prüfung auf NULL immer nach vorne zu nehmen. Ansonsten versucht er erst die Prüfung auf HasParent() (was ins Auge gehen kann) und dann erst auf NULL (was dann schon zu spät ist).
[cpp]
for( int i = 0 ; i < p->ControlCount ; i++ )
{
ctrl = dynamic_cast<TControl*> (FindComponent(p->Controls[i]->Name));
if (ctrl != NULL && ctrl->HasParent())
{
p->Controls[i]->Left = p->Left + 5;
p->Controls[i]->Top = p->Top + 5;
p->Controls[i]->Parent = this;
p->Left += 5;
p->Top += 5;
p->Width -= 5;
p->Height -= 5;
}
[/cpp]

P.S.:
this-> kann man weglassen, wenn Objekte vom Form gemeint sind.

Bis dann denn,

Nash

Alexander Kempf

gerd01 schrieb:

hi, ich finde es eigentlich sehr logisch?! du nicht?

Sonst hätte ich wohl kaum gefragt.
Mal im Einzelnen:
[cpp]
// Zur weiteren Darstellung erstmal leeren ---> Unnötiger Kommentar; das steht in der nächsten Zeile
ListBox2->Items->Clear();
// Zeiger für Objektreferenz holen ---> Unnötiger Kommentar;
TControl* ctrl;
/* Objekte auf dem Panel durchlaufen und schauen, ob Objekt vorhanden,
wenn ja, dann die Position des Objektes zurückholen durch Panelposition,
und Form wieder zum parent des objektes machen./
Wofür ist das Panel da? Ich rate mal, dass Du meinen Vorschlag mit dem "Panel unterschieben"
hier umgesetzt hast? Ein aussagekräftiger Name würde hier vielleicht manche Frage und Rätselei ersparen.
Denk doch auch mal dran, ob Du in einem Jahr noch weißt, was Du da gemacht hast...(Antwort ist Nein)
for( int i = 0 ; i < p->ControlCount ; i++ )
{
Wofür ist die nachfolgende Zeile gut? Ich versuche mal zu beschreiben, was Du da machst:
Du nimmst ein Objekt vom Typ TControl und versuchst anhand des Namens die entsprechende
Komponente (TComponent) auf dem Formular zu finden, was ja gelingen muss, da das gefundene
Control sicher zum Form gehört und TControl eine Unterklasse von TComponent ist.
Das ganze ist flüssiger als flüssig: Überflüssig**
ctrl = dynamic_cast<TControl> ( FindComponent( p->Controls[i]->Name ) );
// hat die kompo eine elternkompo ---> Unnötiger Kommentar; das steht in der nächsten Zeile
Wie von Nash schon angemerkt, sollte die Reihenfolge vertauscht werden.
Prüfen auf 0 ist hier aber ohnehin unnötig, wenn Du den (unnötigen) cast weglässt.
Dann ist auch die ganze Prüfung auf den Parent unnötig. Überleg mal selbst warum.
if( ctrl->HasParent() && ctrl != 0 )
{
// wenn ja pos setzen und elternkompo auf form setzen
p->Controls[i]->Left = p->Left + 5;
p->Controls[i]->Top = p->Top + 5;
p->Controls[i]->Parent = this; // Was passiert hier, wenn Du z.B. ein Panel auf einem Panel hast?
// rahmenbreite zurücksetzen falls element zweimal ausgeählt wird.
p->Left += 5;
p->Top += 5;
p->Width -= 5;
p->Height -= 5;
}
}
// gewähltes element aus liste wählen
ctrl = dynamic_cast<TControl*> (FindComponent(ListBox1->Items->Strings[ListBox1->ItemIndex]));
// Objekt mit Panel hinterlegen
if ( ctrl != 0 )
{
// Namen schreiben
Ja, aber warum? Dass Du das machst kann ich dem Code entnehmen, aber wofür?
Vor allem weshalb Listbox? Hier wäre ein aussagekräftiger Name u.U. aufschlussreich.
Wird denn die Listbox2 jemals für irgendwas benötigt? Wenn ja: wofür? Wenn nein: Könnte
man nicht einfach einen Label für Anzeigezwecke verwenden?
ListBox2->Items->Add(ctrl->Name);
// Panelgröße und pos anpassen
p->Left = ctrl->Left - 5;
p->Top = ctrl->Top - 5;
p->Width = ctrl->Width + 10;
p->Height = ctrl->Height + 10;

/* Panel wird elternkompo des objektes, damit dahinter ein panel liegt, wegen dem benötigten handle in "OnpMouseDown(..)" */

ctrl->Parent = p; Vielleicht solltest Du Dir den Original-Parent irgendwo speichern (s.o.), um ihn später
wieder korrekt zurücksetzen zu können.

//Da Panelbereich überall 5px überstehen soll, hier neu pos setzen
Anstatt überall 5 zu verwenden, solltest Du Dir überlegen, ob Du nicht lieber eine Konstante verwendest.
Das hat zwei Vorteile:
1. Wenn Du den Wert ändern willst.
2. Bessere Lesbarkeit.
ctrl->Left = 5;
ctrl->Top = 5;
ctrl->Width = p->Width - 10;
ctrl->Height = p->Height - 10;
p->Visible = true;
}

[/cpp]

Was die Benennung von Variablen, Methoden und Klassen betrifft, bin ich recht empfindlich. Es bringt mich regelmäßig
zur Weißglut, wenn ich nichtssagenden Namen im Quelltext begegne, den ich verstehen muss. Bei sichtbaren Komponenten
halte ich mich an die Faustregel: Aussagekräftige Namen für alle Komponenten, mit denen ein Benutzer interagieren kann.
Dazu gehören auf jeden Fall Buttons, Checkboxes und eben auch Listboxes. Label, die nur Beschriftungszwecken dienen
benenne ich meist nicht extra.

Noch ein Tip, mit dem Du Dir vielleicht einen Haufen Code ersparen kannst: Es gibt in Stringlisten auch die Möglichkeit
Objekte zu speichern, also Text mit Objekten zu assoziieren - und TListbox verwendet intern eine Stringliste...

Gruß,

Alexander

PS: Ich habe mir relativ viel Zeit genommen. Bitte nimm Dir auch die Zeit und gehe möglichst alle meine Anregungen durch.
Wenn Du dann wieder Fragen hast, werde ich Dir bestimmt helfen.

gerd01

hi,

vielleicht werdet Ihr ja nun etwas schlauer daraus

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;

/*
"Start" wird für die Markierung meherer Elemente benötigt, ich habe Sie jetzt mal
mit reingenommen, damit Ihr den Sinn meiner ListBox2 (lstSelectedControls) versteht.
*/

bool Start=false;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::lstSelectableControlsClick(TObject *Sender)
{
    shpMarker->Visible = false;
    lstSelectedControls->Items->Clear();
    TControl* ctrl;
    // Objekte mit Panel durchlaufen

    /*
    @Alexander Kempf:
    Ja, Du hast recht, ich habe Deinen Vorschlag mit dem Panel umgesetzt, damit
    ich beim Verschieben (pnlBehinderMouseDown) unten einen Handle bekomme, um
    mit ReleaseCapture() arbeiten zu können.

    @Nash:
    Dass ich für Methoden und Eigenschaften kein this benötige ist mir klar, aber
    ich sehe dann eher, was zur aktuellen Form gehört, wenn ich gleiche Methoden
    in anderen Elementen aufrufe
    */

    for( int i = 0 ; i < pnlBehinder->ControlCount ; i++ )
    {
        /*
        @Alexander Kempf:
        Warum ist der cast hier unwichtig? Hast Du mir doch selber gezeigt!
        */
        ctrl = dynamic_cast<TControl*> ( FindComponent( pnlBehinder->Controls[i]->Name ) );
        if( ctrl != 0 && ctrl->HasParent() )
        {

            /*
            Falls Controls einen anderen Parent besitzen als die Form selbst,
            sind Positionsangaben relativ zum Parent. Da ich in diesem Codeabschnitt
            aber den eventuell vorhandenen Parent von einem Control als Parent
            wieder entferne setze ich die Positionen des Controls wieder auf
            relative Werte der Form.
            */

            pnlBehinder->Controls[i]->Left = pnlBehinder->Left + 5;
            pnlBehinder->Controls[i]->Top = pnlBehinder->Top + 5;
            pnlBehinder->Controls[i]->Parent = this;

            /*
            Wenn man das Gleiche Control wieder aus der ListBox1 (lstSelectableControls)
            wählt, würde der Rahemn, wenn ich ihn im nachfogenden Code nicht wieder
            verkleinere doppelt so breit um ein Control gesetzt werden, deshalb hier
            der Abzug der Größen- und Positionsangaben
            */

            pnlBehinder->Left += 5;
            pnlBehinder->Top += 5;
            pnlBehinder->Width -= 5;
            pnlBehinder->Height -= 5;
        }
    }

    /*
    Listbox1 (lstSelectableControls) enhält alle wählbaren Kompos
    "ctrl" enthält also das gewählte Control, welches jetzt das Panel (pnlBehinder)
    als Parent zugewiesen bekommt
    */

    ctrl = dynamic_cast<TControl*> (FindComponent(lstSelectableControls->Items->Strings[lstSelectableControls->ItemIndex]));

    // Objekt mit Panel hinterlegen

    if ( ctrl != 0 )
    {
        /*
        Da ich ja noch das Markierungstool intus habe nehme ich hier eine ListBox2
        (lstSelectedControls), in der ich die Markierungen anzeige
        */

        lstSelectedControls->Items->Add(ctrl->Name);

        /*
        Panel etwas versetzt dahinter platzieren, damit Rahmen greifbar wird.
        */

        pnlBehinder->Left = ctrl->Left - 5;
        pnlBehinder->Top = ctrl->Top - 5;
        pnlBehinder->Width = ctrl->Width + 10;
        pnlBehinder->Height = ctrl->Height + 10;

        ctrl->Parent = pnlBehinder;
        ctrl->Left = 5;
        ctrl->Top = 5;
        ctrl->Width = pnlBehinder->Width - 10;
        ctrl->Height = pnlBehinder->Height - 10;

        pnlBehinder->Visible = true;
    }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
    /*
    Alle Wählbaren Kompos in ListBox1 (lstSelectableControls) schmeissen (nur zum Testen)
    */

    for( int i=0; i < this->ControlCount ; i++ )
    {
        if( this->Controls[i]->Visible )
            lstSelectableControls->Items->Add( this->Controls[i]->Name );
        this->Controls[i]->Visible = true;
    }

    // Markierungstoolrahmen ausblenden
    shpMarker->Visible = false;

    // Panel ausblenden
    pnlBehinder->Visible = false;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormMouseDown(TObject *Sender, TMouseButton Button,
      TShiftState Shift, int X, int Y)
{
    // Markierungstool startet
    Start = true;
    shpMarker->Left = X;
    shpMarker->Top = Y;
    shpMarker->Width = 0;
    shpMarker->Height = 0;
    shpMarker->Visible = true;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormMouseMove(TObject *Sender, TShiftState Shift,
      int X, int Y)
{
    // Zum zeichnen eines Rechtecks
    if(Start)
    {
        shpMarker->Width = X - shpMarker->Left;
        shpMarker->Height = Y - shpMarker->Top;
    }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormMouseUp(TObject *Sender, TMouseButton Button,
      TShiftState Shift, int X, int Y)
{
    /*
    Neu gefundenene Elemente werden wieder in eine gesäuberte ListBox2
    (lbSelectedControls) geschmissen um zu prüfen, ob markiert
    */
    int Temp;

    if(shpMarker->Width < 0)
    {
        Temp = shpMarker->Width * -1;
        shpMarker->Width = Temp;
        shpMarker->Left = shpMarker->Left - Temp;
    }

    if(shpMarker->Height < 0)
    {
        Temp = shpMarker->Height * -1;
        shpMarker->Height = Temp;
        shpMarker->Top = shpMarker->Top - Temp;
    }

    lstSelectedControls->Items->Clear();
    TRect rectc,rects;
    for( int i=0; i < this->ControlCount; i++ )
    {
        if( this->Controls[i]->Name != "shpMarker" )
        {
            rectc = this->Controls[i]->BoundsRect;
            rects = shpMarker->BoundsRect;
            if (rectc.Left >= rects.Left && rectc.right <= rects.right && rectc.Bottom <= rects.bottom && rectc.top >= rects.top)
                lstSelectedControls->Items->Add(this->Controls[i]->Name);
        }
    }
    //Markierungstoolphase beendet
    Start=false;
    shpMarker->Visible = false;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::pnlBehinderMouseDown(TObject *Sender, TMouseButton Button,
      TShiftState Shift, int X, int Y)
{
    // Zum Verschieben des Panels mit dem aktuellen Control als Child des Panels
    ReleaseCapture();
    SendMessage(dynamic_cast <TPanel*>(Sender)->Handle,WM_SYSCOMMAND, SC_MOVE + HTCAPTION, 0);
}
//---------------------------------------------------------------------------

So, denke jetzt sollte aber alles Lesbar sein, habe mir auch mühe gegeben und mehr kommentiert und überflüssige Statements rausgenommen!

@Alexander Kempf:
ok, dass mit den Konstanten wäre ne richtige Vorgehensweise, und das mit dem Aktuellen Parent speichern ist auch ne wunderbare Idee, allerdings habe ich es ja mit Absicht erst mal alles der Form bzw. dem Panel als Child untergejubelt, weil es in allererster Linie ein Test werden soll, ob es alles überhaupt so klappt.

Ein Label als Anzeigezwecke für ein Control ist sinnvoll, doch ich zeige unter Umständen auch mehrere an, siehe code (Markierungstool)

@Nash:
Wie prüfe ich es denn "ob der Sender hier gültig" ?

gruß gerd

Alexander Kempf

Der Code sieht jetzt schon mal wesentlich lesbarer aus, wobei ich den Namen pnlBehinder seltsam finde.
Die Variable Start würde ich in den private-Bereich der Formularklasse legen und im Konstruktor initialisieren.
Für den Markierungsrahmen würde ich mir vielleicht sogar eine eigene Klasse erstellen, die eine Eigenschaft vom
Typ TControl* besitzt. In der set-Methode dieser Eigenschaft kannst Du dann alles fürs Zeichnen und Parent-Merken
bzw. -Setzen machen. Eine solche Klasse ist dann sehr einfach zu verwenden, indem man einfach das ausgewählte
Control der TControl*-Eigenschaft zuweißt. Aber das nur am Rande. Wenn's Dich interessiert, kann ich Dir auch mal
einen Vorschlag zeigen.

gerd01 schrieb:

[cpp]
/*
@Alexander Kempf:
Warum ist der cast hier unwichtig? Hast Du mir doch selber gezeigt!
/
Und wofür brauchst Du FindComponent()?
Von welchem Typ ist pnlBehinder->Controls[i]?
Meine Aussage steht: Du brauchst hier keinen Cast, kein FindComponent() und auch keine if-Bedinung
ctrl = dynamic_cast<TControl> ( FindComponent( pnlBehinder->Controls[i]->Name ) );
if( ctrl != 0 && ctrl->HasParent() )
{

/.../
...
Durch die oben beschriebene Verwendung einer zusätzlichen Klasse könntest Du das eleganter und
verständlicher lösen
/*
Wenn man das Gleiche Control wieder aus der ListBox1 (lstSelectableControls)
wählt, würde der Rahemn, wenn ich ihn im nachfogenden Code nicht wieder
verkleinere doppelt so breit um ein Control gesetzt werden, deshalb hier
der Abzug der Größen- und Positionsangaben
*/

...
}

void __fastcall TForm1::FormCreate(TObject *Sender)
{
for( int i=0; i < this->ControlCount ; i++ ) Wie bereits erwähnt werden so nur direkt auf der Form liegende Komponenten berücksichtigt
{
Warum nur sichtbare hinzufügen und anschließend auch unsichtbare anzeigen, aber nicht in Liste aufnehmen?
if( this->Controls[i]->Visible )
lstSelectableControls->Items->Add( this->Controls[i]->Name );Zaunpfahl: AddObject()
this->Controls[i]->Visible = true;
}
...
}[/cpp]

Gruß,

Alexander

gerd01

sinn und zweck war es daraus hinterher ne klasse zu bauen, nur habe ich keine ahnung wie ich es anstellen sollte, falls dein vorschlag mit einem beispiel steht, würde ich diesen gerne mal sehen daraus eine klasse zu konzipieren.

Und wofür brauchst Du FindComponent()?
Von welchem Typ ist pnlBehinder->Controls[i]?
Meine Aussage steht: Du brauchst hier keinen Cast, kein FindComponent() und auch keine if-Bedinung

du hast vollkommen recht, habe ich geschlafen!

Warum nur sichtbare hinzufügen und anschließend auch unsichtbare anzeigen, aber nicht in Liste aufnehmen?

damit wollte ich die listboxen rauslassen!

Zaunpfahl

addobject() kenne ich zwar, nur wie ich es verwende weiss ich nicht annähernd

gruß gerd

Alexander Kempf

gerd01 schrieb:

sinn und zweck war es daraus hinterher ne klasse zu bauen, nur habe ich keine ahnung wie ich es anstellen sollte, falls dein vorschlag mit einem beispiel steht, würde ich diesen gerne mal sehen daraus eine klasse zu konzipieren.

Im Moment bin ich etwas knapp mit der Zeit. Vielleicht klappt's heute abend.

gerd01 schrieb:

damit wollte ich die listboxen rauslassen!

Das wäre doch eine kleine Erklärung Wert gewesen, oder?

gerd01 schrieb:

addobject() kenne ich zwar, nur wie ich es verwende weiss ich nicht annähernd

Bei TListBox gibt es auch noch AddItem(), was von der Funktionsweise aber AddObject() entspricht.
Beispiel:

for (int i = 0; i < ControlCount; ++i)
   ListBox->AddItem(Controls[i]->Name, Controls[i]);

// ...und beim Auswählen eines Listbox-Eintrags:
TControl* ctrl = (TControl*) ListBox->Items->Objects[ListBox->ItemIndex];

Schau Dir halt mal die BCB-Hilfe zu AddObject() und Objects[] an.

Gruß,

Alexander

gerd01

ok, danke werde es mir mal ansehen, und das mit der erklärung die es wert sein müsste, ok ich habe es für mich eindeutig verstanden, ging also auch davon aus, dass andere es verstehen, fehler, kein anderer weiss es warum!

über das beispiel wäre ich sehr erfreut! wäre super wenn es klappt!

aber gibt es eigentlich nicht gleich vom bs her nen apicall, der das alles irgendwo schon anwedet? weil in office werden markierungen gebraucht, und in corel usw. ja auch. beim splitterbar hat er ja auch so eine linie als pattern, gibt es die nicht schon vom bs? nur ne vermutung meinerseits, oder schreiben sich sämtliche entwickler soetwas selber?

gruß gerd

ps:entgegen jeder meinung hier man würde die bcb hilfe nicht nutzen, ich nutze sie durchaus, nur manches davon ralle ich manchmal nicht, und verstehe es nur in verbindung mit ein paar zeilen code, das du das komplette controll dabei übergibst, ist jetzt wiederum eindeutig genug. ok, zu additem habe ich noch nicht nachgesehen, danke für die zeilen!

Alexander Kempf

Hier mal ein paar Anregungen für eine "Decorator"-Klasse. Die Klasse funktioniert sogar. Dokumentation gibt's nicht,
da alles selbsterklärend ist

Zunächst der Header:

class TControlDecorator: public TPanel
{
public:
   __fastcall TControlDecorator(TComponent* Owner, TControl* ClientControl = 0);

   __property TControl* ClientControl = {read=FClientControl, write=setClientControl};
   __property int FrameWidth = {read=getFrameWidth, write=setFrameWidth};
private:
   TControl* FClientControl;
   TShape* FFrame;

   void setClientControl(TControl* Value);
   int getFrameWidth();
   void setFrameWidth(int Value);
   TShape* getFrame();
   void __fastcall MouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y);

   __property TShape* Frame = {read=getFrame};
};

Und noch die Implementierung:

__fastcall TControlDecorator::TControlDecorator(TComponent* Owner, TControl* ClientControl):
   TPanel(Owner),
   FFrame(0)
{
   this->ClientControl = ClientControl;
   OnMouseDown = MouseDown;
   Frame->OnMouseDown = MouseDown;
}

void TControlDecorator::setClientControl(TControl* Value)
{
   if (Value != FClientControl)
   {
      if (FClientControl != 0)
      {
         FClientControl->Parent = Parent;
         Parent = 0;
         Visible = false;
         FClientControl->Left = Left + FrameWidth;
         FClientControl->Top = Top + FrameWidth;
      }
      FClientControl = Value;
      if (FClientControl != 0)
      {
         Parent = FClientControl->Parent;
         Left = FClientControl->Left - FrameWidth;
         Top = FClientControl->Top - FrameWidth;
         Width = FClientControl->Width + 2 * FrameWidth;
         Height = FClientControl->Height + 2 * FrameWidth;
         Visible = true;
         FClientControl->Parent = this;
         FClientControl->Left = FrameWidth;
         FClientControl->Top = FrameWidth;
      }
   }
}

int TControlDecorator::getFrameWidth()
{
   return Frame->Pen->Width;
}

void TControlDecorator::setFrameWidth(int Value)
{
   if (Frame->Pen->Width != Value)
   {
      TControl* ctrl = ClientControl;
      ClientControl = 0;
      Frame->Pen->Width = Value;
      ClientControl = ctrl;
   }
}

TShape* TControlDecorator::getFrame()
{
   if (FFrame == 0)
   {
      FFrame = new TShape(this);
      FFrame->Parent = this;
      FFrame->Brush->Style = bsClear;
      FFrame->Align = alClient;
   }

   return FFrame;
}

void __fastcall TControlDecorator::MouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y)
{
   ReleaseCapture();
   SendMessage(Handle, WM_SYSCOMMAND, SC_MOVE + HTCAPTION, 0);
}

Verwenden kann man das dann z.B. so:

void __fastcall TForm1::FormShow(TObject *Sender)
{
   addSubControlsToListBox(this);
}

void TForm1::addSubControlsToListBox(TControl* AControl)
{
   TWinControl* winControl = dynamic_cast<TWinControl*> (AControl);
   if (winControl != 0)
      for (int i = 0; i < winControl->ControlCount; ++i)
      {
         lbControls->AddItem(winControl->Controls[i]->Name, winControl->Controls[i]);
         addSubControlsToListBox(winControl->Controls[i]);
      }
}

void __fastcall TForm1::lbControlsClick(TObject *Sender)
{
   ControlDecorator->ClientControl = (TControl*) lbControls->Items->Objects[lbControls->ItemIndex];
}

Die ganze Rahmenmalerei ist jetzt in die Decorator-Klasse gewandert. Und genauso auch das Verschieben.
Bestimmt fallen Dir noch andere schöne Dinge ein, denn eigentlich sieht's ein bisschen hässlich aus...

Gruß,

Alexander

gerd01

cool, werde das ganze mal antesten und mein statement dann schreiben, erstmal danke ich dir. *gespannt*

gruß gerd

gerd01

habe schwierigkeiten das ganze zu integrieren, kannste mir mal ein beispielprojekt an meine e-mail schicken? wäre nett von dir.

gruß gerd