2008-03-27 Carlos Alberto Cortez <calberto.cortez@gmail.com>
[mono.git] / mcs / class / Managed.Windows.Forms / System.Windows.Forms / XplatUIDriver.cs
1 // Permission is hereby granted, free of charge, to any person obtaining
2 // a copy of this software and associated documentation files (the
3 // "Software"), to deal in the Software without restriction, including
4 // without limitation the rights to use, copy, modify, merge, publish,
5 // distribute, sublicense, and/or sell copies of the Software, and to
6 // permit persons to whom the Software is furnished to do so, subject to
7 // the following conditions:
8 // 
9 // The above copyright notice and this permission notice shall be
10 // included in all copies or substantial portions of the Software.
11 // 
12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
13 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
14 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
15 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
16 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
17 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
18 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19 //
20 // Copyright (c) 2004-2006 Novell, Inc.
21 //
22 // Authors:
23 //      Peter Bartok            pbartok@novell.com
24 //      Sebastien Pouliot       sebastien@ximian.com
25 //
26
27 // COMPLETE
28
29 using System.Drawing;
30 using System.Threading;
31 using System.Runtime.InteropServices;
32
33 namespace System.Windows.Forms {
34         internal abstract class XplatUIDriver {
35                 internal abstract IntPtr        InitializeDriver();
36                 internal abstract void          ShutdownDriver(IntPtr token);
37                 internal delegate IntPtr        WndProc(IntPtr hwnd, Msg msg, IntPtr wParam, IntPtr lParam);
38
39
40                 #region XplatUI Driver Properties
41                 internal virtual int ActiveWindowTrackingDelay { get { return 0; } }
42
43                 internal virtual Color ForeColor {
44                         get {
45                                 return ThemeEngine.Current.DefaultWindowForeColor;
46                         }
47                 }
48
49                 internal virtual  Color BackColor { 
50                         get {
51                                 return ThemeEngine.Current.DefaultWindowBackColor;
52                         }
53                 }
54
55                 internal virtual Size Border3DSize {
56                         get {
57                                 return new Size (2, 2);
58                         }
59                 }
60
61                 internal virtual Size BorderSize {
62                         get {
63                                 return new Size (1, 1);
64                         }
65                 }
66
67                 internal virtual Size CaptionButtonSize {
68                         get {
69                                 return new Size (18, 18);
70                         }
71                 }
72
73                 internal virtual int CaretBlinkTime { get { return 530; } }
74                 internal virtual int CaretWidth { get { return 10; } }
75                 
76                 internal virtual Size DoubleClickSize {
77                         get {
78                                 return new Size (4, 4);
79                         }
80                 }
81
82                 internal virtual int DoubleClickTime {
83                         get {
84                                 return 500;
85                         }
86                 }
87
88                 internal virtual Size FixedFrameBorderSize {
89                         get {
90                                 return new Size (3, 3);
91                         }
92                 }
93
94                 internal virtual Font Font {
95                         get {
96                                 return ThemeEngine.Current.DefaultFont;
97                         }
98                 }
99
100                 internal virtual int FontSmoothingContrast { get { return 1400; } }
101                 internal virtual int FontSmoothingType { get { return 1; } }
102                 internal virtual int HorizontalResizeBorderThickness { get { return 8; } }
103                 internal virtual bool IsActiveWindowTrackingEnabled { get { return false; } }
104                 internal virtual bool IsComboBoxAnimationEnabled { get { return false; } }
105                 internal virtual bool IsDropShadowEnabled { get { return false; } }
106                 internal virtual bool IsFontSmoothingEnabled { get { return true; } }
107                 internal virtual bool IsHotTrackingEnabled { get { return false; } }
108                 internal virtual bool IsIconTitleWrappingEnabled { get { return true; } }
109                 internal virtual bool IsKeyboardPreferred { get { return false; } }
110                 internal virtual bool IsListBoxSmoothScrollingEnabled { get { return true; } }
111                 internal virtual bool IsMenuAnimationEnabled { get { return false; } }
112                 internal virtual bool IsMenuFadeEnabled { get { return true; } }
113                 internal virtual bool IsMinimizeRestoreAnimationEnabled { get { return false; } }
114                 internal virtual bool IsSelectionFadeEnabled { get { return false; } }
115                 internal virtual bool IsSnapToDefaultEnabled { get { return false; } }
116                 internal virtual bool IsTitleBarGradientEnabled { get { return false; } }
117                 internal virtual bool IsToolTipAnimationEnabled { get { return false; } }
118                 internal virtual Size MenuBarButtonSize { get { return new Size (19, 19); } }
119                 internal virtual int MenuShowDelay { get { return 0; } }
120                 
121                 internal virtual Keys ModifierKeys {
122                         get {
123                                 return Keys.None;
124                         }
125                 }
126
127                 internal virtual MouseButtons MouseButtons {
128                         get {
129                                 return MouseButtons.None;
130                         }
131                 }
132
133                 internal virtual Size MouseHoverSize {
134                         get {
135                                 return new Size (1, 1);
136                         }
137                 }
138
139                 internal virtual int MouseHoverTime {
140                         get {
141                                 return 500;
142                         }
143                 }
144
145                 internal virtual int MouseSpeed {
146                         get { return 10; }
147                 }
148                 
149                 internal virtual int MouseWheelScrollDelta {
150                         get {
151                                 return 120;
152                         }
153                 }
154                 
155                 internal virtual Point MousePosition {
156                         get {
157                                 return Point.Empty;
158                         }
159                 }
160
161                 internal virtual int MenuHeight {
162                         get {
163                                 return 19;
164                         }
165                 }
166
167                 internal virtual LeftRightAlignment PopupMenuAlignment {
168                         get { return LeftRightAlignment.Left; }
169                 }
170                 
171 #if NET_2_0
172                 internal virtual PowerStatus PowerStatus {
173                         get { throw new NotImplementedException ("Has not been implemented yet for this platform."); }
174                 }
175 #endif
176
177                 internal virtual int SizingBorderWidth {
178                         get { return 4; }
179                 }
180                 
181                 internal virtual Size SmallCaptionButtonSize {
182                         get { return new Size (17, 17); }
183                 }
184                 
185                 internal virtual bool UIEffectsEnabled {
186                         get { return false; }
187                 }
188                 
189                 internal virtual bool DropTarget {
190                         get {
191                                 return false;
192                         }
193
194                         set {
195                         }
196                 }
197
198                 internal virtual int HorizontalScrollBarHeight {
199                         get {
200                                 return 16;
201                         }
202                 }
203
204                 internal virtual bool UserClipWontExposeParent {
205                         get {
206                                 return true;
207                         }
208                 }
209
210                 internal virtual int VerticalResizeBorderThickness { get { return 8; } }
211
212                 internal virtual int VerticalScrollBarWidth {
213                         get {
214                                 return 16;
215                         }
216                 }
217
218                 internal abstract int CaptionHeight { get; }
219                 internal abstract Size CursorSize { get; }
220                 internal abstract bool DragFullWindows { get; }
221                 internal abstract Size DragSize { get; }
222                 internal abstract Size FrameBorderSize { get; }
223                 internal abstract Size IconSize { get; }
224                 internal abstract Size MaxWindowTrackSize { get; }
225                 internal abstract bool MenuAccessKeysUnderlined { get; }
226                 internal abstract Size MinimizedWindowSize { get; }
227                 internal abstract Size MinimizedWindowSpacingSize { get; }
228                 internal abstract Size MinimumWindowSize { get; }
229                 internal virtual Size MinimumFixedToolWindowSize { get { return Size.Empty; } }
230                 internal virtual Size MinimumSizeableToolWindowSize { get { return Size.Empty; } }
231                 internal virtual Size MinimumNoBorderWindowSize { get { return Size.Empty; } }
232                 internal abstract Size MinWindowTrackSize { get; }
233                 internal abstract Size SmallIconSize { get; }
234                 internal abstract int MouseButtonCount { get; }
235                 internal abstract bool MouseButtonsSwapped { get; }
236                 internal abstract bool MouseWheelPresent { get; }
237                 internal abstract Rectangle VirtualScreen { get; }
238                 internal abstract Rectangle WorkingArea { get; }
239                 internal abstract bool ThemesEnabled { get; }
240
241                 #endregion      // XplatUI Driver Properties
242
243                 internal abstract event EventHandler Idle;
244
245                 #region XplatUI Driver Methods
246                 internal abstract void AudibleAlert();
247
248                 internal abstract void EnableThemes();
249
250                 internal abstract void GetDisplaySize(out Size size);
251
252                 internal abstract IntPtr CreateWindow(CreateParams cp);
253                 internal abstract IntPtr CreateWindow(IntPtr Parent, int X, int Y, int Width, int Height);
254                 internal abstract void DestroyWindow(IntPtr handle);
255
256                 internal abstract FormWindowState GetWindowState(IntPtr handle);
257                 internal abstract void SetWindowState(IntPtr handle, FormWindowState state);
258                 internal abstract void SetWindowMinMax(IntPtr handle, Rectangle maximized, Size min, Size max);
259
260                 internal abstract void SetWindowStyle(IntPtr handle, CreateParams cp);
261
262                 internal abstract double GetWindowTransparency(IntPtr handle);
263                 internal abstract void SetWindowTransparency(IntPtr handle, double transparency, Color key);
264                 internal abstract TransparencySupport SupportsTransparency();
265
266                 internal virtual void SetAllowDrop (IntPtr handle, bool value)
267                 {
268                         Console.Error.WriteLine ("Drag and Drop is currently " +
269                                         "not supported on this platform");
270                 }
271
272                 internal virtual DragDropEffects StartDrag(IntPtr handle, object data, DragDropEffects allowedEffects) {
273                         Console.Error.WriteLine ("Drag and Drop is currently " +
274                                         "not supported on this platform");
275                         return DragDropEffects.None;
276                 }
277
278                 internal abstract void SetBorderStyle(IntPtr handle, FormBorderStyle border_style);
279                 internal abstract void SetMenu(IntPtr handle, Menu menu);
280
281                 internal abstract bool GetText(IntPtr handle, out string text);
282                 internal abstract bool Text(IntPtr handle, string text);
283                 internal abstract bool SetVisible(IntPtr handle, bool visible, bool activate);
284                 internal abstract bool IsVisible(IntPtr handle);
285                 internal abstract bool IsEnabled(IntPtr handle);
286                 internal virtual bool IsKeyLocked (VirtualKeys key) { return false; }
287                 internal abstract IntPtr SetParent(IntPtr handle, IntPtr parent);
288                 internal abstract IntPtr GetParent(IntPtr handle);
289
290                 internal abstract void UpdateWindow(IntPtr handle);
291                 internal abstract PaintEventArgs PaintEventStart (ref Message msg, IntPtr handle, bool client);
292                 internal abstract void PaintEventEnd (ref Message msg, IntPtr handle, bool client);
293
294                 internal abstract void SetWindowPos(IntPtr handle, int x, int y, int width, int height);
295                 internal abstract void GetWindowPos(IntPtr handle, bool is_toplevel, out int x, out int y, out int width, out int height, out int client_width, out int client_height);
296                 internal abstract void Activate(IntPtr handle);
297                 internal abstract void EnableWindow(IntPtr handle, bool Enable);
298                 internal abstract void SetModal(IntPtr handle, bool Modal);
299                 internal abstract void Invalidate(IntPtr handle, Rectangle rc, bool clear);
300                 internal abstract void InvalidateNC(IntPtr handle);
301                 internal abstract IntPtr DefWndProc(ref Message msg);
302                 internal abstract void HandleException(Exception e);
303                 internal abstract void DoEvents();
304                 internal abstract bool PeekMessage(Object queue_id, ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax, uint flags);
305                 internal abstract void PostQuitMessage(int exitCode);
306                 internal abstract bool GetMessage(object queue_id, ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax);
307                 internal abstract bool TranslateMessage(ref MSG msg);
308                 internal abstract IntPtr DispatchMessage(ref MSG msg);
309
310                 internal abstract bool SetZOrder(IntPtr hWnd, IntPtr AfterhWnd, bool Top, bool Bottom);
311                 internal abstract bool SetTopmost(IntPtr hWnd, bool Enabled);
312                 internal abstract bool SetOwner(IntPtr hWnd, IntPtr hWndOwner);
313
314                 internal abstract bool CalculateWindowRect(ref Rectangle ClientRect, CreateParams cp, Menu menu, out Rectangle WindowRect);
315
316                 internal abstract Region GetClipRegion(IntPtr hwnd);
317                 internal abstract void SetClipRegion(IntPtr hwnd, Region region);
318
319                 internal abstract void SetCursor(IntPtr hwnd, IntPtr cursor);
320                 internal abstract void ShowCursor(bool show);
321                 internal abstract void OverrideCursor(IntPtr cursor);
322                 internal abstract IntPtr DefineCursor(Bitmap bitmap, Bitmap mask, Color cursor_pixel, Color mask_pixel, int xHotSpot, int yHotSpot);
323                 internal abstract IntPtr DefineStdCursor(StdCursor id);
324                 internal abstract Bitmap DefineStdCursorBitmap(StdCursor id);
325                 internal abstract void DestroyCursor(IntPtr cursor);
326                 internal abstract void GetCursorInfo(IntPtr cursor, out int width, out int height, out int hotspot_x, out int hotspot_y);
327
328                 internal abstract void GetCursorPos(IntPtr hwnd, out int x, out int y);
329                 internal abstract void SetCursorPos(IntPtr hwnd, int x, int y);
330
331                 internal abstract void ScreenToClient(IntPtr hwnd, ref int x, ref int y);
332                 internal abstract void ClientToScreen(IntPtr hwnd, ref int x, ref int y);
333
334                 internal abstract void GrabWindow(IntPtr hwnd, IntPtr ConfineToHwnd);
335                 internal abstract void GrabInfo(out IntPtr hwnd, out bool GrabConfined, out Rectangle GrabArea);
336                 internal abstract void UngrabWindow(IntPtr hwnd);
337
338                 internal abstract void SendAsyncMethod (AsyncMethodData method);
339                 internal abstract void SetTimer (Timer timer);
340                 internal abstract void KillTimer (Timer timer);
341
342                 internal abstract void CreateCaret(IntPtr hwnd, int width, int height);
343                 internal abstract void DestroyCaret(IntPtr hwnd);
344                 internal abstract void SetCaretPos(IntPtr hwnd, int x, int y);
345                 internal abstract void CaretVisible(IntPtr hwnd, bool visible);
346
347                 internal abstract IntPtr GetFocus();
348                 internal abstract void SetFocus(IntPtr hwnd);
349                 internal abstract IntPtr GetActive();
350                 internal abstract IntPtr GetPreviousWindow(IntPtr hwnd);
351
352                 internal abstract void ScrollWindow(IntPtr hwnd, Rectangle rectangle, int XAmount, int YAmount, bool with_children);
353                 internal abstract void ScrollWindow(IntPtr hwnd, int XAmount, int YAmount, bool with_children);
354
355                 internal abstract bool GetFontMetrics(Graphics g, Font font, out int ascent, out int descent);
356
357                 internal abstract bool SystrayAdd(IntPtr hwnd, string tip, Icon icon, out ToolTip tt);
358                 internal abstract bool SystrayChange(IntPtr hwnd, string tip, Icon icon, ref ToolTip tt);
359                 internal abstract void SystrayRemove(IntPtr hwnd, ref ToolTip tt);
360 #if NET_2_0             
361                 internal abstract void SystrayBalloon(IntPtr hwnd, int timeout, string title, string text, ToolTipIcon icon);
362 #endif
363
364                 internal abstract Point GetMenuOrigin(IntPtr hwnd);
365                 internal abstract void MenuToScreen(IntPtr hwnd, ref int x, ref int y);
366                 internal abstract void ScreenToMenu(IntPtr hwnd, ref int x, ref int y);
367
368                 internal abstract void SetIcon(IntPtr handle, Icon icon);
369
370                 internal abstract void ClipboardClose(IntPtr handle);
371                 internal abstract IntPtr ClipboardOpen (bool primary_selection);
372                 internal abstract int ClipboardGetID(IntPtr handle, string format);
373                 internal abstract void ClipboardStore(IntPtr handle, object obj, int id, XplatUI.ObjectToClipboard converter);
374                 internal abstract int[] ClipboardAvailableFormats(IntPtr handle);
375                 internal abstract object ClipboardRetrieve(IntPtr handle, int id, XplatUI.ClipboardToObject converter);
376
377                 internal abstract void DrawReversibleLine(Point start, Point end, Color backColor);
378                 internal abstract void DrawReversibleRectangle(IntPtr handle, Rectangle rect, int line_width);
379                 internal abstract void FillReversibleRectangle (Rectangle rectangle, Color backColor);
380                 internal abstract void DrawReversibleFrame (Rectangle rectangle, Color backColor, FrameStyle style);
381
382                 internal abstract SizeF GetAutoScaleSize(Font font);
383
384                 internal abstract IntPtr SendMessage(IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam);
385                 internal abstract bool PostMessage(IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam);
386                 internal abstract int SendInput(IntPtr hwnd, System.Collections.Queue keys);
387
388                 internal abstract object StartLoop(Thread thread);
389                 internal abstract void EndLoop(Thread thread);
390
391                 internal abstract void RequestNCRecalc(IntPtr hwnd);
392                 internal abstract void ResetMouseHover(IntPtr hwnd);
393                 internal abstract void RequestAdditionalWM_NCMessages(IntPtr hwnd, bool hover, bool leave);
394
395                 internal abstract void RaiseIdle (EventArgs e);
396                 
397                 // System information
398                 internal abstract int KeyboardSpeed { get; } 
399                 internal abstract int KeyboardDelay { get; } 
400
401
402                 // Double buffering
403                 internal virtual void CreateOffscreenDrawable (IntPtr handle,
404                                                                int width, int height,
405                                                                out object offscreen_drawable)
406                 {
407                         Bitmap bmp = new Bitmap (width, height, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
408
409                         offscreen_drawable = bmp;
410                 }
411
412                 internal virtual void DestroyOffscreenDrawable (object offscreen_drawable)
413                 {
414                         Bitmap bmp = (Bitmap)offscreen_drawable;
415
416                         bmp.Dispose ();
417                 }
418                 
419                 internal virtual Graphics GetOffscreenGraphics (object offscreen_drawable)
420                 {
421                         Bitmap bmp = (Bitmap)offscreen_drawable;
422                         return Graphics.FromImage (bmp);
423                 }
424
425                 internal virtual void BlitFromOffscreen (IntPtr dest_handle,
426                                                          Graphics dest_dc,
427                                                          object offscreen_drawable,
428                                                          Graphics offscreen_dc,
429                                                          Rectangle r)
430                 {
431                         dest_dc.DrawImage ((Bitmap)offscreen_drawable, r, r, GraphicsUnit.Pixel);
432                 }
433
434 #endregion      // XplatUI Driver Methods
435         }
436
437         internal class XplatUIDriverSupport {
438                 #region XplatUI Driver Support Methods
439 #if NET_2_0
440                 internal static void ExecutionCallback (object state)
441                 {
442                         AsyncMethodData data = (AsyncMethodData) state;
443                         AsyncMethodResult result = data.Result;
444                         object ret = data.Method.DynamicInvoke (data.Args);
445                         if (result != null) {
446                                 result.Complete (ret);
447                         }
448                 }
449
450                 internal static void ExecuteClientMessage (GCHandle gchandle)
451                 {
452                         AsyncMethodData data = (AsyncMethodData) gchandle.Target;
453                         try {
454                                 if (data.Context == null) {
455                                         ExecutionCallback (data);
456                                 } else {
457                                         ExecutionContext.Run (data.Context, new ContextCallback (ExecutionCallback), data);
458                                 }
459                         }
460                         finally {
461                                 gchandle.Free ();
462                         }
463                 }
464 #else
465                 // for NET_1_0 and NET_1_1 no (public) ExecutionContext exists 
466                 // so we must use the System.Threading.CompressedStack class
467                 internal static void ExecuteClientMessage (GCHandle gchandle) {
468                         AsyncMethodData data = (AsyncMethodData) gchandle.Target;
469                         CompressedStack original = null;
470                         
471 #if !MWF_ON_MSRUNTIME
472                         // Stack is non-null only if the security manager is active
473                         if (data.Stack != null) {
474                                 original = Thread.CurrentThread.GetCompressedStack ();
475                                 Thread.CurrentThread.SetCompressedStack (data.Stack);
476                         }
477 #endif
478
479                         try {
480                                 AsyncMethodResult result = data.Result;
481                                 object ret = data.Method.DynamicInvoke (data.Args);
482                                 result.Complete (ret);
483                         }
484                         finally {
485 #if !MWF_ON_MSRUNTIME
486                                 if (data.Stack != null) {
487                                         // whatever occurs we must revert to the original compressed
488                                         // stack (null being a valid, empty, value in this case).
489                                         Thread.CurrentThread.SetCompressedStack (original);
490                                 }
491 #endif
492                                 gchandle.Free ();
493                         }
494                 }
495 #endif
496                 
497                 #endregion      // XplatUI Driver Support Methods
498         }
499 }