Category

Development Platform
Home > SourceCode/Document > Graph program > View Code
MainFrm.cpp
Package: solidgraph_sources.zip　[view]
Upload User: kairuinn
Upload Date: 2009-02-07
Package Size: 2922k
Code Size: 25k
Category:

Graph program

Development Platform:

Visual C++

MainFrm.cpp：Code Content
  1. // MainFrm.cpp : implementation of the CMainFrame class
  2. //
  4. #include "stdafx.h"
  5. #include "Solidgraph.h"
  6. #include "DocManagerEx.h"
  8. #include "MainFrm.h"
  10. #include "ChildFrm.h"
  12. #include "Dialogs//SetupsDlg.h"
  14. #ifdef _DEBUG
  15. #define new DEBUG_NEW
  16. #endif
  18. static UINT framesToolbarsCurID = START_ID_FOR_FRAMES_TOOLBARS;
  19. // CMainFrame
  21. IMPLEMENT_DYNAMIC(CMainFrame, CEGMDIFrameWnd)
  22. IMPLEMENT_DOCKING(CMainFrame)
  24. BEGIN_MESSAGE_MAP(CMainFrame, CEGMDIFrameWnd)
  25. ON_WM_CREATE()
  26. ON_DOCKING_MESSAGES()
  27. // Global help commands
  28. ON_COMMAND(ID_HELP_FINDER, CEGMDIFrameWnd::OnHelpFinder)
  29. ON_COMMAND(ID_HELP, CEGMDIFrameWnd::OnHelp)
  30. ON_COMMAND(ID_CONTEXT_HELP, CEGMDIFrameWnd::OnContextHelp)
  31. ON_COMMAND(ID_DEFAULT_HELP, CEGMDIFrameWnd::OnHelpFinder)
  32. ON_WM_DESTROY()
  33. ON_MESSAGE_VOID(WM_IDLEUPDATECMDUI, OnIdleUpdateCmdUI)
  34. ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTW, 0, 0xFFFF, OnToolTipText)
  35. ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, OnToolTipText)
  36. ON_COMMAND(ID_SYSTEM_PANEL, OnSystemPanel)
  37. ON_UPDATE_COMMAND_UI(ID_SYSTEM_PANEL, OnUpdateSystemPanel)
  38. ON_COMMAND(ID_SHOW_SCENE_PANEL, OnScenePanel)
  39. ON_UPDATE_COMMAND_UI(ID_SHOW_SCENE_PANEL, OnUpdateScenePanel)
  40. ON_COMMAND(ID_SHOW_COMMAND_PANEL, OnCommandPanel)
  41. ON_UPDATE_COMMAND_UI(ID_SHOW_COMMAND_PANEL, OnUpdateCommandPanel)
  42. ON_COMMAND(ID_SHOW_SCRIPT_PANEL, OnScriptPanel)
  43. ON_UPDATE_COMMAND_UI(ID_SHOW_SCRIPT_PANEL, OnUpdateScriptPanel)
  44. ON_COMMAND(ID_SETUPS, OnSetups)
  45. ON_MESSAGE( WM_ENTERSIZEMOVE, OnEnterSizeMove) 
  46. ON_MESSAGE( WM_EXITSIZEMOVE, OnExitSizeMove)
  47. END_MESSAGE_MAP()
  49. static UINT one_indicator[] =
  50. {
  51. ID_SEPARATOR           // status line indicator
  52. };
  54. static UINT indicators[] =
  55. {
  56. ID_SEPARATOR,           // status line indicator
  57. ID_INDICATOR_CAPS,
  58. ID_INDICATOR_NUM,
  59. ID_INDICATOR_SCRL,
  60. };
  63. // CMainFrame construction/destruction
  65. CMainFrame::CMainFrame():
  66. m_exist_child(false)
  67. , m_PluginsSubMenu(NULL)
  68. , m_bInsertStringsInGeometryMenu(false)
  69. , m_last_active_Child(NULL)
  70. , m_first_raz(true)
  71. {
  72. m_cursorer = new CCursorer();
  73. }
  75. CMainFrame::~CMainFrame()
  76. {
  77. delete m_cursorer;
  78. if (m_PluginsSubMenu)
  79. delete m_PluginsSubMenu;
  80. }
  82. static char  progress_steps_count=0;
  83. static char  progress_cur_step=0;
  85. bool CMainFrame::InitProgresser(unsigned int steps_count)
  86. {
  87. if (!::IsWindow(m_info_bar.m_hWnd) || steps_count==0)
  88. return false;
  90. m_info_bar.SetInfoStyle(INFO_PROGRESS);
  91. progress_steps_count = steps_count;
  92. return true;
  93. }
  95. bool CMainFrame::Progress(unsigned int progress_percent)
  96. {
  97. if (!::IsWindow(m_info_bar.m_hWnd) || progress_steps_count==0)
  98. return false;
  100. if (progress_percent==100)
  101. {
  102. progress_cur_step++;
  103. m_info_bar.Progress(progress_cur_step*100/progress_steps_count);
  104. if (progress_cur_step==progress_steps_count)
  105. {
  106. m_info_bar.Progress(100);
  107. progress_cur_step=0;
  108. progress_steps_count =0;
  109. m_info_bar.SetInfoStyle(INFO_TEXT);
  110. }
  111. }
  112. else
  113. {
  114. m_info_bar.Progress(progress_cur_step*100/progress_steps_count+
  115. static_cast<int>(progress_percent/progress_steps_count));
  116. }
  117. return true;
  118. }
  120. bool CMainFrame::StopProgresser()
  121. {
  122. if (!::IsWindow(m_info_bar.m_hWnd) || progress_steps_count==0)
  123. return false;
  125. progress_cur_step=0;
  126. progress_steps_count =0;
  127. m_info_bar.SetInfoStyle(INFO_TEXT);
  128. return true;
  129. }
  131. /**/
  132. void CMainFrame::PutMessageFromChildFrame(IApplicationInterface::MESSAGE_TYPE mes_type,
  133. const char* mes_str)
  134. {
  135. if (!::IsWindow(m_info_bar.m_hWnd))
  136. return;
  138. switch(mes_type) 
  139. {
  140. case IApplicationInterface::MT_MESSAGE:
  141. m_info_bar.SetMessageString(mes_str);
  142. break;
  143. case IApplicationInterface::MT_WARNING:
  144. m_info_bar.SetWarningString(mes_str,NULL);
  145. break;
  146. case IApplicationInterface::MT_ERROR:
  147. m_info_bar.SetErrorString(mes_str,NULL);
  148. break;
  149. default:
  150. break;
  151. }
  152. }
  155. void CMainFrame::DockControlBarRightOf(CToolBar* Bar, CToolBar* Left)
  156. {
  157. /*if (!Left)
  158. {
  159. DockControlBar(Bar);
  160. return;
  161. }
  163. CRect rect;
  164. DWORD dw;
  165. UINT n;
  167. // get MFC to adjust the dimensions of all docked ToolBars
  168. // so that GetWindowRect will be accurate
  169. RecalcLayout(TRUE);
  171. Left->GetWindowRect(&rect);
  172. rect.OffsetRect(1,0);
  173. dw=Left->GetBarStyle();
  174. n = 0;
  175. n = (dw&CBRS_ALIGN_TOP) ? AFX_IDW_DOCKBAR_TOP : n;
  176. n = (dw&CBRS_ALIGN_BOTTOM && n==0) ? AFX_IDW_DOCKBAR_BOTTOM : n;
  177. n = (dw&CBRS_ALIGN_LEFT && n==0) ? AFX_IDW_DOCKBAR_LEFT : n;
  178. n = (dw&CBRS_ALIGN_RIGHT && n==0) ? AFX_IDW_DOCKBAR_RIGHT : n;
  180. // When we take the default parameters on rect, DockControlBar will dock
  181. // each Toolbar on a seperate line. By calculating a rectangle, we
  182. // are simulating a Toolbar being dragged to that location and docked.
  183. DockControlBar(Bar,n,&rect);*/
  185. if (!Left)
  186. {
  187. DockControlBar(Bar);
  188. return;
  189. }
  190. ASSERT(Bar != NULL);
  191. ASSERT(Bar != Left);
  192. // the neighbour must be already docked
  193. CDockBar* pDockBar = Left->m_pDockBar;
  194. ASSERT(pDockBar != NULL);
  195. UINT nDockBarID = Left->m_pDockBar->GetDlgCtrlID();
  196. ASSERT(nDockBarID != AFX_IDW_DOCKBAR_FLOAT);
  197. bool bHorz = (nDockBarID == AFX_IDW_DOCKBAR_TOP ||
  198. nDockBarID == AFX_IDW_DOCKBAR_BOTTOM);
  199. // dock normally (inserts a new row)
  200. DockControlBar(Bar, nDockBarID);
  201. // delete the new row (the bar pointer and the row end mark)
  202. pDockBar->m_arrBars.RemoveAt(pDockBar->m_arrBars.GetSize() - 1);
  203. pDockBar->m_arrBars.RemoveAt(pDockBar->m_arrBars.GetSize() - 1);
  204. // find the target bar
  205. for (int i = 0; i < pDockBar->m_arrBars.GetSize(); i++)
  206. {
  207. void* p = pDockBar->m_arrBars[i];
  208. if (p == Left) // and insert the new bar after it
  209. pDockBar->m_arrBars.InsertAt(i + 1, Bar);
  210. }
  211. // move the new bar into position
  212. CRect rBar;
  213. Left->GetWindowRect(rBar);
  214. rBar.OffsetRect(bHorz ? 1 : 0, bHorz ? 0 : 1);
  215. Bar->MoveWindow(rBar);
  216. }
  218. /*
  219. CWnd* CMainFrame::GetMessageBar()
  220. {
  221. return &m_wndStatusBar;
  222. }*/
  225. static WORD menu_icons[] = { IDB_GEOMETRY_TOOLBAR_TC, 
  226. 16,16,
  228. ID_FILE_NEW,
  229. ID_FILE_OPEN,
  231. NULL
  232. };
  235. int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
  236. {
  237. if (CEGMDIFrameWnd::OnCreate(lpCreateStruct) == -1)
  238. return -1;
  240. /*if (!m_wndStatusBar.Create(this) ||
  241. !m_wndStatusBar.SetIndicators(indicators,
  242.   sizeof(indicators)/sizeof(UINT)))
  243. {
  244. TRACE0("Failed to create status barn");
  245. return -1;      // fail to create
  246. }*/
  248. if (!m_info_bar.Create(this,IDD_INFO_DLG,
  249. CBRS_TOOLTIPS | CBRS_SIZE_DYNAMIC|CBRS_ALIGN_BOTTOM,1001))
  250. {
  251. TRACE0("Failed to create dialogbarn");
  252. return -1;      // fail to create
  253. }
  254. m_info_bar.EnableDocking(CBRS_ALIGN_BOTTOM);
  256. if( !m_wndAppTabManager.CreateAppTabManager(this) )
  257. {
  258. TRACE0(_T("Failed to create MDI Manager n"));  
  259. return FALSE;      // fail to create
  260. }
  261. EnableDocking(CBRS_ALIGN_ANY);
  262. if (!m_wndMenuBar.Create(this,WS_CHILD | WS_VISIBLE | CBRS_ALIGN_TOP|CBRS_SIZE_DYNAMIC|CBRS_TOOLTIPS|CBRS_GRIPPER))
  263. {
  264. TRACE0("Failed to create menu barn");
  265. return -1;      // fail to create
  266. }
  268. m_wndMenuBar.EnableDocking(CBRS_ALIGN_ANY);
  269. EnableDocking(CBRS_ALIGN_ANY);
  270. DockControlBar(&m_wndMenuBar);
  272. m_DefaultNewMenu.LoadToolBar( menu_icons, RGB( 255, 0, 255 ) );
  273. m_wndMenuBar.SetMenu(&m_DefaultNewMenu);
  275. CString tmpLab;
  276. tmpLab.LoadString(IDS_MENU_PANEL);
  277. m_wndMenuBar.SetWindowText(tmpLab);
  279. tmpLab.LoadString(IDS_STANDARD_TLB_CAPT);
  281. /*CreateToolBar(IDR_MAINFRAME,tmpLab, IDB_MAINFRAME_TOOBAR_TC,
  282. WS_VISIBLE | CBRS_ALIGN_TOP , false,NULL);*/
  283. CToolBar* prevT = CreateToolBar(IDR_GEOMETRY,tmpLab,  IDB_GEOMETRY_TOOLBAR_TC,
  284. CBRS_ALIGN_TOP , true,NULL);
  285. /*tmpLab.LoadString(IDS_PROJECTION_TLB_CAPT);
  286. prevT = CreateToolBar(IDR_PROJECTION_TOOLBAR,tmpLab, IDB_PROJECTION_TOOLBAR_TC,
  287. CBRS_ALIGN_TOP,true,prevT);
  288. tmpLab.LoadString(IDS_NAVIGATE_TLB_CAPT);
  289. prevT = CreateToolBar(IDR_NAVIGATE_TOOLBAR,tmpLab,IDB_NAVIGATE_TOOLBAR_TC,
  290. CBRS_ALIGN_TOP,true,prevT);*/
  291. tmpLab.LoadString(IDS_SNAPS_TLB_CAPT);
  292. prevT = CreateToolBar(IDR_SNAPS_TOOLBAR,tmpLab,IDB_SNAP_TOOLBAR_TC,
  293. CBRS_ALIGN_TOP,true,prevT);
  294. /*tmpLab.LoadString(IDS_MAT_TLB_CAPT);
  295. prevT = CreateToolBar(IDR_MATERIAL_TOOLBAR,tmpLab,IDB_MAINFRAME_TOOBAR_TC,
  296. CBRS_ALIGN_TOP,true,prevT);*/
  298. tmpLab.LoadString(IDS_STANDARD_TLB_CAPT);
  299. prevT = CreateToolBar(IDR_REPORT_TOOLBAR,tmpLab,  IDB_REPORT_TC,
  300. CBRS_ALIGN_TOP , false,NULL);
  301. tmpLab.LoadString(IDS_OBJCTS);
  302. prevT = CreateToolBar(IDR_REPORT_OBJECTS_TOOLBAR,tmpLab,  IDB_REPORT_OBJECTS,
  303. CBRS_ALIGN_TOP , false,prevT);
  304. tmpLab.LoadString(IDS_REPORT_VIEW);
  305. prevT = CreateToolBar(IDR_REPORT_VIEW,tmpLab,  IDB_REPORT_VIEW,
  306. CBRS_ALIGN_TOP , false,prevT);
  308. if (theApp.m_main_pluginer)
  309.  for (size_t ii=0;ii<theApp.m_main_pluginer->m_toolbar_plugins.size();ii++)
  310. AddToolbarPlugin(theApp.m_main_pluginer->m_toolbar_plugins[ii]);
  312. CreateSystemToolbar();
  314. CDocTemplate* pTemplate = NULL;
  315. POSITION posit = theApp.m_pDocManager->GetFirstDocTemplatePosition();
  316. int i=0;
  317. while (posit)
  318. {
  319. pTemplate = theApp.m_pDocManager->GetNextDocTemplate(posit);
  320. CString srr;
  321. if (i==0)
  322. srr = "3D";
  323. else
  324. srr = "2D";
  325. m_wndAppTabManager.AddTab(pTemplate,srr);
  326. i++;
  327. }
  329. EnableDocking(CBRS_ALIGN_ANY);
  330. /*EnableDocking( CBRS_ALIGN_TOP );
  331. EnableDocking( CBRS_ALIGN_LEFT );
  332. EnableDocking( CBRS_ALIGN_BOTTOM );
  333. EnableDocking( CBRS_ALIGN_RIGHT );*/
  335. //m_wndPanelsContainer.Create(this, 100);
  337. //m_script_dlg.Create(CScriptDlg::IDD, &m_wndPanelsContainer);
  338. //m_scene_tree_dlg.Create(CSceneTreeDlg::IDD,&m_wndPanelsContainer);
  340. EnablePinning( CBRS_ALIGN_ANY );
  341. CSize sizeDefault( 200, 200 );
  343. CString tttS;
  344. tttS.LoadString(IDS_COMMANDER);
  345. if (!m_commander_docking.CreatePane((TCHAR*)(LPCTSTR)tttS, sizeDefault,  this, NULL, dctLeft) )
  346. {
  347. TRACE0("Failed to create Workspace viewn");
  348. return -1;    // fail to create
  349. }
  350. m_commander_docking.SetIcon( IDB_COMMANDER );
  352. tttS.LoadString(IDS_SCENE);
  353. if (!m_scene_tree_panel.CreatePane( (TCHAR*)(LPCTSTR)tttS, sizeDefault,  this, NULL, dctRight) )
  354. {
  355. TRACE0("Failed to create Workspace viewn");
  356. return -1;    // fail to create
  357. }
  358. m_scene_tree_panel.SetIcon( IDB_SCENE );
  360. tttS.LoadString(IDS_SCRIPTS);
  361.  m_script_panel.SetResourceID( IDR_SCRIPT_TLB );
  362. if (!m_script_panel.CreatePane( (TCHAR*)(LPCTSTR)tttS, sizeDefault,  this, &m_scene_tree_panel, dctTab) )
  363. {
  364. TRACE0("Failed to create Workspace viewn");
  365. return -1;    // fail to create
  366. }
  367. m_script_panel.GetToolbar()->LoadHiColor(MAKEINTRESOURCE(IDB_SCRIPT_TLB));
  368. m_script_panel.SetIcon( IDB_SCRIPT );
  370. return 0;
  371. }
  375. LRESULT CMainFrame::OnEnterSizeMove(WPARAM,LPARAM)
  376. {
  377. CMDIChildWnd* pChild = MDIGetActive();
  379. if (pChild)
  380. {
  381. CView* v = pChild->GetActiveView();
  382. if (v)
  383. v->PostMessage(WM_ENTERSIZEMOVE);
  384. }
  385. return 0L;
  386. }
  388. LRESULT CMainFrame::OnExitSizeMove(WPARAM,LPARAM)
  389. {
  390. CMDIChildWnd* pChild = MDIGetActive();
  392. if (pChild)
  393. {
  394. CView* v = pChild->GetActiveView();
  395. if (v)
  396. v->PostMessage(WM_EXITSIZEMOVE);
  397. }
  398. return 0L;
  399. }
  402. void CMainFrame::AddPluginMenu()
  403. {
  404. if (m_PluginsSubMenu)
  405. return;
  406. if (!theApp.m_main_pluginer)
  407. return;
  408. if (!theApp.m_main_pluginer->m_toolbar_plugins.empty())
  409. {
  410. m_PluginsSubMenu = new  CEGMenu();
  411. m_PluginsSubMenu->CreatePopupMenu();
  412. CString plTitle;
  413. plTitle.LoadString(IDS_PLUGINS_MENU_STRING);
  414. CWinApp* MyApp=AfxGetApp(); 
  415. POSITION pos;
  416. pos=MyApp->GetFirstDocTemplatePosition();
  417. reinterpret_cast<CEGMultiDocTemplate*>( 
  418. const_cast<CDocTemplate*>(MyApp->GetNextDocTemplate(pos))
  419. )->m_NewMenuShared.InsertMenu(5,MF_BYPOSITION|MF_POPUP,
  420. reinterpret_cast<UINT>(m_PluginsSubMenu->m_hMenu), plTitle);
  421. size_t sz = theApp.m_main_pluginer->m_toolbar_plugins.size();
  422. for (size_t i = 0; i < sz; i++)
  423. m_PluginsSubMenu->AppendMenu(MF_STRING, theApp.m_main_pluginer->m_toolbar_plugins[i]->m_nID_Menu, 
  424. theApp.m_main_pluginer->m_toolbar_plugins[i]->m_info.menu_string);
  425. m_wndMenuBar.RefreshBar();
  426. }
  427. }
  429. void  CMainFrame::InsertToolbarsStringsInMenu()
  430. {
  431. size_t sz = m_geometry_toolbars_container.size();
  432. CString tmpStr;
  433. if (!m_bInsertStringsInGeometryMenu)
  434. {
  435. for (size_t i = 0; i < sz; i++)
  436. if (m_geometry_toolbars_container[i].menuID>=START_ID_FOR_FRAMES_TOOLBARS &&
  437. m_geometry_toolbars_container[i].geometry)
  438. {
  439. m_geometry_toolbars_container[i].toolbar->GetWindowText(tmpStr);
  440. CWinApp* MyApp=AfxGetApp(); 
  441. POSITION pos;
  442. pos=MyApp->GetFirstDocTemplatePosition();
  443. reinterpret_cast<CEGMultiDocTemplate*>( 
  444. const_cast<CDocTemplate*>(MyApp->GetNextDocTemplate(pos))
  445. )->m_NewMenuShared.GetSubMenu(2)->
  446. GetSubMenu(0)->AppendMenu(MF_STRING, m_geometry_toolbars_container[i].menuID, 
  447. tmpStr);
  448. }
  449. m_bInsertStringsInGeometryMenu = true;
  450. }
  451. }
  453. void   CMainFrame::ActivateTab(CDocTemplate* dT)
  454. {
  455. if (dT && theApp.m_pDocManager)
  456. ((CDocManagerEx*)theApp.m_pDocManager)->ActivateFrame(dT);
  457. }
  459. void CMainFrame::OnDestroy()
  460. {
  461. int i,j, sz = m_geometry_toolbars_container.size();
  462. if (theApp.m_main_pluginer)
  463. {
  464. int plTsz = theApp.m_main_pluginer->m_toolbar_plugins.size();
  465. for(i=0;i<sz;i++)
  466. {
  467. bool plagT = false;
  468. for (j=0;j<plTsz;j++)
  469. if (&theApp.m_main_pluginer->m_toolbar_plugins[j]->m_toolbar==m_geometry_toolbars_container[i].toolbar)
  470. {
  471. plagT = true;
  472. break;
  473. }
  474. if (!plagT && m_geometry_toolbars_container[i].toolbar!=&m_system_toolbar)
  475. {
  476. m_geometry_toolbars_container[i].toolbar->DestroyWindow();
  477. delete m_geometry_toolbars_container[i].toolbar;
  478. }
  479. }
  480. }
  481. m_geometry_toolbars_container.clear();
  482. CEGMDIFrameWnd::OnDestroy();
  483. }
  486. BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
  487. {
  488. if( !CEGMDIFrameWnd::PreCreateWindow(cs) )
  489. return FALSE;
  490. // TODO: Modify the Window class or styles here by modifying
  491. //  the CREATESTRUCT cs
  493. cs.style = WS_OVERLAPPED | WS_CAPTION | FWS_ADDTOTITLE
  494.  | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_MAXIMIZE | WS_SYSMENU;
  496. return TRUE;
  497. }
  500. CToolBar* CMainFrame::CreateToolBar(UINT nResID,LPCTSTR t_caption, UINT BitmapID,
  501. DWORD startSideAndVis, bool geometry,
  502. CToolBar* leftOf )
  503. {
  504. // Create a new toolbar object and set the auto delete option
  505. CEGToolBar* pToolBar = new CEGToolBar;
  507. if ( ! pToolBar->CreateEx(this, TBSTYLE_FLAT, WS_CHILD | startSideAndVis
  508. | CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC) )
  509. {
  510. TRACE("Failed creating toolbar %dn", nResID);
  511. return NULL;
  512. }
  514. // Load the toolbar
  515. if ( ! pToolBar->LoadToolBar(nResID) )
  516. {
  517. TRACE("Failed loading toolbar %dn", nResID);
  518. return NULL;
  519. }
  520. pToolBar->LoadHiColor(MAKEINTRESOURCE(BitmapID));
  522. pToolBar->EnableDocking(CBRS_ALIGN_ANY);
  523. // Dock the toolbar
  524. DockControlBarRightOf(pToolBar,leftOf);
  525. // Ok
  526. pToolBar->SetWindowText(t_caption);
  528. /*{
  529. #define BTN_WDTH  16
  530. {
  531. CImageList cImageList;
  532. CBitmap cBitmap;
  533. BITMAP bmBitmap;
  534. CSize cSize;
  535. int nNbBtn;
  537. if (!cBitmap.Attach(LoadImage(AfxGetResourceHandle(),
  538. MAKEINTRESOURCE(BitmapID),
  539. IMAGE_BITMAP, 0, 0,
  540. LR_DEFAULTSIZE|LR_CREATEDIBSECTION)) ||
  541. !cBitmap.GetBitmap(&bmBitmap))
  542. {
  543. ASSERT(0);
  544. return NULL;
  545. }
  546. cSize  = CSize(bmBitmap.bmWidth, bmBitmap.bmHeight); 
  547. nNbBtn = cSize.cx/BTN_WDTH;
  548. RGBTRIPLE* rgb = (RGBTRIPLE*)(bmBitmap.bmBits);
  549. COLORREF   rgbMask = RGB(0,0,0);
  551. if (!cImageList.Create(BTN_WDTH, cSize.cy,
  552. ILC_COLOR24|ILC_MASK,
  553. nNbBtn, 0))
  554. {
  555. ASSERT(0);
  556. return NULL;
  557. }
  559. if (cImageList.Add(&cBitmap, rgbMask) == -1)
  560. {
  561. ASSERT(0);
  562. return NULL;
  563. }
  565. pToolBar->SendMessage(TB_SETIMAGELIST, 0, (LPARAM)cImageList.m_hImageList);
  566. cImageList.Detach(); 
  567. cBitmap.Detach();
  569. }
  570. }*/
  572. TOOLBAR_CONTAINER_ELEMENT  tcEl;
  573. tcEl.toolbar = pToolBar;
  574. tcEl.menuID = framesToolbarsCurID++;
  575. tcEl.visible = TRUE;
  576. tcEl.geometry = geometry;
  577. m_geometry_toolbars_container.push_back(tcEl);
  579. return pToolBar;
  580. }
  582. void CMainFrame::CreateSystemToolbar()
  583. {
  584. if (!m_system_toolbar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_BOTTOM
  585. | CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC) ||
  586. !m_system_toolbar.LoadToolBar(IDR_SYSTEM_TOOLBAR))
  587. {
  588. TRACE0("Failed to create system toolbarn");
  589. ASSERT(0);
  590. return;   
  591. }
  593. m_system_toolbar.LoadHiColor(MAKEINTRESOURCE(IDB_SYSTEM_TC));
  595. m_system_toolbar.LoadControls();
  597. m_system_toolbar.EnableDocking(CBRS_ALIGN_TOP|CBRS_ALIGN_BOTTOM);
  598. // Dock the toolbar
  599. DockControlBar(&m_system_toolbar);
  600. // Ok
  601. CString  tmpLab;
  602. tmpLab.LoadString(IDS_SYSTEM_TLB_CAPT);
  604. m_system_toolbar.SetWindowText(tmpLab);
  606. TOOLBAR_CONTAINER_ELEMENT  tcEl;
  607. tcEl.toolbar = &m_system_toolbar;
  608. tcEl.menuID = 0;
  609. tcEl.visible = TRUE;
  610. tcEl.geometry = true;
  611. m_geometry_toolbars_container.push_back(tcEl);
  612. }
  614. void CMainFrame::OnSystemPanel()
  615. {
  616. ShowControlBar(&m_system_toolbar, !m_system_toolbar.IsWindowVisible(), FALSE);
  617. }
  620. void CMainFrame::OnUpdateSystemPanel(CCmdUI *pCmdUI)
  621. {
  622. pCmdUI->SetCheck(m_system_toolbar.IsWindowVisible());
  623. }
  625. void CMainFrame::OnScenePanel()
  626. {
  627. m_scene_tree_panel.ToggleVisible();
  628. }
  630. void CMainFrame::OnUpdateScenePanel(CCmdUI *pCmdUI)
  631. {
  632. pCmdUI->SetCheck(!m_scene_tree_panel.IsHidden());
  633. }
  635. void CMainFrame::OnCommandPanel()
  636. {
  637. m_commander_docking.ToggleVisible();
  638. }
  640. void CMainFrame::OnUpdateCommandPanel(CCmdUI *pCmdUI)
  641. {
  642. pCmdUI->SetCheck(!m_commander_docking.IsHidden());
  643. }
  645. void CMainFrame::OnScriptPanel()
  646. {
  647.  m_script_panel.ToggleVisible();
  648. }
  650. void CMainFrame::OnUpdateScriptPanel(CCmdUI *pCmdUI)
  651. {
  652. pCmdUI->SetCheck(!m_script_panel.IsHidden());
  653. }
  655. void CMainFrame::OnSetups()
  656. {
  657. CSetupsDlg dlg;
  658. dlg.DoModal();
  659. }
  662. void CMainFrame::AddToolbarPlugin(CToolbarPlugin* pT)
  663. {
  664. static bool firsttlb = true;
  666. pT->LoadToolbar(this);
  667. pT->m_toolbar.SetWindowText(pT->m_info.menu_string);
  669. size_t sz = m_geometry_toolbars_container.size();
  670. if (sz>0)
  671. {
  672. if (firsttlb)
  673. {
  674. DockControlBarRightOf(&pT->m_toolbar,NULL);
  675. firsttlb = false;
  676. }
  677. else
  678. DockControlBarRightOf(&pT->m_toolbar,m_geometry_toolbars_container[sz-1].toolbar);
  679. }
  681. TOOLBAR_CONTAINER_ELEMENT  tcEl;
  682. tcEl.toolbar = &pT->m_toolbar;
  683. tcEl.menuID = 0;
  684. tcEl.visible = TRUE;
  685. tcEl.geometry = true;
  686. m_geometry_toolbars_container.push_back(tcEl);
  687. }
  690. BOOL CMainFrame::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo)
  691. {
  692. if (pHandlerInfo == NULL)
  693. {
  694. if ((nID>=START_ID_FOR_FRAMES_TOOLBARS)&&(nID<START_ID_FOR_COMMANDER_CONTEXT_MENU))
  695. {
  696. size_t sz = m_geometry_toolbars_container.size();
  697. for (size_t i = 0; i < sz; i++)
  698. {
  699. if (nID == m_geometry_toolbars_container[i].menuID)
  700. {
  701. if (nCode == CN_COMMAND)
  702. {
  703. ShowControlBar(m_geometry_toolbars_container[i].toolbar, 
  704. !m_geometry_toolbars_container[i].toolbar->IsWindowVisible(), FALSE);
  705. SetFocus();
  706. }
  707. else if (nCode == CN_UPDATE_COMMAND_UI)
  708. {
  709. ((CCmdUI *) pExtra)->Enable(TRUE);
  710. ((CCmdUI*)pExtra)->SetCheck(m_geometry_toolbars_container[i].toolbar->IsWindowVisible());
  711. }
  712. return TRUE;
  713. }
  714. }
  715. }
  716. if ((nID>=START_ID_FOR_PLUGINS_MENU)&&(nID<START_ID_FOR_PLUGINS_TOOLBARS))
  717. {
  718. if (theApp.m_main_pluginer)
  719. {
  720. size_t sz = theApp.m_main_pluginer->m_toolbar_plugins.size();
  721. for (size_t i = 0; i < sz; i++)
  722. {
  723. if (nID == theApp.m_main_pluginer->m_toolbar_plugins[i]->m_nID_Menu)
  724. {
  725. if (nCode == CN_COMMAND)
  726. {
  727. if(theApp.m_main_pluginer->m_toolbar_plugins[i]->m_was_load)
  728. {
  729. ShowControlBar(&theApp.m_main_pluginer->m_toolbar_plugins[i]->m_toolbar, 
  730. !theApp.m_main_pluginer->m_toolbar_plugins[i]->m_toolbar.IsWindowVisible(), FALSE);
  731. SetFocus();
  732. }
  733. }
  734. else if (nCode == CN_UPDATE_COMMAND_UI)
  735. {
  736. if(theApp.m_main_pluginer->m_toolbar_plugins[i]->m_was_load) 
  737. {
  738. ((CCmdUI *) pExtra)->Enable(TRUE);
  739. ((CCmdUI*)pExtra)->SetCheck(theApp.m_main_pluginer->m_toolbar_plugins[i]->m_toolbar.IsWindowVisible());
  740. }
  741. else
  742. {
  743. ((CCmdUI *) pExtra)->Enable(FALSE);
  744. ((CCmdUI*)pExtra)->SetCheck(FALSE);
  745. }
  746. }
  747. return TRUE;
  748. }
  749. }
  750. }
  751. }
  752. }
  754. return CEGMDIFrameWnd::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);
  755. }
  758. void CMainFrame::OnIdleUpdateCmdUI()
  759. {
  760. int i, sz = m_geometry_toolbars_container.size();
  762. CMDIChildWnd* pChild = MDIGetActive();
  764. bool updateTabs = false;
  765. if (pChild->GetRuntimeClass()!=m_last_active_Child)
  766. {
  767. m_last_active_Child = pChild->GetRuntimeClass();
  768. updateTabs = true;
  769. }
  771. if (!updateTabs)
  772. {
  773. CEGMDIFrameWnd::OnIdleUpdateCmdUI();
  774. return;
  775. }
  777. if (pChild==NULL)
  778. {
  779. ASSERT(0);
  780. CEGMDIFrameWnd::OnIdleUpdateCmdUI();
  781. return;
  782. }
  784. if (pChild->GetRuntimeClass()==RUNTIME_CLASS(CChildFrame))
  785. {
  786. AddPluginMenu();
  787. InsertToolbarsStringsInMenu();
  789. if (updateTabs)
  790. {
  791. POSITION posit = theApp.m_pDocManager->GetFirstDocTemplatePosition();
  792. CDocTemplate* pTemplate = theApp.m_pDocManager->GetNextDocTemplate(posit);
  793. m_wndAppTabManager.ActivateTab(pTemplate);
  794. }
  796.     if (!m_exist_child)
  797. {
  798. for(i=0;i<sz;i++)
  799. {
  800. if (m_geometry_toolbars_container[i].geometry)
  801. ShowControlBar(m_geometry_toolbars_container[i].toolbar, 
  802. m_geometry_toolbars_container[i].visible, FALSE);
  803. else
  804. ShowControlBar(m_geometry_toolbars_container[i].toolbar, 
  805. FALSE, FALSE);
  806. }
  807.     if (m_scene_tree_panel.m_isVisible && m_scene_tree_panel.IsHidden())
  808. m_scene_tree_panel.ToggleVisible();
  809. if (m_commander_docking && m_commander_docking.IsHidden())
  810. m_commander_docking.ToggleVisible();
  811. if (m_script_panel.m_isVisible && m_script_panel.IsHidden())
  812. m_script_panel.ToggleVisible();
  814. m_exist_child = true;
  815. }
  816. else
  817. CEGMDIFrameWnd::OnIdleUpdateCmdUI();
  818. m_first_raz = false;
  819. }
  820. else
  821. {
  822. if (updateTabs)
  823. {
  825. POSITION posit = theApp.m_pDocManager->GetFirstDocTemplatePosition();
  826. CDocTemplate* pTemplate = theApp.m_pDocManager->GetNextDocTemplate(posit);
  827. pTemplate = theApp.m_pDocManager->GetNextDocTemplate(posit);
  828. m_wndAppTabManager.ActivateTab(pTemplate);
  829. }
  831. if (m_exist_child || m_first_raz)
  832. {
  833. for(i=0;i<sz;i++)
  834. {
  835. if (m_geometry_toolbars_container[i].geometry)
  836. {
  837. m_geometry_toolbars_container[i].visible = (m_first_raz)?TRUE:m_geometry_toolbars_container[i].toolbar->IsWindowVisible();
  838. ShowControlBar(m_geometry_toolbars_container[i].toolbar, FALSE, FALSE);
  839. }
  840. else
  841. ShowControlBar(m_geometry_toolbars_container[i].toolbar, 
  842. TRUE, FALSE);
  843. }
  844. if (m_scene_tree_panel.m_isVisible && !m_scene_tree_panel.IsHidden())
  845. m_scene_tree_panel.ToggleVisible();
  846. if (m_commander_docking.m_isVisible && !m_commander_docking.IsHidden())
  847. m_commander_docking.ToggleVisible();
  848. if (m_script_panel.m_isVisible && !m_script_panel.IsHidden())
  849. m_script_panel.ToggleVisible();
  851. if (!m_first_raz)
  852. m_exist_child=false;
  853. }
  854. else
  855. CEGMDIFrameWnd::OnIdleUpdateCmdUI();
  856. }
  857. }
  866. void CMainFrame::GetMessageString(UINT nID, CString& rMessage) const
  867. {
  868. // load appropriate string
  869. if (theApp.m_main_pluginer)
  870. {
  871. size_t sz = theApp.m_main_pluginer->m_toolbar_plugins.size();
  872. for (size_t i = 0; i < sz; i++)
  873. {
  874. if ((nID>=theApp.m_main_pluginer->m_toolbar_plugins[i]->m_start_ID)&&
  875. (nID<=theApp.m_main_pluginer->m_toolbar_plugins[i]->m_end_ID))
  876. {
  877. rMessage = theApp.m_main_pluginer->m_toolbar_plugins[i]->GetStatusBarMessage(nID);
  878. return;
  879. }
  880. }
  881. }
  882. CEGMDIFrameWnd::GetMessageString(nID, rMessage);
  883. }
  886. BOOL CMainFrame::GetToolText( UINT nID, CString& strTipText )
  887. {
  888. if (theApp.m_main_pluginer)
  889. {
  890. size_t sz = theApp.m_main_pluginer->m_toolbar_plugins.size();
  891. for (size_t i = 0; i < sz; i++)
  892. {
  893. if ((nID>=theApp.m_main_pluginer->m_toolbar_plugins[i]->m_start_ID)&&
  894. (nID<=theApp.m_main_pluginer->m_toolbar_plugins[i]->m_end_ID))
  895. {
  896. strTipText = theApp.m_main_pluginer->m_toolbar_plugins[i]->GetTooltipMessage(nID);
  897. return TRUE;
  898. }
  899. }
  900. }
  901. return FALSE;
  902. }
  904. #define _countof(array) (sizeof(array)/sizeof(array[0]))
  906. BOOL CMainFrame::OnToolTipText(UINT nID, NMHDR* pNMHDR, LRESULT*pResult)
  907. {
  908. ASSERT(pNMHDR->code == TTN_NEEDTEXTA || pNMHDR->code == TTN_NEEDTEXTW);
  910. TOOLTIPTEXTA* pTTTA = (TOOLTIPTEXTA*)pNMHDR;
  911. TOOLTIPTEXTW* pTTTW = (TOOLTIPTEXTW*)pNMHDR;
  913. CString strTipText;
  914. if ( GetToolText( pNMHDR->idFrom, strTipText ) )
  915. {
  916. #ifndef _UNICODE
  917. if (pNMHDR->code == TTN_NEEDTEXTA)
  918. lstrcpyn(pTTTA->szText, strTipText, _countof(pTTTA->szText));
  919. else
  920. _mbstowcsz(pTTTW->szText, strTipText, _countof(pTTTW->szText));
  921. #else
  922. if (pNMHDR->code == TTN_NEEDTEXTA)
  923. _wcstombsz(pTTTA->szText, strTipText, _countof(pTTTA->szText));
  924. else
  925. lstrcpyn(pTTTW->szText, strTipText, _countof(pTTTW->szText));
  926. #endif
  927. return TRUE;
  928. }
  930. return CEGMDIFrameWnd::OnToolTipText( nID, pNMHDR, pResult );
  931. }
  934. BOOL CMainFrame::PreTranslateMessage(MSG* pMsg)
  935. {
  936. if (m_wndMenuBar.TranslateFrameMessage(pMsg))
  937. return TRUE;
  939. return CEGMDIFrameWnd::PreTranslateMessage(pMsg);
  940. }