?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dsrc isn't necessary for this repo
[client-tools.git] / src / external / 3rd / application / UiBuilder / UIWindow.cpp
blob3060313eb3ab7d22332584b9620bf396179e3606
1 #include "FirstUiBuilder.h"
2
3 #include "UIBuilderHistory.h"
4 #include "UIDirect3DPrimaryCanvas.h"
5 #include "UIManager.h"
6 #include "UIPage.h"
7 #include "UIScriptEngine.h"
8 #include "uicanvas.h"
9 #include "uimessage.h"
10 #include "uipalette.h"
11 #include "UIUndo.h"
12 #include "UIWidget.h"
13 #include "UIUtils.h"
14
15 #include <cmath>
16 #include <commctrl.h>
17 #include <process.h>
18 #include <windowsx.h>
19
20 #include "objectinspector.h"
21 #include "resource.h"
22
23 static const int UITimerID = 100;
24
25 extern bool g_showShaders;
26
27 HWND gUIWindow = 0;
28 HWND gCanvasWindow = 0;
29 HWND gTabControlWindow = 0;
30
31 HANDLE gEngineThread = 0;
32 HANDLE gStopEvent = 0;
33 HANDLE gFrameRenderingMutex = 0;
34
35 long gTriangleCount = 0;
36 long gFlushCount = 0;
37 long gFrameCount = 0;
38
39 bool gButtonDown;
40 UIPoint gMouseDownPoint;
41
42 UIBaseObject::UISmartObjectList gCurrentSelection;
43
44 bool gMoving;
45 UIPoint gOriginalLocation;
46 bool gSizing;
47 UISize gOriginalSize;
48
49 UIRect gTabControlPadding;
50 UIPage *gCurrentlySelectedPage = 0;
51
52 bool gDrawHighlightRect = true;
53 bool gLimitFrameRate = true;
54 bool gInVisualEditingMode = false;
55 UIColor gHighlightOutlineColor(0xff,0,0,0xaa);
56 UIColor gHighlightFillColor(0xff,0,0,0);
57
58 bool gSizeUp = false;
59 bool gSizeDown = false;
60 bool gSizeLeft = false;
61 bool gSizeRight = false;
62
63 bool gNoChangeSelection = false;
64
65 bool gDrawGrid = false;
66 bool gSnapToGrid = false;
67 UIColor gGridColor(255,255,255,32);
68 unsigned long gXGridStep = 10;
69 unsigned long gYGridStep = 10;
70 unsigned long gGridMajorTicks = 10;
71
72 bool gDrawCursor = true;
73
74 const long LineWidth = 1;
75 const long HandleSize = 4;
76 const double MoveThreshold = 5.0;
77 const double SizeThreshold = 3.0;
78
79 extern HWND gObjectTree;
80 extern HWND gMainWindow;
81 extern HWND gTooltip;
82 extern ObjectInspector *gObjectInspector;
83 extern UIDirect3DPrimaryCanvas *gPrimaryDisplay;
84
85 const char *gVisualEditLockPropertyName = "VisualEditLock";
86
87 void AddTooltipFromControlID( HWND TooltipWindow, HWND ParentWindow, UINT ControlID, char *Tooltip );
88 void ClearDefPushButtonLook( HWND hwndDlg, UINT nControlID );
89 void CopySelectedObjectInTreeToClipboard( HWND hTree );
90 void PasteObjectFromClipboard( HWND hTree );
91 void DeleteSelectedObjectInTree( HWND hTree );
92 void EnableHistoryButtons();
93
94
95 // Undo Stuff
96 void RebuildTreeView(UIBaseObject * newObject);
97
98 void recordUndo(UIBaseObject * const object, bool force = false);
99 void recordUndo(UIBaseObject * const object, UILowerString property, UIString oldValue, UIString newValue, bool force = false);
100 void undo();
101
102 typedef std::vector<UIUndo> UndoQueue;
103 UndoQueue s_UndoQueue;
104 bool volatile s_UndoReady = false;
105 bool volatile s_UndoQueueEmpty = true;
106 extern HMENU gMenu;
107 int const MaxUndoSteps = 128;
108 // End Undo Stuff
109
110 enum Align
111 {
112 LeftAlignment,
113 HCenterAlignment,
114 RightAlignment,
115 TopAlignment,
116 VCenterAlignment,
117 BottomAlignment,
118 };
119
120 void UIThread( void * );
121
122 void AlignSelection( Align NewAlignment )
123 {
124 if( gCurrentSelection.size() < 2 )
125 return;
126
127 UIRect ReferenceRect;
128 bool bFirst = true;
129 bool const forceUndo = s_UndoReady;
130
131 for( UIBaseObject::UISmartObjectList::iterator i = gCurrentSelection.begin(); i != gCurrentSelection.end(); ++i )
132 {
133 if( (*i)->IsA( TUIWidget ) )
134 {
135 UIWidget * w = UI_ASOBJECT(UIWidget, *i );
136
137 if( bFirst )
138 {
139 w->GetWorldRect( ReferenceRect );
140 bFirst = false;
141 }
142 else
143 {
144 UIRect ControlRect;
145 UIPoint MovementRequired(0,0);
146
147 w->GetWorldRect( ControlRect );
148
149 switch( NewAlignment )
150 {
151 case LeftAlignment:
152 MovementRequired.x = ReferenceRect.left - ControlRect.left;
153 break;
154 case HCenterAlignment:
155 MovementRequired.x = (ReferenceRect.right + ReferenceRect.left ) / 2 -
156 (ControlRect.right + ControlRect.left ) / 2;
157 break;
158 case RightAlignment:
159 MovementRequired.x = ReferenceRect.right - ControlRect.right;
160 break;
161 case TopAlignment:
162 MovementRequired.y = ReferenceRect.top - ControlRect.top;
163 break;
164 case VCenterAlignment:
165 MovementRequired.y = (ReferenceRect.bottom + ReferenceRect.top ) / 2 -
166 (ControlRect.bottom + ControlRect.top ) / 2;
167 break;
168 case BottomAlignment:
169 MovementRequired.y = ReferenceRect.bottom - ControlRect.bottom;
170 break;
171 }
172
173 recordUndo(w, forceUndo);
174 w->SetLocation( w->GetLocation() + MovementRequired );
175 }
176 }
177 }
178 }
179
180 void SizeSelection( bool MatchWidth, bool MatchHeight )
181 {
182 if( gCurrentSelection.size() < 2 )
183 return;
184
185 UISize ReferenceSize;
186 bool bFirst = true;
187 bool const forceUndo = s_UndoReady;
188
189 for( UIBaseObject::UISmartObjectList::iterator i = gCurrentSelection.begin(); i != gCurrentSelection.end(); ++i )
190 {
191 if( (*i)->IsA( TUIWidget ) )
192 {
193 UIWidget *w = UI_ASOBJECT(UIWidget, *i );
194
195 if( bFirst )
196 {
197 ReferenceSize = w->GetSize();
198 bFirst = false;
199 }
200 else
201 {
202 UISize ControlSize (w->GetSize());
203
204 if( MatchWidth )
205 ControlSize.x = ReferenceSize.x;
206
207 if( MatchHeight )
208 ControlSize.y = ReferenceSize.y;
209
210 recordUndo(w, forceUndo);
211 w->SetSize( ControlSize );
212 }
213 }
214 }
215 }
216
217 void UpdateAlignmentControlEnabledState( void )
218 {
219 BOOL NewState;
220
221 if( gCurrentSelection.size() >=2 )
222 NewState = TRUE;
223 else
224 NewState = FALSE;
225
226 EnableWindow( GetDlgItem(gUIWindow,IDC_ALIGNLEFT), NewState );
227 EnableWindow( GetDlgItem(gUIWindow,IDC_ALIGNHCENTER), NewState );
228 EnableWindow( GetDlgItem(gUIWindow,IDC_ALIGNRIGHT), NewState );
229 EnableWindow( GetDlgItem(gUIWindow,IDC_ALIGNTOP), NewState );
230 EnableWindow( GetDlgItem(gUIWindow,IDC_ALIGNVCENTER), NewState );
231 EnableWindow( GetDlgItem(gUIWindow,IDC_ALIGNBOTTOM), NewState );
232
233 EnableWindow( GetDlgItem(gUIWindow,IDC_SIZEWIDTH), NewState );
234 EnableWindow( GetDlgItem(gUIWindow,IDC_SIZEHEIGHT), NewState );
235 }
236
237 //-----------------------------------------------------------------
238
239 UIWidget *GetObjectInSelection( const UIPoint &PointToTest )
240 {
241 for( UIBaseObject::UISmartObjectList::iterator i = gCurrentSelection.begin(); i != gCurrentSelection.end(); ++i )
242 {
243 if( (*i)->IsA( TUIWidget ) )
244 {
245 UIWidget *w = UI_ASOBJECT(UIWidget, *i);
246
247 UIRect ObjectRect;
248
249 w->GetWorldRect( ObjectRect );
250 if( ObjectRect.ContainsPoint( PointToTest ) )
251 return w;
252 }
253 }
254 return 0;
255 }
256
257 //-----------------------------------------------------------------
258
259
260 bool SelectionContains( const UIBaseObject *ObjectToQuery )
261 {
262 return std::find (gCurrentSelection.begin(),gCurrentSelection.end(), ObjectToQuery) != gCurrentSelection.end ();
263 }
264
265 //-----------------------------------------------------------------
266
267 void SetSelection( UIBaseObject *NewSelection, bool pushHistory )
268 {
269 if( gNoChangeSelection )
270 return;
271
272 WaitForSingleObject( gFrameRenderingMutex, INFINITE );
273
274 const bool skip = !gCurrentSelection.empty () && gCurrentSelection.front () == static_cast<const UIBaseObject *>(NewSelection);
275
276 if (!skip)
277 {
278 gCurrentSelection.clear();
279
280 if( NewSelection)
281 {
282 gCurrentSelection.push_front(UIBaseObject::UIBaseObjectPointer(NewSelection));
283
284 if( NewSelection->IsA( TUIWidget ) )
285 {
286 UIWidget *w = static_cast<UIWidget *>( NewSelection );
287
288 gOriginalLocation = w->GetLocation();
289 gOriginalSize = w->GetSize();
290 }
291
292 if (pushHistory)
293 UIBuilderHistory::pushNode (NewSelection->GetFullPath ());
294
295 EnableHistoryButtons ();
296 }
297 }
298
299 UpdateAlignmentControlEnabledState();
300
301 ReleaseMutex( gFrameRenderingMutex );
302 }
303
304 //-----------------------------------------------------------------
305
306 bool RemoveFromSelection( const UIBaseObject *ObjectToRemove )
307 {
308 bool selectionChanged = false;
309
310 if( gNoChangeSelection )
311 return selectionChanged;
312
313 if( ObjectToRemove )
314 {
315 WaitForSingleObject( gFrameRenderingMutex, INFINITE );
316
317 for( UIBaseObject::UISmartObjectList::iterator i = gCurrentSelection.begin(); i != gCurrentSelection.end(); ++i )
318 {
319 if( *i == ObjectToRemove )
320 {
321 gCurrentSelection.erase( i );
322 selectionChanged = true;
323 break;
324 }
325 }
326 UpdateAlignmentControlEnabledState();
327
328 ReleaseMutex( gFrameRenderingMutex );
329 }
330
331 return selectionChanged;
332 }
333
334 //-----------------------------------------------------------------
335
336 void AddToSelection( UIBaseObject *ObjectToAdd, bool pushHistory )
337 {
338 if( gNoChangeSelection )
339 return;
340
341 if( ObjectToAdd )
342 {
343 WaitForSingleObject( gFrameRenderingMutex, INFINITE );
344
345 RemoveFromSelection( ObjectToAdd );
346 gCurrentSelection.push_front(UIBaseObject::UIBaseObjectPointer(ObjectToAdd));
347 UpdateAlignmentControlEnabledState();
348
349 if (pushHistory)
350 UIBuilderHistory::pushNode (ObjectToAdd->GetFullPath ());
351
352 EnableHistoryButtons ();
353
354 ReleaseMutex( gFrameRenderingMutex );
355 }
356 }
357
358 //-----------------------------------------------------------------
359
360 HTREEITEM GetObjectInTreeControlFromHandle( HWND hTree, HTREEITEM hParentItem, UIBaseObject *o )
361 {
362 HTREEITEM hItem;
363
364 if( hParentItem )
365 hItem = TreeView_GetChild(hTree, hParentItem);
366 else
367 hItem = TreeView_GetRoot(hTree);
368
369 while( hItem )
370 {
371 TVITEM tvi;
372
373 tvi.mask = TVIF_HANDLE | TVIF_PARAM;
374 tvi.hItem = hItem;
375
376 TreeView_GetItem( hTree, &tvi );
377
378 if( reinterpret_cast<UIBaseObject *>( tvi.lParam ) == o )
379 return hItem;
380
381 HTREEITEM hChildFound = GetObjectInTreeControlFromHandle( gObjectTree, hItem, o );
382
383 if( hChildFound )
384 return hChildFound;
385
386 hItem = TreeView_GetNextSibling( gObjectTree, hItem );
387 }
388 return 0;
389 }
390
391 void SizeWindowToCurrentPageSelection( void )
392 {
393 int iCurrentTab = TabCtrl_GetCurSel( gTabControlWindow );
394
395 if( iCurrentTab >= 0 )
396 {
397 TCITEM tci;
398
399 tci.mask = TCIF_PARAM;
400 TabCtrl_GetItem( gTabControlWindow, iCurrentTab, &tci );
401 assert(tci.lParam);
402
403 if( gCurrentlySelectedPage )
404 gCurrentlySelectedPage->ForceVisible( false );
405
406 gCurrentlySelectedPage = reinterpret_cast<UIPage *>( tci.lParam );
407 const UISize & s = gCurrentlySelectedPage->GetSize();
408 gCurrentlySelectedPage->ForceVisible( true );
409
410 SetWindowPos( gCanvasWindow, 0, 0, 0, s.x, s.y, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE );
411
412 RECT rc;
413 rc.left = 0;
414 rc.top = 0;
415 rc.right = s.x;
416 rc.bottom = s.y;
417 TabCtrl_AdjustRect( gTabControlWindow, TRUE, &rc );
418
419 SetWindowPos( gTabControlWindow, 0, 0, 0, rc.right - rc.left, rc.bottom - rc.top, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE );
420
421 rc.left -= gTabControlPadding.left;
422 rc.top -= gTabControlPadding.top;
423 rc.right += gTabControlPadding.right;
424 rc.bottom += gTabControlPadding.bottom;
425
426 AdjustWindowRectEx( &rc, GetWindowLong( gUIWindow, GWL_STYLE ), FALSE, GetWindowLong( gUIWindow, GWL_EXSTYLE ) );
427 SetWindowPos( gUIWindow, 0, 0, 0, rc.right - rc.left, rc.bottom - rc.top, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE );
428 }
429 }
430
431 void RefreshContents( void )
432 {
433 WaitForSingleObject( gFrameRenderingMutex, INFINITE );
434 UIManager::gUIManager().RefreshGraphics();
435 ReleaseMutex( gFrameRenderingMutex );
436 }
437
438 LRESULT CALLBACK CanvasWindowProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
439 {
440 UIMessage UIMsg;
441
442 // Convert lParam to local coordinate space if needed
443 if( gCurrentlySelectedPage )
444 {
445 switch( uMsg )
446 {
447 case WM_MOUSEMOVE:
448 case WM_LBUTTONDOWN:
449 case WM_LBUTTONUP:
450 case WM_MBUTTONDOWN:
451 case WM_MBUTTONUP:
452 case WM_RBUTTONDOWN:
453 case WM_RBUTTONUP:
454 {
455 UIPoint CanvasTranslation = gCurrentlySelectedPage->GetLocation();
456 POINTS MouseCoord = MAKEPOINTS( lParam );
457
458 const long x = MouseCoord.x + CanvasTranslation.x;
459 const long y = MouseCoord.y + CanvasTranslation.y;
460
461 lParam = MAKELPARAM( x, y );
462 break;
463 }
464 }
465 }
466
467 // First stage: Handle ONLY things that the rendering thread is not
468 // in contention for. Return is prefered to break unless you want the
469 // second stage to process the message as well
470 switch( uMsg )
471 {
472 case WM_CREATE:
473 {
474 gFrameRenderingMutex = CreateMutex( 0, 0, 0 );
475 gStopEvent = CreateEvent( 0, 1, 0, 0 );
476
477 if( !InitializeCanvasSystem( hwnd ) )
478 {
479 MessageBox( NULL, "Could not initialize canvas system", NULL, MB_OK );
480 return -1;
481 }
482
483 RECT rc;
484
485 // Create the primary display before we invoke the loader so that the global gPrimaryDisplay
486 // is set up - so that we can make the textures with the correct pixelformat.
487 GetClientRect( hwnd, &rc );
488 gPrimaryDisplay = new UIDirect3DPrimaryCanvas( UISize( rc.right, rc.bottom ), hwnd, false );
489 gPrimaryDisplay->ShowShaders (g_showShaders);
490 gPrimaryDisplay->Attach( 0 );
491
492 UIManager::gUIManager().SetScriptEngine( new UIScriptEngine );
493
494 gEngineThread = (HANDLE)_beginthread( UIThread, 0, 0 );
495 return DefWindowProc( hwnd, uMsg, wParam, lParam );
496 }
497
498 case WM_SIZE:
499 WaitForSingleObject( gFrameRenderingMutex, INFINITE );
500 gPrimaryDisplay->SetSize( UISize( LOWORD(lParam), HIWORD(lParam) ) );
501 ReleaseMutex( gFrameRenderingMutex );
502
503 InvalidateRect( hwnd, NULL, FALSE );
504 return DefWindowProc( hwnd, uMsg, wParam, lParam );
505
506 case WM_PAINT:
507 {
508 PAINTSTRUCT ps;
509
510 BeginPaint( hwnd, &ps );
511 EndPaint( hwnd, &ps );
512 return 0;
513 }
514
515 case WM_DESTROY:
516 {
517 SetEvent( gStopEvent );
518 WaitForSingleObject( gEngineThread, INFINITE );
519 ShutdownCanvasSystem( hwnd );
520
521 CloseHandle( gFrameRenderingMutex );
522 CloseHandle( gStopEvent );
523
524 gFrameRenderingMutex = 0;
525 gStopEvent = 0;
526
527 delete UIManager::gUIManager().GetScriptEngine();
528 UIManager::gUIManager().SetScriptEngine(0);
529
530 return DefWindowProc( hwnd, uMsg, wParam, lParam );
531 }
532
533 case WM_LBUTTONDOWN:
534 case WM_MBUTTONDOWN:
535 case WM_RBUTTONDOWN:
536 SetCapture( hwnd );
537 break; // Pass through to second stage
538 case WM_LBUTTONDBLCLK:
539 case WM_MBUTTONDBLCLK:
540 case WM_RBUTTONDBLCLK:
541 {
542 if (gInVisualEditingMode)
543 {
544 UIPage * const RootPage = UIManager::gUIManager ().GetRootPage ();
545
546 if (RootPage)
547 {
548 UIWidget * ClickedWidget = RootPage->GetWidgetFromPoint( gMouseDownPoint, true );
549
550 if (!ClickedWidget)
551 ClickedWidget = RootPage->GetWidgetFromPoint( gMouseDownPoint, false );
552 else
553 {
554 const UIPoint & pt = gMouseDownPoint - ClickedWidget->GetWorldLocation ();
555
556 UIWidget * const ClickedWidgetNoInput = ClickedWidget->GetWidgetFromPoint( pt, false );
557
558 UIBaseObject * p = ClickedWidgetNoInput;
559
560 while (p)
561 {
562 if (p == ClickedWidget)
563 {
564 ClickedWidget = ClickedWidgetNoInput;
565 break;
566 }
567
568 p = p->GetParent ();
569 }
570 }
571
572 //-- don't allow selection of transients
573 while (ClickedWidget && ClickedWidget->IsTransient ())
574 ClickedWidget = ClickedWidget->GetParentWidget ();
575
576 UIWidget * const ObjectInSelection = GetObjectInSelection( gMouseDownPoint );
577
578 // Drill down
579 while( ClickedWidget && (ClickedWidget->GetParent() != ObjectInSelection) )
580 {
581 UIWidget * const SearchObject = ClickedWidget->GetParentWidget ();
582
583 if( SearchObject )
584 {
585 if( ClickedWidget != SearchObject->GetParent() )
586 ClickedWidget = SearchObject;
587 }
588 else
589 ClickedWidget = 0;
590 }
591
592 if (ClickedWidget)
593 {
594 SetSelection( ClickedWidget, true);
595
596 HTREEITEM hItemToSelect = GetObjectInTreeControlFromHandle( gObjectTree, 0, ClickedWidget );
597
598 gNoChangeSelection = true;
599 TreeView_SelectItem( gObjectTree, hItemToSelect );
600 gNoChangeSelection = false;
601 }
602 }
603 }
604 }
605
606 break; // Pass through to second stage
607
608 case WM_LBUTTONUP:
609 case WM_MBUTTONUP:
610 case WM_RBUTTONUP:
611 if( GetCapture() == hwnd )
612 ReleaseCapture();
613
614 break; // Pass through to second stage
615
616 case WM_KEYDOWN:
617 case WM_KEYUP:
618 case WM_CHAR:
619 if( gInVisualEditingMode )
620 {
621 RECT rcClient;
622 POINT CursorPosition;
623
624 GetCursorPos( &CursorPosition );
625 GetWindowRect( hwnd, &rcClient );
626
627 if( PtInRect( &rcClient, CursorPosition ) )
628 {
629 HCURSOR hCursor;
630
631 if( GetAsyncKeyState( VK_SHIFT ) & 0x80000000 )
632 hCursor = LoadCursor( GetModuleHandle(0), MAKEINTRESOURCE(IDC_ADDTOSEL) );
633 else if( GetAsyncKeyState( VK_CONTROL ) & 0x80000000 )
634 hCursor = LoadCursor( GetModuleHandle(0), MAKEINTRESOURCE(IDC_REMOVEFROMSEL) );
635 else
636 hCursor = LoadCursor( 0, IDC_ARROW );
637
638 SetCursor( hCursor );
639 }
640 }
641 break; // Pass through to second stage
642
643 case WM_MOUSEMOVE:
644 {
645 POINTS MousePoint = MAKEPOINTS( lParam );
646 HCURSOR hCursor = 0;
647
648 if( gInVisualEditingMode )
649 {
650 UIWidget * const SelectedObject = GetObjectInSelection( UIPoint( MousePoint.x, MousePoint.y ) );
651
652 if( !gButtonDown )
653 {
654 gSizeUp = false;
655 gSizeDown = false;
656 gSizeLeft = false;
657 gSizeRight = false;
658
659 if( SelectedObject )
660 {
661 UIRect HighlightRect;
662 long HHandleLoc;
663 long VHandleLoc;
664
665 SelectedObject->GetWorldRect( HighlightRect );
666
667 HHandleLoc = (HighlightRect.bottom + HighlightRect.top - HandleSize) / 2;
668 VHandleLoc = (HighlightRect.right + HighlightRect.left - HandleSize) / 2;
669
670 // Ordered so when very small the control will prefer to size down and to the right
671 if( MousePoint.x > HighlightRect.right - HandleSize )
672 {
673 if( (MousePoint.y <= HighlightRect.top + HandleSize ) ||
674 (MousePoint.y >= HighlightRect.bottom - HandleSize ) ||
675 (MousePoint.y >= HHandleLoc && MousePoint.y <= HHandleLoc + HandleSize) )
676 {
677 gSizeRight = true;
678 }
679 }
680 else if( MousePoint.x < HighlightRect.left + HandleSize )
681 {
682 if( (MousePoint.y <= HighlightRect.top + HandleSize ) ||
683 (MousePoint.y >= HighlightRect.bottom - HandleSize ) ||
684 (MousePoint.y >= HHandleLoc && MousePoint.y <= HHandleLoc + HandleSize) )
685 {
686 gSizeLeft = true;
687 }
688 }
689
690 if( MousePoint.y > HighlightRect.bottom - HandleSize )
691 {
692 if( (MousePoint.x <= HighlightRect.left + HandleSize ) ||
693 (MousePoint.x >= HighlightRect.right - HandleSize ) ||
694 (MousePoint.x >= VHandleLoc && MousePoint.x <= VHandleLoc + HandleSize) )
695 {
696 gSizeDown = true;
697 }
698 }
699 else if( MousePoint.y < HighlightRect.top + HandleSize )
700 {
701 if( (MousePoint.x <= HighlightRect.left + HandleSize ) ||
702 (MousePoint.x >= HighlightRect.right - HandleSize ) ||
703 (MousePoint.x >= VHandleLoc && MousePoint.x <= VHandleLoc + HandleSize) )
704 {
705 gSizeUp = true;
706 }
707 }
708 }
709 }
710
711 if( gSizeUp )
712 {
713 if( gSizeLeft )
714 hCursor = LoadCursor( 0, IDC_SIZENWSE );
715 else if( gSizeRight )
716 hCursor = LoadCursor( 0, IDC_SIZENESW );
717 else
718 hCursor = LoadCursor( 0, IDC_SIZENS );
719 }
720 else if( gSizeDown )
721 {
722 if( gSizeLeft )
723 hCursor = LoadCursor( 0, IDC_SIZENESW );
724 else if( gSizeRight )
725 hCursor = LoadCursor( 0, IDC_SIZENWSE );
726 else
727 hCursor = LoadCursor( 0, IDC_SIZENS );
728 }
729 else if( gSizeLeft || gSizeRight )
730 hCursor = LoadCursor( 0, IDC_SIZEWE );
731 }
732
733 if( !hCursor )
734 {
735 hCursor = LoadCursor( 0, IDC_ARROW );
736
737 if( gInVisualEditingMode )
738 {
739 if( wParam & MK_SHIFT )
740 hCursor = LoadCursor( GetModuleHandle(0), MAKEINTRESOURCE(IDC_ADDTOSEL) );
741 else if( wParam & MK_CONTROL )
742 hCursor = LoadCursor( GetModuleHandle(0), MAKEINTRESOURCE(IDC_REMOVEFROMSEL) );
743 }
744 }
745
746 if( gInVisualEditingMode || !gDrawCursor )
747 SetCursor( hCursor );
748 else
749 SetCursor( 0 );
750
751 break; // Pass through to second stage
752 }
753
754 case WM_GETDLGCODE:
755 return DLGC_WANTALLKEYS;
756
757 case WM_MOUSEACTIVATE:
758 SetFocus( hwnd );
759 return MA_ACTIVATE;
760
761 default:
762 return DefWindowProc( hwnd, uMsg, wParam, lParam );
763 }
764
765 // Second stage, handle things that the rendering thread
766 // is in contention for.
767 WaitForSingleObject( gFrameRenderingMutex, INFINITE );
768
769 if( !gInVisualEditingMode )
770 {
771 if( UIMsg.CreateFromWindowsMessage( uMsg, wParam, lParam ) )
772 UIManager::gUIManager().ProcessMessage( UIMsg );
773 }
774 else if( UIManager::gUIManager().GetRootPage() )
775 {
776 UIPage *RootPage = UIManager::gUIManager().GetRootPage();
777
778 switch( uMsg )
779 {
780 case WM_KEYUP:
781 {
782 s_UndoReady = true;
783
784 switch (wParam)
785 {
786 case VK_DELETE:
787
788 SendMessage (gMainWindow, WM_COMMAND, ID_EDIT_DELETE, 0);
789 break;
790 case 'C':
791 case 'c':
792 if ( GetAsyncKeyState( VK_CONTROL ) & 0x80000000 )
793 CopySelectedObjectInTreeToClipboard( gObjectTree );
794 break;
795 case 'v':
796 case 'V':
797 if ( GetAsyncKeyState( VK_CONTROL ) & 0x80000000 )
798 PasteObjectFromClipboard( gObjectTree );
799 break;
800 case 'x':
801 case 'X':
802 if ( GetAsyncKeyState( VK_CONTROL ) & 0x80000000 )
803 {
804 CopySelectedObjectInTreeToClipboard( gObjectTree );
805 DeleteSelectedObjectInTree( gObjectTree );
806 }
807 break;
808 default:
809 s_UndoReady = false;
810 }
811 }
812
813 break;
814 case WM_KEYDOWN:
815 {
816 s_UndoReady = true;
817
818 UIPoint Nudge(0,0);
819
820 switch( wParam )
821 {
822 case VK_UP:
823 Nudge.y = -1;
824 break;
825 case VK_DOWN:
826 Nudge.y = 1;
827 break;
828 case VK_LEFT:
829 Nudge.x = -1;
830 break;
831 case VK_RIGHT:
832 Nudge.x = 1;
833 break;
834 default:
835 s_UndoReady = false;
836 }
837
838 bool const forceUndo = s_UndoReady;
839 for( UIBaseObject::UISmartObjectList::iterator i = gCurrentSelection.begin(); i != gCurrentSelection.end(); ++i )
840 {
841 if( (*i)->IsA( TUIWidget ) )
842 {
843 UIWidget * w = UI_ASOBJECT(UIWidget, *i );
844
845 if( w != RootPage )
846 {
847 recordUndo(w, forceUndo);
848 w->SetLocation( w->GetLocation() + Nudge );
849 }
850 }
851 }
852
853 break;
854 }
855
856 case WM_MOUSEMOVE:
857 {
858 if( gButtonDown )
859 {
860 POINTS CurrentMousePoint = MAKEPOINTS( lParam );
861 bool const forceUndo = s_UndoReady;
862
863 if( gMoving )
864 {
865 UIPoint GroupMovement(0,0);
866 bool bFirst = true;
867
868 for( UIBaseObject::UISmartObjectList::iterator i = gCurrentSelection.begin(); i != gCurrentSelection.end(); ++i )
869 {
870 if( !(*i)->IsA( TUIWidget ) )
871 continue;
872
873 UIWidget * w = UI_ASOBJECT(UIWidget, *i );
874
875 if( (w == RootPage) || w->HasProperty( UILowerString (gVisualEditLockPropertyName )) )
876 continue;
877
878 if( !bFirst )
879 {
880 recordUndo(w, forceUndo);
881 w->SetLocation( w->GetLocation() + GroupMovement );
882 continue;
883 }
884
885
886 UIPoint NewLocation;
887
888 UIPoint LocationDiff (CurrentMousePoint.x - gMouseDownPoint.x,
889 CurrentMousePoint.y - gMouseDownPoint.y);
890
891 NewLocation.x = gOriginalLocation.x + LocationDiff.x;
892 NewLocation.y = gOriginalLocation.y + LocationDiff.y;
893
894 const UIPoint OldLocation (w->GetLocation());
895
896 if( gSnapToGrid )
897 {
898 UIRect SnapRect;
899
900 w->GetWorldRect( SnapRect );
901
902 SnapRect.left += LocationDiff.x;
903 SnapRect.top += LocationDiff.y;
904 SnapRect.right += LocationDiff.x;
905 SnapRect.bottom += LocationDiff.y;
906
907 SnapRect.left %= gXGridStep;
908 SnapRect.top %= gYGridStep;
909
910 //-- jww hack to prevent jumping
911
912 NewLocation.x -= SnapRect.left;
913 NewLocation.y -= SnapRect.top;
914
915 /*
916 if( SnapRect.left < halfStepX )
917 NewLocation.x -= SnapRect.left;
918 else
919 NewLocation.x += gXGridStep - SnapRect.left;
920
921 if( SnapRect.top < halfStepY )
922 NewLocation.y -= SnapRect.top;
923 else
924 NewLocation.y += gYGridStep - SnapRect.top;
925 */
926 }
927
928 recordUndo(w, forceUndo);
929 w->SetLocation( NewLocation );
930
931 GroupMovement = NewLocation - OldLocation;
932 bFirst = false;
933 }
934
935 }
936 else if( gSizing )
937 {
938 UIPoint GroupMoveAmount(0,0);
939 UISize GroupSizeAmount(0,0);
940 bool bFirst = true;
941
942 for( UIBaseObject::UISmartObjectList::iterator i = gCurrentSelection.begin(); i != gCurrentSelection.end(); ++i )
943 {
944 if( !(*i)->IsA( TUIWidget ) )
945 continue;
946
947 UIWidget * w = UI_ASOBJECT(UIWidget, *i );
948
949 if( w->HasProperty( UILowerString (gVisualEditLockPropertyName ) ))
950 continue;
951
952 if( !bFirst )
953 {
954 recordUndo(w, forceUndo);
955 w->SetLocation( w->GetLocation() + GroupMoveAmount );
956 w->SetSize( w->GetSize() + GroupSizeAmount );
957 continue;
958 }
959
960 UISize NewSize;
961 UIPoint NewLocation;
962
963 const UIPoint OldLocation (w->GetLocation());
964 const UISize OldSize (w->GetSize());
965
966 if( gSizeLeft )
967 {
968 NewSize.x = gOriginalSize.x + (gMouseDownPoint.x - CurrentMousePoint.x);
969 NewLocation.x = gOriginalLocation.x - (gMouseDownPoint.x - CurrentMousePoint.x);
970 }
971 else if( gSizeRight )
972 {
973 NewSize.x = gOriginalSize.x - (gMouseDownPoint.x - CurrentMousePoint.x);
974 NewLocation.x = gOriginalLocation.x;
975 }
976 else
977 {
978 NewSize.x = gOriginalSize.x;
979 NewLocation.x = gOriginalLocation.x;
980 }
981
982 if( gSizeUp )
983 {
984 NewSize.y = gOriginalSize.y + (gMouseDownPoint.y - CurrentMousePoint.y);
985 NewLocation.y = gOriginalLocation.y - (gMouseDownPoint.y - CurrentMousePoint.y);
986 }
987 else if( gSizeDown )
988 {
989 NewSize.y = gOriginalSize.y - (gMouseDownPoint.y - CurrentMousePoint.y);
990 NewLocation.y = gOriginalLocation.y;
991 }
992 else
993 {
994 NewSize.y = gOriginalSize.y;
995 NewLocation.y = gOriginalLocation.y;
996 }
997
998 if( gSnapToGrid )
999 {
1000 UIRect SnapRect;
1001
1002 if (w->GetParent () && w->GetParent ()->IsA (TUIWidget))
1003 {
1004 UIWidget * parentalWidget = static_cast<UIWidget *> (w->GetParent ());
1005
1006 UIPoint parentalWorldLoc;
1007 parentalWidget->GetWorldLocation (parentalWorldLoc);
1008
1009 SnapRect.left = parentalWorldLoc.x;
1010 SnapRect.top = parentalWorldLoc.y;
1011 }
1012
1013 SnapRect.left += NewLocation.x;
1014 SnapRect.top += NewLocation.y;
1015
1016 SnapRect.right = SnapRect.left + NewSize.x;
1017 SnapRect.bottom = SnapRect.top + NewSize.y;
1018
1019 SnapRect.left %= gXGridStep;
1020 SnapRect.top %= gYGridStep;
1021 SnapRect.right %= gXGridStep;
1022 SnapRect.bottom %= gYGridStep;
1023
1024 if( NewLocation.x != gOriginalLocation.x )
1025 {
1026 if( (unsigned long)SnapRect.left < gXGridStep / 2 )
1027 {
1028 NewLocation.x -= SnapRect.left;
1029 NewSize.x += SnapRect.left;
1030 }
1031 else
1032 {
1033 NewLocation.x += gXGridStep - SnapRect.left;
1034 NewSize.x -= gXGridStep - SnapRect.left;
1035 }
1036 }
1037 else if( NewSize.x != gOriginalSize.x )
1038 {
1039 if( (unsigned long)SnapRect.right < gXGridStep / 2 )
1040 NewSize.x -= SnapRect.right;
1041 else
1042 NewSize.x += gXGridStep - SnapRect.right;
1043 }
1044
1045 if( NewLocation.y != gOriginalLocation.y )
1046 {
1047 if( (unsigned long)SnapRect.top < gYGridStep / 2 )
1048 {
1049 NewLocation.y -= SnapRect.top;
1050 NewSize.y += SnapRect.top;
1051 }
1052 else
1053 {
1054 NewLocation.y += gYGridStep - SnapRect.top;
1055 NewSize.y -= gYGridStep - SnapRect.top;
1056 }
1057 }
1058 else if( NewSize.y != gOriginalSize.y )
1059 {
1060 if( (unsigned long)SnapRect.bottom < gYGridStep / 2 )
1061 NewSize.y -= SnapRect.bottom;
1062 else
1063 NewSize.y += gYGridStep - SnapRect.bottom;
1064 }
1065 }
1066
1067 if( NewSize.x < 1 )
1068 NewSize.x = 1;
1069 if( NewSize.y < 1 )
1070 NewSize.y = 1;
1071
1072 recordUndo(w, forceUndo);
1073 w->SetSize( NewSize );
1074 w->SetLocation( NewLocation );
1075
1076 GroupMoveAmount = NewLocation - OldLocation;
1077 GroupSizeAmount = NewSize - OldSize;
1078 bFirst = false;
1079
1080 }
1081
1082 }
1083 else
1084 {
1085 int dx = CurrentMousePoint.x - gMouseDownPoint.x;
1086 int dy = CurrentMousePoint.y - gMouseDownPoint.y;
1087 double d = sqrt( (double)(dx * dx + dy * dy) );
1088
1089 if( gSizeUp || gSizeDown || gSizeLeft || gSizeRight )
1090 {
1091 if( d > SizeThreshold )
1092 gSizing = true;
1093 }
1094 else if( d > MoveThreshold )
1095 gMoving = true;
1096 }
1097 }
1098 break;
1099 }
1100 case WM_LBUTTONDOWN:
1101 case WM_MBUTTONDOWN:
1102 case WM_RBUTTONDOWN:
1103 {
1104 gMouseDownPoint.x = GET_X_LPARAM( lParam );
1105 gMouseDownPoint.y = GET_Y_LPARAM( lParam );
1106
1107 UIWidget * ClickedWidget = 0;
1108
1109 ClickedWidget = RootPage->GetWidgetFromPoint( gMouseDownPoint, true);
1110
1111 if (!ClickedWidget)
1112 ClickedWidget = RootPage->GetWidgetFromPoint( gMouseDownPoint, false );
1113
1114 //-- don't allow selection of transients
1115 while (ClickedWidget && (ClickedWidget->IsTransient ()))
1116 {
1117 if (ClickedWidget->GetParent ()->IsA (TUIWidget))
1118 ClickedWidget = static_cast<UIWidget *>(ClickedWidget->GetParent ());
1119 }
1120
1121 gButtonDown = true;
1122 gMoving = false;
1123 gSizing = false;
1124
1125 if( ClickedWidget )
1126 {
1127 bool ResetMoveSize = true;
1128
1129 if( wParam & MK_SHIFT )
1130 AddToSelection( ClickedWidget, true );
1131 else if( wParam & MK_CONTROL )
1132 {
1133 RemoveFromSelection( ClickedWidget );
1134 ResetMoveSize = false;
1135 }
1136 else
1137 {
1138 UIWidget *ObjectInSelection = GetObjectInSelection( gMouseDownPoint );
1139 const bool theSelectionContains = SelectionContains( ClickedWidget );
1140
1141 if( ObjectInSelection && !theSelectionContains)
1142 {
1143 /*
1144 UIBaseObject * p = ObjectInSelection;
1145
1146 while (p)
1147 {
1148 if (p == ClickedWidget)
1149 break;
1150
1151 p = p->GetParent ();
1152 }
1153
1154 if (!p)
1155 SetSelection( ClickedWidget, true );
1156 else
1157 */
1158 ResetMoveSize = false;
1159 }
1160 else
1161 {
1162 if(theSelectionContains)
1163 {
1164 // Move clicked item to the start of the selection
1165 RemoveFromSelection( ClickedWidget );
1166 AddToSelection( ClickedWidget, true );
1167 }
1168 else
1169 SetSelection( ClickedWidget, true );
1170 }
1171 }
1172
1173 if( ResetMoveSize && ClickedWidget )
1174 {
1175 gOriginalSize = ClickedWidget->GetSize();
1176 gOriginalLocation = ClickedWidget->GetLocation();
1177 HTREEITEM hItemToSelect = GetObjectInTreeControlFromHandle( gObjectTree, 0, ClickedWidget );
1178
1179 gNoChangeSelection = true;
1180 TreeView_SelectItem( gObjectTree, hItemToSelect );
1181 gNoChangeSelection = false;
1182 }
1183
1184 else
1185 {
1186 //-- reset the original location and size - jww
1187
1188 for( UIBaseObject::UISmartObjectList::iterator i = gCurrentSelection.begin(); i != gCurrentSelection.end(); ++i )
1189 {
1190 if( !(*i)->IsA( TUIWidget ) )
1191 continue;
1192
1193 UIWidget * w = UI_ASOBJECT(UIWidget, *i );
1194 gOriginalSize = w->GetSize ();
1195 gOriginalLocation = w->GetLocation ();
1196 break;
1197 }
1198 }
1199
1200 }
1201
1202 break;
1203 }
1204
1205 case WM_LBUTTONUP:
1206 case WM_MBUTTONUP:
1207 case WM_RBUTTONUP:
1208 {
1209 s_UndoReady = true;
1210 gButtonDown = false;
1211 break;
1212 }
1213 }
1214 }
1215
1216 ReleaseMutex( gFrameRenderingMutex );
1217 return DefWindowProc( hwnd, uMsg, wParam, lParam );
1218 }
1219
1220 void UIThread( void * )
1221 {
1222 UIManager &GUIManager = UIManager::gUIManager();
1223
1224 while( WaitForSingleObject( gStopEvent, 0 ) == WAIT_TIMEOUT )
1225 {
1226 if( WaitForSingleObject( gFrameRenderingMutex, 100 ) == WAIT_OBJECT_0 )
1227 {
1228 UIPage *RootPage = GUIManager.GetRootPage();
1229
1230 if( !gInVisualEditingMode )
1231 GUIManager.SendHeartbeats();
1232
1233 if( !RootPage || !IsWindowVisible( gPrimaryDisplay->GetWindow() ) )
1234 {
1235 ReleaseMutex( gFrameRenderingMutex );
1236 Sleep( 100 );
1237 continue;
1238 }
1239
1240 if( gPrimaryDisplay->BeginRendering() )
1241 {
1242 UIPoint CanvasTranslation(0,0);
1243
1244 gPrimaryDisplay->ClearTo( UIColor( 0, 0, 0 ), UIRect (0, 0, gPrimaryDisplay->GetWidth (), gPrimaryDisplay->GetHeight () ));
1245 gPrimaryDisplay->PushState();
1246
1247 if( gCurrentlySelectedPage )
1248 {
1249 CanvasTranslation = -gCurrentlySelectedPage->GetLocation();
1250 gPrimaryDisplay->Translate( CanvasTranslation );
1251 }
1252
1253 GUIManager.DrawCursor( gDrawCursor );
1254 GUIManager.Render( *gPrimaryDisplay );
1255
1256 if( gDrawGrid )
1257 {
1258 int x;
1259 int y;
1260 int linecount;
1261 int width = RootPage->GetWidth();
1262 int height = RootPage->GetHeight();
1263
1264 float LineOpacity = gGridColor.a / 255.0f;
1265 float ThickLineOpacity = 2.0f * LineOpacity;
1266
1267 gPrimaryDisplay->SetOpacity( LineOpacity );
1268
1269 for( x = 0, linecount = 0; x <= width; x += gXGridStep, ++linecount )
1270 {
1271 if( (linecount % gGridMajorTicks) == 0 )
1272 {
1273 gPrimaryDisplay->SetOpacity( ThickLineOpacity );
1274 gPrimaryDisplay->ClearTo( gGridColor, UIRect( x, CanvasTranslation.y, x+1, height ) );
1275 gPrimaryDisplay->SetOpacity( LineOpacity );
1276 }
1277 else
1278 gPrimaryDisplay->ClearTo( gGridColor, UIRect( x, CanvasTranslation.y, x+1, height ) );
1279 }
1280
1281 for( y = 0, linecount = 0; y <= height; y += gYGridStep, ++linecount )
1282 {
1283 if( (linecount % gGridMajorTicks) == 0 )
1284 {
1285 gPrimaryDisplay->SetOpacity( ThickLineOpacity );
1286 gPrimaryDisplay->ClearTo( gGridColor, UIRect( CanvasTranslation.x, y, width, y+1 ) );
1287 gPrimaryDisplay->SetOpacity( LineOpacity );
1288 }
1289 else
1290 gPrimaryDisplay->ClearTo( gGridColor, UIRect( CanvasTranslation.x, y, width, y+1 ) );
1291 }
1292 }
1293
1294 if( gDrawHighlightRect )
1295 {
1296 for( UIBaseObject::UISmartObjectList::iterator i = gCurrentSelection.begin(); i != gCurrentSelection.end(); ++i )
1297 {
1298 if( !(*i)->IsA( TUIWidget ) )
1299 continue;
1300
1301 UIWidget * w = UI_ASOBJECT(UIWidget, *i );
1302 UIRect HighlightRect;
1303
1304 w->GetWorldRect( HighlightRect );
1305
1306 gPrimaryDisplay->SetOpacity( gHighlightFillColor.a / 255.0f );
1307
1308 gPrimaryDisplay->ClearTo( gHighlightFillColor, UIRect( HighlightRect.left, HighlightRect.top,
1309 HighlightRect.right, HighlightRect.bottom ) );
1310
1311 gPrimaryDisplay->SetOpacity( gHighlightOutlineColor.a / 255.0f );
1312
1313 gPrimaryDisplay->ClearTo( gHighlightOutlineColor, UIRect( HighlightRect.left, HighlightRect.top,
1314 HighlightRect.left + LineWidth, HighlightRect.bottom ) );
1315
1316 gPrimaryDisplay->ClearTo( gHighlightOutlineColor, UIRect( HighlightRect.right - LineWidth, HighlightRect.top,
1317 HighlightRect.right, HighlightRect.bottom ) );
1318
1319 gPrimaryDisplay->ClearTo( gHighlightOutlineColor, UIRect( HighlightRect.left + LineWidth, HighlightRect.top,
1320 HighlightRect.right - LineWidth, HighlightRect.top + LineWidth ) );
1321
1322 gPrimaryDisplay->ClearTo( gHighlightOutlineColor, UIRect( HighlightRect.left + LineWidth, HighlightRect.bottom - LineWidth,
1323 HighlightRect.right - LineWidth, HighlightRect.bottom ) );
1324
1325 if( gInVisualEditingMode && (HighlightRect.Height() >= 8) && (HighlightRect.Width() >= 8) && !w->HasProperty(UILowerString (gVisualEditLockPropertyName) ))
1326 {
1327 gPrimaryDisplay->ClearTo( gHighlightOutlineColor, UIRect( HighlightRect.left + LineWidth, HighlightRect.top + LineWidth,
1328 HighlightRect.left + HandleSize, HighlightRect.top + HandleSize ) );
1329
1330 gPrimaryDisplay->ClearTo( gHighlightOutlineColor, UIRect( HighlightRect.right - HandleSize, HighlightRect.top + LineWidth,
1331 HighlightRect.right - LineWidth, HighlightRect.top + HandleSize ) );
1332
1333 gPrimaryDisplay->ClearTo( gHighlightOutlineColor, UIRect( HighlightRect.left + LineWidth, HighlightRect.bottom - HandleSize,
1334 HighlightRect.left + HandleSize, HighlightRect.bottom - LineWidth ) );
1335
1336 gPrimaryDisplay->ClearTo( gHighlightOutlineColor, UIRect( HighlightRect.right - HandleSize, HighlightRect.bottom - HandleSize,
1337 HighlightRect.right - LineWidth, HighlightRect.bottom - LineWidth ) );
1338
1339 if( HighlightRect.Height() >= 16 && HighlightRect.Width() >= 16 )
1340 {
1341 long HHandleLoc, VHandleLoc;
1342
1343 HHandleLoc = (HighlightRect.bottom + HighlightRect.top - HandleSize) / 2;
1344 VHandleLoc = (HighlightRect.right + HighlightRect.left - HandleSize) / 2;
1345
1346 gPrimaryDisplay->ClearTo( gHighlightOutlineColor, UIRect( HighlightRect.left + LineWidth, HHandleLoc,
1347 HighlightRect.left + HandleSize, HHandleLoc + HandleSize ) );
1348
1349 gPrimaryDisplay->ClearTo( gHighlightOutlineColor, UIRect( HighlightRect.right - HandleSize, HHandleLoc,
1350 HighlightRect.right - LineWidth, HHandleLoc + HandleSize ) );
1351
1352 gPrimaryDisplay->ClearTo( gHighlightOutlineColor, UIRect( VHandleLoc, HighlightRect.top + LineWidth,
1353 VHandleLoc + HandleSize, HighlightRect.top + HandleSize ) );
1354
1355 gPrimaryDisplay->ClearTo( gHighlightOutlineColor, UIRect( VHandleLoc, HighlightRect.bottom - HandleSize,
1356 VHandleLoc + HandleSize, HighlightRect.bottom - LineWidth ) );
1357 }
1358 }
1359 }
1360 }
1361
1362 gPrimaryDisplay->PopState();
1363 gPrimaryDisplay->EndRendering();
1364 gPrimaryDisplay->Flip();
1365
1366 gTriangleCount = gPrimaryDisplay->GetTriangleCount();
1367 gFlushCount = gPrimaryDisplay->GetFlushCount();
1368
1369 ++gFrameCount;
1370 }
1371 ReleaseMutex( gFrameRenderingMutex );
1372
1373 if( gLimitFrameRate && !(gFrameCount % 2) )
1374 Sleep(18);
1375 }
1376 }
1377 }
1378
1379 void InitializeButtonGraphic( HWND hwndDlg, UINT ControlID, UINT ResourceID )
1380 {
1381 SendDlgItemMessage( hwndDlg, ControlID, BM_SETIMAGE, IMAGE_ICON,
1382 (LPARAM)LoadImage( GetModuleHandle(0), MAKEINTRESOURCE(ResourceID), IMAGE_ICON, 16, 16, 0 ) );
1383 }
1384
1385 void InitializeButtonGraphicAndState( HWND hwndDlg, UINT ControlID, UINT ResourceID, bool bPressed )
1386 {
1387 InitializeButtonGraphic( hwndDlg, ControlID, ResourceID );
1388
1389 if( bPressed )
1390 CheckDlgButton( hwndDlg, ControlID, BST_CHECKED );
1391 else
1392 CheckDlgButton( hwndDlg, ControlID, BST_UNCHECKED );
1393 }
1394
1395 BOOL CALLBACK UIWindowDlgProc( HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam )
1396 {
1397 switch( uMsg )
1398 {
1399 case WM_INITDIALOG:
1400 {
1401 WNDCLASSEX wc = { sizeof( wc ) };
1402 RECT rcClient;
1403 RECT rcCanvas;
1404 RECT rcCanvasClient;
1405
1406 gUIWindow = hwndDlg;
1407
1408 wc.lpfnWndProc = CanvasWindowProc;
1409 wc.hInstance = GetModuleHandle(0);
1410 wc.lpszMenuName = MAKEINTRESOURCE( IDR_MAIN_MENU );
1411 wc.hCursor = NULL;
1412 wc.lpszClassName = "UICanvas";
1413 wc.style |= CS_DBLCLKS;
1414
1415 if( !RegisterClassEx( &wc ) )
1416 return 1;
1417
1418 gTabControlWindow = GetDlgItem( hwndDlg, IDC_ROOTPAGE );
1419
1420 GetClientRect( gTabControlWindow, &rcCanvas );
1421 MapWindowPoints( gTabControlWindow, hwndDlg, (LPPOINT)&rcCanvas, 2 );
1422 CopyRect( &rcCanvasClient, &rcCanvas );
1423
1424 TCITEM tci;
1425 tci.mask = TCIF_TEXT;
1426 tci.pszText = "Size Test";
1427 TabCtrl_InsertItem( gTabControlWindow, 0, &tci );
1428 TabCtrl_AdjustRect( gTabControlWindow, FALSE, &rcCanvasClient );
1429 TabCtrl_DeleteAllItems( gTabControlWindow );
1430
1431 GetClientRect( hwndDlg, &rcClient );
1432
1433 gTabControlPadding.left = rcCanvas.left;
1434 gTabControlPadding.top = rcCanvas.top;
1435 gTabControlPadding.right = rcClient.right - rcCanvas.right;
1436 gTabControlPadding.bottom = rcClient.bottom - rcCanvas.bottom;
1437
1438 gCanvasWindow = CreateWindow( "UICanvas", "UICanvas", WS_CHILD | WS_VISIBLE | WS_TABSTOP,
1439 rcCanvasClient.left, rcCanvasClient.top, rcCanvas.right, rcCanvas.bottom, hwndDlg,
1440 (HMENU)100, GetModuleHandle(0), NULL );
1441
1442 InitializeButtonGraphicAndState( hwndDlg, IDC_PLAY, IDI_PLAY, !gInVisualEditingMode );
1443 AddTooltipFromControlID( gTooltip, hwndDlg, IDC_PLAY, "Run / Stop User Interface" );
1444
1445 InitializeButtonGraphic( hwndDlg, IDC_REFRESH, IDI_REFRESH );
1446 AddTooltipFromControlID( gTooltip, hwndDlg, IDC_REFRESH, "Refresh" );
1447
1448 InitializeButtonGraphicAndState( hwndDlg, IDC_DRAWCURSOR, IDI_CURSOR, gDrawCursor );
1449 AddTooltipFromControlID( gTooltip, hwndDlg, IDC_DRAWCURSOR, "Draw Cursor" );
1450
1451 InitializeButtonGraphicAndState( hwndDlg, IDC_DRAWHIGHLIGHT, IDI_DRAWHIGHLIGHT, gDrawHighlightRect );
1452 AddTooltipFromControlID( gTooltip, hwndDlg, IDC_DRAWHIGHLIGHT, "Draw Selection Highlight" );
1453
1454 InitializeButtonGraphicAndState( hwndDlg, IDC_DRAWGRID, IDI_DRAWGRID, gDrawGrid );
1455 AddTooltipFromControlID( gTooltip, hwndDlg, IDC_DRAWGRID, "Draw Grid" );
1456
1457 InitializeButtonGraphicAndState( hwndDlg, IDC_SNAPTOGRID, IDI_SNAPTOGRID, gSnapToGrid );
1458 AddTooltipFromControlID( gTooltip, hwndDlg, IDC_SNAPTOGRID, "Snap to Grid" );
1459
1460 InitializeButtonGraphic( hwndDlg, IDC_ALIGNLEFT, IDI_ALIGNLEFT );
1461 AddTooltipFromControlID( gTooltip, hwndDlg, IDC_ALIGNLEFT, "Align Left" );
1462
1463 InitializeButtonGraphic( hwndDlg, IDC_ALIGNHCENTER, IDI_ALIGNHCENTER );
1464 AddTooltipFromControlID( gTooltip, hwndDlg, IDC_ALIGNHCENTER, "Align on Horzontal Center" );
1465
1466 InitializeButtonGraphic( hwndDlg, IDC_ALIGNRIGHT, IDI_ALIGNRIGHT );
1467 AddTooltipFromControlID( gTooltip, hwndDlg, IDC_ALIGNRIGHT, "Align Right" );
1468
1469 InitializeButtonGraphic( hwndDlg, IDC_ALIGNTOP, IDI_ALIGNTOP );
1470 AddTooltipFromControlID( gTooltip, hwndDlg, IDC_ALIGNTOP, "Align Top" );
1471
1472 InitializeButtonGraphic( hwndDlg, IDC_ALIGNVCENTER, IDI_ALIGNVCENTER );
1473 AddTooltipFromControlID( gTooltip, hwndDlg, IDC_ALIGNVCENTER, "Align on Vertical Center" );
1474
1475 InitializeButtonGraphic( hwndDlg, IDC_ALIGNBOTTOM, IDI_ALIGNBOTTOM );
1476 AddTooltipFromControlID( gTooltip, hwndDlg, IDC_ALIGNBOTTOM, "Align Bottom" );
1477
1478 InitializeButtonGraphic( hwndDlg, IDC_SIZEWIDTH, IDI_SIZEWIDTH );
1479 AddTooltipFromControlID( gTooltip, hwndDlg, IDC_SIZEWIDTH, "Make Controls Same Width" );
1480
1481 InitializeButtonGraphic( hwndDlg, IDC_SIZEHEIGHT, IDI_SIZEHEIGHT );
1482 AddTooltipFromControlID( gTooltip, hwndDlg, IDC_SIZEHEIGHT, "Make Controls Same Height" );
1483
1484 InitializeButtonGraphic( hwndDlg, IDC_RESET, IDI_RESET );
1485 AddTooltipFromControlID( gTooltip, hwndDlg, IDC_RESET, "Reset the Palette Data" );
1486
1487 UpdateAlignmentControlEnabledState();
1488
1489 SetTimer( hwndDlg, UITimerID, 100, 0 );
1490 return 0;
1491 }
1492
1493 case WM_MOVE:
1494 {
1495 RECT rc;
1496 RECT rcMainWindow;
1497 GetWindowRect( hwndDlg, &rc );
1498 GetWindowRect( gMainWindow, &rcMainWindow );
1499
1500 SetWindowPos( gMainWindow, 0, rc.left - (rcMainWindow.right - rcMainWindow.left), rc.top, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
1501 return 0;
1502 }
1503
1504 case WM_NOTIFY:
1505 if( wParam == IDC_ROOTPAGE )
1506 {
1507 LPNMHDR GenericHeader = (LPNMHDR)lParam;
1508
1509 if( GenericHeader->code == TCN_SELCHANGE )
1510 {
1511 HTREEITEM hRoot;
1512
1513 SizeWindowToCurrentPageSelection();
1514 hRoot = GetObjectInTreeControlFromHandle( gObjectTree, 0, gCurrentlySelectedPage );
1515 TreeView_SelectItem( gObjectTree, hRoot );
1516 TreeView_EnsureVisible( gObjectTree, hRoot );
1517 }
1518 }
1519 return 0;
1520
1521 case WM_COMMAND:
1522 if( HIWORD(wParam) == BN_CLICKED )
1523 {
1524 if( LOWORD(wParam) == IDC_PLAY )
1525 gInVisualEditingMode = !gInVisualEditingMode;
1526 if( LOWORD(wParam) == IDC_REFRESH )
1527 {
1528 RefreshContents();
1529 ClearDefPushButtonLook( hwndDlg, IDC_REFRESH );
1530 }
1531 else if( LOWORD( wParam ) == IDC_DRAWCURSOR )
1532 gDrawCursor = !gDrawCursor;
1533 else if( LOWORD( wParam ) == IDC_DRAWHIGHLIGHT )
1534 gDrawHighlightRect = !gDrawHighlightRect;
1535 else if( LOWORD( wParam ) == IDC_DRAWGRID )
1536 gDrawGrid = !gDrawGrid;
1537 else if( LOWORD( wParam ) == IDC_SNAPTOGRID )
1538 gSnapToGrid = !gSnapToGrid;
1539 else if( LOWORD( wParam ) == IDC_ALIGNLEFT )
1540 {
1541 AlignSelection( LeftAlignment );
1542 ClearDefPushButtonLook( hwndDlg, IDC_ALIGNLEFT );
1543 }
1544 else if( LOWORD( wParam ) == IDC_ALIGNHCENTER )
1545 {
1546 AlignSelection( HCenterAlignment );
1547 ClearDefPushButtonLook( hwndDlg, IDC_ALIGNHCENTER );
1548 }
1549 else if( LOWORD( wParam ) == IDC_ALIGNRIGHT )
1550 {
1551 AlignSelection( RightAlignment );
1552 ClearDefPushButtonLook( hwndDlg, IDC_ALIGNRIGHT );
1553 }
1554 else if( LOWORD( wParam ) == IDC_ALIGNTOP )
1555 {
1556 AlignSelection( TopAlignment );
1557 ClearDefPushButtonLook( hwndDlg, IDC_ALIGNTOP );
1558 }
1559 else if( LOWORD( wParam ) == IDC_ALIGNVCENTER )
1560 {
1561 AlignSelection( VCenterAlignment );
1562 ClearDefPushButtonLook( hwndDlg, IDC_ALIGNVCENTER );
1563 }
1564 else if( LOWORD( wParam ) == IDC_ALIGNBOTTOM )
1565 {
1566 AlignSelection( BottomAlignment );
1567 ClearDefPushButtonLook( hwndDlg, IDC_ALIGNBOTTOM );
1568 }
1569 else if( LOWORD( wParam ) == IDC_SIZEWIDTH )
1570 {
1571 SizeSelection( true, false );
1572 ClearDefPushButtonLook( hwndDlg, IDC_SIZEWIDTH );
1573 }
1574 else if( LOWORD( wParam ) == IDC_SIZEHEIGHT )
1575 {
1576 SizeSelection( false, true );
1577 ClearDefPushButtonLook( hwndDlg, IDC_SIZEHEIGHT );
1578 }
1579 else if( LOWORD( wParam ) == IDC_RESET )
1580 {
1581 UIPalette * palette = UIPalette::GetInstance();
1582 if(palette)
1583 palette->Reset();
1584 }
1585 }
1586 SetFocus( gCanvasWindow );
1587 return 0;
1588
1589 case WM_TIMER:
1590 if( UIManager::gUIManager().GetRootPage() )
1591 {
1592 RECT rc;
1593
1594 const UISize & RootSize = UIManager::gUIManager().GetRootPage()->GetSize();
1595 GetClientRect( gCanvasWindow, &rc );
1596
1597 if( ((rc.right - rc.left) != RootSize.x) || ((rc.bottom - rc.top) != RootSize.y) )
1598 SizeWindowToCurrentPageSelection();
1599 }
1600 return 0;
1601
1602 case WM_DESTROY:
1603 KillTimer( hwndDlg, UITimerID );
1604 return 0;
1605
1606 default:
1607 return 0;
1608 }
1609 }
1610
1611 //----------------------------------------------------------------------
1612
1613 void recordUndo(UIBaseObject * const object, bool force)
1614 {
1615 WaitForSingleObject( gFrameRenderingMutex, INFINITE );
1616
1617 if (s_UndoReady || force)
1618 {
1619 if (object && object->GetParent())
1620 {
1621 UIUndo undo(object);
1622 s_UndoQueue.push_back(undo);
1623
1624 // Don't let the list grow too big.
1625 if (s_UndoQueue.size() > MaxUndoSteps)
1626 {
1627 s_UndoQueue.erase(s_UndoQueue.begin());
1628 }
1629
1630 s_UndoReady = false;
1631 }
1632 }
1633
1634 s_UndoQueueEmpty = s_UndoQueue.empty();
1635 EnableMenuItem(gMenu, ID_EDIT_UNDO, s_UndoQueueEmpty ? (MF_BYCOMMAND | MF_GRAYED) : (MF_BYCOMMAND | MF_ENABLED));
1636
1637 ReleaseMutex( gFrameRenderingMutex );
1638 }
1639
1640
1641 //----------------------------------------------------------------------
1642
1643 void recordUndo(UIBaseObject * const object, UILowerString property, UIString oldValue, UIString newValue, bool force)
1644 {
1645 //Can't undo operations to the root object
1646 if(object == UIManager::gUIManager().GetRootPage())
1647 return;
1648
1649 WaitForSingleObject( gFrameRenderingMutex, INFINITE );
1650
1651 if (s_UndoReady || force)
1652 {
1653 UIUndo undo(object, property, oldValue, newValue);
1654 s_UndoQueue.push_back(undo);
1655
1656 // Don't let the list grow too big.
1657 if (s_UndoQueue.size() > MaxUndoSteps)
1658 {
1659 s_UndoQueue.erase(s_UndoQueue.begin());
1660 }
1661
1662 s_UndoReady = false;
1663 }
1664
1665 s_UndoQueueEmpty = s_UndoQueue.empty();
1666 EnableMenuItem(gMenu, ID_EDIT_UNDO, s_UndoQueueEmpty ? (MF_BYCOMMAND | MF_GRAYED) : (MF_BYCOMMAND | MF_ENABLED));
1667
1668 ReleaseMutex( gFrameRenderingMutex );
1669 }
1670
1671 //----------------------------------------------------------------------
1672
1673 void undo()
1674 {
1675 WaitForSingleObject( gFrameRenderingMutex, INFINITE );
1676
1677 UIBaseObject * selectedObject = NULL;
1678
1679 if(!s_UndoQueue.empty())
1680 {
1681 UIUndo & undoObject = s_UndoQueue.back();
1682
1683 selectedObject = undoObject.getObject();
1684
1685 bool rebuildTree = true;
1686 undoObject.undo(rebuildTree, &selectedObject);
1687
1688 if (rebuildTree && selectedObject)
1689 {
1690 // delete old tree, and add a new one.
1691 RebuildTreeView(NULL);
1692
1693 }
1694
1695 s_UndoQueue.pop_back();
1696
1697 s_UndoQueueEmpty = s_UndoQueue.empty();
1698 EnableMenuItem(gMenu, ID_EDIT_UNDO, s_UndoQueueEmpty ? (MF_BYCOMMAND | MF_GRAYED) : (MF_BYCOMMAND | MF_ENABLED));
1699 }
1700
1701 ReleaseMutex( gFrameRenderingMutex );
1702 }
1703
1704 //----------------------------------------------------------------------
1705
1706 void clearUndoHistory()
1707 {
1708 s_UndoQueue.clear();
1709 }
swg client tools