Datetimepicker Backcolor

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

Es gibt 11 Antworten in diesem Thema. Der letzte Beitrag () ist von -Franky-.

    Datetimepicker Backcolor

    Guten Tag

    Ich bin auf der Suche nach einem Datetimepicker-Steuerelement, bei dem man optisch einiges anpassen kann auf Github auf folgenden Code gestossen:
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.ComponentModel;
    3. using System.Drawing;
    4. using System.Runtime.InteropServices;
    5. using System.Windows.Forms;
    6. public class FlatDateTimePicker : DateTimePicker
    7. {
    8. private Image calendarImage;
    9. private Image calendarImageWhite;
    10. public FlatDateTimePicker()
    11. {
    12. SetStyle(ControlStyles.ResizeRedraw, true);
    13. DoubleBuffered = true;
    14. calendarImage = FlatDateTimePickerExample.Properties.Resources.Calendar;
    15. calendarImageWhite = FlatDateTimePickerExample.Properties.Resources.CalendarWhite;
    16. }
    18. private Color borderColor = Color.DeepSkyBlue;
    19. [DefaultValue(typeof(Color), "RoyalBlue")]
    20. public Color BorderColor
    21. {
    22. get { return borderColor; }
    23. set
    24. {
    25. if (borderColor != value)
    26. {
    27. borderColor = value;
    28. Invalidate();
    29. }
    30. }
    31. }
    32. UpDownRenderer updownRenderer;
    33. protected override void WndProc(ref Message m)
    34. {
    35. if (m.Msg == WM_PAINT)
    36. {
    37. var info = new DATETIMEPICKERINFO();
    38. info.cbSize = Marshal.SizeOf(info);
    39. SendMessage(Handle, DTM_GETDATETIMEPICKERINFO, IntPtr.Zero, ref info);
    41. var clientRect = new Rectangle(0, 0, Width, Height);
    42. var dropDownButtonRect = new Rectangle(info.rcButton.L, info.rcButton.T,
    43. info.rcButton.R - info.rcButton.L, clientRect.Height);
    44. var dropDownRect = dropDownButtonRect;
    45. var imageRect = Rectangle.Empty;
    46. if (info.rcButton.R - info.rcButton.L > SystemInformation.HorizontalScrollBarArrowWidth)
    47. {
    48. var w = dropDownButtonRect.Width / 2;
    49. imageRect = dropDownButtonRect;
    50. imageRect.Width = w;
    52. dropDownRect.X += w;
    53. dropDownRect.Width = w;
    54. }
    55. var checkBoxRect = new Rectangle(info.rcCheck.L, info.rcCheck.T,
    56. info.rcCheck.R - info.rcCheck.L, clientRect.Height);
    57. var innerRect = new Rectangle(checkBoxRect.Right + 1, 1,
    58. clientRect.Width - dropDownButtonRect.Width - checkBoxRect.Width - (ShowCheckBox ? 3 : 1),
    59. clientRect.Height - 2);
    60. if (RightToLeft == RightToLeft.Yes && RightToLeftLayout == true)
    61. {
    62. dropDownButtonRect.X = clientRect.Width - dropDownButtonRect.Right;
    63. dropDownButtonRect.Width += 1;
    65. innerRect.X -= clientRect.Width - innerRect.X;
    66. innerRect.Width += 1;
    68. imageRect.X = clientRect.Width - imageRect.Right;
    70. dropDownRect.X = clientRect.Width - dropDownRect.Right;
    71. dropDownRect.Width += 1;
    72. }
    74. var middle = new Point(dropDownRect.Left + dropDownRect.Width / 2,
    75. dropDownRect.Top + dropDownRect.Height / 2);
    76. var arrow = new Point[]
    77. {
    78. new Point(middle.X - 3, middle.Y - 2),
    79. new Point(middle.X + 4, middle.Y - 2),
    80. new Point(middle.X, middle.Y + 2)
    81. };
    83. var borderColor = Enabled ? BorderColor : Color.LightGray;
    85. var ps = new PAINTSTRUCT();
    86. bool shoulEndPaint = false;
    87. IntPtr dc;
    88. if (m.WParam == IntPtr.Zero)
    89. {
    90. dc = BeginPaint(Handle, ref ps);
    91. m.WParam = dc;
    92. shoulEndPaint = true;
    93. }
    94. else
    95. {
    96. dc = m.WParam;
    97. }
    99. var rgn = CreateRectRgn(innerRect.Left, innerRect.Top, innerRect.Right, innerRect.Bottom);
    100. SelectClipRgn(dc, rgn);
    101. DefWndProc(ref m);
    102. DeleteObject(rgn);
    103. rgn = CreateRectRgn(clientRect.Left, clientRect.Top, clientRect.Right, clientRect.Bottom);
    104. SelectClipRgn(dc, rgn);
    106. using (var g = Graphics.FromHdc(dc))
    107. {
    108. if (ShowCheckBox)
    109. {
    110. var r = Rectangle.FromLTRB(info.rcCheck.L, info.rcCheck.T,
    111. info.rcCheck.R, info.rcCheck.B);
    112. if (Checked)
    113. DrawFrameControl(dc, ref info.rcCheck, DFC_MENU, DFCS_MENUCHECK);
    114. else
    115. g.FillRectangle(SystemBrushes.Window, r);
    116. if (!Enabled)
    117. {
    118. using (var b = new SolidBrush(Color.FromArgb(200, SystemColors.Control)))
    119. g.FillRectangle(b, r);
    120. }
    121. var r2 = r;
    122. r2.Width -= 1; r2.Height -= 1;
    123. g.DrawRectangle(Enabled ? SystemPens.WindowText : SystemPens.GrayText, r2);
    125. r2.Inflate(1, 1);
    126. g.DrawRectangle(Pens.White, r2);
    127. }
    129. if (ShowUpDown)
    130. {
    131. if (updownRenderer == null && info.hwndUD != IntPtr.Zero)
    132. updownRenderer = new UpDownRenderer(info.hwndUD);
    133. updownRenderer.ButtonColor = this.BorderColor;
    134. updownRenderer.ArrowColor = Color.Black;
    135. }
    136. else
    137. {
    138. var buttonColor = Enabled ? BorderColor : Color.LightGray;
    139. var arrorColor = Color.Black;
    140. var imageToRender = calendarImage;
    141. if(dropDownButtonRect.Contains(PointToClient(Cursor.Position)))
    142. {
    143. arrorColor = Color.White;
    144. imageToRender = calendarImageWhite;
    145. }
    146. using (var brush = new SolidBrush(buttonColor))
    147. g.FillRectangle(brush, dropDownButtonRect);
    148. if (imageRect != Rectangle.Empty)
    149. g.DrawImage(imageToRender,
    150. imageRect.Left + ((imageRect.Width - imageToRender.Width) / 2),
    151. imageRect.Top + ((imageRect.Height - imageToRender.Height) / 2),
    152. calendarImage.Width,
    153. calendarImage.Height);
    154. using (var brush = new SolidBrush(arrorColor))
    155. g.FillPolygon(brush, arrow);
    156. }
    157. using (var pen = new Pen(borderColor))
    158. g.DrawRectangle(pen, 0, 0,
    159. ClientRectangle.Width - 1, ClientRectangle.Height - 1);
    160. }
    161. if (shoulEndPaint)
    162. EndPaint(Handle, ref ps);
    163. DeleteObject(rgn);
    164. }
    165. else
    166. {
    167. base.WndProc(ref m);
    168. }
    169. }
    171. private class UpDownRenderer : NativeWindow
    172. {
    173. public UpDownRenderer(IntPtr hwnd)
    174. {
    175. this.AssignHandle(hwnd);
    176. SetWindowTheme(Handle, string.Empty, string.Empty);
    177. }
    178. private bool Enabled => IsWindowEnabled(Handle);
    179. private Point PointToClient(Point p)
    180. {
    181. var pt = new POINT() { X = p.X, Y = p.Y };
    182. ScreenToClient(Handle, ref pt);
    183. return new Point(pt.X, pt.Y);
    184. }
    185. private Rectangle ClientRectangle
    186. {
    187. get
    188. {
    189. var r = new RECT();
    190. GetWindowRect(Handle, ref r);
    191. return new Rectangle(0, 0, r.R - r.L, r.B - r.T);
    192. }
    193. }
    194. public Color ButtonColor { get; set; }
    195. public Color ArrowColor { get; set; }
    196. private Point[] GetDownArrow(Rectangle r)
    197. {
    198. var middle = new Point(r.Left + r.Width / 2, r.Top + r.Height / 2);
    199. return new Point[]
    200. {
    201. new Point(middle.X - 3, middle.Y - 1),
    202. new Point(middle.X + 4, middle.Y - 1),
    203. new Point(middle.X, middle.Y + 3)
    204. };
    205. }
    206. private Point[] GetUpArrow(Rectangle r)
    207. {
    208. var middle = new Point(r.Left + r.Width / 2, r.Top + r.Height / 2);
    209. return new Point[]
    210. {
    211. new Point(middle.X - 4, middle.Y + 2),
    212. new Point(middle.X + 4, middle.Y + 2),
    213. new Point(middle.X, middle.Y - 3)
    214. };
    215. }
    216. protected override void WndProc(ref Message m)
    217. {
    218. var enabled = Enabled;
    219. var clientRectangle = ClientRectangle;
    220. var backColor = enabled ? ButtonColor : Color.LightGray;
    221. if (m.Msg == WM_MOUSEMOVE)
    222. {
    223. var r = clientRectangle;
    224. var rect = new RECT() { L = r.Left, T = r.Top, R = r.Right, B = r.Bottom };
    225. InvalidateRect(Handle, ref rect, false);
    226. }
    227. if (m.Msg == WM_PAINT)
    228. {
    229. var s = new PAINTSTRUCT();
    230. BeginPaint(Handle, ref s);
    232. using (var g = Graphics.FromHdc(s.hdc))
    233. {
    234. var context = BufferedGraphicsManager.Current;
    235. using (var bg = context.Allocate(g, clientRectangle))
    236. {
    237. var gg = bg.Graphics;
    238. var r1 = new Rectangle(0, 0,
    239. clientRectangle.Width, clientRectangle.Height / 2);
    240. var r2 = new Rectangle(0, clientRectangle.Height / 2,
    241. clientRectangle.Width, clientRectangle.Height / 2 + 1);
    242. using (var backBrush = new SolidBrush(backColor))
    243. {
    244. gg.FillRectangle(backBrush, r1);
    245. gg.FillRectangle(backBrush, r2);
    246. }
    247. gg.DrawLine(Pens.White, r1.Left, r1.Bottom, r1.Right, r1.Bottom);
    248. gg.DrawLine(Pens.White, r2.Left, r2.Top, r2.Right, r2.Top);
    250. if (r1.Contains(PointToClient(Cursor.Position)))
    251. gg.FillPolygon(Brushes.White, GetUpArrow(r1));
    252. else
    253. gg.FillPolygon(Brushes.Black, GetUpArrow(r1));
    255. if (r2.Contains(PointToClient(Cursor.Position)))
    256. gg.FillPolygon(Brushes.White, GetDownArrow(r2));
    257. else
    258. gg.FillPolygon(Brushes.Black, GetDownArrow(r2));
    259. bg.Render(g);
    260. }
    261. }
    262. m.Result = (IntPtr)1;
    263. base.WndProc(ref m);
    264. EndPaint(Handle, ref s);
    265. }
    266. else
    267. base.WndProc(ref m);
    268. }
    269. }
    271. const int WM_PAINT = 0xF;
    272. const int DTM_FIRST = 0x1000;
    273. const int WM_ERASEBKGND = 0x14;
    274. const int DTM_GETDATETIMEPICKERINFO = DTM_FIRST + 14;
    275. const int WM_MOUSEMOVE = 0x0200;
    277. const int DFC_MENU = 2;
    278. const int DFCS_MENUCHECK = 0x0001;
    279. [DllImport("user32.dll")]
    280. static extern bool DrawFrameControl(IntPtr hDC, ref RECT rect, int type, int state);
    282. [DllImport("user32.dll")]
    283. static extern IntPtr SendMessage(IntPtr hWnd, int Msg,
    284. IntPtr wParam, ref DATETIMEPICKERINFO info);
    285. [DllImport("user32.dll")]
    286. static extern IntPtr SendMessage(IntPtr hWnd, int Msg,
    287. IntPtr wParam, IntPtr info);
    289. [StructLayout(LayoutKind.Sequential)]
    290. struct RECT
    291. {
    292. public int L, T, R, B;
    293. }
    294. [StructLayout(LayoutKind.Sequential)]
    295. struct POINT
    296. {
    297. public int X, Y;
    298. }
    300. [StructLayout(LayoutKind.Sequential)]
    301. struct DATETIMEPICKERINFO
    302. {
    303. public int cbSize;
    304. public RECT rcCheck;
    305. public int stateCheck;
    306. public RECT rcButton;
    307. public int stateButton;
    308. public IntPtr hwndEdit;
    309. public IntPtr hwndUD;
    310. public IntPtr hwndDropDown;
    311. }
    312. [DllImport("user32.dll")]
    313. private static extern bool IsWindowEnabled(IntPtr hWnd);
    314. [DllImport("user32.dll")]
    315. static extern bool GetWindowRect(IntPtr hWnd, ref RECT rect);
    316. [StructLayout(LayoutKind.Sequential)]
    317. public struct PAINTSTRUCT
    318. {
    319. public IntPtr hdc;
    320. public bool fErase;
    321. public int rcPaint_left;
    322. public int rcPaint_top;
    323. public int rcPaint_right;
    324. public int rcPaint_bottom;
    325. public bool fRestore;
    326. public bool fIncUpdate;
    327. public int reserved1;
    328. public int reserved2;
    329. public int reserved3;
    330. public int reserved4;
    331. public int reserved5;
    332. public int reserved6;
    333. public int reserved7;
    334. public int reserved8;
    335. }
    337. [DllImport("uxtheme.dll", ExactSpelling = true, CharSet = CharSet.Unicode)]
    338. static extern int SetWindowTheme(IntPtr hwnd, string pszSubAppName, string pszSubIdList);
    340. [DllImport("user32.dll")]
    341. private static extern IntPtr BeginPaint(IntPtr hWnd, [In, Out] ref PAINTSTRUCT lpPaint);
    343. [DllImport("user32.dll")]
    344. private static extern bool EndPaint(IntPtr hWnd, ref PAINTSTRUCT lpPaint);
    346. [DllImport("gdi32.dll")]
    347. public static extern int SelectClipRgn(IntPtr hDC, IntPtr hRgn);
    349. [DllImport("gdi32.dll")]
    350. internal static extern bool DeleteObject(IntPtr hObject);
    352. [DllImport("gdi32.dll")]
    353. private static extern IntPtr CreateRectRgn(int x1, int y1, int x2, int y2);
    355. [DllImport("user32.dll")]
    356. static extern int ScreenToClient(IntPtr hWnd, ref POINT lpPoint);
    358. [DllImport("user32.dll")]
    359. static extern int InvalidateRect(IntPtr hWnd, ref RECT lpRect, bool bErase);
    360. }


    Dies funktioniert zwar sehr gut, ich möchte aber auch die Hintergrundfarbe ändern. Hiermit könnte ich zwar die Backcolor ändern, aber dabei wird auch der Inhalt überschrieben:

    C#-Quellcode

    1. using (var g=Graphics.FromHdc(dc))
    2. {
    3. using (var bcBrush = new SolidBrush(DefaultBackColor))
    4. {
    5. g.FillRectangle(bcBrush, innerRect);
    6. }
    7. {


    Ich kenne mich weder mit der Entwicklung von Steuerelementen noch mit C# aus und hoffe auf eure Unterstützung.

    aufgrund des Codeumfangs Spoiler hinzugefügt ~VaporiZed

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

    AKP schrieb:

    aber dabei wird auch der Inhalt überschrieben:
    Dann rufst Du die Paint-Prozeduren in der verkehrten Reihenfolge auf.
    Zuerst den Hintergrund darstellen, dann den Vordergrund.
    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!

    AKP schrieb:

    Ich bin auf der Suche nach einem Datetimepicker-Steuerelement, bei dem man optisch einiges anpassen kann

    AKP schrieb:

    Ich kenne mich weder mit der Entwicklung von Steuerelementen noch mit C# aus

    Da sind die Erfolgsaussichten ziemlich mau.
    Ich habs nicht probiert, aber beim Standard-DateTimePicker kann man die BackColor nicht ändern, oder?
    Das Github-Teil erbt vom Standard-DateTimePicker - da wird es das auch nicht können.

    Ich hab sowas mal mit Textbox versucht - mit dem .Net-Framework-Instrumentarium ging da nix.
    Vielleicht kann man was mit WinApi zaubern, aber das ist ziemlich speziell und eher nix für Anfänger.

    ErfinderDesRades schrieb:

    Da sind die Erfolgsaussichten ziemlich mau.
    Ich habs nicht probiert, aber beim Standard-DateTimePicker kann man die BackColor nicht ändern, oder?
    Das Github-Teil erbt vom Standard-DateTimePicker - da wird es das auch nicht können.

    Im Prinzip ist das ein OwnerDrawing der im WndProc, der hier zum Teil bei der Message WM_PAINT, stattfindet. Die Frage wäre nun ob das die richtige Message ist, um die Hintergrundfarbe zu ändern. Da gibt es ja noch ein Haufen Messages mehr. Vllt ist es auch die Message WM_ERASEBKGND. Google, google, ach gucke: stackoverflow.com/questions/19…f-a-datetimepicker-in-net
    Mfg -Franky-

    Hallo

    Besten Dank für eure Antworten. Wenn ich das einfüge:

    C#-Quellcode

    1. ​if(m.Msg == WM_ERASEBKGND)
    2. {
    3. using(var g = Graphics.FromHdc(m.WParam))
    4. {
    5. using(var b = new SolidBrush(_backColor))
    6. {
    7. g.FillRectangle(b, ClientRectangle);
    8. }
    9. }
    10. return;
    11. }


    Klappt es leider nicht. Beim Debuggen wird zwar der Hintergrund eingefärbt bis zur Zeile 101:

    C#-Quellcode

    1. ​ DefWndProc(ref m);

    Dann ist die Formatierung wieder weg.

    Wenn ich das Beispiel von deinem Link in VB-Net nehme, wird zwar der Hintergrund eingefärbt, aber die Cursormarkierung fehlt.

    ich sachja: es ist tricky.
    Normalerweise kann man bei .Net-Controls die BackColor festlegen, aber bei manchen Controls ist das von .Net nicht vorgesehen - und das hat vermutlich auch einen Grund.
    Und da wäre nun Code zu finden, der .Net quasi hintergeht - wie gesagt: bei Textbox habichs nicht hingekriegt.

    AKP schrieb:

    aber die Cursormarkierung fehlt.
    genau sowas.
    Das Zeichnen eines editierbaren Controls, mit blinkendem Cursor, an der richtigen Stelle, und so - ich vermute, das ist sehr komplex, und das mag auch der Grund sein, warum .Net bei derartigen Controls das Paint-Event abgeklemmt hat, und auch keine BackColor-Property anbietet etc.

    ErfinderDesRades schrieb:

    aber bei manchen Controls ist das von .Net nicht vorgesehen - und das hat vermutlich auch einen Grund

    Nö. Ich würde sagen das MS denkt, wir bieten dem Programmierer nur Standard-Eigenschaften. Alles andere kann der der Programmierer ja selbst implementieren oder wird gut versteckt/nicht verfügbar gemacht weil sonst könnte man ja Sachen anstellen, die MS vllt. nicht möchte. zB das Handle vom TaskDialog ab NET5 wird nicht dem Programmierer nicht zur Verfügung gestellt. Warum? Hat MS Angst das man diesen dann Subclassen könnte um den Dialog zu manipulieren?

    Nur weil ein Control eine bestimmte Eigenschaft nicht besitzt, heißt das noch lange nicht das man das nicht nachimplementieren kann. Entweder, wenn es eine entsprechende Control-Message gibt, sendet man diese per SendMessage an das Control oder man betreibt OwnerDrawing. Letzteres ist natürlich aufwendiger. 3 Bsp für fehlende Eigenschaften: ProgressBar Eigenschaft State (Normal, Error, Paused) nicht vorhanden. Per SendMessage und PBM_SETSTATE nachrüstbar. Hintergrundfarbe bei Scrollbars. Message WM_CTLCOLORSCROLLBAR des Parent abfangen und hier eine Farbe für die Scrollbar festlegen. SpellCheck in einer Winforms-RTB. Nicht vorhanden. Ebenfalls per Sendmessage mit entsprechenden Messages nachrüstbar.

    OwnerDrawing ist ein ganz anderes Thema. Da muss man halt alles selber zeichnen. Also auch die Markierung wenn man im DateTimePicker auf den Text (Tag, Monat, Jahr) klickt. Alternativ erstellt man sich per API CreateWindowEx sein eigenes DateTimePicker-Control und per API RegisterClassEx -> Struct WNDCLASSEX <- hbrBackground setzt man die BackColor-Eigenschaft. Machbar ist es auf jeden Fall. Nur der Weg dahin ist halt aufwendig.

    ErfinderDesRades schrieb:

    wie gesagt: bei Textbox habichs nicht hingekriegt

    Auch das geht wie der ScreenShot zeigt. Hier wird allerdings ein BitmapBrush, anstelle eines SolidBrush, verwendet um den Hintergrund/BackColor der TextBox zu manipulieren und um den Cursor muss ich mir dabei keine Gedanken machen. Ja, ist mit VB6 gemacht und was da geht, sollte in .NET erst recht Möglich sein.
    Bilder

    • TextBox.png

      88,25 kB, 591×334, 44 mal angesehen
    Mfg -Franky-

    ErfinderDesRades schrieb:

    aber was nützt das nun dem TE?

    Schauen ob es evtl. eine entsprechende Control-Message gibt die man per SendMessage an das Control senden kann (kann ich jetzt schon sagen, gibt es nicht).
    OwnerDrawing: selbst alles zeichnen
    Selbst das Control per CreateWindowEx, RegisterClassEx, mit einer anderen BackColor (hbrBackground) erstellen.

    Na wenn das keine Hinweise sind, weis ich auch nicht.

    Edit: Einen hab ich noch. Müsste man mal in .NET testen. Unter VB6 geht es.

    Visual Basic-Quellcode

    1. ​
    2. Private Declare Function CreateSolidBrush Lib "gdi32" (ByVal crColor As Long) As Long
    4. Private Const GCL_HBRBACKGROUND = -10
    6. Private Declare Function SetClassLong Lib "user32" Alias "SetClassLongA" ( _
    7. ByVal hWnd As Long, _
    8. ByVal nIndex As Long, _
    9. ByVal dwNewLong As Long) As Long
    11. Private Sub Form_Load()
    12. SetClassLong DTPicker1.hWnd, GCL_HBRBACKGROUND, CreateSolidBrush(vbCyan)
    13. End Sub


    Aber Achtung! Das wirkt sich dann auf alle DateTimePicker Controls aus, die von der gleichen WNDCLASS stammen.
    Mfg -Franky-

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „-Franky-“ ()

    Ja, sind sicher Hinweise, aber auf zu hohem Niveau.
    dein letztes Snippet ist eiglich einfach, aber immer noch zu hoch: es setzt ja voraus, dass man vb6 nach .Net-Code konvertieren kann.
    Aber habichmal gemacht, aus Interesse und für den TE:

    VB.NET-Quellcode

    1. Private Declare Function CreateSolidBrush Lib "gdi32" (ByVal crColor As Integer) As Integer
    2. Private Const GCL_HBRBACKGROUND = -10
    3. Private Declare Function SetClassLong Lib "user32" Alias "SetClassLongA" (
    4. ByVal hWnd As IntPtr,
    5. ByVal nIndex As Integer,
    6. ByVal dwNewLong As Integer) As Integer
    8. Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
    9. SetClassLong(DateTimePicker2.Handle, GCL_HBRBACKGROUND, CreateSolidBrush(9))
    10. End Sub
    Tut sich aber nichts.
    Kann sein, es liegt daran, dass ich nicht den Wert von vbCyan weiss - ich hab einfach 9 eingesetzt.

    @ErfinderDesRades
    Jau, der DateTimePicker unter .Net verweigert alles was ich aus VB6 Zeiten kenne um die BackColor zu ändern. Außer Subclassing und WM_xxx Messages auswerten und selber zeichnen. vbCyan wäre 0xFFFF00 gewesen.

    Also bleibt nur OwnerDrawing (Me.SetStyle(ControlStyles.UserPaint, True) wenn man ein vorhandenes Control manipulieren möchte. Denke das die WndProc schon die richtige Stelle ist. Ich kann da evtl. ein kleines Tool empfehlen, mit dem man entsprechende WindowsMessages (WM_xxx) ermitteln kann wenn man bestimmte Aktionen auf einem Control durchführt. Also wenn der Text markiert wird bzw. einen Text (Tag, Monat, Jahr) anklickt. Den Rest müsste man sich ergoogeln und nachbauen. docs.microsoft.com/de-de/windows/win32/controls/control-spy Schade das Control Spy nicht weiter entwickelt wird weil da doch so einige Control-Messages fehlen. Zum Ausprobieren einiger Control-Messages und welche Const zum Erstellen von Controls (CreateWindowEx) was bewirkt, reicht es auf jeden Fall.
    Mfg -Franky-

Facebook
Telefonspende