TMyLabel - Refresh-Problem

**scrat1979**

Hallo zusammen,

Ich habe kein kleines Problem mit einer (Zu Lernzwecken!) erstellten Komponente. Dass es auch einfacher mit einer von TLabel abgeleiteten Komponente geht, ist klar, nur möchte ich eben ein paar Dinge ausprobieren und dabei ist mir die Idee mit dieser einfachen grafischen Komponente gekommen. Das Erstellen und Anzeigen der Komponente funktioniert einwandfrei. Wird aber nun z.B. das Formular verkleinert und die Komponente etws verdeckt, dann "verschmiert" die Komponente beim erneuten vergrössern des Formulares. Ein "Repaint", "Update" etc. in der Paint-Routine hat nichts gebracht. Hoffe Ihr könnt mir weiterhelfen.

zusammenfalten · markieren

Delphi-Quellcode:

			type

  TMyLabel = class(TCustomControl)

  private

    { Private-Deklarationen }

    FText : String;

    procedure SetFText(Value : String);

  protected

    { Protected-Deklarationen }

    procedure Paint; override;

  public

    { Public-Deklarationen }

    constructor Create(AOwner : TComponent); override;

    destructor Destroy; override;

  published

    property Text : String read FText write SetFText;

    { Published-Deklarationen }

  end;

procedure Register;

implementation

constructor TMyLabel.Create(AOwner: TComponent);

begin

  inherited;

end;

destructor TMyLabel.destroy;

Begin

  inherited;

End;

procedure TMyLabel.SetFText(Value: string);

begin

  FText := Value;

  Invalidate;

end;

procedure TMyLabel.Paint;

begin

  inherited;

  // Falls in der IDE, dann getrichelten Rahmen anzeigen

  if csDesigning in ComponentState then

  begin

    Canvas.Brush.style := bsClear;

    Canvas.Pen.style := psDashDot;

    Canvas.Rectangle(0,0,width,height);

    canvas.TextOut((width - Canvas.TextWidth(FText)) div 2,(height - Canvas.TextHeight(FText)) div 2,FText);

    exit;

  end;

   // Zur Laufzeit einen Rahmen + Text in der Mitte anzeigen

   With Canvas do Begin;

    Canvas.Brush.Style := bsClear;

    Rectangle(Canvas.ClipRect);

    TextOut((width - Canvas.TextWidth(FText)) div 2,(height - Canvas.TextHeight(FText)) div 2,FText);

  End;

end;

SCRaT

**cruiser**

Repaint ruft nur die Paint-Prozedur wieder auf. Hilft dir also nicht gross weiter.

Ist das parent auf doublebuffered gestellt?

Ansonsten kannst du auch in ein Bitmap im Speicher repainten und das dann mit BitBlt auf den Canvas kopieren.

Zudem fällt mir Zeile 62 auf. meckert der Compiler da nicht?

**Hansa**

TCustomControl ist von TWinControl abgeleitet. Jetzt guck dir das mal an :

zusammenfalten · markieren

Delphi-Quellcode:

			  TWinControl = class(TControl)

  private

    FAlignLevel: Word;

    FBevelEdges: TBevelEdges;

    FBevelInner: TBevelCut;

    FBevelOuter: TBevelCut;

    FBevelKind: TBevelKind;

    FBevelWidth: TBevelWidth;

    FBorderWidth: TBorderWidth;

    FBrush: TBrush;

    FDefWndProc: Pointer;

    FDockClients: TList;

    FDockManager: IDockManager;

    FHandle: HWnd;

    FImeMode: TImeMode;

    FImeName: TImeName;

    FObjectInstance: Pointer;

    FParentWindow: HWnd;

    FTabList: TList;

    FControls: TList;

    FWinControls: TList;

    FTabOrder: Integer;

    FTabStop: Boolean;

    FCtl3D: Boolean;

    FShowing: Boolean;

    FUseDockManager: Boolean;

    FDockSite: Boolean;

    FParentCtl3D: Boolean;

    FOnDockDrop: TDockDropEvent;

    FOnDockOver: TDockOverEvent;

    FOnEnter: TNotifyEvent;

    FOnExit: TNotifyEvent;

    FOnGetSiteInfo: TGetSiteInfoEvent;

    FOnKeyDown: TKeyEvent;

    FOnKeyPress: TKeyPressEvent;

    FOnKeyUp: TKeyEvent;

    FOnUnDock: TUnDockEvent;

    procedure AlignControl(AControl: TControl);

    procedure CalcConstraints(var MinWidth, MinHeight, MaxWidth,

      MaxHeight: Integer);

    function GetAlignDisabled: Boolean;

    function GetControl(Index: Integer): TControl;

    function GetControlCount: Integer;

    function GetDockClientCount: Integer;

    function GetDockClients(Index: Integer): TControl;

    function GetHandle: HWnd;

    function GetParentBackground: Boolean;

    function GetTabOrder: TTabOrder;

    function GetVisibleDockClientCount: Integer;

    procedure Insert(AControl: TControl);

    procedure InvalidateFrame;

    procedure InvokeHelp;

    function IsCtl3DStored: Boolean;

    function PrecedingWindow(Control: TWinControl): HWnd;

    procedure ReadDesignSize(Reader: TReader);

    procedure Remove(AControl: TControl);

    procedure RemoveFocus(Removing: Boolean);

    procedure SetBevelCut(Index: Integer; const Value: TBevelCut);

    procedure SetBevelEdges(const Value: TBevelEdges);

    procedure SetBevelKind(const Value: TBevelKind);

    procedure SetBevelWidth(const Value: TBevelWidth);

    procedure SetBorderWidth(Value: TBorderWidth);

    procedure SetCtl3D(Value: Boolean);

    procedure SetDockSite(Value: Boolean);

    procedure SetParentCtl3D(Value: Boolean);

    procedure SetParentWindow(Value: HWnd);

    procedure SetTabOrder(Value: TTabOrder);

    procedure SetTabStop(Value: Boolean);

    procedure SetUseDockManager(Value: Boolean);

    procedure SetZOrderPosition(Position: Integer);

    procedure UpdateTabOrder(Value: TTabOrder);

    procedure UpdateBounds;

    procedure UpdateShowing;

    procedure WriteDesignSize(Writer: TWriter);

    function IsMenuKey(var Message: TWMKey): Boolean;

    procedure WMPaint(var Message: TWMPaint); message WM_PAINT;

    procedure WMCommand(var Message: TWMCommand); message WM_COMMAND;

    procedure WMNotify(var Message: TWMNotify); message WM_NOTIFY;

    procedure WMSysColorChange(var Message: TWMSysColorChange); message WM_SYSCOLORCHANGE;

    procedure WMHScroll(var Message: TWMHScroll); message WM_HSCROLL;

    procedure WMVScroll(var Message: TWMVScroll); message WM_VSCROLL;

    procedure WMCompareItem(var Message: TWMCompareItem); message WM_COMPAREITEM;

    procedure WMDeleteItem(var Message: TWMDeleteItem); message WM_DELETEITEM;

    procedure WMDrawItem(var Message: TWMDrawItem); message WM_DRAWITEM;

    procedure WMMeasureItem(var Message: TWMMeasureItem); message WM_MEASUREITEM;

    procedure WMEraseBkgnd(var Message: TWmEraseBkgnd); message WM_ERASEBKGND;

    procedure WMWindowPosChanged(var Message: TWMWindowPosChanged); message WM_WINDOWPOSCHANGED;

    procedure WMWindowPosChanging(var Message: TWMWindowPosChanging); message WM_WINDOWPOSCHANGING;

    procedure WMSize(var Message: TWMSize); message WM_SIZE;

    procedure WMMove(var Message: TWMMove); message WM_MOVE;

    procedure WMSetCursor(var Message: TWMSetCursor); message WM_SETCURSOR;

    procedure WMKeyDown(var Message: TWMKeyDown); message WM_KEYDOWN;

    procedure WMSysKeyDown(var Message: TWMKeyDown); message WM_SYSKEYDOWN;

    procedure WMKeyUp(var Message: TWMKeyUp); message WM_KEYUP;

    procedure WMSysKeyUp(var Message: TWMKeyUp); message WM_SYSKEYUP;

    procedure WMChar(var Message: TWMChar); message WM_CHAR;

    procedure WMSysCommand(var Message: TWMSysCommand); message WM_SYSCOMMAND;

    procedure WMCharToItem(var Message: TWMCharToItem); message WM_CHARTOITEM;

    procedure WMParentNotify(var Message: TWMParentNotify); message WM_PARENTNOTIFY;

    procedure WMVKeyToItem(var Message: TWMVKeyToItem); message WM_VKEYTOITEM;

    procedure WMDestroy(var Message: TWMDestroy); message WM_DESTROY;

    procedure WMNCCalcSize(var Message: TWMNCCalcSize); message WM_NCCALCSIZE;

    procedure WMNCDestroy(var Message: TWMNCDestroy); message WM_NCDESTROY;

    procedure WMNCHitTest(var Message: TWMNCHitTest); message WM_NCHITTEST;

    procedure WMNCPaint(var Message: TMessage); message WM_NCPAINT;

    procedure WMQueryNewPalette(var Message: TMessage); message WM_QUERYNEWPALETTE;

    procedure WMPaletteChanged(var Message: TMessage); message WM_PALETTECHANGED;

    procedure WMWinIniChange(var Message: TMessage); message WM_WININICHANGE;

    procedure WMFontChange(var Message: TMessage); message WM_FONTCHANGE;

    procedure WMTimeChange(var Message: TMessage); message WM_TIMECHANGE;

    procedure WMSetFocus(var Message: TWMSetFocus); message WM_SETFOCUS;

    procedure WMKillFocus(var Message: TWMSetFocus); message WM_KILLFOCUS;

    procedure WMIMEStartComp(var Message: TMessage); message WM_IME_STARTCOMPOSITION;

    procedure WMIMEEndComp(var Message: TMessage); message WM_IME_ENDCOMPOSITION;

    procedure WMContextMenu(var Message: TWMContextMenu); message WM_CONTEXTMENU;

    procedure CMChanged(var Message: TMessage); message CM_CHANGED;

    procedure CMChildKey(var Message: TMessage); message CM_CHILDKEY;

    procedure CMDialogKey(var Message: TCMDialogKey); message CM_DIALOGKEY;

    procedure CMDialogChar(var Message: TCMDialogChar); message CM_DIALOGCHAR;

    procedure CMFocusChanged(var Message: TCMFocusChanged); message CM_FOCUSCHANGED;

    procedure CMVisibleChanged(var Message: TMessage); message CM_VISIBLECHANGED;

    procedure CMEnabledChanged(var Message: TMessage); message CM_ENABLEDCHANGED;

    procedure CMColorChanged(var Message: TMessage); message CM_COLORCHANGED;

    procedure CMFontChanged(var Message: TMessage); message CM_FONTCHANGED;

    procedure CMBorderChanged(var Message: TMessage); message CM_BORDERCHANGED;

    procedure CMCursorChanged(var Message: TMessage); message CM_CURSORCHANGED;

    procedure CMCtl3DChanged(var Message: TMessage); message CM_CTL3DCHANGED;

    procedure CMParentCtl3DChanged(var Message: TMessage); message CM_PARENTCTL3DCHANGED;

    procedure CMShowingChanged(var Message: TMessage); message CM_SHOWINGCHANGED;

    procedure CMShowHintChanged(var Message: TMessage); message CM_SHOWHINTCHANGED;

    procedure CMEnter(var Message: TCMEnter); message CM_ENTER;

    procedure CMExit(var Message: TCMExit); message CM_EXIT;

    procedure CMDesignHitTest(var Message: TCMDesignHitTest); message CM_DESIGNHITTEST;

    procedure CMSysColorChange(var Message: TMessage); message CM_SYSCOLORCHANGE;

    procedure CMSysFontChanged(var Message: TMessage); message CM_SYSFONTCHANGED;

    procedure CMWinIniChange(var Message: TWMWinIniChange); message CM_WININICHANGE;

    procedure CMFontChange(var Message: TMessage); message CM_FONTCHANGE;

    procedure CMTimeChange(var Message: TMessage); message CM_TIMECHANGE;

    procedure CMDrag(var Message: TCMDrag); message CM_DRAG;

    procedure CNKeyDown(var Message: TWMKeyDown); message CN_KEYDOWN;

    procedure CNKeyUp(var Message: TWMKeyUp); message CN_KEYUP;

    procedure CNChar(var Message: TWMChar); message CN_CHAR;

    procedure CNSysKeyDown(var Message: TWMKeyDown); message CN_SYSKEYDOWN;

    procedure CNSysChar(var Message: TWMChar); message CN_SYSCHAR;

    procedure CMControlListChange(var Message: TMessage); message CM_CONTROLLISTCHANGE;

    procedure CMRecreateWnd(var Message: TMessage); message CM_RECREATEWND;

    procedure CMInvalidate(var Message: TMessage); message CM_INVALIDATE;

    procedure CMDockClient(var Message: TCMDockClient); message CM_DOCKCLIENT;

    procedure CMUnDockClient(var Message: TCMUnDockClient); message CM_UNDOCKCLIENT;

    procedure CMFloat(var Message: TCMFloat); message CM_FLOAT;

    procedure CMBiDiModeChanged(var Message: TMessage); message CM_BIDIMODECHANGED;

    procedure WMPrintClient(var Message: TWMPrintClient); message WM_PRINTCLIENT;

  protected

    FDoubleBuffered: Boolean;

    FInImeComposition: Boolean;

    FDesignSize: TPoint;

    procedure ActionChange(Sender: TObject; CheckDefaults: Boolean); override;

    procedure AddBiDiModeExStyle(var ExStyle: DWORD);

    procedure AssignTo(Dest: TPersistent); override;

    procedure AdjustClientRect(var Rect: TRect); virtual;

    procedure AdjustSize; override;

    procedure AlignControls(AControl: TControl; var Rect: TRect); virtual;

    function CanAutoSize(var NewWidth, NewHeight: Integer): Boolean; override;

    function CanResize(var NewWidth, NewHeight: Integer): Boolean; override;

    procedure ChangeScale(M, D: Integer); override;

    procedure ConstrainedResize(var MinWidth, MinHeight, MaxWidth,

      MaxHeight: Integer); override;

    procedure ControlsAligned; dynamic;

    function CreateDockManager: IDockManager; dynamic;

    procedure CreateHandle; virtual;

    procedure CreateParams(var Params: TCreateParams); virtual;

    procedure CreateSubClass(var Params: TCreateParams;

      ControlClassName: PChar);

    procedure CreateWindowHandle(const Params: TCreateParams); virtual;

    procedure CreateWnd; virtual;

    function CustomAlignInsertBefore(C1, C2: TControl): Boolean; virtual;

    procedure CustomAlignPosition(Control: TControl; var NewLeft, NewTop, NewWidth,

      NewHeight: Integer; var AlignRect: TRect; AlignInfo: TAlignInfo); virtual;

    procedure DefineProperties(Filer: TFiler); override;

    procedure DestroyHandle;

    procedure DestroyWindowHandle; virtual;

    procedure DestroyWnd; virtual;

    procedure DoAddDockClient(Client: TControl; const ARect: TRect); dynamic;

    procedure DockOver(Source: TDragDockObject; X, Y: Integer; State: TDragState;

      var Accept: Boolean); dynamic;

    procedure DoDockOver(Source: TDragDockObject; X, Y: Integer; State: TDragState;

      var Accept: Boolean); dynamic;

    procedure DoEnter; dynamic;

    procedure DoExit; dynamic;

    procedure DoFlipChildren; dynamic;

    function DoKeyDown(var Message: TWMKey): Boolean;

    function DoKeyPress(var Message: TWMKey): Boolean;

    function DoKeyUp(var Message: TWMKey): Boolean;

    procedure DoRemoveDockClient(Client: TControl); dynamic;

    function DoUnDock(NewTarget: TWinControl; Client: TControl): Boolean; dynamic;

    function FindNextControl(CurControl: TWinControl;

      GoForward, CheckTabStop, CheckParent: Boolean): TWinControl;

    procedure FixupTabList;

    function GetActionLinkClass: TControlActionLinkClass; override;

    procedure GetChildren(Proc: TGetChildProc; Root: TComponent); override;

    function GetClientOrigin: TPoint; override;

    function GetClientRect: TRect; override;

    function GetControlExtents: TRect; virtual;

    function GetDeviceContext(var WindowHandle: HWnd): HDC; override;

    function GetParentHandle: HWnd;

    procedure GetSiteInfo(Client: TControl; var InfluenceRect: TRect;

      MousePos: TPoint; var CanDock: Boolean); dynamic;

    function GetTopParentHandle: HWnd;

    function IsControlMouseMsg(var Message: TWMMouse): Boolean;

    procedure KeyDown(var Key: Word; Shift: TShiftState); dynamic;

    procedure KeyUp(var Key: Word; Shift: TShiftState); dynamic;

    procedure KeyPress(var Key: Char); dynamic;

    procedure MainWndProc(var Message: TMessage);

    procedure NotifyControls(Msg: Word);

    procedure PaintControls(DC: HDC; First: TControl);

    procedure PaintHandler(var Message: TWMPaint);

    procedure PaintWindow(DC: HDC); virtual;

    function PaletteChanged(Foreground: Boolean): Boolean; override;

    procedure ReadState(Reader: TReader); override;

    procedure RecreateWnd;

    procedure ReloadDockedControl(const AControlName: string;

      var AControl: TControl); dynamic;

    procedure ResetIme;

    function ResetImeComposition(Action: DWORD): Boolean;

    procedure ScaleControls(M, D: Integer);

    procedure SelectFirst;

    procedure SelectNext(CurControl: TWinControl;

      GoForward, CheckTabStop: Boolean);

    procedure SetChildOrder(Child: TComponent; Order: Integer); override;

    procedure SetIme;

    function SetImeCompositionWindow(Font: TFont; XPos, YPos: Integer): Boolean;

    procedure SetParentBackground(Value: Boolean); virtual;

    procedure SetZOrder(TopMost: Boolean); override;

    procedure ShowControl(AControl: TControl); virtual;

    procedure UpdateUIState(CharCode: Word);

    procedure WndProc(var Message: TMessage); override;

    property BevelEdges: TBevelEdges read FBevelEdges write SetBevelEdges default [beLeft, beTop, beRight, beBottom];

    property BevelInner: TBevelCut index 0 read FBevelInner write SetBevelCut default bvRaised;

    property BevelOuter: TBevelCut index 1 read FBevelOuter write SetBevelCut default bvLowered;

    property BevelKind: TBevelKind read FBevelKind write SetBevelKind default bkNone;

    property BevelWidth: TBevelWidth read FBevelWidth write SetBevelWidth default 1;

    property BorderWidth: TBorderWidth read FBorderWidth write SetBorderWidth default 0;

    property Ctl3D: Boolean read FCtl3D write SetCtl3D stored IsCtl3DStored;

    property DefWndProc: Pointer read FDefWndProc write FDefWndProc;

    property DockSite: Boolean read FDockSite write SetDockSite default False;

    property DockManager: IDockManager read FDockManager write FDockManager;

    property ImeMode: TImeMode read FImeMode write FImeMode default imDontCare;

    property ImeName: TImeName read FImeName write FImeName;

    property ParentBackground: Boolean read GetParentBackground write SetParentBackground;

    property ParentCtl3D: Boolean read FParentCtl3D write SetParentCtl3D default True;

    property UseDockManager: Boolean read FUseDockManager write SetUseDockManager

      default False;

    property WindowHandle: HWnd read FHandle write FHandle;

    property OnDockDrop: TDockDropEvent read FOnDockDrop write FOnDockDrop;

    property OnDockOver: TDockOverEvent read FOnDockOver write FOnDockOver;

    property OnEnter: TNotifyEvent read FOnEnter write FOnEnter;

    property OnExit: TNotifyEvent read FOnExit write FOnExit;

    property OnGetSiteInfo: TGetSiteInfoEvent read FOnGetSiteInfo write FOnGetSiteInfo;

    property OnKeyDown: TKeyEvent read FOnKeyDown write FOnKeyDown;

    property OnKeyPress: TKeyPressEvent read FOnKeyPress write FOnKeyPress;

    property OnKeyUp: TKeyEvent read FOnKeyUp write FOnKeyUp;

    property OnUnDock: TUnDockEvent read FOnUnDock write FOnUnDock;

  public

    constructor Create(AOwner: TComponent); override;

    constructor CreateParented(ParentWindow: HWnd);

    class function CreateParentedControl(ParentWindow: HWnd): TWinControl;

    destructor Destroy; override;

    procedure Broadcast(var Message);

    function CanFocus: Boolean; dynamic;

    function ContainsControl(Control: TControl): Boolean;

    function ControlAtPos(const Pos: TPoint; AllowDisabled: Boolean;

      AllowWinControls: Boolean = False): TControl;

    procedure DefaultHandler(var Message); override;

    procedure DisableAlign;

    property DockClientCount: Integer read GetDockClientCount;

    property DockClients[Index: Integer]: TControl read GetDockClients;

    procedure DockDrop(Source: TDragDockObject; X, Y: Integer); dynamic;

    property DoubleBuffered: Boolean read FDoubleBuffered write FDoubleBuffered;

    procedure EnableAlign;

    function FindChildControl(const ControlName: string): TControl;

    procedure FlipChildren(AllLevels: Boolean); dynamic;

    function Focused: Boolean; dynamic;

    procedure GetTabOrderList(List: TList); dynamic;

    function HandleAllocated: Boolean;

    procedure HandleNeeded;

    procedure InsertControl(AControl: TControl);

    procedure Invalidate; override;

    procedure PaintTo(DC: HDC; X, Y: Integer); overload;

    procedure PaintTo(Canvas: TCanvas; X, Y: Integer); overload;

    procedure RemoveControl(AControl: TControl);

    procedure Realign;

    procedure Repaint; override;

    procedure ScaleBy(M, D: Integer);

    procedure ScrollBy(DeltaX, DeltaY: Integer);

    procedure SetBounds(ALeft, ATop, AWidth, AHeight: Integer); override;

    procedure SetFocus; virtual;

    procedure Update; override;

    procedure UpdateControlState;

    property AlignDisabled: Boolean read GetAlignDisabled;

    property VisibleDockClientCount: Integer read GetVisibleDockClientCount;

    property Brush: TBrush read FBrush;

    property Controls[Index: Integer]: TControl read GetControl;

    property ControlCount: Integer read GetControlCount;

    property Handle: HWnd read GetHandle;

    property ParentWindow: HWnd read FParentWindow write SetParentWindow;

    property Showing: Boolean read FShowing;

    property TabOrder: TTabOrder read GetTabOrder write SetTabOrder default -1;

    property TabStop: Boolean read FTabStop write SetTabStop default False;

  published

end;

Macht es da wirklich Sinn, "zu Lernzwecken" diesen ganzen Kram (fast) neu zu programmieren, zu testen usw. ?

Auch das "Overload" spielt eine wichtige Rolle. Siehe z.B. "PaintTo".

Du steigst in die Objekt-Hierarchie wirklich sehr tief ein. Zeichenroutinen sollte man nach Möglichkeit wirklich Windows überlassen und nicht auch noch das selber übernehmen.

**scrat1979**

Zitat von Hansa:

Macht es da wirklich Sinn, "zu Lernzwecken" diesen ganzen Kram (fast) neu zu programmieren, zu testen usw. ?

Auch das "Overload" spielt eine wichtige Rolle. Siehe z.B. "PaintTo".

Du steigst in die Objekt-Hierarchie wirklich sehr tief ein. Zeichenroutinen sollte man nach Möglichkeit wirklich Windows überlassen und nicht auch noch das selber übernehmen.

Hmmm, naja ok. Anders herum gefragt: Wenn ich eine grafische Komponente entwickeln möchte (z.B. eine ProgressBar, wie gesagt, nur als Beispiel!), gibt es da einen bestimmten Vorfahren, den man wählen sollte und bei welchem dann dieses Problem nicht auftritt?

Zitat:

Ansonsten kannst du auch in ein Bitmap im Speicher repainten und das dann mit BitBlt auf den Canvas kopieren.

Gibt es dazu einen Beispiel-Code, habe davon nämlich (leider) noch keine Ahnung

Zitat:

Zudem fällt mir Zeile 62 auf. meckert der Compiler da nicht?

Zeile 62 lautet bei mir:

canvas.TextOut((width - Canvas.TextWidth(FText)) div 2,(height - Canvas.TextHeight(FText)) div 2,FText); Nein, also bei mir kommt kein Hinweis oder Fehler. Wieso, was stimmt denn daran nicht?!?

Also, da ist mir gerade noch was aufgefallen. Zur Designzeit, wo ja auch was gezeichnet wird, tritt dieses Problem nicht auf und die Komponente erscheint nach vergrößern des Fenstern wieder korrekt. vielleicht ist das normal, vielleicht hilft Euch das aber auch noch weiter...

Schonmal jetzt danke für Eure Tips!

SCRaT

**scrat1979**

Zitat von cruiser:

Repaint ruft nur die Paint-Prozedur wieder auf. Hilft dir also nicht gross weiter.

Ist das parent auf doublebuffered gestellt?

Ansonsten kannst du auch in ein Bitmap im Speicher repainten und das dann mit BitBlt auf den Canvas kopieren.

Jaaaa!! Jetzt funktioniert es. Habe jetzt einfach "Doublebuffered := True" in den Constructor eingefüt. Hoffe dass ich es korrekt eingefügt habe

Zitat von Hansa:

Macht es da wirklich Sinn, "zu Lernzwecken" diesen ganzen Kram (fast) neu zu programmieren, zu testen usw. ? Shocked Auch das "Overload" spielt eine wichtige Rolle. Siehe z.B. "PaintTo".

Du steigst in die Objekt-Hierarchie wirklich sehr tief ein. Zeichenroutinen sollte man nach Möglichkeit wirklich Windows überlassen und nicht auch noch das selber übernehmen.

Ok, ich habe mir Deinen Tips mal zu Herzen genommen (bin ja schliesslich flexibel

) und die Komponente von "TCustomLabel" abgeleitet. Leider funktioniert da ein doublebuffered := true nicht und das Problem tritt hier genau so auf. Was für ein "Trick" gibt es denn in diesem Fall?

Wäre nett,wenn Ihr meinen letzten Post trotzdem noch anschauen würdet!

SCRaT

**bitsetter**

Versuche es mal damit:

markieren

Delphi-Quellcode:

			   // Zur Laufzeit einen Rahmen + Text in der Mitte anzeigen

   With Canvas do Begin

    Canvas.Brush.Style := bsClear;

    Canvas.Rectangle(0,0,width,height);//geändert

    //Rectangle(Canvas.ClipRect);

    TextOut((width - Canvas.TextWidth(FText)) div 2,(height - Canvas.TextHeight(FText)) div 2,FText);

  End;

EDIT:

markieren

Delphi-Quellcode:

			procedure TMyLabel.SetFText(Value: string);

begin

  FText := Value;

  Invalidate;

  self.Width:= Canvas.TextWidth(FText);//breite automatisch setzen

  self.Height:= canvas.TextHeight(FText);//höhe automatisch setzen

end;

**SirThornberry**

wenn du transparenz willst solltest du nicht von TCustomControl sondern von TGraphicControl ableiten.

**scrat1979**

Vielen Dank! Jetzt läuft es auch wie es soll

SCRaT

TMyLabel - Refresh-Problem

TMyLabel - Refresh-Problem

Re: TMyLabel - Refresh-Problem

Re: TMyLabel - Refresh-Problem

Re: TMyLabel - Refresh-Problem

Re: TMyLabel - Refresh-Problem

Re: TMyLabel - Refresh-Problem

Re: TMyLabel - Refresh-Problem

Re: TMyLabel - Refresh-Problem

Forumregeln

SirThornberry (Moderator) Registriert seit: 23. Sep 2003 Ort: Bockwen 12.235 Beiträge Delphi 2006 Professional	#7 Re: TMyLabel - Refresh-Problem 14. Feb 2007, 09:54 wenn du transparenz willst solltest du nicht von TCustomControl sondern von TGraphicControl ableiten. Jens Mit Source ist es wie mit Kunst - Hauptsache der Künstler versteht's
	Zitat

scrat1979 Registriert seit: 12. Jan 2007 Ort: Sulzbach a.d. Murr 1.028 Beiträge Delphi 10.4 Sydney	#8 Re: TMyLabel - Refresh-Problem 14. Feb 2007, 12:31 Vielen Dank! Jetzt läuft es auch wie es soll SCRaT Michael Kübler
	Zitat