Forenbeiträge von Kileak Ingesamt 62 Beiträge
Vielleicht versteh ich dich ja einfach nur falsch, aber:
private ?
Von einer 32Bit-Anwendung auf den 64Bit-Teil zuzugreifen ist in meinen Augen zwar nicht die feine englische Art, aber wenn Du es unbedingt brauchst kannst Du es auch über die WinApi-Version RegOpenKeyEx machen...
pinvoke.net: regopenkeyex (advapi32)
Da steht alles was Du brauchst (weiter unten ist sogar direkt ein Beispiel für deinen Frage)
Schon, der Presenter sollte den Aufruf einfach ans Model durchreichen.
Die Methode AddOrder kommt ins Model und der Presenter, wie auch der Command rufen die Methode des Models auf (Der Presenter kann auf das Hinzufügen eines Orders im Model ggf. durch ein entsprechendes Event reagieren).
Mit einer rekursiven Methode.
Hast Du überhaupt "Break, when an exception is Thrown" aktiviert?
-> Debug -> Exceptions
Bei "Common Language Runtime Exceptions" einen Haken bei "Thrown" setzen und nochmal probieren.
Da du Selected.Columns ja schon hast, geh ich mal davon aus das du das Selektieren der Spalte ja doch schon hast, und jetzt nur noch an die zugehörigen Zellen-Inhalte kommen willst.
Bin mir grad nicht sicher, ob es nicht eine einfachere Möglichkeit gibt, direkt an die ausgewählten Zellen zu kommen, aber zur Not kommst Du auch nur über den ColumnHeader an die Inhalte, in dem Du über die Rows iterierst und direkt auf die Zelle zugreifst.
(Ungetestet, da grad kein Infragistics zur Hand)
foreach (ColumnHeader colHeader in gridX.Selected.Columns) {
foreach(UltraGridRow row in gridX.Rows) {
value = row[colHeader.Column]
}
}
Setz AutoClose auf true, und fang stattdessen das Closing-Event ab
private void contextMenuStrip1_Closing(object sender, ToolStripDropDownClosingEventArgs e)
{
if (e.CloseReason == ToolStripDropDownCloseReason.ItemClicked)
e.Cancel = true;
}
Das kommt mir zu einfach vor 😉
public delegate T MethodDel<T, T1>(T1 paramArgs);
public class MethodList<T, T1>
{
private static Dictionary<string, MethodDel<T, T1>> Methods { get; set; }
public MethodList()
{
Methods = new Dictionary<string, MethodDel<T, T1>>();
}
public void Register(string methodKey, MethodDel<T, T1> method)
{
if (!Methods.ContainsKey(methodKey))
Methods.Add(methodKey, method);
}
public MethodDel<T, T1> this[string methodKey]
{
get
{
if (Methods.ContainsKey(methodKey))
return Methods[methodKey];
return ((T1 b) => { Trace.WriteLine(string.Format("Method not implemented ({0})", methodKey)); return default(T); });
}
}
}
public static class MethodFactory<T, T1>
{
public static MethodList<T, T1> Methods { get; private set; }
static MethodFactory()
{
Methods = new MethodList<T, T1>();
}
public static void Register(string methodKey, MethodDel<T, T1> method)
{
Methods.Register(methodKey, method);
}
}
Da kann man ganz "einfach" seine Methoden registrieren
public int Method1(int param)
{
Console.WriteLine("Method1");
return 0;
}
public int Method2(int param)
{
Console.WriteLine("Method2");
return 0;
}
...
MethodFactory<int,int>.Register("a", Method1);
MethodFactory<int,int>.Register("b", Method2);
MethodFactory<int,int>.Register("c", testClass.Method3);
und das ganze dann über
string eingabe = Console.ReadLine();
int param = 10;
MethodFactory<int, int>.Methods[eingabe](param);
aufrufen. Über den Sinn und Unsinn lässt sich hierbei natürlich streiten, aber zumindest kommen kaum if's drin vor 😉
Ich nehme dafür meist eine generische EventArgs-Klasse, mit der man auf die Schnelle beliebige Argumente übergeben kann
public class EventArgs<T> : EventArgs
{
public T Data { get; set; }
public EventArgs(T data)
{
Data = data;
}
}
Entsprechender EventHandler dazu sähe dann so aus
public event EventHandler<EventArgs<string>> TestEvent
...
if (TestEvent != null)
{
TestEvent(this, new EventArgs<string>("Test"));
}
Im Ergeignis an sich, kannst Du dann einfach über Data drauf zugreifen
void Form1_TestEvent(object sender, EventArgs<string> e)
{
MessageBox.Show(e.Data);
}
Wenn Du mehrere Argumente brauchst, kannst Du sie in eine ensptr. Klasse packen und die genauso übergeben.
Über den sender des Events kommst du an das entspr. ToolStripItem das den Dateinamen enthält (bei deinem Beispielt kämst Du so z.B. über das Text-Property an den Dateinamen)
ToolStripItem item = fileToolStripMenuItem.DropDownItems.Add("Dateiname");
item.Click += new EventHandler(item_Click);
}
void item_Click(object sender, EventArgs e)
{
ToolStripItem srcItem = sender as ToolStripItem;
if (srcItem != null)
{
MessageBox.Show(srcItem.Text);
}
}
Ohne FusionLog zu kennen, ist dein Versuch den EnableLog-Schlüssel anzulegen wohl etwas schiefgegangen.
Lösch den Eintrag, danach Rechtsklick auf Fusion->"Neu"->"DWORD-Wert". Nenn den Eintrag EnableLog und setz den Wert auf 1.
Dasselbe mit dem LogResourceBinds-Eintrag.
Kurz: Überschreibe die ToString-Methode in der mitarbeiter-Klasse...
Fürs Verschieben zwischen den Trees kannst Du mit DoDragDrop eine Drag&Drop-Operation anfangen und über die DragOver-, DragDrop-Events der Trees feststellen, wenn Items reingezogen wurden.
Meinst Du mit 'schön aussehen' die Oberfläche oder den Code dazu?
Um alle Controls einfach zu deaktivieren/aktivieren einfach ein Panel auf die Form und die entspr. Controls reingezogen, und im Code lediglich das Panel enablen/disablen.
Wenns dir um das Aussehen der Oberfläche geht: Der Benutzer ist sicher froh darüber, am 'Disabled'-Aussehen der Buttons, Textboxen, etc. direkt zu wissen, dass er diese nicht ändern kann.
Solang M233 lokal deklariert bleibt, wird sie beim M233.Kill() auch nie definiert sein...
Eine andere Möglichkeit wäre auch eine Wrapper-Methode in der Basisklasse, die statt deiner abstrakten Methode aufgerufen wird. Diese ruft entspr. die implementierte Methode auf und feuert danach das Event.
So muss dein 'Implementierer' nichts von dem Event wissen und nur die entspr. abstrakte Methode überschreiben.
Grad so hingekritzelt sähe das so aus
public class BaseClassXYZ {
protected abstract xyzMethode();
public void Methode() {
xyzMethode();
FireEvent();
}
}
Entspr. müsste dann nur die xyzMethode überschrieben werden...
Da Du die writeLog-Methode für jedes Item extra aufrufst, hat dein Begin/EndUpdate so ziemlich gar keinen Effekt, da Du letztenendes ja doch immer nur ein Item hinzufügst. Der Effekt ist also derselbe als wenn Du es ganz weglassen würdest.
Eine kleine Verbesserung wäre vielleicht zumindest eine Liste, in der dein Thread die Items hinzufügen kann, und Du aus dieser Liste dann alle x Items deine ListView aktualisierst (bzw. sobald dein Thread fertig ist, alle restlichen Items).
Benutz immer dasselbe Tooltip-Objekt und erstelle nicht für jeden Hover ein neues
ToolTip testTool = new ToolTip();
private void listView1_ItemMouseHover(object sender, ListViewItemMouseHoverEventArgs e)
{
testTool.Hide(listView1);
testTool.Show(e.Item.Text, listView1, 3000);
}
Dann sollte es wie erwartet funktionieren.
Ohne jetzt deinen ganzen Ansatz komplett nachvollzogen zu haben, scheinen mir da doch einige Ungereimtheiten drin zu sein.
Zum einen benutzt du eine lokale Variable l sowie l als Index für die for-schleife. Abgesehen davon das sich der Code so nicht kompilieren lässt, ist so auch nicht ganz nachzuvollziehen welches l wann genutzt werden soll.
Soll die Matrix über das gesamte 2-dimensionale Array laufen, sind wohl auch zwei verschachtelte for-schleifen angebracht, im Moment durchläufst Du ja nur einmal die Breite deines Arrays (wobei Du dann auch noch in jedem Schritt nur einen Wert deiner Matrix hinzurechnest).
Falls ich dich nicht ganz missverstanden habe, möchtest Du z.B. eine 3x3 Matrix von oben links über alle Spalten/Zeilen wandern lassen und jeweils den Mittelwert der 9 Werte berechnen.
Das könnte dann so in diese Richtung aussehen.
// zweidimensionales Array durchlaufen
for (int y=0; y<hoehe-matrixHoehe; ++y) {
for (int x=0; x<breite-matrixBreite; ++x) {
// Die Matrix an sich durchlaufen
for (int ym=0; ym<matrixHoehe; ++ym) {
for (int xm=0; xm<matrixBreite; ++xm) {
// Wert aus dem Array
zweiDim[x+xm, y+ym]
}
}
}
}
}
So würdest Du zumindest schon mal das gesamte Array durchlaufen und die Werte "über denen deine Matrix momentan liegt" bekommen.
Über _Screen _ kannst Du dir auch die genauen Positionen des zweiten Bildschirms holen (und bist so unabhängig davon ob er "links" oder "rechts" vom primären ist)
So könntest Du z.B. eine Form auf dem sekundären über den gesamten Bildschirm anzeigen lassen
if (Screen.AllScreens != null && Screen.AllScreens.Length > 1)
{
FormBorderStyle = FormBorderStyle.None;
Location = new Point(Screen.AllScreens[1].Bounds.X, Screen.AllScreens[1].Bounds.Y);
Size = new Size(Screen.AllScreens[1].Bounds.Width, Screen.AllScreens[1].Bounds.Height);
}
GetFiles liefert dir ein Array zurück, das Du als einzelnes Objekt deiner Fileliste hinzufügst, daher ist deren Grösse 1.
Wenn Du dir dieses eine Element ansiehst, wirst Du merken das es wiederum ein Array mit den gesuchten Dateinamen ist (string[]).
Du könntest es also entweder als
string[] fileList = Directory.GetFiles(@"C:\", "*.txt");
lösen. Dann hast Du direkt das richtige Array mit den Dateinamen, oder wenn Du es unbedingt als ArrayList möchtest als
FileListe.AddRange (Directory.GetFiles(@"C:\", "*.txt"));
Dann werden die Elemente einzeln deiner Liste hinzugefügt.
Da Du ja aber eh dann z.B. die Erstellungsdaten ermitteln willst, würde es sich wohl anbieten direkt über FileInfo/DirectoryInfo zu gehen, da Du dann nicht nur die Dateinamen sondern auch direkt alle Dateiinformationen gesammelt zur Verfügung stehen hast.
Was spricht dagegen das Menü einfach bei
Control.MousePosition
anzuzeigen, anstatt die Position der Maus extra nochmal zu berechnen (zumindest sieht dein Bild danach aus, dass Du das Menü doch an der Mausposition anzeigen möchtest)?
RowIndex ist, wie der Name vermuten lässt, der Index der Zeile, nicht der Spalte 😉
An die Spaltenüberschrift kommst Du z.B. mit
dataGridView.Columns[e.ColumnIndex].HeaderText
ähnlich also wie beim Visual Studio Projektmappenexplorer der oberste Node, der die Solution angibt.
Genau dieses Verhalten erhält man mit 'ShowRootLines=false'
treeView.ShowRootLines = false;
Damit hat dein Hauptnode kein + aber die Unterknoten noch. Sollen diese auch kein '+' mehr davor haben
treeView.ShowPlusMinus = false;
Dann hast Du wohl deinem Control vorm Hinzufügen zu deinem Fenster keinen korrekten Namen gegeben, über den Du es später in der Control-Collection finden kannst.
Label testControl = new Label();
testControl.Text = "Woohoo";
testControl.Name = "testName";
Controls.Add(testControl);
Control[] controls = Controls.Find("testName", true);
if (controls != null && controls.Length > 0)
{
controls[0].Text = "Test yay";
}
else
{
MessageBox.Show("Control not found");
}
Wenn jeder Name "wirklich" nur einmal vorkommen dürfte (was grade bei Namen wie Müller&Co doch sehr fraglich ist), könntest Du dafür einen Hashtable nehmen.
Da würde sich dann auch wie von dir gewünscht mit
HashtableName["Maier"]
drauf zugreifen lassen. Da es ja aber in einem Telefonbuch meist nicht nur einen Eintrag zu einem Nachnamen gibt, könntest Du den Nachnamen auch einfach als Key benuzen, und dort eine Liste mit Personen einfügen, die den Namen "Maier" enthalten. So könntest Du über den Nachnamen auf alle Personen zugreifen, die denselben Nachnamen haben (besser wäre aber wohl doch ein eindeutiger Key für den Hashtable zu nehmen).
MSDN: Math.Round(double)
Rückgabewert
Der der Ganzzahl am nächsten liegende a. Wenn a genau in der Mitte zwischen zwei Ganzzahlen liegt, von denen eine gerade und die andere ungerade ist, wird die gerade Zahl zurückgegeben.Hinweise
Das Verhalten dieser Methode entspricht dem Standard IEEE 754, Abschnitt 4. Diese Art der Rundung wird zuweilen als Rundung auf den nächsten Wert bzw. unverzerrte Rundung (Banker's Rounding) bezeichnet.
Danke für die Antwort.
Das hier funktioniert leider nicht so wirklich.
bindingSource.DataSource = listWarenkorb; lbWarenkorb.DataSource = bindingSource;
Na, da hab ichs ja doch mal ausprobiert und es macht eigtl genau das was du brauchst.
Hier noch mal ein kleines Beispiel. Die BindingSource ist btw. mit dem Designer einfach draufgezogen (System.Windows.Forms.BindingSource), vllt hast Du da die falsche genommen.
Von der Funktionalität kommts dem zuweisen von null und darauf der alten Liste zwar gleich, aber für das Binden von Daten an Controls finde ich BindingSources passender (und sie bieten im nachhinein auch noch etwas zusätzliche Funktionalität)
public partial class Form1 : Form
{
List<TestEntry> testList;
public Form1()
{
InitializeComponent();
testList = new List<TestEntry>();
bindingSource.DataSource = testList;
listBox1.DataSource = bindingSource;
}
private void button1_Click(object sender, EventArgs e)
{
testList.Add(new TestEntry("newentry", 0));
bindingSource.ResetBindings(false);
}
}
public class TestEntry
{
string text;
long value;
public TestEntry(string txt, long val)
{
text = txt;
value = val;
}
public override string ToString()
{
return text;
}
}
Nicht ausprobiert, aber mit einer BindingSource dazwischen sollte das funktionieren.
bindingSource.DataSource = listWarenkorb;
lbWarenkorb.DataSource = bindingSource;
Bei einer Änderung der Liste solltest Du mit
bindingSource.ResetBindings(false);
eine Aktualisierung bekommen.
Schön ist anders, aber es funktioniert (Copy&Paste).
Frage ist da allerdings auch, wie Du deinen Viewport aufsetzt.
So sähe der Resize in meinem Test aus.
private void glControl_Resize(object sender, EventArgs e)
{
int height = glControl.Height;
int width = glControl.Width;
if (height == 0)
height = 1;
double ratio = (double)width / (double)height;
Gl.glViewport(0, 0, width, height);
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glLoadIdentity();
Glu.gluPerspective(45.0, ratio, 0.1, -100.0);
Gl.glMatrixMode(Gl.GL_MODELVIEW);
Gl.glLoadIdentity();
}
Damit Du deine Szene damit auch zu Gesicht bekommst solltest Du noch ein
Gl.glTranslatef(0.0f, 0.0f, -50.0f);
vor deine Rotation setzen, da Du deinen Viewport anscheinend mit glOrtho aufgebaut hast. Sollte dich aber zumindest schon mal soweit bringen das deine Hit-Tests funktionieren.
Hab das mal schnell zusammenkopiert, und die Hits werden eigtl. richtig erkannt, vielleicht übergibst Du da auch nur die falschen Maus-Koordinaten.
Init
Gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Black Background
Gl.glClearDepth(1.0f); // Depth Buffer Setup
Gl.glDepthFunc(Gl.GL_LEQUAL); // Type Of Depth Testing
Gl.glEnable(Gl.GL_DEPTH_TEST); // Enable Depth Testing
Selektion
private void Selection(int mouse_x, int mouse_y)
{
uint[] buffer = new uint[512];
int[] viewport = new int[4];
int hits = 0;
Gl.glGetIntegerv(Gl.GL_VIEWPORT, viewport);
Gl.glSelectBuffer(512, buffer);
// Puts OpenGL In Selection Mode. Nothing Will Be Drawn. Object ID's and Extents Are Stored In The Buffer.
Gl.glRenderMode(Gl.GL_SELECT);
Gl.glInitNames();
Gl.glPushName(0);
Gl.glMatrixMode(Gl.GL_PROJECTION); // Selects The Projection Matrix
Gl.glPushMatrix(); // Push The Projection Matrix
Gl.glLoadIdentity(); // Resets The Matrix
// This Creates A Matrix That Will Zoom Up To A Small Portion Of The Screen, Where The Mouse Is.
Glu.gluPickMatrix((double)mouse_x, (double)(viewport[3] - mouse_y), 1.0f, 1.0f, viewport);
// Apply The Perspective Matrix
Glu.gluPerspective(45.0f, (float)(viewport[2] - viewport[0]) / (float)(viewport[3] - viewport[1]), 0.1f, 100.0f);
Gl.glMatrixMode(Gl.GL_MODELVIEW); // Select The Modelview Matrix
DrawTargets(); // Render The Targets To The Selection Buffer
Gl.glMatrixMode(Gl.GL_PROJECTION); // Select The Projection Matrix
Gl.glPopMatrix(); // Pop The Projection Matrix
Gl.glMatrixMode(Gl.GL_MODELVIEW); // Select The Modelview Matrix
hits = Gl.glRenderMode(Gl.GL_RENDER); // Switch To Render Mode, Find Out How Many
if (hits > 0) // If There Were More Than 0 Hits
{
int choose = (int)buffer[3]; // Make Our Selection The First Object
int depth = (int)buffer[1]; // Store How Far Away It Is
for (int loop = 1; loop < hits; loop++) // Loop Through All The Detected Hits
{
// If This Object Is Closer To Us Than The One We Have Selected
if (buffer[loop * 4 + 1] < depth)
{
choose = (int)buffer[loop * 4 + 3]; // Select The Closer Object
depth = (int)buffer[loop * 4 + 1]; // Store How Far Away It Is
}
}
}
else
{
MessageBox.Show("No hits");
}
}
Zeichnen
private void DrawTargets()
{
Glu.GLUquadric quadric = Glu.gluNewQuadric();
Gl.glLoadIdentity();
Gl.glLoadName(21);
Gl.glPushMatrix();
Gl.glTranslatef(-3.0f, -2.0f, -15.0f);
Glu.gluQuadricDrawStyle(quadric, Glu.GLU_FILL);
Glu.gluQuadricNormals(quadric, Glu.GLU_SMOOTH);
Glu.gluSphere(quadric, 2.0, 40, 40);
Gl.glPopMatrix();
Gl.glLoadName(22);
Gl.glPushMatrix();
Gl.glTranslatef(3.0f, 1.0f, -20.0f);
Glu.gluQuadricDrawStyle(quadric, Glu.GLU_FILL);
Glu.gluQuadricNormals(quadric, Glu.GLU_SMOOTH);
Glu.gluSphere(quadric, 3.0, 40, 40);
Gl.glPopMatrix();
Glu.gluDeleteQuadric(quadric);
}
Auswahl
private void glControl_MouseClick(object sender, MouseEventArgs e)
{
Selection(e.X, e.Y);
}
Ja auf Picking würde das ganze hinauslaufen. Einen Einstieg dazu findest Du (wie zu vielen anderen Themen OpenGL betreffend) bei Nehe
Picking, Alpha Blending, Alpha Testing, Sorting:
Zu deinem Rotationsproblem würde sich dabei auch gleich folgendes anbieten
Wenn das dann Funktioniert, möchte ich mit der Maus die Szene drehen können (Bei gedrückter Rechter maustaste). Wie realisiere ich, das die Szene mit der Maus rotiert?
Eine einfache Möglichkeit dafür wäre z.B. immer die letzte Mausposition beim MouseDown-Event zwischenzuspeichern und dann die Differenz in X-/Y-Richtung zur aktuellen Position zu berechnen und dies entsprechend auf xRot und yRot umzurechnen. Noch ein Invalidate dazu und deine Szene dreht sich.
Ich habe in meine Szene mehrere Kugeln gezeichnet.
Ist es möglich mit der linken Maustaste auf die Kugel zu llicken und dann ein event auszuführen (unabhängig von der Ansicht)?
Wenn ja wie?
So etwas ist zwar schon möglich, müsste aber selbst implementiert werden. OpenGL wird mit dem TAO Framework wohl auch nur gewrapped und ist von sich aus nicht "objektorientiert".
Es ist auch keine gute Idee, das Quadric-Objekt nach jeder Benutzung zu löschen und es dann trotzdem weiterzuverwenden.
Erzeuge das Quadric-Objekt zu Beginn der Szene mit gluNewQuadric und lösch es erst zum Ende deiner Render-Methode (oder nimms gleich ganz raus in eine Init/Shut-Methode, es sollte glaube keinen Grund geben es für jeden Zeichnenvorgang neu zu erzeugen)
Hallo Max,
glRotatef dient nicht dazu die Szene "nachträglich" zu drehen, sondern wirkt sich nur auf die nachfolgenden Aktionen aus.
Wenn ich dich richtig verstehe, möchtest Du aber erreichen, das Du über den Button einen bestimmten Winkel setzen oder ändern kannst und die Szene entsprechend um diesen Winkel gedreht wird.
Dazu müsstest Du die Rotation entsprechend vor dem Zeichnen der eigentlichen Szene durchführen. Ich habe bisher noch nicht mit dem TAO-Framework gearbeitet, aber es sollte vom Ablauf dort ähnlich funktionieren.
public void DrawScene()
{
glLoadIdentity();
glTranslatef (0.0f, 0.0f, -5.0f);
glRotatef (xRot, 1.0f, 0.0f, 0.0f);
glRotatef (yRot, 0.0f, 1.0f, 0.0f);
glRotatef (zRot, 0.0f, 0.0f, 1.0f);
// Szene zeichnen
}
public void button1_click(....)
{
xRot += 10.0f;
// entsprechende Funktion um das OpenGL-Control zum Neuzeichnen zu bringen
GLControl.Invalidate();
}
Das ist so natürlich kein lauffähiger Code, aber sollte den Vorgang etwas veranschaulichen.
Durch das Remove änderst Du auch immer noch das Feld. Das Feld wird kleiner, der Index jedoch erhöht (dadurch wird immer ein Control übersprungen).
Eine Möglichkeit wäre nach dem Remove den Index zu dekrementieren oder die Schleife einfach rückwärts durchlaufen zu lassen.
for (int i = this.Controls.Count-1; i>=0; i--)
{
if (this.Controls[i] is TextBox)
{
this.Controls.Remove(this.Controls[i]);
}
}
Denke das sollte über das Erzeugen eines entsprechenden ListViewItems gehen
listView.Items.Add(new ListViewItem(new string[]{"Spalte1 Inhalt", "Spalte2 Inhalt"}));
Ihr redet da wohl auch nur etwas aneinander vorbei 😉
Wie das Koordinatensystem aufgebaut ist, ist reine Definitionssache, und Trekki wollte wohl ein nach oben wachsendes System.
// Fensterkoordinaten
int nX = MousePosition.X - Left;
int nY = MousePosition.Y - Top;
Dadurch werden die Koordinaten so umgerechnet, dass die obere linke Ecke des Fensters 0/0 ist und nach unten hin wächst.
Das kann aber wenn wie hier benötigt, in Y-Richtung einfach umgedreht werden, und schon wächst das Koordinatensystem nach oben.
// Umgerechnete Koordinaten
int centerX = nX - (Width / 2);
int centerY = (Height / 2) - nY;
// oder vielleicht verständlicher
int centerY = (nY-Height/2) * (-1);
Also aus dem Stehgreif würde ich die Koordinaten erstmal in Fensterkoordinaten umrechnen und sie dann relativ zur Mitte des Fensters betrachten.
// Fensterkoordinaten
int nX = MousePosition.X - Left;
int nY = MousePosition.Y - Top;
// Umgerechnete Koordinaten
int centerX = nX - (Width / 2);
int centerY = (Height / 2) - nY;
So ungefähr könnte das aussehen (allerdings bezieht sich dann der Mittelpunkt auf das gesamte Fenster inklusive Rahmen)
Hast Du dein Projekt nach dem "mit Button bestücken" auch nochmal durchcompiliert?
Sonst bekommst du im Designer auch nur die alte Version deines UserControls angezeigt.
Versuchs mal mit einem
Thread.Sleep(100)
in deiner Endlosschleife, das sollte zumindest der 100% Prozessorauslastung entgegenwirken.
aaaaahhhhh nun sehe ich etwas mehr durch! Danke!
Nein, anscheinend leider nicht 😉
Einfach nur den vorhandenen Code per Copy&Paste in sein Projekt einfügen, und dann an irgendwelchen Stellen Stichwörter, die einem genannt wurden einfügen, ohne überhaupt zu verstehen was der entsprechende Code macht ist seltenst von Erfolg gekrönt.
Ausführlicher als JAck30lena es bereits getan hat, kann man das wohl nicht mehr ausführen. Vielleicht sollte es bei so einer Erklärung auch nicht zuviel verlangt sein, mal selber in der MSDN nachzuschlagen, was der Befehl int.Parse() überhaupt macht und wieso deine zig ToString()-Try&Error-Einfüge-Variationen keinen Sinn machen.
Hast Du dir den Artikel auch durchgelesen, bzw. nochmal betrachtet was Du aus dem Code gemacht hast? 😉
Du registriert die Windows-Hooks in deinem MouseDown-Event (welches ohne die Windows-Hooks gar nicht ausgelöst werden kann)...
public class ClickableTextBox : TextBox
{
public delegate void onClick(object sender, EventArgs e);
public event onClick Clicked;
public ClickableTextBox()
{
WndProcHooker.HookWndProc(this,
new WndProcHooker.WndProcCallback(this.WM_LButtonDown_Handler),
Win32.WM_LBUTTONDOWN);
WndProcHooker.HookWndProc(this,
new WndProcHooker.WndProcCallback(this.WM_LButtonUp_Handler),
Win32.WM_LBUTTONUP);
}
#region OnClick
int WM_Notify_Handler(IntPtr hwnd, uint msg, uint wParam, int lParam, ref bool handled)
{
Win32.NMHDR nmHdr = new Win32.NMHDR();
System.Runtime.InteropServices.Marshal.PtrToStructure((IntPtr)lParam, nmHdr);
switch (nmHdr.code)
{
case Win32.WM_LBUTTONDOWN:
case Win32.WM_LBUTTONUP:
// get the cursor coordinates on the client
Point msgPos = Win32.LParamToPoint((int)Win32.GetMessagePos());
msgPos = this.PointToClient(msgPos);
RaiseMouseClickEvent(MouseButtons.Left, msgPos);
break;
default:
break;
}
return 0;
}
public void OnMouseClick(MouseEventArgs e)
{
this.OnClick(new EventArgs());
}
protected override void OnClick(EventArgs e)
{
base.OnClick(e);
}
public void RaiseMouseClickEvent(MouseButtons button, Point coords)
{
MouseEventArgs e = new MouseEventArgs(button, 1, coords.X, coords.Y, 0);
OnMouseClick(e);
}
int WM_LButtonDown_Handler(IntPtr hwnd, uint msg, uint wParam, int lParam, ref bool handled)
{
this.Capture = true;
this.Focus();
handled = true;
return 0;
}
int WM_LButtonUp_Handler(IntPtr hwnd, uint msg, uint wParam, int lParam, ref bool handled)
{
this.Capture = false;
// Hier wird der Clicked-Event ausgeführt
Clicked(this, null);
handled = true;
return 0;
}
#endregion
}
Damit hast Du ein Control, das Du dir auf die Form ziehen kannst und ein Clicked-Event in das Du dann deine Farbänderungen packen kannst
clickableTextBox1.Clicked += new ClickableTextBox.onClick(clickableTextBox1_Clicked);
void clickableTextBox1_Clicked(object sender, EventArgs e)
{
clickableTextBox1.BackColor = Color.Azure;
}
Getestet und funktioniert.
Wie wär's denn mit
public class BaseClass
{
public string Name { get; set; }
public BaseClass Parent { get; set; }
...
}
Wenn du an spezifische Properties der Unterklassen über Parent willst, müsstest du diese halt entsprechend casten, aber da der Typ in der Unterklasse ja eh bekannt sein muss, sollte das doch kein Problem sein.
Bisher noch nicht mit dem CF gearbeitet, allerdings wird es in der MSDN unter OnMouseClick und OnMouseDoubleClick nicht unter den unterstützten Frameworks aufgeführt.
Der OnMouseDown-Event hingegen sollte auch unter CF2.0 funktionieren.
Hmmm das sieht wohl nach einem Missverständnis aus. Wenn ich das richtig sehe, willst du nicht die Kommentare als ganzes entfernen, sondern nur die einleitenden Zeichen.
Also wenn deine Textdatei wirklich immer so aufgebaut ist, das die Kommentarzeichen am Anfang stehen könntest Du diese ganz simpel entfernen (mitsamt den folgenden Leerzeichen)
char[] trimChars = new char[] { '/', ' ', '\t'};
s = s.Trim(trimChars);
Dies funktioniert aber auch nur für den Fall, das die Zeilen nur die Kommentare enthalten, und diese nicht noch z.B. hinter vorhandenem Code stehen können, da sollte man dann doch über RegEx nachdenken (da würde es aber wohl auch nicht viel Sinn machen, einfach nur die Kommentarzeichen zu entfernen).
Seltsam, grade sogar mal ausprobiert und das Control wird in dieser Form entsprechend der Events eingefärbt.
Das Problem "müsste" also irgendwo ausserhalb deines Controls zu suchen sein.
Du definierst ja lediglich ein eigenes Event, auf das eine Anwendung reagieren könnte, das aber nirgendwo ausgelöst wird.
Was soll dein Event eigentlich darstellen, bzw. wodurch soll es ausgelöst werden?
Ein Beispiel, wie sich die Hintergrundfarbe z.B. bei einem Click auf die Textbox ändern würde wäre
public class ClickableTextBox : TextBox
{
public ClickableTextBox()
{
this.BackColor = Color.Red;
}
protected override void OnMouseClick(MouseEventArgs e)
{
this.BackColor = Color.Yellow;
base.OnMouseClick(e);
}
}
Entsprechend kannst Du natürlich auch die anderen vorhandenen Mouse-Events der Textbox überschreiben bzw. erweitern.