Windows Forms Shortcut Problem

  • C#
  • .NET (FX) 4.5–4.8

Es gibt 16 Antworten in diesem Thema. Der letzte Beitrag () ist von Skaterkeks.

    Windows Forms Shortcut Problem

    Guten Morgen.

    Ich hätte mal eine kleine Frage,

    ich versuche gerade, mit Windows Forms ein Programm zu entwickeln, welches per Shortcut zulässt, das alles was groß geschrieben wurde in einem Satz, kleingeschrieben wird.

    Also: Man Kopiert einen Text, diese wird kopiert, man drückt die Taste und fügt es ein. Demnach ist alles im Satz danach klein geschrieben.

    Wenn ich diese auf eine Taste (Bsp F2 ) funktioniert dies nun auch tadellos.

    Problem an der Geschichte ist nun, das ich es erweitern möchte mit einer neuen Form, worin man sich seine Tastenkombination selbst legen kann.

    Ich weiß allerdings nun nicht, wie ich von der einen Form in die andere Form die Methoden verknüpfen kann.

    Also, das funktioniert schon, allerdings funktioniert dann die Tastenkombination für jede Taste.

    Ich hoffe auf viele Antworten.

    Liebe Grüße,

    Skaterkeks

    Thema verschoben ~VaporiZed
    Bilder

    • Bild_2022-07-19_085108980.png

      56,85 kB, 718×467, 48 mal angesehen

    • Bild_2022-07-19_085130606.png

      70,67 kB, 569×738, 52 mal angesehen

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „VaporiZed“ ()

    Willkommen im Forum.

    Statt mit Code-Screenshots zu arbeiten, wäre der Code als

    C#-Quellcode

    1. Code
    sinnvoller gepostet gewesen.

    Du hast jetzt

    C#-Quellcode

    1. Form2 form = new Form2;
    Und danach wertest Du was von form aus. Ohne, dass form vorher (z.B. als Dialog) angezeigt wurde? So wie die Screenshots aussehen, scheint das nicht zu klappen. Tja, und warum jetzt jede Taste funktioniert? Dazu müsste man den Code vollständig sehen.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    @Skaterkeks Willkommen im Forum. :thumbup:
    Falls Du mit C# (CSharp) arbeitest, gib bitte diesem Deinem Thread oben den richtigen Code-Tag.
    Zum Aufruf von Dialogen kannst Du auch mal hier rein schauen: Dialoge: Instanziierung von Forms und Aufruf von Dialogen
    den Teil mit den VB.NET-Default-Instanzen kannst Du überlesen.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Zuerst könntest Du die Logik Deines Programms für Dich und uns aufklären. Du übergibst einen Key an form, also die Form2-Instanz. In der wird aber combobox1.Text ausgewertet. Und diese combobox1 ist wahrscheinlich auf form. Nur: Wie soll der ComboBox-Text vom User oder wemauchimmer beeinflusst werden, wenn form nicht angezeigt wird?
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    Ich versuche das nochmal ausführlich von vorne zu beginnen.

    Es gibt eine Form 1. Diese läuft im Hintergrund, ist quasi auch garnicht sichtbar.

    In dieser Form funktionierte es so, wenn man einen Text kopierte, die Taste F9 drückte kam eine MessageBox "Aktiviert!".
    Dadurch war er in der Lage, jeden beliebeigen Text, den er kopierte sich in kleinbuchstaben wieder ausgeben zu lassen.

    Nun hatte ich eine 2. Form "entwickelt" worin sich der Nutzer selber aussuchen konnte, welche Taste er für den Hotkey verwenden möchte.

    Diese sah so aus

    C#-Quellcode

    1. public VKeys kbHook_KeyUp(VKeys key)
    2. {
    3. switch (comboBox1.Text)
    4. {
    5. case "A":
    6. key = VKeys.KEY_A;
    7. break;
    8. case "B":
    9. key = VKeys.KEY_B;
    10. break;
    11. case "C":
    12. key = VKeys.KEY_C;
    13. break;
    14. case "D":
    15. key = VKeys.KEY_D;
    16. break;
    17. case "E":
    18. key = VKeys.KEY_E;
    19. break;
    20. case "F":
    21. key = VKeys.KEY_F;
    22. break;
    23. case "G":
    24. key = VKeys.KEY_G;
    25. break;
    26. case "H":
    27. key = VKeys.KEY_H;
    28. break;
    29. case "I":
    30. key = VKeys.KEY_I;
    31. break;
    32. case "J":
    33. key = VKeys.KEY_J;
    34. break;
    35. case "K":
    36. key = VKeys.KEY_K;
    37. break;
    38. case "L":
    39. key = VKeys.KEY_L;
    40. break;
    41. case "M":
    42. key = VKeys.KEY_M;
    43. break;
    44. case "N":
    45. key = VKeys.KEY_N;
    46. break;
    47. case "O":
    48. key = VKeys.KEY_O;
    49. break;
    50. case "P":
    51. key = VKeys.KEY_P;
    52. break;
    53. case "Q":
    54. key = VKeys.KEY_Q;
    55. break;
    56. case "R":
    57. key = VKeys.KEY_R;
    58. break;
    59. case "S":
    60. key = VKeys.KEY_S;
    61. break;
    62. case "T":
    63. key = VKeys.KEY_T;
    64. break;
    65. case "U":
    66. key = VKeys.KEY_U;
    67. break;
    68. case "V":
    69. key = VKeys.KEY_V;
    70. break;
    71. case "W":
    72. key = VKeys.KEY_W;
    73. break;
    74. case "X":
    75. key = VKeys.KEY_X;
    76. break;
    77. case "Y":
    78. key = VKeys.KEY_Y;
    79. break;
    80. case "Z":
    81. key = VKeys.KEY_Z;
    82. break;
    83. case "F1":
    84. key = VKeys.F1;
    85. break;
    86. case "F2":
    87. key = VKeys.F2;
    88. break;
    89. case "F3":
    90. key = VKeys.F3;
    91. break;
    92. case "F4":
    93. key = VKeys.F4;
    94. break;
    95. case "F5":
    96. key = VKeys.F5;
    97. break;
    98. case "F6":
    99. key = VKeys.F6;
    100. break;
    101. case "F7":
    102. key = VKeys.F7;
    103. break;
    104. case "F8":
    105. key = VKeys.F8;
    106. break;
    107. case "F9":
    108. key = VKeys.F9;
    109. break;
    110. case "F10":
    111. key = VKeys.F10;
    112. break;
    113. case "F11":
    114. key = VKeys.F11;
    115. break;
    116. case "F12":
    117. key = VKeys.F12;
    118. break;
    119. }
    120. return key;


    Ich möchte, wenn der Nutzer sich nun entscheidet, ich nehme bsp den Buchstaben A, das aus dem

    C#-Quellcode

    1. public VKeys keyboardHook_KeyUp(VKeys key)
    2. {
    4. if (key == VKeys.F9)
    5. {
    6. try
    7. {
    8. StreamWriter sw = new StreamWriter(Path.Combine(path, "lowCase.txt"));
    9. var wandel = Clipboard.GetText();
    10. Clipboard.SetText(wandel.ToLower());
    11. sw.Write(DateTime.Now.ToLongTimeString() + " " + wandel.ToString());
    12. sw.Close();
    13. MessageBox.Show("Aktiviert!");
    14. }
    15. catch
    16. {
    17. MessageBox.Show("Bitte Text markieren!");
    18. }
    19. }
    20. return key;


    im if Statement die Auswahl vom Nutzer "überschrieben" wird.

    Problem ist bei mir gerade, ich weiß leider nicht, wie ich diese miteinander so kombinieren kann, sodass er immer die IF "überschreibt"


    Ich hoffe, ich konnte es halbwegs besser erklären.

    Hier evtl auch mal meine KeyboardHook

    C#-Quellcode

    1. using System;
    2. using System.Runtime.InteropServices;
    3. using System.Diagnostics;
    5. namespace LowCaser
    6. {
    7. /// <summary>
    8. /// Class for intercepting low level keyboard hooks
    9. /// </summary>
    10. public class KeyboardHook
    11. {
    13. #region WinAPI
    14. private const int WM_KEYDOWN = 0x100;
    15. private const int WM_SYSKEYDOWN = 0x104;
    16. private const int WM_KEYUP = 0x101;
    17. private const int WM_SYSKEYUP = 0x105;
    19. [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    20. private static extern IntPtr SetWindowsHookEx(int idHook, KeyboardHookHandler lpfn, IntPtr hMod, uint dwThreadId);
    22. [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    23. [return: MarshalAs(UnmanagedType.Bool)]
    24. private static extern bool UnhookWindowsHookEx(IntPtr hhk);
    26. [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    27. private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);
    29. [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    30. private static extern IntPtr GetAsyncKeyState(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);
    32. [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    33. private static extern IntPtr GetModuleHandle(string lpModuleName);
    34. #endregion
    36. #region Enum Vkeys
    37. public enum VKeys
    38. {
    39. LBUTTON = 0x01, // Linke Maus
    40. RBUTTON = 0x02, // Rechte Maus
    41. MBUTTON = 0x04, // Mitte von der Maus
    42. // 0x07 // Undefined
    43. BACK = 0x08, // Zurück
    44. TAB = 0x09, // TAB
    45. //
    46. SHIFT = 0x10, // SHIFT key
    47. CONTROL = 0x11, // CTRL key
    48. MENU = 0x12, // ALT key
    49. PAUSE = 0x13, // PAUSE key
    50. CAPITAL = 0x14, // CAPS LOCK key
    51. // 0x1A, // Undefined
    52. ESCAPE = 0x1B, // ESC key
    53. CONVERT = 0x1C, // IME convert
    54. NONCONVERT = 0x1D, // IME nonconvert
    55. ACCEPT = 0x1E, // IME accept
    56. MODECHANGE = 0x1F, // IME mode change request
    57. SPACE = 0x20, // SPACEBAR
    58. PRIOR = 0x21, // PAGE UP key
    59. NEXT = 0x22, // PAGE DOWN key
    60. END = 0x23, // END key
    61. HOME = 0x24, // HOME key
    62. LEFT = 0x25, // LEFT ARROW key
    63. UP = 0x26, // UP ARROW key
    64. RIGHT = 0x27, // RIGHT ARROW key
    65. DOWN = 0x28, // DOWN ARROW key
    66. SELECT = 0x29, // SELECT key
    67. PRINT = 0x2A, // PRINT key
    68. EXECUTE = 0x2B, // EXECUTE key
    69. SNAPSHOT = 0x2C, // PRINT SCREEN key
    70. INSERT = 0x2D, // INS key
    71. DELETE = 0x2E, // DEL key
    72. HELP = 0x2F, // HELP key
    73. KEY_0 = 0x30, // 0 key
    74. KEY_1 = 0x31, // 1 key
    75. KEY_2 = 0x32, // 2 key
    76. KEY_3 = 0x33, // 3 key
    77. KEY_4 = 0x34, // 4 key
    78. KEY_5 = 0x35, // 5 key
    79. KEY_6 = 0x36, // 6 key
    80. KEY_7 = 0x37, // 7 key
    81. KEY_8 = 0x38, // 8 key
    82. KEY_9 = 0x39, // 9 key
    83. // 0x3A-0x40, // Undefined
    84. KEY_A = 0x41, // A key
    85. KEY_B = 0x42, // B key
    86. KEY_C = 0x43, // C key
    87. KEY_D = 0x44, // D key
    88. KEY_E = 0x45, // E key
    89. KEY_F = 0x46, // F key
    90. KEY_G = 0x47, // G key
    91. KEY_H = 0x48, // H key
    92. KEY_I = 0x49, // I key
    93. KEY_J = 0x4A, // J key
    94. KEY_K = 0x4B, // K key
    95. KEY_L = 0x4C, // L key
    96. KEY_M = 0x4D, // M key
    97. KEY_N = 0x4E, // N key
    98. KEY_O = 0x4F, // O key
    99. KEY_P = 0x50, // P key
    100. KEY_Q = 0x51, // Q key
    101. KEY_R = 0x52, // R key
    102. KEY_S = 0x53, // S key
    103. KEY_T = 0x54, // T key
    104. KEY_U = 0x55, // U key
    105. KEY_V = 0x56, // V key
    106. KEY_W = 0x57, // W key
    107. KEY_X = 0x58, // X key
    108. KEY_Y = 0x59, // Y key
    109. KEY_Z = 0x5A, // Z key
    110. LWIN = 0x5B, // Left Windows key (Microsoft Natural keyboard)
    111. RWIN = 0x5C, // Right Windows key (Natural keyboard)
    112. APPS = 0x5D, // Applications key (Natural keyboard)
    113. // 0x5E, // Reserved
    114. SLEEP = 0x5F, // Computer Sleep key
    115. NUMPAD0 = 0x60, // Numeric keypad 0 key
    116. NUMPAD1 = 0x61, // Numeric keypad 1 key
    117. NUMPAD2 = 0x62, // Numeric keypad 2 key
    118. NUMPAD3 = 0x63, // Numeric keypad 3 key
    119. NUMPAD4 = 0x64, // Numeric keypad 4 key
    120. NUMPAD5 = 0x65, // Numeric keypad 5 key
    121. NUMPAD6 = 0x66, // Numeric keypad 6 key
    122. NUMPAD7 = 0x67, // Numeric keypad 7 key
    123. NUMPAD8 = 0x68, // Numeric keypad 8 key
    124. NUMPAD9 = 0x69, // Numeric keypad 9 key
    125. MULTIPLY = 0x6A, // Multiply key
    126. ADD = 0x6B, // Add key
    127. SEPARATOR = 0x6C, // Separator key
    128. SUBTRACT = 0x6D, // Subtract key
    129. DECIMAL = 0x6E, // Decimal key
    130. DIVIDE = 0x6F, // Divide key
    131. F1 = 0x70, // F1 key
    132. F2 = 0x71, // F2 key
    133. F3 = 0x72, // F3 key
    134. F4 = 0x73, // F4 key
    135. F5 = 0x74, // F5 key
    136. F6 = 0x75, // F6 key
    137. F7 = 0x76, // F7 key
    138. F8 = 0x77, // F8 key
    139. F9 = 0x78, // F9 key
    140. F10 = 0x79, // F10 key
    141. F11 = 0x7A, // F11 key
    142. F12 = 0x7B, // F12 key
    143. F13 = 0x7C, // F13 key
    144. F14 = 0x7D, // F14 key
    145. F15 = 0x7E, // F15 key
    146. F16 = 0x7F, // F16 key
    147. F17 = 0x80, // F17 key
    148. F18 = 0x81, // F18 key
    149. F19 = 0x82, // F19 key
    150. F20 = 0x83, // F20 key
    151. F21 = 0x84, // F21 key
    152. F22 = 0x85, // F22 key, (PPC only) Key used to lock device.
    153. F23 = 0x86, // F23 key
    154. F24 = 0x87, // F24 key
    155. }
    156. #endregion
    158. private delegate IntPtr KeyboardHookHandler(int nCode, IntPtr wParam, IntPtr lParam);
    159. private KeyboardHookHandler hookHandler;
    161. public delegate VKeys KeyboardHookCallback(VKeys key);
    163. #region Events
    164. public event KeyboardHookCallback KeyDown;
    165. public event KeyboardHookCallback KeyUp;
    166. #endregion
    168. private IntPtr hookID = IntPtr.Zero;
    169. public void Install()
    170. {
    171. hookHandler = HookFunc;
    172. hookID = SetHook(hookHandler);
    173. }
    174. public void Uninstall()
    175. {
    176. UnhookWindowsHookEx(hookID);
    177. }
    178. private IntPtr SetHook(KeyboardHookHandler proc)
    179. {
    180. using (ProcessModule module = Process.GetCurrentProcess().MainModule)
    181. return SetWindowsHookEx(13, proc, GetModuleHandle(module.ModuleName), 0);
    182. }
    183. private IntPtr HookFunc(int nCode, IntPtr wParam, IntPtr lParam)
    184. {
    185. if (nCode >= 0)
    186. {
    187. int iwParam = wParam.ToInt32();
    189. if ((iwParam == WM_KEYDOWN || iwParam == WM_SYSKEYDOWN))
    190. if (KeyDown != null)
    191. KeyDown((VKeys)Marshal.ReadInt32(lParam));
    192. if ((iwParam == WM_KEYUP || iwParam == WM_SYSKEYUP))
    193. if (KeyUp != null)
    194. KeyUp((VKeys)Marshal.ReadInt32(lParam));
    195. }
    197. return CallNextHookEx(hookID, nCode, wParam, lParam);
    198. }
    199. ~KeyboardHook()
    200. {
    201. Uninstall();
    202. }
    203. }
    204. }​

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Skaterkeks“ ()

    Noml gooonz longsom.
    Wo befindet sich combobox1? Also, auf welchem Form?
    Wie wird combobox1.text geändert?
    Diese Fragen sind deshalb, weil Post#1 impliziert, dass combobox1 ein Teil von Form2 ist, von Form2 eine Instanz namens form erstellt wird und sofort danach eben combobox1.text ausgewertet wird.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    combobox1 befindet sich auf Form2.

    Ich brauch aber die Werte, die man von der Form2 combox auswählt, auf der Form1, die im Hintergrund läuft.

    Ich würde das halt mal gerne zeigen, aber das ist etwas umständlich hier.

    Ich füge auch nochmal ein Bild von der Form2 ein.
    Bilder

    • Bild_2022-07-19_114602703.png

      5,69 kB, 492×202, 37 mal angesehen

    @Skaterkeks Von der Parent-Form kommst Du auf die Child-Form, indem Du ihr eine geeignete Methode oder Property gibst.
    Von der Child-Form kommst Du auf die Parent-Form, indem sie an diese ein Event sendet.
    Die VB-Umsetzung findest Du in meinem in Post #3 verwiesenen Thread.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    An welcher Stelle im Programmablauf wird form (die Form2-Instanz) dem User zur Laufzeit gezeigt, sodass er was aus der combobox1 auswählen kann? Und: Wie lautet der Code zur Instanziierung und Anzeige jener Form2-Instanz?
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    direkt beim start der Anwendung wird dem Nutzer die form2 angezeigt.
    Habe auch mittlerweile es geändert von einer Combobox in eine Textbox

    C#-Quellcode

    1. ​ public partial class Form2 : Form
    2. {
    3. public Form2()
    4. {
    5. KeyboardHook kbHook = new KeyboardHook();
    6. InitializeComponent();
    7. kbHook.KeyUp += new KeyboardHookCallback(kbHook_KeyUp);
    8. }
    10. private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
    11. {
    12. label2.Text = textBox1.Text;
    13. }
    15. private void button1_Click(object sender, EventArgs e)
    16. {
    17. MessageBox.Show("Sie haben " + label2.Text + " ausgewählt");
    18. Form1 form = new Form1();
    19. Form2 form2 = new Form2();
    20. form2.ShowDialog(form);
    22. if (textBox1.Text == "")
    23. {
    24. MessageBox.Show("Bitte eine Kombination eingeben!");
    25. }
    26. }
    28. private void button2_Click(object sender, EventArgs e)
    29. {
    30. Close();
    31. }
    33. private void Form2_Load(object sender, EventArgs e)
    34. {
    35. MessageBox.Show("Hier können Sie auswählen, welche Tastatur belegt wird für Ihre LowCase");
    36. label1.Text = "Es wurde ausgewählt: ";
    37. }
    38. public VKeys kbHook_KeyUp(VKeys key)
    39. {
    40. IDictionary<string, VKeys> dict = new Dictionary<string, VKeys>();
    41. if(textBox1.Text == dict.ToString())
    42. {
    43. dict.Add("A", VKeys.KEY_A);
    44. dict.Add("B", VKeys.KEY_B);
    45. dict.Add("C", VKeys.KEY_C);
    46. dict.Add("D", VKeys.KEY_D);
    47. dict.Add("E", VKeys.KEY_E);
    48. dict.Add("F", VKeys.KEY_F);
    49. dict.Add("G", VKeys.KEY_G);
    50. dict.Add("H", VKeys.KEY_H);
    51. dict.Add("I", VKeys.KEY_I);
    52. dict.Add("J", VKeys.KEY_J);
    53. dict.Add("K", VKeys.KEY_K);
    54. dict.Add("L", VKeys.KEY_L);
    55. dict.Add("M", VKeys.KEY_M);
    56. dict.Add("N", VKeys.KEY_N);
    57. dict.Add("O", VKeys.KEY_O);
    58. dict.Add("P", VKeys.KEY_P);
    59. dict.Add("Q", VKeys.KEY_Q);
    60. dict.Add("R", VKeys.KEY_R);
    61. dict.Add("S", VKeys.KEY_S);
    62. dict.Add("T", VKeys.KEY_T);
    63. dict.Add("U", VKeys.KEY_U);
    64. dict.Add("V", VKeys.KEY_V);
    65. dict.Add("W", VKeys.KEY_W);
    66. dict.Add("X", VKeys.KEY_X);
    67. dict.Add("Y", VKeys.KEY_Y);
    68. dict.Add("Z", VKeys.KEY_Z);
    69. dict.Add("F1", VKeys.F1);
    70. dict.Add("F2", VKeys.F2);
    71. dict.Add("F3", VKeys.F3);
    72. dict.Add("F4", VKeys.F4);
    73. dict.Add("F5", VKeys.F5);
    74. dict.Add("F6", VKeys.F6);
    75. dict.Add("F7", VKeys.F7);
    76. dict.Add("F8", VKeys.F8);
    77. dict.Add("F9", VKeys.F9);
    78. dict.Add("F10", VKeys.F10);
    79. dict.Add("F11", VKeys.F11);
    80. dict.Add("F12", VKeys.F12);
    81. }
    82. return key;
    83. }
    85. private void btnOk_Click(object sender, EventArgs e)
    86. {
    87. MessageBox.Show("Sie haben " + label2.Text + " ausgewählt");
    88. Form1 form = new Form1();
    89. Form2 form2 = new Form2();
    90. form2.Visible = false;
    91. form.Hide();
    92. }
    93. }
    94. }


    Das ist der gesamte Form2.cs Code

    @Skaterkeks Lässt sich das nicht mit frm.KeyPreview = true; und einem entsprechenden KeyDown-Eventhandler lösen?
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    8|
    Was'n das für'n Chaos? Warum hat Form2 eine Möglichkeit, von sich selbst auf Knopfdruck eine Instanz zu erzeugen, und dann von form1 gleich noch mit. Also dieser Programmverlauf ist für mich absolut nicht nachvollziehbar, von daher bin ich (auch aus Zeitgründen) erstmal raus.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    Skaterkeks schrieb:

    noch nicht richtig genug erklärt.
    Erkläre rein verbal was passieren soll ohne dass Du Code dazu postest.
    Sei bereit, dass wir Dein Konzept völlig über den Haufen werfen.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Form1 Funktioniert ohne jegliche Sichtbarkeit. Mit (Gerade F9 ) Taste wird alles was in einem Satz Groß geschrieben ist - klein geschrieben.

    Man kopiert quasi den Satz, drückt F9 und beim einfügen ist alles klein geschrieben

    Soll nun erweitern in dem man selber auswählen kann, welche Taste man nutzen möchte, um alles was groß geschrieben ist, kleinzuschreiben

Facebook
Telefonspende