?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2007-03-19 Chris Toshok <toshok@ximian.com>
[mono-project.git] / mcs / class / Managed.Windows.Forms / System.Windows.Forms / MdiWindowManager.cs
blobc991b31f9ddae6ce4fd8e13562366d4f5e2afdae
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) 2005 Novell, Inc. (http://www.novell.com)
21 //
22 // Authors:
23 // Jackson Harper (jackson@ximian.com)
24 //
25 //
26
27
28 using System;
29 using System.Drawing;
30 using System.Drawing.Drawing2D;
31 using System.Runtime.InteropServices;
32
33 namespace System.Windows.Forms {
34
35 internal class MdiWindowManager : InternalWindowManager {
36
37 private MainMenu merged_menu;
38 private MainMenu maximized_menu;
39 private MenuItem icon_menu;
40 private ContextMenu icon_popup_menu;
41 internal bool was_minimized;
42
43 private PaintEventHandler draw_maximized_buttons;
44 internal EventHandler form_closed_handler;
45
46 private MdiClient mdi_container;
47 private Rectangle prev_virtual_position;
48
49 private Point icon_clicked;
50 private DateTime icon_clicked_time;
51 private bool icon_dont_show_popup;
52
53 private TitleButtons maximized_title_buttons;
54 private bool is_visible_pending;
55
56 internal bool IsVisiblePending {
57 get {
58 return is_visible_pending;
59 }
60 set {
61 is_visible_pending = value;
62 }
63 }
64
65 private TitleButtons MaximizedTitleButtons {
66 get {
67 if (maximized_title_buttons == null) {
68 maximized_title_buttons = new TitleButtons (this.Form);
69 maximized_title_buttons.CloseButton.Visible = true;
70 maximized_title_buttons.RestoreButton.Visible = true;
71 maximized_title_buttons.MinimizeButton.Visible = true;
72 }
73 return maximized_title_buttons;
74 }
75 }
76
77 internal override Rectangle MaximizedBounds {
78 get {
79 Rectangle pb = mdi_container.ClientRectangle;
80 int bw = ThemeEngine.Current.ManagedWindowBorderWidth (this);
81 int tw = TitleBarHeight;
82
83 Rectangle new_bounds = new Rectangle (pb.Left - bw,
84 pb.Top - tw - bw,
85 pb.Width + bw * 2,
86 pb.Height + tw + bw * 2);
87 return new_bounds;
88 }
89 }
90
91
92
93 public MdiWindowManager (Form form, MdiClient mdi_container) : base (form)
94 {
95 this.mdi_container = mdi_container;
96 if (form.WindowState == FormWindowState.Normal) {
97 NormalBounds = form.Bounds;
98 }
99 form_closed_handler = new EventHandler (FormClosed);
100 form.Closed += form_closed_handler;
101 form.TextChanged += new EventHandler (FormTextChangedHandler);
102 form.SizeChanged += new EventHandler (FormSizeChangedHandler);
103 form.LocationChanged += new EventHandler (FormLocationChangedHandler);
104 form.VisibleChanged += new EventHandler (FormVisibleChangedHandler);
105 draw_maximized_buttons = new PaintEventHandler (DrawMaximizedButtons);
106 CreateIconMenus ();
107 }
108
109 private void FormVisibleChangedHandler (object sender, EventArgs e)
110 {
111 if (mdi_container == null)
112 return;
113
114 if (form.Visible) {
115 mdi_container.ActivateChild (form);
116 } else if (mdi_container.Controls.Count > 1) {
117 mdi_container.ActivateActiveMdiChild ();
118 }
119 }
120
121 private void FormTextChangedHandler (object sender, EventArgs e)
122 {
123 mdi_container.SetParentText (false);
124
125 #if NET_2_0
126 if (form.MdiParent.MainMenuStrip != null)
127 form.MdiParent.MainMenuStrip.RefreshMdiItems ();
128 #endif
129 }
130
131 private void FormLocationChangedHandler (object sender, EventArgs e)
132 {
133 if (form.window_state == FormWindowState.Minimized)
134 IconicBounds = form.Bounds;
135 form.MdiParent.MdiContainer.SizeScrollBars ();
136 }
137
138 private void FormSizeChangedHandler (object sender, EventArgs e)
139 {
140 if (form.window_state == FormWindowState.Maximized && form.Bounds != MaximizedBounds)
141 form.Bounds = MaximizedBounds;
142
143 form.MdiParent.MdiContainer.SizeScrollBars ();
144 }
145
146 public MainMenu MergedMenu {
147 get {
148 if (merged_menu == null)
149 merged_menu = CreateMergedMenu ();
150 return merged_menu;
151 }
152 }
153
154 private MainMenu CreateMergedMenu ()
155 {
156 Form parent = (Form) mdi_container.Parent;
157 MainMenu clone;
158 if (parent.Menu != null)
159 clone = (MainMenu) parent.Menu.CloneMenu ();
160 else
161 clone = new MainMenu ();
162
163 if (form.WindowState == FormWindowState.Maximized) {
164
165 }
166 clone.MergeMenu (form.Menu);
167 clone.MenuChanged += new EventHandler (MenuChangedHandler);
168 clone.SetForm (parent);
169 return clone;
170 }
171
172 public MainMenu MaximizedMenu {
173 get {
174 if (maximized_menu == null)
175 maximized_menu = CreateMaximizedMenu ();
176 return maximized_menu;
177 }
178 }
179
180 private MainMenu CreateMaximizedMenu ()
181 {
182 Form parent = (Form) mdi_container.Parent;
183 MainMenu res = new MainMenu ();
184
185 if (parent.Menu != null) {
186 MainMenu clone = (MainMenu) parent.Menu.CloneMenu ();
187 res.MergeMenu (clone);
188 }
189
190 if (form.Menu != null) {
191 MainMenu clone = (MainMenu) form.Menu.CloneMenu ();
192 res.MergeMenu (clone);
193 }
194
195 if (res.MenuItems.Count == 0)
196 res.MenuItems.Add (new MenuItem ()); // Dummy item to get the menu height correct
197
198 res.MenuItems.Insert (0, icon_menu);
199
200 res.SetForm (parent);
201 return res;
202 }
203
204 private void CreateIconMenus ()
205 {
206 icon_menu = new MenuItem ();
207 icon_popup_menu = new ContextMenu ();
208
209 icon_menu.OwnerDraw = true;
210 icon_menu.MeasureItem += new MeasureItemEventHandler (MeasureIconMenuItem);
211 icon_menu.DrawItem += new DrawItemEventHandler (DrawIconMenuItem);
212 icon_menu.Click += new EventHandler (ClickIconMenuItem);
213
214 MenuItem restore = new MenuItem ("Restore", new EventHandler (RestoreItemHandler));
215 MenuItem move = new MenuItem ("Move", new EventHandler (MoveItemHandler));
216 MenuItem size = new MenuItem ("Size", new EventHandler (SizeItemHandler));
217 MenuItem minimize = new MenuItem ("Minimize", new EventHandler (MinimizeItemHandler));
218 MenuItem maximize = new MenuItem ("Maximize", new EventHandler (MaximizeItemHandler));
219 MenuItem close = new MenuItem ("Close", new EventHandler (CloseItemHandler));
220 MenuItem next = new MenuItem ("Next", new EventHandler (NextItemHandler));
221
222 icon_menu.MenuItems.AddRange (new MenuItem [] { restore, move, size, minimize,
223 maximize, close, next });
224 icon_popup_menu.MenuItems.AddRange (new MenuItem [] { restore, move, size, minimize,
225 maximize, close, next });
226 }
227
228 private void ClickIconMenuItem(object sender, EventArgs e)
229 {
230 if ((DateTime.Now - icon_clicked_time).TotalMilliseconds < 500) {
231 form.Close ();
232 return;
233 }
234 icon_clicked_time = DateTime.Now;
235 Point pnt = Point.Empty;
236 pnt = form.MdiParent.PointToScreen (pnt);
237 pnt = form.PointToClient (pnt);
238 ShowPopup (pnt);
239 }
240
241 private void ShowPopup (Point pnt)
242 {
243 icon_popup_menu.MenuItems[0].Enabled = form.window_state != FormWindowState.Normal; // restore
244 icon_popup_menu.MenuItems[1].Enabled = form.window_state != FormWindowState.Maximized; // move
245 icon_popup_menu.MenuItems[2].Enabled = form.window_state != FormWindowState.Maximized; // size
246 icon_popup_menu.MenuItems[3].Enabled = form.window_state != FormWindowState.Minimized; // minimize
247 icon_popup_menu.MenuItems[4].Enabled = form.window_state != FormWindowState.Maximized; // maximize
248 icon_popup_menu.MenuItems[5].Enabled = true; // close
249 icon_popup_menu.MenuItems[6].Enabled = true; // next
250
251 icon_popup_menu.Show(form, pnt);
252 }
253
254 private void RestoreItemHandler (object sender, EventArgs e)
255 {
256 form.WindowState = FormWindowState.Normal;
257 }
258
259 private void MoveItemHandler (object sender, EventArgs e)
260 {
261 int x = 0;
262 int y = 0;
263
264 PointToScreen (ref x, ref y);
265 Cursor.Position = new Point (x, y);
266 form.Cursor = Cursors.Cross;
267 state = State.Moving;
268 form.Capture = true;
269 }
270
271 private void SizeItemHandler (object sender, EventArgs e)
272 {
273 int x = 0;
274 int y = 0;
275
276 PointToScreen (ref x, ref y);
277 Cursor.Position = new Point (x, y);
278 form.Cursor = Cursors.Cross;
279 state = State.Sizing;
280 form.Capture = true;
281 }
282
283 private void MinimizeItemHandler (object sender, EventArgs e)
284 {
285 form.WindowState = FormWindowState.Minimized;
286 }
287
288 private void MaximizeItemHandler (object sender, EventArgs e)
289 {
290 if (form.WindowState != FormWindowState.Maximized)
291 form.WindowState = FormWindowState.Maximized;
292 }
293
294 private void CloseItemHandler (object sender, EventArgs e)
295 {
296 form.Close ();
297 }
298
299 private void NextItemHandler (object sender, EventArgs e)
300 {
301 mdi_container.ActivateNextChild ();
302 }
303
304 private void DrawIconMenuItem (object sender, DrawItemEventArgs de)
305 {
306 de.Graphics.DrawIcon (form.Icon, new Rectangle (de.Bounds.X + 2, de.Bounds.Y + 2,
307 de.Bounds.Height - 4, de.Bounds.Height - 4));
308 }
309
310 private void MeasureIconMenuItem (object sender, MeasureItemEventArgs me)
311 {
312 int size = SystemInformation.MenuHeight;
313 me.ItemHeight = size;
314 me.ItemWidth = size + 2; // some padding
315 }
316
317 private void MenuChangedHandler (object sender, EventArgs e)
318 {
319 CreateMergedMenu ();
320 }
321
322 public override void PointToClient (ref int x, ref int y)
323 {
324 XplatUI.ScreenToClient (mdi_container.Handle, ref x, ref y);
325 }
326
327 public override void PointToScreen (ref int x, ref int y)
328 {
329 XplatUI.ClientToScreen (mdi_container.Handle, ref x, ref y);
330 }
331
332 public override void UpdateWindowDecorations (FormWindowState window_state)
333 {
334 switch (window_state) {
335 case FormWindowState.Minimized:
336 case FormWindowState.Normal:
337 MaximizedMenu.Paint -= draw_maximized_buttons;
338 MaximizedTitleButtons.Visible = false;
339 TitleButtons.Visible = true;
340 break;
341 case FormWindowState.Maximized:
342 MaximizedMenu.Paint += draw_maximized_buttons;
343 MaximizedTitleButtons.Visible = true;
344 TitleButtons.Visible = false;
345 break;
346 }
347
348 base.UpdateWindowDecorations (window_state);
349 }
350
351 public override void SetWindowState (FormWindowState old_state, FormWindowState window_state)
352 {
353 mdi_container.SetWindowState (form, old_state, window_state, false);
354 }
355
356 private void FormClosed (object sender, EventArgs e)
357 {
358 mdi_container.CloseChildForm (form);
359
360 #if NET_2_0
361 if (form.MdiParent.MainMenuStrip != null)
362 form.MdiParent.MainMenuStrip.RefreshMdiItems ();
363 #endif
364 }
365
366 public override void DrawMaximizedButtons (object sender, PaintEventArgs pe)
367 {
368 Size bs = ThemeEngine.Current.ManagedWindowButtonSize (this);
369 Point pnt = XplatUI.GetMenuOrigin (mdi_container.ParentForm.Handle);
370 int bw = ThemeEngine.Current.ManagedWindowBorderWidth (this);
371 TitleButtons buttons = MaximizedTitleButtons;
372
373 buttons.Visible = true;
374 TitleButtons.Visible = false;
375
376 buttons.CloseButton.Rectangle = new Rectangle (mdi_container.ParentForm.Size.Width - 1 - bw - bs.Width - 2,
377 pnt.Y + 2, bs.Width, bs.Height);
378
379 buttons.RestoreButton.Rectangle = new Rectangle (buttons.CloseButton.Rectangle.Left - 2 - bs.Width,
380 pnt.Y + 2, bs.Width, bs.Height);
381
382 buttons.MinimizeButton.Rectangle = new Rectangle (buttons.RestoreButton.Rectangle.Left - bs.Width,
383 pnt.Y + 2, bs.Width, bs.Height);
384
385 DrawTitleButton (pe.Graphics, buttons.MinimizeButton, pe.ClipRectangle);
386 DrawTitleButton (pe.Graphics, buttons.RestoreButton, pe.ClipRectangle);
387 DrawTitleButton (pe.Graphics, buttons.CloseButton, pe.ClipRectangle);
388
389 buttons.MinimizeButton.Rectangle.Y -= pnt.Y;
390 buttons.RestoreButton.Rectangle.Y -= pnt.Y;
391 buttons.CloseButton.Rectangle.Y -= pnt.Y;
392 }
393
394 public bool HandleMenuMouseDown (MainMenu menu, int x, int y)
395 {
396 Point pt = MenuTracker.ScreenToMenu (menu, new Point (x, y));
397
398 HandleTitleBarDown (pt.X, pt.Y);
399 return TitleButtons.AnyPushedTitleButtons;
400 }
401
402 public void HandleMenuMouseUp (MainMenu menu, int x, int y)
403 {
404 Point pt = MenuTracker.ScreenToMenu (menu, new Point (x, y));
405
406 HandleTitleBarUp (pt.X, pt.Y);
407 }
408
409 public void HandleMenuMouseLeave (MainMenu menu, int x, int y)
410 {
411 Point pt = MenuTracker.ScreenToMenu (menu, new Point (x, y));
412 HandleTitleBarLeave (pt.X, pt.Y);
413
414 }
415
416 public void HandleMenuMouseMove (MainMenu menu, int x, int y)
417 {
418 Point pt = MenuTracker.ScreenToMenu (menu, new Point (x, y));
419
420 HandleTitleBarMouseMove (pt.X, pt.Y);
421
422 }
423
424 protected override void HandleTitleBarLeave (int x, int y)
425 {
426 base.HandleTitleBarLeave (x, y);
427
428 if (maximized_title_buttons != null) {
429 maximized_title_buttons.MouseLeave (x, y);
430 }
431
432 if (IsMaximized)
433 XplatUI.InvalidateNC (form.MdiParent.Handle);
434 }
435
436 protected override void HandleTitleBarUp (int x, int y)
437 {
438 if (IconRectangleContains (x, y)) {
439 if (!icon_dont_show_popup) {
440 if (IsMaximized)
441 ClickIconMenuItem (null, null);
442 else
443 ShowPopup (Point.Empty);
444 } else {
445 icon_dont_show_popup = false;
446 }
447 return;
448 }
449
450 bool was_maximized = IsMaximized;
451 base.HandleTitleBarUp (x, y);
452 if (maximized_title_buttons != null && was_maximized) {
453 maximized_title_buttons.MouseUp (x, y);
454 }
455
456 if (IsMaximized)
457 XplatUI.InvalidateNC (mdi_container.Parent.Handle);
458 }
459
460 protected override void HandleTitleBarDoubleClick (int x, int y)
461 {
462 if (IconRectangleContains (x, y)) {
463 form.Close ();
464 } else {
465 form.WindowState = FormWindowState.Maximized;
466 }
467 base.HandleTitleBarDoubleClick (x, y);
468 }
469
470 protected override void HandleTitleBarDown (int x, int y)
471 {
472 if (IconRectangleContains (x, y)) {
473 if ((DateTime.Now - icon_clicked_time).TotalMilliseconds < 500 && icon_clicked.X == x && icon_clicked.Y == y) {
474 form.Close ();
475 } else {
476 icon_clicked_time = DateTime.Now;
477 icon_clicked.X = x;
478 icon_clicked.Y = y;
479 }
480
481 return;
482 }
483
484 base.HandleTitleBarDown (x, y);
485
486 if (maximized_title_buttons != null) {
487 maximized_title_buttons.MouseDown (x, y);
488 }
489
490 if (IsMaximized) {
491 XplatUI.InvalidateNC (mdi_container.Parent.Handle);
492 }
493 }
494
495 protected override void HandleTitleBarMouseMove (int x, int y)
496 {
497 base.HandleTitleBarMouseMove (x, y);
498
499 if (maximized_title_buttons != null) {
500 maximized_title_buttons.MouseMove (x, y);
501 }
502 }
503
504 protected override bool HandleLButtonDblClick (ref Message m)
505 {
506
507 int x = Control.LowOrder ((int)m.LParam.ToInt32 ());
508 int y = Control.HighOrder ((int)m.LParam.ToInt32 ());
509
510 // Correct since we are in NC land.
511 NCClientToNC (ref x, ref y);
512
513 if (IconRectangleContains (x, y)) {
514 icon_popup_menu.Wnd.Hide ();
515 form.Close ();
516 return true;
517 }
518
519 return base.HandleLButtonDblClick (ref m);
520 }
521
522 protected override bool HandleLButtonDown (ref Message m)
523 {
524
525 int x = Control.LowOrder ((int)m.LParam.ToInt32 ());
526 int y = Control.HighOrder ((int)m.LParam.ToInt32 ());
527
528 // Correct y since we are in NC land.
529 NCClientToNC(ref x, ref y);
530
531 if (IconRectangleContains (x, y)){
532 if ((DateTime.Now - icon_clicked_time).TotalMilliseconds < 500) {
533 if (icon_popup_menu != null && icon_popup_menu.Wnd != null) {
534 icon_popup_menu.Wnd.Hide ();
535 }
536 form.Close ();
537 return true;
538 } else if (form.Capture) {
539 icon_dont_show_popup = true;
540 }
541 }
542 return base.HandleLButtonDown (ref m);
543 }
544
545 protected override bool ShouldRemoveWindowManager (FormBorderStyle style)
546 {
547 return false;
548 }
549
550 protected override void HandleWindowMove (Message m)
551 {
552 Point move = MouseMove (m);
553
554 if (move.X == 0 && move.Y == 0)
555 return;
556
557 int x = virtual_position.X + move.X;
558 int y = virtual_position.Y + move.Y;
559
560 Rectangle client = mdi_container.ClientRectangle;
561 if (mdi_container.VerticalScrollbarVisible)
562 client.Width -= SystemInformation.VerticalScrollBarWidth;
563 if (mdi_container.HorizontalScrollbarVisible)
564 client.Height -= SystemInformation.HorizontalScrollBarHeight;
565 if (!client.Contains (new Point(x + clicked_point.X, y + clicked_point.Y)))
566 return;
567
568 UpdateVP (x, y, form.Width, form.Height);
569 start = Cursor.Position;
570 }
571
572 protected override bool HandleNCMouseMove (ref Message m)
573 {
574 XplatUI.RequestAdditionalWM_NCMessages (form.Handle, true, true);
575 return base.HandleNCMouseMove (ref m);
576 }
577
578 protected override void DrawVirtualPosition (Rectangle virtual_position)
579 {
580 ClearVirtualPosition ();
581
582 if (form.Parent != null)
583 XplatUI.DrawReversibleRectangle (form.Parent.Handle, virtual_position, 2);
584 prev_virtual_position = virtual_position;
585 }
586
587 protected override void ClearVirtualPosition ()
588 {
589 if (prev_virtual_position != Rectangle.Empty && form.Parent != null)
590 XplatUI.DrawReversibleRectangle (form.Parent.Handle,
591 prev_virtual_position, 2);
592 prev_virtual_position = Rectangle.Empty;
593 }
594
595 protected override void OnWindowFinishedMoving ()
596 {
597 form.Refresh ();
598 }
599
600 public override bool IsActive {
601 get {
602 return mdi_container.ActiveMdiChild == form;
603 }
604 }
605
606 protected override void Activate ()
607 {
608 if (mdi_container.ActiveMdiChild != form) {
609 mdi_container.ActivateChild (form);
610 }
611 base.Activate ();
612 }
613 }
614 }
615
Mirror of the official Mono project git repository