1 /////////////////////////////////////////////////////////////////////////////
2 // WinMerge: an interactive diff/merge utility
3 // Copyright (C) 1997-2000 Thingamahoochie Software
6 // This program is free software; you can redistribute it and/or modify
7 // it under the terms of the GNU General Public License as published by
8 // the Free Software Foundation; either version 2 of the License, or
9 // (at your option) any later version.
11 // This program is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
16 // You should have received a copy of the GNU General Public License
17 // along with this program; if not, write to the Free Software
18 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 /////////////////////////////////////////////////////////////////////////////
24 * @brief Implementation of the CMainFrame class
31 #include <Poco/Exception.h>
33 #include "Constants.h"
35 #include "FileFilterHelper.h"
36 #include "UnicodeString.h"
39 #include "DirFrame.h" // Include type information
41 #include "HexMergeFrm.h"
47 #include "MergeEditView.h"
48 #include "HexMergeDoc.h"
49 #include "ImgMergeFrm.h"
50 #include "LineFiltersList.h"
51 #include "ConflictFileParser.h"
52 #include "LineFiltersDlg.h"
54 #include "Environment.h"
55 #include "PatchTool.h"
57 #include "SelectUnpackerDlg.h"
58 #include "ConfigLog.h"
60 #include "Merge7zFormatMergePluginImpl.h"
61 #include "FileFiltersDlg.h"
62 #include "OptionsMgr.h"
63 #include "OptionsDef.h"
64 #include "codepage_detect.h"
67 #include "PreferencesDlg.h"
68 #include "ProjectFilePathsDlg.h"
69 #include "FileOrFolderSelect.h"
71 #include "PluginsListDlg.h"
72 #include "stringdiffs.h"
73 #include "MergeCmdLineInfo.h"
74 #include "OptionsFont.h"
77 #include "DropHandler.h"
78 #include "LanguageSelect.h"
84 One source file must compile the stubs for multimonitor
85 by defining the symbol COMPILE_MULTIMON_STUBS & including <multimon.h>
87 #ifdef COMPILE_MULTIMON_STUBS
88 #undef COMPILE_MULTIMON_STUBS
90 #define COMPILE_MULTIMON_STUBS
96 static char THIS_FILE[] = __FILE__;
99 static void LoadToolbarImageList(CMainFrame::TOOLBAR_SIZE size, UINT nIDResource, CImageList& ImgList);
100 static const CPtrList &GetDocList(const CMultiDocTemplate *pTemplate);
101 template<class DocClass>
102 DocClass * GetMergeDocForDiff(CMultiDocTemplate *pTemplate, CDirDoc *pDirDoc, int nFiles);
105 * @brief A table associating menuitem id, icon and menus to apply.
107 const CMainFrame::MENUITEM_ICON CMainFrame::m_MenuIcons[] = {
108 { ID_FILE_OPENCONFLICT, IDB_FILE_OPENCONFLICT, CMainFrame::MENU_ALL },
109 { ID_EDIT_COPY, IDB_EDIT_COPY, CMainFrame::MENU_ALL },
110 { ID_EDIT_CUT, IDB_EDIT_CUT, CMainFrame::MENU_ALL },
111 { ID_EDIT_PASTE, IDB_EDIT_PASTE, CMainFrame::MENU_ALL },
112 { ID_EDIT_FIND, IDB_EDIT_SEARCH, CMainFrame::MENU_ALL },
113 { ID_WINDOW_CASCADE, IDB_WINDOW_CASCADE, CMainFrame::MENU_ALL },
114 { ID_WINDOW_TILE_HORZ, IDB_WINDOW_HORIZONTAL, CMainFrame::MENU_ALL },
115 { ID_WINDOW_TILE_VERT, IDB_WINDOW_VERTICAL, CMainFrame::MENU_ALL },
116 { ID_FILE_CLOSE, IDB_WINDOW_CLOSE, CMainFrame::MENU_ALL },
117 { ID_WINDOW_CHANGE_PANE, IDB_WINDOW_CHANGEPANE, CMainFrame::MENU_ALL },
118 { ID_EDIT_WMGOTO, IDB_EDIT_GOTO, CMainFrame::MENU_ALL },
119 { ID_EDIT_REPLACE, IDB_EDIT_REPLACE, CMainFrame::MENU_ALL },
120 { ID_VIEW_SELECTFONT, IDB_VIEW_SELECTFONT, CMainFrame::MENU_ALL },
121 { ID_APP_EXIT, IDB_FILE_EXIT, CMainFrame::MENU_ALL },
122 { ID_HELP_CONTENTS, IDB_HELP_CONTENTS, CMainFrame::MENU_ALL },
123 { ID_EDIT_SELECT_ALL, IDB_EDIT_SELECTALL, CMainFrame::MENU_ALL },
124 { ID_TOOLS_FILTERS, IDB_TOOLS_FILTERS, CMainFrame::MENU_ALL },
125 { ID_TOOLS_CUSTOMIZECOLUMNS, IDB_TOOLS_COLUMNS, CMainFrame::MENU_ALL },
126 { ID_TOOLS_GENERATEPATCH, IDB_TOOLS_GENERATEPATCH, CMainFrame::MENU_ALL },
127 { ID_PLUGINS_LIST, IDB_PLUGINS_LIST, CMainFrame::MENU_ALL },
128 { ID_COPY_FROM_LEFT, IDB_COPY_FROM_LEFT, CMainFrame::MENU_ALL },
129 { ID_COPY_FROM_RIGHT, IDB_COPY_FROM_RIGHT, CMainFrame::MENU_ALL },
130 { ID_FILE_PRINT, IDB_FILE_PRINT, CMainFrame::MENU_FILECMP },
131 { ID_TOOLS_GENERATEREPORT, IDB_TOOLS_GENERATEREPORT, CMainFrame::MENU_FILECMP },
132 { ID_EDIT_TOGGLE_BOOKMARK, IDB_EDIT_TOGGLE_BOOKMARK, CMainFrame::MENU_FILECMP },
133 { ID_EDIT_GOTO_NEXT_BOOKMARK, IDB_EDIT_GOTO_NEXT_BOOKMARK, CMainFrame::MENU_FILECMP },
134 { ID_EDIT_GOTO_PREV_BOOKMARK, IDB_EDIT_GOTO_PREV_BOOKMARK, CMainFrame::MENU_FILECMP },
135 { ID_EDIT_CLEAR_ALL_BOOKMARKS, IDB_EDIT_CLEAR_ALL_BOOKMARKS, CMainFrame::MENU_FILECMP },
136 { ID_VIEW_ZOOMIN, IDB_VIEW_ZOOMIN, CMainFrame::MENU_FILECMP },
137 { ID_VIEW_ZOOMOUT, IDB_VIEW_ZOOMOUT, CMainFrame::MENU_FILECMP },
138 { ID_MERGE_COMPARE, IDB_MERGE_COMPARE, CMainFrame::MENU_FOLDERCMP },
139 { ID_MERGE_COMPARE_LEFT1_LEFT2, IDB_MERGE_COMPARE_LEFT1_LEFT2, CMainFrame::MENU_FOLDERCMP },
140 { ID_MERGE_COMPARE_RIGHT1_RIGHT2, IDB_MERGE_COMPARE_RIGHT1_RIGHT2,CMainFrame::MENU_FOLDERCMP },
141 { ID_MERGE_COMPARE_LEFT1_RIGHT2, IDB_MERGE_COMPARE_LEFT1_RIGHT2, CMainFrame::MENU_FOLDERCMP },
142 { ID_MERGE_COMPARE_LEFT2_RIGHT1, IDB_MERGE_COMPARE_LEFT2_RIGHT1, CMainFrame::MENU_FOLDERCMP },
143 { ID_MERGE_DELETE, IDB_MERGE_DELETE, CMainFrame::MENU_FOLDERCMP },
144 { ID_TOOLS_GENERATEREPORT, IDB_TOOLS_GENERATEREPORT, CMainFrame::MENU_FOLDERCMP },
145 { ID_DIR_COPY_LEFT_TO_RIGHT, IDB_LEFT_TO_RIGHT, CMainFrame::MENU_FOLDERCMP },
146 { ID_DIR_COPY_RIGHT_TO_LEFT, IDB_RIGHT_TO_LEFT, CMainFrame::MENU_FOLDERCMP },
147 { ID_DIR_COPY_LEFT_TO_BROWSE, IDB_LEFT_TO_BROWSE, CMainFrame::MENU_FOLDERCMP },
148 { ID_DIR_COPY_RIGHT_TO_BROWSE, IDB_RIGHT_TO_BROWSE, CMainFrame::MENU_FOLDERCMP },
149 { ID_DIR_MOVE_LEFT_TO_BROWSE, IDB_MOVE_LEFT_TO_BROWSE, CMainFrame::MENU_FOLDERCMP },
150 { ID_DIR_MOVE_RIGHT_TO_BROWSE, IDB_MOVE_RIGHT_TO_BROWSE, CMainFrame::MENU_FOLDERCMP },
151 { ID_DIR_DEL_LEFT, IDB_LEFT, CMainFrame::MENU_FOLDERCMP },
152 { ID_DIR_DEL_RIGHT, IDB_RIGHT, CMainFrame::MENU_FOLDERCMP },
153 { ID_DIR_DEL_BOTH, IDB_BOTH, CMainFrame::MENU_FOLDERCMP },
154 { ID_DIR_COPY_PATHNAMES_LEFT, IDB_LEFT, CMainFrame::MENU_FOLDERCMP },
155 { ID_DIR_COPY_PATHNAMES_RIGHT, IDB_RIGHT, CMainFrame::MENU_FOLDERCMP },
156 { ID_DIR_COPY_PATHNAMES_BOTH, IDB_BOTH, CMainFrame::MENU_FOLDERCMP },
157 { ID_DIR_COPY_LEFT_TO_CLIPBOARD, IDB_LEFT, CMainFrame::MENU_FOLDERCMP },
158 { ID_DIR_COPY_RIGHT_TO_CLIPBOARD, IDB_RIGHT, CMainFrame::MENU_FOLDERCMP },
159 { ID_DIR_COPY_BOTH_TO_CLIPBOARD, IDB_BOTH, CMainFrame::MENU_FOLDERCMP },
160 { ID_DIR_ZIP_LEFT, IDB_LEFT, CMainFrame::MENU_FOLDERCMP },
161 { ID_DIR_ZIP_RIGHT, IDB_RIGHT, CMainFrame::MENU_FOLDERCMP },
162 { ID_DIR_ZIP_BOTH, IDB_BOTH, CMainFrame::MENU_FOLDERCMP }
166 /////////////////////////////////////////////////////////////////////////////
169 IMPLEMENT_DYNAMIC(CMainFrame, CMDIFrameWnd)
171 BEGIN_MESSAGE_MAP(CMainFrame, CMDIFrameWnd)
172 //{{AFX_MSG_MAP(CMainFrame)
175 ON_WM_INITMENUPOPUP()
178 ON_COMMAND(ID_FILE_OPEN, OnFileOpen)
179 ON_COMMAND(ID_HELP_GNULICENSE, OnHelpGnulicense)
180 ON_COMMAND(ID_OPTIONS, OnOptions)
181 ON_COMMAND(ID_VIEW_SELECTFONT, OnViewSelectfont)
182 ON_UPDATE_COMMAND_UI(ID_VIEW_SELECTFONT, OnUpdateViewSelectfont)
183 ON_COMMAND(ID_VIEW_USEDEFAULTFONT, OnViewUsedefaultfont)
184 ON_UPDATE_COMMAND_UI(ID_VIEW_USEDEFAULTFONT, OnUpdateViewUsedefaultfont)
185 ON_COMMAND(ID_HELP_CONTENTS, OnHelpContents)
186 ON_UPDATE_COMMAND_UI(ID_HELP_CONTENTS, OnUpdateHelpContents)
188 ON_COMMAND(ID_TOOLS_GENERATEPATCH, OnToolsGeneratePatch)
190 ON_COMMAND_RANGE(ID_UNPACK_MANUAL, ID_UNPACK_AUTO, OnPluginUnpackMode)
191 ON_UPDATE_COMMAND_UI_RANGE(ID_UNPACK_MANUAL, ID_UNPACK_AUTO, OnUpdatePluginUnpackMode)
192 ON_COMMAND_RANGE(ID_PREDIFFER_MANUAL, ID_PREDIFFER_AUTO, OnPluginPrediffMode)
193 ON_UPDATE_COMMAND_UI_RANGE(ID_PREDIFFER_MANUAL, ID_PREDIFFER_AUTO, OnUpdatePluginPrediffMode)
194 ON_UPDATE_COMMAND_UI(ID_RELOAD_PLUGINS, OnUpdateReloadPlugins)
195 ON_COMMAND(ID_RELOAD_PLUGINS, OnReloadPlugins)
196 ON_COMMAND(ID_HELP_GETCONFIG, OnSaveConfigData)
197 ON_COMMAND(ID_FILE_NEW, OnFileNew)
198 ON_COMMAND(ID_FILE_NEW3, OnFileNew3)
199 ON_COMMAND(ID_TOOLS_FILTERS, OnToolsFilters)
200 ON_COMMAND(ID_VIEW_STATUS_BAR, OnViewStatusBar)
201 ON_UPDATE_COMMAND_UI(ID_VIEW_TAB_BAR, OnUpdateViewTabBar)
202 ON_COMMAND(ID_VIEW_TAB_BAR, OnViewTabBar)
203 ON_UPDATE_COMMAND_UI(ID_VIEW_RESIZE_PANES, OnUpdateResizePanes)
204 ON_COMMAND(ID_VIEW_RESIZE_PANES, OnResizePanes)
205 ON_COMMAND(ID_FILE_OPENPROJECT, OnFileOpenproject)
206 ON_MESSAGE(WM_COPYDATA, OnCopyData)
207 ON_MESSAGE(WM_USER+1, OnUser1)
208 ON_COMMAND(ID_WINDOW_CLOSEALL, OnWindowCloseAll)
209 ON_UPDATE_COMMAND_UI(ID_WINDOW_CLOSEALL, OnUpdateWindowCloseAll)
210 ON_COMMAND(ID_FILE_SAVEPROJECT, OnSaveProject)
214 ON_COMMAND(ID_TOOLBAR_NONE, OnToolbarNone)
215 ON_UPDATE_COMMAND_UI(ID_TOOLBAR_NONE, OnUpdateToolbarNone)
216 ON_COMMAND(ID_TOOLBAR_SMALL, OnToolbarSmall)
217 ON_UPDATE_COMMAND_UI(ID_TOOLBAR_SMALL, OnUpdateToolbarSmall)
218 ON_COMMAND(ID_TOOLBAR_BIG, OnToolbarBig)
219 ON_UPDATE_COMMAND_UI(ID_TOOLBAR_BIG, OnUpdateToolbarBig)
220 ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTW, 0, 0xFFFF, OnToolTipText)
221 ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, OnToolTipText)
222 ON_COMMAND(ID_HELP_CHECKFORUPDATES, OnHelpCheckForUpdates)
223 ON_COMMAND(ID_FILE_OPENCONFLICT, OnFileOpenConflict)
224 ON_COMMAND(ID_PLUGINS_LIST, OnPluginsList)
225 ON_UPDATE_COMMAND_UI(ID_STATUS_PLUGIN, OnUpdatePluginName)
226 ON_NOTIFY(TBN_DROPDOWN, AFX_IDW_TOOLBAR, OnDiffOptionsDropDown)
227 ON_COMMAND_RANGE(IDC_DIFF_WHITESPACE_COMPARE, IDC_DIFF_WHITESPACE_IGNOREALL, OnDiffWhitespace)
228 ON_UPDATE_COMMAND_UI_RANGE(IDC_DIFF_WHITESPACE_COMPARE, IDC_DIFF_WHITESPACE_IGNOREALL, OnUpdateDiffWhitespace)
229 ON_COMMAND(IDC_DIFF_CASESENSITIVE, OnDiffCaseSensitive)
230 ON_UPDATE_COMMAND_UI(IDC_DIFF_CASESENSITIVE, OnUpdateDiffCaseSensitive)
231 ON_COMMAND(IDC_DIFF_IGNOREEOL, OnDiffIgnoreEOL)
232 ON_UPDATE_COMMAND_UI(IDC_DIFF_IGNOREEOL, OnUpdateDiffIgnoreEOL)
233 ON_COMMAND_RANGE(ID_COMPMETHOD_FULL_CONTENTS, ID_COMPMETHOD_SIZE, OnCompareMethod)
234 ON_UPDATE_COMMAND_UI_RANGE(ID_COMPMETHOD_FULL_CONTENTS, ID_COMPMETHOD_SIZE, OnUpdateCompareMethod)
235 ON_COMMAND_RANGE(ID_MRU_FIRST, ID_MRU_LAST, OnMRUs)
236 ON_UPDATE_COMMAND_UI(ID_MRU_FIRST, OnUpdateNoMRUs)
237 ON_UPDATE_COMMAND_UI(ID_NO_MRU, OnUpdateNoMRUs)
242 * @brief MainFrame statusbar panels/indicators
244 static UINT StatusbarIndicators[] =
246 ID_SEPARATOR, // Plugin name
247 ID_SEPARATOR, // status line indicator
248 ID_SEPARATOR, // Merge mode
249 ID_SEPARATOR, // Diff number
250 ID_INDICATOR_CAPS, // Caps Lock
251 ID_INDICATOR_NUM, // Num Lock
252 ID_INDICATOR_OVR, // Insert
255 /** @brief Timer ID for window flashing timer. */
256 static const UINT ID_TIMER_FLASH = 1;
258 /** @brief Timeout for window flashing timer, in milliseconds. */
259 static const UINT WINDOW_FLASH_TIMEOUT = 500;
262 * @brief Return a const reference to a CMultiDocTemplate's list of documents.
264 static const CPtrList &GetDocList(const CMultiDocTemplate *pTemplate)
266 struct Template : public CMultiDocTemplate
269 using CMultiDocTemplate::m_docList;
271 return static_cast<const struct Template *>(pTemplate)->m_docList;
274 /////////////////////////////////////////////////////////////////////////////
275 // CMainFrame construction/destruction
278 * @brief MainFrame constructor. Loads settings from registry.
279 * @todo Preference for logging?
281 CMainFrame::CMainFrame()
284 , m_pDropHandler(NULL)
286 ZeroMemory(&m_pMenus[0], sizeof(m_pMenus));
289 CMainFrame::~CMainFrame()
291 GetOptionsMgr()->SaveOption(OPT_TABBAR_AUTO_MAXWIDTH, m_wndTabBar.GetAutoMaxWidth());
296 const TCHAR CMainFrame::szClassName[] = _T("WinMergeWindowClassW");
298 const TCHAR CMainFrame::szClassName[] = _T("WinMergeWindowClassA");
301 * @brief Change MainFrame window class name
302 * see http://support.microsoft.com/kb/403825/ja
304 BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
307 BOOL bRes = CMDIFrameWnd::PreCreateWindow(cs);
308 HINSTANCE hInst = AfxGetInstanceHandle();
309 // see if the class already exists
310 if (!::GetClassInfo(hInst, szClassName, &wndcls))
313 ::GetClassInfo(hInst, cs.lpszClass, &wndcls);
314 // register a new class
315 wndcls.lpszClassName = szClassName;
316 wndcls.hIcon = ::LoadIcon(hInst, MAKEINTRESOURCE(IDR_MAINFRAME));
317 ::RegisterClass(&wndcls);
319 cs.lpszClass = szClassName;
323 int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
325 if (CMDIFrameWnd::OnCreate(lpCreateStruct) == -1)
328 m_lfDiff = Options::Font::Load(OPT_FONT_FILECMP);
329 m_lfDir = Options::Font::Load(OPT_FONT_DIRCMP);
331 if (!CreateToolbar())
333 TRACE0("Failed to create toolbar\n");
334 return -1; // fail to create
337 if (!m_wndTabBar.Create(this))
339 TRACE0("Failed to create tab bar\n");
340 return -1; // fail to create
342 m_wndTabBar.SetAutoMaxWidth(GetOptionsMgr()->GetBool(OPT_TABBAR_AUTO_MAXWIDTH));
344 if (GetOptionsMgr()->GetBool(OPT_SHOW_TABBAR) == false)
345 CMDIFrameWnd::ShowControlBar(&m_wndTabBar, false, 0);
347 if (!m_wndStatusBar.Create(this))
349 TRACE0("Failed to create status bar\n");
350 return -1; // fail to create
352 theApp.SetIndicators(m_wndStatusBar, StatusbarIndicators,
353 countof(StatusbarIndicators));
355 m_wndStatusBar.SetPaneInfo(1, ID_STATUS_PLUGIN, 0, 300);
356 m_wndStatusBar.SetPaneInfo(2, ID_STATUS_MERGINGMODE, 0, 100);
357 m_wndStatusBar.SetPaneInfo(3, ID_STATUS_DIFFNUM, 0, 150);
359 if (GetOptionsMgr()->GetBool(OPT_SHOW_STATUSBAR) == false)
360 CMDIFrameWnd::ShowControlBar(&m_wndStatusBar, false, 0);
362 m_pDropHandler = new DropHandler(std::bind(&CMainFrame::OnDropFiles, this, std::placeholders::_1));
363 RegisterDragDrop(m_hWnd, m_pDropHandler);
368 void CMainFrame::OnDestroy(void)
371 RevokeDragDrop(m_hWnd);
374 static HMENU GetSubmenu(HMENU mainMenu, UINT nIDFirstMenuItem, bool bFirstSubmenu)
377 for (i = 0 ; i < ::GetMenuItemCount(mainMenu) ; i++)
378 if (::GetMenuItemID(::GetSubMenu(mainMenu, i), 0) == nIDFirstMenuItem)
380 HMENU menu = ::GetSubMenu(mainMenu, i);
384 // look for last submenu
385 for (i = ::GetMenuItemCount(menu) ; i >= 0 ; i--)
386 if (::GetSubMenu(menu, i) != NULL)
387 return ::GetSubMenu(menu, i);
391 // look for first submenu
392 for (i = 0 ; i < ::GetMenuItemCount(menu) ; i++)
393 if (::GetSubMenu(menu, i) != NULL)
394 return ::GetSubMenu(menu, i);
397 // error, submenu not found
402 * @brief Find the scripts submenu from the main menu
403 * As now this is the first submenu in "Edit" menu
404 * We find the "Edit" menu by looking for a menu
405 * starting with ID_EDIT_UNDO.
407 HMENU CMainFrame::GetScriptsSubmenu(HMENU mainMenu)
409 return GetSubmenu(mainMenu, ID_PLUGINS_LIST, false);
413 * @brief Find the scripts submenu from the main menu
414 * As now this is the first submenu in "Plugins" menu
415 * We find the "Plugins" menu by looking for a menu
416 * starting with ID_UNPACK_MANUAL.
418 HMENU CMainFrame::GetPrediffersSubmenu(HMENU mainMenu)
420 return GetSubmenu(mainMenu, ID_PLUGINS_LIST, true);
424 * @brief Create a new menu for the view..
425 * @param [in] view Menu view either MENU_DEFAULT, MENU_MERGEVIEW or MENU_DIRVIEW.
426 * @param [in] ID Menu's resource ID.
427 * @return Menu for the view.
429 HMENU CMainFrame::NewMenu(int view, int ID)
431 int menu_view, index;
432 if (m_pMenus[view] == NULL)
434 m_pMenus[view].reset(new BCMenu());
435 if (m_pMenus[view] == NULL)
442 menu_view = MENU_FILECMP;
445 menu_view = MENU_FOLDERCMP;
449 menu_view = MENU_MAINFRM;
453 if (!m_pMenus[view]->LoadMenu(ID))
459 if (view == MENU_IMGMERGEVIEW)
461 BCMenu *pMenu = new BCMenu;
462 pMenu->LoadMenu(MAKEINTRESOURCE(IDR_POPUP_IMGMERGEVIEW));
463 m_pMenus[view]->InsertMenu(4, MF_BYPOSITION | MF_POPUP, (UINT_PTR)pMenu->GetSubMenu(0)->m_hMenu, const_cast<TCHAR *>(LoadResString(IDS_IMAGE_MENU).c_str()));
466 // Load bitmaps to menuitems
467 for (index = 0; index < countof(m_MenuIcons); index ++)
469 if (menu_view == (m_MenuIcons[index].menusToApply & menu_view))
471 m_pMenus[view]->ModifyODMenu(NULL, m_MenuIcons[index].menuitemID, m_MenuIcons[index].iconResID);
475 m_pMenus[view]->LoadToolbar(IDR_MAINFRAME);
477 theApp.TranslateMenu(m_pMenus[view]->m_hMenu);
479 return (m_pMenus[view]->Detach());
483 * @brief Create new default (CMainFrame) menu.
485 HMENU CMainFrame::NewDefaultMenu(int ID /*=0*/)
489 return NewMenu( MENU_DEFAULT, ID );
493 * @brief Create new File compare (CMergeEditView) menu.
495 HMENU CMainFrame::NewMergeViewMenu()
497 return NewMenu( MENU_MERGEVIEW, IDR_MERGEDOCTYPE);
501 * @brief Create new Dir compare (CDirView) menu
503 HMENU CMainFrame::NewDirViewMenu()
505 return NewMenu(MENU_DIRVIEW, IDR_DIRDOCTYPE );
509 * @brief Create new File compare (CHexMergeView) menu.
511 HMENU CMainFrame::NewHexMergeViewMenu()
513 return NewMenu( MENU_HEXMERGEVIEW, IDR_MERGEDOCTYPE);
517 * @brief Create new Image compare (CImgMergeView) menu.
519 HMENU CMainFrame::NewImgMergeViewMenu()
521 return NewMenu( MENU_IMGMERGEVIEW, IDR_MERGEDOCTYPE);
525 * @brief Create new File compare (COpenView) menu.
527 HMENU CMainFrame::NewOpenViewMenu()
529 return NewMenu( MENU_OPENVIEW, IDR_MAINFRAME);
533 * @brief This handler ensures that the popup menu items are drawn correctly.
535 void CMainFrame::OnMeasureItem(int nIDCtl,
536 LPMEASUREITEMSTRUCT lpMeasureItemStruct)
538 BOOL setflag = FALSE;
539 if (lpMeasureItemStruct->CtlType == ODT_MENU)
541 if (IsMenu((HMENU)lpMeasureItemStruct->itemID))
544 CMenu::FromHandle((HMENU)lpMeasureItemStruct->itemID);
546 if (m_pMenus[MENU_DEFAULT]->IsMenu(cmenu))
548 m_pMenus[MENU_DEFAULT]->MeasureItem(lpMeasureItemStruct);
555 CMDIFrameWnd::OnMeasureItem(nIDCtl, lpMeasureItemStruct);
559 * @brief This handler ensures that keyboard shortcuts work.
561 LRESULT CMainFrame::OnMenuChar(UINT nChar, UINT nFlags,
565 if(m_pMenus[MENU_DEFAULT]->IsMenu(pMenu))
566 lresult=BCMenu::FindKeyboardShortcut(nChar, nFlags, pMenu);
568 lresult=CMDIFrameWnd::OnMenuChar(nChar, nFlags, pMenu);
573 * @brief This handler updates the menus from time to time.
575 void CMainFrame::OnInitMenuPopup(CMenu* pPopupMenu, UINT nIndex, BOOL bSysMenu)
577 CMDIFrameWnd::OnInitMenuPopup(pPopupMenu, nIndex, bSysMenu);
581 if (BCMenu::IsMenu(pPopupMenu))
583 BCMenu::UpdateMenu(pPopupMenu);
588 /////////////////////////////////////////////////////////////////////////////
589 // CMainFrame message handlers
591 void CMainFrame::OnFileOpen()
597 * @brief Check for BOM, and also, if bGuessEncoding, try to deduce codepage
599 * Unpacks info from FileLocation & delegates all work to codepage_detect module
602 FileLocationGuessEncodings(FileLocation & fileloc, int iGuessEncoding)
604 fileloc.encoding = GuessCodepageEncoding(fileloc.filepath, iGuessEncoding);
607 int CMainFrame::ShowAutoMergeDoc(CDirDoc * pDirDoc,
608 int nFiles, const FileLocation ifileloc[],
609 const DWORD dwFlags[] /*=0*/, const PackingInfo * infoUnpacker /*= NULL*/)
612 FileFilterHelper filterImg, filterBin;
613 filterImg.UseMask(true);
614 filterImg.SetMask(GetOptionsMgr()->GetString(OPT_CMP_IMG_FILEPATTERNS));
615 filterBin.UseMask(true);
616 filterBin.SetMask(GetOptionsMgr()->GetString(OPT_CMP_BIN_FILEPATTERNS));
617 for (pane = 0; pane < nFiles; ++pane)
619 if (filterImg.includeFile(ifileloc[pane].filepath))
620 return ShowImgMergeDoc(pDirDoc, nFiles, ifileloc, dwFlags, infoUnpacker);
621 else if (filterBin.includeFile(ifileloc[pane].filepath))
624 for (int pane = 0; pane < nFiles; pane++)
625 bRO[pane] = (dwFlags) ? ((dwFlags[pane] & FFILEOPEN_READONLY) > 0) : FALSE;
626 ShowHexMergeDoc(pDirDoc,
628 PathContext(ifileloc[0].filepath, ifileloc[1].filepath) :
629 PathContext(ifileloc[0].filepath, ifileloc[1].filepath, ifileloc[2].filepath)
634 return ShowMergeDoc(pDirDoc, nFiles, ifileloc, dwFlags, infoUnpacker);
638 * @brief Creates new MergeDoc instance and shows documents.
639 * @param [in] pDirDoc Dir compare document to create a new Merge document for.
640 * @param [in] ifilelocLeft Left side file location info.
641 * @param [in] ifilelocRight Right side file location info.
642 * @param [in] dwLeftFlags Left side flags.
643 * @param [in] dwRightFlags Right side flags.
644 * @param [in] infoUnpacker Plugin info.
645 * @return OPENRESULTS_TYPE for success/failure code.
647 int CMainFrame::ShowMergeDoc(CDirDoc * pDirDoc,
648 int nFiles, const FileLocation ifileloc[],
649 const DWORD dwFlags[] /*=0*/, const PackingInfo * infoUnpacker /*= NULL*/)
651 if (!m_pMenus[MENU_MERGEVIEW])
652 theApp.m_pDiffTemplate->m_hMenuShared = NewMergeViewMenu();
653 CMergeDoc * pMergeDoc = GetMergeDocForDiff<CMergeDoc>(theApp.m_pDiffTemplate, pDirDoc, nFiles);
655 // Make local copies, so we can change encoding if we guess it below
656 FileLocation fileloc[3];
659 for (pane = 0; pane < nFiles; pane++)
661 fileloc[pane] = ifileloc[pane];
663 bRO[pane] = (dwFlags[pane] & FFILEOPEN_READONLY) > 0;
668 ASSERT(pMergeDoc); // must ASSERT to get an answer to the question below ;-)
670 return OPENRESULTS_FAILED_MISC; // when does this happen ?
672 // if an unpacker is selected, it must be used during LoadFromFile
673 // MergeDoc must memorize it for SaveToFile
674 // Warning : this unpacker may differ from the pDirDoc one
675 // (through menu : "Plugins"->"Open with unpacker")
676 pMergeDoc->SetUnpacker(infoUnpacker);
679 int iGuessEncodingType = GetOptionsMgr()->GetInt(OPT_CP_DETECT);
680 for (pane = 0; pane < nFiles; pane++)
682 if (fileloc[pane].encoding.m_unicoding == -1)
683 fileloc[pane].encoding.m_unicoding = ucr::NONE;
684 if (fileloc[pane].encoding.m_unicoding == ucr::NONE && fileloc[pane].encoding.m_codepage == -1)
686 FileLocationGuessEncodings(fileloc[pane], iGuessEncodingType);
689 // TODO (Perry, 2005-12-04)
690 // Should we do any unification if unicodings are different?
694 // In ANSI (8-bit) build, character loss can occur in merging
695 // if the two buffers use different encodings
696 if (pane > 0 && fileloc[pane - 1].encoding.m_codepage != fileloc[pane].encoding.m_codepage)
699 msg.Format(theApp.LoadString(IDS_SUGGEST_IGNORECODEPAGE).c_str(), fileloc[pane - 1].encoding.m_codepage,fileloc[pane].encoding.m_codepage);
700 int msgflags = MB_YESNO | MB_ICONQUESTION | MB_DONT_ASK_AGAIN;
701 // Two files with different codepages
702 // Warn and propose to use the default codepage for both
703 int userChoice = AfxMessageBox(msg, msgflags);
704 if (userChoice == IDYES)
706 fileloc[pane - 1].encoding.SetCodepage(ucr::getDefaultCodepage());
707 fileloc[pane - 1].encoding.m_bom = false;
708 fileloc[pane].encoding.SetCodepage(ucr::getDefaultCodepage());
709 fileloc[pane].encoding.m_bom = false;
715 int nActivePane = -1;
716 for (pane = 0; pane < nFiles; pane++)
718 if (dwFlags && (dwFlags[pane] & FFILEOPEN_SETFOCUS))
722 // Note that OpenDocs() takes care of closing compare window when needed.
723 OPENRESULTS_TYPE openResults = pMergeDoc->OpenDocs(fileloc, bRO, nActivePane);
725 if (openResults == OPENRESULTS_SUCCESS)
727 for (pane = 0; pane < nFiles; pane++)
731 BOOL bModified = (dwFlags[pane] & FFILEOPEN_MODIFIED) > 0;
734 pMergeDoc->m_ptBuf[pane]->SetModified(TRUE);
735 pMergeDoc->UpdateHeaderPath(pane);
737 if (dwFlags[pane] & FFILEOPEN_AUTOMERGE)
739 pMergeDoc->DoAutoMerge(pane);
747 void CMainFrame::ShowHexMergeDoc(CDirDoc * pDirDoc,
748 const PathContext &paths, const bool bRO[])
750 if (!m_pMenus[MENU_HEXMERGEVIEW])
751 theApp.m_pHexMergeTemplate->m_hMenuShared = NewHexMergeViewMenu();
752 if (CHexMergeDoc *pHexMergeDoc = GetMergeDocForDiff<CHexMergeDoc>(theApp.m_pHexMergeTemplate, pDirDoc, paths.GetSize()))
753 pHexMergeDoc->OpenDocs(paths, bRO);
756 int CMainFrame::ShowImgMergeDoc(CDirDoc * pDirDoc, int nFiles, const FileLocation fileloc[],
757 const DWORD dwFlags[], const PackingInfo * infoUnpacker/* = NULL*/)
759 CImgMergeFrame *pImgMergeFrame = new CImgMergeFrame();
760 if (!CImgMergeFrame::menu.m_hMenu)
761 CImgMergeFrame::menu.m_hMenu = NewImgMergeViewMenu();
762 pImgMergeFrame->SetSharedMenu(CImgMergeFrame::menu.m_hMenu);
765 for (pane = 0; pane < nFiles; ++pane)
766 files.SetPath(pane, fileloc[pane].filepath, false);
769 for (pane = 0; pane < nFiles; pane++)
772 bRO[pane] = (dwFlags[pane] & FFILEOPEN_READONLY) > 0;
777 int nActivePane = -1;
778 for (pane = 0; pane < nFiles; pane++)
780 if (dwFlags && (dwFlags[pane] & FFILEOPEN_SETFOCUS))
784 pImgMergeFrame->SetDirDoc(pDirDoc);
785 pDirDoc->AddMergeDoc(pImgMergeFrame);
787 if (!pImgMergeFrame->OpenImages(files, bRO, nActivePane, this))
789 ShowMergeDoc(pDirDoc, nFiles, fileloc, dwFlags, infoUnpacker);
793 for (pane = 0; pane < nFiles; pane++)
795 if (dwFlags[pane] & FFILEOPEN_AUTOMERGE)
796 pImgMergeFrame->DoAutoMerge(pane);
804 * @brief Show GNU licence information in notepad (local file) or in Web Browser
806 void CMainFrame::OnHelpGnulicense()
808 const String spath = env_GetProgPath() + LicenseFile;
809 theApp.OpenFileOrUrl(spath.c_str(), LicenceUrl);
813 * @brief Opens Options-dialog and saves changed options
815 void CMainFrame::OnOptions()
817 // Using singleton shared syntax colors
818 CPreferencesDlg dlg(GetOptionsMgr(), theApp.GetMainSyntaxColors());
819 INT_PTR rv = dlg.DoModal();
823 LANGID lang = GetOptionsMgr()->GetInt(OPT_SELECTED_LANGUAGE);
824 if (lang != theApp.m_pLangDlg->GetLangId())
826 theApp.m_pLangDlg->SetLanguage(lang, TRUE);
828 // Update status bar inicator texts
829 theApp.SetIndicators(m_wndStatusBar, 0, 0);
831 // Update the current menu
834 // update the title text of the document
840 // Set new filterpath
841 String filterPath = GetOptionsMgr()->GetString(OPT_FILTER_USERPATH);
842 theApp.m_pGlobalFileFilter->SetUserFilterPath(filterPath);
844 theApp.UpdateCodepageModule();
846 sd_SetBreakChars(GetOptionsMgr()->GetString(OPT_BREAK_SEPARATORS).c_str());
848 // make an attempt at rescanning any open diff sessions
851 // Update all dirdoc settings
852 const DirDocList &dirDocs = GetAllDirDocs();
853 POSITION pos = dirDocs.GetHeadPosition();
856 CDirDoc * pDirDoc = dirDocs.GetNext(pos);
857 pDirDoc->RefreshOptions();
860 const HexMergeDocList &hexdocs = GetAllHexMergeDocs();
861 pos = hexdocs.GetHeadPosition();
864 CHexMergeDoc * pMergeDoc = hexdocs.GetNext(pos);
865 pMergeDoc->RefreshOptions();
870 static bool AddToRecentDocs(const PathContext& paths, const unsigned flags[], bool recurse, const String& filter)
872 String params, title;
873 for (int nIndex = 0; nIndex < paths.GetSize(); ++nIndex)
875 if (flags[nIndex] & FFILEOPEN_READONLY)
879 case 0: params += _T("/wl "); break;
880 case 1: params += paths.GetSize() == 2 ? _T("/wr ") : _T("/wm "); break;
881 case 2: params += _T("/wr "); break;
884 params += _T("\"") + paths[nIndex] + _T("\" ");
886 String path = paths[nIndex];
887 paths_normalize(path);
888 title += paths_FindFileName(path);
889 if (nIndex < paths.GetSize() - 1)
895 params += _T("/f \"") + filter + _T("\" ");
896 return JumpList::AddToRecentDocs(_T(""), params, title, params, 0);
900 * @brief Begin a diff: open dirdoc if it is directories, else open a mergedoc for editing.
901 * @param [in] pszLeft Left-side path.
902 * @param [in] pszRight Right-side path.
903 * @param [in] dwLeftFlags Left-side flags.
904 * @param [in] dwRightFlags Right-side flags.
905 * @param [in] bRecurse Do we run recursive (folder) compare?
906 * @param [in] pDirDoc Dir compare document to use.
907 * @param [in] prediffer Prediffer plugin name.
908 * @return TRUE if opening files and compare succeeded, FALSE otherwise.
910 BOOL CMainFrame::DoFileOpen(const PathContext * pFiles /*=NULL*/,
911 const DWORD dwFlags[] /*=0*/, bool bRecurse /*=FALSE*/, CDirDoc *pDirDoc/*=NULL*/,
912 String prediffer /*=_T("")*/, const PackingInfo *infoUnpacker/*=NULL*/)
914 if (pDirDoc && !pDirDoc->CloseMergeDocs())
917 g_bUnpackerMode = theApp.GetProfileInt(_T("Settings"), _T("UnpackerMode"), PLUGIN_MANUAL);
918 g_bPredifferMode = theApp.GetProfileInt(_T("Settings"), _T("PredifferMode"), PLUGIN_MANUAL);
920 Merge7zFormatMergePluginScope scope(infoUnpacker);
928 bRO[0] = (dwFlags[0] & FFILEOPEN_READONLY) != 0;
929 bRO[1] = (dwFlags[1] & FFILEOPEN_READONLY) != 0;
930 bRO[2] = (dwFlags[2] & FFILEOPEN_READONLY) != 0;
933 // pop up dialog unless arguments exist (and are compatible)
934 PATH_EXISTENCE pathsType = GetPairComparability(files, IsArchiveFile);
935 if (pathsType == DOES_NOT_EXIST)
937 if (!m_pMenus[MENU_OPENVIEW])
938 theApp.m_pOpenTemplate->m_hMenuShared = NewOpenViewMenu();
939 COpenDoc *pOpenDoc = (COpenDoc *)theApp.m_pOpenTemplate->CreateNewDocument();
942 pOpenDoc->m_dwFlags[0] = dwFlags[0];
943 pOpenDoc->m_dwFlags[1] = dwFlags[1];
944 pOpenDoc->m_dwFlags[2] = dwFlags[2];
946 pOpenDoc->m_files = files;
948 pOpenDoc->m_infoHandler = *infoUnpacker;
949 CFrameWnd *pFrame = theApp.m_pOpenTemplate->CreateNewFrame(pOpenDoc, NULL);
950 theApp.m_pOpenTemplate->InitialUpdateFrame(pFrame, pOpenDoc);
955 // Add trailing '\' for directories if its missing
956 if (pathsType == IS_EXISTING_DIR)
958 if (!paths_EndsWithSlash(files[0]) && !IsArchiveFile(files[0]))
960 if (!paths_EndsWithSlash(files[1]) && !IsArchiveFile(files[1]))
962 if (files.GetSize() == 3 && !paths_EndsWithSlash(files[2]) && !IsArchiveFile(files[1]))
966 //save the MRU left and right files.
969 if (!(dwFlags[0] & FFILEOPEN_NOMRU))
970 addToMru(files[0].c_str(), _T("Files\\Left"));
971 if (!(dwFlags[1] & FFILEOPEN_NOMRU))
972 addToMru(files[1].c_str(), _T("Files\\Right"));
973 if (files.GetSize() == 3 && !(dwFlags[2] & FFILEOPEN_NOMRU))
974 addToMru(files[2].c_str(), _T("Files\\Option"));
978 DecompressResult res = DecompressArchive(m_hWnd, files);
979 if (res.pTempPathContext)
981 pathsType = res.pathsType;
985 // Determine if we want new a dirview open now that we know if it was
986 // and archive. Don't open new dirview if we are comparing files.
989 if (pathsType == IS_EXISTING_DIR)
991 CDirDoc::m_nDirsTemp = files.GetSize();
992 if (!m_pMenus[MENU_DIRVIEW])
993 theApp.m_pDirTemplate->m_hMenuShared = NewDirViewMenu();
994 pDirDoc = (CDirDoc*)theApp.m_pDirTemplate->OpenDocumentFile(NULL);
998 pDirDoc = (CDirDoc*)theApp.m_pDirTemplate->CreateNewDocument();
1003 if (pathsType == IS_EXISTING_DIR)
1007 if (files.GetSize() == 3)
1009 AfxMessageBox(_T("3-way folder compare feature is in progress"), MB_ICONWARNING | MB_DONT_ASK_AGAIN);
1011 // Anything that can go wrong inside InitCompare() will yield an
1012 // exception. There is no point in checking return value.
1013 pDirDoc->InitCompare(files, bRecurse, res.pTempPathContext);
1015 pDirDoc->SetDescriptions(theApp.m_strDescriptions);
1016 pDirDoc->SetTitle(NULL);
1017 for (int nIndex = 0; nIndex < files.GetSize(); nIndex++)
1019 pDirDoc->SetReadOnly(nIndex, bRO[nIndex]);
1020 theApp.m_strDescriptions[nIndex].erase();
1028 FileLocation fileloc[3];
1030 for (int nPane = 0; nPane < files.GetSize(); nPane++)
1031 fileloc[nPane].setPath(files[nPane]);
1033 if (!prediffer.empty())
1035 String strBothFilenames = string_join(files.begin(), files.end(), _T("|"));
1036 pDirDoc->SetPluginPrediffer(strBothFilenames, prediffer);
1039 ShowAutoMergeDoc(pDirDoc, files.GetSize(), fileloc, dwFlags,
1043 if (pFiles && !(dwFlags[0] & FFILEOPEN_NOMRU))
1045 String filter = GetOptionsMgr()->GetString(OPT_FILEFILTER_CURRENT);
1046 AddToRecentDocs(*pFiles, (unsigned *)dwFlags, bRecurse, filter);
1052 void CMainFrame::UpdateFont(FRAMETYPE frame)
1054 if (frame == FRAME_FOLDER)
1056 const DirDocList &dirdocs = GetAllDirDocs();
1057 POSITION pos = dirdocs.GetHeadPosition();
1060 CDirDoc * pDoc = dirdocs.GetNext(pos);
1062 pDoc->GetMainView()->SetFont(m_lfDir);
1067 const MergeDocList &mergedocs = GetAllMergeDocs();
1068 POSITION pos = mergedocs.GetHeadPosition();
1071 CMergeDoc * pDoc = mergedocs.GetNext(pos);
1072 for (int pane = 0; pane < pDoc->m_nBuffers; pane++)
1074 CMergeEditView * pView = pDoc->GetView(pane);
1075 CMergeEditView * pDetailView = pDoc->GetDetailView(pane);
1077 pView->SetFont(m_lfDiff);
1079 pDetailView->SetFont(m_lfDiff);
1086 * @brief Select font for Merge/Dir view
1088 * Shows font selection dialog to user, sets current font and saves
1089 * selected font properties to registry. Selects fon type to active
1090 * view (Merge/Dir compare). If there is no open views, then font
1091 * is selected for Merge view (for example user may want to change to
1092 * unicode font before comparing files).
1094 void CMainFrame::OnViewSelectfont()
1096 FRAMETYPE frame = GetFrameType(GetActiveFrame());
1099 ZeroMemory(&cf, sizeof(CHOOSEFONT));
1100 cf.lStructSize = sizeof(CHOOSEFONT);
1101 cf.Flags = CF_INITTOLOGFONTSTRUCT|CF_FORCEFONTEXIST|CF_SCREENFONTS;
1102 if (frame == FRAME_FILE)
1103 cf.Flags |= CF_FIXEDPITCHONLY; // Only fixed-width fonts for merge view
1105 // CF_FIXEDPITCHONLY = 0x00004000L
1106 // in case you are a developer and want to disable it to test with, eg, a Chinese capable font
1107 if (frame == FRAME_FOLDER)
1114 if (ChooseFont(&cf))
1116 Options::Font::Save(frame == FRAME_FOLDER ? OPT_FONT_DIRCMP : OPT_FONT_FILECMP, lf, true);
1122 * @brief Enable 'Select font'.
1124 void CMainFrame::OnUpdateViewSelectfont(CCmdUI* pCmdUI)
1126 pCmdUI->Enable(TRUE);
1130 * @brief Use default font for active view type
1132 * Disable user-selected font for active view type (Merge/Dir compare).
1133 * If there is no open views, then Merge view font is changed.
1135 void CMainFrame::OnViewUsedefaultfont()
1137 FRAMETYPE frame = GetFrameType(GetActiveFrame());
1139 if (frame == FRAME_FOLDER)
1141 Options::Font::Reset(OPT_FONT_DIRCMP);
1142 m_lfDir = Options::Font::Load(OPT_FONT_DIRCMP);
1143 Options::Font::Save(OPT_FONT_DIRCMP, &m_lfDir, false);
1147 Options::Font::Reset(OPT_FONT_FILECMP);
1148 m_lfDiff = Options::Font::Load(OPT_FONT_FILECMP);
1149 Options::Font::Save(OPT_FONT_FILECMP, &m_lfDiff, false);
1156 * @brief Enable 'Use Default font'.
1158 void CMainFrame::OnUpdateViewUsedefaultfont(CCmdUI* pCmdUI)
1160 pCmdUI->Enable(TRUE);
1164 * @brief Update any resources necessary after a GUI language change
1166 void CMainFrame::UpdateResources()
1168 m_wndStatusBar.SetPaneText(0, theApp.LoadString(AFX_IDS_IDLEMESSAGE).c_str());
1170 const DirDocList &dirdocs = GetAllDirDocs();
1171 POSITION pos = dirdocs.GetHeadPosition();
1174 CDirDoc * pDoc = dirdocs.GetNext(pos);
1175 pDoc->UpdateResources();
1178 const MergeDocList &mergedocs = GetAllMergeDocs();
1179 pos = mergedocs.GetHeadPosition();
1182 CMergeDoc * pDoc = mergedocs.GetNext(pos);
1183 pDoc->UpdateResources();
1188 * @brief Open WinMerge help.
1190 * If local HTMLhelp file is found, open it, otherwise open HTML page from web.
1192 void CMainFrame::OnHelpContents()
1198 * @brief Enable Open WinMerge help -menuitem.
1200 void CMainFrame::OnUpdateHelpContents(CCmdUI* pCmdUI)
1202 pCmdUI->Enable(TRUE);
1206 * @brief Handle translation of default messages on the status bar
1208 void CMainFrame::GetMessageString(UINT nID, CString& rMessage) const
1210 // load appropriate string
1211 const String s = theApp.LoadString(nID);
1213 AfxExtractSubString(rMessage, s.c_str(), 0);
1216 void CMainFrame::ActivateFrame(int nCmdShow)
1220 CMDIFrameWnd::ActivateFrame(nCmdShow);
1224 m_bFirstTime = FALSE;
1227 wp.length = sizeof(WINDOWPLACEMENT);
1228 GetWindowPlacement(&wp);
1229 wp.rcNormalPosition.left=theApp.GetProfileInt(_T("Settings"), _T("MainLeft"),0);
1230 wp.rcNormalPosition.top=theApp.GetProfileInt(_T("Settings"), _T("MainTop"),0);
1231 wp.rcNormalPosition.right=theApp.GetProfileInt(_T("Settings"), _T("MainRight"),0);
1232 wp.rcNormalPosition.bottom=theApp.GetProfileInt(_T("Settings"), _T("MainBottom"),0);
1233 if (nCmdShow != SW_MINIMIZE && theApp.GetProfileInt(_T("Settings"), _T("MainMax"), FALSE))
1234 wp.showCmd = SW_MAXIMIZE;
1236 wp.showCmd = nCmdShow;
1238 CRect dsk_rc,rc(wp.rcNormalPosition);
1240 dsk_rc.left = ::GetSystemMetrics(SM_XVIRTUALSCREEN);
1241 dsk_rc.top = ::GetSystemMetrics(SM_YVIRTUALSCREEN);
1242 dsk_rc.right = dsk_rc.left + ::GetSystemMetrics(SM_CXVIRTUALSCREEN);
1243 dsk_rc.bottom = dsk_rc.top + ::GetSystemMetrics(SM_CYVIRTUALSCREEN);
1244 if (rc.Width() != 0 && rc.Height() != 0)
1246 // Ensure top-left corner is on visible area,
1247 // 20 points margin is added to prevent "lost" window
1248 CPoint ptTopLeft(rc.TopLeft());
1249 ptTopLeft += CPoint(20, 20);
1251 if (dsk_rc.PtInRect(ptTopLeft))
1252 SetWindowPlacement(&wp);
1254 CMDIFrameWnd::ActivateFrame(nCmdShow);
1257 CMDIFrameWnd::ActivateFrame(nCmdShow);
1261 * @brief Called when mainframe is about to be closed.
1262 * This function is called when mainframe is to be closed (not for
1263 * file/compare windows.
1265 void CMainFrame::OnClose()
1267 if (theApp.GetActiveOperations())
1270 // Check if there are multiple windows open and ask for closing them
1271 BOOL bAskClosing = GetOptionsMgr()->GetBool(OPT_ASK_MULTIWINDOW_CLOSE);
1274 bool quit = AskCloseConfirmation();
1279 // Save last selected filter
1280 String filter = theApp.m_pGlobalFileFilter->GetFilterNameOrMask();
1281 GetOptionsMgr()->SaveOption(OPT_FILEFILTER_CURRENT, filter);
1283 // save main window position
1285 wp.length = sizeof(WINDOWPLACEMENT);
1286 GetWindowPlacement(&wp);
1287 theApp.WriteProfileInt(_T("Settings"), _T("MainLeft"),wp.rcNormalPosition.left);
1288 theApp.WriteProfileInt(_T("Settings"), _T("MainTop"),wp.rcNormalPosition.top);
1289 theApp.WriteProfileInt(_T("Settings"), _T("MainRight"),wp.rcNormalPosition.right);
1290 theApp.WriteProfileInt(_T("Settings"), _T("MainBottom"),wp.rcNormalPosition.bottom);
1291 theApp.WriteProfileInt(_T("Settings"), _T("MainMax"), (wp.showCmd == SW_MAXIMIZE));
1293 // Close Non-Document/View frame with confirmation
1294 CMDIChildWnd *pChild = static_cast<CMDIChildWnd *>(CWnd::FromHandle(m_hWndMDIClient)->GetWindow(GW_CHILD));
1297 CMDIChildWnd *pNextChild = static_cast<CMDIChildWnd *>(pChild->GetWindow(GW_HWNDNEXT));
1298 if (GetFrameType(pChild) == FRAME_IMGFILE)
1300 if (!static_cast<CImgMergeFrame *>(pChild)->CloseNow())
1303 pChild = pNextChild;
1306 CMDIFrameWnd::OnClose();
1310 * @brief Utility function to update CSuperComboBox format MRU
1312 void CMainFrame::addToMru(LPCTSTR szItem, LPCTSTR szRegSubKey, UINT nMaxItems)
1314 std::vector<CString> list;
1316 UINT cnt = AfxGetApp()->GetProfileInt(szRegSubKey, _T("Count"), 0);
1317 list.push_back(szItem);
1318 for (UINT i=0 ; i<cnt; ++i)
1320 s2.Format(_T("Item_%d"), i);
1321 s = AfxGetApp()->GetProfileString(szRegSubKey, s2);
1325 cnt = list.size() > nMaxItems ? nMaxItems : static_cast<UINT>(list.size());
1326 for (UINT i=0 ; i<cnt; ++i)
1328 s2.Format(_T("Item_%d"), i);
1329 AfxGetApp()->WriteProfileString(szRegSubKey, s2, list[i]);
1332 AfxGetApp()->WriteProfileInt(szRegSubKey, _T("Count"), cnt);
1335 void CMainFrame::ApplyDiffOptions()
1337 const MergeDocList &docs = GetAllMergeDocs();
1338 POSITION pos = docs.GetHeadPosition();
1341 CMergeDoc * pMergeDoc = docs.GetNext(pos);
1342 // Re-read MergeDoc settings (also updates view settings)
1343 // and rescan using new options
1344 pMergeDoc->RefreshOptions();
1345 pMergeDoc->FlushAndRescan(TRUE);
1349 /// Get list of OpenDocs (documents underlying edit sessions)
1350 const OpenDocList &CMainFrame::GetAllOpenDocs()
1352 return static_cast<const OpenDocList &>(GetDocList(theApp.m_pOpenTemplate));
1355 /// Get list of MergeDocs (documents underlying edit sessions)
1356 const MergeDocList &CMainFrame::GetAllMergeDocs()
1358 return static_cast<const MergeDocList &>(GetDocList(theApp.m_pDiffTemplate));
1361 /// Get list of DirDocs (documents underlying a scan)
1362 const DirDocList &CMainFrame::GetAllDirDocs()
1364 return static_cast<const DirDocList &>(GetDocList(theApp.m_pDirTemplate));
1367 /// Get list of HexMergeDocs (documents underlying edit sessions)
1368 const HexMergeDocList &CMainFrame::GetAllHexMergeDocs()
1370 return static_cast<const HexMergeDocList &>(GetDocList(theApp.m_pHexMergeTemplate));
1374 * @brief Obtain a merge doc to display a difference in files.
1375 * @return Pointer to CMergeDoc to use.
1377 template<class DocClass>
1378 DocClass * GetMergeDocForDiff(CMultiDocTemplate *pTemplate, CDirDoc *pDirDoc, int nFiles)
1380 // Create a new merge doc
1381 DocClass::m_nBuffersTemp = nFiles;
1382 DocClass *pMergeDoc = (DocClass*)pTemplate->OpenDocumentFile(NULL);
1385 pDirDoc->AddMergeDoc(pMergeDoc);
1386 pMergeDoc->SetDirDoc(pDirDoc);
1391 // Set status in the main status pane
1392 CString CMainFrame::SetStatus(LPCTSTR status)
1394 CString old = m_wndStatusBar.GetPaneText(0);
1395 m_wndStatusBar.SetPaneText(0, status);
1399 // Clear the item count in the main status pane
1400 void CMainFrame::ClearStatusbarItemCount()
1402 m_wndStatusBar.SetPaneText(2, _T(""));
1406 * @brief Generate patch from files selected.
1408 * Creates a patch from selected files in active directory compare, or
1409 * active file compare. Files in file compare must be saved before
1412 void CMainFrame::OnToolsGeneratePatch()
1415 CFrameWnd * pFrame = GetActiveFrame();
1416 FRAMETYPE frame = GetFrameType(pFrame);
1417 BOOL bOpenDialog = TRUE;
1420 if (frame == FRAME_FILE)
1422 CMergeDoc * pMergeDoc = (CMergeDoc *) pFrame->GetActiveDocument();
1423 // If there are changes in files, tell user to save them first
1424 BOOL bModified = FALSE;
1425 for (int pane = 0; pane < pMergeDoc->m_nBuffers; pane++)
1427 if (pMergeDoc->m_ptBuf[pane]->IsModified())
1432 bOpenDialog = FALSE;
1433 LangMessageBox(IDS_SAVEFILES_FORPATCH, MB_ICONSTOP);
1437 patcher.AddFiles(pMergeDoc->m_filePaths.GetLeft(),
1438 pMergeDoc->m_filePaths.GetRight());
1442 else if (frame == FRAME_FOLDER)
1444 CDirDoc * pDoc = (CDirDoc*)pFrame->GetActiveDocument();
1445 CDirView *pView = pDoc->GetMainView();
1447 // Get selected items from folder compare
1448 BOOL bValidFiles = TRUE;
1449 int ind = pView->GetFirstSelectedInd();
1450 while (ind != -1 && bValidFiles)
1452 const DIFFITEM &item = pView->GetItemAt(ind);
1453 if (item.diffcode.isBin())
1455 LangMessageBox(IDS_CANNOT_CREATE_BINARYPATCH, MB_ICONWARNING |
1456 MB_DONT_DISPLAY_AGAIN, IDS_CANNOT_CREATE_BINARYPATCH);
1457 bValidFiles = FALSE;
1459 else if (item.diffcode.isDirectory())
1461 LangMessageBox(IDS_CANNOT_CREATE_DIRPATCH, MB_ICONWARNING |
1462 MB_DONT_DISPLAY_AGAIN, IDS_CANNOT_CREATE_DIRPATCH);
1463 bValidFiles = FALSE;
1468 // Format full paths to files (leftFile/rightFile)
1469 String leftFile = item.getFilepath(0, pDoc->GetBasePath(0));
1470 if (!leftFile.empty())
1471 leftFile = paths_ConcatPath(leftFile, item.diffFileInfo[0].filename);
1472 String rightFile = item.getFilepath(1, pDoc->GetBasePath(1));
1473 if (!rightFile.empty())
1474 rightFile = paths_ConcatPath(rightFile, item.diffFileInfo[1].filename);
1476 // Format relative paths to files in folder compare
1477 String leftpatch = item.diffFileInfo[0].path;
1478 if (!leftpatch.empty())
1479 leftpatch += _T("/");
1480 leftpatch += item.diffFileInfo[0].filename;
1481 String rightpatch = item.diffFileInfo[1].path;
1482 if (!rightpatch.empty())
1483 rightpatch += _T("/");
1484 rightpatch += item.diffFileInfo[1].filename;
1485 patcher.AddFiles(leftFile, leftpatch, rightFile, rightpatch);
1486 pView->GetNextSelectedInd(ind);
1493 if (patcher.CreatePatch())
1495 if (patcher.GetOpenToEditor())
1497 theApp.OpenFileToExternalEditor(patcher.GetPatchFile().c_str());
1503 void CMainFrame::OnDropFiles(const std::vector<String>& dropped_files)
1505 PathContext files(dropped_files);
1506 const size_t fileCount = files.GetSize();
1508 // If Ctrl pressed, do recursive compare
1509 bool recurse = !!::GetAsyncKeyState(VK_CONTROL) || !!theApp.GetProfileInt(_T("Settings"), _T("Recurse"), 0);
1511 // If user has <Shift> pressed with one file selected,
1512 // assume it is an archive and set filenames to same
1513 if (::GetAsyncKeyState(VK_SHIFT) < 0 && fileCount == 1)
1515 files.SetRight(files[0]);
1518 // Check if they dropped a project file
1519 DWORD dwFlags[3] = {FFILEOPEN_NONE, FFILEOPEN_NONE, FFILEOPEN_NONE};
1522 if (theApp.IsProjectFile(files[0].c_str()))
1524 theApp.LoadAndOpenProjectFile(files[0].c_str());
1527 if (IsConflictFile(files[0]))
1529 DoOpenConflict(files[0], true);
1534 DoFileOpen(&files, dwFlags, recurse);
1537 void CMainFrame::OnPluginUnpackMode(UINT nID )
1541 case ID_UNPACK_MANUAL:
1542 g_bUnpackerMode = PLUGIN_MANUAL;
1544 case ID_UNPACK_AUTO:
1545 g_bUnpackerMode = PLUGIN_AUTO;
1548 theApp.WriteProfileInt(_T("Settings"), _T("UnpackerMode"), g_bUnpackerMode);
1551 void CMainFrame::OnUpdatePluginUnpackMode(CCmdUI* pCmdUI)
1553 if (GetOptionsMgr()->GetBool(OPT_PLUGINS_ENABLED))
1554 pCmdUI->Enable(TRUE);
1556 pCmdUI->Enable(FALSE);
1558 if (pCmdUI->m_nID == ID_UNPACK_MANUAL)
1559 pCmdUI->SetRadio(PLUGIN_MANUAL == g_bUnpackerMode);
1560 if (pCmdUI->m_nID == ID_UNPACK_AUTO)
1561 pCmdUI->SetRadio(PLUGIN_AUTO == g_bUnpackerMode);
1563 void CMainFrame::OnPluginPrediffMode(UINT nID )
1567 case ID_PREDIFFER_MANUAL:
1568 g_bPredifferMode = PLUGIN_MANUAL;
1570 case ID_PREDIFFER_AUTO:
1571 g_bPredifferMode = PLUGIN_AUTO;
1574 PrediffingInfo infoPrediffer;
1575 const MergeDocList &mergedocs = GetAllMergeDocs();
1576 POSITION pos = mergedocs.GetHeadPosition();
1578 mergedocs.GetNext(pos)->SetPrediffer(&infoPrediffer);
1579 const DirDocList &dirdocs = GetAllDirDocs();
1580 pos = dirdocs.GetHeadPosition();
1582 dirdocs.GetNext(pos)->SetPluginPrediffSettingAll(g_bPredifferMode);
1583 theApp.WriteProfileInt(_T("Settings"), _T("PredifferMode"), g_bPredifferMode);
1586 void CMainFrame::OnUpdatePluginPrediffMode(CCmdUI* pCmdUI)
1588 if (GetOptionsMgr()->GetBool(OPT_PLUGINS_ENABLED))
1589 pCmdUI->Enable(TRUE);
1591 pCmdUI->Enable(FALSE);
1593 if (pCmdUI->m_nID == ID_PREDIFFER_MANUAL)
1594 pCmdUI->SetRadio(PLUGIN_MANUAL == g_bPredifferMode);
1595 if (pCmdUI->m_nID == ID_PREDIFFER_AUTO)
1596 pCmdUI->SetRadio(PLUGIN_AUTO == g_bPredifferMode);
1599 * @brief Called when "Reload Plugins" item is updated
1601 void CMainFrame::OnUpdateReloadPlugins(CCmdUI* pCmdUI)
1603 if (GetOptionsMgr()->GetBool(OPT_PLUGINS_ENABLED))
1604 pCmdUI->Enable(TRUE);
1606 pCmdUI->Enable(FALSE);
1609 void CMainFrame::OnReloadPlugins()
1611 // delete all script interfaces
1612 // (interfaces will be created again automatically when WinMerge needs them)
1613 CAllThreadsScripts::GetActiveSet()->FreeAllScripts();
1615 // update the editor scripts submenu
1616 HMENU scriptsSubmenu = GetScriptsSubmenu(m_hMenuDefault);
1617 if (scriptsSubmenu != NULL)
1618 CMergeEditView::createScriptsSubmenu(scriptsSubmenu);
1619 UpdatePrediffersMenu();
1622 /** @brief Return active merge edit view, if can figure it out/is available */
1623 CMergeEditView * CMainFrame::GetActiveMergeEditView()
1625 // NB: GetActiveDocument does not return the Merge Doc
1626 // even when the merge edit view is in front
1627 // NB: CChildFrame::GetActiveView returns NULL when location view active
1628 // So we have this rather complicated logic to try to get a merge edit view
1629 // We look at the front child window, which should be a frame
1630 // and we can get a MergeEditView from it, if it is a CChildFrame
1631 // (DirViews use a different frame type)
1632 CChildFrame * pFrame = dynamic_cast<CChildFrame *>(GetActiveFrame());
1633 if (!pFrame) return 0;
1634 // Try to get the active MergeEditView (ie, left or right)
1635 if (pFrame->GetActiveView() && pFrame->GetActiveView()->IsKindOf(RUNTIME_CLASS(CMergeEditView)))
1637 return dynamic_cast<CMergeEditView *>(pFrame->GetActiveView());
1639 return pFrame->GetMergeDoc()->GetActiveMergeView();
1642 void CMainFrame::UpdatePrediffersMenu()
1644 CMenu* menu = GetMenu();
1650 HMENU hMainMenu = menu->m_hMenu;
1651 HMENU prediffersSubmenu = GetPrediffersSubmenu(hMainMenu);
1652 if (prediffersSubmenu != NULL)
1654 CMergeEditView * pEditView = GetActiveMergeEditView();
1656 pEditView->createPrediffersSubmenu(prediffersSubmenu);
1659 // no view or dir view : display an empty submenu
1660 int i = GetMenuItemCount(prediffersSubmenu);
1662 ::DeleteMenu(prediffersSubmenu, 0, MF_BYPOSITION);
1663 ::AppendMenu(prediffersSubmenu, MF_SEPARATOR, 0, NULL);
1669 * @brief Save WinMerge configuration and info to file
1671 void CMainFrame::OnSaveConfigData()
1673 CConfigLog configLog;
1676 if (configLog.WriteLogFile(sError))
1678 String sFileName = configLog.GetFileName();
1679 theApp.OpenFileToExternalEditor(sFileName);
1683 String sFileName = configLog.GetFileName();
1684 String msg = LangFormatString2(IDS_ERROR_FILEOPEN, sFileName.c_str(), sError.c_str());
1685 AfxMessageBox(msg.c_str(), MB_OK | MB_ICONSTOP);
1690 * @brief Open two new empty docs, 'Scratchpads'
1692 * Allows user to open two empty docs, to paste text to
1693 * compare from clipboard.
1694 * @note File filenames are set emptys and filedescriptors
1695 * are loaded from resource.
1696 * @sa CMergeDoc::OpenDocs()
1697 * @sa CMergeDoc::TrySaveAs()
1699 void CMainFrame::FileNew(int nPanes)
1701 CDirDoc *pDirDoc = (CDirDoc*)theApp.m_pDirTemplate->CreateNewDocument();
1703 // Load emptyfile descriptors and open empty docs
1704 // Use default codepage
1705 DWORD dwFlags[3] = {0, 0, 0};
1706 FileLocation fileloc[3];
1709 theApp.m_strDescriptions[0] = theApp.LoadString(IDS_EMPTY_LEFT_FILE);
1710 theApp.m_strDescriptions[1] = theApp.LoadString(IDS_EMPTY_RIGHT_FILE);
1711 fileloc[0].encoding.SetCodepage(ucr::getDefaultCodepage());
1712 fileloc[1].encoding.SetCodepage(ucr::getDefaultCodepage());
1713 ShowMergeDoc(pDirDoc, 2, fileloc, dwFlags);
1717 theApp.m_strDescriptions[0] = theApp.LoadString(IDS_EMPTY_LEFT_FILE);
1718 theApp.m_strDescriptions[1] = theApp.LoadString(IDS_EMPTY_MIDDLE_FILE);
1719 theApp.m_strDescriptions[2] = theApp.LoadString(IDS_EMPTY_RIGHT_FILE);
1720 fileloc[0].encoding.SetCodepage(ucr::getDefaultCodepage());
1721 fileloc[1].encoding.SetCodepage(ucr::getDefaultCodepage());
1722 fileloc[2].encoding.SetCodepage(ucr::getDefaultCodepage());
1723 ShowMergeDoc(pDirDoc, 3, fileloc, dwFlags);
1726 // Empty descriptors now that docs are open
1727 theApp.m_strDescriptions[0].erase();
1728 theApp.m_strDescriptions[1].erase();
1729 theApp.m_strDescriptions[2].erase();
1733 * @brief Open two new empty docs, 'Scratchpads'
1735 * Allows user to open two empty docs, to paste text to
1736 * compare from clipboard.
1737 * @note File filenames are set emptys and filedescriptors
1738 * are loaded from resource.
1739 * @sa CMergeDoc::OpenDocs()
1740 * @sa CMergeDoc::TrySaveAs()
1742 void CMainFrame::OnFileNew()
1747 void CMainFrame::OnFileNew3()
1753 * @brief Open Filters dialog
1755 void CMainFrame::OnToolsFilters()
1757 String title = theApp.LoadString(IDS_FILTER_TITLE);
1758 CPropertySheet sht(title.c_str());
1759 LineFiltersDlg lineFiltersDlg;
1760 FileFiltersDlg fileFiltersDlg;
1761 vector<FileFilterInfo> fileFilters;
1762 std::unique_ptr<LineFiltersList> lineFilters(new LineFiltersList());
1763 String selectedFilter;
1764 const String origFilter = theApp.m_pGlobalFileFilter->GetFilterNameOrMask();
1765 sht.AddPage(&fileFiltersDlg);
1766 sht.AddPage(&lineFiltersDlg);
1767 sht.m_psh.dwFlags |= PSH_NOAPPLYNOW; // Hide 'Apply' button since we don't need it
1769 // Make sure all filters are up-to-date
1770 theApp.m_pGlobalFileFilter->ReloadUpdatedFilters();
1772 theApp.m_pGlobalFileFilter->GetFileFilters(&fileFilters, selectedFilter);
1773 fileFiltersDlg.SetFilterArray(&fileFilters);
1774 fileFiltersDlg.SetSelected(selectedFilter);
1775 const BOOL lineFiltersEnabledOrig = GetOptionsMgr()->GetBool(OPT_LINEFILTER_ENABLED);
1776 lineFiltersDlg.m_bIgnoreRegExp = lineFiltersEnabledOrig;
1778 lineFilters->CloneFrom(theApp.m_pLineFilters.get());
1779 lineFiltersDlg.SetList(lineFilters.get());
1781 if (sht.DoModal() == IDOK)
1783 String strNone = theApp.LoadString(IDS_USERCHOICE_NONE);
1784 String path = fileFiltersDlg.GetSelected();
1785 if (path.find(strNone) != String::npos)
1787 // Don't overwrite mask we already have
1788 if (!theApp.m_pGlobalFileFilter->IsUsingMask())
1790 String sFilter(_T("*.*"));
1791 theApp.m_pGlobalFileFilter->SetFilter(sFilter);
1792 GetOptionsMgr()->SaveOption(OPT_FILEFILTER_CURRENT, sFilter);
1797 theApp.m_pGlobalFileFilter->SetFileFilterPath(path);
1798 theApp.m_pGlobalFileFilter->UseMask(FALSE);
1799 String sFilter = theApp.m_pGlobalFileFilter->GetFilterNameOrMask();
1800 GetOptionsMgr()->SaveOption(OPT_FILEFILTER_CURRENT, sFilter);
1802 BOOL linefiltersEnabled = lineFiltersDlg.m_bIgnoreRegExp;
1803 GetOptionsMgr()->SaveOption(OPT_LINEFILTER_ENABLED, linefiltersEnabled == TRUE);
1805 // Check if compare documents need rescanning
1806 BOOL bFileCompareRescan = FALSE;
1807 BOOL bFolderCompareRescan = FALSE;
1808 CFrameWnd * pFrame = GetActiveFrame();
1809 FRAMETYPE frame = GetFrameType(pFrame);
1810 if (frame == FRAME_FILE)
1812 if (lineFiltersEnabledOrig != linefiltersEnabled ||
1813 !theApp.m_pLineFilters->Compare(lineFilters.get()))
1815 bFileCompareRescan = TRUE;
1818 else if (frame == FRAME_FOLDER)
1820 const String newFilter = theApp.m_pGlobalFileFilter->GetFilterNameOrMask();
1821 if (lineFiltersEnabledOrig != linefiltersEnabled ||
1822 !theApp.m_pLineFilters->Compare(lineFilters.get()) || origFilter != newFilter)
1824 int res = LangMessageBox(IDS_FILTERCHANGED, MB_ICONWARNING | MB_YESNO);
1826 bFolderCompareRescan = TRUE;
1830 // Save new filters before (possibly) rescanning
1831 theApp.m_pLineFilters->CloneFrom(lineFilters.get());
1832 theApp.m_pLineFilters->SaveFilters();
1834 if (bFileCompareRescan)
1836 const MergeDocList &docs = GetAllMergeDocs();
1837 POSITION pos = docs.GetHeadPosition();
1840 CMergeDoc * pMergeDoc = docs.GetNext(pos);
1841 pMergeDoc->FlushAndRescan(TRUE);
1844 else if (bFolderCompareRescan)
1846 const DirDocList &dirDocs = GetAllDirDocs();
1847 POSITION pos = dirDocs.GetHeadPosition();
1850 CDirDoc * pDirDoc = dirDocs.GetNext(pos);
1858 * @brief Open Filters dialog.
1860 void CMainFrame::SelectFilter()
1866 * @brief Closes application with ESC.
1868 * Application is closed if:
1869 * - 'Close Windows with ESC' option is enabled and
1870 * there is no open document windows
1871 * - '-e' commandline switch is given
1873 BOOL CMainFrame::PreTranslateMessage(MSG* pMsg)
1875 // Check if we got 'ESC pressed' -message
1876 if ((pMsg->message == WM_KEYDOWN) && (pMsg->wParam == VK_ESCAPE))
1878 if (theApp.m_bEscShutdown && m_wndTabBar.GetItemCount() <= 1)
1880 AfxGetMainWnd()->PostMessage(WM_COMMAND, ID_APP_EXIT);
1883 else if (GetOptionsMgr()->GetBool(OPT_CLOSE_WITH_ESC) && m_wndTabBar.GetItemCount() == 0)
1885 AfxGetMainWnd()->PostMessage(WM_COMMAND, ID_APP_EXIT);
1889 return CMDIFrameWnd::PreTranslateMessage(pMsg);
1893 * @brief Show/hide statusbar.
1895 void CMainFrame::OnViewStatusBar()
1897 bool bShow = !GetOptionsMgr()->GetBool(OPT_SHOW_STATUSBAR);
1898 GetOptionsMgr()->SaveOption(OPT_SHOW_STATUSBAR, bShow);
1900 CMDIFrameWnd::ShowControlBar(&m_wndStatusBar, bShow, 0);
1904 * @brief Updates "Show Tabbar" menuitem.
1906 void CMainFrame::OnUpdateViewTabBar(CCmdUI* pCmdUI)
1908 pCmdUI->SetCheck(GetOptionsMgr()->GetBool(OPT_SHOW_TABBAR));
1912 * @brief Show/hide tabbar.
1914 void CMainFrame::OnViewTabBar()
1916 bool bShow = !GetOptionsMgr()->GetBool(OPT_SHOW_TABBAR);
1917 GetOptionsMgr()->SaveOption(OPT_SHOW_TABBAR, bShow);
1919 CMDIFrameWnd::ShowControlBar(&m_wndTabBar, bShow, 0);
1923 * @brief Updates "Automatically Resize Panes" menuitem.
1925 void CMainFrame::OnUpdateResizePanes(CCmdUI* pCmdUI)
1927 pCmdUI->SetCheck(GetOptionsMgr()->GetBool(OPT_RESIZE_PANES));
1932 * @brief Enable/disable automatic pane resizing.
1934 void CMainFrame::OnResizePanes()
1936 bool bResize = !GetOptionsMgr()->GetBool(OPT_RESIZE_PANES);
1937 GetOptionsMgr()->SaveOption(OPT_RESIZE_PANES, bResize);
1938 // TODO: Introduce a common merge frame superclass?
1939 CFrameWnd *pActiveFrame = GetActiveFrame();
1940 if (CChildFrame *pFrame = DYNAMIC_DOWNCAST(CChildFrame, pActiveFrame))
1942 pFrame->UpdateAutoPaneResize();
1944 pFrame->UpdateSplitter();
1946 else if (CHexMergeFrame *pFrame = DYNAMIC_DOWNCAST(CHexMergeFrame, pActiveFrame))
1948 pFrame->UpdateAutoPaneResize();
1950 pFrame->UpdateSplitter();
1955 * @brief Open project-file.
1957 void CMainFrame::OnFileOpenproject()
1961 // get the default projects path
1962 String strProjectPath = GetOptionsMgr()->GetString(OPT_PROJECTS_PATH);
1963 if (!SelectFile(GetSafeHwnd(), sFilepath, strProjectPath.c_str(), IDS_OPEN_TITLE,
1964 IDS_PROJECTFILES, TRUE))
1967 strProjectPath = paths_GetParentPath(sFilepath);
1968 // store this as the new project path
1969 GetOptionsMgr()->SaveOption(OPT_PROJECTS_PATH, strProjectPath);
1971 theApp.LoadAndOpenProjectFile(sFilepath.c_str());
1975 * @brief Receive command line from another instance.
1977 * This function receives command line when only single-instance
1978 * is allowed. New instance tried to start sends its command line
1979 * to here so we can open paths it was meant to.
1981 LRESULT CMainFrame::OnCopyData(WPARAM wParam, LPARAM lParam)
1983 COPYDATASTRUCT *pCopyData = (COPYDATASTRUCT*)lParam;
1984 LPCTSTR pchData = (LPCTSTR)pCopyData->lpData;
1985 // Bail out if data isn't zero-terminated
1986 DWORD cchData = pCopyData->cbData / sizeof(TCHAR);
1987 if (cchData == 0 || pchData[cchData - 1] != _T('\0'))
1990 MergeCmdLineInfo cmdInfo = pchData;
1991 theApp.ParseArgsAndDoOpen(cmdInfo, this);
1995 LRESULT CMainFrame::OnUser1(WPARAM wParam, LPARAM lParam)
1997 CFrameWnd * pFrame = GetActiveFrame();
2000 IMergeDoc *pMergeDoc = dynamic_cast<IMergeDoc *>(pFrame->GetActiveDocument());
2002 pMergeDoc = dynamic_cast<IMergeDoc *>(pFrame);
2004 pMergeDoc->CheckFileChanged();
2010 * @brief Handle timer events.
2011 * @param [in] nIDEvent Timer that timed out.
2013 void CMainFrame::OnTimer(UINT_PTR nIDEvent)
2017 case WM_NONINTERACTIVE:
2018 KillTimer(WM_NONINTERACTIVE);
2019 PostMessage(WM_CLOSE);
2022 case ID_TIMER_FLASH:
2023 // This timer keeps running until window is activated
2028 CMDIFrameWnd::OnTimer(nIDEvent);
2032 * @brief Close all open windows.
2034 * Asks about saving unsaved files and then closes all open windows.
2036 void CMainFrame::OnWindowCloseAll()
2038 CMDIChildWnd *pChild = MDIGetActive();
2042 if ((pDoc = pChild->GetActiveDocument()) != NULL)
2044 if (!pDoc->SaveModified())
2046 pDoc->OnCloseDocument();
2048 else if (GetFrameType(pChild) == FRAME_IMGFILE)
2050 if (!static_cast<CImgMergeFrame *>(pChild)->CloseNow())
2055 pChild->DestroyWindow();
2057 pChild = MDIGetActive();
2063 * @brief Enables Window/Close All item if there are open windows.
2065 void CMainFrame::OnUpdateWindowCloseAll(CCmdUI* pCmdUI)
2067 const MergeDocList &mergedocs = GetAllMergeDocs();
2068 if (!mergedocs.IsEmpty())
2070 pCmdUI->Enable(TRUE);
2074 const DirDocList &dirdocs = GetAllDirDocs();
2075 if (!dirdocs.IsEmpty())
2076 pCmdUI->Enable(TRUE);
2078 pCmdUI->Enable(FALSE);
2082 * @brief Access to the singleton main frame (where we have some globals)
2084 CMainFrame * GetMainFrame()
2086 CWnd * mainwnd = AfxGetMainWnd();
2088 CMainFrame *pMainframe = dynamic_cast<CMainFrame*>(mainwnd);
2094 * @brief Opens dialog for user to Load, edit and save project files.
2095 * This dialog gets current compare paths and filter (+other properties
2096 * possible in project files) and initializes the dialog with them.
2098 void CMainFrame::OnSaveProject()
2100 String title = theApp.LoadString(IDS_PROJFILEDLG_CAPTION);
2101 CPropertySheet sht(title.c_str());
2102 ProjectFilePathsDlg pathsDlg;
2103 sht.AddPage(&pathsDlg);
2104 sht.m_psh.dwFlags |= PSH_NOAPPLYNOW; // Hide 'Apply' button since we don't need it
2108 CFrameWnd * pFrame = GetActiveFrame();
2109 FRAMETYPE frame = GetFrameType(pFrame);
2111 if (frame == FRAME_FILE)
2113 CMergeDoc * pMergeDoc = (CMergeDoc *) pFrame->GetActiveDocument();
2114 left = pMergeDoc->m_filePaths.GetLeft();
2115 right = pMergeDoc->m_filePaths.GetRight();
2116 pathsDlg.SetPaths(left.c_str(), right.c_str());
2117 pathsDlg.m_bLeftPathReadOnly = pMergeDoc->m_ptBuf[0]->GetReadOnly();
2118 pathsDlg.m_bRightPathReadOnly = pMergeDoc->m_ptBuf[1]->GetReadOnly();
2120 else if (frame == FRAME_FOLDER)
2122 // Get paths currently in compare
2123 CDirDoc * pDoc = (CDirDoc*)pFrame->GetActiveDocument();
2124 left = pDoc->GetLeftBasePath();
2125 right = pDoc->GetRightBasePath();
2126 if (!paths_EndsWithSlash(left))
2128 if (!paths_EndsWithSlash(right))
2131 // Set-up the dialog
2132 pathsDlg.SetPaths(left.c_str(), right.c_str());
2133 pathsDlg.m_bIncludeSubfolders = pDoc->GetRecursive();
2134 pathsDlg.m_bLeftPathReadOnly = pDoc->GetReadOnly(0);
2135 pathsDlg.m_bRightPathReadOnly = pDoc->GetReadOnly(pDoc->m_nDirs - 1);
2138 String filterNameOrMask = theApp.m_pGlobalFileFilter->GetFilterNameOrMask();
2139 pathsDlg.m_sFilter = filterNameOrMask.c_str();
2144 * @brief Start flashing window if window is inactive.
2146 void CMainFrame::StartFlashing()
2148 CWnd * activeWindow = GetActiveWindow();
2149 if (activeWindow != this)
2153 SetTimer(ID_TIMER_FLASH, WINDOW_FLASH_TIMEOUT, NULL);
2158 * @brief Stop flashing window when window is activated.
2160 * If WinMerge is inactive when compare finishes, we start flashing window
2161 * to alert user. When user activates WinMerge window we stop flashing.
2162 * @param [in] nState Tells if window is being activated or deactivated.
2163 * @param [in] pWndOther Pointer to window whose status is changing.
2164 * @param [in] Is window minimized?
2166 void CMainFrame::OnActivate(UINT nState, CWnd* pWndOther, BOOL bMinimized)
2168 CMDIFrameWnd::OnActivate(nState, pWndOther, bMinimized);
2170 if (nState == WA_ACTIVE || nState == WA_CLICKACTIVE)
2174 m_bFlashing = FALSE;
2176 KillTimer(ID_TIMER_FLASH);
2181 #if _MFC_VER > 0x0600
2182 void CMainFrame::OnActivateApp(BOOL bActive, DWORD dwThreadID)
2184 void CMainFrame::OnActivateApp(BOOL bActive, HTASK hTask)
2187 #if _MFC_VER > 0x0600
2188 CMDIFrameWnd::OnActivateApp(bActive, dwThreadID);
2190 CMDIFrameWnd::OnActivateApp(bActive, hTask);
2193 CFrameWnd * pFrame = GetActiveFrame();
2196 IMergeDoc *pMergeDoc = dynamic_cast<IMergeDoc *>(pFrame->GetActiveDocument());
2198 pMergeDoc = dynamic_cast<IMergeDoc *>(pFrame);
2200 PostMessage(WM_USER+1);
2204 BOOL CMainFrame::CreateToolbar()
2206 if (!m_wndToolBar.CreateEx(this) ||
2207 !m_wndToolBar.LoadToolBar(IDR_MAINFRAME))
2212 if (!m_wndReBar.Create(this))
2217 VERIFY(m_wndToolBar.ModifyStyle(0, TBSTYLE_FLAT|TBSTYLE_TRANSPARENT));
2219 // Remove this if you don't want tool tips or a resizable toolbar
2220 m_wndToolBar.SetBarStyle(m_wndToolBar.GetBarStyle() |
2221 CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
2222 m_wndToolBar.GetToolBarCtrl().SetExtendedStyle(TBSTYLE_EX_DRAWDDARROWS);
2224 m_wndReBar.AddBar(&m_wndToolBar);
2226 LoadToolbarImages();
2230 int index = m_wndToolBar.GetToolBarCtrl().CommandToIndex(ID_OPTIONS);
2231 m_wndToolBar.GetButtonInfo(index, nID, nStyle, iImage);
2232 nStyle |= TBSTYLE_DROPDOWN;
2233 m_wndToolBar.SetButtonInfo(index, nID, nStyle, iImage);
2235 if (GetOptionsMgr()->GetBool(OPT_SHOW_TOOLBAR) == false)
2237 CMDIFrameWnd::ShowControlBar(&m_wndToolBar, false, 0);
2243 /** @brief Load toolbar images from the resource. */
2244 void CMainFrame::LoadToolbarImages()
2246 int toolbarSize = GetOptionsMgr()->GetInt(OPT_TOOLBAR_SIZE);
2247 CToolBarCtrl& BarCtrl = m_wndToolBar.GetToolBarCtrl();
2249 m_ToolbarImages[TOOLBAR_IMAGES_ENABLED].DeleteImageList();
2250 m_ToolbarImages[TOOLBAR_IMAGES_DISABLED].DeleteImageList();
2251 CSize sizeButton(0, 0);
2253 if (toolbarSize == 0)
2255 LoadToolbarImageList(TOOLBAR_SIZE_16x16, IDB_TOOLBAR_ENABLED,
2256 m_ToolbarImages[TOOLBAR_IMAGES_ENABLED]);
2257 LoadToolbarImageList(TOOLBAR_SIZE_16x16, IDB_TOOLBAR_DISABLED,
2258 m_ToolbarImages[TOOLBAR_IMAGES_DISABLED]);
2259 sizeButton = CSize(24, 24);
2261 else if (toolbarSize == 1)
2263 LoadToolbarImageList(TOOLBAR_SIZE_32x32, IDB_TOOLBAR_ENABLED32,
2264 m_ToolbarImages[TOOLBAR_IMAGES_ENABLED]);
2265 LoadToolbarImageList(TOOLBAR_SIZE_32x32, IDB_TOOLBAR_DISABLED32,
2266 m_ToolbarImages[TOOLBAR_IMAGES_DISABLED]);
2267 sizeButton = CSize(40, 40);
2270 BarCtrl.SetButtonSize(sizeButton);
2271 BarCtrl.SetImageList(&m_ToolbarImages[TOOLBAR_IMAGES_ENABLED]);
2272 BarCtrl.SetDisabledImageList(&m_ToolbarImages[TOOLBAR_IMAGES_DISABLED]);
2273 m_ToolbarImages[TOOLBAR_IMAGES_ENABLED].Detach();
2274 m_ToolbarImages[TOOLBAR_IMAGES_DISABLED].Detach();
2276 // resize the rebar.
2278 rbbi.cbSize = sizeof(rbbi);
2279 rbbi.fMask = RBBIM_CHILDSIZE;
2280 rbbi.cyMinChild = sizeButton.cy;
2281 m_wndReBar.GetReBarCtrl().SetBandInfo(0, &rbbi);
2286 * @brief Load a transparent 24-bit color image list.
2288 static void LoadHiColImageList(UINT nIDResource, int nWidth, int nHeight, int nCount, CImageList& ImgList, COLORREF crMask = RGB(255,0,255))
2291 VERIFY(bm.LoadBitmap(nIDResource));
2292 VERIFY(ImgList.Create(nWidth, nHeight, ILC_COLORDDB|ILC_MASK, nCount, 0));
2293 int nIndex = ImgList.Add(&bm, crMask);
2294 ASSERT(-1 != nIndex);
2298 * @brief Load toolbar image list.
2300 static void LoadToolbarImageList(CMainFrame::TOOLBAR_SIZE size, UINT nIDResource,
2301 CImageList& ImgList)
2303 const int ImageCount = 22;
2305 int imageHeight = 0;
2309 case CMainFrame::TOOLBAR_SIZE_16x16:
2313 case CMainFrame::TOOLBAR_SIZE_32x32:
2319 LoadHiColImageList(nIDResource, imageWidth, imageHeight, ImageCount, ImgList);
2323 * @brief Called when the document title is modified.
2325 void CMainFrame::OnUpdateFrameTitle(BOOL bAddToTitle)
2327 CFrameWnd::OnUpdateFrameTitle(bAddToTitle);
2329 if (m_wndTabBar.m_hWnd)
2330 m_wndTabBar.UpdateTabs();
2333 /** @brief Hide the toolbar. */
2334 void CMainFrame::OnToolbarNone()
2336 GetOptionsMgr()->SaveOption(OPT_SHOW_TOOLBAR, false);
2337 CMDIFrameWnd::ShowControlBar(&m_wndToolBar, FALSE, 0);
2340 /** @brief Update menuitem for hidden toolbar. */
2341 void CMainFrame::OnUpdateToolbarNone(CCmdUI* pCmdUI)
2343 bool enabled = GetOptionsMgr()->GetBool(OPT_SHOW_TOOLBAR);
2344 pCmdUI->SetRadio(!enabled);
2347 /** @brief Show small toolbar. */
2348 void CMainFrame::OnToolbarSmall()
2350 GetOptionsMgr()->SaveOption(OPT_SHOW_TOOLBAR, true);
2351 GetOptionsMgr()->SaveOption(OPT_TOOLBAR_SIZE, 0);
2353 LoadToolbarImages();
2355 CMDIFrameWnd::ShowControlBar(&m_wndToolBar, TRUE, 0);
2358 /** @brief Update menuitem for small toolbar. */
2359 void CMainFrame::OnUpdateToolbarSmall(CCmdUI* pCmdUI)
2361 bool enabled = GetOptionsMgr()->GetBool(OPT_SHOW_TOOLBAR);
2362 int toolbar = GetOptionsMgr()->GetInt(OPT_TOOLBAR_SIZE);
2363 pCmdUI->SetRadio(enabled && toolbar == 0);
2366 /** @brief Show big toolbar. */
2367 void CMainFrame::OnToolbarBig()
2369 GetOptionsMgr()->SaveOption(OPT_SHOW_TOOLBAR, true);
2370 GetOptionsMgr()->SaveOption(OPT_TOOLBAR_SIZE, 1);
2372 LoadToolbarImages();
2374 CMDIFrameWnd::ShowControlBar(&m_wndToolBar, TRUE, 0);
2377 /** @brief Update menuitem for big toolbar. */
2378 void CMainFrame::OnUpdateToolbarBig(CCmdUI* pCmdUI)
2380 bool enabled = GetOptionsMgr()->GetBool(OPT_SHOW_TOOLBAR);
2381 int toolbar = GetOptionsMgr()->GetInt(OPT_TOOLBAR_SIZE);
2382 pCmdUI->SetRadio(enabled && toolbar == 1);
2385 /** @brief Lang aware version of CFrameWnd::OnToolTipText() */
2386 BOOL CMainFrame::OnToolTipText(UINT, NMHDR* pNMHDR, LRESULT* pResult)
2388 ASSERT(pNMHDR->code == TTN_NEEDTEXTA || pNMHDR->code == TTN_NEEDTEXTW);
2390 // need to handle both ANSI and UNICODE versions of the message
2391 TOOLTIPTEXTA* pTTTA = (TOOLTIPTEXTA*)pNMHDR;
2392 TOOLTIPTEXTW* pTTTW = (TOOLTIPTEXTW*)pNMHDR;
2395 UINT_PTR nID = pNMHDR->idFrom;
2396 if (pNMHDR->code == TTN_NEEDTEXTA && (pTTTA->uFlags & TTF_IDISHWND) ||
2397 pNMHDR->code == TTN_NEEDTEXTW && (pTTTW->uFlags & TTF_IDISHWND))
2399 // idFrom is actually the HWND of the tool
2400 nID = ::GetDlgCtrlID((HWND)nID);
2403 if (nID != 0) // will be zero on a separator
2405 strFullText = theApp.LoadString(static_cast<UINT>(nID));
2406 // don't handle the message if no string resource found
2407 if (strFullText.empty())
2410 // this is the command id, not the button index
2411 AfxExtractSubString(strTipText, strFullText.c_str(), 1, '\n');
2414 if (pNMHDR->code == TTN_NEEDTEXTA)
2415 lstrcpyn(pTTTA->szText, strTipText, countof(pTTTA->szText));
2417 _mbstowcsz(pTTTW->szText, strTipText, countof(pTTTW->szText));
2419 if (pNMHDR->code == TTN_NEEDTEXTA)
2420 _wcstombsz(pTTTA->szText, strTipText, countof(pTTTA->szText));
2422 lstrcpyn(pTTTW->szText, strTipText, countof(pTTTW->szText));
2426 // bring the tooltip window above other popup windows
2427 ::SetWindowPos(pNMHDR->hwndFrom, HWND_TOP, 0, 0, 0, 0,
2428 SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOOWNERZORDER);
2430 return TRUE; // message was handled
2434 * @brief Ask user for close confirmation when closing the mainframe.
2435 * This function asks if user wants to close multiple open windows when user
2436 * selects (perhaps accidentally) to close WinMerge (application).
2437 * @return true if user agreeds to close all windows.
2439 bool CMainFrame::AskCloseConfirmation()
2441 const DirDocList &dirdocs = GetAllDirDocs();
2442 const MergeDocList &mergedocs = GetAllMergeDocs();
2445 const size_t count = dirdocs.GetCount() + mergedocs.GetCount();
2448 // Check that we don't have one empty dirdoc + mergedoc situation.
2449 // That happens since we open "hidden" dirdoc for every file compare.
2450 if (dirdocs.GetCount() == 1)
2452 CDirDoc *pDoc = dirdocs.GetHead();
2453 if (!pDoc->HasDiffs())
2456 ret = LangMessageBox(IDS_CLOSEALL_WINDOWS, MB_YESNO | MB_ICONWARNING);
2458 return (ret == IDYES);
2461 void CMainFrame::OnHelpCheckForUpdates()
2463 CVersionInfo version(AfxGetResourceHandle());
2464 CInternetSession session;
2467 CHttpFile *file = (CHttpFile *)session.OpenURL(CurrentVersionURL);
2470 char buf[256] = { 0 };
2471 file->Read(buf, sizeof(buf));
2473 String current_version = ucr::toTString(buf);
2474 string_replace(current_version, _T("\r\n"), _T(""));
2477 int exe_vers[4] = { 0 }, cur_vers[4] = { 0 };
2478 _stscanf(version.GetProductVersion().c_str(), _T("%d.%d.%d.%d"), &exe_vers[0], &exe_vers[1], &exe_vers[2], &exe_vers[3]);
2479 _stscanf(current_version.c_str(), _T("%d.%d.%d.%d"), &cur_vers[0], &cur_vers[1], &cur_vers[2], &cur_vers[3]);
2480 String exe_version_hex = string_format(_T("%08x%08x%08x%08x"), exe_vers[0], exe_vers[1], exe_vers[2], exe_vers[3]);
2481 String cur_version_hex = string_format(_T("%08x%08x%08x%08x"), cur_vers[0], cur_vers[1], cur_vers[2], cur_vers[3]);
2483 switch (exe_version_hex.compare(cur_version_hex))
2486 if (cur_version_hex == _T("00000000000000000000000000000000"))
2488 String msg = theApp.LoadString(IDS_CHECKFORUPDATES_FAILED);
2489 AfxMessageBox(msg.c_str(), MB_ICONERROR);
2495 String msg = theApp.LoadString(IDS_CHECKFORUPDATES_UPTODATE);
2496 AfxMessageBox(msg.c_str(), MB_ICONINFORMATION);
2501 String msg = LangFormatString2(IDS_CHECKFORUPDATES_NEWVERSION, current_version.c_str(), version.GetProductVersion().c_str());
2502 if (AfxMessageBox(msg.c_str(), MB_ICONINFORMATION | MB_YESNO) == IDYES)
2503 ShellExecute(NULL, _T("open"), DownloadUrl, NULL, NULL, SW_SHOWNORMAL);
2508 catch (CException& e)
2511 e.GetErrorMessage(msg, sizeof(msg)/sizeof(msg[0]));
2512 AfxMessageBox(msg, MB_ICONERROR);
2517 * @brief Called when user selects File/Open Conflict...
2519 void CMainFrame::OnFileOpenConflict()
2521 String conflictFile;
2522 if (SelectFile(GetSafeHwnd(), conflictFile))
2524 DoOpenConflict(conflictFile);
2529 * @brief Select and open conflict file for resolving.
2530 * This function lets user to select conflict file to resolve.
2531 * Then we parse conflict file to two files to "merge" and
2532 * save resulting file over original file.
2534 * Set left-side file read-only as it is the repository file which cannot
2535 * be modified anyway. Right-side file is user's file which is set as
2536 * modified by default so user can just save it and accept workspace
2537 * file as resolved file.
2538 * @param [in] conflictFile Full path to conflict file to open.
2539 * @param [in] checked If true, do not check if it really is project file.
2540 * @return TRUE if conflict file was opened for resolving.
2542 BOOL CMainFrame::DoOpenConflict(const String& conflictFile, bool checked)
2544 BOOL conflictCompared = FALSE;
2548 bool confFile = IsConflictFile(conflictFile);
2551 String message = LangFormatString1(IDS_NOT_CONFLICT_FILE, conflictFile.c_str());
2552 AfxMessageBox(message.c_str(), MB_ICONSTOP);
2557 // Create temp files and put them into the list,
2558 // from where they get deleted when MainFrame is deleted.
2559 String ext = paths_FindExtension(conflictFile);
2560 TempFilePtr wTemp(new TempFile());
2561 String workFile = wTemp->Create(_T("confw_"), ext.c_str());
2562 m_tempFiles.push_back(wTemp);
2563 TempFilePtr vTemp(new TempFile());
2564 String revFile = vTemp->Create(_T("confv_"), ext.c_str());
2565 m_tempFiles.push_back(vTemp);
2567 // Parse conflict file into two files.
2569 int iGuessEncodingType = GetOptionsMgr()->GetInt(OPT_CP_DETECT);
2570 bool success = ParseConflictFile(conflictFile, workFile, revFile, iGuessEncodingType, inners);
2574 // Open two parsed files to WinMerge, telling WinMerge to
2575 // save over original file (given as third filename).
2576 theApp.m_strSaveAsPath = conflictFile.c_str();
2577 String theirs = LoadResString(IDS_CONFLICT_THEIRS_FILE);
2578 String my = LoadResString(IDS_CONFLICT_MINE_FILE);
2579 theApp.m_strDescriptions[0] = theirs;
2580 theApp.m_strDescriptions[1] = my;
2582 DWORD dwFlags[2] = {FFILEOPEN_READONLY | FFILEOPEN_NOMRU, FFILEOPEN_NOMRU | FFILEOPEN_MODIFIED};
2583 conflictCompared = DoFileOpen(&PathContext(revFile, workFile),
2588 LangMessageBox(IDS_ERROR_CONF_RESOLVE, MB_ICONSTOP);
2590 return conflictCompared;
2594 * @brief Get type of frame (File/Folder compare).
2595 * @param [in] pFrame Pointer to frame to check.
2596 * @return FRAMETYPE of the given frame.
2598 CMainFrame::FRAMETYPE CMainFrame::GetFrameType(const CFrameWnd * pFrame) const
2600 BOOL bMergeFrame = pFrame->IsKindOf(RUNTIME_CLASS(CChildFrame));
2601 BOOL bHexMergeFrame = pFrame->IsKindOf(RUNTIME_CLASS(CHexMergeFrame));
2602 BOOL bImgMergeFrame = pFrame->IsKindOf(RUNTIME_CLASS(CImgMergeFrame));
2603 BOOL bDirFrame = pFrame->IsKindOf(RUNTIME_CLASS(CDirFrame));
2607 else if (bHexMergeFrame)
2608 return FRAME_HEXFILE;
2609 else if (bImgMergeFrame)
2610 return FRAME_IMGFILE;
2612 return FRAME_FOLDER;
2618 * @brief Show the plugins list dialog.
2620 void CMainFrame::OnPluginsList()
2626 void CMainFrame::OnDiffOptionsDropDown(NMHDR* pNMHDR, LRESULT* pResult)
2628 LPNMTOOLBAR pToolBar = reinterpret_cast<LPNMTOOLBAR>(pNMHDR);
2629 ClientToScreen(&(pToolBar->rcButton));
2631 VERIFY(menu.LoadMenu(IDR_POPUP_DIFF_OPTIONS));
2632 theApp.TranslateMenu(menu.m_hMenu);
2633 CMenu* pPopup = menu.GetSubMenu(0);
2636 pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON,
2637 pToolBar->rcButton.left, pToolBar->rcButton.bottom, this);
2641 void CMainFrame::OnDiffWhitespace(UINT nID)
2643 GetOptionsMgr()->SaveOption(OPT_CMP_IGNORE_WHITESPACE, nID - IDC_DIFF_WHITESPACE_COMPARE);
2647 void CMainFrame::OnUpdateDiffWhitespace(CCmdUI* pCmdUI)
2649 pCmdUI->SetRadio((pCmdUI->m_nID - IDC_DIFF_WHITESPACE_COMPARE) == GetOptionsMgr()->GetInt(OPT_CMP_IGNORE_WHITESPACE));
2653 void CMainFrame::OnDiffCaseSensitive()
2655 GetOptionsMgr()->SaveOption(OPT_CMP_IGNORE_CASE, !GetOptionsMgr()->GetBool(OPT_CMP_IGNORE_CASE));
2659 void CMainFrame::OnUpdateDiffCaseSensitive(CCmdUI* pCmdUI)
2661 pCmdUI->SetCheck(!GetOptionsMgr()->GetBool(OPT_CMP_IGNORE_CASE));
2665 void CMainFrame::OnDiffIgnoreEOL()
2667 GetOptionsMgr()->SaveOption(OPT_CMP_IGNORE_EOL, !GetOptionsMgr()->GetBool(OPT_CMP_IGNORE_EOL));
2671 void CMainFrame::OnUpdateDiffIgnoreEOL(CCmdUI* pCmdUI)
2673 pCmdUI->SetCheck(GetOptionsMgr()->GetBool(OPT_CMP_IGNORE_EOL));
2677 void CMainFrame::OnCompareMethod(UINT nID)
2679 GetOptionsMgr()->SaveOption(OPT_CMP_METHOD, nID - ID_COMPMETHOD_FULL_CONTENTS);
2682 void CMainFrame::OnUpdateCompareMethod(CCmdUI* pCmdUI)
2684 pCmdUI->SetRadio((pCmdUI->m_nID - ID_COMPMETHOD_FULL_CONTENTS) == GetOptionsMgr()->GetInt(OPT_CMP_METHOD));
2688 void CMainFrame::OnMRUs(UINT nID)
2690 std::vector<JumpList::Item> mrus = JumpList::GetRecentDocs(9);
2691 const int idx = nID - ID_MRU_FIRST;
2692 if (idx < mrus.size())
2694 MergeCmdLineInfo cmdInfo((_T("\"") + mrus[idx].path + _T("\" ") + mrus[idx].params).c_str());
2695 theApp.ParseArgsAndDoOpen(cmdInfo, this);
2699 void CMainFrame::OnUpdateNoMRUs(CCmdUI* pCmdUI)
2701 // append the MRU submenu
2702 HMENU hMenu = GetSubmenu(AfxGetMainWnd()->GetMenu()->m_hMenu, ID_FILE_NEW, false);
2707 int i = ::GetMenuItemCount(hMenu);
2709 ::DeleteMenu(hMenu, 0, MF_BYPOSITION);
2711 std::vector<JumpList::Item> mrus = JumpList::GetRecentDocs(9);
2713 if (mrus.size() == 0)
2715 // no script : create a <empty> entry
2716 ::AppendMenu(hMenu, MF_STRING, ID_NO_EDIT_SCRIPTS, theApp.LoadString(IDS_NO_EDIT_SCRIPTS).c_str());
2720 // or fill in the submenu with the scripts names
2721 int ID = ID_MRU_FIRST; // first ID in menu
2722 for (i = 0 ; i < mrus.size() ; i++, ID++)
2723 ::AppendMenu(hMenu, MF_STRING, ID, (string_format(_T("&%d "), i+1) + mrus[i].title).c_str());
2726 pCmdUI->Enable(true);
2730 * @brief Update plugin name
2731 * @param [in] pCmdUI UI component to update.
2733 void CMainFrame::OnUpdatePluginName(CCmdUI* pCmdUI)
2735 pCmdUI->SetText(_T(""));
2738 void CMainFrame::ReloadMenu()
2740 // set the menu of the main frame window
2741 UINT idMenu = IDR_MAINFRAME;
2742 CMergeApp *pApp = dynamic_cast<CMergeApp *> (AfxGetApp());
2743 CMainFrame * pMainFrame = dynamic_cast<CMainFrame *> ((CFrameWnd*)pApp->m_pMainWnd);
2744 HMENU hNewDefaultMenu = pMainFrame->NewDefaultMenu(idMenu);
2745 HMENU hNewMergeMenu = pMainFrame->NewMergeViewMenu();
2746 HMENU hNewImgMergeMenu = pMainFrame->NewImgMergeViewMenu();
2747 HMENU hNewDirMenu = pMainFrame->NewDirViewMenu();
2748 if (hNewDefaultMenu && hNewMergeMenu && hNewDirMenu)
2750 // Note : for Windows98 compatibility, use FromHandle and not Attach/Detach
2751 CMenu * pNewDefaultMenu = CMenu::FromHandle(hNewDefaultMenu);
2752 CMenu * pNewMergeMenu = CMenu::FromHandle(hNewMergeMenu);
2753 CMenu * pNewImgMergeMenu = CMenu::FromHandle(hNewImgMergeMenu);
2754 CMenu * pNewDirMenu = CMenu::FromHandle(hNewDirMenu);
2756 CWnd *pFrame = CWnd::FromHandle(::GetWindow(pMainFrame->m_hWndMDIClient, GW_CHILD));
2759 if (pFrame->IsKindOf(RUNTIME_CLASS(CChildFrame)))
2760 static_cast<CChildFrame *>(pFrame)->SetSharedMenu(hNewMergeMenu);
2761 if (pFrame->IsKindOf(RUNTIME_CLASS(CHexMergeFrame)))
2762 static_cast<CHexMergeFrame *>(pFrame)->SetSharedMenu(hNewMergeMenu);
2763 if (pFrame->IsKindOf(RUNTIME_CLASS(CImgMergeFrame)))
2764 static_cast<CImgMergeFrame *>(pFrame)->SetSharedMenu(hNewImgMergeMenu);
2765 else if (pFrame->IsKindOf(RUNTIME_CLASS(COpenFrame)))
2766 static_cast<COpenFrame *>(pFrame)->SetSharedMenu(hNewDefaultMenu);
2767 else if (pFrame->IsKindOf(RUNTIME_CLASS(CDirFrame)))
2768 static_cast<CDirFrame *>(pFrame)->SetSharedMenu(hNewDirMenu);
2769 pFrame = pFrame->GetNextWindow();
2772 CFrameWnd *pActiveFrame = pMainFrame->GetActiveFrame();
2775 if (pActiveFrame->IsKindOf(RUNTIME_CLASS(CChildFrame)))
2776 pMainFrame->MDISetMenu(pNewMergeMenu, NULL);
2777 else if (pActiveFrame->IsKindOf(RUNTIME_CLASS(CHexMergeFrame)))
2778 pMainFrame->MDISetMenu(pNewMergeMenu, NULL);
2779 else if (pActiveFrame->IsKindOf(RUNTIME_CLASS(CImgMergeFrame)))
2780 pMainFrame->MDISetMenu(pNewImgMergeMenu, NULL);
2781 else if (pActiveFrame->IsKindOf(RUNTIME_CLASS(CDirFrame)))
2782 pMainFrame->MDISetMenu(pNewDirMenu, NULL);
2784 pMainFrame->MDISetMenu(pNewDefaultMenu, NULL);
2787 pMainFrame->MDISetMenu(pNewDefaultMenu, NULL);
2789 // Don't delete the old menu
2790 // There is a bug in BCMenu or in Windows98 : the new menu does not
2791 // appear correctly if we destroy the old one
2792 // if (pOldDefaultMenu)
2793 // pOldDefaultMenu->DestroyMenu();
2794 // if (pOldMergeMenu)
2795 // pOldMergeMenu->DestroyMenu();
2797 // pOldDirMenu->DestroyMenu();
2799 // m_hMenuDefault is used to redraw the main menu when we close a child frame
2800 // if this child frame had a different menu
2801 pMainFrame->m_hMenuDefault = hNewDefaultMenu;
2802 pApp->m_pOpenTemplate->m_hMenuShared = hNewDefaultMenu;
2803 pApp->m_pDiffTemplate->m_hMenuShared = hNewMergeMenu;
2804 pApp->m_pDirTemplate->m_hMenuShared = hNewDirMenu;
2806 // force redrawing the menu bar
2807 pMainFrame->DrawMenuBar();
2811 void CMainFrame::UpdateDocTitle()
2813 CDocManager* pDocManager = AfxGetApp()->m_pDocManager;
2814 POSITION posTemplate = pDocManager->GetFirstDocTemplatePosition();
2815 ASSERT(posTemplate != NULL);
2817 while (posTemplate != NULL)
2819 CDocTemplate* pTemplate = pDocManager->GetNextDocTemplate(posTemplate);
2821 ASSERT(pTemplate != NULL);
2823 POSITION pos = pTemplate->GetFirstDocPosition();
2828 pDoc = pTemplate->GetNextDoc(pos);
2829 pDoc->SetTitle(NULL);
2830 ((CFrameWnd*)AfxGetApp()->m_pMainWnd)->OnUpdateFrameTitle(TRUE);