00001 // $Id: basebar2.cpp 1282 2006-06-09 09:46:49Z alex $ 00002 /* @@tag:xara-cn@@ DO NOT MODIFY THIS LINE 00003 ================================XARAHEADERSTART=========================== 00004 00005 Xara LX, a vector drawing and manipulation program. 00006 Copyright (C) 1993-2006 Xara Group Ltd. 00007 Copyright on certain contributions may be held in joint with their 00008 respective authors. See AUTHORS file for details. 00009 00010 LICENSE TO USE AND MODIFY SOFTWARE 00011 ---------------------------------- 00012 00013 This file is part of Xara LX. 00014 00015 Xara LX is free software; you can redistribute it and/or modify it 00016 under the terms of the GNU General Public License version 2 as published 00017 by the Free Software Foundation. 00018 00019 Xara LX and its component source files are distributed in the hope 00020 that it will be useful, but WITHOUT ANY WARRANTY; without even the 00021 implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 00022 See the GNU General Public License for more details. 00023 00024 You should have received a copy of the GNU General Public License along 00025 with Xara LX (see the file GPL in the root directory of the 00026 distribution); if not, write to the Free Software Foundation, Inc., 51 00027 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 00028 00029 00030 ADDITIONAL RIGHTS 00031 ----------------- 00032 00033 Conditional upon your continuing compliance with the GNU General Public 00034 License described above, Xara Group Ltd grants to you certain additional 00035 rights. 00036 00037 The additional rights are to use, modify, and distribute the software 00038 together with the wxWidgets library, the wxXtra library, and the "CDraw" 00039 library and any other such library that any version of Xara LX relased 00040 by Xara Group Ltd requires in order to compile and execute, including 00041 the static linking of that library to XaraLX. In the case of the 00042 "CDraw" library, you may satisfy obligation under the GNU General Public 00043 License to provide source code by providing a binary copy of the library 00044 concerned and a copy of the license accompanying it. 00045 00046 Nothing in this section restricts any of the rights you have under 00047 the GNU General Public License. 00048 00049 00050 SCOPE OF LICENSE 00051 ---------------- 00052 00053 This license applies to this program (XaraLX) and its constituent source 00054 files only, and does not necessarily apply to other Xara products which may 00055 in part share the same code base, and are subject to their own licensing 00056 terms. 00057 00058 This license does not apply to files in the wxXtra directory, which 00059 are built into a separate library, and are subject to the wxWindows 00060 license contained within that directory in the file "WXXTRA-LICENSE". 00061 00062 This license does not apply to the binary libraries (if any) within 00063 the "libs" directory, which are subject to a separate license contained 00064 within that directory in the file "LIBS-LICENSE". 00065 00066 00067 ARRANGEMENTS FOR CONTRIBUTION OF MODIFICATIONS 00068 ---------------------------------------------- 00069 00070 Subject to the terms of the GNU Public License (see above), you are 00071 free to do whatever you like with your modifications. However, you may 00072 (at your option) wish contribute them to Xara's source tree. You can 00073 find details of how to do this at: 00074 http://www.xaraxtreme.org/developers/ 00075 00076 Prior to contributing your modifications, you will need to complete our 00077 contributor agreement. This can be found at: 00078 http://www.xaraxtreme.org/developers/contribute/ 00079 00080 Please note that Xara will not accept modifications which modify any of 00081 the text between the start and end of this header (marked 00082 XARAHEADERSTART and XARAHEADEREND). 00083 00084 00085 MARKS 00086 ----- 00087 00088 Xara, Xara LX, Xara X, Xara X/Xtreme, Xara Xtreme, the Xtreme and Xara 00089 designs are registered or unregistered trademarks, design-marks, and/or 00090 service marks of Xara Group Ltd. All rights in these marks are reserved. 00091 00092 00093 Xara Group Ltd, Gaddesden Place, Hemel Hempstead, HP2 6EX, UK. 00094 http://www.xara.com/ 00095 00096 =================================XARAHEADEREND============================ 00097 */ 00098 /* 00099 // */ 00100 00101 #include "camtypes.h" 00102 //#include "dlgbar.h" 00103 //#include "ensure.h" - in camtypes.h [AUTOMATICALLY REMOVED] 00104 #include "camframe.h" 00105 #include "oilmods.h" 00106 #include "dlgmgr.h" 00107 //#include "bitbutn.h" 00108 //#include "resource.h" // temp 00109 //#include "barsdlgs.h" 00110 //#include "childbar.h" 00111 //#include "bbutdef.h" 00112 //#include "ctrlhelp.h" 00113 //#include "bars.h" - in camtypes.h [AUTOMATICALLY REMOVED] 00114 #include "camelot.h" 00115 //#include "ctl3d.h" 00116 //#include "fonts.h" 00117 #include "gallery.h" 00118 //#include "sgallery.h" - in camtypes.h [AUTOMATICALLY REMOVED] 00119 //#include "tool.h" - in camtypes.h [AUTOMATICALLY REMOVED] 00120 //#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED] 00121 //#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED] 00122 #include "camview.h" 00123 #include "keypress.h" 00124 //#include "bars.h" - in camtypes.h [AUTOMATICALLY REMOVED] 00125 #include "selector.h" 00126 //#include "reshelp.h" 00127 //#include "dragmgr.h" 00128 //#include "custmsg.h" 00129 //#include "cursor.h" - in camtypes.h [AUTOMATICALLY REMOVED] 00130 #include "csrstack.h" 00131 //#include "phil.h" 00132 //#include "convert.h" - in camtypes.h [AUTOMATICALLY REMOVED] 00133 #include "bubbleid.h" 00134 //#include "will2.h" // for HideDisableGadgetAndResuffleBar and 00135 // ShowEnableGadgetAndResuffleBar 00136 // to jump to point where ID's are used search 00137 // for 'HideDisableGadgetAndResuffleBar' .... 00138 00139 #include "basebar.h" 00140 00141 #ifdef STANDALONE 00142 #include "galbar.h" 00143 #endif 00144 00145 IMPLEMENT_DYNAMIC_CLASS( BaseBar, wxWindow ) 00146 00147 // Statics 00148 00149 wxRect BaseBar::OldDragRect(0,0,0,0); 00150 00151 DlgDragType BaseBar::DragType = NONE; 00152 00153 BOOL BaseBar::InRecreate = FALSE; 00154 BOOL BaseBar::DoingErrorBox = FALSE; 00155 00156 // NEW BUTTON STUFF 00157 UINT32 BaseBar::GalButtonWidth = 0; 00158 00159 00160 wxWindow * BaseBar::LastWindowWithFocus = NULL; 00161 00162 BOOL BaseBar::ControlHasFocus = FALSE; 00163 00164 BOOL BaseBar::IsBackGroundRendering = FALSE; 00165 00166 wxWindow* BaseBar::HwndWithFocus = NULL ; 00167 00168 BaseBar * BaseBar::CurrentBar = NULL; 00169 00170 INT32 BaseBar::TitleBarHeight = 0; // UIC 00171 INT32 BaseBar::BorderWidth = 0; // UIC 00172 00173 00174 // control dragging stuff 00175 ControlDragState BaseBar::CtlDragState = NO_DRAG; 00176 ControlDragMode BaseBar::CtlDragMode = CUT; 00177 00178 Cursor* BaseBar::pCurrentCursor = NULL; 00179 Cursor* BaseBar::pButtonCopyCursor = NULL; 00180 Cursor* BaseBar::pButtonCutCursor = NULL; 00181 INT32 BaseBar::CurrentCursorID = 0; 00182 BaseBar* BaseBar::PtrToToolBar = NULL; 00183 00184 // This macro aligns a BYTE ptr to a dword boundary 00185 #if WIN32 00186 #define DWORD_ALIGN(x) if (((DWORD)(x))&3) x+=4-(((DWORD)(x))&3) 00187 #else 00188 #define DWORD_ALIGN(x) 00189 #endif 00190 00191 #define NO_REDRAW FALSE 00192 00193 CC_IMPLEMENT_DYNAMIC(FormatPosition, ListItem) 00194 00195 00196 // Used to be 725, 600 00197 // Used to be 770, 614 00198 enum InfoBarWidths { LARGE_INFO_BAR = 910, SMALL_INFO_BAR = 774 }; 00199 00200 #define COMBOHEIGHT SMALLBUTTONHEIGHT - 2 00201 00202 #define IS_CHICAGO ((LOBYTE(LOWORD(GetVersion()))) > 3) 00203 00204 #define COMMIT 2 00205 00206 #define Y_BASEUNITS 16 00207 #define X_BASEUNITS 8 00208 00209 00210 //#define IS_CHICAGO 1 00211 00212 00213 00214 /******************************************************************************************** 00215 00216 > BaseBar::GetEnumItemType(BarItem * Item) 00217 00218 Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> 00219 Created: 30/3/94 00220 Inputs: the baritem to type 00221 Outputs: - 00222 Returns: An Enumerated BarType 00223 Purpose: To return an enumerated BarType from a BarItem 00224 Errors: - 00225 SeeAlso: - 00226 00227 ********************************************************************************************/ 00228 00229 BarItemType GetEnumItemType(BarItem * Item) 00230 { 00231 PORTNOTETRACE( "dialog", "GetEnumItemType - do nothing" ); 00232 #ifndef EXCLUDE_FROM_XARALX 00233 if(Item == NULL) 00234 return UNKNOWN_ITEM; 00235 if (Item->IsKindOf(CC_RUNTIME_CLASS(BarControl))) 00236 { 00237 HWND hcontrol=(HWND)((BarControl*)Item)->GetWinID(); // Get the Window Handle 00238 00239 String_256 ClassNameStr; 00240 00241 GetClassName(hcontrol, (TCHAR*)ClassNameStr, 255); // Check type of control 00242 if (ClassNameStr == String_16(TEXT("cc_BitmapButton"))) 00243 return BITMAPBUTTON; 00244 if (ClassNameStr == String_16(TEXT("Button"))) 00245 return BUTTON; 00246 if (ClassNameStr == String_16(TEXT("cc_SmallButton"))) 00247 return SMALLBITMAPBUTTON; 00248 if (ClassNameStr == String_16(TEXT("Static"))) 00249 return STATIC; 00250 if (ClassNameStr == String_16(TEXT("ComboBox"))) 00251 return COMBO; 00252 if (ClassNameStr == String_16(TEXT("Edit"))) 00253 return EDIT; 00254 if (ClassNameStr == String_16(TEXT("cc_StaticBitmap"))) 00255 return STATICBITMAP; 00256 if (ClassNameStr == String_16(TEXT("cc_Grid"))) 00257 return ROTATEGRID; 00258 if (ClassNameStr == String_16(TEXT("cc_Text3D"))) 00259 return TEXT3D; 00260 if (ClassNameStr == String_16(TEXT("cc_Slider"))) 00261 return SLIDER; 00262 if (ClassNameStr == String_64(TEXT("cc_1dBitmapComboBoxEdit"))) 00263 return BITMAPCOMBO1D; 00264 if (ClassNameStr == String_64(TEXT("cc_2dBitmapComboBoxEdit"))) 00265 return BITMAPCOMBO2D; 00266 return OTHERCONTROL; 00267 } 00268 00269 if ( Item->IsKindOf(CC_RUNTIME_CLASS(BarSeparator)) ) 00270 return SEPARATOR; 00271 if ( Item->IsKindOf(CC_RUNTIME_CLASS(BarLineFeed)) ) 00272 return LINEFEED; 00273 if ( Item->IsKindOf(CC_RUNTIME_CLASS(DDeckerTop))) 00274 return DECKER_TOP; 00275 if ( Item->IsKindOf(CC_RUNTIME_CLASS(DDeckerBottom))) 00276 return DECKER_BOTTOM; 00277 if ( Item->IsKindOf(CC_RUNTIME_CLASS(DDeckerEnd))) 00278 return DECKER_END; 00279 ENSURE(FALSE,"Unknown Bar Item"); 00280 #endif 00281 return UNKNOWN_ITEM; 00282 } 00283 00284 /******************************************************************************************** 00285 00286 > static BOOL BaseBar::DeclarePreferences() 00287 00288 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 00289 Created: 20/12/95 00290 Returns: TRUE if it worked, FALSE if it failed 00291 Purpose: Declares any preferences that the BaseBar class needs to decalre 00292 00293 ********************************************************************************************/ 00294 00295 BOOL BaseBar::DeclarePreferences() 00296 { 00297 // Use a built-in resource rather than an ini file setting... 00298 INT32 TempWidth = 72; 00299 Convert::StringToLong( String_8( _R(IDS_DEFAULT_GAL_BUTTON_SIZE) ), &TempWidth ); 00300 GalButtonWidth = (UINT32)TempWidth; 00301 return TRUE; 00302 00303 // GalButtonWidth = 72; 00304 // return Camelot.DeclareSection("Galleries",2) 00305 // && Camelot.DeclarePref("Galleries", "ButtonWidth", &GalButtonWidth); 00306 } 00307 00308 /******************************************************************************************** 00309 00310 > BaseBar::BaseBar() 00311 00312 Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> 00313 Created: 30/3/94 00314 Inputs: - 00315 Outputs: - 00316 Returns: - 00317 Purpose: The BaseBar constructor 00318 Errors: - 00319 SeeAlso: - 00320 00321 ********************************************************************************************/ 00322 00323 BaseBar::BaseBar() 00324 { 00325 // Get pointers to Stock Fonts for Title and controls 00326 // TitleFont = FontFactory::GetwxFont(STOCKFONT_DIALOGBARTITLE); 00327 // BarFont = FontFactory::GetwxFont(STOCKFONT_DIALOGBARCLIENT); 00328 // SmallThinFont = FontFactory::GetwxFont(STOCKFONT_DIALOGBARSMALL); 00329 // LargeThinFont = FontFactory::GetwxFont(STOCKFONT_DIALOGBARLARGE); 00330 00331 // Get the System FrameWidth 00332 BorderWidth = wxSystemSettings::GetMetric( wxSYS_FRAMESIZE_X ); 00333 00334 // Get the height of the title bar UIC 00335 // under '95 this is system wide UIC 00336 00337 #if defined(__WXMSW__) 00338 if(IS_CHICAGO) 00339 { 00340 TitleBarHeight = 14; // UIC 00341 #if _MFC_VER >= 0x400 00342 TitleBarHeight = wxSystemSettings::GetMetric(SM_CYSMCAPTION); 00343 #endif 00344 } 00345 else 00346 #endif 00347 { 00348 TitleBarHeight = 10; // UIC 00349 } 00350 // used in GrowNorth GrowSouth 00351 TallestFloat = WidestFloat = 1; 00352 00353 // init drag state 00354 DragType = NONE; 00355 DragCtlHwnd = NULL; 00356 00357 Active = TRUE; 00358 00359 00360 InitFormatRects(); 00361 LastSmallBarPos.x = LastSmallBarPos.y = -1; 00362 00363 // create a bitmap for the drag rendering 00364 #pragma message( __LOCMSG__ "Not using dither pattern" ) 00365 // WORD WindowsGray [] = { 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA } ; 00366 // BrushBitmap.CreateBitmap (8, 8, 1, 1, (LPSTR) WindowsGray) ; 00367 BrushBitmap.Create( 8, 8, 1 ); 00368 } 00369 00370 00371 00372 00373 /******************************************************************************************** 00374 00375 > BaseBar::~BaseBar() 00376 00377 Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> 00378 Created: 30/3/94 00379 Inputs: - 00380 Outputs: - 00381 Returns: - 00382 Purpose: BaseBar destructor 00383 Errors: - 00384 SeeAlso: - 00385 00386 ********************************************************************************************/ 00387 00388 BaseBar::~BaseBar() 00389 { 00390 FormatPositions.DeleteAll(); 00391 } 00392 00393 /******************************************************************************************** 00394 00395 > BOOL BaseBar::IsBarInRecreate() 00396 00397 Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> 00398 Created: 30/3/94 00399 Inputs: - 00400 Outputs: - 00401 Returns: - 00402 Purpose: BaseBar destructor 00403 Errors: - 00404 SeeAlso: - 00405 00406 ********************************************************************************************/ 00407 00408 BOOL BaseBar::IsBarInRecreate() 00409 { 00410 return InRecreate; 00411 } 00412 00413 00414 /******************************************************************************************** 00415 00416 > static BOOL BaseBar::IsDoingErrorBox() 00417 00418 Author: Richard_Millican (Xara Group Ltd) <camelotdev@xara.com> 00419 Created: 22/6/95 00420 Inputs: - 00421 Outputs: - 00422 Returns: - 00423 Purpose: Returns whether we're doing an error box or not... 00424 Errors: - 00425 SeeAlso: - 00426 00427 ********************************************************************************************/ 00428 00429 BOOL BaseBar::IsDoingErrorBox() 00430 { 00431 // If it's an MFC exception, etc... 00432 /* if(CCamApp::IsDisabled()) 00433 return TRUE;*/ 00434 00435 return DoingErrorBox; 00436 } 00437 00438 /******************************************************************************************** 00439 00440 > static void BaseBar::StartErrorBox() 00441 00442 Author: Richard_Millican (Xara Group Ltd) <camelotdev@xara.com> 00443 Created: 22/6/95 00444 Inputs: - 00445 Outputs: - 00446 Returns: - 00447 Purpose: To set the variable which stops us grabbing back the focus in mainframe if 00448 the bar / gallery hasn't been created 00449 Errors: - 00450 SeeAlso: - 00451 00452 ********************************************************************************************/ 00453 00454 void BaseBar::StartErrorBox() 00455 { 00456 DoingErrorBox = TRUE; 00457 } 00458 00459 /******************************************************************************************** 00460 00461 > static void BaseBar::FinishErrorBox() 00462 00463 Author: Richard_Millican (Xara Group Ltd) <camelotdev@xara.com> 00464 Created: 22/6/95 00465 Inputs: - 00466 Outputs: - 00467 Returns: - 00468 Purpose: To reset the variable which stops us grabbing back the focus in mainframe if 00469 the bar / gallery hasn't been created 00470 Errors: - 00471 SeeAlso: - 00472 00473 ********************************************************************************************/ 00474 00475 void BaseBar::FinishErrorBox() 00476 { 00477 DoingErrorBox = FALSE; 00478 } 00479 00480 /******************************************************************************************** 00481 00482 > BaseBar::SetFormatVariables() 00483 00484 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 00485 Created: 9/5/94 00486 Inputs: - 00487 Outputs: - 00488 Returns: - 00489 Purpose: Sets up various formating variables according to dockbar type 00490 large/small controls etc .. must be called on every create 00491 Errors: - 00492 SeeAlso: - 00493 00494 ********************************************************************************************/ 00495 00496 00497 void BaseBar::SetFormatVariables() 00498 { 00499 #pragma message( __LOCMSG__ "BaseBar::SetFormatVariables - do nothing" ) 00500 TRACE( _T("Warning - BaseBar::SetFormatVariables called") ); 00501 /* if (GetMainFrame()->GetDockBar(ParentDockBarType)->IsBigControls()) 00502 SeparatorWidth = LARGE_SEPARATOR; 00503 else 00504 SeparatorWidth = SMALL_SEPARATOR; */ 00505 } 00506 00507 00508 00509 /******************************************************************************************** 00510 00511 > void BaseBar::CloseCombos() 00512 00513 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 00514 Created: 16/5/94 00515 Inputs: - 00516 Outputs: - 00517 Returns: - 00518 Purpose: Close any drop-down windows 00519 Errors: - 00520 SeeAlso: - 00521 00522 ********************************************************************************************/ 00523 00524 00525 void BaseBar::CloseCombos() 00526 { 00527 #pragma message( __LOCMSG__ "BaseBar::CloseCombos - do nothing" ) 00528 TRACE( _T("Warning - BaseBar::CloseCombos called") ); 00529 /* String_256 ClassNameStr; 00530 HWND CurrentChild; 00531 HWND NextChild; 00532 00533 // Get control HWND's 00534 for (CurrentChild = ::GetWindow(GetSafeHwnd(),GW_CHILD); 00535 CurrentChild != NULL; 00536 CurrentChild = NextChild) 00537 { 00538 GetClassName(CurrentChild, (TCHAR*)ClassNameStr, 255); 00539 // check for ComboBox/ListBox 00540 if ( (ClassNameStr == String_8(TEXT("ListBox"))) || 00541 (ClassNameStr == String_8(TEXT("ComboBox"))) || 00542 (ClassNameStr == String_64(TEXT("cc_1dBitmapComboBoxEdit"))) || 00543 (ClassNameStr == String_64(TEXT("cc_2dBitmapComboBoxEdit"))) 00544 ) 00545 { 00546 // send close message 00547 ::SendMessage(CurrentChild,CB_SHOWDROPDOWN,FALSE,0); 00548 } 00549 NextChild = ::GetWindow(CurrentChild,GW_HWNDNEXT); 00550 } */ 00551 00552 } 00553 00554 00555 00556 00557 /******************************************************************************************** 00558 00559 > wxRect BaseBar::GetDragFormatRect(DockBarType BarType, wxPoint CursorPos, BOOL ToLeft 00560 BOOL Below) 00561 00562 Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> 00563 Created: 19/5/94 00564 Inputs: BarType: Type of docking bar to create new bar shape for 00565 CursorPos: Current cursor position 00566 (and class statics) 00567 OldDragRect: Previous dragged rectangle 00568 DragOffset: Offset of cursro into previous rectangle 00569 DragOffsetFromLeft: TRUE when cursor is offset from left of previous 00570 DragOffsetFromTop: TRUE when cursor is offset from top of previous 00571 00572 Outputs: - 00573 Returns: - 00574 Purpose: Get cached format size and offset it appropriately around the current drag 00575 position. 00576 Errors: - 00577 SeeAlso: - 00578 00579 ********************************************************************************************/ 00580 00581 wxRect BaseBar::GetDragFormatRect(DockBarType BarType, wxPoint CursorPos, BOOL ToLeft, 00582 BOOL Below ) 00583 { 00584 wxRect DragRect(0,0,0,0); 00585 DragRect = GetFormatRect(BarType); 00586 00587 // TRACEUSER( "Gerry", _T("FormatRect(%d) = (%d, %d) - (%d, %d)\n"), BarType, DragRect.left, DragRect.top, DragRect.GetRight(), DragRect.GetBottom()); 00588 00589 wxPoint NewOffset = CalcDragOffset(DragRect, CursorPos, ToLeft, Below); 00590 00591 // TRACEUSER( "Gerry", _T("Offset = (%d, %d)\n"), NewOffset.x, NewOffset.y); 00592 00593 DragRect.Offset( CursorPos.x - NewOffset.x, CursorPos.y - NewOffset.y ); 00594 00595 // TRACEUSER( "Gerry", _T("After Offset = (%d, %d) - (%d, %d)\n"), DragRect.left, DragRect.GetTop(), DragRect.GetRight(), DragRect.GetBottom()); 00596 00597 return ( DragRect ); 00598 } 00599 00600 00601 00602 00603 /******************************************************************************************** 00604 00605 > wxPoint BaseBar::CalcDragOffset(wxRect DragRect, wxPoint CursorPos, BOOL ToLeft, BOOL Below) 00606 00607 Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> 00608 Created: 19/5/94 00609 Inputs: DragRect: Current dragged rectangle 00610 (and class statics) 00611 OldDragRect: Previous dragged rectangle 00612 DragOffset: Offset of cursor into previous rectangle 00613 DragOffsetFromLeft: TRUE when cursor is offset from left of previous 00614 DragOffsetFromTop: TRUE when cursor is offset from top of previous 00615 Outputs: - 00616 Returns: - 00617 Purpose: Use the current drag rect the previous one and the current cursor pos to 00618 calculate the new offsets into the new drag rectangle. 00619 Errors: - 00620 SeeAlso: - 00621 00622 ********************************************************************************************/ 00623 00624 wxPoint BaseBar::CalcDragOffset(wxRect DragRect, wxPoint CursorPos, BOOL ToLeft, BOOL Below) 00625 { 00626 wxPoint NewOffset; 00627 00628 if (ToLeft) 00629 { 00630 NewOffset.x = DragOffset.x; 00631 if (NewOffset.x > DragRect.GetWidth()) 00632 NewOffset.x = DragRect.GetWidth()-6; 00633 } 00634 else 00635 { 00636 NewOffset.x = DragRect.GetWidth()-(OldDragRect.GetWidth()-DragOffset.x); 00637 if (NewOffset.x < 0) 00638 NewOffset.x = 6; 00639 } 00640 00641 if (Below) 00642 { 00643 NewOffset.y = DragOffset.y; 00644 if (NewOffset.y > DragRect.GetHeight()) 00645 NewOffset.y = DragRect.GetHeight()-6; 00646 } 00647 else 00648 { 00649 NewOffset.y = DragRect.GetHeight()-(OldDragRect.GetHeight()-DragOffset.y); 00650 if (NewOffset.y < 0) 00651 NewOffset.y = 6; 00652 } 00653 00654 return ( NewOffset ); 00655 } 00656 00657 00658 /******************************************************************************************** 00659 00660 > wxRect BaseBar::BaseBar::UnCacheFormatRects() 00661 00662 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 00663 Created: 4/5/94 00664 Inputs: DockBarType 00665 Outputs: - 00666 Returns: - 00667 Purpose: Set all Cache Format rectangles empty 00668 Errors: - 00669 SeeAlso: - 00670 00671 ********************************************************************************************/ 00672 00673 void BaseBar::InitFormatRects() 00674 { 00675 00676 FloatLargeRect = wxRect(); 00677 VerticalLargeRect = wxRect(); 00678 HorizontalLargeRect = wxRect(); 00679 FloatSmallRect = wxRect(); 00680 VerticalSmallRect = wxRect(); 00681 HorizontalSmallRect = wxRect(); 00682 00683 } 00684 00685 /******************************************************************************************** 00686 00687 > wxRect BaseBar::GetFormatRect(DockBarType BarType) 00688 00689 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 00690 Created: 4/5/94 00691 Inputs: DockBarType 00692 Outputs: - 00693 Returns: Cached Rectangle according to dock and control size 00694 Purpose: Get cached format size - if none available format and cache 00695 Errors: - 00696 SeeAlso: - 00697 00698 ********************************************************************************************/ 00699 00700 wxRect BaseBar::GetFormatRect(DockBarType BarType) 00701 { 00702 #pragma message( __LOCMSG__ "BaseBar::GetFormatRect - do nothing" ) 00703 TRACE( _T("Warning - BaseBar::GetFormatRect called") ); 00704 /* OILDockingBar* DockBar = GetMainFrame()->GetDockBar(BarType); 00705 switch(BarType) 00706 { 00707 case DOCKBAR_FLOAT: 00708 if (DockBar->IsBigControls()) 00709 { 00710 if (FloatLargeRect.IsEmpty()) 00711 FormatFloatingBar(FALSE,USE_BAR); 00712 return FloatLargeRect; 00713 } 00714 else 00715 { 00716 if (FloatSmallRect.IsEmpty()) 00717 FormatFloatingBar(FALSE,USE_BAR); 00718 return FloatSmallRect; 00719 } 00720 break; 00721 case DOCKBAR_LEFT: 00722 case DOCKBAR_RIGHT: 00723 if (DockBar->IsBigControls()) 00724 { 00725 if (VerticalLargeRect.IsEmpty()) 00726 FormatVerticalBar(FALSE,USE_BAR); 00727 return VerticalLargeRect; 00728 } 00729 else 00730 { 00731 if (VerticalSmallRect.IsEmpty()) 00732 FormatVerticalBar(FALSE,USE_BAR); 00733 return VerticalSmallRect; 00734 } 00735 break; 00736 00737 case DOCKBAR_TOP: 00738 case DOCKBAR_BOTTOM: 00739 if (DockBar->IsBigControls()) 00740 { 00741 if (HorizontalLargeRect.IsEmpty()) 00742 FormatHorizontalBar(FALSE,USE_BAR); 00743 return HorizontalLargeRect; 00744 } 00745 else 00746 { 00747 if (HorizontalSmallRect.IsEmpty()) 00748 FormatHorizontalBar(FALSE,USE_BAR); 00749 return HorizontalSmallRect; 00750 } 00751 break; 00752 default: 00753 ENSURE(FALSE,"Unknown Dockbar Type"); 00754 00755 } */ 00756 return wxRect(0,0,0,0) ; 00757 } 00758 00759 /******************************************************************************************** 00760 00761 > DockBarType BaseBar::IsPointerOverDock(wxPoint point) 00762 00763 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 00764 Created: 18/5/94 00765 Inputs: point in Screen Coordinates 00766 Outputs: - 00767 Returns: The DockBarType that the pointer is over 00768 Purpose: Test whether the pointer is currently over a dockingbar 00769 Errors: - 00770 SeeAlso: - 00771 00772 ********************************************************************************************/ 00773 00774 DockBarType BaseBar::IsPointerOverDock(wxPoint point) 00775 { 00776 #pragma message( __LOCMSG__ "BaseBar::IsPointerOverDock - do nothing" ) 00777 TRACE( _T("Warning - BaseBar::IsPointerOverDock called") ); 00778 /* wxRect temp ; 00779 OILFixedDockingBar * ParentDockBar; 00780 00781 ParentDockBar = (OILFixedDockingBar * )GetMainFrame()->GetDockBar(DOCKBAR_LEFT); 00782 ParentDockBar->GetDockScreenRect(&temp); 00783 if (temp.PtInRect(point)) 00784 return DOCKBAR_LEFT; 00785 00786 ParentDockBar = (OILFixedDockingBar * )GetMainFrame()->GetDockBar(DOCKBAR_RIGHT); 00787 ParentDockBar->GetDockScreenRect(&temp); 00788 if (temp.PtInRect(point)) 00789 return DOCKBAR_RIGHT; 00790 00791 ParentDockBar = (OILFixedDockingBar * )GetMainFrame()->GetDockBar(DOCKBAR_TOP); 00792 ParentDockBar->GetDockScreenRect(&temp); 00793 if (temp.PtInRect(point)) 00794 return DOCKBAR_TOP; 00795 00796 ParentDockBar = (OILFixedDockingBar * )GetMainFrame()->GetDockBar(DOCKBAR_BOTTOM); 00797 ParentDockBar->GetDockScreenRect(&temp); 00798 if (temp.PtInRect(point)) 00799 return DOCKBAR_BOTTOM; */ 00800 00801 return DOCKBAR_FLOAT; 00802 } 00803 00804 00805 /******************************************************************************************** 00806 00807 > BaseBar::SetBarSize(DockBarType BarType,BOOL DoRedraw) 00808 00809 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 00810 Created: 4/5/94 00811 Inputs: BarType - type of dock the bar is attached to 00812 Redraw - flag to indicate a redraw is needed 00813 Outputs: - 00814 Returns: new size 00815 Purpose: Set the Window size 00816 Errors: - 00817 SeeAlso: - 00818 00819 ********************************************************************************************/ 00820 00821 wxRect BaseBar::SetBarSize(DockBarType BarType ,BOOL DoRedraw) 00822 { 00823 wxRect temp; 00824 00825 #pragma message( __LOCMSG__ "BaseBar::SetBarSize - do nothing" ) 00826 TRACE( _T("Warning - BaseBar::SetBarSize called") ); 00827 /* switch(BarType) 00828 { 00829 case DOCKBAR_FLOAT: 00830 if (ParentDockBar->IsBigControls()) 00831 temp = FloatLargeRect; 00832 else 00833 temp = FloatSmallRect; 00834 break; 00835 00836 case DOCKBAR_LEFT: 00837 case DOCKBAR_RIGHT: 00838 if (ParentDockBar->IsBigControls()) 00839 temp = VerticalLargeRect; 00840 else 00841 temp = VerticalSmallRect; 00842 break; 00843 00844 case DOCKBAR_TOP: 00845 case DOCKBAR_BOTTOM: 00846 if (ParentDockBar->IsBigControls()) 00847 temp = HorizontalLargeRect; 00848 else 00849 temp = HorizontalSmallRect; 00850 break; 00851 } 00852 UINT32 flags = SWP_NOMOVE|SWP_NOZORDER; 00853 if(! DoRedraw) 00854 flags |= SWP_NOREDRAW; 00855 SetWindowPos( NULL, 0, 0, temp.GetRight(), temp.GetBottom(), flags ); */ 00856 00857 return temp; 00858 } 00859 00860 /******************************************************************************************** 00861 00862 > BaseBar::PositionControls(BOOL DoRedraw = TRUE) 00863 00864 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 00865 Created: 4/5/94 00866 Inputs: - 00867 Outputs: - 00868 Returns: - 00869 Purpose: Format and place controls according to docking bar type 00870 Errors: - 00871 SeeAlso: - 00872 00873 ********************************************************************************************/ 00874 00875 BOOL BaseBar::PositionControls(BOOL DoRedraw) 00876 { 00877 // Position the controls in the bar 00878 switch(ParentDockBarType) 00879 { 00880 case DOCKBAR_FLOAT: 00881 FormatFloatingBar(TRUE,USE_BAR); 00882 pOp->SetCurrentOrientation(Horizontal); 00883 break; 00884 00885 case DOCKBAR_LEFT: 00886 case DOCKBAR_RIGHT: 00887 FormatVerticalBar(TRUE,USE_BAR); 00888 pOp->SetCurrentOrientation(Vertical); 00889 break; 00890 00891 case DOCKBAR_TOP: 00892 case DOCKBAR_BOTTOM: 00893 FormatHorizontalBar(TRUE,USE_BAR); 00894 pOp->SetCurrentOrientation(Horizontal); 00895 break; 00896 default: 00897 ENSURE(FALSE,"Unknown Parent DockBar"); 00898 } 00899 // Size the window correctly 00900 SetBarSize(ParentDockBarType, DoRedraw); 00901 return TRUE ; 00902 } 00903 00904 00905 /******************************************************************************************** 00906 00907 > BOOL BaseBar::Show(DialogBarOp* Op) 00908 00909 Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> 00910 Created: 30/3/94 00911 Inputs: - 00912 Outputs: - 00913 Returns: TRUE if successful, else FALSE 00914 Purpose: Creates a BaseBar window 00915 Errors: - 00916 SeeAlso: - 00917 00918 ********************************************************************************************/ 00919 00920 00921 BOOL BaseBar::Show(DialogBarOp* Op) 00922 { 00923 #pragma message( __LOCMSG__ "BaseBar::Show - do nothing" ) 00924 TRACE( _T("Warning - BaseBar::Show called") ); 00925 /* if (Op->IS_KIND_OF(InformationBarOp)) 00926 ((InformationBarOp*)Op)->SetInfo(); 00927 DockBarType InfoDock; 00928 00929 InfoDock = Op->GetDockBarType(); 00930 if(InfoDock != ParentDockBarType) 00931 { 00932 00933 OILDockingBar * NewDock ; 00934 OILDockingBar * OldDock ; 00935 BOOL CanCopy; 00936 NewDock = GetMainFrame()->GetDockBar(InfoDock); 00937 OldDock = GetMainFrame()->GetDockBar(ParentDockBarType); 00938 CanCopy = NewDock->IsBigControls() == OldDock->IsBigControls(); 00939 if(HasOrientationChanged(ParentDockBarType,DragDockBarType)) 00940 CanCopy = FALSE; 00941 00942 // dynamically create a new BaseBar/derived Bar 00943 BaseBar* NewBaseBar = (BaseBar *)GetClassInfo()->CreateObject(); 00944 00945 NewBaseBar->Recreate(InfoDock, this, Op,CanCopy); 00946 // The current BaseBar dies 00947 CCamApp::GetDlgManager()->Delete(GetSafeHwnd(),Op); 00948 return TRUE; 00949 } 00950 00951 KernelBarPos ThisPos; 00952 ThisPos.Dock = ParentDockBarType; 00953 00954 if (ParentDockBarType == DOCKBAR_FLOAT) 00955 { 00956 // Get x/y position of floating bar 00957 wxPoint FloatPos = Op->GetFloatingCPoint(); 00958 ThisPos.x=FloatPos.x; 00959 ThisPos.y=FloatPos.y; 00960 } 00961 else 00962 { 00963 // Get slot/offset position of docked bar 00964 ThisPos.Slot = Op->GetSlot(); 00965 ThisPos.Position = Op->GetOffset(); 00966 // Get a pointer to the docking bar 00967 OILFixedDockingBar * FixedDock = (OILFixedDockingBar*)GetMainFrame()-> 00968 GetDockBar(ParentDockBarType); 00969 } 00970 // Attach the BaseBar to the docking bar 00971 ParentDockBar->PlaceBar(GetSafeHwnd(),ThisPos); 00972 00973 SetWindowText(Op->GetName()); 00974 00975 // send a create to info bars so they can set the state of controls before 00976 // we show the window 00977 00978 // Show the Window 00979 ShowWindow(SW_SHOW); 00980 00981 InvalidateRect(NULL,TRUE); 00982 UpdateWindow(); */ 00983 00984 return TRUE; 00985 } 00986 00987 /******************************************************************************************** 00988 00989 > BOOL BaseBar::Hide(DialogBarOp* Op) 00990 00991 Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> 00992 Created: 30/3/94 00993 Inputs: - 00994 Outputs: - 00995 Returns: TRUE if successful, else FALSE 00996 Purpose: Creates a BaseBar window 00997 Errors: - 00998 SeeAlso: - 00999 01000 ********************************************************************************************/ 01001 BOOL BaseBar::Hide(DialogBarOp* Op) 01002 { 01003 #pragma message( __LOCMSG__ "BaseBar::Hide - do nothing" ) 01004 TRACE( _T("Warning - BaseBar::Hide called") ); 01005 /* BOOL DoTidy = DO_TIDY; 01006 01007 ShowWindow(SW_HIDE); 01008 01009 if (Op->IS_KIND_OF(InformationBarOp)) 01010 ((InformationBarOp*)Op)->GetInfo(); 01011 01012 #ifndef STANDALONE 01013 // we dont want a tidy (reposition and redraw of bars) 01014 // if we are just switching out of the Selector Tool 01015 if(SelectorTool::IsSelectorCaching()) 01016 DoTidy = DONT_TIDY; 01017 #endif 01018 01019 GetMainFrame()->GetDockBar(ParentDockBarType)->ReleaseBar(this->GetSafeHwnd(),DoTidy); 01020 //TRACE( _T("Hide now %d"),ParentDockBarType); */ 01021 return TRUE; 01022 } 01023 01024 /******************************************************************************************** 01025 01026 > BOOL BaseBar::Create(DialogBarOp* Op) 01027 01028 Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> 01029 Created: 30/3/94 01030 Inputs: - 01031 Outputs: - 01032 Returns: TRUE if successful, else FALSE 01033 Purpose: Creates a BaseBar window 01034 Errors: - 01035 SeeAlso: - 01036 01037 ********************************************************************************************/ 01038 01039 BOOL BaseBar::Create(DialogBarOp* Op) 01040 { 01041 #pragma message( __LOCMSG__ "BaseBar::Create - do nothing" ) 01042 TRACE( _T("Warning - BaseBar::Create called") ); 01043 /* InRecreate = TRUE; 01044 pOp = Op; 01045 01046 #ifdef STANDALONE 01047 if (pOp->IS_KIND_OF(InformationBarOp)) 01048 { // We don't want any info bars in the standalone version. 01049 01050 InRecreate = FALSE; 01051 return FALSE; 01052 } 01053 #endif 01054 01055 ParentDockBarType = pOp->GetDockBarType(); // Get the current dock bar 01056 01057 //TRACE( _T("Create now %d"),ParentDockBarType); 01058 ParentDockBar = GetMainFrame()->GetDockBar(ParentDockBarType); 01059 01060 ENSURE(ParentDockBar != NULL, "Could not find docking bar"); 01061 01062 // init control size etc .. 01063 SetFormatVariables(); 01064 01065 KernelBarPos ThisPos; 01066 ThisPos.Dock = ParentDockBarType; 01067 01068 BOOL WindowCreated ; 01069 01070 wxPoint p ; 01071 01072 if (ParentDockBarType == DOCKBAR_FLOAT) 01073 // || pOp->IsKindOf(CC_RUNTIME_CLASS(SuperGallery))) 01074 { 01075 // Get x/y position of floating bar 01076 wxPoint FloatPos = pOp->GetFloatingwxPoint(); 01077 01078 if (!MonitorFromPoint(FloatPos, MONITOR_DEFAULTTONULL)) 01079 { 01080 // The float pos is not on any monitor in the system so lets use the top left 01081 // corner of the monitor nearest the point 01082 MONITORINFO mi; 01083 mi.cbSize = sizeof(MONITORINFO); 01084 if (GetMonitorInfo(MonitorFromPoint(FloatPos, MONITOR_DEFAULTTONEAREST), &mi)) 01085 { 01086 FloatPos.x = mi.rcWork.left; 01087 FloatPos.y = mi.rcWork.GetTop(); 01088 } 01089 else 01090 { 01091 FloatPos.x = FloatPos.y = 0; 01092 } 01093 } 01094 01095 ThisPos.x=FloatPos.x; 01096 ThisPos.y=FloatPos.y; 01097 01098 01099 //TRACE( _T("FLOAT At %d %d"),ThisPos.Slot,ThisPos.Position); 01100 // Set bar mode 01101 CurrentDlgBarMode = DIALOG; 01102 01103 // Create a popup floater 01104 WindowCreated = CreateEx(0, // WS_EX_TOOLWINDOW - I think we should've used one of these, Matt 1/11/00 01105 NULL, 01106 NULL, WS_POPUP |WS_CHILD,// | WS_BORDER, 01107 FloatPos.x, FloatPos.y,0,0, 01108 GetMainFrame()->GetSafeHwnd(), // Parent is the frame window 01109 NULL); 01110 } 01111 else 01112 { 01113 // Get slot/offset position of docked bar 01114 ThisPos.Slot = pOp->GetSlot(); 01115 ThisPos.Position = pOp->GetOffset(); 01116 CurrentDlgBarMode = BAR; 01117 01118 // Get a pointer to the docking bar 01119 OILFixedDockingBar * FixedDock = (OILFixedDockingBar*)GetMainFrame()-> 01120 GetDockBar(ParentDockBarType); 01121 01122 // Get a client coordinate for this slot/offset 01123 FixedDock->BarPosToScreen(ThisPos,&p); 01124 01125 // Create a child window of the docking bar 01126 WindowCreated = CreateEx(0, NULL, 01127 NULL, WS_CHILD | WS_BORDER, 01128 p.x,p.y,0,0, 01129 ParentDockBar->GetSafeHwnd(), 01130 NULL); 01131 } 01132 01133 if (!WindowCreated) 01134 { 01135 InRecreate = FALSE; 01136 return FALSE; 01137 } 01138 01139 if (!LoadResourceControls()|| (!CreateExtraControls())) 01140 { 01141 // We failed to load the controls 01142 // Delete the window, and all children which may have been created 01143 CCamApp::GetDlgManager()->Delete(GetSafeHwnd(), Op); 01144 InRecreate = FALSE; 01145 return FALSE; 01146 } 01147 01148 if (!PositionControls()) 01149 { 01150 InRecreate = FALSE; 01151 return FALSE; 01152 } 01153 // Attach the BaseBar to the docking bar 01154 ParentDockBar->PlaceBar(GetSafeHwnd(),ThisPos); 01155 01156 // send a create to info bars so they can set the state of controls before 01157 // we show the window 01158 01159 pOp->WindowID = (CWindowID)(GetSafeHwnd()); 01160 BROADCAST_TO_CLASS(DialogMsg(GetSafeHwnd(), DIM_CREATE, NULL) ,DialogBarOp); 01161 01162 // Update the bar's state before showing 01163 Op->UpdateState(); 01164 01165 // Show the Window 01166 ShowWindow(SW_SHOW); 01167 ::InvalidateRect(GetSafeHwnd(),NULL,TRUE); 01168 ::UpdateWindow(GetSafeHwnd()); 01169 01170 // inform help system 01171 ControlHelper::NotifyBarCreated(GetSafeHwnd()); 01172 01173 FormatHorizontalBar(FALSE,FORCE_SMALL); 01174 FormatVerticalBar(FALSE,FORCE_SMALL); 01175 FormatFloatingBar(FALSE,FORCE_SMALL); 01176 FormatHorizontalBar(FALSE,FORCE_LARGE); 01177 FormatVerticalBar(FALSE,FORCE_LARGE); 01178 FormatFloatingBar(FALSE,FORCE_LARGE); 01179 01180 InRecreate = FALSE; 01181 01182 SetWindowText(Op->GetName()); 01183 01184 // ZZZZ 01185 LastSmallBarPos = ThisPos; 01186 01187 // get a pointer to the toolbar - so that we can do things with it! 01188 01189 if (Op->GetName () == String_32 (TEXT ("Toolbar"))) 01190 { 01191 PtrToToolBar = this; 01192 } */ 01193 01194 return TRUE; 01195 } 01196 01197 01198 01199 /******************************************************************************************** 01200 01201 > BaseBar::RecreateAt(KernelBarPos Pos,DockBarType DockBar, 01202 BaseBar* BaseBar, DialogBarOp* Op,HWND OldHwnd ) 01203 01204 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 01205 Created: 11/5/94 01206 Inputs: 01207 Pos - Kernel position to place at ((slot/offset)|(x/y)) 01208 Dockbar - Type of dock attached to 01209 BaseBar - item to recreate 01210 Op - attached op 01211 OldHwnd - Hwnd of previous incarnation 01212 Outputs: - 01213 Returns: - 01214 Purpose: ReCreates an existing bar after a change of controlsize - as the bar stays 01215 in the same dock we don't need to release / reattach - we need only inform 01216 the docking bar of the new HWND 01217 Errors: - 01218 SeeAlso: - 01219 01220 ********************************************************************************************/ 01221 01222 01223 BOOL BaseBar::RecreateAt(KernelBarPos Pos,DockBarType DockBarTyp, 01224 BaseBar* BaseBar, DialogBarOp* Op, wxWindow* OldHwnd) 01225 { 01226 #pragma message( __LOCMSG__ "BaseBar::RecreateAt - do nothing" ) 01227 TRACE( _T("Warning - BaseBar::RecreateAt called") ); 01228 /* LastSmallBarPos = Pos; 01229 pOp = Op; 01230 ParentDockBarType = DockBarTyp; // Record the current dock bar 01231 01232 ParentDockBar = GetMainFrame()->GetDockBar(DockBarTyp); 01233 01234 SetFormatVariables(); 01235 01236 wxRect NewBarSize = OldDragRect; // Screen coords 01237 if (DockBarTyp == DOCKBAR_FLOAT) 01238 // || pOp->IsKindOf(CC_RUNTIME_CLASS(SuperGallery))) 01239 { 01240 CurrentDlgBarMode = DIALOG; // For now 01241 01242 // Create a popup floater 01243 CreateEx(0, NULL, 01244 NULL, WS_POPUP |WS_CHILD, //| WS_BORDER , 01245 Pos.x, Pos.y,0,0, 01246 GetMainFrame()->GetSafeHwnd(), // Parent is the frame window 01247 NULL); 01248 01249 } 01250 else 01251 { 01252 CurrentDlgBarMode = BAR; // For now 01253 OILFixedDockingBar * FixedDock = 01254 (OILFixedDockingBar*)GetMainFrame()->GetDockBar(DockBarTyp); 01255 wxPoint p; 01256 FixedDock->BarPosToScreen(Pos,&p); 01257 // Create a child bar 01258 CreateEx(0, NULL, 01259 NULL, WS_CHILD | WS_BORDER , 01260 p.x,p.y,0,0, 01261 ParentDockBar->GetSafeHwnd(), 01262 NULL); 01263 } 01264 if (!LoadResourceControls()|| (!CreateExtraControls())) 01265 { 01266 // We failed to load the controls 01267 // Delete the window, and all children which may have been created 01268 CCamApp::GetDlgManager()->Delete(GetSafeHwnd(), Op); 01269 return FALSE; 01270 } 01271 01272 if (!PositionControls()) 01273 return FALSE; 01274 01275 01276 //TRACE( _T("Done Recreate %d"),GetSafeHwnd()); 01277 // Place BaseBar via docking bar 01278 if (DockBarTyp == DOCKBAR_FLOAT) 01279 { 01280 ParentDockBar->PlaceBar(GetSafeHwnd(),Pos); 01281 } 01282 else 01283 { 01284 OILFixedDockingBar * FixedDock = 01285 (OILFixedDockingBar*)GetMainFrame()->GetDockBar(DockBarTyp); 01286 if ((ParentDockBar->SetNewHwnd(OldHwnd,GetSafeHwnd()))==NULL) 01287 return FALSE; 01288 FixedDock->PlaceBarAt(GetSafeHwnd(),Pos); 01289 01290 } 01291 // inform help system 01292 ControlHelper::NotifyBarCreated(GetSafeHwnd()); 01293 01294 // send a create to info bars so they can set the state of controls before 01295 // we show the window 01296 01297 pOp->WindowID = (CWindowID)(GetSafeHwnd()); 01298 BROADCAST_TO_CLASS(DialogMsg(GetSafeHwnd(), DIM_CREATE, NULL) ,DialogBarOp); 01299 01300 // Update the bar's state before showing 01301 Op->UpdateState(); 01302 01303 // Show the Window 01304 ShowWindow(SW_SHOW); 01305 01306 ::InvalidateRect(GetSafeHwnd(),NULL,TRUE); 01307 ::UpdateWindow(GetSafeHwnd()); 01308 01309 FormatHorizontalBar(FALSE,FORCE_SMALL); 01310 FormatVerticalBar(FALSE,FORCE_SMALL); 01311 FormatFloatingBar(FALSE,FORCE_SMALL); 01312 FormatHorizontalBar(FALSE,FORCE_LARGE); 01313 FormatVerticalBar(FALSE,FORCE_LARGE); 01314 FormatFloatingBar(FALSE,FORCE_LARGE); 01315 01316 SetWindowText(Op->GetName()); 01317 01318 if (Op->GetName () == String_32 (TEXT ("Toolbar"))) 01319 { 01320 PtrToToolBar = this; 01321 } */ 01322 01323 return TRUE; 01324 } 01325 01326 01327 01328 /******************************************************************************************** 01329 01330 > BaseBar::Recreate(DockBarType DockBar, BaseBar* BaseBar, DialogBarOp* Op,BOOL CanCopy ) 01331 01332 Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> 01333 Created: 30/3/94 01334 Inputs: - 01335 Outputs: - 01336 Returns: - 01337 Purpose: 01338 Errors: - 01339 SeeAlso: - 01340 01341 ********************************************************************************************/ 01342 01343 01344 BOOL BaseBar::Recreate(DockBarType DockBarTyp, BaseBar* BaseBar, DialogBarOp* Op,BOOL CanCopy ) 01345 { 01346 #pragma message( __LOCMSG__ "BaseBar::Recreate - do nothing" ) 01347 TRACE( _T("Warning - BaseBar::Recreate called") ); 01348 /* pOp = Op; 01349 ParentDockBarType = DockBarTyp; // Record the current dock ba 01350 01351 ParentDockBar = GetMainFrame()->GetDockBar(DockBarTyp); 01352 01353 SetFormatVariables(); 01354 01355 wxRect NewBarSize = OldDragRect; // Screen coords 01356 01358 01359 // 'dynamic' infobar update logic 01360 01362 01363 String_32 dialogBarOpName = Op->GetName (); 01364 01365 if (dialogBarOpName == TEXT (String_32 (_R(IDS_FILLTOOL_FILLINFOBARNAME)))) 01366 // || add the name of your 'dynamic' infobar here 01367 { 01368 //pOp->ResetHiddenGadgetStates (); 01369 } 01370 01372 01373 if (DockBarTyp == DOCKBAR_FLOAT) 01374 { 01375 CurrentDlgBarMode = DIALOG; // For now 01376 01377 // Create a popup floater 01378 CreateEx(0, NULL, 01379 NULL, WS_POPUP |WS_CHILD,// | WS_BORDER , 01380 NewBarSize.GetLeft()+(NewBarSize.GetWidth()/2), NewBarSize.GetTop()+(NewBarSize.GetHeight()/2), NewBarSize.GetWidth(), NewBarSize.GetHeight(), 01381 GetMainFrame()->GetSafeHwnd(), // Parent is the frame window 01382 NULL); 01383 01384 } 01385 else 01386 { 01387 CurrentDlgBarMode = BAR; // For now 01388 01389 // Convert the NewBarSize to client coords 01390 ::ScreenToClient(ParentDockBar->GetSafeHwnd(), &NewBarSize.TopLeft()); 01391 ::ScreenToClient(ParentDockBar->GetSafeHwnd(), &NewBarSize.BottomRight()); 01392 01393 // Create a child bar 01394 CreateEx(0, NULL, NULL, WS_CHILD| WS_BORDER , 01395 NewBarSize.GetLeft(), NewBarSize.GetTop(), NewBarSize.GetWidth(), NewBarSize.GetHeight(), 01396 ParentDockBar->GetSafeHwnd(), 01397 NULL); 01398 01399 } 01400 if (CanCopy) 01401 { 01402 if (!CopyOrLoadControls(GetSafeHwnd())|| (!CreateExtraControls())) 01403 { 01404 // We failed to load the controls 01405 // Delete the window, and all children which may have been created 01406 CCamApp::GetDlgManager()->Delete(GetSafeHwnd(),Op); 01407 return FALSE; 01408 } 01409 } 01410 else 01411 { 01412 if (!LoadResourceControls()|| (!CreateExtraControls())) 01413 { 01414 // We failed to load the controls 01415 // Delete the window, and all children which may have been created 01416 CCamApp::GetDlgManager()->Delete(GetSafeHwnd(),Op); 01417 return FALSE; 01418 } 01419 } 01420 if (! PositionControls()) 01421 return FALSE; 01422 01423 // Attach the BaseBar to the docking bar 01424 ParentDockBar->PlaceBar(GetSafeHwnd(), wxPoint(OldDragRect.GetLeft(), OldDragRect.GetTop())); 01425 // inform help system 01426 01427 pOp->WindowID = (CWindowID)(GetSafeHwnd()); 01428 01429 BROADCAST_TO_CLASS(DialogMsg(GetSafeHwnd(), DIM_CREATE, NULL) ,DialogBarOp); 01430 01431 wxRect temprect; 01432 GetClientRect(&temprect); 01433 01434 // Update the bar's state before showing 01435 Op->UpdateState(); 01436 01437 //if (Op->GetName () != String_32 (TEXT ("Toolbar"))) 01438 { 01439 // Show the Window 01440 ShowWindow(SW_SHOW); 01441 01442 ::InvalidateRect(GetSafeHwnd(),NULL,TRUE); 01443 ::UpdateWindow(GetSafeHwnd()); 01444 } 01445 01446 ControlHelper::NotifyBarCreated(GetSafeHwnd()); 01447 01448 FormatHorizontalBar(FALSE,FORCE_SMALL); 01449 FormatVerticalBar(FALSE,FORCE_SMALL); 01450 FormatFloatingBar(FALSE,FORCE_SMALL); 01451 FormatHorizontalBar(FALSE,FORCE_LARGE); 01452 FormatVerticalBar(FALSE,FORCE_LARGE); 01453 FormatFloatingBar(FALSE,FORCE_LARGE); 01454 01455 SetWindowText(Op->GetName()); 01456 01457 // ZZZZZ 01458 LastSmallBarPos = * GetMainFrame()->GetDockBar(ParentDockBarType)-> 01459 GetBarPos(this->GetSafeHwnd()); 01460 01461 if (Op->GetName () == String_32 (TEXT ("Toolbar"))) 01462 { 01463 PtrToToolBar = this; 01464 } */ 01465 01466 return TRUE; 01467 } 01468 01469 /******************************************************************************************** 01470 01471 > BaseBar::LoadResourceControls() 01472 01473 Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> 01474 Created: 11/4/94 01475 Inputs: - 01476 Outputs: - 01477 Returns: - 01478 Purpose: 01479 Errors: - 01480 SeeAlso: - 01481 01482 ********************************************************************************************/ 01483 01484 01485 BOOL BaseBar::LoadResourceControls() 01486 { 01487 // Find out how many bar items 01488 UINT32 NumBarItems = pOp->GetNumBarItems(); 01489 01490 BarItem* pBarItem; 01491 01492 // track ddecker state 01493 DDeckerState = DDECKER_NONE; 01494 01495 // ThisIsAnInfoBar = ( (pOp->IsKindOf(CC_RUNTIME_CLASS(InformationBarOp))) 01496 // || (pOp->IsKindOf(CC_RUNTIME_CLASS(SuperGallery))) ); 01497 01498 ThisIsAnInfoBar = pOp->IsKindOf(CC_RUNTIME_CLASS(InformationBarOp)); 01499 BOOL ThisIsAGallery = pOp->IsKindOf(CC_RUNTIME_CLASS(SuperGallery)); 01500 01501 for (UINT32 i = 0; i< NumBarItems; i++) 01502 { 01503 // Get the next BarItem 01504 pBarItem = pOp->GetPtrBarItem(i); 01505 01506 ENSURE(pBarItem != NULL, "NumBarItems is incorrect"); 01507 // Check whether we need to create thin items for double deckers 01508 01509 if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(BarControl))) 01510 { 01511 BarControl * pBarControl = (BarControl*)pBarItem; 01512 if (ThisIsAnInfoBar || ThisIsAGallery) 01513 { 01514 // If the DialogBarOp is an InformationBarOp then the Bar controls 01515 // control ID will be unique for the InformationBar's Message handler 01516 pBarControl->SetUniqueGadgetID( 01517 pBarControl->GetBarControlInfo(pOp->IsHorizontal()).ControlID); 01518 } 01519 else 01520 { 01521 // use index as gadget id 01522 pBarControl->SetUniqueGadgetID(i + 100); 01523 } 01524 // create the control i==0 indicates initialise 01525 if (!CreateInfoControlFromResource(pBarControl,i==0)) 01526 { 01527 // We failed to create the control 01528 //ENSURE(FALSE,"Failed to create control"); 01529 return FALSE ; 01530 } 01531 } 01532 else if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(DDeckerTop))) 01533 { 01534 DDeckerState = DDECKER_TOP; 01535 } 01536 else if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(DDeckerBottom))) 01537 { 01538 DDeckerState = DDECKER_BOTTOM; 01539 } 01540 else if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(DDeckerEnd))) 01541 { 01542 DDeckerState = DDECKER_NONE; 01543 } 01544 } 01545 01546 // call to free resources; 01547 CreateInfoControlFromResource(NULL,0); 01548 return TRUE; 01549 }; 01550 01551 /******************************************************************************************** 01552 01553 > BaseBar::CopyOrLoadResourceControls() 01554 01555 Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> 01556 Created: 11/4/94 01557 Inputs: - 01558 Outputs: - 01559 Returns: - 01560 Purpose: 01561 Errors: - 01562 SeeAlso: - 01563 01564 ********************************************************************************************/ 01565 01566 BOOL BaseBar::CopyOrLoadControls(wxWindow* BarHwnd) 01567 { 01568 PORTNOTETRACE( "dialog", "BaseBar::CopyOrLoadControls - do nothing" ); 01569 #ifndef EXCLUDE_FROM_XARALX 01570 // Find out how many bar items 01571 UINT32 NumBarItems = pOp->GetNumBarItems(); 01572 01573 // track ddecker state 01574 DDeckerState = DDECKER_NONE; 01575 01576 BarItem* pBarItem; 01577 01578 ThisIsAnInfoBar = (pOp->IsKindOf(CC_RUNTIME_CLASS(InformationBarOp))); 01579 01580 for (UINT32 i = 0; i< NumBarItems; i++) 01581 { 01582 // Get the next BarItem 01583 pBarItem = pOp->GetPtrBarItem(i); 01584 01585 ENSURE(pBarItem != NULL, "NumBarItems is incorrect"); 01586 01587 // Check whether we need to create thin items for double deckers 01588 01589 if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(BarControl))) 01590 { 01591 BarControl * pBarControl = (BarControl*)pBarItem; 01592 01593 01594 // Obtain handle to the controls HWnd 01595 HWND hWndControl=(HWND)(pBarControl)->GetWinID(); 01596 // ------------------------------------------------------- 01597 // Find out if the control is copyable 01598 // - This code may appear a little on the brink of insanity, however 01599 // it is neccessary cos windows is edit/combo/list set parently 01600 // challenged. 01601 01602 // Determine the control's class 01603 01604 switch (GetEnumItemType(pBarItem)) 01605 { 01606 case BUTTON: 01607 case LIST: 01608 case COMBO: 01609 case STATIC: 01610 case EDIT: 01611 case BITMAPCOMBO1D: // IF THIS ISN'T HERE - THEN FOR SOME 01612 // BIZARRE REASON - OUR CONTROL CANNOT ACCESS 01613 // ITS DATA, AND CAMELOT FALLS OVER! 01614 case BITMAPCOMBO2D: 01615 { 01616 // The control cannot be copied, so must be recreated from the 01617 // resource. 01618 01619 if (!CreateInfoControlFromResource(pBarControl,i==0)) 01620 { 01621 // We failed to create the control 01622 ENSURE(FALSE,"Failed to create control"); 01623 return(FALSE); 01624 } 01625 } 01626 break; 01627 default : 01628 { 01629 // We can safely copy the control to its new parent 01630 ::SetParent(hWndControl, BarHwnd); 01631 } 01632 break; 01633 } 01634 } 01635 else if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(DDeckerTop))) 01636 { 01637 DDeckerState = DDECKER_TOP; 01638 } 01639 else if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(DDeckerBottom))) 01640 { 01641 DDeckerState = DDECKER_BOTTOM; 01642 } 01643 else if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(DDeckerEnd))) 01644 { 01645 DDeckerState = DDECKER_NONE; 01646 } 01647 } 01648 CreateInfoControlFromResource(NULL,0); 01649 #endif 01650 return TRUE; 01651 }; 01652 01653 01654 /******************************************************************************************** 01655 01656 > BaseBar::GetBarPosition() 01657 01658 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 01659 Created: 25/4/94 01660 Inputs: - 01661 Outputs: - 01662 Returns: Pointer to KernelBarPos Object containing current Slot / Offset 01663 Purpose: - 01664 Errors: - 01665 SeeAlso: - 01666 01667 ********************************************************************************************/ 01668 01669 KernelBarPos * BaseBar::GetBarPosition() 01670 { 01671 #pragma message( __LOCMSG__ "BaseBar::GetBarPosition - do nothing" ) 01672 TRACE( _T("Warning - BaseBar::GetBarPosition called") ); 01673 // return GetMainFrame()->GetDockBar(ParentDockBarType)->GetBarPos(GetSafeHwnd()); 01674 01675 return NULL; 01676 }; 01677 01678 /******************************************************************************************** 01679 01680 > BaseBar::GetDockBarType() 01681 01682 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 01683 Created: 25/4/94 01684 Inputs: - 01685 Outputs: - 01686 Returns: Parent DockBarType 01687 Purpose: - 01688 Errors: - 01689 SeeAlso: - 01690 01691 ********************************************************************************************/ 01692 01693 DockBarType BaseBar::GetDockBarType() 01694 { 01695 01696 return ParentDockBarType; 01697 01698 }; 01699 01700 01701 /******************************************************************************************** 01702 01703 > BaseBar::IsDoubleDecker(BarItem * ThisControl,BarItem * Start,BarItem * End) 01704 01705 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 01706 Created: 18/4/94 01707 Inputs: ThisControl Control to test 01708 Start to return a pointer to first item in the DD 01709 End to return a pointer to last item in the DD 01710 Outputs: Pointers to first and last controls in this group if one found 01711 Returns: DDECKER_NONE / DDECKER_TOP /DDECKER_BOTTOM 01712 Purpose: to determine whether a given control is part of a double decker group 01713 Errors: - 01714 SeeAlso: - 01715 01716 ********************************************************************************************/ 01717 01718 DDeckerReadState BaseBar::IsDoubleDecker(BarItem * ThisControl,BarItem * Start,BarItem * End) 01719 { 01720 BarItem * pBarItem = pOp->GetPtrBarNext(ThisControl) ; 01721 BarItem * LastItem = NULL; 01722 // Test assumes that the bar list will contain DDeckerTop/DDeckerBottom/DDeckerEnd 01723 // in that order 01724 01725 DDeckerReadState State = DDECKER_NONE; 01726 while ( pBarItem != NULL ) 01727 { 01728 01729 if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(DDeckerTop))) 01730 { 01731 State = DDECKER_NONE; 01732 } 01733 01734 else if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(DDeckerBottom))) 01735 { 01736 State = DDECKER_TOP; 01737 } 01738 01739 else if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(DDeckerEnd))) 01740 { 01741 if(State == DDECKER_NONE) 01742 State = DDECKER_BOTTOM; 01743 01744 // point End to last control in group 01745 if(LastItem != NULL && End != NULL) 01746 End = LastItem; 01747 } 01748 01749 // keep a pointer to the last control 01750 else if ( pBarItem->IsKindOf(CC_RUNTIME_CLASS(BarControl))) 01751 { 01752 LastItem = pBarItem; 01753 } 01754 pBarItem = pOp->GetPtrBarNext(pBarItem); 01755 } 01756 01757 // point Start to the first control in this group 01758 if(Start != NULL && State != DDECKER_NONE ) 01759 { 01760 01761 pBarItem = ThisControl; 01762 BarItem * Head = pOp->GetPtrBarHead(); 01763 01764 // run backwards through the list until we find the start 01765 // of the double decker or get to the head of the bar list 01766 while(pBarItem != Head) 01767 { 01768 // check for start of double decker 01769 if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(DDeckerTop))) 01770 { 01771 Start = LastItem; 01772 break; 01773 } 01774 01775 // keep a pointer to the last control 01776 else if ( pBarItem->IsKindOf(CC_RUNTIME_CLASS(BarControl))) 01777 { 01778 LastItem = pBarItem; 01779 } 01780 pBarItem = pOp->GetPtrBarPrev(pBarItem); 01781 } 01782 } 01783 01784 // not a double decker - set Start and End to NULL 01785 if( State == DDECKER_NONE) 01786 Start = End = NULL; 01787 01788 return State; 01789 }; 01790 01791 /******************************************************************************************** 01792 01793 > BaseBar::TidyBarItemsAfterDrag() 01794 01795 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 01796 Created: 18/4/94 01797 Returns: BOOL 01798 Purpose: Tidy up Linefeeds and Separators after dragging controls 01799 Errors: - 01800 SeeAlso: - 01801 01802 ********************************************************************************************/ 01803 01804 BOOL BaseBar::TidyBarItemsAfterDrag() 01805 { 01806 // nothing to tidy 01807 if(pOp->GetNumBarItems()==0) 01808 return TRUE; 01809 01810 // remove any SP's that preceed LF's 01811 BarItem * pBarItem = pOp->GetPtrBarHead(); 01812 while (pBarItem != NULL) 01813 { 01814 if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(BarLineFeed))) 01815 { 01816 BarItem * pLastItem = pOp->GetPtrBarPrev(pBarItem); 01817 if(pLastItem) 01818 { 01819 if(pLastItem->IsKindOf(CC_RUNTIME_CLASS(BarSeparator))) 01820 { 01821 pOp->RemoveBarItem(pLastItem); 01822 delete pLastItem; 01823 } 01824 } 01825 } 01826 pBarItem = pOp->GetPtrBarNext(pBarItem); 01827 } 01828 01829 // stip leading and multiple line feeds - we can get into this state after dragging controls around 01830 BOOL LF = FALSE; 01831 BOOL FoundControl=FALSE; 01832 BarItem * pLastControl = NULL; 01833 pBarItem = pOp->GetPtrBarHead(); 01834 01835 while (pBarItem != NULL) 01836 { 01837 // keep a record of the last control so that we can strip any trailing LFs 01838 if ( pBarItem->IsKindOf(CC_RUNTIME_CLASS(BarControl))) 01839 { 01840 pLastControl = pBarItem; 01841 FoundControl = TRUE; 01842 } 01843 if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(BarLineFeed))) 01844 { 01845 BarItem * pFoundItem = pBarItem; 01846 pBarItem = pOp->GetPtrBarNext(pBarItem); 01847 01848 // either it's a mulitiple (LF is set) or we haven't found any controls yet 01849 if(LF || !FoundControl) 01850 { 01851 pOp->RemoveBarItem(pFoundItem); 01852 delete pFoundItem; 01853 } 01854 else 01855 { 01856 if(FoundControl) 01857 LF = TRUE; 01858 } 01859 } 01860 else 01861 { 01862 LF = FALSE; 01863 pBarItem = pOp->GetPtrBarNext(pBarItem); 01864 } 01865 } 01866 01867 // stip leading and multiple Separators - we can get into this state after dragging controls around 01868 BOOL SP = FALSE; 01869 FoundControl=FALSE; 01870 pLastControl = NULL; 01871 pBarItem = pOp->GetPtrBarHead(); 01872 01873 while (pBarItem != NULL) 01874 { 01875 // keep a record of the last control so that we can strip any trailing SPs 01876 if ( pBarItem->IsKindOf(CC_RUNTIME_CLASS(BarControl))) 01877 { 01878 pLastControl = pBarItem; 01879 FoundControl = TRUE; 01880 } 01881 if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(BarSeparator))) 01882 { 01883 BarItem * pFoundItem = pBarItem; 01884 pBarItem = pOp->GetPtrBarNext(pBarItem); 01885 // either it's a mulitiple (SP is set) or we haven't found any controls yet 01886 if(SP || !FoundControl) 01887 { 01888 pOp->RemoveBarItem(pFoundItem); 01889 delete pFoundItem; 01890 } 01891 else 01892 { 01893 if(FoundControl) 01894 SP = TRUE; 01895 } 01896 } 01897 else 01898 { 01899 SP = FALSE; 01900 pBarItem = pOp->GetPtrBarNext(pBarItem); 01901 } 01902 } 01903 01904 // we don't need anything after the last control 01905 // so.... move past it 01906 pLastControl = pOp->GetPtrBarNext(pLastControl); 01907 01908 // and delete the rest 01909 while(pLastControl) 01910 { 01911 BarItem * pItem = pLastControl; 01912 pLastControl = pOp->GetPtrBarNext(pLastControl); 01913 delete pOp->RemoveBarItem(pItem); 01914 } 01915 01916 return TRUE; 01917 }; 01918 01919 /******************************************************************************************** 01920 01921 > BOOL BaseBar::BaseBar::CacheFormatingData() 01922 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 01923 Created: 12/2/96 01924 Inputs: - 01925 Outputs: - 01926 Returns: Failure/Success 01927 Purpose: Delete and recache bar height to width mapping values - these are required 01928 for vertical sizing - 01929 There is one limitation with this system - we can't use height values to find every 01930 possible format - many widths can map to one height..we compromise and cache the 01931 narrowest width for each height 01932 Errors: - 01933 SeeAlso: - 01934 01935 ********************************************************************************************/ 01936 01937 BOOL BaseBar::CacheFormatingData() 01938 { 01939 // delete the last cache 01940 if(!FormatPositions.IsEmpty()) 01941 FormatPositions.DeleteAll(); 01942 01943 FormatPosition * pNewFP = NULL; 01944 wxSize BarSize(0,0); 01945 wxSize LastBarSize(0,0); 01946 INT32 NoLFs = -1; 01947 01948 // incrementally call FormatLineFeeds - cache the value every time we get a new height 01949 // when there are no LF's in the bar we have found it's widest format 01950 for(INT32 TryWidth = 16;NoLFs!=0;TryWidth +=4) 01951 { 01952 FormatLineFeeds(TryWidth,&BarSize,&NoLFs); 01953 01954 // there may be many valid widths that map to this height 01955 // we just cache the first one 01956 if(BarSize.x != LastBarSize.x) 01957 { 01958 LastBarSize = BarSize; 01959 pNewFP = new FormatPosition( TryWidth, BarSize.x ); 01960 01961 ERROR2IF(pNewFP == NULL,FALSE,"Couldn't create Format Position"); 01962 01963 // we add to new item to the head so that we can search from the shortest up 01964 // in GetBestCachedWidth() 01965 FormatPositions.AddHead((ListItem *)pNewFP); 01966 } 01967 } 01968 01969 return TRUE; 01970 }; 01971 01972 /******************************************************************************************** 01973 01974 > BOOL BaseBar::BaseBar::GetBestCachedWidth(INT32 TargetHeight,INT32 * FoundWidth) 01975 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 01976 Created: 12/2/96 01977 Inputs: TargetHeight: 01978 Outputs: A cached Width 01979 Returns: Failure/Success 01980 Purpose: given a height return a cached Width value to use during vertical resizing 01981 Errors: - 01982 SeeAlso: - 01983 01984 ********************************************************************************************/ 01985 01986 BOOL BaseBar::GetBestCachedWidth(INT32 TargetHeight, INT32 * FoundWidth) 01987 { 01988 ERROR2IF(FormatPositions.IsEmpty(),FALSE,"No Format Cache"); 01989 01990 FormatPosition * pFormatPosition=(FormatPosition *) FormatPositions.GetHead(); 01991 01992 ERROR2IF(pFormatPosition==NULL,FALSE,"No Format Cache"); 01993 01994 INT32 LastWidth = pFormatPosition->Width; 01995 01996 // find the cached Width that maps onto the target height 01997 while (pFormatPosition) 01998 { 01999 // break if we have gone past the target height 02000 if (pFormatPosition->Height>TargetHeight) //found the bar 02001 break; 02002 02003 // record this width - we will output the "last" value 02004 LastWidth = pFormatPosition->Width; 02005 pFormatPosition =(FormatPosition *) FormatPositions.GetNext(pFormatPosition); 02006 02007 }// end while 02008 02009 * FoundWidth = LastWidth; 02010 02011 return TRUE; 02012 }; 02013 02014 /******************************************************************************************** 02015 02016 > BaseBar::FormatLineFeeds(INT32 Targetx,wxSize * pBarSize, INT32 * pNoLFs) 02017 02018 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 02019 Created: 18/4/94 02020 Inputs: TargetWidth 02021 Outputs: wxSize* pBarSize:returns the size of the bar - used during vertical resizing 02022 INT32* pNoLFs:the number of linefeeds in the bar -used during vertical resizing 02023 Returns: - 02024 Purpose: Reformat a floating toolbar 02025 Errors: - 02026 SeeAlso: - 02027 02028 ********************************************************************************************/ 02029 02030 BOOL BaseBar::FormatLineFeeds(INT32 Targetx,wxSize * pBarSize, INT32 * pNoLFs) 02031 { 02032 #pragma message( __LOCMSG__ "BaseBar::FormatLineFeeds - do nothing" ) 02033 TRACE( _T("Warning - BaseBar::FormatLineFeeds called") ); 02034 /* //List is empty just return 02035 if (pOp->IsListEmpty()) 02036 return FALSE; 02037 02038 INT32 xpos = 0; 02039 INT32 WidestControl=0; 02040 INT32 CarryWidth = 0; 02041 INT32 LastWidth = 0; 02042 INT32 StartControlX =0; 02043 INT32 ControlHeight ; 02044 INT32 BarWidth =0; 02045 02046 if(pNoLFs) 02047 (* pNoLFs) = 0; 02048 02049 OILDockingBar * ThisDock ; 02050 ThisDock = GetMainFrame()->GetDockBar(DOCKBAR_FLOAT); 02051 02052 // are we on a big/small dock 02053 if (ThisDock->IsBigControls()) 02054 ControlHeight = LARGEBUTTONHEIGHT; 02055 else 02056 ControlHeight = SMALLBUTTONHEIGHT; 02057 02058 INT32 BarHeight = ControlHeight+TitleBarHeight; // UIC 02059 02060 INT32 DDeckerStart = 0; 02061 INT32 DDeckerEnd = 0; 02062 02063 Targetx += BAR_BORDERSIZE; 02064 02065 BarItem * pBarItem = NULL; 02066 BarItem * SeparatorPtr = NULL; 02067 BarItem * head = NULL; 02068 BOOL GroupSplit = FALSE; 02069 BOOL LastItemWasDDTop = FALSE; 02070 BOOL FirstControlInDecker = FALSE; 02071 BOOL ItsABarItem = FALSE; 02072 DDeckerReadState DDeckerState = DDECKER_NONE; 02073 02074 // Remove the existing linefeeds 02075 pBarItem = pOp->GetPtrBarHead(); 02076 02077 while (pBarItem != NULL) 02078 { 02079 if ( pBarItem->IsKindOf(CC_RUNTIME_CLASS(BarControl))) 02080 { 02081 wxRect WindSize; 02082 ::GetClientRect((HWND)((BarControl*)pBarItem)->GetWinID(),&WindSize); 02083 if(WindSize.GetWidth()>WidestControl) 02084 WidestControl = WindSize.GetWidth(); 02085 } 02086 if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(BarLineFeed))) 02087 { 02088 BarItem * FoundItem = pBarItem; 02089 pBarItem = pOp->GetPtrBarNext(pBarItem); 02090 pOp->RemoveBarItem(FoundItem); 02091 delete FoundItem; 02092 } 02093 else 02094 pBarItem = pOp->GetPtrBarNext(pBarItem); 02095 } 02096 // we can't make the bar narrower than the widest control 02097 if(Targetx <(WidestControl+(BAR_BORDERSIZE*2))) 02098 { 02099 Targetx = WidestControl + (BAR_BORDERSIZE*2) ; 02100 } 02101 //TRACEUSER( "chris", _T("\n -- Format line feeds -- \n\n")); 02102 // Insert new LineFeeds 02103 head = pBarItem = pOp->GetPtrBarHead(); 02104 02105 while ( pBarItem != NULL ) 02106 { 02107 02108 ENSURE(!pBarItem->IsKindOf(CC_RUNTIME_CLASS(BarLineFeed)),"LineFeed still in List"); 02109 // Double Decker stuff... 02110 if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(DDeckerTop))) 02111 { 02112 DDeckerState = DDECKER_TOP; 02113 DDeckerStart = xpos; 02114 LastItemWasDDTop = TRUE; 02115 // TRACEUSER( "chris", _T("DD Top\n")); 02116 } 02117 if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(DDeckerBottom))) 02118 { 02119 DDeckerState = DDECKER_BOTTOM; 02120 DDeckerEnd = xpos; 02121 // go back to start 02122 xpos = DDeckerStart; 02123 // TRACEUSER( "chris", _T("DD Bottom\n")); 02124 } 02125 if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(DDeckerEnd))) 02126 { 02127 DDeckerState = DDECKER_NONE; 02128 if(xpos < DDeckerEnd) 02129 xpos = DDeckerEnd; 02130 // TRACEUSER( "chris", _T("DD End\n")); 02131 } 02132 if ( pBarItem->IsKindOf(CC_RUNTIME_CLASS(BarSeparator)) ) 02133 { 02134 if( DDeckerState == DDECKER_NONE) 02135 { 02136 if(pBarItem!=head) 02137 { 02138 SeparatorPtr = pBarItem; 02139 CarryWidth = xpos; 02140 } 02141 } 02142 xpos += SeparatorWidth; 02143 } 02144 else if ( (ItsABarItem = pBarItem->IsKindOf(CC_RUNTIME_CLASS(BarControl)))||DDeckerState != DDECKER_NONE ) 02145 { 02146 if ( ItsABarItem) 02147 { 02148 wxRect WindSize; 02149 ::GetClientRect((HWND)((BarControl*)pBarItem)->GetWinID(),&WindSize); 02150 02151 LastWidth = WindSize.GetWidth(); 02152 xpos += WindSize.GetWidth(); 02153 // we need a record of the widest line 02154 if(xpos>BarWidth) 02155 BarWidth= xpos; 02156 FirstControlInDecker = FALSE; 02157 if(LastItemWasDDTop) 02158 { 02159 FirstControlInDecker = TRUE; 02160 LastItemWasDDTop = FALSE; 02161 } 02162 // TRACEUSER( "chris", _T("Control Size %d"),LastWidth); 02163 } 02164 // TRACEUSER( "chris", _T("targetx - %d xpos - %d \n"),Targetx,xpos); 02165 // Control overlaps TargetWidth - don't insert at head of list 02166 if ( xpos >= Targetx && pBarItem != head) 02167 { 02168 // We can't split if we are in a double decker control 02169 BOOL CanSplit = FALSE; 02170 if(FirstControlInDecker) 02171 CanSplit = TRUE; 02172 if(DDeckerState == DDECKER_NONE) 02173 CanSplit = TRUE; 02174 // TRACEUSER( "chris", _T("%s\n",CanSplit ?"Can Split ":"Can't Split")); 02175 if(CanSplit) 02176 { 02177 BarItem * NewLineFeed = new BarLineFeed; 02178 if(pNoLFs) 02179 (* pNoLFs)++; 02180 BarHeight += ControlHeight+VERTICAL_SPACE; 02181 if ( SeparatorPtr != NULL ) // insert a LineFeed before the last separator 02182 { 02183 pOp->InsertItemBefore(SeparatorPtr,NewLineFeed); 02184 SeparatorPtr = NULL; 02185 xpos -= CarryWidth; // decrease xpos by pos of last separator 02186 DDeckerStart = xpos; 02187 GroupSplit = FALSE; 02188 BarHeight += SeparatorWidth; 02189 // TRACEUSER( "chris", _T("Separator split - xpos %d\n"),xpos); 02190 } 02191 else // no separator on this line 02192 { 02193 02194 if(!FirstControlInDecker) 02195 pOp->InsertItemBefore(pBarItem,NewLineFeed); 02196 else 02197 pOp->InsertItemBefore(pOp->GetPtrBarPrev(pBarItem),NewLineFeed); 02198 xpos = LastWidth; // xpos set to width of last control 02199 if(FirstControlInDecker) 02200 DDeckerStart = xpos-LastWidth; 02201 GroupSplit = TRUE ; // we must have split a group 02202 // TRACEUSER( "chris", _T("Normal split - xpos %d\n"),xpos); 02203 //LastWidth = 0; 02204 } 02205 } 02206 } 02207 else if (GroupSplit && SeparatorPtr) 02208 { 02209 02210 BarItem * NewLineFeed = new BarLineFeed; 02211 if(pNoLFs) 02212 (* pNoLFs)++; 02213 pOp->InsertItemBefore(SeparatorPtr,NewLineFeed); 02214 SeparatorPtr = NULL; 02215 xpos -= CarryWidth; // decrease xpos by pos of last separator 02216 DDeckerStart = xpos; 02217 GroupSplit = FALSE; 02218 // TRACEUSER( "chris", _T("Group split - xpos %d\n"),xpos); 02219 BarHeight += ControlHeight+VERTICAL_SPACE + SeparatorWidth; 02220 } 02221 } 02222 pBarItem = pOp->GetPtrBarNext(pBarItem); 02223 } 02224 02225 HeightEstimate = BarHeight; 02226 if(pBarSize) 02227 * pBarSize = wxSize(BarWidth,BarHeight); */ 02228 return TRUE; 02229 }; 02230 02231 02232 /******************************************************************************************** 02233 02234 > BaseBar::GetNearestControl(wxPoint DropPnt) 02235 02236 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 02237 Created: 18/4/94 02238 Inputs: - 02239 Outputs: - 02240 Returns: An index to place the new control in the bar item list 02241 Purpose: Return the nearest control given a mouse position in client coords 02242 Errors: - 02243 SeeAlso: - 02244 02245 ********************************************************************************************/ 02246 02247 UINT32 BaseBar::GetNearestControl(wxPoint DropPoint) 02248 { 02249 #pragma message( __LOCMSG__ "BaseBar::GetNearestControl - do nothing" ) 02250 TRACE( _T("Warning - BaseBar::GetNearestControl called") ); 02251 /* HWND hcontrol; // handle of current control 02252 INT32 ControlIndex = 0; // index in bar item list 02253 BarItem * pBarItem; // baritem pointer 02254 BarItemType ThisControl; // type of current item 02255 DDeckerReadState DDeckerState = DDECKER_NONE; // enum to record current double decker state 02256 // check orientation of the bar we are dropping on 02257 BOOL bIsHorizontal = pOp->IsHorizontal(); 02258 02259 02260 // if the bar is empty it must be the first item on the list 02261 if (pOp->IsListEmpty()) 02262 return ControlIndex ; 02263 02264 // get head item of the bar item list 02265 pBarItem = pOp->GetPtrBarHead(); 02266 02267 while (pBarItem != NULL) 02268 { 02269 02270 ThisControl = GetEnumItemType(pBarItem); 02271 // Double Decker stuff... 02272 switch(ThisControl) 02273 { 02274 case DECKER_TOP: 02275 DDeckerState = DDECKER_TOP; 02276 break; 02277 case DECKER_BOTTOM: 02278 DDeckerState = DDECKER_BOTTOM; 02279 break; 02280 case DECKER_END: 02281 DDeckerState = DDECKER_NONE; 02282 break; 02283 } 02284 02285 if(DDeckerState != DDECKER_TOP) 02286 { 02287 if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(BarControl))) 02288 { 02289 02290 // get the handle 02291 hcontrol=(HWND)((BarControl*)pBarItem)->GetWinID(); 02292 02293 // Get window rect - screen coords 02294 wxRect WindSize; 02295 ::GetWindowRect(hcontrol,&WindSize); 02296 02297 // to Client - mouse messages are in client coords 02298 ScreenToClient(&WindSize); 02299 02300 // expand the rect slightly to the top and bottom 02301 wxRect HitTest(WindSize.GetLeft(),WindSize.GetTop()-4,WindSize.GetRight(),WindSize.GetBottom()+4); 02302 02303 // check the next item - if it's a line feed we might have a load of empty space to the right 02304 // of this control - in which case we'll expand the hit test rect to include it 02305 BarItem * pNextBarItem = pOp->GetPtrBarNext(pBarItem); 02306 if(pNextBarItem ) 02307 { 02308 if(bIsHorizontal) 02309 { 02310 if(pNextBarItem->IsKindOf(CC_RUNTIME_CLASS(BarLineFeed))) 02311 { 02312 wxRect ThisWindowRect; 02313 GetWindowRect(&ThisWindowRect); 02314 HitTest.GetRight() += (ThisWindowRect.GetRight() - WindSize.GetRight()); 02315 } 02316 else if (pNextBarItem->IsKindOf(CC_RUNTIME_CLASS(BarControl))) 02317 { 02318 // get the handle 02319 HWND hNextControl=(HWND)((BarControl*)pNextBarItem)->GetWinID(); 02320 // Get window rect - screen coords 02321 wxRect NextWindSize; 02322 ::GetWindowRect(hNextControl,&NextWindSize); 02323 // to Client - mouse messages are in client coords 02324 ScreenToClient(&NextWindSize); 02325 02326 // the hit test area should extends from the control's left edge 02327 // to the next control's left edge 02328 if(NextWindSize.GetLeft() > HitTest.GetRight()) 02329 HitTest.GetRight() = NextWindSize.GetLeft(); 02330 } 02331 } 02332 BarItem * pLastBarItem = pOp->GetPtrBarPrev(pBarItem); 02333 if(pLastBarItem) 02334 { 02335 if (pLastBarItem->IsKindOf(CC_RUNTIME_CLASS(BarSeparator))) 02336 { 02337 if(bIsHorizontal) 02338 HitTest.GetLeft() -= SeparatorWidth; 02339 else 02340 HitTest.GetTop() -=SeparatorWidth; 02341 } 02342 } 02343 } 02344 02345 // if the mouse is in this area we have found our drop point 02346 if(HitTest.PtInRect(DropPoint)) 02347 return ControlIndex ; 02348 02349 } 02350 } 02351 02352 // increment index 02353 ControlIndex ++; 02354 02355 // we skip past the dragged control as it will be deleted later 02356 // this avoids the problem where a control is dropped into the 02357 // correct place only to be shifted to the left after the original control is deleted 02358 if(DragCtlHwnd==hcontrol) 02359 ControlIndex ++; 02360 02361 // move to next item 02362 pBarItem = pOp->GetPtrBarNext(pBarItem); 02363 } 02364 02365 // off the end ! 02366 // return index of last item 02367 return pOp->GetNumBarItems(); */ 02368 02369 return (UINT32)-1; 02370 }; 02371 02372 02373 /**************************************************************************** 02374 02375 > BOOL BaseBar::FormatToolBar (INT32 NewWidth) 02376 02377 Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> 02378 Created: 16/11/2004 02379 02380 Inputs: NewWidth - 02381 Returns: TRUE if ok, FALSE if bother 02382 Purpose: 02383 02384 ****************************************************************************/ 02385 02386 BOOL BaseBar::FormatToolBar (INT32 NewWidth) 02387 { 02388 if (this != PtrToToolBar) 02389 { 02390 return (FALSE); 02391 } 02392 else 02393 { 02394 FormatLineFeeds (NewWidth); 02395 FormatFloatingBar(FALSE,USE_BAR); 02396 02397 return (TRUE); 02398 } 02399 } 02400 02401 02402 02403 02404 /**************************************************************************** 02405 02406 > BOOL BaseBar::FormatBar(BOOL MoveWindows,ForceControlSize ForceSize) 02407 02408 Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> 02409 Created: 16/11/2004 02410 02411 Inputs: MoveWindows - 02412 ForceSize - 02413 Returns: TRUE if ok, FALSE if bother 02414 Purpose: 02415 02416 ****************************************************************************/ 02417 02418 BOOL BaseBar::FormatBar(BOOL MoveWindows,ForceControlSize ForceSize) 02419 { 02420 switch(ParentDockBarType) 02421 { 02422 case DOCKBAR_FLOAT: 02423 return(FormatFloatingBar(MoveWindows, ForceSize)); 02424 break; 02425 02426 case DOCKBAR_TOP: 02427 case DOCKBAR_BOTTOM: 02428 return(FormatHorizontalBar(MoveWindows, ForceSize)); 02429 break; 02430 02431 case DOCKBAR_LEFT: 02432 case DOCKBAR_RIGHT: 02433 return(FormatVerticalBar(MoveWindows, ForceSize)); 02434 break; 02435 02436 default: 02437 break; 02438 } 02439 return(FALSE); 02440 } 02441 02442 02443 /******************************************************************************************** 02444 02445 > BaseBar::FormatFloatingBar(BOOL MoveWindows,ForceControlSize Force) 02446 02447 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 02448 Created: 18/4/94 02449 Inputs: MoveWindows - flag to force a set window pos on the controls 02450 Force normally we use the current dock size to format the bar - sometimes 02451 however we need to know how big the bar would be large or small. 02452 Outputs: - 02453 Returns: TRUE 02454 Purpose: Format a floating toolbar with separators and newlines 02455 Errors: - 02456 SeeAlso: - 02457 02458 ********************************************************************************************/ 02459 02460 BOOL BaseBar::FormatFloatingBar(BOOL MoveWindows,ForceControlSize ForceSize) 02461 { 02462 // TRACEUSER( "Gerry", _T("FormatFloatingBar\n")); 02463 02464 #pragma message( __LOCMSG__ "BaseBar::FormatFloatingBar - do nothing" ) 02465 TRACE( _T("Warning - BaseBar::FormatFloatingBar called") ); 02466 /* HWND hcontrol; 02467 wxSize BarSize(0,0); 02468 INT32 xpos = BAR_BORDERSIZE; 02469 INT32 ypos = BAR_BORDERSIZE; 02470 INT32 yOffset = 0; 02471 INT32 MaxWidth = 0; 02472 INT32 DDeckerStart = 0; 02473 INT32 DDeckerEnd = 0; 02474 02475 BarItem * pBarItem; 02476 BarItem * LastItem = NULL; 02477 02478 // Check Current Control Sizes in this Docking Bar 02479 INT32 ControlWidth = 0; 02480 INT32 ControlHeight = 0; 02481 ControlSizes ControlSize; 02482 02483 DDeckerReadState DDeckerState = DDECKER_NONE; 02484 DDeckerControlHeights DDeckerHeight = SMALL_DDECKERS; 02485 02486 //if we are dragging a bar check the size of the dock we are over 02487 // otherwise use control size of parent dock 02488 OILDockingBar * ThisDock ; 02489 DockBarType CurrentType; 02490 02491 CurrentType = (DragType==MOVE) ? DragDockBarType : ParentDockBarType; 02492 ThisDock = GetMainFrame()->GetDockBar(CurrentType); 02493 02494 BarItemType ThisControl; 02495 BarItemType LastControl = OTHERCONTROL; 02496 02497 INT32 LargeWidth = LARGEBUTTONWIDTH; 02498 INT32 LargeHeight = LARGEBUTTONHEIGHT; 02499 INT32 SmallWidth = SMALLBUTTONWIDTH; 02500 INT32 SmallHeight = SMALLBUTTONHEIGHT; 02501 INT32 Control =0; 02502 02503 // Get the current control size for this dock 02504 if (ForceSize == USE_BAR) 02505 { 02506 if (ThisDock->IsBigControls()) 02507 { 02508 ControlWidth = LargeWidth; 02509 ControlHeight = LargeHeight; 02510 } 02511 else 02512 { 02513 ControlWidth = SmallWidth; 02514 ControlHeight = SmallHeight; 02515 } 02516 } 02517 else if (ForceSize == FORCE_LARGE) 02518 { 02519 ControlWidth = LargeWidth; 02520 ControlHeight = LargeHeight; 02521 02522 } 02523 else if (ForceSize == FORCE_SMALL) 02524 { 02525 ControlWidth = SmallWidth; 02526 ControlHeight = SmallHeight; 02527 } 02528 02529 02530 if (ControlHeight == LargeHeight ) 02531 { 02532 ControlSize = LARGE_CONTROLS; 02533 DDeckerHeight = LARGE_DDECKERS ; 02534 } 02535 else 02536 { 02537 ControlSize = SMALL_CONTROLS; 02538 DDeckerHeight = SMALL_DDECKERS ; 02539 } 02540 // if list is empty just set a minimum size 02541 if (! pOp->IsListEmpty()) 02542 { 02543 // TRACEUSER( "chris", _T("\n --- FORMAT ---\n")); 02544 pBarItem = pOp->GetPtrBarHead(); 02545 02546 while (pBarItem != NULL) 02547 { 02548 ThisControl = GetEnumItemType(pBarItem); 02549 // Double Decker stuff... 02550 switch(ThisControl) 02551 { 02552 case DECKER_TOP: 02553 { 02554 DDeckerState = DDECKER_TOP; 02555 // xpos to come back to 02556 DDeckerStart = xpos; 02557 } 02558 break; 02559 case DECKER_BOTTOM: 02560 { 02561 DDeckerState = DDECKER_BOTTOM; 02562 // extent of double decker 02563 DDeckerEnd = xpos; 02564 // go back to start 02565 xpos = DDeckerStart; 02566 02567 } 02568 break; 02569 case DECKER_END: 02570 { 02571 DDeckerState = DDECKER_NONE; 02572 // check for longest line top or bottom ? 02573 if(xpos < DDeckerEnd) 02574 xpos = DDeckerEnd; 02575 } 02576 break; 02577 case SEPARATOR: 02578 // insert a separator normally this is horizontal but if the last control was 02579 // a LineFeed we do a vertical separator 02580 { 02581 if(LastItem) 02582 { 02583 if (LastItem->IsKindOf(CC_RUNTIME_CLASS(BarLineFeed))) 02584 ypos += SeparatorWidth; 02585 else 02586 xpos += SeparatorWidth; 02587 } 02588 // TRACEUSER( "chris", _T("Separator\n")); 02589 } 02590 break; 02591 case LINEFEED: 02592 // move down to next line and reset xpos 02593 { 02594 ypos += ControlHeight+VERTICAL_SPACE; // Move down to the next line 02595 if(IS_CHICAGO && pOp->IsKindOf(CC_RUNTIME_CLASS(SuperGallery))) 02596 ypos +=4; 02597 xpos = BAR_BORDERSIZE; 02598 DDeckerStart = xpos; 02599 } 02600 break; 02601 } 02602 if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(BarControl))) 02603 { 02604 // TRACEUSER( "chris", _T("Control\n")); 02605 hcontrol=(HWND)((BarControl*)pBarItem)->GetWinID(); // Get the Window Handle 02606 wxRect WindSize; 02607 02608 ::GetClientRect(hcontrol,&WindSize); // Get the window size 02609 switch (DDeckerState) 02610 { 02611 case DDECKER_TOP: 02612 if(ThisControl == SMALLBITMAPBUTTON) 02613 { 02614 if (ControlSize == LARGE_CONTROLS) 02615 yOffset = (ControlHeight / 2) - sLARGEBUTTONHEIGHT +1; //get offset to center control 02616 else 02617 yOffset = (ControlHeight / 2) - sSMALLBUTTONHEIGHT +1; 02618 xpos++; 02619 } 02620 else 02621 { 02622 yOffset = (ControlHeight / 2) - // WindSize.GetHeight()+1; 02623 DDeckerHeight + 1 ; 02624 } 02625 02626 // bodge to center static text 02627 if(ThisControl == STATIC) 02628 yOffset +=3; 02629 02630 break; 02631 case DDECKER_BOTTOM : 02632 yOffset = (ControlHeight / 2) ; //get offset to center control 02633 // bodge to center static text 02634 if(ThisControl == STATIC) 02635 yOffset +=3; 02636 if ( ThisControl == SMALLBITMAPBUTTON) 02637 { 02638 yOffset ++ ; 02639 xpos ++; 02640 } 02641 if(IS_CHICAGO) 02642 { 02643 yOffset ++; 02644 } 02645 break; 02646 case DDECKER_NONE : 02647 yOffset = (ControlHeight - WindSize.GetHeight()) / 2; //get offset to center control 02648 break; 02649 } 02650 02651 if (MoveWindows) 02652 ::SetWindowPos(hcontrol,NULL,xpos,ypos + yOffset,0,0, // Move the control 02653 SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOZORDER|SWP_NOREDRAW); 02654 02655 xpos += WindSize.GetWidth()-1; 02656 if(ThisControl == STATICBITMAP) 02657 xpos ++; 02658 else if(ThisControl == SLIDER) 02659 xpos +=4; 02660 LastControl = ThisControl ; 02661 02662 if(IS_CHICAGO) 02663 { 02664 if(ThisControl == EDIT) 02665 xpos += 2; 02666 } 02667 02668 } 02669 02670 // keep MaxWidth up to date 02671 if (xpos > MaxWidth) 02672 MaxWidth = xpos; 02673 02674 // remember last control 02675 LastItem = pBarItem; 02676 02677 // move to next item 02678 pBarItem = pOp->GetPtrBarNext(pBarItem); 02679 } 02680 02681 02682 // 02683 BarSize.width = MaxWidth + BAR_BORDERSIZE + (BorderWidth * 2) + 1 ; 02684 BarSize.cx = ypos + ControlHeight + BAR_BORDERSIZE + (BorderWidth * 2) ; 02685 02686 } 02687 // Set a Minimum Bar Height 02688 if (BarSize.cx < ControlHeight + (BAR_BORDERSIZE)+ (BorderWidth * 2)) 02689 BarSize.cx = ControlHeight + (BAR_BORDERSIZE)+ (BorderWidth * 2); 02690 02691 // ---------------------------- 02692 // Set a Minimum Bar Width 02693 02694 String_32 Name = pOp->GetName(); 02695 02696 INT32 SmallestWidth = ControlWidth + (BAR_BORDERSIZE * 2)+ (BorderWidth * 2); 02697 02698 // If this an empty bar make sure we can see the title 02699 if (pOp->IsListEmpty()) 02700 { 02701 // Select the title font into a screen dc and get the text extent of the title 02702 wxDC *dc = GetWindowDC(); 02703 02704 wxFont * OldFont=dc->SelectObject(TitleFont); 02705 02706 wxSize TextSize=dc->GetTextExtent(Name,camStrlen(Name)); 02707 02708 dc->SelectObject(OldFont); 02709 02710 ReleaseDC(dc); 02711 02712 // Check that the title string will be visible UIC 02713 if ((TextSize.width + TitleBarHeight + (BorderWidth * 4) ) > SmallestWidth) 02714 SmallestWidth = TextSize.width + TitleBarHeight + (BorderWidth * 4); 02715 } 02716 02717 02718 if (BarSize.width < SmallestWidth) 02719 BarSize.width = SmallestWidth ; 02720 02721 AdjustFormattedBarSize(&BarSize); 02722 if (MoveWindows) 02723 PositionExtraControls(BarSize,xpos,ypos+ControlHeight); 02724 // Cache the rectangle 02725 if (ForceSize == USE_BAR) 02726 { 02727 if (ThisDock->IsBigControls()) 02728 { 02729 FloatLargeRect.GetRight() = BarSize.width; 02730 FloatLargeRect.GetBottom() = BarSize.cx + TitleBarHeight; // UIC 02731 } 02732 else 02733 { 02734 FloatSmallRect.GetRight() = BarSize.width; 02735 FloatSmallRect.GetBottom() = BarSize.cx + TitleBarHeight; // UIC 02736 } 02737 } 02738 else if (ForceSize == FORCE_LARGE) 02739 { 02740 FloatLargeRect.GetRight() = BarSize.width; 02741 FloatLargeRect.GetBottom() = BarSize.cx + TitleBarHeight; // UIC 02742 } 02743 else if (ForceSize == FORCE_SMALL) 02744 { 02745 FloatSmallRect.GetRight() = BarSize.width; 02746 FloatSmallRect.GetBottom() = BarSize.cx + TitleBarHeight; // UIC 02747 } */ 02748 return TRUE; 02749 }; 02750 02751 /******************************************************************************************** 02752 02753 > BaseBar::FormatHorizontalBar(BOOL MoveWindows,ForceControlSize Force) 02754 02755 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 02756 Created: 18/4/94 02757 Inputs: 02758 MoveWindows - flag to force a set window pos on the controls 02759 Force normally we use the current dock size to format the bar - sometimes 02760 however we need to know how big the bar would be large or small. 02761 Outputs: - 02762 Returns: - 02763 Purpose: Format a Horizontal toolbar with separators 02764 Errors: - 02765 SeeAlso: - 02766 02767 ********************************************************************************************/ 02768 BOOL BaseBar::FormatHorizontalBar(BOOL MoveControls,ForceControlSize ForceSize) 02769 { 02770 // TRACEUSER( "Gerry", _T("FormatHorizontalBar\n")); 02771 02772 #pragma message( __LOCMSG__ "BaseBar::FormatHorizontalBar - do nothing" ) 02773 TRACE( _T("Warning - BaseBar::FormatHorizontalBar called") ); 02774 /* BOOL AtFront = TRUE; 02775 HWND hcontrol; 02776 // Find out how many bar items 02777 UINT32 NumBarItems = pOp->GetNumBarItems(); 02778 INT32 ypos = 0 ; 02779 INT32 xpos = BAR_BORDERSIZE; 02780 INT32 yOffset = 0; 02781 INT32 DDeckerStart = 0; 02782 INT32 DDeckerEnd = 0; 02783 wxSize BarSize(0,0); 02784 BarItem* pBarItem; 02785 ControlSizes ControlSize; 02786 DDeckerReadState DDeckerState = DDECKER_NONE; 02787 DDeckerControlHeights DDeckerHeight = SMALL_DDECKERS; 02788 INT32 ButtonSize; 02789 BarItemType ThisControl ; 02790 BarItemType LastControl = OTHERCONTROL; 02791 // if we are dragging a bar check the size of the dock we are over 02792 // otherwise use control size of parent dock 02793 02794 OILDockingBar * ThisDock ; 02795 DockBarType CurrentType; 02796 02797 CurrentType = (DragType==MOVE) ? DragDockBarType : ParentDockBarType; 02798 ThisDock = GetMainFrame()->GetDockBar(CurrentType); 02799 02800 // Get the current control size for this dock 02801 if (ForceSize == USE_BAR) 02802 { 02803 if (ThisDock->IsBigControls()) 02804 ControlSize = LARGE_CONTROLS; 02805 else 02806 ControlSize = SMALL_CONTROLS; 02807 } 02808 else if (ForceSize == FORCE_LARGE) 02809 { 02810 ControlSize = LARGE_CONTROLS; 02811 } 02812 else if (ForceSize == FORCE_SMALL) 02813 { 02814 ControlSize = SMALL_CONTROLS; 02815 } 02816 02817 02818 if (ControlSize == LARGE_CONTROLS) 02819 { 02820 ButtonSize = LARGEBUTTONWIDTH-1; 02821 DDeckerHeight = LARGE_DDECKERS ; 02822 } 02823 else 02824 { 02825 ButtonSize = SMALLBUTTONWIDTH-1; 02826 DDeckerHeight = SMALL_DDECKERS ; 02827 } 02828 // if list is empty just set a minimum size 02829 if (! pOp->IsListEmpty()||ThisIsAnInfoBar) 02830 { 02831 02832 pBarItem = pOp->GetPtrBarHead(); 02833 02834 while(pBarItem!=NULL) 02835 { 02836 // Get the next BarItem 02837 ThisControl = GetEnumItemType(pBarItem); 02838 switch ( ThisControl ) 02839 { 02840 case DECKER_TOP: 02841 { 02842 DDeckerState = DDECKER_TOP; 02843 // xpos to come back to 02844 DDeckerStart = xpos; 02845 } 02846 break; 02847 case DECKER_BOTTOM: 02848 { 02849 DDeckerState = DDECKER_BOTTOM; 02850 // extent of double decker 02851 DDeckerEnd = xpos; 02852 // go back to start 02853 xpos = DDeckerStart; 02854 02855 } 02856 break; 02857 case DECKER_END: 02858 { 02859 DDeckerState = DDECKER_NONE; 02860 // check for longest line top or bottom ? 02861 if ( xpos < DDeckerEnd) 02862 xpos = DDeckerEnd; 02863 } 02864 break; 02865 case SEPARATOR: 02866 { 02867 if( ! AtFront ) // don't separate at the front of a bar 02868 { 02869 xpos += SeparatorWidth; 02870 } 02871 } 02872 break; 02873 } 02874 02875 if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(BarControl))) 02876 { 02877 hcontrol=(HWND)((BarControl*)pBarItem)->GetWinID(); // Get the Window Handle 02878 02879 wxRect WindSize; 02880 ::GetClientRect(hcontrol,&WindSize); 02881 switch (DDeckerState) 02882 { 02883 case DDECKER_TOP: 02884 02885 // this is all rather messy because SMALLBITMAPBUTTONS and Chicago 02886 // buttons don't overlap where normal pre chicago buttons do ... 02887 02888 if ( ThisControl == SMALLBITMAPBUTTON) 02889 { 02890 if (ControlSize == LARGE_CONTROLS) 02891 yOffset = (ControlSize / 2) - sLARGEBUTTONHEIGHT +1 ; //get offset to center control 02892 else 02893 yOffset = (ControlSize / 2) - sSMALLBUTTONHEIGHT +1 ; 02894 02895 xpos++; 02896 } 02897 else 02898 { 02899 yOffset = (ControlSize / 2) - DDeckerHeight +1; 02900 02901 } 02902 // bodge to center static text 02903 if(ThisControl == STATIC) 02904 yOffset +=3; 02905 02906 02907 break; 02908 case DDECKER_BOTTOM : 02909 02910 yOffset = (ControlSize / 2) ; //get offset to center control 02911 02912 if ( ThisControl == SMALLBITMAPBUTTON) 02913 { 02914 yOffset ++ ; 02915 xpos ++; 02916 } 02917 if ( ThisControl == STATIC) 02918 { 02919 yOffset +=3; 02920 } 02921 break; 02922 case DDECKER_NONE : 02923 yOffset = (ControlSize - WindSize.GetHeight()) / 2; //get offset to center control 02924 break; 02925 } 02926 if ( MoveControls ) 02927 ::SetWindowPos(hcontrol,NULL,xpos,ypos + yOffset,0,0, 02928 SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOZORDER|SWP_NOREDRAW); 02929 02930 xpos += WindSize.GetWidth()-1; 02931 02932 if(ThisControl == STATICBITMAP) 02933 xpos++; 02934 02935 LastControl = ThisControl ; 02936 if(IS_CHICAGO) 02937 { 02938 if(ThisControl == EDIT) 02939 xpos += 2; 02940 } 02941 } 02942 AtFront = FALSE; 02943 pBarItem = pOp->GetPtrBarNext(pBarItem); 02944 }// end while 02945 02946 BarSize.width = xpos + (BAR_BORDERSIZE*2)-1; 02947 02948 } 02949 // Set a Minimum Bar Size 02950 if (BarSize.width < ControlSize + (BAR_BORDERSIZE *2)) 02951 { 02952 BarSize.width = ControlSize + (BAR_BORDERSIZE *2); 02953 } 02954 02955 // This test forces horizontal infobars to be a set width 02956 if (ThisIsAnInfoBar && ! pOp->IsKindOf(CC_RUNTIME_CLASS(SuperGallery))) 02957 { 02958 if(ControlSize == LARGE_CONTROLS) 02959 BarSize.width = LARGE_INFO_BAR; 02960 else 02961 BarSize.width = SMALL_INFO_BAR; 02962 } 02963 02964 BarSize.cx = ControlSize +1; 02965 02966 if(IS_CHICAGO) 02967 BarSize.height--; 02968 02969 // Cache this bar size 02970 if (ForceSize == USE_BAR) 02971 { 02972 if (ThisDock->IsBigControls()) 02973 { 02974 HorizontalLargeRect.GetRight() = BarSize.width; 02975 HorizontalLargeRect.GetBottom() = BarSize.height; 02976 } 02977 else 02978 { 02979 HorizontalSmallRect.GetRight() = BarSize.width; 02980 HorizontalSmallRect.GetBottom() = BarSize.height; 02981 } 02982 } 02983 else if (ForceSize == FORCE_LARGE) 02984 { 02985 HorizontalLargeRect.GetRight() = BarSize.width; 02986 HorizontalLargeRect.GetBottom() = BarSize.height; 02987 } 02988 else if (ForceSize == FORCE_SMALL) 02989 { 02990 HorizontalSmallRect.GetRight() = BarSize.width; 02991 HorizontalSmallRect.GetBottom() = BarSize.height; 02992 } */ 02993 return TRUE; 02994 }; 02995 02996 02997 02998 02999 /******************************************************************************************** 03000 03001 > BaseBar::FormatVerticalBar(BOOL MoveWindows,ForceControlSize Force) 03002 03003 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 03004 Created: 18/4/94 03005 Inputs: 03006 MoveWindows - flag to force a set window pos on the controls 03007 Force normally we use the current dock size to format the bar - sometimes 03008 however we need to know how big the bar would be large or small. 03009 Outputs: - 03010 Returns: - 03011 Purpose: Format a Vertical toolbar with separators 03012 Errors: - 03013 SeeAlso: - 03014 03015 ********************************************************************************************/ 03016 03017 03018 BOOL BaseBar::FormatVerticalBar(BOOL MoveControls,ForceControlSize ForceSize) 03019 { 03020 // TRACEUSER( "Gerry", _T("FormatVerticalBar\n")); 03021 #pragma message( __LOCMSG__ "BaseBar::FormatVerticalBar - do nothing" ) 03022 TRACE( _T("Warning - BaseBar::FormatVerticalBar called") ); 03023 /* BOOL AtFront = TRUE; 03024 HWND hcontrol; 03025 03026 // Find out how many bar items 03027 UINT32 NumBarItems = pOp->GetNumBarItems(); 03028 INT32 xpos = BAR_VERTICAL_CENTEROFFSET; 03029 INT32 ypos = BAR_BORDERSIZE; 03030 BarItem* pBarItem; 03031 BarItemType ThisControl; 03032 ControlSizes ControlSize; 03033 INT32 ButtonSize; 03034 03035 wxSize BarSize(0,0) ; 03036 03037 //if we are dragging a bar check the size of the dock we are over 03038 // otherwise use control size of parent dock 03039 OILDockingBar * ThisDock ; 03040 DockBarType CurrentType; 03041 03042 CurrentType = (DragType==MOVE) ? DragDockBarType : ParentDockBarType; 03043 ThisDock = GetMainFrame()->GetDockBar(CurrentType); 03044 03045 // Get the current control size for this dock 03046 if (ForceSize == USE_BAR) 03047 { 03048 if (ThisDock->IsBigControls()) 03049 ControlSize = LARGE_CONTROLS; 03050 else 03051 ControlSize = SMALL_CONTROLS; 03052 } 03053 else if (ForceSize == FORCE_LARGE) 03054 { 03055 ControlSize = LARGE_CONTROLS; 03056 } 03057 else if (ForceSize == FORCE_SMALL) 03058 { 03059 ControlSize = SMALL_CONTROLS; 03060 } 03061 03062 if (ControlSize == LARGE_CONTROLS) 03063 ButtonSize = LARGEBUTTONHEIGHT-1; 03064 else 03065 ButtonSize = SMALLBUTTONHEIGHT-1; 03066 03067 // if list is empty just set a minimum size 03068 if (! pOp->IsListEmpty()) 03069 { 03070 03071 pBarItem = pOp->GetPtrBarHead(); 03072 while (pBarItem != NULL) 03073 { 03074 ThisControl = GetEnumItemType(pBarItem); 03075 if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(BarSeparator))) 03076 { 03077 if(!AtFront ) // don't separate at the front of a bar 03078 { 03079 ypos += SeparatorWidth; 03080 } 03081 } 03082 else if (pBarItem->IsKindOf(CC_RUNTIME_CLASS(BarControl))) 03083 { 03084 hcontrol=(HWND)((BarControl*)pBarItem)->GetWinID(); // Get the Window Handle 03085 wxRect WindSize; 03086 ::GetClientRect(hcontrol,&WindSize); 03087 INT32 Offset = (ControlSize - WindSize.GetWidth())/2; 03088 if (MoveControls) 03089 ::SetWindowPos(hcontrol,NULL,Offset,ypos,0,0, 03090 SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOZORDER|SWP_NOREDRAW); 03091 03092 if(ThisControl == SLIDER) 03093 { 03094 ypos += WindSize.GetHeight(); 03095 } 03096 else 03097 { 03098 ypos += ButtonSize; 03099 } 03100 } 03101 AtFront = FALSE; 03102 pBarItem = pOp->GetPtrBarNext(pBarItem); 03103 } 03104 03105 BarSize.height = ypos + (BAR_BORDERSIZE*2)-1; 03106 } 03107 // Set a Minimum Bar Size 03108 if (BarSize.height < ControlSize + (BAR_BORDERSIZE *2)) 03109 BarSize.height = ControlSize + (BAR_BORDERSIZE *2); 03110 03111 BarSize.width = ControlSize +1; 03112 03113 if(IS_CHICAGO) 03114 BarSize.width--; 03115 03116 if (ForceSize == USE_BAR) 03117 { 03118 if (ThisDock->IsBigControls()) 03119 { 03120 VerticalLargeRect.GetRight() = BarSize.width; 03121 VerticalLargeRect.GetBottom() = BarSize.height; 03122 } 03123 else 03124 { 03125 VerticalSmallRect.GetRight() = BarSize.width; 03126 VerticalSmallRect.GetBottom() = BarSize.height; 03127 } 03128 } 03129 else if (ForceSize == FORCE_LARGE) 03130 { 03131 VerticalLargeRect.GetRight() = BarSize.width; 03132 VerticalLargeRect.GetBottom() = BarSize.height; 03133 } 03134 else if (ForceSize == FORCE_SMALL) 03135 { 03136 VerticalSmallRect.GetRight() = BarSize.width; 03137 VerticalSmallRect.GetBottom() = BarSize.height; 03138 } */ 03139 03140 return TRUE; 03141 }; 03142 03143 /******************************************************************************************** 03144 03145 > void BaseBar::AdjustFormattedBarSize(wxSize* BarSize) 03146 03147 Author: Alex 03148 Created: 1/7/94 03149 Inputs: Pointer to the bar size record to adjust 03150 Outputs: - 03151 Returns: None 03152 Purpose: Adjusts the proposed new size of a bar once formatting has taken place 03153 Errors: - 03154 SeeAlso: GalleryBar::AdjustFormattedBarSize 03155 03156 This function does nothing in the base class, but may be overridden, for instance by Gallery 03157 Bars. 03158 03159 ********************************************************************************************/ 03160 03161 void BaseBar::AdjustFormattedBarSize(wxSize* BarSize) 03162 { 03163 } 03164 03165 /******************************************************************************************** 03166 03167 > void BaseBar::PositionExtraControls(wxSize BarSize, INT32 xpos, INT32 ypos) 03168 03169 Author: Alex 03170 Created: 1/7/94 03171 Inputs: Bar size record, x & y coord of current format position. 03172 Outputs: - 03173 Returns: None 03174 Purpose: Moves extra controls about once they have been created 03175 Errors: - 03176 SeeAlso: GalleryBar::PositionExtraControls, BaseBar::CreateExtraControls 03177 03178 This function does nothing in the base class, but may be overridden, for instance by Gallery 03179 Bars. 03180 03181 ********************************************************************************************/ 03182 03183 void BaseBar::PositionExtraControls(wxSize BarSize, INT32 xpos, INT32 ypos) 03184 { 03185 } 03186 03187 /******************************************************************************************** 03188 03189 > INT32 BaseBar::CreateExtraControls() 03190 03191 Author: Alex 03192 Created: 1/7/94 03193 Inputs: None 03194 Outputs: TRUE if successful, else FALSE 03195 Returns: None 03196 Purpose: Allows subclasses to create additional bar controls 03197 Errors: - 03198 SeeAlso: GalleryBar::CreateExtraControls, BaseBar::PositionExtraControls 03199 03200 This function does nothing in the base class, but may be overridden, for instance by Gallery 03201 Bars. 03202 03203 ********************************************************************************************/ 03204 03205 INT32 BaseBar::CreateExtraControls() 03206 { 03207 return TRUE; 03208 } 03209 03210 03211 03212 03213 /******************************************************************************************** 03214 03215 > BOOL BaseBar::CreateToolBtn(BarToolButton* pToolBtn) 03216 03217 Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> 03218 Created: 13/4/94 03219 Inputs: pToolBtn: The 03220 Outputs: - 03221 Returns: TRUE if succesful, FALSE otherwise 03222 Purpose: Creates tool bar button control 03223 Errors: - 03224 SeeAlso: - 03225 03226 ********************************************************************************************/ 03227 // This function is probably dead wood 03228 BOOL BaseBar::CreateToolBtn(BarToolButton* pToolBtn) 03229 { 03230 return TRUE ; 03231 } 03232 03233 03234 DLGITEMTEMPLATE* BaseBar::GetPointerToControl(DLGTEMPLATE* pDlg ,UINT32 CtlId) 03235 { 03236 PORTNOTETRACE( "dialog", "BaseBar::GetPointerToControl - do nothing - DLGITEMTEMPLATE usage" ); 03237 #ifndef EXCLUDE_FROM_XARALX 03238 DLGITEMTEMPLATE* pCurrentControl = (DLGITEMTEMPLATE *) (((ADDR)pDlg) + SizeDlgHeader(pDlg)); 03239 WORD NumControls = pDlg->cdit; 03240 ENSURE(pCurrentControl != NULL, "Hideous Error in Load Controls"); 03241 03242 for (UINT32 i = 0; i< NumControls; i++) 03243 { 03244 if (pCurrentControl->id == CtlId) 03245 { 03246 return pCurrentControl; 03247 } 03248 pCurrentControl = (DLGITEMTEMPLATE *) 03249 (((ADDR)pCurrentControl) + SizeCtrlData(pCurrentControl)); 03250 } 03251 #endif 03252 return NULL; 03253 } 03254 03255 HINSTANCE BaseBar::GetModuleInst(const BarControlInfo*pBarCtlInfo,UINT32 * ToolModuleID ) 03256 { 03257 #pragma message( __LOCMSG__ "BaseBar::GetModuleInst - do nothing" ) 03258 TRACE( _T("Warning - BaseBar::GetModuleInst called") ); 03259 /* *ToolModuleID = Tool::GetModuleID(pBarCtlInfo->ToolID); 03260 03261 // tools.dll not loaded, chances are the resources are in with the rest 03262 if(DLLs[0] == (HINSTANCE)HINSTANCE_ERROR || DLLs[0] == 0) 03263 return AfxGetResourceHandle(); 03264 03265 return ResHelp::GetInstanceFromID( pBarCtlInfo->ResourceID ); 03266 03267 #if 0 03268 // old code before Andy got to it 03269 HINSTANCE ModuleInst; 03270 if (pBarCtlInfo->ToolID != 0) // We want to get control from tool DLL 03271 { 03272 // Try to get the tools module ID 03273 *ToolModuleID = Tool::GetModuleID(pBarCtlInfo->ToolID); 03274 03275 ENSURE(*ToolModuleID != 0, "Could not find module ID"); 03276 if (*ToolModuleID == 0) 03277 return NULL; 03278 // Now try to get the module's instance 03279 ModuleInst = OILModule::GetInstance(*ToolModuleID); 03280 ENSURE (ModuleInst != (HINSTANCE)HINSTANCE_ERROR, "Could not obtain module instance"); 03281 if (ModuleInst == (HINSTANCE)HINSTANCE_ERROR) 03282 return NULL; 03283 else 03284 return ModuleInst; 03285 } 03286 else 03287 { 03288 // get controls from exe 03289 return AfxGetApp()->m_hInstance; 03290 } 03291 #endif */ 03292 03293 return HINSTANCE(-1); 03294 } 03295 /******************************************************************************************** 03296 03297 > BOOL BaseBar::CreateInfoControlFromResource(BarControl* pBarControl) 03298 03299 Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> 03300 Created: 13/4/94 03301 Inputs: pBarControl: The BarControl to create 03302 Outputs: - 03303 Returns: - 03304 Purpose: Special case for info bars 03305 Errors: - 03306 SeeAlso: - 03307 03308 ********************************************************************************************/ 03309 03310 03311 BOOL BaseBar::CreateInfoControlFromResource(BarControl* pBarControl,BOOL Init) 03312 { 03313 PORTNOTETRACE( "dialog", "BaseBar::CreateInfoControlFromResource - do nothing" ); 03314 #ifndef EXCLUDE_FROM_XARALX 03315 const BarControlInfo * pBarCtlInfo; 03316 static DLGITEMTEMPLATE * pCurrentControl; 03317 static HINSTANCE ModuleInst = NULL; 03318 static UINT32 ResID =0; 03319 static UINT32 ControlID; 03320 static HRSRC hRes = NULL; 03321 static DLGTEMPLATE* pDlg; 03322 static HGLOBAL hGlobalRes = NULL; 03323 03324 UINT32 ToolModuleID = 0; 03325 HINSTANCE ThisModuleInst = NULL; 03326 03327 // DISABLE CACHING FOR NOW ! 03328 Init = TRUE; 03329 03330 if(pBarControl==NULL) 03331 { if(hGlobalRes != NULL) 03332 { 03333 // Lets do the nice thing 03334 UnlockResource(hGlobalRes); 03335 FreeResource(hGlobalRes); 03336 } 03337 return FALSE; 03338 } 03339 03340 // Get control info 03341 if (pOp->IsKindOf(CC_RUNTIME_CLASS(SuperGallery))) 03342 { 03343 pBarCtlInfo = &(pBarControl->GetHorzControl()->BarCtrlInfo); 03344 } 03345 else 03346 { 03347 switch(ParentDockBarType) 03348 { 03349 case DOCKBAR_TOP: 03350 case DOCKBAR_BOTTOM: 03351 case DOCKBAR_FLOAT: 03352 pBarCtlInfo =&(pBarControl->GetHorzControl()->BarCtrlInfo); 03353 break; 03354 case DOCKBAR_LEFT: 03355 case DOCKBAR_RIGHT: 03356 pBarCtlInfo =&(pBarControl->GetVertControl()->BarCtrlInfo); 03357 break; 03358 } 03359 } 03360 03361 // initialise ModuleInst 03362 if(Init) 03363 { 03364 ModuleInst = GetModuleInst(pBarCtlInfo,&ToolModuleID); 03365 } 03366 // normally just check if we need the same module 03367 else 03368 { 03369 ThisModuleInst = GetModuleInst(pBarCtlInfo,&ToolModuleID); 03370 if(ThisModuleInst != ModuleInst) 03371 { 03372 Init = TRUE; 03373 ModuleInst = ThisModuleInst; 03374 } 03375 if(ModuleInst == NULL) 03376 ENSURE(FALSE,"Can't find Module Instance"); 03377 if(pBarCtlInfo->ResourceID != ResID) 03378 { 03379 Init = TRUE; 03380 ResID = pBarCtlInfo->ResourceID; 03381 } 03382 } 03383 03384 BOOL CreatedControl = FALSE; 03385 03386 // Try to find, load and lock the dialog resource 03387 if(Init) 03388 { 03389 if(hGlobalRes!=NULL) 03390 { 03391 // Lets do the nice thing 03392 UnlockResource(hGlobalRes); 03393 FreeResource(hGlobalRes); 03394 } 03395 03396 hRes = FindResource(ModuleInst, MAKEINTRESOURCE(pBarCtlInfo->ResourceID), RT_DIALOG); 03397 if (hRes == NULL) 03398 { 03399 ERROR3_PF( ("Could not find RT_DIALOG id %u in %x", pBarCtlInfo->ResourceID, 03400 ModuleInst ) ); 03401 return FALSE; 03402 } 03403 // Try to get handle to global block containing resource data 03404 hGlobalRes = LoadResource(ModuleInst, hRes); 03405 ENSURE(hGlobalRes != NULL, "Could not load resource"); 03406 if (hGlobalRes == NULL) 03407 return FALSE; 03408 03409 // Get the dialog resource 03410 pDlg = (DLGTEMPLATE *) LockResource(hGlobalRes); 03411 ENSURE(pDlg != NULL, "Could not lock resource"); 03412 if (pDlg == NULL) 03413 return FALSE; 03414 03415 pCurrentControl = (DLGITEMTEMPLATE *) (((ADDR)pDlg) + SizeDlgHeader(pDlg)); 03416 } 03417 03418 //TRACE( _T("found %d after %d"),pCurrentControl->id,pBarCtlInfo->ControlID); 03419 03420 if(!Init) 03421 { 03422 if (pCurrentControl->id == pBarCtlInfo->ControlID ) 03423 { 03424 // Yippee ! We have found the control required 03425 // Lets create it 03426 if (CreateControlItem(pCurrentControl,pBarControl,ModuleInst,ToolModuleID)) 03427 { 03428 return TRUE; 03429 } 03430 else 03431 { 03432 ENSURE(FALSE,"Failed to create control"); 03433 return FALSE; 03434 } 03435 pCurrentControl = (DLGITEMTEMPLATE *) 03436 (((ADDR)pCurrentControl) + SizeCtrlData(pCurrentControl)); 03437 } 03438 else 03439 { 03440 Init =TRUE; 03441 return CreateInfoControlFromResource(pBarControl,TRUE); 03442 } 03443 } 03444 03445 03446 if(Init) 03447 { 03448 03449 DLGITEMTEMPLATE * ThisControl = GetPointerToControl(pDlg ,pBarCtlInfo->ControlID); 03450 if(ThisControl==NULL) 03451 { 03452 //ENSURE(FALSE,"Can't find Control in Resource"); 03453 ERROR3_PF(("Can't find Control (%d / 0x%x) in Resource (%d / 0x%x)", pBarCtlInfo->ControlID, pBarCtlInfo->ControlID, pBarCtlInfo->ResourceID, pBarCtlInfo->ResourceID)); 03454 return FALSE; 03455 } 03456 if (CreateControlItem(ThisControl,pBarControl,ModuleInst,ToolModuleID)) 03457 { 03458 return TRUE; 03459 } 03460 else 03461 { 03462 return FALSE; 03463 } 03464 pCurrentControl = (DLGITEMTEMPLATE *) 03465 (((ADDR)ThisControl) + SizeCtrlData(ThisControl)); 03466 } 03467 03468 return (CreatedControl); 03469 #else 03470 return FALSE; 03471 #endif 03472 } 03473 03474 03475 /******************************************************************************************** 03476 03477 > BOOL BaseBar::CreateControlFromResource(BarControl* pBarControl) 03478 03479 Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> 03480 Created: 13/4/94 03481 Inputs: pBarControl: The BarControl to create 03482 Outputs: - 03483 Returns: - 03484 Purpose: Create 03485 Errors: - 03486 SeeAlso: - 03487 03488 ********************************************************************************************/ 03489 03490 BOOL BaseBar::CreateControlFromResource(BarControl* pBarControl) 03491 { 03492 PORTNOTETRACE( "dialog", "BaseBar::CreateControlFromResource - do nothing - Resource usage" ); 03493 #ifndef EXCLUDE_FROM_XARALX 03494 const BarControlInfo*pBarCtlInfo; 03495 03496 if (pOp->IsKindOf(CC_RUNTIME_CLASS(SuperGallery))) 03497 { 03498 pBarCtlInfo = &(pBarControl->GetHorzControl()->BarCtrlInfo); 03499 } 03500 else 03501 { 03502 switch(ParentDockBarType) 03503 { 03504 case DOCKBAR_TOP: 03505 case DOCKBAR_BOTTOM: 03506 case DOCKBAR_FLOAT: 03507 pBarCtlInfo =&(pBarControl->GetHorzControl()->BarCtrlInfo); 03508 break; 03509 case DOCKBAR_LEFT: 03510 case DOCKBAR_RIGHT: 03511 pBarCtlInfo =&(pBarControl->GetVertControl()->BarCtrlInfo); 03512 break; 03513 } 03514 } 03515 03516 HINSTANCE ModuleInst = NULL; 03517 UINT32 ToolModuleID = 0; 03518 03519 ModuleInst = GetModuleInst(pBarCtlInfo,&ToolModuleID); 03520 03521 // ------------------------------------------------------------------------------------- 03522 // Try to find, load and lock the dialog resource 03523 03524 HRSRC hRes = FindResource(ModuleInst, MAKEINTRESOURCE(pBarCtlInfo->ResourceID), RT_DIALOG); 03525 03526 ENSURE(hRes != NULL, "Could not find resource"); 03527 if (hRes == NULL) 03528 return FALSE; 03529 03530 // Try to get handle to global block containing resource data 03531 HGLOBAL hGlobalRes = LoadResource(ModuleInst, hRes); 03532 ENSURE(hGlobalRes != NULL, "Could not load resource"); 03533 if (hGlobalRes == NULL) 03534 return FALSE; 03535 03536 // Get the dialog resource 03537 DLGTEMPLATE* pDlg = (DLGTEMPLATE *) LockResource(hGlobalRes); 03538 ENSURE(pDlg != NULL, "Could not lock resource"); 03539 if (pDlg == NULL) 03540 return FALSE; 03541 03542 03543 // We are totally disinterested in the Dialog itself as it's only a recepticle for storing 03544 // control resources 03545 03546 03547 BOOL CreatedControl = FALSE; 03548 03549 // Loop until we have found the control to create 03550 03551 WORD NumControls = pDlg->cdit; // The number of items in the dialog 03552 03553 TRACEUSER( "Simon", _T("Dialog has %d controls"), NumControls); 03554 03555 // Get pointer to first control 03556 DLGITEMTEMPLATE *pCurrentControl = (DLGITEMTEMPLATE *) (((ADDR)pDlg) + SizeDlgHeader(pDlg)); 03557 03558 ENSURE(pCurrentControl != NULL, "Hideous Error in Load Controls"); 03559 03560 for (UINT32 i = 0; i< NumControls; i++) 03561 { 03562 if (pCurrentControl->id == pBarCtlInfo->ControlID) 03563 { 03564 // Yippee ! We have found the control required 03565 // Lets create it 03566 if (CreateControlItem(pCurrentControl,pBarControl,ModuleInst,ToolModuleID)) 03567 { 03568 CreatedControl = TRUE; 03569 } 03570 break; 03571 } 03572 pCurrentControl = (DLGITEMTEMPLATE *) 03573 (((ADDR)pCurrentControl) + SizeCtrlData(pCurrentControl)); 03574 } 03575 03576 // Lets do the nice thing 03577 UnlockResource(hGlobalRes); 03578 FreeResource(hGlobalRes); 03579 03580 return (CreatedControl); 03581 #else 03582 return FALSE; 03583 #endif 03584 } 03585 03586 03587 /******************************************************************************************** 03588 03589 > void BaseBar::CreateControlItem(DLGITEMTEMPLATE * pCurrentControl, 03590 BarControl * pBarControl, 03591 HINSTANCE ModuleInst, 03592 UINT32 ToolModuleID) 03593 03594 Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> 03595 Created: 13/4/94 03596 Inputs: pCurrentControl: The control to create 03597 pBarControl : Kernel description of control 03598 ModuleInst : Module handle 03599 ToolModuleID : The tool's module ID 03600 Outputs: - 03601 Returns: - 03602 Purpose: Creates the control and attaches it as a child of the BaseBars window, 03603 Errors: - 03604 sCOPE: private 03605 SeeAlso: - 03606 03607 ********************************************************************************************/ 03608 03609 BOOL BaseBar::CreateControlItem(DLGITEMTEMPLATE * pCurrentControl, 03610 BarControl * pBarControl, 03611 HINSTANCE ModuleInst, 03612 UINT32 ToolModuleID) 03613 { 03614 #pragma message( __LOCMSG__ "BaseBar::GetModuleInst - do nothing" ) 03615 TRACE( _T("Warning - BaseBar::GetModuleInst called") ); 03616 /* BarItemType ThisControlType = OTHERCONTROL; 03617 03618 BOOL ResizeWithFont = FALSE; 03619 03620 #if WIN32 03621 // Get pointer to the data after the DLGITEMTEMPLATE structure. 03622 WORD *pData = (WORD *) (pCurrentControl + 1); 03623 03624 // Obtain the class 03625 LPWSTR pClass; 03626 03627 if (*pData == 0xFFFF) 03628 { 03629 // Convert the atom value into a string 03630 03631 switch((*(pData+1))) 03632 { 03633 case 0x0080: 03634 { 03635 pClass = L"Button"; 03636 ThisControlType = BUTTON; 03637 ResizeWithFont = TRUE; 03638 break; 03639 } 03640 case 0x0081: 03641 { 03642 pClass = L"Edit"; 03643 ThisControlType = EDIT; 03644 ResizeWithFont = TRUE; 03645 break; 03646 } 03647 case 0x0082: 03648 { 03649 pClass = L"Static"; 03650 ThisControlType = STATIC; 03651 ResizeWithFont = TRUE; 03652 break; 03653 } 03654 case 0x0083: 03655 { 03656 pClass = L"Listbox"; 03657 ThisControlType = LIST; 03658 ResizeWithFont = TRUE; 03659 break; 03660 } 03661 case 0x0084: 03662 { 03663 pClass = L"Scrollbar"; 03664 ThisControlType = SCROLLBAR; 03665 break; 03666 } 03667 case 0x0085: 03668 { 03669 pClass = L"Combobox"; 03670 ThisControlType = COMBO; 03671 ResizeWithFont = TRUE; 03672 break; 03673 } 03674 } 03675 03676 pData += 2; 03677 } 03678 else 03679 { 03680 // The class is specified as a string 03681 pClass = (LPWSTR)pData; 03682 pData = (WORD *) MovePastWideStr((LPWSTR) pData); 03683 } 03684 03685 // Obtain the windows title 03686 LPWSTR pTitle; 03687 03688 if (*pData == 0xFFFF) 03689 { 03690 // It's a resource 03691 pTitle = (LPWSTR) (pData+1); 03692 03693 pData += 2; 03694 } 03695 else 03696 { 03697 pTitle = (LPWSTR) pData; 03698 // The title array is a string - skip it 03699 pData = (WORD *) MovePastWideStr((LPWSTR) pData); 03700 } 03701 03702 // Obtain the creation data 03703 LPVOID pCreationData = (LPVOID*) (pData+2); 03704 03705 03706 // ------------------------------------------------------------------------------------ 03707 03708 #else 03709 // Get pointer to the data after the DLGITEMTEMPLATE structure. 03710 ADDR pData = (ADDR) (pCurrentControl + 1); 03711 // Obtain the class 03712 03713 LPCTSTR pClass; 03714 LPCTSTR pTitle; 03715 03716 if ((*pData) & 0x80) 03717 { 03718 // An atom is specified 03719 03720 // Convert the atom 03721 switch((*(pData+1))) 03722 { 03723 case 0x0080: 03724 { 03725 pClass = "Button"; 03726 ThisControlType = BUTTON; 03727 ResizeWithFont = TRUE; 03728 break; 03729 } 03730 case 0x0081: 03731 { 03732 pClass = "Edit"; 03733 ThisControlType = EDIT; 03734 ResizeWithFont = TRUE; 03735 break; 03736 } 03737 case 0x0082: 03738 { 03739 pClass = "Static"; 03740 ThisControlType = STATIC; 03741 ResizeWithFont = TRUE; 03742 break; 03743 } 03744 case 0x0083: 03745 { 03746 pClass = "Listbox"; 03747 ThisControlType = LIST; 03748 ResizeWithFont = TRUE; 03749 break; 03750 } 03751 case 0x0084: 03752 { 03753 pClass = "Scrollbar"; 03754 ThisControlType = SCROLLBAR; 03755 break; 03756 } 03757 case 0x0085: 03758 { 03759 pClass = "Combobox"; 03760 ThisControlType = COMBO; 03761 ResizeWithFont = TRUE; 03762 break; 03763 } 03764 } 03765 pData++; 03766 03767 } 03768 else 03769 { 03770 pClass = (LPCTSTR)pData; // Get the class string 03771 03772 pData = (ADDR) MovePastWideStr((LPWSTR) pData); 03773 } 03774 03775 // Obtain the windows title 03776 pTitle = (LPCTSTR) pData; 03777 pData = (ADDR) MovePastWideStr((LPWSTR) pData); 03778 03779 // Obtain the creation data 03780 LPVOID pCreationData = (LPVOID*) pData+1; // Skip the length 03781 03782 #endif 03783 03784 // get the dialog base units so that we can convert to pixels 03785 INT32 BaseUnits = GetDialogBaseUnits(); 03786 03787 // A bit of nasty this.. hard code base units in so controls don't change size 03788 // if the user switches to LARGE FONTS 03789 03790 WORD DialogUnitX = X_BASEUNITS ;//LOWORD((UINT32)BaseUnits); 03791 WORD DialogUnitY = Y_BASEUNITS ;//HIWORD((UINT32)BaseUnits); 03792 03793 char AnsiClass[256]; 03794 char AnsiTitle[256]; 03795 03796 #if WIN32 03797 // we cannot pass Unicode strings under Win32s, so we convert to multibyte strings. 03798 // If we ever need a Chinese NT version then we could pass these directly onto 03799 // ::CreateWindowExW, but currently we always convert down to Ansi 03800 // INT32 result; 03801 03802 // really we should use WideCharToMultiByte, but it refuses to work under Win32s 1.1 03803 // returning zero with a GetLastError of 2, so we use camWcstombs instead. 03804 camWcstombs( AnsiClass, pClass, sizeof(AnsiClass) ); 03805 camWcstombs( AnsiTitle, pTitle, sizeof(AnsiTitle) ); 03806 #else 03807 // 16-bit version needs no conversion, but we have to copy them because we 03808 // crap upon them 03809 camStrcpy( AnsiClass, pClass ); 03810 camStrcpy( AnsiTitle, pTitle ); 03811 #endif 03812 03813 // Check for type here if not already set 03814 if(ThisControlType == OTHERCONTROL) 03815 { 03816 if (camStricmp(AnsiClass, "cc_BitmapButton") == 0) // Internal 03817 ThisControlType = BITMAPBUTTON; 03818 else if (camStricmp(AnsiClass, "cc_SmallButton") == 0) // Internal 03819 ThisControlType = SMALLBITMAPBUTTON; 03820 else if (camStricmp(AnsiClass, "cc_StaticBitmap") == 0) // Internal 03821 ThisControlType = STATICBITMAP; 03822 else if (camStricmp(AnsiClass, "cc_Text3D") == 0) // Internal 03823 ThisControlType = TEXT3D; 03824 else if (camStricmp(AnsiClass, "cc_Grid")==0) // Internal 03825 ThisControlType = ROTATEGRID; 03826 else if (camStricmp(AnsiClass,"cc_Slider")==0) // Internal 03827 ThisControlType = SLIDER; 03828 else if (camStricmp(AnsiClass, "cc_1dBitmapComboBoxEdit") == 0) // internal 03829 ThisControlType = BITMAPCOMBO1D; 03830 else if (camStricmp(AnsiClass, "cc_2dBitmapComboBoxEdit") == 0) // internal 03831 ThisControlType = BITMAPCOMBO2D; 03832 } 03833 03834 03835 DWORD Style = pCurrentControl->style; 03836 03837 OpDescriptor* OpDesc ; 03838 if (pOp->IsKindOf(CC_RUNTIME_CLASS(SuperGallery))) 03839 { 03840 OpDesc = (pBarControl)->GetOpDescriptor(Horizontal); 03841 } 03842 else 03843 { 03844 switch(ParentDockBarType) 03845 { 03846 case DOCKBAR_TOP: 03847 case DOCKBAR_BOTTOM: 03848 case DOCKBAR_FLOAT: 03849 OpDesc = (pBarControl)-> GetOpDescriptor(Horizontal); 03850 break; 03851 case DOCKBAR_LEFT: 03852 case DOCKBAR_RIGHT: 03853 OpDesc = (pBarControl)-> GetOpDescriptor(Vertical); 03854 break; 03855 } 03856 } 03857 03858 if (OpDesc != NULL) 03859 { 03860 String_256 Desc; 03861 OpState NewState = OpDesc->GetOpsState(&Desc); 03862 if(NewState.Greyed) 03863 { 03864 Style |= BS_DISABLED; 03865 } 03866 else 03867 { 03868 Style &= (~BS_DISABLED); 03869 } 03870 } 03871 03872 OILDockingBar * ThisDock =GetMainFrame()->GetDockBar(ParentDockBarType); 03873 03874 if( ThisControlType == ROTATEGRID || 03875 ThisControlType == TEXT3D) 03876 ResizeWithFont = TRUE; 03877 03878 03879 if( ThisControlType == BITMAPBUTTON || 03880 ThisControlType == STATICBITMAP || 03881 ThisControlType == SMALLBITMAPBUTTON) 03882 { 03883 if (ThisDock->IsBigControls()) 03884 { 03885 Style &= (~BS_HALFSIZE); 03886 } 03887 else 03888 { 03889 Style |= BS_HALFSIZE; 03890 } 03891 } 03892 03893 // CHICAGO BODGE - this is something to do with dialog units/system font in Chicago 03894 // but until finalised this will do.. 03895 03896 INT32 XSize = (pCurrentControl->cx * DialogUnitX) / 4; 03897 INT32 YSize = (pCurrentControl->cy * DialogUnitY) / 8; 03898 03899 Style &= (~WS_VISIBLE); 03900 HWND CreatedWindow = ::CreateWindowEx( 03901 #if WIN32 03902 pCurrentControl->dwExtendedStyle, 03903 #else 03904 0, 03905 #endif 03906 AnsiClass, 03907 AnsiTitle, 03908 Style, 03909 0, 03910 0, 03911 XSize, 03912 YSize, 03913 GetSafeHwnd(), // this window is its parent 03914 (HMENU)pBarControl->GetUniqueGadgetID(), 03915 AfxGetApp()->m_hInstance, 03916 pCreationData 03917 ); 03918 03919 // if the class is a Jason button bar then we need to set its bitmap 03920 if (CreatedWindow != NULL) 03921 { 03922 // Store Hwnd in BarControl list 03923 pBarControl->SetWinID((CWindowID)CreatedWindow); 03924 ThisControlType = GetEnumItemType((BarItem *)pBarControl); 03925 03926 // Send old style messages to cc_StaticBitmap because that class doesn't yet have 03927 // PNG rendering ability 03928 if (ThisControlType == STATICBITMAP) 03929 { 03930 BitmapButtonInfo BtnInfo; 03931 03932 // find the position of the specifier's separator 03933 INT32 SeparatorPos = 0; 03934 while (AnsiTitle[SeparatorPos] != 0 && AnsiTitle[SeparatorPos] != '.') 03935 SeparatorPos++; 03936 03937 INT32 Index = 0; // Default to using icon index 0 if no '.' separator was found 03938 if (AnsiTitle[SeparatorPos] == '.') 03939 { 03940 // We found a separator. In that case, truncate the resource string at the '.' 03941 // so we can extract the bitmap name, and convert the text after the '.' into 03942 // an integer index. 03943 Index = _ttoi( AnsiTitle + SeparatorPos+1 ); 03944 AnsiTitle[SeparatorPos] = 0; 03945 } 03946 03947 // Fill in the BtnInfo structure 03948 BtnInfo.hAppInstance = ModuleInst; // We assume that the bitmap resouce can be 03949 // found in the same module as this control. 03950 String_256 Title =("L"); 03951 Title += TEXT(AnsiTitle); 03952 03953 BtnInfo.Bitmap[BMP_L_UNSELECTED] = (LPTSTR)Title; 03954 BtnInfo.Bitmap[BMP_S_UNSELECTED] = (LPTSTR)AnsiTitle; 03955 03956 BtnInfo.Bitmap[BMP_S_SELECTED] = NULL; // NULL, or name of selected bitmap 03957 BtnInfo.Bitmap[BMP_L_SELECTED] = NULL; // NULL, or name of selected bitmap 03958 03959 BtnInfo.UnselectedIndex=Index; // Indices of glyph bitmaps within the 03960 BtnInfo.SelectedIndex=Index; // Unselected/Selected bitmaps 03961 03962 ::SendMessage( CreatedWindow, WM_SETBITMAPS, 0, ((LPARAM) &BtnInfo)); 03963 } 03964 03965 // Send new style messages to the button classes because they can use PNG 03966 // resources 03967 if( ThisControlType == BITMAPBUTTON || 03968 ThisControlType == SMALLBITMAPBUTTON) 03969 { 03970 DialogManager::SetGadgetBitmaps(CreatedWindow, ModuleInst); 03971 } 03972 03973 03974 BOOL Horz=TRUE; 03975 if(ParentDockBarType == DOCKBAR_LEFT || ParentDockBarType == DOCKBAR_RIGHT) 03976 Horz = FALSE; 03977 03978 // Inform the help system that a control has been created 03979 ControlHelpInfo Info; 03980 Info.pOpDesc = pBarControl->GetOpDescriptor(Horz); 03981 Info.ModuleID = ToolModuleID; 03982 03983 // Are we making a tool ?? if so we'll have to set it's select state ... 03984 if (Info.pOpDesc) 03985 { 03986 if ((Info.pOpDesc)->IsKindOf(CC_RUNTIME_CLASS(ToolOpDescriptor))) 03987 { 03988 ToolOpDescriptor * ThisOpDesc = (ToolOpDescriptor *)Info.pOpDesc; 03989 ::SendMessage(CreatedWindow, BM_SETSTATE,(WORD)ThisOpDesc->IsCurrentTool(),0L); 03990 } 03991 } 03992 03993 if (Info.pOpDesc == NULL) 03994 { 03995 Info.BubbleID = pBarControl->GetBubbleID(Horz); 03996 Info.StatusID = pBarControl->GetStatusID(Horz); 03997 } 03998 else 03999 { 04000 Info.BubbleID = _R(IDBBL_NOOP); 04001 Info.StatusID = 0; 04002 } 04003 04004 if ( ThisControlType != BITMAPBUTTON && 04005 DDeckerState == DDECKER_NONE) 04006 { 04007 Ctl3dSubClassCtl(CreatedWindow); 04008 } 04009 04010 ControlHelper::NotifyControlCreated(CreatedWindow,&Info); 04011 04012 if(ThisControlType == SLIDER) 04013 { 04014 if(Horz == FALSE) 04015 { 04016 ::SetWindowPos(CreatedWindow,NULL,0,0,YSize,XSize, 04017 SWP_NOZORDER|SWP_NOMOVE|SWP_NOREDRAW); 04018 04019 } 04020 04021 04022 } 04023 // Create correctly sized normal and double decker controls 04024 // Add new controls to here as necessary 04025 if (ResizeWithFont) 04026 { 04027 // Reset the font of this control... 04028 if(DDeckerState == DDECKER_NONE) 04029 { 04030 ::SendMessage( CreatedWindow, WM_SETFONT, (WPARAM)BarFont->m_hObject, 0); 04031 switch (ThisControlType) 04032 { 04033 case BUTTON: 04034 case BITMAPBUTTON: 04035 { 04036 wxRect cRect; 04037 ::GetClientRect(CreatedWindow,&cRect); 04038 if(ParentDockBar->IsBigControls()) 04039 ::SetWindowPos(CreatedWindow,NULL,0,0,cRect.GetWidth(),LARGEBUTTONHEIGHT, 04040 SWP_NOZORDER|SWP_NOMOVE|SWP_NOREDRAW); 04041 else 04042 ::SetWindowPos(CreatedWindow,NULL,0,0,cRect.GetWidth(),SMALLBUTTONHEIGHT, 04043 SWP_NOZORDER|SWP_NOMOVE|SWP_NOREDRAW); 04044 break; 04045 } 04046 case EDIT: 04047 case COMBO: 04048 { 04049 wxRect cRect; 04050 ::GetClientRect(CreatedWindow,&cRect); 04051 ::SetWindowPos(CreatedWindow,NULL,0,0,cRect.GetWidth(),COMBOHEIGHT, 04052 SWP_NOZORDER|SWP_NOMOVE|SWP_NOREDRAW); 04053 break; 04054 } 04055 case ROTATEGRID: 04056 if(ParentDockBar->IsBigControls()) 04057 ::SetWindowPos(CreatedWindow,NULL,0,0,LARGEBUTTONHEIGHT,LARGEBUTTONHEIGHT, 04058 SWP_NOZORDER|SWP_NOMOVE|SWP_NOREDRAW); 04059 else 04060 ::SetWindowPos(CreatedWindow,NULL,0,0,SMALLBUTTONHEIGHT,SMALLBUTTONHEIGHT, 04061 SWP_NOZORDER|SWP_NOMOVE|SWP_NOREDRAW); 04062 break; 04063 } 04064 04065 } 04066 // Double decker 04067 else 04068 { 04069 DDeckerControlHeights DDeckerHeight; 04070 wxFont * ThisFont ; 04071 if(ParentDockBar->IsBigControls()) 04072 { 04073 if (ThisControlType == BITMAPBUTTON ||ThisControlType == BUTTON) 04074 ThisFont = FontFactory::GetwxFont(STOCKFONT_DIALOGBARLARGE); 04075 else 04076 ThisFont = FontFactory::GetwxFont(STOCKFONT_EDITFIELDLARGE); 04077 ::SendMessage( CreatedWindow, WM_SETFONT, (WPARAM)ThisFont->m_hObject, 0); 04078 DDeckerHeight = LARGE_DDECKERS ; 04079 } 04080 else 04081 { 04082 if (ThisControlType == BITMAPBUTTON ||ThisControlType == BUTTON) 04083 ThisFont = FontFactory::GetwxFont(STOCKFONT_DIALOGBARSMALL); 04084 else 04085 ThisFont = FontFactory::GetwxFont(STOCKFONT_EDITFIELDSMALL); 04086 ::SendMessage( CreatedWindow, WM_SETFONT, (WPARAM)ThisFont->m_hObject, 0); 04087 DDeckerHeight = SMALL_DDECKERS ; 04088 } 04089 04090 04091 switch(ThisControlType) 04092 { 04093 case BUTTON: 04094 case BITMAPBUTTON: 04095 { 04096 // NEW BUTTON STUFF 04097 if(pOp->IsKindOf(CC_RUNTIME_CLASS(SuperGallery))) 04098 ::SetWindowPos(CreatedWindow,NULL,0,0,GalButtonWidth,DDeckerHeight , 04099 SWP_NOZORDER|SWP_NOMOVE|SWP_NOREDRAW); 04100 else 04101 { 04102 wxRect cRect; 04103 ::GetClientRect(CreatedWindow,&cRect); 04104 ::SetWindowPos(CreatedWindow,NULL,0,0,cRect.GetWidth(),DDeckerHeight , 04105 SWP_NOZORDER|SWP_NOMOVE|SWP_NOREDRAW); 04106 } 04107 04108 04109 break; 04110 } 04111 case EDIT: 04112 case STATIC: 04113 { 04114 wxRect cRect; 04115 ::GetClientRect(CreatedWindow,&cRect); 04116 ::SetWindowPos(CreatedWindow,NULL,0,0,cRect.GetWidth(),DDeckerHeight, 04117 SWP_NOZORDER|SWP_NOMOVE|SWP_NOREDRAW); 04118 break; 04119 } 04120 case COMBO: 04121 ::SendMessage(CreatedWindow,CB_SETITEMHEIGHT,(WPARAM)-1,(LPARAM)DDeckerHeight); 04122 ::SendMessage(CreatedWindow,CB_SETITEMHEIGHT,(WPARAM)0,(LPARAM)DDeckerHeight); 04123 break; 04124 } 04125 } 04126 } 04127 } 04128 return (CreatedWindow != NULL); */ 04129 04130 return false; 04131 } 04132 04133 /******************************************************************************************** 04134 04135 > LPWSTR BaseBar::MovePastWideStr(LPWSTR pWideStr) 04136 04137 Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> 04138 Created: 11/11/93 04139 Inputs: pWideStr - the start of the string to skip 04140 Returns: Address of first byte past the end of the string. 04141 Purpose: Given a ptr to the first byte in a wide string (or char string if win16) 04142 return a ptr to the byte past the null. 04143 04144 ********************************************************************************************/ 04145 04146 LPWSTR BaseBar::MovePastWideStr(LPWSTR pWideStr) 04147 { 04148 // Skip the string 04149 while (*pWideStr++) 04150 ; 04151 04152 // Return the address of the following character 04153 return pWideStr; 04154 } 04155 04156 /******************************************************************************************** 04157 04158 > size_t BaseBar::SizeDlgHeader(DLGTEMPLATE *pHeader) 04159 04160 Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> 04161 Created: 13/04/94 04162 Inputs: pHeader - start of the dialog box header. 04163 Returns: Size of the dialog box header. 04164 Purpose: Given a ptr to DIALOGBOXHEADER, return its size. 04165 Scope: private 04166 04167 ********************************************************************************************/ 04168 04169 04170 size_t BaseBar::SizeDlgHeader(DLGTEMPLATE *pHeader) 04171 { 04172 PORTNOTETRACE( "dialog", "BaseBar::CreateControlFromResource - do nothing - Resource usage" ); 04173 #ifndef EXCLUDE_FROM_XARALX 04174 // Move past the header 04175 ADDR pResult = (ADDR) (pHeader + 1); 04176 04177 // skip szMenuName 04178 04179 #if WIN32 04180 04181 pResult = (ADDR) MovePastWideStr((LPWSTR) pResult); 04182 04183 #else 04184 04185 switch (*pResult++) 04186 { 04187 // See SDK help file (Dialog Box Resource) for details 04188 case 0: 04189 break; 04190 04191 case 0xFF: 04192 pResult += 2; 04193 break; 04194 04195 default: 04196 pResult += camStrlen((LPTCHAR) (pResult)) + 1; 04197 break; 04198 } 04199 04200 #endif 04201 04202 // then skip szClassName 04203 04204 pResult = (ADDR) MovePastWideStr((LPWSTR) pResult); 04205 04206 // then the caption 04207 04208 pResult = (ADDR) MovePastWideStr((LPWSTR) pResult); 04209 04210 // then the font stuff 04211 if ((pHeader->style) & DS_SETFONT) 04212 pResult = (ADDR) MovePastWideStr((LPWSTR) (pResult + 2)); // skip font size too 04213 04214 DWORD_ALIGN(pResult); 04215 04216 // Compute the size of the header and return it. 04217 return (size_t) (pResult - ((ADDR) pHeader)); 04218 #else 04219 return 0; 04220 #endif 04221 } 04222 04223 04224 /******************************************************************************************** 04225 04226 > size_t BaseBar::SizeCtrlData(DLGITEMTEMPLATE *pData) 04227 04228 Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> 04229 Created: 11/11/93 04230 Inputs: pData - the start of the control structure. 04231 Returns: Size of the control data. 04232 Purpose: Given a ptr to a controldata struct, return its length. 04233 Under Win32, all strings are UniCode (as they are in the res file). 04234 04235 ********************************************************************************************/ 04236 04237 size_t BaseBar::SizeCtrlData(DLGITEMTEMPLATE *pControl) 04238 { 04239 #if WIN32 04240 // Get pointer to the data after the DLGITEMTEMPLATE structure. 04241 WORD *pData = (WORD *) (pControl + 1); 04242 04243 // Skip the class 04244 if (*pData == 0xFFFF) 04245 // There is only one more word - the atom of the window class - skip it. 04246 pData += 2; 04247 else 04248 // The class is specified as a string - skip it 04249 pData = (WORD *) MovePastWideStr((LPWSTR) pData); 04250 04251 // Skip the 'title' array 04252 if (*pData == 0xFFFF) 04253 // There is only one more word - it is a resource ID - skip it. 04254 pData += 2; 04255 else 04256 // The title array is a string - skip it 04257 pData = (WORD *) MovePastWideStr((LPWSTR) pData); 04258 04259 // Skip the creation data. 04260 UINT32 Extra = (UINT32) *pData; 04261 pData++; 04262 04263 #else 04264 // Get pointer to the data after the DLGITEMTEMPLATE structure. 04265 ADDR pData = (ADDR) (pControl + 1); 04266 04267 // Skip the class 04268 if ((*pData) & 0x80) 04269 pData++; 04270 else 04271 pData = (ADDR) MovePastWideStr((LPWSTR) pData); 04272 04273 // Skip the 'text' array 04274 pData = (ADDR) MovePastWideStr((LPWSTR) pData); 04275 04276 // Skip the creation data. 04277 BYTE Extra = *pData; 04278 pData++; 04279 04280 #endif 04281 04282 // Get end pointer and double-word align it. 04283 ADDR pEnd = (ADDR) pData; 04284 DWORD_ALIGN(pEnd); 04285 04286 // Compute size of control data and return it. 04287 ADDR pStart = (ADDR) pControl; 04288 pEnd += Extra; 04289 return (size_t) (pEnd - pStart); 04290 } 04291 04292 04293 04294 /******************************************************************************************** 04295 04296 > BaseBar::InformControlsDead() 04297 04298 Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> 04299 Created: 7/4/94 04300 Inputs: SrcBaseBar: The dialog to copy the controls from 04301 Outputs: - 04302 Returns: - 04303 Purpose: Copies the child controls of SrcBaseBar to this BaseBar. It does not 04304 do any positioning of controls. 04305 Scope: private 04306 Errors: - 04307 SeeAlso: - 04308 04309 ********************************************************************************************/ 04310 04311 void BaseBar::InformControlsDead() 04312 { 04313 #pragma message( __LOCMSG__ "BaseBar::InformControlsDead - do nothing" ) 04314 TRACE( _T("Warning - BaseBar::InformControlsDead called") ); 04315 /* HWND CurrentChild; 04316 HWND NextChild; 04317 for (CurrentChild = ::GetWindow(GetSafeHwnd(),GW_CHILD); 04318 CurrentChild != NULL; 04319 CurrentChild = NextChild) 04320 { 04321 ControlHelper::NotifyControlDeleted(CurrentChild); 04322 NextChild = ::GetWindow(CurrentChild,GW_HWNDNEXT); 04323 } */ 04324 } 04325 04326 /******************************************************************************************** 04327 04328 > wxRect BaseBar::GetDlgBarRect(DockBarType DockBar, wxRect CurrentBarRect) 04329 04330 04331 Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> 04332 Created: 6/4/94 04333 Inputs: DockBar: Specifies which docking bar 04334 CurrentBarRect: The current bar rectangle 04335 Outputs: - 04336 Returns: The new bar rectangle 04337 04338 Purpose: For finding the screen rectangle defining the shape of the BaseBar when 04339 over DockBar 04340 Errors: - 04341 Scope: private 04342 SeeAlso: - 04343 04344 ********************************************************************************************/ 04345 wxRect BaseBar::GetDlgBarRect(DockBarType DockBarType, wxRect CurrentBarRect) 04346 { 04347 /* OILDockingBar* DockBar = GetMainFrame()->GetDockBar(DockBarType); 04348 switch (DockBarType) 04349 { 04350 case DOCKBAR_TOP: 04351 case DOCKBAR_BOTTOM: 04352 if (DockBar->IsBigControls()) 04353 { 04354 if (HorizontalLargeRect.IsEmpty()()) 04355 { 04356 FormatHorizontalBar(FALSE,USE_BAR); 04357 } 04358 } 04359 else 04360 { 04361 if (HorizontalSmallRect.IsEmpty()()) 04362 { 04363 FormatHorizontalBar(FALSE,USE_BAR); 04364 } 04365 } 04366 break; 04367 case DOCKBAR_LEFT: 04368 case DOCKBAR_RIGHT: 04369 if (DockBar->IsBigControls()) 04370 { 04371 if (VerticalLargeRect.IsEmpty()()) 04372 { 04373 FormatVerticalBar(FALSE,USE_BAR); 04374 } 04375 } 04376 else 04377 { 04378 if (VerticalSmallRect.IsEmpty()()) 04379 { 04380 FormatVerticalBar(FALSE,USE_BAR); 04381 } 04382 } 04383 break; 04384 default: 04385 { 04386 ENSURE(DockBarType == DOCKBAR_FLOAT, "Unknown Dockbar type"); 04387 if (DockBar->IsBigControls()) 04388 { 04389 if (FloatLargeRect.IsEmpty()()) 04390 { 04391 FormatFloatingBar(FALSE,USE_BAR); 04392 } 04393 } 04394 else 04395 { 04396 if (FloatSmallRect.IsEmpty()()) 04397 { 04398 FormatFloatingBar(FALSE,USE_BAR); 04399 } 04400 } 04401 04402 break; 04403 04404 } 04405 }*/ 04406 wxRect temp =GetFormatRect(DockBarType); 04407 temp.Offset(CurrentBarRect.GetLeft(),CurrentBarRect.GetRight()); 04408 // temp.OffsetRect(CurrentBarRect.GetLeft(), CurrentBarRect.GetTop()); 04409 return temp; 04410 } 04411 04412 /******************************************************************************************** 04413 04414 > BOOL BaseBar::CanStartDrag(wxPoint point, DlgDragType TypeOfDrag) 04415 04416 Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> 04417 Created: 7/4/94 04418 Inputs: CursorPoint: The screen cursor pos 04419 Outputs: - 04420 Returns: YES / NO 04421 Purpose: decides whether we can start a Drag 04422 Scope: private 04423 Errors: - 04424 SeeAlso: - 04425 04426 ********************************************************************************************/ 04427 04428 04429 BOOL BaseBar::CanStartDrag(wxPoint point) 04430 { 04431 #ifdef STANDALONE 04432 #ifndef EXCLUDE_GALS 04433 if (!this->IsKindOf(RUNTIME_CLASS(GalleryBar))) 04434 return FALSE; 04435 #endif 04436 #endif 04437 04438 return (point.x < (StartDragPoint.x - DRAG_START_MARGIN) || 04439 point.x > (StartDragPoint.x + DRAG_START_MARGIN) || 04440 point.y < (StartDragPoint.y - DRAG_START_MARGIN) || 04441 point.y > (StartDragPoint.y + DRAG_START_MARGIN) 04442 ); 04443 } 04444 04445 /******************************************************************************************** 04446 04447 > void BaseBar::StartDrag(wxPoint point, DlgDragType TypeOfDrag) 04448 04449 Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> 04450 Created: 7/4/94 04451 Inputs: CursorPoint: The screen cursor pos 04452 TypeOfDrag: The type of drag being started 04453 Outputs: - 04454 Returns: - 04455 Purpose: Starts a Drag 04456 Scope: private 04457 Errors: - 04458 SeeAlso: - 04459 04460 ********************************************************************************************/ 04461 04462 04463 void BaseBar::StartDrag(wxPoint point, DlgDragType TypeOfDrag) 04464 { 04465 #pragma message( __LOCMSG__ "BaseBar::StartDrag - do nothing" ) 04466 TRACE( _T("Warning - BaseBar::StartDrag called") ); 04467 /*#ifdef STANDALONE 04468 #ifndef EXCLUDE_GALS 04469 // In StandAlone version we only let the user drag Galleries around 04470 if (!this->IsKindOf(RUNTIME_CLASS(GalleryBar))) 04471 { 04472 return; 04473 } 04474 #endif 04475 #endif 04476 04477 //ControlHelper::BubbleHelpDisable(); 04478 04479 // disable resizing of an empty bar 04480 if (TypeOfDrag != MOVE) 04481 { 04482 if (pOp->IsListEmpty()) 04483 return ; 04484 } 04485 04486 ScreenRect.SetRect(0,0,wxSystemSettings::GetMetric(SM_CXSCREEN),wxSystemSettings::GetMetric(SM_CYSCREEN)); 04487 04488 BorderOffset = wxPoint(0,0); 04489 04490 RECT rect; 04491 GetWindowRect(&rect); 04492 DragStartRect=rect; 04493 DragType = TypeOfDrag; 04494 CurrentBar = this; 04495 OldDragBarType = DragDockBarType = ParentDockBarType; 04496 04497 04498 04499 if (TypeOfDrag == GROW_SOUTH || TypeOfDrag == GROW_NORTH) 04500 { 04501 OILDockingBar* DockBar = GetMainFrame()->GetDockBar(DragDockBarType); 04502 if (DockBar->IsBigControls()) 04503 { 04504 WidestFloat = HorizontalLargeRect.GetWidth(); 04505 TallestFloat = VerticalLargeRect.GetHeight(); 04506 } 04507 else 04508 { 04509 WidestFloat = HorizontalSmallRect.GetWidth(); 04510 TallestFloat = VerticalSmallRect.GetHeight(); 04511 } 04512 CacheFormatingData(); 04513 } 04514 04515 switch (TypeOfDrag) 04516 { 04517 case MOVE : 04518 // Calculate drag offsets, used only by move drags 04519 DragOffset = wxPoint(point.x - rect.GetLeft(), point.y - rect.GetTop()); 04520 DragOffsetFromTop = TRUE; 04521 DragOffsetFromLeft = TRUE; 04522 CacheAllDockRects(); 04523 // Close any drop-down windows in this bar 04524 CloseCombos(); 04525 break; 04526 case GROW_WEST : 04527 BorderOffset = wxPoint(point.x - rect.GetLeft(),0); 04528 break; 04529 case GROW_EAST : 04530 BorderOffset = wxPoint(rect.GetRight() - point.x,0); 04531 break; 04532 case GROW_NORTH : 04533 BorderOffset = wxPoint(0,point.y - rect.GetTop()); 04534 break; 04535 case GROW_SOUTH : 04536 BorderOffset = wxPoint(0,rect.GetBottom() - point.y); 04537 break; 04538 case GROW_NORTHWEST : 04539 BorderOffset = wxPoint(point.x - rect.GetLeft(),point.y - rect.GetTop()); 04540 break; 04541 case GROW_NORTHEAST : 04542 BorderOffset = wxPoint(rect.GetRight() - point.x,point.y - rect.GetTop()); 04543 break; 04544 case GROW_SOUTHEAST : 04545 BorderOffset = wxPoint(rect.GetRight() - point.x,rect.GetBottom() - point.y); 04546 break; 04547 case GROW_SOUTHWEST : 04548 BorderOffset = wxPoint(point.x - rect.GetLeft(),rect.GetBottom() - point.y); 04549 break; 04550 } 04551 04552 // TRACEUSER( "Gerry", _T("DragPoint = (%d, %d)\n"), point.x, point.y); 04553 // TRACEUSER( "Gerry", _T("DragStartRect = (%d, %d) - (%d, %d)\n"), DragStartRect.GetLeft(), DragStartRect.top, DragStartRect.Width(), DragStartRect.GetHeight()); 04554 // TRACEUSER( "Gerry", _T("BorderOffset = (%d, %d)\n"), BorderOffset.x, BorderOffset.y); 04555 04556 SetCapture(); // Capture the mouse 04557 DragManagerOp::SetDragActive(TRUE); 04558 // Keep a copy of the rectangle so we can XOR it off 04559 OldDragRect = rect; 04560 PaintDragRect(OldDragRect,wxRect(0,0,0,0),DragDockBarType,DragDockBarType); */ 04561 } 04562 04563 04564 // ----------------------------------------------------------------------------------------- 04565 // Message map - maintained by Class Wizard. 04566 04567 BEGIN_EVENT_TABLE( BaseBar, wxWindow ) 04568 #pragma message( __LOCMSG__ "Removed BaseBar message map" ) 04569 /* ON_WM_NCCALCSIZE() 04570 ON_WM_NCPAINT() 04571 ON_WM_NCACTIVATE() 04572 ON_WM_PAINT() 04573 ON_WM_NCHITTEST() 04574 ON_WM_MOUSEMOVE() 04575 ON_WM_KILLFOCUS() 04576 ON_WM_SETFOCUS() 04577 ON_WM_NCLBUTTONDOWN() 04578 ON_WM_LBUTTONDOWN() 04579 ON_WM_LBUTTONDBLCLK() 04580 ON_WM_LBUTTONUP() 04581 ON_WM_NCRBUTTONDOWN() 04582 ON_MESSAGE( WM_RESIZECONTROLS,DoResize ) 04583 ON_MESSAGE(WM_CTL_SETFOCUS, SetControlFocus) 04584 ON_MESSAGE(WM_MOVEBAR,MoveBar) 04585 ON_MESSAGE(WM_GETBARSIZE,GetBarSize) 04586 ON_MESSAGE(WM_START_CTLDRAG,StartControlDrag) 04587 ON_MESSAGE(WM_END_CTLDRAG,EndControlDrag) 04588 ON_WM_DESTROY( ) 04589 ON_WM_DRAWITEM( ) 04590 ON_WM_MOUSEACTIVATE( ) 04591 ON_WM_ACTIVATE( ) 04592 ON_WM_ACTIVATEAPP( ) 04593 ON_WM_PARENTNOTIFY( ) 04594 ON_LBN_KILLFOCUS(_R(IDC_GALLERY_LISTBOX),ListLostFocus) 04595 ON_LBN_SELCHANGE(_R(IDC_GALLERY_LISTBOX),ListSelChanged) 04596 ON_WM_MOUSEWHEEL() */ 04597 END_EVENT_TABLE() 04598 04599 /******************************************************************************************** 04600 04601 > void PatB(wxDC * hDC, INT32 x, INT32 y, INT32 dx, INT32 dy, COLORREF rgb) 04602 04603 Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> (Some MFC dude, actually) 04604 Created: 14/3/94 04605 Inputs: hDC - destination DC 04606 x,y,dx,dy - rectangle to fill 04607 rgb - colour to fill with 04608 04609 Purpose: Paints a rectangle in the given (dithered) colour 04610 It looks pretty hideous, but this is how the MFC buttonbar does it... 04611 The conclusions that this leads to are left as an exercise for the reader. 04612 (OK, so they're not. It suggest that either MFC sux, or plotting text is 04613 easier/faster than creating a brush, in which case Windoze sux) 04614 04615 Scope: private 04616 04617 ********************************************************************************************/ 04618 04619 static void PatB( wxDC &DC, INT32 x, INT32 y, INT32 dx, INT32 dy, wxColour &rgb ) 04620 { 04621 #pragma message( __LOCMSG__ "PatB - do nothing" ) 04622 TRACE( _T("Warning - PatB called") ); 04623 /* RECT rect; 04624 04625 rect.x = x; 04626 rect.y = y; 04627 rect.width = dx; 04628 rect.height = dy; 04629 04630 cDC->SetBkColor(rgb); 04631 cDC->ExtTextOut(0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL); */ 04632 } 04633 04634 04635 /******************************************************************************************** 04636 04637 > void BaseBar::Paint3dPlinth(wxDC* pDC, wxRect *rect, BOOL PlinthOut) 04638 04639 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 04640 Created: 3/8/94 04641 Inputs: pDC - The DC to draw into 04642 rect - The rectangle to draw around the OUTSIDE of with a plinth 04643 PlinthOut - FALSE to indent, TRUE to pop-out the plinth. 04644 Outputs: - 04645 Returns: - 04646 Purpose: Draws a rectangular 3d plinth(Chicago/Win 3.1 styles) 04647 around the edge of the given rectangle 04648 04649 ********************************************************************************************/ 04650 04651 void BaseBar::Paint3dPlinth(wxDC* pDC, wxRect *rect, BOOL PlinthOut) 04652 { 04653 #pragma message( __LOCMSG__ "BaseBar::Paint3dPlinth - do nothing" ) 04654 TRACE( _T("Warning - BaseBar::Paint3dPlinth called") ); 04655 /* if((LOBYTE(LOWORD(GetVersion()))) > 3 ) 04656 { 04657 // create brush for the background 04658 wxBrush Back(GetSysColor(COLOR_BTNFACE)); 04659 04660 // select into dc 04661 wxBrush * OldBrush = (wxBrush *) pDC->SelectObject(&Back); 04662 wxRect Fill(rect); 04663 Fill.Inflate(-1,-1); 04664 //Fill.OffsetRect(1,1); 04665 // fill in the background 04666 pDC->FillRect(&Fill, &Back); 04667 04668 // restore dc state 04669 pDC->SelectObject(OldBrush); 04670 04671 04672 COLORREF TopLeft; 04673 COLORREF BotRight; 04674 COLORREF TopLeftInside; 04675 COLORREF BotRightInside; 04676 04677 04678 if (!PlinthOut) 04679 { 04680 TopLeft = GetSysColor(COLOR_WINDOWFRAME); 04681 BotRight = GetSysColor(COLOR_BTNHIGHLIGHT); 04682 TopLeftInside = GetSysColor(COLOR_BTNSHADOW); 04683 BotRightInside = GetSysColor(COLOR_BTNFACE); 04684 } 04685 else 04686 { 04687 TopLeft = GetSysColor(COLOR_BTNHIGHLIGHT); 04688 BotRight = GetSysColor(COLOR_WINDOWFRAME); 04689 TopLeftInside = GetSysColor(COLOR_BTNFACE); 04690 BotRightInside = GetSysColor(COLOR_BTNSHADOW); 04691 } 04692 INT32 x = rect->GetLeft(); 04693 INT32 y = rect->GetTop(); 04694 INT32 dx = rect->GetWidth()-1; 04695 INT32 dy = rect->GetHeight(); 04696 04697 // The plinth is always made up of 4 right-angle elements 04698 // When indented, the colours are swapped, but the elements retain position 04699 PatB(pDC, x, y, 1, dy-1, TopLeft); 04700 PatB(pDC, x, y, dx-1, 1, TopLeft); 04701 04702 PatB(pDC, x+dx-1, y, 1, dy, BotRight); 04703 PatB(pDC, x, y+dy-1, dx, 1, BotRight); 04704 04705 PatB(pDC, x+1, y+1, 1, dy-2, TopLeftInside); 04706 PatB(pDC, x+1, y+1, dx-2, 1, TopLeftInside); 04707 04708 PatB(pDC, x+dx-2, y+1, 1, dy-2, BotRightInside); 04709 PatB(pDC, x+1, y+dy-2, dx-2, 1, BotRightInside); 04710 } 04711 else 04712 { 04713 // create brushes /pens etc.. 04714 wxPen Black(PS_SOLID, 0,RGB(0,0,0)); 04715 wxPen Shadow(PS_SOLID, 0, GetSysColor(COLOR_BTNSHADOW)); 04716 wxPen White(PS_SOLID, 0, GetSysColor(COLOR_BTNHIGHLIGHT)); 04717 wxBrush Back(GetSysColor(COLOR_BTNFACE)); 04718 04719 // select into dc 04720 wxPen *OldPen = (wxPen *) pDC->SelectObject(&Black); 04721 wxBrush * OldBrush = (wxBrush *) pDC->SelectObject(&Back); 04722 04723 // fill in the background 04724 pDC->FillRect(rect, &Back); 04725 04726 // draw the black outline 04727 pDC->MoveTo(rect->GetLeft(), rect->bottom-2); 04728 pDC->LineTo(rect->GetLeft(), rect->GetTop()); 04729 pDC->MoveTo(rect->right-1, rect->bottom-2); 04730 pDC->LineTo(rect->right-1, rect->GetTop()); 04731 pDC->MoveTo(rect->GetLeft()+1, rect->bottom-1); 04732 pDC->LineTo(rect->right-1, rect->bottom-1); 04733 pDC->MoveTo(rect->GetLeft()+1, rect->GetTop()); 04734 pDC->LineTo(rect->right-1, rect->GetTop()); 04735 04736 04737 // draw the 3d slabbing 04738 pDC->SelectObject(((PlinthOut) ? &White : &Shadow)); 04739 pDC->MoveTo(rect->GetLeft()+1, rect->bottom-2); 04740 pDC->LineTo(rect->GetLeft()+1, rect->GetTop()+1); 04741 pDC->LineTo(rect->right-1, rect->GetTop()+1); 04742 04743 pDC->SelectObject(((PlinthOut) ? &Shadow : &White)); 04744 pDC->MoveTo(rect->right-2, rect->GetTop()+2); // Ensure corner pixel is correct 04745 pDC->LineTo(rect->right-2, rect->bottom-2); 04746 pDC->LineTo(rect->GetLeft()+1, rect->bottom-2); 04747 04748 // restore dc state 04749 pDC->SelectObject(OldPen); 04750 pDC->SelectObject(OldBrush); 04751 } */ 04752 04753 } 04754 04755 /******************************************************************************************** 04756 04757 > void BaseBar::OnDrawItem( INT32 nIDCtl, LPDRAWITEMSTRUCT lpDrawItemStruct ) 04758 04759 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 04760 Created: 20/7/94 04761 Inputs: nIDCtl - control id of the gadget to be drawn 04762 lpDrawItemStruct - control data 04763 Outputs: - 04764 Returns: - 04765 Purpose: - called when an owner drawn child of this bars needs to be redraw 04766 04767 ********************************************************************************************/ 04768 04769 04770 #pragma message( __LOCMSG__ "BaseBar::OnDrawItem removed" ) 04771 /*void BaseBar::OnDrawItem( INT32 nIDCtl, LPDRAWITEMSTRUCT lpDrawItemStruct ) 04772 { 04773 // owner drawn text button 04774 if(lpDrawItemStruct->CtlType == ODT_BUTTON) 04775 { 04776 wxRect Rect(lpDrawItemStruct->rcItem); 04777 wxDC hDC; 04778 hDC.Attach(lpDrawItemStruct->hDC); 04779 04780 // is the button selected 04781 BOOL Selected = lpDrawItemStruct->itemState & ODS_SELECTED; 04782 BOOL Focus = lpDrawItemStruct->itemState & ODS_FOCUS; 04783 04784 // paint background and border 04785 // if(lpDrawItemStruct->CtlType== ODT_BUTTON) 04786 Paint3dPlinth(& hDC,&Rect,!Selected); 04787 04788 // if selected shift the text x+1 and y+1 04789 if(Selected) 04790 Rect.OffsetRect(1, 1); 04791 04792 // text paint mode transparent 04793 hDC.SetBkMode(TRANSPARENT); 04794 04795 if ((lpDrawItemStruct->itemState & (ODS_GRAYED | ODS_DISABLED)) != 0) 04796 { 04797 // Slight cheat here- using the button shadow colour, rather than dithering 04798 // the output text as Windows does. This is because we use a small, thin font 04799 // in these buttons, which does not dither well, and solid colour looks 04800 // much better (Note: We can't use GRAYTEXT, because it's the same as BTNFACE!) 04801 hDC.SetTextColor(GetSysColor(COLOR_BTNSHADOW)); 04802 } 04803 else 04804 hDC.SetTextColor(GetSysColor(COLOR_BTNTEXT)); 04805 04806 char wtext[33]; 04807 04808 // get the button text 04809 ::GetWindowText(lpDrawItemStruct->hwndItem,(LPTSTR)wtext,32); 04810 04811 // now draw it formated into the button rectangle 04812 hDC.DrawText(wtext,-1,&Rect,DT_CENTER|DT_VCENTER|DT_SINGLELINE); 04813 04814 if(Focus) 04815 { 04816 wxBrush Back(RGB(0,0,0)); 04817 // select into dc 04818 wxBrush * OldBrush = (wxBrush *) hDC.SelectObject(&Back); 04819 04820 hDC.Ellipse(Rect.GetLeft()+4,Rect.GetTop()+4,Rect.GetLeft()+8,Rect.GetTop()+8); 04821 hDC.SelectObject(OldBrush); 04822 } 04823 // must detach else we eat up GDI16 resources 04824 hDC.Detach(); 04825 } 04826 } */ 04827 04828 // ------------------------------------------------------------------------------------------ 04829 // Message Handler functions 04830 04831 /******************************************************************************************** 04832 04833 > void BaseBar::OnParentNotify( UINT32 message, LPARAM lParam ) 04834 04835 Author: Chris_Parks (Xara Group Ltd) <camelotdev@xara.com> 04836 Created: 19/7/94 04837 Inputs: from Windows 04838 Outputs: - 04839 Returns: - 04840 Purpose: Sets ControlHasFocus flag if input focus with a writable control 04841 Errors: - 04842 SeeAlso: - 04843 Scope: Public 04844 04845 ********************************************************************************************/ 04846 04847 #pragma message( __LOCMSG__ "BaseBar::OnParentNotify removed" ) 04848 /*void BaseBar::OnParentNotify( UINT32 message, LPARAM lParam ) 04849 { 04850 if(message == WM_LBUTTONDOWN) 04851 { 04852 String_256 ClassNameStr; 04853 POINT Pnt; 04854 GetCursorPos(&Pnt); 04855 wxWindow * Cwnd = WindowFromPoint(Pnt); 04856 GetClassName(Cwnd->GetSafeHwnd(), (TCHAR*)ClassNameStr, 255); 04857 04858 // check for ComboBox/Edit/ListBox 04859 if ( (ClassNameStr == String_8(TEXT("ListBox"))) || //ZZZ 04860 (ClassNameStr == String_8(TEXT("Edit"))) || 04861 (ClassNameStr == String_8(TEXT("ComboBox"))) || 04862 (ClassNameStr == String_64(TEXT("cc_1dBitmapComboBoxEdit"))) || 04863 (ClassNameStr == String_64(TEXT("cc_2dBitmapComboBoxEdit"))) 04864 ) 04865 04866 { 04867 ControlHasFocus = TRUE; 04868 } 04869 } 04870 } */ 04871 04872 /******************************************************************************************** 04873 04874 > void BaseBar::OnKillFocus(wxWindow * Wnd) 04875 04876 Author: Chris_Parks (Xara Group Ltd) <camelotdev@xara.com> 04877 Created: 19/7/94 04878 Inputs: - 04879 Outputs: - 04880 Returns: - 04881 Purpose: - nothing at the moment 04882 Errors: - 04883 SeeAlso: - 04884 Scope: Public 04885 04886 ********************************************************************************************/ 04887 04888 #pragma message( __LOCMSG__ "BaseBar::OnKillFocus removed" ) 04889 /*void BaseBar::OnKillFocus( wxWindow*Wnd ) 04890 { 04891 wxWindow::OnKillFocus(Wnd); 04892 } */ 04893 04894 /******************************************************************************************** 04895 04896 > void BaseBar::OnSetFocus(wxWindow * Wnd) 04897 04898 Author: Chris_Parks (Xara Group Ltd) <camelotdev@xara.com> 04899 Created: 19/7/94 04900 Inputs: - 04901 Outputs: - 04902 Returns: - 04903 Purpose: 04904 Errors: - 04905 SeeAlso: - 04906 Scope: Public 04907 04908 ********************************************************************************************/ 04909 04910 04911 #pragma message( __LOCMSG__ "BaseBar::OnSetFocus removed" ) 04912 /*void BaseBar::OnSetFocus( wxWindow * Wnd ) 04913 { 04914 wxWindow::OnSetFocus(Wnd); 04915 } */ 04916 04917 /******************************************************************************************** 04918 04919 > void BaseBar::OnActivateApp( BOOL bActive, HTASK hTask ) 04920 04921 Author: Chris_Parks (Xara Group Ltd) <camelotdev@xara.com> 04922 Created: 19/7/94 04923 Inputs: from mfc 04924 Outputs: - 04925 Returns: - 04926 Purpose: Forces bars to be repainted to reflect active state 04927 Errors: - 04928 SeeAlso: - 04929 Scope: Public 04930 04931 ********************************************************************************************/ 04932 04933 #pragma message( __LOCMSG__ "BaseBar::OnActivateApp removed" ) 04934 /*void BaseBar::OnActivateApp( BOOL bActive, HTASK hTask ) 04935 { 04936 04937 Active = bActive; 04938 ::SendMessage(GetSafeHwnd(), WM_NCPAINT,0,0); 04939 04940 if(!Active && CurrentBar != NULL) 04941 { 04942 if(CtlDragState==DRAGGING) 04943 { 04944 CurrentBar->PaintDragRect(CurrentBar->OldDragRect,wxRect(0,0,0,0),DOCKBAR_FLOAT,DOCKBAR_FLOAT); 04945 CurrentBar->TidyUpControlDrag(); 04946 } 04947 else if(DragType != NONE) 04948 CurrentBar->TidyUpBarDrag(); 04949 } 04950 } */ 04951 04952 /******************************************************************************************** 04953 04954 > void BaseBar::OnActivate( UINT32 state , wxWindow* LastWin, BOOL IsMin) 04955 04956 Author: Chris_Parks (Xara Group Ltd) <camelotdev@xara.com> 04957 Created: 16/6/94 04958 Inputs: from mfc 04959 Outputs: - 04960 Returns: - 04961 Purpose: attempt to force focus to mainframe 04962 Errors: - 04963 SeeAlso: - 04964 Scope: Protected 04965 04966 ********************************************************************************************/ 04967 04968 #pragma message( __LOCMSG__ "BaseBar::OnActivate removed" ) 04969 /*void BaseBar::OnActivate( UINT32 State, wxWindow* pWndOther, BOOL bMinimized ) 04970 { 04971 04972 //if a control has the focus do nothing 04973 if(ControlHasFocus) 04974 return; 04975 04976 04977 // pass the focus back to the mainframe 04978 if ( State == WA_ACTIVE ) 04979 { 04980 GetMainFrame()->SetActiveWindow(); 04981 return; 04982 } 04983 04984 //if(GetMainFrame() == pWndOther) return; 04985 04986 wxWindow::OnActivate(State, pWndOther,bMinimized); 04987 04988 } */ 04989 04990 /******************************************************************************************** 04991 04992 > void BaseBar::OnMouseActivate(wxWindow* pDesktopWnd, UINT32 nHitTest, UINT32 message ) 04993 04994 Author: Chris_Parks (Xara Group Ltd) <camelotdev@xara.com> 04995 Created: 16/6/94 04996 Inputs: from mfc 04997 Outputs: - 04998 Returns: - 04999 Purpose: - 05000 Errors: - 05001 SeeAlso: - 05002 Scope: Protected 05003 05004 ********************************************************************************************/ 05005 05006 #pragma message( __LOCMSG__ "BaseBar::OnMouseActivate removed" ) 05007 /*INT32 BaseBar::OnMouseActivate( wxWindow* pDesktopWnd, UINT32 nHitTest, UINT32 message ) 05008 { 05009 05010 // fix by chris 05011 // if camelot isn't active we should just use default handling - i.e. make camelot active 05012 // don't just throw away the click. 05013 if(GetMainFrame()!= GetActiveWindow()) 05014 return wxWindow::OnMouseActivate( pDesktopWnd, nHitTest, message ); 05015 05016 05017 05018 String_256 ClassNameStr; 05019 POINT Pnt; 05020 GetCursorPos(&Pnt); 05021 wxWindow * Cwnd = WindowFromPoint(Pnt); 05022 GetClassName(Cwnd->GetSafeHwnd(), (TCHAR*)ClassNameStr, 255); 05023 ControlHasFocus = FALSE; 05024 // check for ComboBox/Edit 05025 if ( (ClassNameStr == String_8(TEXT("ListBox"))) || //ZZZ 05026 (ClassNameStr == String_8(TEXT("Edit"))) || 05027 (ClassNameStr == String_8(TEXT("ComboBox"))) || 05028 (ClassNameStr == String_64(TEXT("cc_1dBitmapComboBoxEdit"))) || 05029 (ClassNameStr == String_64(TEXT("cc_2dBitmapComboBoxEdit"))) 05030 ) 05031 { 05032 ControlHasFocus = TRUE; 05033 } 05034 if(ControlHasFocus) 05035 return MA_ACTIVATE; 05036 return MA_NOACTIVATE; 05037 05038 // return wxWindow::OnMouseActivate( pDesktopWnd, nHitTest, message ); 05039 } */ 05040 05041 /******************************************************************************************** 05042 > void BaseBar::OnDestroy( ) 05043 05044 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 05045 Created: 7/5/94 05046 Inputs: - 05047 Outputs: - 05048 Returns: - 05049 Purpose: To Notify ControlHelper and DockingBar that BaseBar is about to die 05050 Errors: - 05051 SeeAlso: - 05052 05053 ********************************************************************************************/ 05054 05055 #pragma message( __LOCMSG__ "BaseBar::OnDestroy removed" ) 05056 /*void BaseBar ::OnDestroy( ) 05057 { 05058 05059 // If the current dialog is set to this bar, set the current dlg to NULL 05060 HWND hwnd = GetSafeHwnd(); 05061 if(hwnd == 0) 05062 return; 05063 05064 if (DialogManager::hDlgCurrent == hwnd) 05065 DialogManager::hDlgCurrent = NULL; 05066 05067 TRACEUSER( "chris", _T("Destruct Bar %X\n"),hwnd); 05068 // inform Help system 05069 05070 InformControlsDead(); 05071 05072 ControlHelper::NotifyBarDeleted(GetSafeHwnd()); 05073 05074 // release bar from it's dock 05075 // If the tool is simply changing rather being closed down we don't want to 05076 // force a tidy 05077 05078 BOOL DoTidy = DO_TIDY; 05079 if (ThisIsAnInfoBar ) 05080 if (Tool::IsToolChanging()) 05081 DoTidy = DONT_TIDY; 05082 05083 if (Camelot.CamelotIsDying()) 05084 { 05085 DoTidy = DONT_TIDY; // We can be messy cos camelot is shutting down 05086 } 05087 05088 GetMainFrame()->GetDockBar(ParentDockBarType)->ReleaseBar(this->GetSafeHwnd(),DoTidy); 05089 05090 }; */ 05091 05092 /******************************************************************************************** 05093 05094 > void BaseBar::ListLostFocus(void ) 05095 05096 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 05097 Created: 7/5/94 05098 Inputs: - 05099 Outputs: - 05100 Returns: - 05101 Purpose: Command received when a list box receives the focus 05102 Errors: - 05103 SeeAlso: - 05104 05105 ********************************************************************************************/ 05106 05107 #pragma message( __LOCMSG__ "BaseBar::ListLostFocus removed" ) 05108 /*void BaseBar::ListLostFocus(void) 05109 { 05110 05111 }*/ 05112 05113 /******************************************************************************************** 05114 05115 > void BaseBar::ListSelChanged(void ) 05116 05117 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 05118 Created: 7/5/94 05119 Inputs: - 05120 Outputs: - 05121 Returns: - 05122 Purpose: Command received when a list box receives the focus - assumes only galleries 05123 will have listbox controls 05124 Errors: - 05125 SeeAlso: - 05126 05127 ********************************************************************************************/ 05128 05129 #pragma message( __LOCMSG__ "BaseBar::ListSelChanged removed" ) 05130 /*void BaseBar::ListSelChanged(void) 05131 { 05132 // if( pOp->IsKindOf(CC_RUNTIME_CLASS(SuperGallery)) ) 05133 // { 05134 // GetMainFrame()->SetActiveWindow(); 05135 // } 05136 }*/ 05137 05138 /******************************************************************************************** 05139 05140 > LRESULT BaseBar::DoResize(WPARAM , LPARAM ) 05141 05142 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 05143 Created: 7/5/94 05144 Inputs: from windows 05145 Outputs: - 05146 Returns: - 05147 Purpose: To recreate this BaseBar after a change in control sizes 05148 Errors: - 05149 SeeAlso: - 05150 05151 ********************************************************************************************/ 05152 05153 #pragma message( __LOCMSG__ "BaseBar::DoResize removed" ) 05154 /*LRESULT BaseBar::DoResize(WPARAM , LPARAM) 05155 { 05156 // ZZZZ 05157 KernelBarPos * Pos; 05158 05159 // if(LastSmallBarPos.x !=-1 &&LastSmallBarPos.y!=-1) 05160 // Pos = & LastSmallBarPos; 05161 // else 05162 Pos = GetMainFrame()->GetDockBar(ParentDockBarType)-> 05163 GetBarPos(this->GetSafeHwnd()); 05164 05165 LastSmallBarPos = * Pos; 05166 KernelBarPos NewPos = *Pos; 05167 05168 // create new BaseBar 05169 BaseBar* NewBaseBar = (BaseBar *)GetRuntimeClass()->CreateObject(); 05170 05171 // Recreate the Dialog at the old position 05172 NewBaseBar->RecreateAt(NewPos,ParentDockBarType, this, pOp,this->GetSafeHwnd()); 05173 //TRACE( _T("Recreate %d"),this->GetSafeHwnd()); 05174 // The operations window id has changed 05175 CCamApp::GetDlgManager()->Delete(this->GetSafeHwnd(),pOp); 05176 //delete this; 05177 05178 return 0; 05179 }*/ 05180 05181 /******************************************************************************************** 05182 05183 > BOOL BaseBar::HaveNonClientMetricsChanged( ) 05184 05185 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 05186 Created: 7/5/94 05187 Inputs: - 05188 Outputs: - 05189 Returns: - 05190 Purpose: returns TRUE if Non-Client metrics have changed 05191 Errors: - 05192 SeeAlso: - 05193 05194 ********************************************************************************************/ 05195 05196 BOOL BaseBar::HaveNonClientMetricsChanged( ) 05197 { 05198 BOOL returnVal = FALSE; 05199 05200 #if _MFC_VER >= 0x400 05201 05202 if( TitleBarHeight != wxSystemSettings::GetMetric(SM_CYSMCAPTION)) 05203 returnVal = TRUE; 05204 if(BorderWidth != wxSystemSettings::GetMetric(SM_CXFRAME)) 05205 returnVal = TRUE; 05206 if(FontFactory::CheckSystemBarFontsChanged()) 05207 returnVal = TRUE; 05208 05209 #endif 05210 05211 return returnVal; 05212 } 05213 05214 /******************************************************************************************** 05215 05216 > LRESULT BaseBar::GetBarSize(WPARAM DockType, LPARAM ControlSize ) 05217 05218 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 05219 Created: 7/5/94 05220 Inputs: from windows 05221 Outputs: - 05222 Returns: - 05223 Purpose: To return a pointer to a rectangle of bar size 05224 Errors: - 05225 SeeAlso: - 05226 05227 ********************************************************************************************/ 05228 05229 #pragma message( __LOCMSG__ "BaseBar::GetBarSize removed" ) 05230 /*LRESULT BaseBar::GetBarSize(WPARAM DockType , LPARAM ControlS) 05231 { 05232 DockBarType ThisDock = (DockBarType) DockType; 05233 ControlSizes ControlSize = (ControlSizes ) ControlS; 05234 05235 switch (ThisDock) 05236 { 05237 case DOCKBAR_TOP: 05238 case DOCKBAR_BOTTOM: 05239 if(ControlSize == LARGE_CONTROLS) 05240 return (LRESULT) &HorizontalLargeRect ; 05241 else 05242 return (LRESULT) &HorizontalSmallRect ; 05243 case DOCKBAR_LEFT: 05244 case DOCKBAR_RIGHT: 05245 if(ControlSize == LARGE_CONTROLS) 05246 return (LRESULT) &VerticalLargeRect ; 05247 else 05248 return (LRESULT) &VerticalSmallRect ; 05249 05250 case DOCKBAR_FLOAT: 05251 if(ControlSize == LARGE_CONTROLS) 05252 return (LRESULT) &FloatLargeRect ; 05253 else 05254 return (LRESULT) &FloatSmallRect ; 05255 } 05256 return 0; 05257 } */ 05258 05259 /******************************************************************************************** 05260 05261 > LRESULT BaseBar::GetBarSize(DockBarType DockBarType) 05262 05263 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 05264 Created: 12/4/2000 05265 Inputs: the dockbar type 05266 Outputs: - 05267 Returns: - 05268 Purpose: To return the size of the bar 05269 Errors: - 05270 SeeAlso: - 05271 05272 ********************************************************************************************/ 05273 05274 wxRect BaseBar::GetBarsDims (DockBarType DockBarType) 05275 { 05276 wxRect ReturnRect(0,0,0,0); 05277 05278 #pragma message( __LOCMSG__ "BaseBar::GetBarsDims - do nothing" ) 05279 TRACE( _T("Warning - BaseBar::GetBarsDims called") ); 05280 /* OILDockingBar* FloatBars = GetMainFrame ()->GetDockBar (DockBarType);//DOCKBAR_FLOAT); 05281 BOOL BigControls = FloatBars->IsBigControls (); 05282 05283 switch (DockBarType) 05284 { 05285 case DOCKBAR_TOP: 05286 case DOCKBAR_BOTTOM: 05287 if (BigControls) 05288 ReturnRect = HorizontalLargeRect; 05289 else 05290 ReturnRect = HorizontalSmallRect; 05291 case DOCKBAR_LEFT: 05292 case DOCKBAR_RIGHT: 05293 if (BigControls) 05294 ReturnRect = VerticalLargeRect; 05295 else 05296 ReturnRect = VerticalSmallRect; 05297 05298 case DOCKBAR_FLOAT: 05299 if (BigControls) 05300 ReturnRect = FloatLargeRect; 05301 else 05302 ReturnRect = FloatSmallRect; 05303 } */ 05304 05305 return ReturnRect; 05306 } 05307 05308 05309 05310 /******************************************************************************************** 05311 05312 > LRESULT BaseBar::SetControlFocus(WPARAM , LPARAM ) 05313 05314 Author: everyone... 05315 Created: 7/5/94 05316 Inputs: - 05317 Outputs: - 05318 Returns: - 05319 Purpose: used to be sent by controls to inform bar that a control has got the focus 05320 not ****ing sure anymore . 05321 Errors: - 05322 SeeAlso: - 05323 05324 ********************************************************************************************/ 05325 05326 #pragma message( __LOCMSG__ "BaseBar::GetBarSize removed" ) 05327 /*LRESULT BaseBar::SetControlFocus(WPARAM State, LPARAM Hwnd) 05328 { 05329 if (State == TRUE) 05330 DialogManager::hDlgCurrent = GetSafeHwnd(); 05331 else 05332 DialogManager::hDlgCurrent = NULL; 05333 05334 if(ControlHasFocus == (BOOL)State) 05335 { 05336 return 0; 05337 } 05338 05339 05340 if(State !=COMMIT && HwndWithFocus != (HWND)Hwnd) 05341 return 0; 05342 05343 // this is sent after return is pressed in a control 05344 if(State == COMMIT) 05345 State = FALSE; 05346 05347 if(!GetMainFrame()->IsAppActive()) 05348 { 05349 return 0; 05350 } 05351 ControlHasFocus = State ; 05352 HwndWithFocus = (HWND)Hwnd ; 05353 // give the focus back to the main frame 05354 if(State == FALSE) 05355 { 05356 GetMainFrame()->SetActiveWindow(); 05357 ::HideCaret(NULL); 05358 } 05359 05360 return 0; 05361 } */ 05362 05363 /******************************************************************************************** 05364 05365 > LRESULT BaseBar::StartControlDrag(WPARAM , LPARAM ) 05366 05367 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 05368 Created: 15\11/94 05369 Inputs: from windows 05370 Outputs: - 05371 Returns: - 05372 Purpose: sent by controls to inform bar that a control is about to be dragged 05373 Errors: - 05374 SeeAlso: - 05375 05376 ********************************************************************************************/ 05377 05378 #pragma message( __LOCMSG__ "BaseBar::GetBarSize removed" ) 05379 /*LRESULT BaseBar::StartControlDrag(WPARAM State, LPARAM Hwnd) 05380 { 05381 #ifdef STANDALONE 05382 return FALSE; 05383 #else 05384 05385 if(!KeyPress::IsAlternativePressed()) 05386 return FALSE; 05387 // we can't drag items on or off infobars or double deckers (for the mo) 05388 BarControl * foundControl = (BarControl*)pOp->GetBarItem((HWND)Hwnd); 05389 05390 if (foundControl) 05391 { 05392 // use these to get pointers to first and last item of double decker if found 05393 BarControl * DDStart = NULL; 05394 BarControl * DDEnd = NULL; 05395 05396 BOOL DoubleDecker = FALSE; 05397 if(IsDoubleDecker(foundControl,DDStart,DDEnd)!=DDECKER_NONE) 05398 DoubleDecker = TRUE; 05399 05400 if(!ThisIsAnInfoBar && !DoubleDecker) 05401 { 05402 InRecreate = TRUE; 05403 // keep a record of the ctl hwnd 05404 DragCtlHwnd = (HWND)Hwnd; 05405 05406 // get the initial outline 05407 ::GetWindowRect(DragCtlHwnd,&OldDragRect); 05408 05409 // and the 'size' 05410 ::GetClientRect(DragCtlHwnd,&DragCtlClientRect); 05411 05412 // calculate the cursor offset into the control 05413 wxPoint CursorPos; 05414 GetCursorPos(&CursorPos); 05415 ::ScreenToClient(DragCtlHwnd,&CursorPos); 05416 DragCtlOffset = CursorPos; 05417 05418 // paint the outline 05419 PaintDragRect(OldDragRect,wxRect(0,0,0,0),DOCKBAR_FLOAT,DOCKBAR_FLOAT); 05420 05421 // Dragging Control is on 05422 CtlDragState = DRAGGING; 05423 05424 // and capture the mouse 05425 SetCapture(); 05426 CurrentBar = this; 05427 // GetMainFrame()->SetActiveWindow(); // BODGE! Removed by Phil 13/10/96 (at 23.12!) 05428 DragManagerOp::SetDragActive(TRUE); 05429 05430 if(CtlDragMode == COPY) 05431 pCurrentCursor = new Cursor(_R(IDC_BUTTONDRAGCOPY)); 05432 else 05433 pCurrentCursor = new Cursor(_R(IDC_BUTTONDRAGCUT)); 05434 05435 // Did the cursor create ok ? 05436 if (pCurrentCursor && pCurrentCursor->IsValid()) 05437 { 05438 CurrentCursorID = CursorStack::GPush(pCurrentCursor, TRUE); // Push cursor, and display now 05439 } 05440 05441 } 05442 return 0; 05443 } 05444 05445 return 0; 05446 #endif 05447 } */ 05448 05449 #pragma message( __LOCMSG__ "BaseBar::GetBarSize removed" ) 05450 /*LRESULT BaseBar::EndControlDrag(WPARAM State, LPARAM Hwnd) 05451 { 05452 return 0; 05453 } */ 05454 05455 /******************************************************************************************** 05456 05457 > LRESULT BaseBar::StartControlDrag(WPARAM , LPARAM ) 05458 05459 Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> 05460 Created: 15\11/94 05461 Inputs: from windows 05462 Outputs: - 05463 Returns: - 05464 Purpose: sent by controls to inform bar that a control is about to be dragged 05465 Errors: - 05466 SeeAlso: - 05467 05468 ********************************************************************************************/ 05469 05470 BOOL BaseBar::SwapCursors(DWORD CursorID) 05471 { 05472 ERROR2IF(pCurrentCursor==NULL,FALSE,"Null last Cursor in SwapCursors"); 05473 ERROR2IF(CurrentCursorID==0,FALSE,"CurrentID 0 in SwapCursors"); 05474 05475 if(pCurrentCursor) 05476 { 05477 CursorStack::GPop(CurrentCursorID); 05478 delete pCurrentCursor; 05479 pCurrentCursor = NULL; 05480 CurrentCursorID = 0; 05481 } 05482 05483 pCurrentCursor = new Cursor(CursorID); 05484 05485 // Did the cursor create ok ? 05486 if (pCurrentCursor && pCurrentCursor->IsValid()) 05487 { 05488 CurrentCursorID = CursorStack::GPush(pCurrentCursor, TRUE); // Push cursor, and display now 05489 } 05490 else 05491 return FALSE; 05492 05493 return TRUE ; 05494 } 05495 05496 05497 05498 05499 /******************************************************************************************** 05500 05501 > LRESULT BaseBar::WindowProc( UINT32 message, WPARAM wParam, LPARAM lParam ) 05502 05503 Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> 05504 Created: 16/4/94 05505 Inputs: from windows 05506 Outputs: - 05507 Returns: - 05508 Purpose: The BaseBar's WindowProc firstly sends the message to the dialog manager 05509 so that it can dispatch it to the appropriate DialogBarOp (if neccessary). 05510 Then the message is processed as normal. 05511 Errors: - 05512 SeeAlso: - 05513 05514 ********************************************************************************************/ 05515 05516 LRESULT BaseBar::WindowProc( UINT32 Message, WPARAM wParam, LPARAM lParam ) 05517 { 05518 #pragma message( __LOCMSG__ "BaseBar::WindowProc - do nothing" ) 05519 TRACE( _T("Warning - BaseBar::WindowProc called") ); 05520 /* // First send the message to the dialog manager 05521 DialogManager::SendDialogMessage(this, 05522 Message, 05523 wParam, 05524 lParam); 05525 05526 05527 // this checks to see whether this Window is still around 05528 // it is possible that the kernel just deleted this window 05529 // no further proceesing if this is the case ! 05530 if(!(IsWindow(GetSafeHwnd()))) return 0; 05531 // return brush for ctl3d 05532 switch(Message) 05533 { 05534 case WM_COMMAND: 05535 //TRACEUSER( "chris", _T("WM_COMMAND to %d\n"),GetSafeHwnd()); 05536 // user has closed down a combo list - return focus to mainframe 05537 if(HIWORD(wParam)==CBN_CLOSEUP) 05538 GetMainFrame()->SetFocus(); 05539 05540 break; 05541 #ifdef WIN32 05542 case WM_CTLCOLORBTN: 05543 case WM_CTLCOLORDLG: 05544 case WM_CTLCOLOREDIT: 05545 case WM_CTLCOLORLISTBOX: 05546 case WM_CTLCOLORMSGBOX: 05547 case WM_CTLCOLORSCROLLBAR: 05548 case WM_CTLCOLORSTATIC: 05549 #else 05550 case WM_CTLCOLOR: 05551 #endif 05552 HBRUSH hbrush = DoCtl3dCtlColorEx(Message, wParam, lParam); 05553 if (hbrush != NULL) 05554 return (LRESULT)hbrush; 05555 } 05556 // Now process the message normally 05557 return(wxWindow::WindowProc( Message, wParam, lParam )); */ 05558 05559 return 0; 05560 } 05561 05562 05563 /******************************************************************************************** 05564 05565 > void BaseBar::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp) 05566 05567 Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> 05568 Created: 1/9/93 05569 Inputs: bCalcValidRects - unused 05570 lpncsp - pointer to the structure containing the window area.