Entwickler-Ecke
Sonstiges (Delphi) - Formel gesucht?
ALF - Do 04.11.10 16:06
Titel: Formel gesucht?
Ich weiss, peinlich. Ich Frage trotzdem mal nach.
Das ist der Ausgangspunkt:
FillSize:= SolveForX(PercentDone, W)
Ergebnis: FillSize 0<=W.
Nun kommt eine Variable dazu, nennen wir sie A diese kann Werte annehmen 0<=X
Fillsize soll nun zusätzlich den Wert von A annehmen und A soll wiederum Proportional >=0 werden wenn Fillsize <=W wird.
vergebliche Versuche, naja......
FillSize:= SolveForX(PercentDone, W) + A ..... (Fillsize (/) (*) irgendwas - irgenwas (/) (*) ...) ????
Aber wie immer pack ich die Reihenfolge nicht, wo was an welcher Stelle mit wem, sein muss!?
Selbst auf Papier(mehrere Seiten) will nichts zustande kommen :oops:
und hoffe da könnt ihr weiter Helfen.
Gruss ALf
Kha - Do 04.11.10 16:14
ALF hat folgendes geschrieben : |
| Fillsize soll nun zusätzlich den Wert von A annehmen und A soll wiederum Proportional >=0 werden wenn Fillsize <=max wird. |
Kannst du diesen Satz noch einmal mathematisch definieren? Bis jetzt sieht er für mich so aus, als könnte man das Blaue vom Himmel dort hinein-interpretieren :| .
/edit: Es fängt schon früher an, was soll
| Zitat: |
| Ergebnis: FillSize 0<=W. |
bedeuten? 0 <= FillSize <= W?
elundril - Do 04.11.10 16:15
Kann es sein das du einfach ne Progressbar nachbauen willst? So mehr oder weniger?
lg elundril
ALF - Do 04.11.10 16:31
@elundril: jo hab ich schon. Problem ist der zusätzliche Border, den ich ab bzw dazu rechnen muss.
@Kha: Ok ohne Symbole.
FillSize soll nun zusätzlich den Wert von A annehmen.
A, soll wiederum proportional kleiner gleich 0 werden, wenn FillSize grösser wird bis max W.
Hinweis: A, ist nie grösser als W
Bin nun mal kein Mathematiker um dies so zu schreiben oder anders zu erklären :oops:
Wüsste sonst nicht mehr wie man es noch schreiben soll?
Gruss ALf
buster - Do 04.11.10 17:09
öhm... A = W - FillSize ??? wenn W konstant bleibt :idea:
ALF - Do 04.11.10 17:38
Ich weiss, schlecht beschrieben aber wie soll ich es sonst Formulieren!!
@Buster: A ist ein selbständiger Wert und soll kleiner werden!
Gruss ALf
platzwart - Do 04.11.10 17:51
@Alf: Sorry, aber niemand versteht, worum es überhaupt geht?!? Vielleicht kannst du uns folgendermaßen helfen:
Welche Variable ist eine Konstante, welche nicht?
Für was stehen die Variablennamen A, w, ...
Was sind Maximal-/Minimalwerte?
FinnO - Do 04.11.10 17:52
Sowas?
| Zitat: |
FillSize soll nun zusätzlich den Wert von A annehmen.
A, soll wiederum proportional kleiner gleich 0 werden, wenn FillSize grösser wird bis max W.
Hinweis: A, ist nie grösser als W |
Delphi-Quelltext
1: 2: 3: 4:
| Fillsize := A; if A < W then A := A * (1 / Fillsize) |
LG
ALF - Do 04.11.10 20:11
Ok, mal sehen ob ich es jetzt schaffe. :cry:
SolveForX(PercentDone, W) ist eine Funktion aus ProgressBar.
W kann einen Wert von 0 bis entlos annehmen. Setzen wir aber auf 100.
Quelltext
1: 2: 3:
| W = 100
Fillsize:= SolveForX(PercentDone, W) |
Fillsize enthält das Ergebnis von SolveForX(PercentDone, W), also in diesem Fall 0 bis 100.
Jetzt kommt das
zusätzliche!
A kann einen Wert von 0 bis entlos annehmen. Setzen wir aber auf 3.
FillSize soll nun
zusätzlich den Wert von A annehmen. Kein Problem :wink:
Quelltext
1:
| Fillsize:= SolveForX(PercentDone, W) + A |
jetzt wirds eng.
A soll aber proportional kleiner werden, wenn das Ergebnis von SolveForX(PercentDone, W) grösser wird
also in etwa so:
Quelltext
1:
| Fillsize:= SolveForX(PercentDone, W) + A - (( SolveForX(PercentDone, W) / A) * w) |
oder so ähnlich. Dabei darf A ja nicht kleiner als 0 werden.
Ich hoffe das es nun Verständlich ist
Wenn nicht, löscht einfach diesen Thread.
Gruss ALf
FinnO - Do 04.11.10 20:21
Also so?
Delphi-Quelltext
1:
| Fillsize := SolveForX(PercentDone, W) + (1 / SolveForX(PercentDone, W)) * A |
LG
ALF - Do 04.11.10 20:30
Im prinzip ja. Nur halt die Division durch null darf ja nicht vorkommen.
und da gabs auch was mit ner Formel???
Irgend wie so:
Quelltext
1:
| Fillsize := SolveForX(PercentDone, W) + (1 div (SolveForX(PercentDone, W) + 1) * PaintRect.Left); |
nur fehlt da noch was??
Gruss Alf
FinnO - Do 04.11.10 21:04
Moin,
wenn du ein proportionales schrumpfen möchtest, bietet sich soetwas einfach an :-P. Im einfachsten Fall kannst du einfach vorher abfragen, ob SolveForX > 0 ist (davon bin ich mal ausgegangen, bei <0 müsste man noch am Vorzeichen drehen. Wenn du einen Grenzwert möchtest, bietet sich ja eine Exponentialfunktion an ;)
edit:
Sorry, hab deinen nachtrag zu spät gelesen. Also die addition dreht imho zu sehr am ergebnis. Auch die Divison mit div und die darauffolgende multiplikation versemmeln dir jegliche genauigkeit. Besser: erst rechnen, dann runden.
LG
delfiphan - Do 04.11.10 21:14
Vielleicht kannst du einfach mal beschreiben, was du erreichen willst, ohne irgendwelche Formeln. Vielleicht eine Skizze, mit den Bereichen und dem Border. Wenn du dir die Fragestellung klar formulierst und skizzierst, kommst du vermutlich selbst auf die Lösung...
Du willst irgendwie die Breite des zu füllenden Rechtecks in einer Progressbar berechnen und dabei einen linken Rand berücksichtigen?
Damm meinst du vielleicht das hier: SolveForX(PercentDone, W) liefert einen Wert zwischen 0 und W. Du möchtest jetzt aber eine Verschobene und linear skalierte Funktion, die einen Wert zwischen A und W liefert. In dem Fall skalierst du das Resultat von SolveForX um den Faktor (W - A)/W und addierst A. Also FillSize = SolveForX(PercentDone, W) * (W - A) / W + A ?
ALF - Do 04.11.10 21:45
FinnO hat folgendes geschrieben : |
| Also die addition dreht imho zu sehr am ergebnis. |
So wie sie da steht richtig. Wie gesagt dafür gabs auch was, das dies wieder ausgeglichen wird. Nur ewig her wo man sowas mal wusste.
FinnO hat folgendes geschrieben : |
Auch die Divison mit div und die darauffolgende multiplikation versemmeln dir jegliche genauigkeit. Besser: erst rechnen, dann runden.
LG |
schon korregiert :wink:
delfiphan hat folgendes geschrieben : |
| Vielleicht kannst du einfach mal beschreiben, was du erreichen willst, ohne irgendwelche Formeln. |
Schlicht und einfach. Ich habe vergessen bei der graphischen Darstellung einer selbstgebastellten Gauge den BorderSize zu berücksichtigen. Ergo fängt die zu füllende Fläsche bei 0 an und nicht bei '3' zB, bzw wenn kein Border ist dann natürlich bei 0.
Der Versuch einfach das zeichnen daran anzupassen mh.... wüsste einfach nicht wo??? kurzer Code dazu.
Delphi-Quelltext
1: 2: 3: 4: 5: 6:
| Fillsize := trunc(SolveForX(PercentDone, W); AnImage.Canvas.FillRect(Rect(PaintRect.Left, PaintRect.Top, FillSize, PaintRect.Bottom)); |
Dürfte aber nix mehr mit Formel zu tun haben. Aber irgend wie doch noch :gruebel:
Gruss ALf
ALF - Do 04.11.10 21:53
THX @delfiphan
Genau das war es :tongue:
Also doch Formel, nur der Weg dahin schweeeeeeer.
Sorry 'Verschobene und linear skalierte Funktion' hat man ja nicht jeden Tag.
Merken kann ich mir sowas eh nicht, leider. :?
Gruss ALf
delfiphan - Do 04.11.10 22:45
ALF hat folgendes geschrieben : |
Also doch Formel, nur der Weg dahin schweeeeeeer.
Merken kann ich mir sowas eh nicht, leider. :? |
So viel zu merken gibt's da nicht ;)
Du machst einfach eine Skizze und merkst, dass du aus dem Bereich der Grösse W einen Bereich der Grösse W - A machen willst. Daher kannst du mit dem Dreisatz einfach durch W dividieren und mit W - A multiplizieren. Dann noch A addieren, wie du bereits selbst herausgefunden hast. Gibt genau die Formel oben.
Dein Lösungsansatz war gar nicht so falsch. Du hast einfach den Dreisatz verkehrt angewendet. Die Formel "auf deine Art gelöst" müsste so gehen:
SolveForX(PercentDone, W) + A - SolveForX(PercentDone, W) / W * A
Alternativ könnte man auch schreiben:
SolveForX(PercentDone, W) + A - PercentDone / 100 * A
Die 3 Formeln kann man ineinander umrechnen.
Delete - Do 04.11.10 23:08
Entweder werde ich durch die Chemo langsam matschig in der Birne oder er hat es so erklärt, dass es für den durchschnittlich intelligenten Erdenbürger, wie ich es einer bin, unverständlich bleibt.
Also er hat doch schon den Prozentsatz. Diesen muss er doch nur in Pixel in Abhängigkeit der Breite der Gauge umrechnen. Die Breite natürlich ohne Rand. Den Rand kann man dann ja beim Zeichnen berücksichtigen. Was ich sagen will, mir kommen eure Lösungen unnötig kompliziert vor.
delfiphan - Do 04.11.10 23:29
Naja, ob Percent / 100 * (W - A) + A. oder SolveForX(PercentDone, W) / W * (W - A) + A, ist praktisch das gleiche. Ich ging jetzt mal davon aus, dass er ums Verrecken seine Funktion verwenden will. Das hatte ich bisher noch nicht hinterfragt ;)
Sinnvoll wäre eine "world transformation", die aus dem Parameter direkt die Breite in Pixel berechnet.
ALF - Do 04.11.10 23:31
Luckie hat folgendes geschrieben : |
| ...dass es für den durchschnittlich intelligenten Erdenbürger, wie ich es einer bin, unverständlich bleibt. |
Du erkennst an meiner Fragestellung wie weit ich da noch drunter bin!
EDIT: Zeilen entfernt.
Ok,ich nehme alles zurück und behaupte das gegenteil :wink:
Nach nochmaligen durchschauen der Paint Routine, habt ihr natürlich recht.
Ich kann die ganze Fläsche zeichnen und dann mit
Delphi-Quelltext
1: 2:
| if FBorderStyle = bsSingle then InflateRect(PaintRect, -FBorderSize, -FBorderSize); |
das ganze wieder zurück zeichnen erspart man sich die Formel! 8)
Aber durch solch Diskurs, kann man halt nur lernen und weis es beim nächsten mal selbst :D
Gruss ALf
Delete - Fr 05.11.10 03:17
Also ich hätte es so gemacht:
Delphi-Quelltext
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41: 42: 43: 44: 45: 46: 47: 48: 49: 50: 51: 52: 53: 54: 55: 56: 57: 58: 59: 60: 61: 62: 63: 64: 65: 66: 67: 68: 69: 70: 71: 72: 73: 74: 75: 76: 77: 78: 79: 80: 81: 82: 83:
| unit Unit1;
interface
uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls, ExtCtrls;
type TForm1 = class(TForm) Timer1: TTimer; procedure FormPaint(Sender: TObject); procedure Timer1Timer(Sender: TObject); procedure FormCreate(Sender: TObject); private FPercent: Integer; FPixels: Integer; procedure PaintGauge; procedure CalcPixels; public end;
var Form1: TForm1;
const MAXWIDTH = 375; PENWIDTH = 1;
implementation
{$R *.dfm}
procedure TForm1.FormCreate(Sender: TObject); begin FPercent := 0; CalcPixels; Form1.Repaint; end;
procedure TForm1.Timer1Timer(Sender: TObject); begin if FPercent < 100 then begin CalcPixels; Inc(FPercent); Caption := Format('Prozent: %d / Pixel: %d', [FPercent, FPixels]); end else FPercent := 0; Form1.Repaint; end;
procedure TForm1.FormPaint(Sender: TObject); begin PaintGauge; end;
procedure TForm1.CalcPixels; begin FPixels := MAXWIDTH * FPercent div 100; end;
procedure TForm1.PaintGauge; begin Canvas.Pen.Style := psSolid; Canvas.Pen.Color := clBlack; Canvas.Pen.Width := PENWIDTH; Canvas.Rectangle(100, 75, 100+MAXWIDTH, 90); Canvas.Brush.Style := bsSolid; Canvas.Brush.Color := clWhite; Canvas.FillRect(Rect(100+PENWIDTH,75+PENWIDTH,100+MAXWIDTH-PENWIDTH,90-PENWIDTH)); Canvas.Brush.Style := bsSolid; Canvas.Brush.Color := clRed; Canvas.FillRect(Rect(100+PENWIDTH,75+PENWIDTH,100+PENWIDTH+FPixels+PENWIDTH,90-PENWIDTH)); end;
end. |
Die Zeichenroutine stimmt nicht ganz. Ändert man die Zeichenstiftdicke, wird das nicht so richtig berücksichtigt. Mit den Zeichenroutinen kenne ich mich nicht so aus.
ALF - Fr 05.11.10 13:17
Hi, hab das mal nur überflogen.
Unabhängig von Pen, der eh nur 1Pixel ist und bleibt, ausser beim '//Rahmen'= BorderSize 3Pixel als Beispiel, sehe ich aber auch nur, das Progress nicht den Border berücksichtigt sondern ebenfalls bei 0 anfängt zu Zeichnen und nicht nach den Border, so auf den ersten Blick.
Denn, wenn der '//Rahmen' 3Pixel=BorderSize breit ist, muss es bei '//Hintergrund und //Fortschritt' Pen=1 und bei 'CalcPixel' berücksichtigt werden oder nicht?
Vom Prinzip her, kommt es zum Schluss auf das selbe herraus wie ich es jetzt mache. //CalcPixel muss den Rahmen beim berechen mit berücksichtigen! so oder so :wink:
Gruss ALf
buster - Fr 05.11.10 15:22
Luckie hat folgendes geschrieben : |
| ... mir kommen eure Lösungen unnötig kompliziert vor. |
Finde ich auch :)
Entweder man berechnet sich die verfügbare Breite über
Delphi-Quelltext
1:
| UseableWidth := MAXWIDTH - (2 * PENWIDTH); |
und berechnet dann
Delphi-Quelltext
1:
| FPixels := UseableWidth * FPercent div 100; |
und tut dann halt dergleichen:
Delphi-Quelltext
1: 2: 3:
| Canvas.Rectangle(100, 75, 100+MAXWIDTH, 90); Canvas.FillRect(Rect(100+PENWIDTH,75+PENWIDTH,100+MAXWIDTH-PENWIDTH,90-PENWIDTH)); Canvas.FillRect(Rect(100+PENWIDTH,75+PENWIDTH,100+PENWIDTH+FPixels,90-PENWIDTH)); |
oder man belässt es einfach bei der alten Fläche und rechnet den Rahmen drumherum noch dazu (wenn es denn möglich ist), in der Art
Delphi-Quelltext
1: 2: 3:
| Canvas.Rectangle(100-PENWIDTH, 75-PENWIDTH, 100+MAXWIDTH+PENWIDTH, 90+PENWIDTH); Canvas.FillRect(Rect(100,75,100+MAXWIDTH,90)); Canvas.FillRect(Rect(100,75,100+FPixels,90)); |
delfiphan - Fr 05.11.10 16:18
buster hat folgendes geschrieben : |
Delphi-Quelltext 1:
| FPixels := UseableWidth * FPercent div 100; | |
buster - Fr 05.11.10 16:40
Jaaaa...??? und? Prozentrechnung??? ;) (wenns 50% sind, dann sind es die Anzahl der Pixel mal 50 geteilt durch 100 ohne Rest, oder?)
delfiphan - Fr 05.11.10 17:19
Ich nehms zurück. Ich hab da wohl eine Klammer halluziniert :)
buster - Fr 05.11.10 17:21
jo, ist ja auch schon spääät ;)
ALF - Sa 06.11.10 01:13
Habt ihr euch mal das alles angeschaut! Sieht das nicht unübersichtlich aus?
Es gibt nur einen Pen der 1x verändert wird und das ist der für den Rahmen. Danach bleibt der Pen beim Zeichnen 1Pixel gross. Wenn ich jetzt noch Vertikal, von rechts nach links, von oben nach unten und umgekehrt zeichnen will,
müsste ich das alles so eingeben wie @Lucki es macht. Sorry @Lucki, in diesem Fall zu aufwendig und meiner Meinung nach umständlich! Eventuell sogar anfällig irgendwo mal ne Zahl falsch anzugeben!
Da man dies dann in
jeder Zeichenroutine wieder eintragen muss.
Ich verwende einfach:
Delphi-Quelltext
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41: 42: 43: 44: 45: 46: 47: 48: 49: 50: 51: 52: 53: 54: 55: 56: 57: 58: 59: 60: 61: 62: 63: 64: 65:
| procedure TGaugeButton.Paint; var TheImage: TBitmap; OverlayImage: TBltBitmap; PaintRect: TRect; Distance: Integer; begin with Canvas do begin TheImage:= TBitmap.Create; try TheImage.Height:= Height; TheImage.Width:= Width;
PaintRect:= ClientRect; if FBorderStyle = bsSingle then InflateRect(PaintRect, -FBorderWidth, -FBorderWidth);
OverlayImage:= TBltBitmap.Create; try OverlayImage.MakeLike(TheImage); PaintBorder(OverlayImage); PaintAsBar(OverlayImage, PaintRect); PaintALink(OverlayImage); PaintAsText(OverlayImage, PaintRect); TheImage.Canvas.Draw(0, 0, OverlayImage);
finally OverlayImage.Free; end; Canvas.Draw(0, 0, TheImage); finally TheImage.Destroy; end; end;
procedure TGaugeButton.PaintBorder(AnImage: TBitmap); begin AnImage.Canvas.Brush.Color:= FBorderColor; AnImage.Canvas.FillRect(AnImage.Canvas.ClipRect); end;
procedure TGaugeButton.PaintAsBar(AnImage: TBitmap; PaintRect: TRect); var FillSize: Longint; W, I, mergepos: Integer; RsValue, GsValue, BsValue, ReValue, GeValue, BeValue: Double; begin W:= PaintRect.Right; AnImage.Canvas.Brush.Color:= FBackColor; AnImage.Canvas.FillRect(PaintRect); AnImage.Canvas.Pen.Width:= 1; AnImage.Canvas.Brush.Color:= FStartColor;
Fillsize := trunc(SolveForX(PercentDone, W)*(W - PaintRect.Left) / W +PaintRect.Left); AnImage.Canvas.FillRect(Rect(PaintRect.Left, PaintRect.Top, FillSize, PaintRect.Bottom)); end; |
Ich persöhnlich finde meine Variante übersichtlicher
Aber na gut, was nun besser ist..???
Wichtig ist das es optimal ist und gut funktioniert. :wink:
Gruss ALf
Delete - Sa 06.11.10 04:57
Also mein Code war nur relativ schnell runtergeschrieben. Ich wollte deutlich machen, dass ich die Berechnung etwas umständlich fand. Mit den Zeichenroutinen kenne ich mich nicht so aus, deswegen kann man da bestimmt noch optimieren bzw. es besser machen.
ALF - Sa 06.11.10 08:14
Jo das weiß ich doch :wink:
Die Idee, mit der Formel den evtl Border gleich dort mit zu berücksichtigen, find ich doch nur einfacher, als ihn beim zeichnen zu berücksichtigen. Ob man es nun so macht oder nicht, bleibt doch letztentlich jedem selbst überlassen :mrgreen: :zwinker:
Dabei wollte ich doch nur den Dreisatz noch mal erklärt haben :lol:
Gruss ALf
jaenicke - Sa 06.11.10 11:52
Ich benutze für sowas lieber die integrierten Möglichkeiten der API, z.B. für Rechtecke und Berechnung des Bereichs der Textausgabe.
Im Anhang nen kleines Beispiel für einen GaugeButton mit Themes (im Programm sind diese nicht akitiviert, nur bei der Komponente). Die drei Trackbars regeln Minimum, Position und Maximum (auch umgekehrt mit Max < Min geht natürlich).
Code zum Zeichnen selbst:
Delphi-Quelltext
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27:
| procedure TGaugeButton.Paint; var DrawRect, ChunkRect, CaptionRect: TRect; begin inherited; DrawRect := ClientRect; Canvas.Brush.Style := bsClear; InflateRect(DrawRect, -2, -2); if FMouseDown then OffsetRect(DrawRect, 1, 1); ThemeServices.DrawElement(Canvas.Handle, ThemeServices.GetElementDetails(tpBar), DrawRect); InflateRect(DrawRect, -1, -1); ChunkRect := DrawRect; if FMax > FMin then Dec(ChunkRect.Right, (FMax - FPosition) * (ChunkRect.Right - ChunkRect.Left) div (FMax - FMin)) else if FMax < FMin then Inc(ChunkRect.Left, (FMax - FPosition) * (ChunkRect.Right - ChunkRect.Left) div (FMax - FMin)); ThemeServices.DrawElement(Canvas.Handle, ThemeServices.GetElementDetails(tpChunk), ChunkRect); CaptionRect := DrawRect; DrawText(Canvas.Handle, PChar(Text), Length(Text), CaptionRect, DT_CENTER or DT_WORDBREAK or DT_CALCRECT); InflateRect(DrawRect, - (DrawRect.Right - CaptionRect.Right) div 2, - (DrawRect.Bottom - CaptionRect.Bottom) div 2); DrawText(Canvas.Handle, PChar(Text), Length(Text), DrawRect, DT_CENTER or DT_WORDBREAK); end; |
ALF - Sa 06.11.10 15:46
Um Missverständnisse auszuräumen. Meine Komponente(ProgressBar oder Gauge) ist kein Button als solches. Sie beinhaltet lediglich zusätzlich 4 Buttons, die für spezielle Aufgaben bestimmt sind. Darum auch diese private Bezeichnung (GaugeButton) von mir :wink:
Aber Dein Code @jaenicke, die gesamte Gauge als Button zu machen, hat mich natürlich wieder mal voll überzeugt und werde es als Option zusätzlich mit anbieten. Ob Er es dann nutzen will, kann Er ja dann selber entscheiden. :beer:
Für diese Idee ein dickes Danke
Gruss ALf
jaenicke - Sa 06.11.10 15:48
Genauso kannst du das auch mit mehreren Buttons machen. ;-)
Dann natürlich mit etwas mehr Logik.
Ich wollte vor allem zeigen, dass Windows durchaus fertige Funktionen zu bieten hat um solche Bereiche zu berechnen.
jaenicke - So 07.11.10 01:38
Hier einmal ein Beispiel für mehrere Buttons mit Theming und Alphablending. Mir war langweilig und es hat mich interessiert. :D
BenBE - So 07.11.10 07:23
Ich hoffe, das handled wenigstens FMin=FMax ;-) Ansonsten nette Beispiele. IIRC gab's auch eine DeflateRect-Funktion o.s.ä. Bin mir da aber grad nicht sicher und hab kein Delphi verfügbar.
jaenicke - So 07.11.10 11:17
BenBE hat folgendes geschrieben : |
| Ich hoffe, das handled wenigstens FMin=FMax ;-) |
Es fängt es ab, ja. Ich behandle es nicht weiter (wozu auch?), aber die Division durch Null verhindere ich.
BenBE hat folgendes geschrieben : |
| IIRC gab's auch eine DeflateRect-Funktion o.s.ä. Bin mir da aber grad nicht sicher und hab kein Delphi verfügbar. |
Wäre mir und Delphi neu. :mrgreen: ;-)
Man kann ja negative Werte an InflateRect übergeben, deshalb braucht man das auch nicht.
ALF - So 07.11.10 15:21
Hi, optisch natürlich super. Würde mich und meine einfache Arbeit um Wochen zurückwerfen, würde ich versuchen es so umzusetzen!
Vom Verstehen(Lerneffekt), was, wie, wo und warum so und nicht so, mal ganz abgesehen!
Gruss ALf
Entwickler-Ecke.de based on phpBB
Copyright 2002 - 2011 by Tino Teuber, Copyright 2011 - 2026 by Christian Stelzmann Alle Rechte vorbehalten.
Alle Beiträge stammen von dritten Personen und dürfen geltendes Recht nicht verletzen.
Entwickler-Ecke und die zugehörigen Webseiten distanzieren sich ausdrücklich von Fremdinhalten jeglicher Art!