Source/Core/DolphinWX/Src/FrameAui.cpp

   1 // Copyright (C) 2003 Dolphin Project.
   2
   3 // This program is free software: you can redistribute it and/or modify
   4 // it under the terms of the GNU General Public License as published by
   5 // the Free Software Foundation, version 2.0.
   6
   7 // This program is distributed in the hope that it will be useful,
   8 // but WITHOUT ANY WARRANTY; without even the implied warranty of
   9 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10 // GNU General Public License 2.0 for more details.
  11
  12 // A copy of the GPL 2.0 should have been included with the program.
  13 // If not, see http://www.gnu.org/licenses/
  14
  15 // Official SVN repository and contact information can be found at
  16 // http://code.google.com/p/dolphin-emu/
  17
  18 #include "Setup.h" // Common
  19
  20 #include "NetWindow.h"
  21
  22 #include "Common.h" // Common
  23 #include "FileUtil.h"
  24 #include "FileSearch.h"
  25 #include "Timer.h"
  26
  27 #include "Globals.h" // Local
  28 #include "Frame.h"
  29 #include "ConfigMain.h"
  30 #include "PluginManager.h"
  31 #include "MemcardManager.h"
  32 #include "CheatsWindow.h"
  33 #include "AboutDolphin.h"
  34 #include "GameListCtrl.h"
  35 #include "BootManager.h"
  36 #include "LogWindow.h"
  37 #include "WxUtils.h"
  38
  39 #include "ConfigManager.h" // Core
  40 #include "ConsoleListener.h"
  41 #include "Core.h"
  42 #include "OnFrame.h"
  43 #include "HW/DVDInterface.h"
  44 #include "State.h"
  45 #include "VolumeHandler.h"
  46 #include "NANDContentLoader.h"
  47
  48 #include <wx/datetime.h> // wxWidgets
  49
  50 // ------------
  51 // Aui events
  52
  53 void CFrame::OnManagerResize(wxAuiManagerEvent& event)
  54 {
  55         event.Skip();
  56         ResizeConsole();
  57 }
  58
  59 void CFrame::OnPaneClose(wxAuiManagerEvent& event)
  60 {
  61         event.Veto();
  62
  63         wxAuiNotebook * nb = (wxAuiNotebook*)event.pane->window;
  64         if (!nb) return;
  65
  66         if (!g_pCodeWindow)
  67         {
  68                 if ((nb->GetPage(0)->GetId() == IDM_LOGWINDOW ||
  69                                         nb->GetPage(0)->GetId() == IDM_CONSOLEWINDOW))
  70                 {
  71                         // Closing a pane containing the logwindow or a console closes both
  72                         SConfig::GetInstance().m_InterfaceConsole = false;
  73                         SConfig::GetInstance().m_InterfaceLogWindow = false;
  74                         ToggleConsole(false);
  75                         ToggleLogWindow(false);
  76                 }
  77         }
  78         else
  79         {
  80                 if (GetNotebookCount() == 1)
  81                         wxMessageBox(wxT("At least one pane must remain open."),
  82                                         wxT("Notice"), wxOK, this);
  83                 else if (nb->GetPageCount() != 0 && !nb->GetPageText(0).IsSameAs(wxT("<>")))
  84                         wxMessageBox(wxT("You can't close panes that have pages in them."),
  85                                         wxT("Notice"), wxOK, this);
  86                 else
  87                 {
  88                         // Detach and delete the empty notebook
  89                         event.pane->DestroyOnClose(true);
  90                         m_Mgr->ClosePane(*event.pane);
  91                 }
  92         }
  93
  94         m_Mgr->Update();
  95 }
  96
  97 void CFrame::ToggleLogWindow(bool bShow)
  98 {
  99         GetMenuBar()->FindItem(IDM_LOGWINDOW)->Check(bShow);
 100
 101         if (bShow)
 102         {
 103                 if (!m_LogWindow) m_LogWindow = new CLogWindow(this, IDM_LOGWINDOW);
 104                 m_LogWindow->Enable();
 105                 DoAddPage(m_LogWindow,
 106                                 g_pCodeWindow ? g_pCodeWindow->iNbAffiliation[0] : 0,
 107                                 g_pCodeWindow ? bFloatWindow[0] : false);
 108         }
 109         else
 110         {
 111                 m_LogWindow->Disable();
 112                 DoRemovePage(m_LogWindow, true);
 113         }
 114
 115         // Hide or Show the pane
 116         if (!g_pCodeWindow)
 117                 TogglePane();
 118 }
 119
 120 void CFrame::ToggleConsole(bool bShow)
 121 {
 122 #ifdef _WIN32
 123         GetMenuBar()->FindItem(IDM_CONSOLEWINDOW)->Check(bShow);
 124
 125         if (bShow)
 126         {
 127                 // If the console doesn't exist, we create it
 128                 if (!GetConsoleWindow())
 129                 {
 130                         ConsoleListener *Console = LogManager::GetInstance()->getConsoleListener();
 131                         Console->Open();
 132                 }
 133                 else
 134                         ShowWindow(GetConsoleWindow(), SW_SHOW);
 135
 136                 // Create the parent window if it doesn't exist
 137                 wxPanel *ConsoleParent = (wxPanel*)FindWindowById(IDM_CONSOLEWINDOW);
 138                 if (!ConsoleParent) ConsoleParent = new wxPanel(this, IDM_CONSOLEWINDOW,
 139                                 wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL, _("Console"));
 140
 141                 wxWindow *ConsoleWin = new wxWindow();
 142                 ConsoleWin->SetHWND((WXHWND)GetConsoleWindow());
 143                 ConsoleWin->AdoptAttributesFromHWND();
 144                 ConsoleWin->Reparent(ConsoleParent);
 145
 146                 ConsoleParent->Enable();
 147                 DoAddPage(ConsoleParent,
 148                                 g_pCodeWindow ? g_pCodeWindow->iNbAffiliation[1] : 0,
 149                                 g_pCodeWindow ? bFloatWindow[1] : false);
 150         }
 151         else // Hide
 152         {
 153                 if(GetConsoleWindow())
 154                         ShowWindow(GetConsoleWindow(), SW_HIDE); // WIN32
 155
 156                 wxPanel *ConsoleParent = (wxPanel*)FindWindowById(IDM_CONSOLEWINDOW);
 157                 if (ConsoleParent)
 158                         ConsoleParent->Disable();
 159
 160                 // Then close the page
 161                 DoRemovePage(ConsoleParent, true);
 162         }
 163
 164         // Hide or Show the pane
 165         if (!g_pCodeWindow)
 166                 TogglePane();
 167 #endif
 168 }
 169
 170 void CFrame::OnToggleWindow(wxCommandEvent& event)
 171 {
 172         bool bShow = event.IsChecked();
 173
 174         switch(event.GetId())
 175         {
 176                 case IDM_LOGWINDOW:
 177                         if (!g_pCodeWindow)
 178                                 SConfig::GetInstance().m_InterfaceLogWindow = bShow;
 179                         ToggleLogWindow(bShow);
 180                         break;
 181                 case IDM_CONSOLEWINDOW:
 182                         if (!g_pCodeWindow)
 183                                 SConfig::GetInstance().m_InterfaceConsole = bShow;
 184                         ToggleConsole(bShow);
 185                         break;
 186                 case IDM_REGISTERWINDOW:
 187                         g_pCodeWindow->ToggleRegisterWindow(bShow);
 188                         break;
 189                 case IDM_BREAKPOINTWINDOW:
 190                         g_pCodeWindow->ToggleBreakPointWindow(bShow);
 191                         break;
 192                 case IDM_MEMORYWINDOW:
 193                         g_pCodeWindow->ToggleMemoryWindow(bShow);
 194                         break;
 195                 case IDM_JITWINDOW:
 196                         g_pCodeWindow->ToggleJitWindow(bShow);
 197                         break;
 198                 case IDM_SOUNDWINDOW:
 199                         g_pCodeWindow->ToggleDLLWindow(IDM_SOUNDWINDOW, bShow);
 200                         break;
 201                 case IDM_VIDEOWINDOW:
 202                         g_pCodeWindow->ToggleDLLWindow(IDM_VIDEOWINDOW, bShow);
 203                         break;
 204         }
 205 }
 206
 207 // Notebooks
 208 // ---------------------
 209 void CFrame::ClosePages()
 210 {
 211         ToggleLogWindow(false);
 212         ToggleConsole(false);
 213         if (g_pCodeWindow)
 214         {
 215                 g_pCodeWindow->ToggleCodeWindow(false);
 216                 g_pCodeWindow->ToggleRegisterWindow(false);
 217                 g_pCodeWindow->ToggleBreakPointWindow(false);
 218                 g_pCodeWindow->ToggleMemoryWindow(false);
 219                 g_pCodeWindow->ToggleJitWindow(false);
 220                 g_pCodeWindow->ToggleDLLWindow(IDM_SOUNDWINDOW, false);
 221                 g_pCodeWindow->ToggleDLLWindow(IDM_VIDEOWINDOW, false);
 222         }
 223 }
 224
 225 void CFrame::OnNotebookPageChanged(wxAuiNotebookEvent& event)
 226 {
 227         event.Skip();
 228         if (!g_pCodeWindow) return;
 229
 230         // Remove the blank page if any
 231         AddRemoveBlankPage();
 232
 233         // Update the notebook affiliation
 234         for (int i = IDM_LOGWINDOW; i <= IDM_CODEWINDOW; i++)
 235         {
 236                 if(GetNotebookAffiliation(i) >= 0)
 237                         g_pCodeWindow->iNbAffiliation[i - IDM_LOGWINDOW] = GetNotebookAffiliation(i);
 238         }
 239 }
 240
 241 void CFrame::OnNotebookPageClose(wxAuiNotebookEvent& event)
 242 {
 243         // Override event
 244         event.Veto();
 245
 246         wxAuiNotebook* Ctrl = (wxAuiNotebook*)event.GetEventObject();
 247
 248         if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_LOGWINDOW)
 249                 ToggleLogWindow(false);
 250         if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_CONSOLEWINDOW)
 251                 ToggleConsole(false);
 252         if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_REGISTERWINDOW)
 253                 g_pCodeWindow->ToggleRegisterWindow(false);
 254         if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_BREAKPOINTWINDOW)
 255                 g_pCodeWindow->ToggleBreakPointWindow(false);
 256         if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_JITWINDOW)
 257                 g_pCodeWindow->ToggleJitWindow(false);
 258         if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_MEMORYWINDOW)
 259                 g_pCodeWindow->ToggleMemoryWindow(false);
 260         if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_SOUNDWINDOW)
 261                 g_pCodeWindow->ToggleDLLWindow(IDM_SOUNDWINDOW, false);
 262         if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_VIDEOWINDOW)
 263                 g_pCodeWindow->ToggleDLLWindow(IDM_VIDEOWINDOW, false);
 264 }
 265
 266 void CFrame::OnFloatingPageClosed(wxCloseEvent& event)
 267 {
 268         ToggleFloatWindow(event.GetId() - IDM_LOGWINDOW_PARENT + IDM_FLOAT_LOGWINDOW);
 269 }
 270
 271 void CFrame::OnFloatingPageSize(wxSizeEvent& event)
 272 {
 273         event.Skip();
 274         ResizeConsole();
 275 }
 276
 277 void CFrame::OnFloatWindow(wxCommandEvent& event)
 278 {
 279         ToggleFloatWindow(event.GetId());
 280 }
 281
 282 void CFrame::ToggleFloatWindow(int Id)
 283 {
 284         wxWindowID WinId = Id - IDM_FLOAT_LOGWINDOW + IDM_LOGWINDOW;
 285         if (GetNotebookPageFromId(WinId))
 286         {
 287                 DoFloatNotebookPage(WinId);
 288                 bFloatWindow[WinId - IDM_LOGWINDOW] = true;
 289         }
 290         else
 291         {
 292                 if (FindWindowById(WinId))
 293                         DoUnfloatPage(WinId - IDM_LOGWINDOW + IDM_LOGWINDOW_PARENT);
 294                 bFloatWindow[WinId - IDM_LOGWINDOW] = false;
 295         }
 296 }
 297
 298 void CFrame::DoFloatNotebookPage(wxWindowID Id)
 299 {
 300         wxPanel *Win = (wxPanel*)FindWindowById(Id);
 301         if (!Win) return;
 302
 303         for (int i = 0; i < GetNotebookCount(); i++)
 304         {
 305                 wxAuiNotebook *nb = GetNotebookFromId(i);
 306                 if (nb->GetPageIndex(Win) != wxNOT_FOUND)
 307                 {
 308                         nb->RemovePage(nb->GetPageIndex(Win));
 309                         // Create the parent frame and reparent the window
 310                         CreateParentFrame(Win->GetId() + IDM_LOGWINDOW_PARENT - IDM_LOGWINDOW,
 311                                         Win->GetName(), Win);
 312                         if (nb->GetPageCount() == 0)
 313                                 AddRemoveBlankPage();
 314                 }
 315         }
 316 }
 317
 318 void CFrame::DoUnfloatPage(int Id)
 319 {
 320         wxFrame * Win = (wxFrame*)FindWindowById(Id);
 321         if (!Win) return;
 322
 323         wxWindow * Child = Win->GetChildren().Item(0)->GetData();
 324         Child->Reparent(this);
 325         DoAddPage(Child, g_pCodeWindow->iNbAffiliation[Child->GetId() - IDM_LOGWINDOW], false);
 326         Win->Destroy();
 327 }
 328
 329 void CFrame::OnTab(wxAuiNotebookEvent& event)
 330 {
 331         event.Skip();
 332         if (!g_pCodeWindow) return;
 333
 334         // Create the popup menu
 335         wxMenu* MenuPopup = new wxMenu;
 336
 337         wxMenuItem* Item =  new wxMenuItem(MenuPopup, wxID_ANY,
 338                         wxT("Select floating windows"));
 339         MenuPopup->Append(Item);
 340         Item->Enable(false);
 341         MenuPopup->Append(new wxMenuItem(MenuPopup));
 342         for (int i = IDM_LOGWINDOW; i <= IDM_CODEWINDOW; i++)
 343         {
 344                 wxWindow *Win = FindWindowById(i);
 345                 if (Win && Win->IsEnabled())
 346                 {
 347                         Item = new wxMenuItem(MenuPopup, i + IDM_FLOAT_LOGWINDOW - IDM_LOGWINDOW,
 348                                         Win->GetName(), wxT(""), wxITEM_CHECK);
 349                         MenuPopup->Append(Item);
 350                         Item->Check(!!FindWindowById(i + IDM_LOGWINDOW_PARENT - IDM_LOGWINDOW));
 351                 }
 352         }
 353
 354         // Line up our menu with the cursor
 355         wxPoint Pt = ::wxGetMousePosition();
 356         Pt = ScreenToClient(Pt);
 357         // Show
 358         PopupMenu(MenuPopup, Pt);
 359 }
 360
 361 void CFrame::OnAllowNotebookDnD(wxAuiNotebookEvent& event)
 362 {
 363         event.Skip();
 364         event.Allow();
 365         ResizeConsole();
 366 }
 367
 368 void CFrame::TogglePane()
 369 {
 370         // Get the first notebook
 371         wxAuiNotebook * NB = NULL;
 372         for (size_t i = 0; i < m_Mgr->GetAllPanes().GetCount(); i++)
 373         {
 374                 if (m_Mgr->GetAllPanes()[i].window->IsKindOf(CLASSINFO(wxAuiNotebook)))
 375                         NB = (wxAuiNotebook*)m_Mgr->GetAllPanes()[i].window;
 376         }
 377         if (NB)
 378         {
 379                 if (NB->GetPageCount() == 0)
 380                 {
 381                         m_LogWindow->x = m_Mgr->GetPane(wxT("Pane 1")).rect.GetWidth();
 382                         m_LogWindow->y = m_Mgr->GetPane(wxT("Pane 1")).rect.GetHeight();
 383                         m_LogWindow->winpos = m_Mgr->GetPane(wxT("Pane 1")).dock_direction;
 384                         m_Mgr->GetPane(wxT("Pane 1")).Hide();
 385                 }
 386                 else
 387                 {
 388                         m_Mgr->GetPane(wxT("Pane 1")).BestSize(m_LogWindow->x, m_LogWindow->y)
 389                                 .MinSize(m_LogWindow->x, m_LogWindow->y)
 390                                 .Direction(m_LogWindow->winpos).Show();
 391                         m_Mgr->Update();
 392
 393                         // Reset the minimum size of the pane
 394                         m_Mgr->GetPane(wxT("Pane 1")).MinSize(-1, -1);
 395                 }
 396                 m_Mgr->Update();
 397         }
 398 }
 399
 400 void CFrame::DoRemovePage(wxWindow *Win, bool bHide)
 401 {
 402         if (!Win) return;
 403
 404         wxWindow *Parent = FindWindowById(Win->GetId() +
 405                         IDM_LOGWINDOW_PARENT - IDM_LOGWINDOW);
 406
 407         if (Parent)
 408         {
 409                 if (bHide)
 410                 {
 411                         Win->Hide();
 412                         Win->Reparent(this);
 413                 }
 414                 else
 415                         Win->Close();
 416                 Parent->Destroy();
 417         }
 418         else
 419         {
 420                 for (int i = 0; i < GetNotebookCount(); i++)
 421                 {
 422                         int PageIndex = GetNotebookFromId(i)->GetPageIndex(Win);
 423                         if (PageIndex != wxNOT_FOUND)
 424                         {
 425                                 GetNotebookFromId(i)->RemovePage(PageIndex);
 426                                 if (bHide)
 427                                 {
 428                                         Win->Hide();
 429                                         Win->Reparent(this);
 430                                 }
 431                                 else
 432                                         Win->Close();
 433                         }
 434                 }
 435         }
 436         if (g_pCodeWindow)
 437                 AddRemoveBlankPage();
 438 }
 439
 440 void CFrame::DoAddPage(wxWindow *Win, int i, bool Float)
 441 {
 442         if (!Win) return;
 443         if (i < 0 || i > GetNotebookCount()-1) i = 0;
 444         if (Win && GetNotebookFromId(i)->GetPageIndex(Win) != wxNOT_FOUND) return;
 445         if (!Float)
 446                 GetNotebookFromId(i)->AddPage(Win, Win->GetName(), true);
 447         else
 448                 CreateParentFrame(Win->GetId() + IDM_LOGWINDOW_PARENT - IDM_LOGWINDOW,
 449                                 Win->GetName(), Win);
 450 }
 451
 452 // Toolbar
 453 void CFrame::OnDropDownSettingsToolbar(wxAuiToolBarEvent& event)
 454 {
 455         event.Skip();
 456         ClearStatusBar();
 457
 458         if (event.IsDropDownClicked())
 459         {
 460                 wxAuiToolBar* Tb = static_cast<wxAuiToolBar*>(event.GetEventObject());
 461                 Tb->SetToolSticky(event.GetId(), true);
 462
 463                 // Create the popup menu
 464                 wxMenu* menuPopup = new wxMenu;
 465
 466                 wxMenuItem* Item =  new wxMenuItem(menuPopup, IDM_PERSPECTIVES_ADD_PANE,
 467                                 wxT("Add new pane"));
 468                 menuPopup->Append(Item);
 469                 menuPopup->Append(new wxMenuItem(menuPopup));
 470                 Item = new wxMenuItem(menuPopup, IDM_TAB_SPLIT, wxT("Tab split"),
 471                                 wxT(""), wxITEM_CHECK);
 472                 menuPopup->Append(Item);
 473                 Item->Check(m_bTabSplit);
 474                 Item = new wxMenuItem(menuPopup, IDM_NO_DOCKING, wxT("No docking"),
 475                                 wxT(""), wxITEM_CHECK);
 476                 menuPopup->Append(Item);
 477                 Item->Check(m_bNoDocking);
 478
 479                 // Line up our menu with the button
 480                 wxRect rect = Tb->GetToolRect(event.GetId());
 481                 wxPoint Pt = Tb->ClientToScreen(rect.GetBottomLeft());
 482                 Pt = ScreenToClient(Pt);
 483                 // Show
 484                 PopupMenu(menuPopup, Pt);
 485                 // Make the button un-stuck again
 486                 if (!m_bEdit) Tb->SetToolSticky(event.GetId(), false);
 487         }
 488 }
 489
 490 void CFrame::OnDropDownToolbarItem(wxAuiToolBarEvent& event)
 491 {
 492         event.Skip();
 493         ClearStatusBar();
 494
 495         if (event.IsDropDownClicked())
 496         {
 497                 wxAuiToolBar* tb = static_cast<wxAuiToolBar*>(event.GetEventObject());
 498                 tb->SetToolSticky(event.GetId(), true);
 499
 500                 // create the popup menu
 501                 wxMenu* menuPopup = new wxMenu;
 502                 wxMenuItem* Item = new wxMenuItem(menuPopup, IDM_ADD_PERSPECTIVE,
 503                                 wxT("Create new perspective"));
 504                 menuPopup->Append(Item);
 505
 506                 if (Perspectives.size() > 0)
 507                 {
 508                         menuPopup->Append(new wxMenuItem(menuPopup));
 509                         for (size_t i = 0; i < Perspectives.size(); i++)
 510                         {
 511                                 wxMenuItem* mItem = new wxMenuItem(menuPopup, IDM_PERSPECTIVES_0 + i,
 512                                                 wxString::FromAscii(Perspectives[i].Name.c_str()),
 513                                                 wxT(""), wxITEM_CHECK);
 514                                 menuPopup->Append(mItem);
 515                                 if (i == ActivePerspective) mItem->Check(true);
 516                         }
 517                 }
 518
 519                 // line up our menu with the button
 520                 wxRect rect = tb->GetToolRect(event.GetId());
 521                 wxPoint pt = tb->ClientToScreen(rect.GetBottomLeft());
 522                 pt = ScreenToClient(pt);
 523                 // show
 524                 PopupMenu(menuPopup, pt);
 525                 // make sure the button is "un-stuck"
 526                 tb->SetToolSticky(event.GetId(), false);
 527         }
 528 }
 529
 530 void CFrame::OnToolBar(wxCommandEvent& event)
 531 {
 532         ClearStatusBar();
 533
 534         switch (event.GetId())
 535         {
 536                 case IDM_SAVE_PERSPECTIVE:
 537                         if (Perspectives.size() == 0)
 538                         {
 539                                 wxMessageBox(wxT("Please create a perspective before saving"),
 540                                                 wxT("Notice"), wxOK, this);
 541                                 return;
 542                         }
 543                         SaveIniPerspectives();
 544                         GetStatusBar()->SetStatusText(wxString::FromAscii(std::string
 545                                                 ("Saved " + Perspectives[ActivePerspective].Name).c_str()), 0);
 546                         break;
 547                 case IDM_PERSPECTIVES_ADD_PANE:
 548                         AddPane();
 549                         break;
 550                 case IDM_EDIT_PERSPECTIVES:
 551                         m_bEdit = !m_bEdit;
 552                         m_ToolBarAui->SetToolSticky(IDM_EDIT_PERSPECTIVES, m_bEdit);
 553                         TogglePaneStyle(m_bEdit, IDM_EDIT_PERSPECTIVES);
 554                         break;
 555         }
 556 }
 557
 558 void CFrame::OnDropDownToolbarSelect(wxCommandEvent& event)
 559 {
 560         ClearStatusBar();
 561
 562         switch(event.GetId())
 563         {
 564                 case IDM_ADD_PERSPECTIVE:
 565                         {
 566                                 wxTextEntryDialog dlg(this,
 567                                                 wxT("Enter a name for the new perspective:"),
 568                                                 wxT("Create new perspective"));
 569                                 wxString DefaultValue = wxString::Format(wxT("Perspective %d"),
 570                                                 Perspectives.size() + 1);
 571                                 dlg.SetValue(DefaultValue);
 572                                 bool DlgOk = false; int Return = 0;
 573                                 while (!DlgOk)
 574                                 {
 575                                         Return = dlg.ShowModal();
 576                                         if (Return == wxID_CANCEL)
 577                                                 return;
 578                                         else if (dlg.GetValue().Find(wxT(",")) != -1)
 579                                         {
 580                                                 wxMessageBox(wxT("The name can not contain the character ','"),
 581                                                                 wxT("Notice"), wxOK, this);
 582                                                 wxString Str = dlg.GetValue();
 583                                                 Str.Replace(wxT(","), wxT(""), true);
 584                                                 dlg.SetValue(Str);
 585                                         }
 586                                         else if (dlg.GetValue().IsSameAs(wxT("")))
 587                                         {
 588                                                 wxMessageBox(wxT("The name can not be empty"),
 589                                                                 wxT("Notice"), wxOK, this);
 590                                                 dlg.SetValue(DefaultValue);
 591                                         }
 592                                         else
 593                                                 DlgOk = true;
 594                                 }
 595
 596                                 SPerspectives Tmp;
 597                                 Tmp.Name = dlg.GetValue().mb_str();
 598                                 Tmp.Perspective = m_Mgr->SavePerspective();
 599
 600                                 ActivePerspective = Perspectives.size();
 601                                 Perspectives.push_back(Tmp);
 602
 603                                 UpdateCurrentPerspective();
 604                         }
 605                         break;
 606                 case IDM_TAB_SPLIT:
 607                         m_bTabSplit = event.IsChecked();
 608                         ToggleNotebookStyle(m_bTabSplit, wxAUI_NB_TAB_SPLIT);
 609                         break;
 610                 case IDM_NO_DOCKING:
 611                         m_bNoDocking = event.IsChecked();
 612                         TogglePaneStyle(m_bNoDocking, IDM_NO_DOCKING);
 613                         break;
 614         }
 615 }
 616
 617 void CFrame::ResetToolbarStyle()
 618 {
 619         wxAuiPaneInfoArray& AllPanes = m_Mgr->GetAllPanes();
 620         for (int i = 0, Count = (int)AllPanes.GetCount(); i < Count; ++i)
 621         {
 622                 wxAuiPaneInfo& Pane = AllPanes[i];
 623                 if (Pane.window->IsKindOf(CLASSINFO(wxAuiToolBar)))
 624                 {
 625                         Pane.Show();
 626                         // Show all of it
 627                         if (Pane.rect.GetLeft() > GetClientSize().GetX() - 50)
 628                                 Pane.Position(GetClientSize().GetX() - Pane.window->GetClientSize().GetX());
 629                 }
 630         }
 631         m_Mgr->Update();
 632 }
 633
 634 void CFrame::TogglePaneStyle(bool On, int EventId)
 635 {
 636         wxAuiPaneInfoArray& AllPanes = m_Mgr->GetAllPanes();
 637         for (size_t i = 0; i < AllPanes.GetCount(); ++i)
 638         {
 639                 wxAuiPaneInfo& Pane = AllPanes[i];
 640                 if (Pane.window->IsKindOf(CLASSINFO(wxAuiNotebook)))
 641                 {
 642                         // Default
 643                         Pane.CloseButton(true);
 644                         Pane.MaximizeButton(true);
 645                         Pane.MinimizeButton(true);
 646                         Pane.PinButton(true);
 647                         Pane.Show();
 648
 649                         switch(EventId)
 650                         {
 651                                 case IDM_EDIT_PERSPECTIVES:
 652                                         Pane.CaptionVisible(On);
 653                                         Pane.Movable(On);
 654                                         Pane.Floatable(On);
 655                                         Pane.Dockable(On);
 656                                         break;
 657                         }
 658                         Pane.Dockable(!m_bNoDocking);
 659                 }
 660         }
 661         m_Mgr->Update();
 662 }
 663
 664 void CFrame::ToggleNotebookStyle(bool On, long Style)
 665 {
 666         wxAuiPaneInfoArray& AllPanes = m_Mgr->GetAllPanes();
 667         for (int i = 0, Count = (int)AllPanes.GetCount(); i < Count; ++i)
 668         {
 669                 wxAuiPaneInfo& Pane = AllPanes[i];
 670                 if (Pane.window->IsKindOf(CLASSINFO(wxAuiNotebook)))
 671                 {
 672                         wxAuiNotebook* NB = (wxAuiNotebook*)Pane.window;
 673
 674                         if (On)
 675                                 NB->SetWindowStyleFlag(NB->GetWindowStyleFlag() | Style);
 676                         else
 677                                 NB->SetWindowStyleFlag(NB->GetWindowStyleFlag() &~ Style);
 678
 679                         NB->Refresh();
 680                 }
 681         }
 682 }
 683
 684 void CFrame::OnSelectPerspective(wxCommandEvent& event)
 685 {
 686         size_t _Selection = event.GetId() - IDM_PERSPECTIVES_0;
 687         if (Perspectives.size() <= _Selection) _Selection = 0;
 688         ActivePerspective = _Selection;
 689         DoLoadPerspective();
 690 }
 691
 692 void CFrame::ResizeConsole()
 693 {
 694 #ifdef _WIN32
 695         // Get the console parent window
 696         wxWindow * Win = FindWindowById(IDM_CONSOLEWINDOW);
 697         if (!Win) return;
 698
 699         const int wxBorder = 2, Border = 4, LowerBorder = 6,
 700                 MenuBar = 30, ScrollBar = 19;
 701         const int WidthReduction = 30 - Border;
 702
 703         // Get the client size
 704         int X = Win->GetClientSize().GetX();
 705         int Y = Win->GetClientSize().GetY();
 706         int InternalWidth = X - wxBorder*2 - ScrollBar;
 707         int InternalHeight = Y - wxBorder*2;
 708         int WindowWidth = InternalWidth + Border*2 +
 709                 /*max out the width in the word wrap mode*/ 100;
 710         int WindowHeight = InternalHeight + MenuBar;
 711         // Resize buffer
 712         ConsoleListener* Console = LogManager::GetInstance()->getConsoleListener();
 713         Console->PixelSpace(0,0, InternalWidth,InternalHeight, false);
 714         // Move the window to hide the border
 715         MoveWindow(GetConsoleWindow(), -Border-wxBorder, -MenuBar-wxBorder,
 716                         WindowWidth + 100,WindowHeight, true);
 717 #endif
 718 }
 719
 720 static int Limit(int i, int Low, int High)
 721 {
 722         if (i < Low) return Low;
 723         if (i > High) return High;
 724         return i;
 725 }
 726
 727 void CFrame::SetPaneSize()
 728 {
 729         if (Perspectives.size() <= ActivePerspective) return;
 730         int iClientX = GetSize().GetX(), iClientY = GetSize().GetY();
 731
 732         for (size_t i = 0, j = 0; i < m_Mgr->GetAllPanes().GetCount(); i++)
 733         {
 734                 if (!m_Mgr->GetAllPanes()[i].window->IsKindOf(CLASSINFO(wxAuiToolBar)))
 735                 {
 736                         if (!m_Mgr->GetAllPanes()[i].IsOk()) return;
 737                         if (Perspectives[ActivePerspective].Width.size() <= j ||
 738                                         Perspectives[ActivePerspective].Height.size() <= j)
 739                                 continue;
 740                         size_t W = Perspectives[ActivePerspective].Width[j],
 741                                 H = Perspectives[ActivePerspective].Height[j];
 742                         // Check limits
 743                         W = Limit(W, 5, 95);
 744                         H = Limit(H, 5, 95);
 745                         // Convert percentages to pixel lengths
 746                         W = (W * iClientX) / 100;
 747                         H = (H * iClientY) / 100;
 748                         m_Mgr->GetAllPanes()[i].BestSize(W,H).MinSize(W,H);
 749
 750                         j++;
 751                 }
 752         }
 753         m_Mgr->Update();
 754
 755         for (size_t i = 0; i < m_Mgr->GetAllPanes().GetCount(); i++)
 756         {
 757                 if (!m_Mgr->GetAllPanes()[i].window->IsKindOf(CLASSINFO(wxAuiToolBar)))
 758                 {
 759                         m_Mgr->GetAllPanes()[i].MinSize(-1,-1);
 760                 }
 761         }
 762 }
 763
 764 void CFrame::ReloadPanes()
 765 {
 766         // Close all pages
 767         ClosePages();
 768
 769         CloseAllNotebooks();
 770
 771         // Create new panes with notebooks
 772         for (size_t i = 0; i < Perspectives[ActivePerspective].Width.size() - 1; i++)
 773         {
 774                 wxString PaneName = wxString::Format(wxT("Pane %i"), i + 1);
 775                 m_Mgr->AddPane(CreateEmptyNotebook(), wxAuiPaneInfo().Hide()
 776                                 .CaptionVisible(m_bEdit).Dockable(!m_bNoDocking).Position(i)
 777                                 .Name(PaneName).Caption(PaneName));
 778         }
 779
 780         // Perspectives
 781         m_Mgr->LoadPerspective(Perspectives[ActivePerspective].Perspective, false);
 782         // Reset toolbars
 783         ResetToolbarStyle();
 784         // Restore settings
 785         TogglePaneStyle(m_bNoDocking, IDM_NO_DOCKING);
 786         TogglePaneStyle(m_bEdit, IDM_EDIT_PERSPECTIVES);
 787
 788         // Load GUI settings
 789         g_pCodeWindow->Load();
 790         // Open notebook pages
 791         AddRemoveBlankPage();
 792         g_pCodeWindow->OpenPages();
 793         if (g_pCodeWindow->bShowOnStart[0]) ToggleLogWindow(true);
 794         if (g_pCodeWindow->bShowOnStart[1]) ToggleConsole(true);
 795 }
 796
 797 void CFrame::DoLoadPerspective()
 798 {
 799         ReloadPanes();
 800         // Restore the exact window sizes, which LoadPerspective doesn't always do
 801         SetPaneSize();
 802
 803         m_Mgr->Update();
 804 }
 805
 806 // Update the local perspectives array
 807 void CFrame::LoadIniPerspectives()
 808 {
 809         Perspectives.clear();
 810         std::vector<std::string> VPerspectives;
 811         std::string _Perspectives;
 812
 813         IniFile ini;
 814         ini.Load(File::GetUserPath(F_DEBUGGERCONFIG_IDX));
 815         ini.Get("Perspectives", "Perspectives", &_Perspectives, "Perspective 1");
 816         ini.Get("Perspectives", "Active", &ActivePerspective, 0);
 817         SplitString(_Perspectives, ",", VPerspectives);
 818
 819         for (size_t i = 0; i < VPerspectives.size(); i++)
 820         {
 821                 SPerspectives Tmp;
 822                 std::string _Section, _Perspective, _Width, _Height;
 823                 std::vector<std::string> _SWidth, _SHeight;
 824                 Tmp.Name = VPerspectives[i];
 825                 // Don't save a blank perspective
 826                 if (Tmp.Name.empty()) continue;
 827
 828                 _Section = StringFromFormat("P - %s", Tmp.Name.c_str());
 829                 ini.Get(_Section.c_str(), "Perspective", &_Perspective,
 830                                 "layout2|"
 831                                 "name=Pane 0;caption=Pane 0;state=768;dir=5;prop=100000;|"
 832                                 "name=Pane 1;caption=Pane 1;state=31458108;dir=4;prop=100000;|"
 833                                 "dock_size(5,0,0)=22|dock_size(4,0,0)=333|");
 834                 ini.Get(_Section.c_str(), "Width", &_Width, "70,25");
 835                 ini.Get(_Section.c_str(), "Height", &_Height, "80,80");
 836
 837                 Tmp.Perspective = wxString::FromAscii(_Perspective.c_str());
 838
 839                 SplitString(_Width, ",", _SWidth);
 840                 SplitString(_Height, ",", _SHeight);
 841                 for (size_t j = 0; j < _SWidth.size(); j++)
 842                 {
 843                         int _Tmp;
 844                         if (TryParseInt(_SWidth[j].c_str(), &_Tmp)) Tmp.Width.push_back(_Tmp);
 845                 }
 846                 for (size_t j = 0; j < _SHeight.size(); j++)
 847                 {
 848                         int _Tmp;
 849                         if (TryParseInt(_SHeight[j].c_str(), &_Tmp)) Tmp.Height.push_back(_Tmp);
 850                 }
 851                 Perspectives.push_back(Tmp);
 852         }
 853 }
 854
 855 void CFrame::UpdateCurrentPerspective()
 856 {
 857         SPerspectives *current = &Perspectives[ActivePerspective];
 858         current->Perspective = m_Mgr->SavePerspective();
 859
 860         // Get client size
 861         int iClientX = GetSize().GetX(), iClientY = GetSize().GetY();
 862         current->Width.clear();
 863         current->Height.clear();
 864         for (size_t i = 0; i < m_Mgr->GetAllPanes().GetCount(); i++)
 865         {
 866                 if (!m_Mgr->GetAllPanes()[i].window->
 867                                 IsKindOf(CLASSINFO(wxAuiToolBar)))
 868                 {
 869                         // Save width and height as a percentage of the client width and height
 870                         current->Width.push_back(
 871                                         (m_Mgr->GetAllPanes()[i].window->GetClientSize().GetX() * 100) /
 872                                         iClientX);
 873                         current->Height.push_back(
 874                                         (m_Mgr->GetAllPanes()[i].window->GetClientSize().GetY() * 100) /
 875                                         iClientY);
 876                 }
 877         }
 878 }
 879
 880 void CFrame::SaveIniPerspectives()
 881 {
 882         if (Perspectives.size() == 0) return;
 883         if (ActivePerspective >= Perspectives.size()) ActivePerspective = 0;
 884
 885         // Turn off edit before saving
 886         TogglePaneStyle(false, IDM_EDIT_PERSPECTIVES);
 887
 888         UpdateCurrentPerspective();
 889
 890         IniFile ini;
 891         ini.Load(File::GetUserPath(F_DEBUGGERCONFIG_IDX));
 892
 893         // Save perspective names
 894         std::string STmp = "";
 895         for (size_t i = 0; i < Perspectives.size(); i++)
 896         {
 897                 STmp += Perspectives[i].Name + ",";
 898         }
 899         STmp = STmp.substr(0, STmp.length()-1);
 900         ini.Set("Perspectives", "Perspectives", STmp.c_str());
 901         ini.Set("Perspectives", "Active", ActivePerspective);
 902
 903         // Save the perspectives
 904         for (size_t i = 0; i < Perspectives.size(); i++)
 905         {
 906                 std::string _Section = "P - " + Perspectives[i].Name;
 907                 ini.Set(_Section.c_str(), "Perspective", Perspectives[i].Perspective.mb_str());
 908
 909                 std::string SWidth = "", SHeight = "";
 910                 for (size_t j = 0; j < Perspectives[i].Width.size(); j++)
 911                 {
 912                         SWidth += StringFromFormat("%i,", Perspectives[i].Width[j]);
 913                         SHeight += StringFromFormat("%i,", Perspectives[i].Height[j]);
 914                 }
 915                 // Remove the ending ","
 916                 SWidth = SWidth.substr(0, SWidth.length()-1);
 917                 SHeight = SHeight.substr(0, SHeight.length()-1);
 918
 919                 ini.Set(_Section.c_str(), "Width", SWidth.c_str());
 920                 ini.Set(_Section.c_str(), "Height", SHeight.c_str());
 921         }
 922
 923         ini.Save(File::GetUserPath(F_DEBUGGERCONFIG_IDX));
 924
 925         // Save notebook affiliations
 926         g_pCodeWindow->Save();
 927
 928         TogglePaneStyle(m_bEdit, IDM_EDIT_PERSPECTIVES);
 929 }
 930
 931 void CFrame::AddPane()
 932 {
 933         int PaneNum = GetNotebookCount() + 1;
 934         wxString PaneName = wxString::Format(wxT("Pane %i"), PaneNum);
 935         m_Mgr->AddPane(CreateEmptyNotebook(), wxAuiPaneInfo()
 936                 .CaptionVisible(m_bEdit).Dockable(!m_bNoDocking)
 937                 .Name(PaneName).Caption(PaneName)
 938                 .Position(GetNotebookCount()));
 939
 940         AddRemoveBlankPage();
 941         m_Mgr->Update();
 942 }
 943
 944 wxWindow * CFrame::GetNotebookPageFromId(wxWindowID Id)
 945 {
 946         for (size_t i = 0; i < m_Mgr->GetAllPanes().GetCount(); i++)
 947         {
 948                 if (!m_Mgr->GetAllPanes()[i].window->IsKindOf(CLASSINFO(wxAuiNotebook)))
 949                         continue;
 950                 wxAuiNotebook * NB = (wxAuiNotebook*)m_Mgr->GetAllPanes()[i].window;
 951                 for(size_t j = 0; j < NB->GetPageCount(); j++)
 952                 {
 953                         if (NB->GetPage(j)->GetId() == Id) return NB->GetPage(j);
 954                 }
 955         }
 956         return NULL;
 957 }
 958
 959 wxFrame * CFrame::CreateParentFrame(wxWindowID Id, const wxString& Title,
 960                                                                         wxWindow * Child)
 961 {
 962         wxFrame * Frame = new wxFrame(this, Id, Title,
 963                         wxDefaultPosition, wxDefaultSize, wxDEFAULT_FRAME_STYLE);
 964
 965         Child->Reparent(Frame);
 966
 967         wxBoxSizer * m_MainSizer = new wxBoxSizer(wxHORIZONTAL);
 968
 969         m_MainSizer->Add(Child, 1, wxEXPAND);
 970
 971         Frame->Connect(wxID_ANY, wxEVT_CLOSE_WINDOW,
 972                 wxCloseEventHandler(CFrame::OnFloatingPageClosed),
 973                 (wxObject*)0, this);
 974
 975         if (Id == IDM_CONSOLEWINDOW_PARENT)
 976         {
 977                 Frame->Connect(wxID_ANY, wxEVT_SIZE,
 978                         wxSizeEventHandler(CFrame::OnFloatingPageSize),
 979                         (wxObject*)0, this);
 980         }
 981
 982         // Main sizer
 983         Frame->SetSizer(m_MainSizer);
 984         // Minimum frame size
 985         Frame->SetMinSize(wxSize(200, 200));
 986         Frame->Show();
 987         return Frame;
 988 }
 989
 990 wxAuiNotebook* CFrame::CreateEmptyNotebook()
 991 {
 992         const long NOTEBOOK_STYLE = wxAUI_NB_TOP | wxAUI_NB_TAB_SPLIT |
 993                 wxAUI_NB_TAB_EXTERNAL_MOVE | wxAUI_NB_SCROLL_BUTTONS |
 994                 wxAUI_NB_WINDOWLIST_BUTTON | wxNO_BORDER;
 995         wxAuiNotebook* NB = new wxAuiNotebook(this, wxID_ANY,
 996                         wxDefaultPosition, wxDefaultSize, NOTEBOOK_STYLE);
 997         return NB;
 998 }
 999
1000 void CFrame::AddRemoveBlankPage()
1001 {
1002         for (size_t i = 0; i < m_Mgr->GetAllPanes().GetCount(); i++)
1003         {
1004                 if (!m_Mgr->GetAllPanes()[i].window->IsKindOf(CLASSINFO(wxAuiNotebook)))
1005                         continue;
1006                 wxAuiNotebook * NB = (wxAuiNotebook*)m_Mgr->GetAllPanes()[i].window;
1007                 for(size_t j = 0; j < NB->GetPageCount(); j++)
1008                 {
1009                         if (NB->GetPageText(j).IsSameAs(wxT("<>")) && NB->GetPageCount() > 1)
1010                                 NB->DeletePage(j);
1011                 }
1012                 if (NB->GetPageCount() == 0)
1013                         NB->AddPage(new wxPanel(this, wxID_ANY), wxT("<>"), true);
1014         }
1015 }
1016
1017 int CFrame::GetNotebookAffiliation(wxWindowID Id)
1018 {
1019         for (size_t i = 0, j = 0; i < m_Mgr->GetAllPanes().GetCount(); i++)
1020         {
1021                 if (!m_Mgr->GetAllPanes()[i].window->IsKindOf(CLASSINFO(wxAuiNotebook)))
1022                         continue;
1023                 wxAuiNotebook * NB = (wxAuiNotebook*)m_Mgr->GetAllPanes()[i].window;
1024                 for(size_t k = 0; k < NB->GetPageCount(); k++)
1025                 {
1026                         if (NB->GetPage(k)->GetId() == Id)
1027                                 return j;
1028                 }
1029                 j++;
1030         }
1031         return -1;
1032 }
1033
1034 // Close all panes with notebooks
1035 void CFrame::CloseAllNotebooks()
1036 {
1037         wxAuiPaneInfoArray AllPanes = m_Mgr->GetAllPanes();
1038         for (size_t i = 0; i < AllPanes.GetCount(); i++)
1039         {
1040                 if (AllPanes[i].window->IsKindOf(CLASSINFO(wxAuiNotebook)))
1041                 {
1042                         AllPanes[i].DestroyOnClose(true);
1043                         m_Mgr->ClosePane(AllPanes[i]);
1044                 }
1045         }
1046 }
1047
1048 int CFrame::GetNotebookCount()
1049 {
1050         int Ret = 0;
1051         for (size_t i = 0; i < m_Mgr->GetAllPanes().GetCount(); i++)
1052         {
1053                 if (m_Mgr->GetAllPanes()[i].window->IsKindOf(CLASSINFO(wxAuiNotebook)))
1054                         Ret++;
1055         }
1056         return Ret;
1057 }
1058
1059 wxAuiNotebook * CFrame::GetNotebookFromId(size_t NBId)
1060 {
1061         for (size_t i = 0, j = 0; i < m_Mgr->GetAllPanes().GetCount(); i++)
1062         {
1063                 if (!m_Mgr->GetAllPanes()[i].window->IsKindOf(CLASSINFO(wxAuiNotebook)))
1064                         continue;
1065                 if (j == NBId)
1066                         return (wxAuiNotebook*)m_Mgr->GetAllPanes()[i].window;
1067                 j++;
1068         }
1069         return NULL;
1070 }