Forenbeiträge von Andreas.May Ingesamt 915 Beiträge
Habe noch bei deinen Beitrag etwas ergänzt 🙂
Prima Beitrag 👍
Hätte mir vor einigen Wochen eine menge Arbeit erspaart 🙂
#region NCHITTEST enum
/// <summary>
/// Location of cursor hot spot returnet in WM_NCHITTEST.
/// </summary>
public enum NCHITTEST
{
/// <summary>
/// On the screen background or on a dividing line between windows
/// (same as HTNOWHERE, except that the DefWindowProc function produces a system beep to indicate an error).
/// </summary>
HTERROR = (-2),
/// <summary>
/// In a window currently covered by another window in the same thread
/// (the message will be sent to underlying windows in the same thread until one of them returns a code that is not HTTRANSPARENT).
/// </summary>
HTTRANSPARENT = (-1),
/// <summary>
/// On the screen background or on a dividing line between windows.
/// </summary>
HTNOWHERE = 0,
/// <summary>In a client area.</summary>
HTCLIENT = 1,
/// <summary>In a title bar.</summary>
HTCAPTION = 2,
/// <summary>In a window menu or in a Close button in a child window.</summary>
HTSYSMENU = 3,
/// <summary>In a size box (same as HTSIZE).</summary>
HTGROWBOX = 4,
/// <summary>In a menu.</summary>
HTMENU = 5,
/// <summary>In a horizontal scroll bar.</summary>
HTHSCROLL = 6,
/// <summary>In the vertical scroll bar.</summary>
HTVSCROLL = 7,
/// <summary>In a Minimize button.</summary>
HTMINBUTTON = 8,
/// <summary>In a Maximize button.</summary>
HTMAXBUTTON = 9,
/// <summary>In the left border of a resizable window
/// (the user can click the mouse to resize the window horizontally).</summary>
HTLEFT = 10,
/// <summary>
/// In the right border of a resizable window
/// (the user can click the mouse to resize the window horizontally).
/// </summary>
HTRIGHT = 11,
/// <summary>In the upper-horizontal border of a window.</summary>
HTTOP = 12,
/// <summary>In the upper-left corner of a window border.</summary>
HTTOPLEFT = 13,
/// <summary>In the upper-right corner of a window border.</summary>
HTTOPRIGHT = 14,
/// <summary> In the lower-horizontal border of a resizable window
/// (the user can click the mouse to resize the window vertically).</summary>
HTBOTTOM = 15,
/// <summary>In the lower-left corner of a border of a resizable window
/// (the user can click the mouse to resize the window diagonally).</summary>
HTBOTTOMLEFT = 16,
/// <summary> In the lower-right corner of a border of a resizable window
/// (the user can click the mouse to resize the window diagonally).</summary>
HTBOTTOMRIGHT = 17,
/// <summary>In the border of a window that does not have a sizing border.</summary>
HTBORDER = 18,
HTOBJECT = 19,
/// <summary>In a Close button.</summary>
HTCLOSE = 20,
/// <summary>In a Help button.</summary>
HTHELP = 21,
}
Was man noch ergänzen könnte ist das man beim eigenen gezeichneten "Icon" noch NCHITTEST.HTMENU über SendMessage mitgeben kann um die Systemmenü Eigenschaften zu realisieren.
Wer noch das Systemmenu etwas erweitern möchte kann das hiermit:
Klasse:
public class CSystemMenu
{
[DllImport("USER32", EntryPoint = "GetSystemMenu", SetLastError = true,
CharSet = CharSet.Unicode, ExactSpelling = true,
CallingConvention = CallingConvention.Winapi)]
private static extern IntPtr apiGetSystemMenu(IntPtr WindowHandle,
int bReset);
[DllImport("USER32", EntryPoint = "AppendMenuW", SetLastError = true,
CharSet = CharSet.Unicode, ExactSpelling = true,
CallingConvention = CallingConvention.Winapi)]
private static extern int apiAppendMenu(IntPtr MenuHandle, int Flags,
int NewID, String Item);
[DllImport("USER32", EntryPoint = "InsertMenuW", SetLastError = true,
CharSet = CharSet.Unicode, ExactSpelling = true,
CallingConvention = CallingConvention.Winapi)]
private static extern int apiInsertMenu(IntPtr hMenu, int Position,
int Flags, int NewId,
String Item);
// Remove menu
[DllImport("user32.dll")]
private static extern bool RemoveMenu(IntPtr hMenu, int uPosition, int uFlags);
public CSystemMenu()
{
}
private IntPtr m_SysMenu = IntPtr.Zero; // Handle to the System Menu
public CSystemMenu()
{
}
/// <summary>
/// Remove an menu entry
/// </summary>
/// <param name="Pos"></param>
/// <param name="Flags"></param>
/// <returns></returns>
public bool RemoveMenu(int Pos, ItemFlags Flag)
{
return RemoveMenu(m_SysMenu, Pos, (int) Flag);
}
public bool InsertSeparator(int Pos)
{
return (InsertMenu(Pos, ItemFlags.mfSeparator |
ItemFlags.mfByPosition, 0, ""));
}
public bool InsertMenu(int Pos, int ID, String Item)
{
return (InsertMenu(Pos, ItemFlags.mfByPosition |
ItemFlags.mfString, ID, Item));
}
public bool InsertMenu(int Pos, ItemFlags Flags, int ID, String Item)
{
return (apiInsertMenu(m_SysMenu, Pos, (Int32)Flags, ID, Item) == 0);
}
public bool AppendSeparator()
{
return AppendMenu(0, "", ItemFlags.mfSeparator);
}
public bool AppendMenu(int ID, String Item)
{
return AppendMenu(ID, Item, ItemFlags.mfString);
}
public bool AppendMenu(int ID, String Item, ItemFlags Flags)
{
return (apiAppendMenu(m_SysMenu, (int)Flags, ID, Item) == 0);
}
public static CSystemMenu FromForm(Form Frm)
{
CSystemMenu cSysMenu = new CSystemMenu();
cSysMenu.m_SysMenu = apiGetSystemMenu(Frm.Handle, 0);
if (cSysMenu.m_SysMenu == IntPtr.Zero)
{ // Throw an exception on failure
throw new NoSystemMenuException();
}
return cSysMenu.;
}
public static void ResetSystemMenu(Form Frm)
{
apiGetSystemMenu(Frm.Handle, 1);
}
public static bool VerifyItemID(int ID)
{
return (bool)(ID < 0xF000 && ID > 0);
}
}
Na ja, 100MB ist schon recht viel - evtl. musst deinen Berechnungsalgorithmus noch mal überdenken.
Bin zwar kein Student aber zum Beispiel wäre ne gute UNI Idiotenaufgabe zählt mal von 1 bis 1000 Millionen alle zahlen zusammen. Während etliche wohl ne schleife durchlaufen lassen, nutzen manche die Gaußsche Formel und lösen das Problem Performant. Meistens (nicht immer) lässt sich durch Mathematik etliches an Problemen lösen.
Wenn wirklich keine andere Wahl hast, nutz einfach den Garbage Collector - Es spricht wirklich nichts dagegen.
Eigentlich brauchst nichts anderes als das Handle des Fensters mitzugeben an welche die Tastatureingaben gesendet werden sollen.
Bzw. wenn es nicht klappt schaue ich es mir bei Zeiten genauer an und poste dir den Quellcode dazu 🙂
Könntest eine eigene Fehlerausgabe gestallten in der StatusBar.
Bzw. eine eigene StatusBar zu entwerfen, Beispiel:
Standard
Fehlerausgabe
Also gegen GC.Collect spricht eigentlich nichts, kümmere mich in etlichen Anwendungen auch selbst darum dass nach Formularen oder Businessobjekten der Garbage Collector manuell angestoßen wird.
Hrm, habe mal nachgeschaut leider wird FindWindowEx nicht für Windows CE supported 🙁
Fürchte musst dann einen anderen Lösungsansatz versuchen, nur ehrlich gesagt habe keine Ahnung wie es sonst ohne viele Probleme zu erzeugen sonst machbar wäre.
Im schlimmstenfall musst die Nachrichten selbst schreiben, denk nur bei CF gibt es nicht user32.dll sondern core.dll 🙂
Hrm, soviel ich weis wird die Größe des Buttons vom Text beeinflusst der sich im Button befindet (klar man kann das auch verhindern aber standardmäßig hat das Control diese Eigenschaft). Schreibe etwas in den Button rein und er wird größer oder beeinflusse die Größe des Controls selbst.
Hrm, wenn es nichts einfacheres gibt nutzt die WindowsApi Funktion SetWindowPos.
Im Link ist ein kleines Testprojekt enthalten mit der Funktion.
Deskbar
Na ja, man kann halt in .Net Projekten mit einen Dissasembler Programm rein. Aber es gibt recht viele und brauchbare Produkte die Code verwurschteln so das jeden Nacharmer die Lust dran vergeht. Aus Klasse.Methode wird zum Beispiel oftmals. A.A usw. Dann wird es schwer das ganze zu interpretieren.
Probleme haben die meisten Codeverwurstler die ich mir mal angesehen habe nur bei string werten wie string bla = „Hallo das ist ein String Wert“. Der steht dann noch unverschlüsselt drinnen. Oder bei eingebetteten Resourcen die auch noch voll und ganz drinnen stehen.
Klar, gibt Tools die das mitlerweile auch können aber kostet meistens dann extra.
Benutzt die Generische Liste.
Also List<int> bla = new List<int>();
Dann mit bla.Add("1") oder bla.AddRange(new int[]{1,2,3,4,5});
Mit foreach(int Value in bla){} kannst dann die Schleife durchgehen.
Geht auch ArrayList aber finde eine Pointerliste etwas performanter.
Kannst auch folgendes machen int[] bla = new int[]{1,2,3,4,5}; Und dann mit bla.CopyTo das Array mit einen Hilfsarray erweitern.
Aber die GenerischenListen sind am schönsten dafür.
Hrm, für mich klingt das arg nach einer Basiskalsse. Schreib einfach eine abstrakte Basisklasse. Sauber wäre es wenn sie davor in ein Interface kapselst.
So kannst zusätzlich unabhängig für was auch immer, später eine Typenidentifizierung vornehmen.
Sprich:
Interface -> abstrakte Basisklasse: Interface -> Nebenklasse: abstrakte Basisklasse.
Aber ist wie schon schriebst, Geschmackssache.
Wenn aus welchen Grund auch immer das trotzdem so beibehalten möchtest.
Setze in deiner MainForm ein statisches Propertie welches die statische variable von typ Form zurück gibt welche du dann im Konstruktor von MainForm auf this initialisierst.
public static Form MainForm
{
get{ return myform; }
}
Aber normal sollte man es wie herbivore schrieb so halten das man entweder beim initialisieren den MdiParent festlegt oder im MDIChild beim Konstruktor den MDIParent mitgibt.
Würde dir empfehlen zuerst von Charles Petzold ein paar Bücher zur C# Programmierung anzusehen. Die Bücher sind allgemein sehr gutgeschrieben und helfen dir evtl. einige Vorgänge besser zu verstehen.
Windows-Programmierung mit Visual C#.
von Charles Petzold
Sprache: Deutsch
Sondereinband - 1200 Seiten - Microsoft Press
Erscheinungsdatum: 2002
ISBN: 3860636529
Windows Forms-Programmierung mit Visual C sharp 2005.
von Charles Petzold
Sprache: Deutsch
Gebundene Ausgabe - 385 Seiten - Microsoft Press Deutschland
Erscheinungsdatum: Februar 2006
Auflage: 1
ISBN: 3860639854
Hrm, unter VS2005 kann man bei Thread.Start(<meineVariable>) Variablen mitgeben an die entsprechende Methode.
Evtl. bin ich auch nur zu müde und es ging um etwas ganz anderes... X(
Hm, etwas mehr Beschreibung wäre klasse.
Nutzt du den Thread für eine "DoNothing loop" so was wie while(true) ?
Hm, vielleicht hilft die das angefügte Projekt etwas weiter.
Allerdings war es das erste was ich jemals erstellt habe und hatte davor keine Ahnung von C++. Es ist daher nicht besonders schön.
Dafür lässt es sich in C# einbinden und behandelt unmanged Code.
Solltest du also weiterhin dne Ansatz verfolgen die DLL in ein C++ Projekt einzubinden und dann in C# zu die daraus resultierende Dll zu verwenden.
Dann wäre das ein möglicher Ansatz dafür (nur VS2003 nutzbar, bei VS2005 treten Fehler auf).
Ansonsten schau dir so etwas an :
[System.Runtime.InteropServices.DllImport("user32.dll")]
private static extern IntPtr FindWindowEx(IntPtr hwndParent, IntPtr hwndChildAfter, string lpszClass, string lpszWindow);
Hallo malloc,
leider ist das Projekt vielleicht nicht ganz was du suchst aber kann dir evtl. zumindest einen Ansatz zeigen.
/ps
*hust* Bitte nur die vielen Rechtschreibfehler zu ignorieren, habe es mehr oder weniger nur hingeklatscht 😉
Über RichTextBox1.Parent kommt man dran.
Bzw:
if (RichTextBox1.Parent is System.Windows.Forms.Form)
{
((System.Windows.Forms.Form)RichTextBox1.Parent).Activate():
}
Original von TNDAri
Also wenn ich den hilfe text bei der Accept button eigenschaft richtig verstehe wird ein klicken auf den accept button simuliert. Also müsstest du nur praktisch abfangen das er das form nciht schliesst, wenn die richtextbox aktiv ist.Umständlich kannst du auch einfach die Accept button Eigenschaft auf (Keinen) setzten und dann bei jedem anderen control einfach die key down event abfangen, schaun ob Enter gedrückt wurde und wenn ja mit this.DialogResult = DialogResults.OK das form beenden. Wie gesagt ist die umständliche lösung 😉
Wird aber wohl das einzige sein was er noch tun kann, neben abfangen von Windowsnachrichten 😠
Hm, wie bereits geschrieben, frag einfach die Keys ab und schau ob eben das Control den Focus hat.
Wenn es den Focus besitzt machst eben den Zeilenumbruch. Sollte es nicht den focus besitzen lässt das Event weiter laufen bzw. aktivierst den Button. Kannst das auch über die Windowsnachrichten machen, was dir halt persönlich lieber ist.
/ps
Ob es eine "schönere" Lösung gibt weis ich nicht.
Hrm, wenn es sonst keine Alternative gibt über die Windowsnachrichten.
public enum WindowsMessages
{
WM_SYSCOMMAND = 0x112,
}
public enum SystemCommands
{
SC_SIZE = 0xF000,
SC_MOVE = 0xF010,
SC_MINIMIZE = 0xF020,
SC_MAXIMIZE = 0xF030,
SC_NEXTWINDOW = 0xF040,
SC_PREVWINDOW = 0xF050,
SC_CLOSE = 0xF060,
SC_VSCROLL = 0xF070,
SC_HSCROLL = 0xF080,
SC_MOUSEMENU = 0xF090,
SC_KEYMENU = 0xF100,
SC_ARRANGE = 0xF110,
SC_RESTORE = 0xF120,
SC_TASKLIST = 0xF130,
SC_SCREENSAVE = 0xF140,
SC_HOTKEY = 0xF150,
SC_DEFAULT = 0xF160,
SC_MONITORPOWER = 0xF170,
SC_CONTEXTHELP = 0xF180,
SC_SEPARATOR = 0xF00F
}
protected override void WndProc(ref Message m)
{
if (m.Msg == (int)WindowMessages.WM_SYSCOMMAND)
if (m.WParam.ToInt32() == (int)SystemCommands.SC_MINIMIZE)
return;
base.WndProc(ref m);
}
Hrm, schau mal im Forum ob es einen Beitrag über Actions und Commands gibt.
Ansonsten machst dir das leben einfacher wenn über eine Schnittstelle von Typ ICommand folgendes implementierst.
/// <summary>
/// A basic command interface. A command has simply an owner which "runs" the command
/// and a Run method which invokes the command.
/// </summary>
public interface ICommand
{
/// <summary>
/// Returns the owner of the command.
/// </summary>
object Owner {
get;
set;
}
/// <summary>
/// Invokes the command.
/// </summary>
void Run(object sender, EventArgs e);
}
Erstelle dann eine abstracte Kalsse die folgendes Implementiert.
/// <summary>
/// Abstract implementation of the <see cref="ICommand"/> interface.
/// </summary>
public abstract class Command : ICommand
{
object owner = null;
/// <summary>
/// Returns the owner of the command.
/// </summary>
public virtual object Owner {
get {
return owner;
}
set {
owner = value;
}
}
/// <summary>
/// Invokes the command.
/// </summary>
public abstract void Run(object sender, EventArgs e);
}
Schreibe die Menüs um mit folgenden.
public class CustomMenuItem:MenuItem
{ private object m_Tag = null;
public CustomMenuItem():base(){}
public CustomMenuItem(MenuMerge _mergeType,int _nMergeOrder,Shortcut _shortcut,string _sText,EventHandler _onClick,EventHandler _onPopup,EventHandler _onSelect,MenuItem[] _amItems):base(_mergeType,_nMergeOrder,_shortcut,_sText,_onClick,_onPopup,_onSelect,_amItems)
{
}
public CustomMenuItem(string _sText,MenuItem[] _amItems):base(_sText,_amItems){}
public CustomMenuItem(string _sText,EventHandler _onClick):base(_sText,_onClick)
{
m_Tag = (AbstractCommand) _onClick.Target;
}
public CustomMenuItem(string _sText,EventHandler _onClick,Shortcut _shortcut):base(_sText,_onClick,_shortcut){}
public CustomMenuItem(string _sText):base(_sText){}
public CustomMenuItem(string _sText,EventHandler _onClick,AbstractCommand _command):base(_sText,_onClick)
{
this.Tag = _command;
}
public object Tag
{
get{ return m_Tag;}
set{ m_Tag = value;}
}
}
Danach erstellst du Klassen welche von der Abstrakten form wie folgt abgeleitet sind (das ist ein Beispiel!). Die Form1 ist die ParentForm mit dem statischen Propertie MainForm, die APrentform hat eine RichtextBox die Beinflusst werden soll. Dieses Beispiel Klasse zeigt nur die Möglichkeiten auf, es ist hier dir selbst überlassen was du brauchst und was passieren soll. Über den Owner bekommst du dann deine Childforms, falls dort was passieren soll. Über sender bekommst du dein MenüItem das beinflussen kannst.
/// <summary>
/// Zusammenfassung für ActionZoom.
/// </summary>
///
public enum ZOOM
{
IN,
OUT,
RESET,
CUSTOM,
DEFAULT
}
public class ActionZoom: Command
{
private ZOOM M_ZOOM = ZOOM.DEFAULT;
public ActionZoom(ZOOM ZOOM)
{
M_ZOOM = ZOOM;
}
public override void Run(object sender, EventArgs e)
{
RichTextBox rtbEdit = Form1.MainForm.rtbText;
switch(M_ZOOM)
{
case ZOOM.IN:
rtbEdit.ZoomFactor += 0.1f;
break;
case ZOOM.OUT:
rtbEdit.ZoomFactor -= 0.1f;
break;
case ZOOM.RESET:
rtbEdit.ZoomFactor = 1.0f;
break;
case ZOOM.CUSTOM:
FormChooseZoom frmChooseZoom = new FormChooseZoom();
if (frmChooseZoom.ShowDialog() == DialogResult.OK)
{
rtbEdit.ZoomFactor = frmChooseZoom.ZoomLevel;
}
break;
default:
break;
}
}
Nun Initalisierst du die die Menüpunkte wie folgt.
private CustomMenuItem m_miZoomIn = new CustomMenuItem("&Hereinzoomen", new EventHandler(new ActionZoom(ZOOM.IN).Run));
Du benötigst nun überhaupt keinen Ereignisshandler auf irgend einen Formular für deine Menüpunkte mehr, den diese arbeiten selbstständig alles ab. (Thema: Design Pattern Programming)
Hm, frag die protected override void OnKeyDown(KeyEventArgs e) ab und schau ob der Focus nicht in der Control der RichtTextBox liegt.
Hm, wollte eigentlich nur zeigen das man vor Casts allgemein immer die Chance hat ohne Exceptions anhand der Typabfrage Fehler zu vermeiden.
Schön sind solche Dinge hier zum Beispiel, verwendet man aber relativ selten:
public bool Is<T>() where T : class
{
try
{
CastTo<T>();
return true;
}
catch
{
return false;
}
}
Hmm, herbivore Code geht schon man fragt vorher nur den Typ ab.
private void Test(object sender /* in sender liegt eine TextBoxinstanz */ )
{
if (sender is Button)
{
Button btn = (Button)sender;
MessageBox.Show("Der Code geht ohne Fehler.");
}
}
Hm, ich weis nicht ob es wirklich leichter ist aber es gibt viel Beispielquellcode im Netz für DirectX. Hatte damit selbst schon einige erfolge ohne zu wissen was ich da genau tue 😮)
Also wenn du die Zeit hast lohnt es sich einen Blick rein zuwerfen ist wirklich sehr leicht außer bei UTF-16 (unter VS2005 muss man etwas aufpassen). Auch kann ich nur anraten Librarys zu schreiben mit Standardfunktionalitäten die man immer wieder nutzt, zum Beispiel eine LogDatei Ausgabe oder Grafische Bibleotheken, UserControls usw. Bräuchtest dich daher nur einmal um ein XML Template bemühen und könntest es für andere weitere Projekte wieder verwenden. Irgendwann spart man sich damit sehr viel Zeit 🙂
Hm, geh einfach mal in den UserControl rein und füg das Propertie hinzu.
public new Control Control
{
get { return this.panel1.Controls ;}
}
Denk dran das neue Control ist das PanelControl, kannst das Propertie auch anders Beschimpfen. Nur wenn das normale UserControl.Control nicht brauchst kannst es mit new überschreiben wie im Beispiel.
Eine Sache solltest noch machen, entweder das TableLayoutPanel oder this.panel1.Dock = System.Windows.Forms.DockStyle.Fill; benutzen damit beim Resize keine Probleme bekommst.
Hm, frag die WindowsMessages ab bei protected override void WinProc und ermittle die entsprechenden gesendeten Keys über WPARAM oder LPARAM, dafür einfach in die kostenlos erhältliche Windows SDK reinschauen. Wenn die entsprechende Teste gesendet wird, einfach return; zurückgeben und es erfolgt keine weitere Verarbeitung.
Nur, muss man aufpassen ob bei protected override void WinProc nicht bereist schon zu spät ist. Sollte das der Fall sein, dann über SubClassing das ganze Lösen.
Das würde aber nur funktionieren solange dein Programm läuft, blöd ist nur möchte der Benutzer dann ScreenShoots währenddessen machen während dein Programm läuft klappt das dann auch nicht mehr für andere Programme.
Frage ist wirklich, ob das sein muss? Wenn ja, dann musst den Kunden darauf hinweisen das während der Betriebnahme deines Programms keine ScreenShoot funktionalität gegeben ist.
Natürlich ist aber auch klar das ThirdParty Tools immer noch gehen. Alles abfangen geht nicht.
Also wenn du Einstellungen speichern möchtest die über ein Formular getätigt werden das selbst nach Programmneustart nicht mehr erscheinen soll wenn bereits alle Einstellungen getätigt wurden. Dann rate ich zu einem XML File. Speichere deine Einstellungen dort ab in die Entsprechenden Nodes bzw. Atributes. Dann einfach das ganze beim Programmstart abprüfen ob XML Knoten gefüllt wurden oder nicht. Wenn nicht, starte Konfiguration, wenn gefüllt und alle Eingaben korrekt sind überspringe Konfiguration.
Vielleicht habe ich es auch nur falsch verstanden.
Hups, stimmt.
Naja ansonsten würde mir nur einfallen das ganze irgendwie über die Windows API zu lösen. Und zu überprüfen ob das Fenster noch TopMost ist.
Geht es wirklich nicht anders, fang unter protected override void WndProc(ref System.Windows.Forms.Message m) die Windows Nachricht für die Tasten ab und gib einfach nur return zurück (WindProc ist eine DoNothing Schleife sowas wie while(true)) somit verhinderst das weitere aktionen von F1 ausgehen. Den Rest behandle wie Xynratron Beispiel 🙂
Hier der Link für die Windows Nachrichten, für den Rest wirst das Windows SDK brauchen um festzustellen ob und was WPARAM und LPARAM dir als Infos bieten.
Aber wie herbivore schon schrieb, normal sollte man nichts daran ändern.
Borg hat da schon einen sehr guten Lösungsansatz.
Original von Borg
Muss gleich weg, daher nur schnell die ungetestete Idee:Wenn der Paint-Handler aufgerufen wird, wird diesem doch in den EventArgs sowohl eine Clipping-Region als auch ein Graphics-Objekt mitgegeben.
Wenn diese Region nicht dem kompletten Hauptfenster entspricht (das Paint -Ereignis muss durch ein Refresh des Hauptfensters ausgelöst werden), wird das Fenster überdeckt.Würde mich freuen, wenn das jemand testet. Wenn nicht, werde ich das heute abend mal probieren.
Über die Möglichkeit Controls.Add hast du die Möglichkeit wietere controls auch zur Laufzeit hinzuzufügen. Du musst nur definieren wann das ausgelöst werdne soll.
Ideal ist es dann schon im Vorfeld zu wissen wo die neuen Controls sich befinden sollen.
Das hinzufügen ist weniger Problematisch 🙂
Hm, ich denke das Problem wird einfach sein das die Koordinaten (Points) nicht stimmen. Du gehst davon aus dass die Gleiße Nord, Süd, Ost und West sich jeweils um den Wert 23 um die andere Controls befinden. Denke ist auch von dir gewollt das bestimmte Gleiße die weit außerhalb liegen evtl. mal Nord und Ost oder Süd und West usw. nicht finden. Aber Gleiße im Zentrum sollten immer alle vier finden.
Ich weis nicht, wäre es nicht leichter das ganze anders als über eine Grafische Findung zu realisieren oder können sich die Positionen der Gleiße ändern und wenn ja, werden der Wert 23 dabei berücksichtigt.
Schöner wäre es wenn eine Liste pflegen würdest die deine Elemente erstellt somit wüsstest du durch das erstellen des Elements welche Nachbar Gleiße du besitzt.
Grafisch musst immer sehr aufpassen, wenn würde ich versuchen durch einen näherungswert die nächsten zu finden. Macht das ganze natürlich komplizierter aber dann spielt es keine Rolle ob Süden nun genau um den Wert 23 über den aktuellen Gleiß befinden sollte. Dann kann das ganze auch Wirrwar sein .)
Bin leider nicht sonderlich gut im erklären.
Kurzum, DoubleBuffered verhindert Flackereffekte. Zum Beispiel. wenn das Control vergrößerst oder verkleinerst. Benötigt aber etwas mehr Speicher.
Invalidate habe ich beim Resize eingebaut damit die OnPaint Methode wieder angesteuert wird. Das Problem wenn das rauslassen würdest, hättest beim vergrößern und verkleinern zur Laufzeit das Problem das der Rahmen die Größe nicht korrekt mit anpasst. Die Ränder würden so Schliereneffekte hervorrufen im Control selbst.
Die TextBox muss ich mir mal anschauen, mit der OnPaint Methode geht das nicht so einfach. Bitte da um etwas Geduld 🙂
Uhh, wenn das Formular auf XP Style möchtest hast eine Wahnsinns arbeit vor dir...
Hm, müsste erst mit einen Kollegen sprechen ob ich da evtl. sein WindowsLonghorn Form als Beispielprojekt einbinden darf.
Ansonsten kann ich dir am Montag nur in etwa angeben was zu tun hast.
Überleg dir aber wirklich ob dir den Aufwand antun möchtest.
Hallo Fabian,
schau dir mal das Testprojekt im Anhang an.
Wenn du es komplett umgestellten möchtest ist das ganze schwieriger aber auch machbar.
Melde dich dann einfach.
Gruß
A.M
Hm, mir fällt da auch nicht mehr zu ein als selbst ein UserControl zu erstellen.
Also getestet habe ich es leider nicht.
Aber vermute mal das es sich einfach nur um ein anderes Handle handelt.
Versuch mal mit dem Spy++ und FindWindowEx das Handle abzufangen.
DllImport("user32.dll")]
private static extern IntPtr FindWindowEx(IntPtr hwndParent, IntPtr hwndChildAfter, string lpszClass, string lpszWindow);
Eigentlich sollte SetParent immer noch gehen.
Schau dir mal den Thread dazu an 🙂
Hmm, habe leider keinen Windows CE/Pocket-PC...
Hab es daher verpennt das es kein 'user32.dll' gibt, aber trotzdem kein Thema.
Ersetzt das einfach durch 'coredll.dll' dann sollte es funktionieren.
Wird leider ein bisschen dauern.
Mache aber ein kleines Demo-Projekt.
Hmm, mach mal this.DoubleBuffered = true.
Original von Fryti
Dumme Frage die nicht zum Topic gehört:
Was ist ein
[sehr simples] Hypertexthilfesystemprogramm
^^
Würde mich interressieren.
Hm, Knotenverweise in nichtlinearen Texten.
Kommt drauf an was man darunter nun versteht, denke mal man klickt auf nen Link und springst auf die Textmarke davon.
Das kann dir sicher auch weiterhelfen wenn noch andere Zeiteinstellungen benötigst.
Original von Kabelsalat
Ich würde mich an die Vorgaben der in Windows eingestellten Kultur halten (CultureInfo.CurrentCulture). Das geschieht automatisch und du musst dich nichteinmal darum kümmern. Wenn du das nicht machst kannst du einige User ganz schön vor dem Kopf stoßen: Ich rege mich z.B. unglaublich über das amerikanische Zeit- und Datumsformat auf!
Also da hat Kabelsalat recht. Nutzt einfach die CultureInfo Klasse, damit kannst nach belieben umstellen.
Unter System.Globalization.CultureInfo.CurrentCulture.DateTimeFormat.PMDesignator
findest auch PM oder AM als Anzeige..
Vielleicht verstehe ich die Frage auch nicht ganz 🤔