[delphi] custom listbox items tekenen

[tombo_inc]

ik ben een applicatie aan het maken en daarin komt onderandere een venstertje voor met een listbox erin. ik wil echter geen standaard strings in die listbox hebben, maar zelfgemaakte controls. volgens de help moet dat allemaal kunnen en is het gewoon een kwestie van de juiste properties setten en wat events handlers schrijven. dus dat heb ik gedaan, en alles werkt op 1 ding na en wel het belangrijkste namelijk de items tekenen. voor mijn items neem ik TGraphicControl afgeleiden. daarvan override ik de paint method waarin ik zeg wat er getekend moet worden. als ik nu op een knop op mijn form klik dan word er een nieuwe instantie van zo'n graphiccontrol (mijn listitem dus) gemaakt en toegevoegd aan de list. hij komt ook in de list te staan, want als je er op klikt dan zie je er een gestippeld lijntje omheen verschijnen. vervolgens implementeer ik de OnDrawItem event handler. daarin moet getekend gaan worden. maar waarop? dat kan ik nergens terug vinden. dus wat ik nu doe is de paint method van mijn graphiccontrol aanroepen en die laten tekenen op eigen canvas. maar helaas er gebeurt helemaal niks . ik weet zeker dat de paint method aangeroepen wordt, maar er word gewoon niks getekend. ik zou ook niet weten waar ik anders op zou moeten tekenen. ik ben hier al bijna de hele dag mee bezig maar kan nergens oplossingen vinden. weet iemand hier hoe ik dit aan moet pakken?

[Creepy]

Ff uit m'n hoofd (dus kijk het ff na ):

Je kan je listbox.canvas gebruiken om op te tekenen. In de ondrawitem krijg je een rect mee. Deze rect bevat de coordinaten die je kan gebruiken om je item te tekenen.

[tombo_inc]

ik heb het net ff geprobeerd en dit is inderdaad wat ze willen denk ik. maar dat betekend dus dat wat ik wil zo niet kan. ik wil namelijk net zoiets maken als de layerpallette van photoshop. een lijst met items waarmee je het een en ander kan, zoals naam wijzigen etc. je kent dat vast wel van photoshop. als ik dus alleen maar kan tekenenen in zo'n vierkant en geen controls weer kan geven in zo'n listbox, hoe zou ik het dan op moeten lossen? moet ik dan gewoon zelf een lijst maken of moet ik met een customlistbox aan de gang?

[alienfruit]

Tijdens het editen er een (inplace) TEdit box bovenop knallen, of een eigen component bouwen.

[ Voor 6% gewijzigd door alienfruit op 01-01-2006 08:58 ]

[tombo_inc]

wat bedoel je met tijdens het editen? en bij alles wat ik tot nu toe geprobeerd heb is het me niet gelukt om dan ook maar iets weer te geven van een zelfgemaakte control die ik in de listbox stop. als ik bijvoorbeeld teken op de canvas van een eigen control afgeleid van een graphiccontrol dan laat hij gewoon niks zien.

[alienfruit]

Nou als je bijvoorbeeld een item hebt geselecteerd en je drukt op Enter dat er dan een TEdit te voor zijn komt die boven op de item komt te liggen. Waairn ed gebruiker dan de nieuwe tekst kan intikken drukt hij vervolgens weer op Enter dan verdwijnt de TEdit en wordt de item correct gewijzigd.

Maar goed zo'n component ziet gewoon standaard in JVCL. bij mijn weten. Verder zijn er zat te vinden op Torry.

[ Voor 17% gewijzigd door alienfruit op 01-01-2006 16:19 ]

[tombo_inc]

ja dat is inderdaad een leuk idee, en zoiets ben ik ook van plan. maar ik krijg het gewoon niet voor mekaar om een control weer te geven in die lijst. ik begin steeds meer te geloven dat het uberhaupt niet kan. als ik nu mijn TGraphicControl afgeleide toevoeg aan de lijst en dan in het onitemdraw event zijn paint method aanroep om te tekenen, dan word mijn control helemaal niet getekend. het enige wat er gebeurd is dat er een nieuw item in de lijst word gezet waar dan alleen zo'n mooi stippellijntje omheen wordt getekend. ik zou dus ook niet weten hoe ik dit op moet lossen. moet ik met een customlistbox aan de gang of moet ik alles zelf maken, of is er toch een manier op dit met een reguliere listbox te doen? volgens de delphi help kun je ipv standaard strings ook objecten in de lijst zetten, en dat klopt. ze zeggen dat je dan in 1 eventhandler het zaakje moet tekenen. en daar loop ik dus vast

edit:
ik kan zo'n component nergens vinden, ben wel veel andere handige dingen tegengekomen.
en bovendien vind ik het leuk om zelf zoiets te maken.

edit2:
na nog wat graven in de help, vond ik dit:
"Use Style to specify whether the list box is a standard list box that displays text strings, or an owner-draw list box that can display graphical images. Owner-draw list boxes let you display items in some nonstandard way. In this case, you must write the code to paint items in the list box."

hieruit concludeer ik dus dat je alleen plaatjes kan laten zien op de standaar manier, en geen objecten die zelf allerlei zaken afhandelen. dan is mijn volgende vraag, moet ik die functionaliteit die ik wil dan helemaal zelf implementeren (vanuit een TCustomListBox). of zijn er nog andere/eenvoudigere wegen te bewandelen? (behalve componenten die ergens op het net rondzwerven)

[ Voor 35% gewijzigd door tombo_inc op 01-01-2006 17:21 ]

[LordLarry]

Nee, wat je moet concluderen is dat je bij een Owner-draw listbox de items zelf moet tekenen. Het is aan jouw om te bepalen wat en hoe je tekent. Je kan besluiten om op dat moment niet zelf te gaan tekenen, maar een TEdit op die plaats te zetten. Deze zal zich dan zelf tekenen.

Maar probeer eerst eens als eerste stap een owner draw listbox aan de praat te krijgen zodat ie er uitziet als een normale listbox. Als je dat helemaal door hebt kan je naar de volgende stap gaan en er een edit in zetten.

[tombo_inc]

ik heb mijn owner-drawn listbox al lang aan de praat
en ik ben ook tot de conclusie gekomen dat je die items die erin staan alleen op maar de canvas van de listbox kan tekenen. en dat er niet (zoals ik eerst dacht) gewoon een lijst met controls verschijnt die zelf hun painting afhandelen.
ik heb nog eens wat gezocht en ben toen dit http://www.shorterpath.co...articles/VisualStyles.asp tegengekomen. erg handig en leuk allemaal, behalve dat mijn delphi (personal 7) weigerd om de DrawFrameControl() functie te herkennen. ik ben dus tot de volgende conclusie gekomen, namelijk dat ik gewoon alles zelf (inclusief controls als een checkbox of edit veld) op de canvas van mijn listbox moet tekenen. nu nog uitvissen hoe . ik hoopte dat jullie me daarbij kunnen helpen. ow ja en verbeter me als ik foute conclusies trek.

edit:
hum, ik heb nu wel wat verbetering. ik heb um nu zo ver dat mijn eigen control getekend word in de lijst. maar nu is het zo dat je geen items meer kan selecteren uit de lijst omdat mijn control even groot is als de Rect van het item. je ziet dus niet meer dat het item geselecteerd is. en ik neem aan dat ie dan ook niet als geselecteerd word gezien in het programma.

[ Voor 19% gewijzigd door tombo_inc op 01-01-2006 18:40 ]

[LordLarry]

De Windows unit usen voor DrawFrameControl?

Ja, bij Owner draw moet je alles zelf tekenen. Maar aangezien een edit weet hoe het zichzelf moet tekenen kan je gewoon een edit op de plaats zetten waar je wat wilde tekenen en klaar is klara.

/edit

Een heel simpel voorbeeld van een Form met daarop een ListBox1 die OwnerDraw aan heeft staan en designtime enkele items heeft ingevuld.

Delphi:

  TForm2 = class(TForm)
    Edits: array of TEdit;
  ...

procedure TForm2.FormCreate(Sender: TObject);
var
  I: Integer;
begin
  SetLength(Edits, ListBox1.Items.Count);

  for I := 0 to ListBox1.Items.Count - 1 do begin
    Edits[I] := TEdit.Create(Self);
    Edits[I].Parent := ListBox1;
    Edits[I].Text := ListBox1.Items[I];
  end;
end;

procedure TForm2.ListBox1DrawItem(Control: TWinControl; Index: Integer;
  Rect: TRect; State: TOwnerDrawState);
begin
  Edits[Index].BoundsRect := Rect;
end;

[ Voor 61% gewijzigd door LordLarry op 01-01-2006 18:52 ]

[tombo_inc]

hehe kijk kijk ,
dit is ongeveer wat ik ook inmiddels klaargestoomt heb. ik heb nu hetvolgende, net iets anders namelijk. ik heb een eigen object afgeleid van TCustomControl. dit object bevat onder andere een TEdit.
op het moment dat ik op mijn button op mijn form klik dan word er een nieuw eigen object geinstantieerd en word de listbox als parent toegewezen. dan zeg ik vervolgens in de listboxdrawitem dat de boundsrect van mijn eigen control gelijk is aan rect die meegeven word als argument. nu word alles netjes getekend. mijn eigen control met daarop de edit etc. das dus zeer zeker mooi. maar...
het volgende probleem waar ik wat advies voor nodig heb, doet zich dan voor. omdat mijn object even groot is als de Rect van een listitem, en omdat mijn object op de canvas van de listbox word geplaatst en dus over de listboxitem(s) heen valt (in feite). werkt het selecteren van de listboxitems niet meer (want er staat iets over de items heen). nu moet daar dus een oplossing voor bedacht worden. en ik zelf heb het volgende in gedachte. ik implementeer een onclick event in mijn eigen object en zeg daarin dat het juiste listitem geselecteerd moet zijn/worden.

nu wil ik graag weten of deze aanpak die ik hierboven beschrijf juist is. of dat er een andere methode voor is. en of ik de rest nu ook goed heb geimplementeerd. alvast bedankt voor de info/voorbeeld(en)

[LordLarry]

Nee, dat lijkt me correct.

[tombo_inc]

ok bedankt.
dan ga ik weer aan de slag, om alles even goed te implementeren

[Tomatoman]

Ik heb een zelfgemaakte combo box uitgekleed tot de code hieronder. Een combo box verschilt eigenlijk weinig van een list box. Waar het om gaat is DrawItem. Er wordt daar een verticale lijn getekend met links en rechts ervan een tekst.

Delphi:

type
  TUserComboBoxStrings = class(TCustomComboBoxStrings);

  TUserComboBox = class(TComboBox)
  private
    function GetItems: TUserComboBoxStrings;
  protected
    function GetItemsClass: TCustomComboBoxStringsClass; override;
    procedure SetItems(Value: TUserComboBoxStrings); reintroduce;
    procedure CreateParams(var Params: TCreateParams); override;
    procedure DrawItem(Index: Integer; Rect: TRect;
      State: TOwnerDrawState); override;
  public
    constructor Create(AOwner: TComponent); override;
  published
    property Items: TUserComboBoxStrings read GetItems write SetItems;
    property LinePos: Integer read FLinePos write FLinePos default 100;
  end;

implementation

function TUserComboBox.GetItems: TUserComboBoxStrings;
begin
  Result := TUserComboBoxStrings(inherited Items);
end;

function TUserComboBox.GetItemsClass: TCustomComboBoxStringsClass;
begin
  Result := TUserComboBoxStrings;
end;

procedure TUserComboBox.SetItems(Value: TUserComboBoxStrings);
begin
  if Assigned(inherited Items) then
    inherited Items.Assign(Value)
  else
    inherited Items := Value;
end;

procedure TUserComboBox.CreateParams(var Params: TCreateParams);
begin
  inherited CreateParams(Params);
  Params.Style := CBS_OWNERDRAWFIXED;
end;

procedure TUserComboBox.DrawItem(Index: Integer; Rect: TRect;
  State: TOwnerDrawState);
var
  ClipRect: TRect;
begin
  TControlCanvas(Canvas).UpdateTextFlags;
  if Assigned(OnDrawItem) then
    OnDrawItem(Self, Index, Rect, State)
  else
  begin
    Canvas.FillRect(Rect);
    if Index >= 0 then
      if odComboBoxEdit in State then
        Canvas.TextOut(Rect.Left + 2, Rect.Top, Items[Index])
      else
      begin
        ClipRect := Rect;
        ClipRect.Right := ClipRect.Left + FLinePos - 2;
        Canvas.TextRect(ClipRect, Rect.Left + 2, Rect.Top, Items[Index]);
        if ColorToRGB(Color) <> ColorToRGB(clBtnFace) then
          Canvas.Pen.Color := clBtnFace
        else
          Canvas.Pen.Color := clBtnShadow;
        Canvas.MoveTo(Rect.Left + FLinePos, Rect.Top);
        Canvas.LineTo(Rect.Left + FLinePos, Rect.Bottom);
        Canvas.TextOut(FLinePos + 3, Rect.Top,
          Format('This is user %d', [Index]));
      end;
  end;
end;

constructor TUserComboBox.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FLinePos := 100;
end;

[ Voor 3% gewijzigd door Tomatoman op 03-01-2006 00:43 ]

[tombo_inc]

dat ziet er wel interessant uit. ik zal de code eens op mijn gemak gaan bekijken

[tombo_inc]

ik heb je code eens bekeken en een aantal zaken vallen me op.
waarom gebruik je dit en zet je dit niet gewoon in de constructor?

Delphi:

procedure TUserComboBox.CreateParams(var Params: TCreateParams);
begin
  inherited CreateParams(Params);
  Params.Style := CBS_OWNERDRAWFIXED;
end; 

en ik vroeg me af wat je met die TControlCanvas doet in de DrawItem method.
verder denk ik dat het me wel duidelijk is.

ik heb er dit keer zelf voor gekozen om niet zelf een heel component te schrijven, maar om gewoon een bestaande listbox te nemen en die wat aan te passen. ik heb wel zelf de listitems gemaakt. ik heb nu het volgende en ik vroeg me af of ik dit op de juiste manier doe, of dat die listitems van mij te overdreven zijn zo of dat het makkelijker kan.

Delphi:

// mijn form met TListBox (LayerList)

type
  TLagenBeheerForm = class(TForm)
   
    LayerList: TListBox;
   NewLayer: TAction;
   procedure NewLayerExecute(Sender: TObject);
   destructor Destroy; override;
   procedure LayerListDrawItem(Control: TWinControl; Index: Integer;
      Rect: TRect; State: TOwnerDrawState);

  private
    { Private declarations }
  public
    { Public declarations }
   CurrentDocument: TDocumentContainerForm;
  end;

var
  LagenBeheerForm: TLagenBeheerForm;

implementation

{$R *.dfm}


// hier word een nieuwe laag aangemaakt.
procedure TLagenBeheerForm.NewLayerExecute(Sender: TObject);
var
  LayerListItem: TLayerListItem; // mijn eigen component
  Layer: TDrawLayer; //mijn eigen component nvt hier
begin

  if ParentGUI.ActiveMDIChild <> nil then
  begin

    Layer := (ParentGUI.ActiveMDIChild as TDocumentContainerForm).Document.CreateNewLayer( true ); //maak daadwerkelijk nieuwe laag in document, nvt hier

    LayerListItem                 := TLayerListItem.Create( self );
    LayerListItem.Parent          := self.LayerList;
    LayerListItem.LayerID         := Layer.ID;

    LayerListItem.Caption.Caption := Layer.Name;

    self.LayerList.AddItem('', LayerListItem);

  end;

end;


destructor TLagenBeheerForm.Destroy;
begin

  self.LayerList.Free;
  inherited;

end;

procedure TLagenBeheerForm.LayerListDrawItem(Control: TWinControl;
  Index: Integer; Rect: TRect; State: TOwnerDrawState);
begin

  //TLayerListItem(self.ListBox1.Items.Objects[Index]).BoundsRect := Rect;  
{wat is het verschil tussen deze 2 methodes want er komt gewoon hetzelfde uit ?}
  (self.LayerList.Items.Objects[Index] as TLayerListItem).BoundsRect := Rect;
  
end;

en hier mijn eigen layerlistitem component

Delphi:

type
  TLayerListItem = class(TCustomControl)
    Edit: TEdit;
    Caption: TLabel;
  private

  public
    LayerID: Integer;
    constructor Create( AOwner: TComponent ); override;
    procedure Paint; override;
    procedure Click; override;
    procedure CaptionDblClick( Sender: TObject );
    procedure EditKeyPress( Sender: TObject; var Key: Char );
    destructor Destroy; override;
  end;

implementation

uses
  lagenbeheer.gui;

constructor TLayerListItem.Create( AOwner: TComponent );
begin
  inherited;

//  self.Color := ff een mooie uitzoeken :p
  self.Cursor := crHandPoint;

  self.Caption := TLabel.Create( self );
  self.Caption.Parent := self;
  self.Caption.Left := 20;
  self.Caption.Top  := 15;
  self.Caption.OnDblClick := self.CaptionDblClick;

  self.Edit := TEdit.Create(self);
  self.Edit.Visible := false;
  self.Edit.Parent := self;
  self.Edit.Left := 20;
  self.Edit.Top  := 15;
  self.Edit.OnKeyPress := self.EditKeyPress;
  
end;

procedure TLayerListItem.Paint;
begin
  inherited;


  // hier komt eventueel wat tekenwerk

end;

procedure TLayerListItem.Click;
var
  Layer: TDrawLayer;
begin
  inherited;
  
  //self.Color := clHighLight;


  if self.Edit.Visible = true then
  begin

    Layer := LagenBeheerForm.CurrentDocument.Document.GetLayer( self.LayerID );
    Layer.Name := self.Edit.Text;
    
    self.Edit.Visible := false;
    self.Caption.Caption := self.Edit.Text;
    self.Caption.Visible := true;

  end;

end;


procedure TLayerListItem.CaptionDblClick( Sender: TObject );
begin

  self.Caption.Visible := false;
  self.Edit.Text := self.Caption.Caption;
  self.Edit.Visible := true;

end;

procedure TLayerListItem.EditKeyPress( Sender: TObject; var Key: Char );
begin
 {ik hoor hier een irritante plong van mij os als ik op enter druk ??}
  if Key = #13 then
  begin

    self.Caption.Caption := self.Edit.Text;
    self.Edit.Visible := false;
    self.Caption.Visible := true;
    
  end;

end;


destructor TLayerListItem.Destroy;
begin
  self.Edit.Free;
  self.Caption.Free;
  inherited;
end;

offtopic:
ik hoop dat mijn vragen en lappe codes niet vervelend zijn

[LordLarry]

Delphi:

  TLayerListItem(self.ListBox1.Items.Objects[Index]).BoundsRect := Rect;  
{wat is het verschil tussen deze 2 methodes want er komt gewoon hetzelfde uit ?}
  (self.LayerList.Items.Objects[Index] as TLayerListItem).BoundsRect := Rect; 

Als self.ListBox1.Items.Objects[Index] geen TLayerListItem is zal je in het eerste geval random fouten krijgen. In het 2e geval direct een exceptie dat het object op die manier niet gecast kan worden. De 2e manier is dus veiliger.

Delphi:

 {ik hoor hier een irritante plong van mij os als ik op enter druk ??}
  if Key = #13 then
  begin

Voeg Key := #0; toe en je hoort het niet meer.

[tombo_inc]

hey bedankt, dat werkt in ieder geval al.
maar nog even over dat eerste. het zijn dus allebei typecasts?

[LordLarry]

Yep