Forenbeiträge von Console.Beep() Ingesamt 20 Beiträge
Hallo,
Ich habe in meinen Programm ein ZedGraph-Control welches bis zu 4 Y-Achsen hat.
Nun möchte ich für die Punkte, die über die 4. Y-Achse angezeigt und skaliert werden, Text anzeigen.
Dazu verwende ich folgenden Code:
TextObj tobj = new TextObj(text, date, xVal, CoordType.AxisXYScale);
zedGraph.GraphPane.GraphObjList.Add(tobj);
Der Text ist an der richtigen X-Position nur die Y-Position ist um einiges höher. ZedGraph verwendet die Skalierung der 1. Y-Achse, das wird auch spürbar wenn ich die Skallierung der 1. Y-Achse ändere.
Ich könnte die Achse mit der 1. Achse tauschen aber die Reihenfolge soll unverändert bleiben.
Gibt es eine möglichkeit die Skalierung der 4. Achse zu verwenden wärend der Text erstellt wird?
Wie JAck30lena schon mit seinen Antworten verdeutlicht hat, ist es nicht möglich eine eindeutige Antwort zu finden, da es hierfür mehrere Ansichten gibt (und dadurch auch mehrere Antworten).
Ich versuche es mal den Blickwinkel aus jeden Lebenden Organismus zu nehmen:
F1: Jedes Lebewesen muss essen um am Leben zu bleiben. Und da jedes Lebewesen einen Überlebensdrang besitzt, wird es auch essen. (Es gibt natürlich auch Ausnahmen).
F2: Um seine Spezies zu erhalten muss man geboren werden, ob man will oder nicht^^
F3: Ich denk mal ja, es ist wichtig sich und seiner Spezies einen Vorteil gegenüber anderen Arten zu schaffen.
F4: Es müssen Lebewesen sterben damit andere Leben können das ist in der Natur normal,wie heißt doch so schön "Fressen oder Gefressen werden".
F5: Ich denke mal das ist nur ein problem des Menschen, weil wir Rachsüchtig sind.
Es liegt warscheinlich daran, dass wir ein eigenes Befinden für Recht und Unrecht haben.
F6: Ja^^
F7: Ist Ansichtssache, ich finde den Thread sinvoll, denn es zeigt dass man zu algemeinen fragen keine eindeutige Antwort geben kann^^. So ist es auch in der Mathematik^^.
@LaTino Beitrag: Es klingt plausibel
AP1: ...ich kann da LaTino nur zustimmen
AP2 und AP3: @JAck30lena amen
AP4: Denke ich nicht. Der Mensch ist nur so wie wir uns einen Menschen vorstellen.
Und das ist vom Wissen und der Vorstellungskraft des Menschen abhängig
Ich hab:
Board: Asus P5X800 MX
CPU: Intel Celeron D 2,8 Ghz
Graka: ATI Radeon 9600 XT
RAM: 1,5 GB
Die Restlichen Daten bleiben geheim ;3
Zum Proggn Reicht es ^^'
Ich lag total daneben -.-. Ich weis jetz was dein Fehler ist
Point point = new Point(e.ClipRectangle.Right - 10, e.ClipRectangle.Top + (e.ClipRectangle.Height / 2));
is falsch (zumindest für dein fall). Du musst e.ClipRectangle rausnehmen, genauso wie hier
using (LinearGradientBrush brush = new LinearGradientBrush(e.ClipRectangle, startColor, endColor, LinearGradientMode.Vertical))
Und ersetze sie durch Höhe und Breite des jeweiligen Objektes
Schau dir bitte mal die PaintEventArgs an bzw was e.ClipRectangle überhaupt ist.
Dann findest du auch raus warum er dieses "Fehlverhalten" hatte^^
Das toolstrip muss die Unterobjekte zum Neuzeichnen anstoßen.
private void toolStrip1_Paint(object sender, PaintEventArgs e)
{
tspDropDown.Invalidate();
}
Und "this" brauchst du hier nicht unbedingt verwenden.
Das da könnte dir helfen:
http://msdn.microsoft.com/de-de/library/bb979208.aspx
Da ist ein Zeitgeberserve schön beschrieben
Enum's werden hier schön erklärt
MSDN: enum (C#-Referenz)
und das mit get und set nennt man properties (zu deutsch EIGENSCHAFTEN)
MSDN: Eigenschaften (C#-Programmierhandbuch)
Ich vermute ,dass das Problem zwischen Laden und Ausgeben des Bildes zu finden ist. Es könnte sein das ein Fehler in der Datei ist aber dann hätte das Prog schon beim Laden dir die Exception ausgeworfen.
Es ist jedenfalls komisch das alle Daten in der Bitmap nicht funzen und die Exception auslösen. An irgendeiner Stelle geht warscheinlich die Bitmap kaputt.
Also nochmal debuggen und schaun ob diese Fehler wie im Bild von Anfang bis Ende da sind, wenn nicht hätten wir die stelle genau eingegrenzt.
(Bitte korrigiert mich wenn ich falsch liege)
Hm.. das ist wirklich merkwürdig.
Ich sehe da auch leider keinen Fehler in der Methode.
Tritt der Fehler generell auf oder nur wenn Einstellungen eines Bildes geändert wurden und das Vorschaubild aktualisiert werden muss?
Wenn ich dieses zurückgegebene Bild auf der Form anzeigen will (darauf zugreifen will), wird eine Exception geschmissen
Dann schick bitte noch denn Quelltext wo das Bild angezeigt wird.
#endregion
Es ist immer gut Ordnung zu halten :3
Edit: Einen Vergleich mit der Nazi-Zeit zu ziehen halte ich im Übrigen schon für sehr übertrieben und taktlos...
wenn du meinst das die Stasi aus der Zeit ist irrst du dich.
http://de.wikipedia.org/wiki/Ministerium_f%C3%BCr_Staatssicherheit
Ich nutze auch Avira AV und bin sehr zufrieden damit, zusätzlich nutze ich auch den Dienst bei VirusTotal.com wenn ich mir nicht sicher bin ob die Dateien die ich Herundergeladen hab sauber sind. Und ich kontrolliere regelmäßig mit HijackThis, mein PC auf auffällige Programmen.
Ich denk mal mit der Kombination fährt man recht sicher, und es kostet mich nichts.
Als Firewall nehm ich die vom Router, bei den Software Firewall fühle ich mich einfach nicht sicher.
Naja ich glaub meinen Nick brauch ich nicht weiter zu erklären. °(:3)
Und der Avatar is Haruhi Suzumiya aus "Melancoly of Haruhi Suzumiya"
Haruhi rulez!!!! 😁
Sry das ich erst so spät antworte.
Ich hab ein Weg gefunden um noch ein wenig Geschwindigkeit rauszukitzeln 😁
ich habe in der zeile wo _Ani_index erhöht wird
_Ani_index[h, v] += 5;
das geschrieben:
_Ani_index[h, v] += pic.Height / 7;
jetzt ist es zwar keine flüssige Bewegung da aber das fällt nicht weiter auf :3 .
Hallo,
ich habe eine Klasse erstellt mit der eine Klappenanzeigetaffel, wie man sie in Flughäfen kennt, in der Anwendung angezeigt werden kann. es können beliebig viele Klappenanzeigen erstellt werden. Mein Problem ist nun das die Dauer der Umklappanimation recht langsam ist wenn ich viele Klappenanzeigen animiere.
Hier erstmal die funktionsweise:
- Klasse wird erstellt
- der User löst ein Event aus (z.b. Buttonklick) und startet dadurch einen Timer
- wenn der Timer tickt (passiert im intervall von 1) wird überprüft ob die Methode Draw_Animation (ist unten zu finden) TRUE zurückgibt
- mit bool[,] Klappenwechseln erfährt die methode welche Klappen animiert
werden sollen. - wenn Draw_Animation TRUE zurückgibt wird der Timer gestoppt
- danach Invalidate() ,und das was in Draw_Animation gezeichnet wurde kommt auf den Schirm^^
Hier die Variablen und der Konstruktor:
public class Anzeige
{
//--------------------------------------------------------------------------
private int[,] _Ani_index;//Um die Animationen zu Kontrollieren
private int[,] _pic_index_new;//Index nächstes bild zu ermitteln
private int[,] _pic_index_old;//Index derzeitiges bild zu ermitteln
//--------------------------------------------------------------------------
private Bitmap[] _piclist;//Enthält die Bilder die angezeigt werden können
public Bitmap _bitmAhead;//Darauf wird gezeichnet
//--------------------------------------------------------------------------
private Graphics _gCanvasAhead;
//--------------------------------------------------------------------------
public readonly Size _Size;//Stellt die größe der Bilder dar(alle bilder
werden in der gleichen Größe dargestellt)
//--------------------------------------------------------------------------
private Size _Array_Size;//Stellt die anzahl der Klappenanzeigen dar
public Anzeige(Bitmap Bmp_vorne, Bitmap[] Bmp_liste, Size Größe, Size
Arraygröße_Anzeigedigits)
{
ArrayList Piclist = new ArrayList();
//--------------------------------------------------------------------------
_piclist = Bmp_liste;
//--------------------------------------------------------------------------
_bitmAhead = Bmp_vorne;
//--------------------------------------------------------------------------
_gCanvasAhead = Graphics.FromImage(_bitmAhead);
//--------------------------------------------------------------------------
this._Size = Größe;
//--------------------------------------------------------------------------
this._Array_Size = Arraygröße_Anzeigedigits;
//--------------------------------------------------------------------------
_Ani_index = new int[Arraygröße_Anzeigedigits.Width,
Arraygröße_Anzeigedigits.Height];
_pic_index_new = new int[Arraygröße_Anzeigedigits.Width,
Arraygröße_Anzeigedigits.Height];
_pic_index_old = new int[Arraygröße_Anzeigedigits.Width,
Arraygröße_Anzeigedigits.Height];
//--------------------------------------------------------------------------
}
Hier die Methode die für die Animation verantwortlich ist:
public bool Draw_Animation(bool[,] Klappenwechseln)
{
//--------------------------------------------------------------------------
int _count = 0;
int _count_for_bool = 0;
//--------------------------------------------------------------------------
bool[,] _klappen_werden_animiert =
new bool[Klappenwechseln.GetLength(0),
Klappenwechseln.GetLength(1)];
//--Hier werden die Bilder ermittelt die zur Animation gebraucht werden
for (int h = 0; h < Klappenwechseln.GetLength(0); h++)
{
for (int v = 0; v < Klappenwechseln.GetLength(1); v++)
{
if (Klappenwechseln[h, v] == true)
{
_count_for_bool++;
if (_Ani_index[h, v] == 0)
{
Next_Pic(h, v);
}
}
}
}
//----Hier wird Animiert-----------------------
for (int h = 0; h < Klappenwechseln.GetLength(0); h++)
{
for (int v = 0; v < Klappenwechseln.GetLength(1); v++)
{
//----Überprüfen ob die animation zu ende bzw
//----_Ani_index größer als die angegebene
if (_Ani_index[h, v] >= _Size.Height && Klappenwechseln[h, v]
== true && _klappen_werden_animiert[h, v] == false)
{
_Ani_index[h, v] = 0;
_pic_index_old[h, v] = _pic_index_new[h, v];
_count++;
_klappen_werden_animiert[h, v] = true;
}
//--------------------------------------------------------------------------
else if (Klappenwechseln[h, v] == true &&
_klappen_werden_animiert[h, v] == false)
{
//--------------------------------------------------------------------------
_Ani_index[h, v] += 5;
//--------------------------------------------------------------------------
_gCanvasAhead.DrawImage(_piclist[_pic_index_new[h, v]],
new Rectangle(h * _Size.Width, v * _Size.Height,
_Size.Width, _Size.Height / 2),
new Rectangle(0, 0, _piclist[_pic_index_new[h, v]].Width,
_piclist[_pic_index_new[h,v]].Height /2),GraphicsUnit.Pixel);
//--------------------------------------------------------------------------
_gCanvasAhead.DrawImage(_piclist[_pic_index_old[h, v]],
new Rectangle(h * _Size.Width, v * _Size.Height +
_Size.Height / 2,_Size.Width, _Size.Height / 2),
new Rectangle(0, _piclist[_pic_index_old[h, v]].Height /2,
_piclist[_pic_index_old[h, v]].Width,
_piclist[_pic_index_old[h, v]].Height / 2),
GraphicsUnit.Pixel);
//-Hier wird das Umklappen animiert(von oben bis zur mitte
if (_Ani_index[h, v] <= _Size.Height / 2)
{
_gCanvasAhead.DrawImage(_piclist[_pic_index_old[h, v]],
new Rectangle(h * _Size.Width, v * _Size.Height +
_Ani_index[h, v], _Size.Width, _Size.Height / 2 - _Ani_index[h, v]),
new Rectangle(0, 0, _piclist[_pic_index_old[h, v]].Width,
_piclist[_pic_index_old[h, v]].Height / 2), GraphicsUnit.Pixel);
}
//-Hier wird das Umklappen animiert(von mitte bis unten
if (_Ani_index[h, v] >= _Size.Height / 2)
{
_gCanvasAhead.DrawImage(_piclist[_pic_index_new[h, v]],
new Rectangle(h * _Size.Width, v * _Size.Height +
_Size.Height / 2, _Size.Width, _Ani_index[h, v] -
_Size.Height / 2),
new Rectangle(0, _piclist[_pic_index_new[h, v]].Height / 2,
_piclist[_pic_index_new[h, v]].Width,
_piclist[_pic_index_new[h, v]].Height / 2),
GraphicsUnit.Pixel);
}
}
}
}
//--------------------------------------------------------------------------
if (_count == _count_for_bool)
{
return true;
}
//--------------------------------------------------------------------------
else
{
return false;
}
}
Nun ist meine Frage was ich tun könnte um die Animation noch etwas schneller zu bekommen wenn ich viele Klappen gleichzeitig animiere (bei 16 wird es schon leicht langsamer).
Ich bin für Kritiken und Verbesserungswünsche offen^^
Ich habe es abgeändert und es funktioniert:
class Rechteck
{
public int A, B;
public Rechteck()
{
}
public Rechteck(int Seite_A, int Seite_B)
{
this.A=Seite_A;
this.B=Seite_B;
}
public virtual int Volumen()
{
return A * B;
}
}
class Quader:Rechteck
{
private int C;
public Quader(int Seite_A, int Seite_B, int Seite_C)
: base(Seite_A, Seite_B)
{
this.C = Seite_C;
}
public override int Volumen()
{
return A * B * C;
}
}
static void Main(string[] args)
{
Rechteck test1 = new Rechteck(4, 5); ;
Console.WriteLine(test1.Volumen());
test1= new Quader(test1.A,test1.B,6);
Console.WriteLine(test1.Volumen());
}
Danke für eure schnelle hilfe^^
Ich habe ein problem mit den Klassen. Ich möchte, nachdem ich ein Objekt mit den Eigenschaften der Hauptklasse erstellt habe, das Objekt der Unterklasse zuweisen. Danach sollte eine Methode der Unterklasse ausgeführt werden.
So sieht der Code aus:
class Rechteck
{
public int A, B;
public Rechteck()
{
}
public Rechteck(int Seite_A, int Seite_B)
{
this.A=Seite_A;
this.B=Seite_B;
}
public int Fläche()
{
return A * B;
}
}
class Quader:Rechteck
{
private int C;
public Quader(int Seite_C)
{
this.C = Seite_C;
}
public int Volumen()
{
return A * B * C;
}
}
static void Main(string[] args)
{
Rechteck test1 = new Rechteck(4, 5);
Console.WriteLine(test1.Fläche());
test1 = new Quader(5);
}
Nach "test1 = new Quader(5);" sollte die Methode "Volumen()" aufgerufen werden, wenn ich "test1." schreibe kommt die kleine Liste der möglichen Methoden etc. , aber es wird nicht die methode "Volumen" angezeigt. Es wird auch nicht die Variable "C" angezeigt.
Jetzt weis ich aber nicht was ich ändern muss.
Kann jemand mir bei dem Problem helfen?