Src/MainFrm.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 //    WinMerge:  an interactive diff/merge utility
   3 //    Copyright (C) 1997-2000  Thingamahoochie Software
   4 //    Author: Dean Grimm
   5 //
   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.
  10 //
  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.
  15 //
  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.
  19 //
  20 /////////////////////////////////////////////////////////////////////////////
  21 /**
  22  * @file  MainFrm.cpp
  23  *
  24  * @brief Implementation of the CMainFrame class
  25  */
  26
  27 #include "StdAfx.h"
  28 #include "MainFrm.h"
  29 #include <vector>
  30 #include <afxinet.h>
  31 #include <boost/range/mfc.hpp>
  32 #include "Constants.h"
  33 #include "Merge.h"
  34 #include "FileFilterHelper.h"
  35 #include "UnicodeString.h"
  36 #include "BCMenu.h"
  37 #include "OpenFrm.h"
  38 #include "DirFrame.h"           // Include type information
  39 #include "ChildFrm.h"
  40 #include "HexMergeFrm.h"
  41 #include "DirView.h"
  42 #include "DirDoc.h"
  43 #include "OpenDoc.h"
  44 #include "MergeDoc.h"
  45 #include "MergeEditView.h"
  46 #include "HexMergeDoc.h"
  47 #include "HexMergeView.h"
  48 #include "ImgMergeFrm.h"
  49 #include "LineFiltersList.h"
  50 #include "ConflictFileParser.h"
  51 #include "LineFiltersDlg.h"
  52 #include "paths.h"
  53 #include "Environment.h"
  54 #include "PatchTool.h"
  55 #include "Plugins.h"
  56 #include "ConfigLog.h"
  57 #include "7zCommon.h"
  58 #include "Merge7zFormatMergePluginImpl.h"
  59 #include "FileFiltersDlg.h"
  60 #include "OptionsMgr.h"
  61 #include "OptionsDef.h"
  62 #include "codepage_detect.h"
  63 #include "unicoder.h"
  64 #include "PreferencesDlg.h"
  65 #include "FileOrFolderSelect.h"
  66 #include "PluginsListDlg.h"
  67 #include "stringdiffs.h"
  68 #include "MergeCmdLineInfo.h"
  69 #include "OptionsFont.h"
  70 #include "JumpList.h"
  71 #include "DropHandler.h"
  72 #include "LanguageSelect.h"
  73 #include "VersionInfo.h"
  74 #include "Bitmap.h"
  75 #include "CCrystalTextMarkers.h"
  76
  77 using std::vector;
  78 using boost::begin;
  79 using boost::end;
  80
  81 #ifdef _DEBUG
  82 #define new DEBUG_NEW
  83 #endif
  84
  85 static void LoadToolbarImageList(int imageWidth, UINT nIDResource, UINT nIDResourceMask, bool bGrayscale, CImageList& ImgList);
  86 static CPtrList &GetDocList(CMultiDocTemplate *pTemplate);
  87 template<class DocClass>
  88 DocClass * GetMergeDocForDiff(CMultiDocTemplate *pTemplate, CDirDoc *pDirDoc, int nFiles, bool bMakeVisible = true);
  89
  90 /**
  91  * @brief A table associating menuitem id, icon and menus to apply.
  92  */
  93 const CMainFrame::MENUITEM_ICON CMainFrame::m_MenuIcons[] = {
  94         { ID_FILE_OPENCONFLICT,                 IDB_FILE_OPENCONFLICT,                  CMainFrame::MENU_ALL },
  95         { ID_FILE_NEW3,                 IDB_FILE_NEW3,                  CMainFrame::MENU_ALL },
  96         { ID_EDIT_COPY,                                 IDB_EDIT_COPY,                                  CMainFrame::MENU_ALL },
  97         { ID_EDIT_CUT,                                  IDB_EDIT_CUT,                                   CMainFrame::MENU_ALL },
  98         { ID_EDIT_PASTE,                                IDB_EDIT_PASTE,                                 CMainFrame::MENU_ALL },
  99         { ID_EDIT_FIND,                                 IDB_EDIT_SEARCH,                                CMainFrame::MENU_ALL },
 100         { ID_WINDOW_CASCADE,                    IDB_WINDOW_CASCADE,                             CMainFrame::MENU_ALL },
 101         { ID_WINDOW_TILE_HORZ,                  IDB_WINDOW_HORIZONTAL,                  CMainFrame::MENU_ALL },
 102         { ID_WINDOW_TILE_VERT,                  IDB_WINDOW_VERTICAL,                    CMainFrame::MENU_ALL },
 103         { ID_FILE_CLOSE,                                IDB_WINDOW_CLOSE,                               CMainFrame::MENU_ALL },
 104         { ID_WINDOW_CHANGE_PANE,                IDB_WINDOW_CHANGEPANE,                  CMainFrame::MENU_ALL },
 105         { ID_EDIT_WMGOTO,                               IDB_EDIT_GOTO,                                  CMainFrame::MENU_ALL },
 106         { ID_EDIT_REPLACE,                              IDB_EDIT_REPLACE,                               CMainFrame::MENU_ALL },
 107         { ID_VIEW_SELECTFONT,                   IDB_VIEW_SELECTFONT,                    CMainFrame::MENU_ALL },
 108         { ID_APP_EXIT,                                  IDB_FILE_EXIT,                                  CMainFrame::MENU_ALL },
 109         { ID_HELP_CONTENTS,                             IDB_HELP_CONTENTS,                              CMainFrame::MENU_ALL },
 110         { ID_EDIT_SELECT_ALL,                   IDB_EDIT_SELECTALL,                             CMainFrame::MENU_ALL },
 111         { ID_TOOLS_FILTERS,                             IDB_TOOLS_FILTERS,                              CMainFrame::MENU_ALL },
 112         { ID_TOOLS_CUSTOMIZECOLUMNS,    IDB_TOOLS_COLUMNS,                              CMainFrame::MENU_ALL },
 113         { ID_TOOLS_GENERATEPATCH,               IDB_TOOLS_GENERATEPATCH,                CMainFrame::MENU_ALL },
 114         { ID_PLUGINS_LIST,                              IDB_PLUGINS_LIST,                               CMainFrame::MENU_ALL },
 115         { ID_COPY_FROM_LEFT,                    IDB_COPY_FROM_LEFT,                             CMainFrame::MENU_ALL },
 116         { ID_COPY_FROM_RIGHT,                   IDB_COPY_FROM_RIGHT,                    CMainFrame::MENU_ALL },
 117         { ID_FILE_PRINT,                                IDB_FILE_PRINT,                                 CMainFrame::MENU_FILECMP },
 118         { ID_TOOLS_GENERATEREPORT,              IDB_TOOLS_GENERATEREPORT,               CMainFrame::MENU_FILECMP },
 119         { ID_EDIT_TOGGLE_BOOKMARK,              IDB_EDIT_TOGGLE_BOOKMARK,               CMainFrame::MENU_FILECMP },
 120         { ID_EDIT_GOTO_NEXT_BOOKMARK,   IDB_EDIT_GOTO_NEXT_BOOKMARK,    CMainFrame::MENU_FILECMP },
 121         { ID_EDIT_GOTO_PREV_BOOKMARK,   IDB_EDIT_GOTO_PREV_BOOKMARK,    CMainFrame::MENU_FILECMP },
 122         { ID_EDIT_CLEAR_ALL_BOOKMARKS,  IDB_EDIT_CLEAR_ALL_BOOKMARKS,   CMainFrame::MENU_FILECMP },
 123         { ID_VIEW_ZOOMIN,                               IDB_VIEW_ZOOMIN,                                CMainFrame::MENU_FILECMP },
 124         { ID_VIEW_ZOOMOUT,                              IDB_VIEW_ZOOMOUT,                               CMainFrame::MENU_FILECMP },
 125         { ID_MERGE_COMPARE,                             IDB_MERGE_COMPARE,                              CMainFrame::MENU_FOLDERCMP },
 126         { ID_MERGE_COMPARE_LEFT1_LEFT2,         IDB_MERGE_COMPARE_LEFT1_LEFT2,  CMainFrame::MENU_FOLDERCMP },
 127         { ID_MERGE_COMPARE_RIGHT1_RIGHT2,       IDB_MERGE_COMPARE_RIGHT1_RIGHT2,CMainFrame::MENU_FOLDERCMP },
 128         { ID_MERGE_COMPARE_LEFT1_RIGHT2,        IDB_MERGE_COMPARE_LEFT1_RIGHT2, CMainFrame::MENU_FOLDERCMP },
 129         { ID_MERGE_COMPARE_LEFT2_RIGHT1,        IDB_MERGE_COMPARE_LEFT2_RIGHT1, CMainFrame::MENU_FOLDERCMP },
 130         { ID_MERGE_DELETE,                              IDB_MERGE_DELETE,                               CMainFrame::MENU_FOLDERCMP },
 131         { ID_TOOLS_GENERATEREPORT,              IDB_TOOLS_GENERATEREPORT,               CMainFrame::MENU_FOLDERCMP },
 132         { ID_DIR_COPY_LEFT_TO_RIGHT,    IDB_LEFT_TO_RIGHT,                              CMainFrame::MENU_FOLDERCMP },
 133         { ID_DIR_COPY_LEFT_TO_MIDDLE,   IDB_LEFT_TO_MIDDLE,                             CMainFrame::MENU_FOLDERCMP },
 134         { ID_DIR_COPY_RIGHT_TO_LEFT,    IDB_RIGHT_TO_LEFT,                              CMainFrame::MENU_FOLDERCMP },
 135         { ID_DIR_COPY_RIGHT_TO_MIDDLE,  IDB_RIGHT_TO_MIDDLE,                    CMainFrame::MENU_FOLDERCMP },
 136         { ID_DIR_COPY_MIDDLE_TO_LEFT,   IDB_MIDDLE_TO_LEFT,                             CMainFrame::MENU_FOLDERCMP },
 137         { ID_DIR_COPY_MIDDLE_TO_RIGHT,  IDB_MIDDLE_TO_RIGHT,                    CMainFrame::MENU_FOLDERCMP },
 138         { ID_DIR_COPY_LEFT_TO_BROWSE,   IDB_LEFT_TO_BROWSE,                             CMainFrame::MENU_FOLDERCMP },
 139         { ID_DIR_COPY_MIDDLE_TO_BROWSE, IDB_MIDDLE_TO_BROWSE,                   CMainFrame::MENU_FOLDERCMP },
 140         { ID_DIR_COPY_RIGHT_TO_BROWSE,  IDB_RIGHT_TO_BROWSE,                    CMainFrame::MENU_FOLDERCMP },
 141         { ID_DIR_MOVE_LEFT_TO_BROWSE,   IDB_MOVE_LEFT_TO_BROWSE,                CMainFrame::MENU_FOLDERCMP },
 142         { ID_DIR_MOVE_MIDDLE_TO_BROWSE, IDB_MOVE_MIDDLE_TO_BROWSE,              CMainFrame::MENU_FOLDERCMP },
 143         { ID_DIR_MOVE_RIGHT_TO_BROWSE,  IDB_MOVE_RIGHT_TO_BROWSE,               CMainFrame::MENU_FOLDERCMP },
 144         { ID_DIR_DEL_LEFT,                              IDB_LEFT,                                               CMainFrame::MENU_FOLDERCMP },
 145         { ID_DIR_DEL_MIDDLE,                    IDB_MIDDLE,                                             CMainFrame::MENU_FOLDERCMP },
 146         { ID_DIR_DEL_RIGHT,                             IDB_RIGHT,                                              CMainFrame::MENU_FOLDERCMP },
 147         { ID_DIR_DEL_BOTH,                              IDB_BOTH,                                               CMainFrame::MENU_FOLDERCMP },
 148         { ID_DIR_DEL_ALL,                               IDB_ALL,                                                CMainFrame::MENU_FOLDERCMP },
 149         { ID_DIR_COPY_PATHNAMES_LEFT,   IDB_LEFT,                                               CMainFrame::MENU_FOLDERCMP },
 150         { ID_DIR_COPY_PATHNAMES_MIDDLE, IDB_MIDDLE,                                             CMainFrame::MENU_FOLDERCMP },
 151         { ID_DIR_COPY_PATHNAMES_RIGHT,  IDB_RIGHT,                                              CMainFrame::MENU_FOLDERCMP },
 152         { ID_DIR_COPY_PATHNAMES_BOTH,   IDB_BOTH,                                               CMainFrame::MENU_FOLDERCMP },
 153         { ID_DIR_COPY_PATHNAMES_ALL,    IDB_ALL,                                                CMainFrame::MENU_FOLDERCMP },
 154         { ID_DIR_COPY_LEFT_TO_CLIPBOARD, IDB_LEFT,                                              CMainFrame::MENU_FOLDERCMP },
 155         { ID_DIR_COPY_MIDDLE_TO_CLIPBOARD, IDB_MIDDLE,                                  CMainFrame::MENU_FOLDERCMP },
 156         { ID_DIR_COPY_RIGHT_TO_CLIPBOARD, IDB_RIGHT,                                    CMainFrame::MENU_FOLDERCMP },
 157         { ID_DIR_COPY_BOTH_TO_CLIPBOARD, IDB_BOTH,                                              CMainFrame::MENU_FOLDERCMP },
 158         { ID_DIR_COPY_ALL_TO_CLIPBOARD, IDB_ALL,                                                CMainFrame::MENU_FOLDERCMP },
 159         { ID_DIR_ZIP_LEFT,                              IDB_LEFT,                                               CMainFrame::MENU_FOLDERCMP },
 160         { ID_DIR_ZIP_MIDDLE,                    IDB_MIDDLE,                                             CMainFrame::MENU_FOLDERCMP },
 161         { ID_DIR_ZIP_RIGHT,                             IDB_RIGHT,                                              CMainFrame::MENU_FOLDERCMP },
 162         { ID_DIR_ZIP_BOTH,                              IDB_BOTH,                                               CMainFrame::MENU_FOLDERCMP },
 163         { ID_DIR_ZIP_ALL,                               IDB_ALL,                                                CMainFrame::MENU_FOLDERCMP }
 164 };
 165
 166
 167 /////////////////////////////////////////////////////////////////////////////
 168 // CMainFrame
 169
 170 IMPLEMENT_DYNAMIC(CMainFrame, CMDIFrameWnd)
 171
 172 BEGIN_MESSAGE_MAP(CMainFrame, CMDIFrameWnd)
 173         //{{AFX_MSG_MAP(CMainFrame)
 174         ON_WM_MENUCHAR()
 175         ON_WM_MEASUREITEM()
 176         ON_WM_INITMENUPOPUP()
 177         ON_WM_INITMENU()
 178         ON_WM_CREATE()
 179         ON_COMMAND(ID_FILE_OPEN, OnFileOpen)
 180         ON_COMMAND(ID_HELP_GNULICENSE, OnHelpGnulicense)
 181         ON_COMMAND(ID_OPTIONS, OnOptions)
 182         ON_COMMAND(ID_VIEW_SELECTFONT, OnViewSelectfont)
 183         ON_COMMAND(ID_VIEW_USEDEFAULTFONT, OnViewUsedefaultfont)
 184         ON_COMMAND(ID_HELP_CONTENTS, OnHelpContents)
 185         ON_WM_CLOSE()
 186         ON_COMMAND(ID_TOOLS_GENERATEPATCH, OnToolsGeneratePatch)
 187         ON_WM_DESTROY()
 188         ON_COMMAND_RANGE(ID_UNPACK_MANUAL, ID_UNPACK_AUTO, OnPluginUnpackMode)
 189         ON_UPDATE_COMMAND_UI_RANGE(ID_UNPACK_MANUAL, ID_UNPACK_AUTO, OnUpdatePluginUnpackMode)
 190         ON_COMMAND_RANGE(ID_PREDIFFER_MANUAL, ID_PREDIFFER_AUTO, OnPluginPrediffMode)
 191         ON_UPDATE_COMMAND_UI_RANGE(ID_PREDIFFER_MANUAL, ID_PREDIFFER_AUTO, OnUpdatePluginPrediffMode)
 192         ON_UPDATE_COMMAND_UI(ID_RELOAD_PLUGINS, OnUpdateReloadPlugins)
 193         ON_COMMAND(ID_RELOAD_PLUGINS, OnReloadPlugins)
 194         ON_COMMAND(ID_HELP_GETCONFIG, OnSaveConfigData)
 195         ON_COMMAND(ID_FILE_NEW, OnFileNew)
 196         ON_COMMAND(ID_FILE_NEW3, OnFileNew3)
 197         ON_COMMAND(ID_TOOLS_FILTERS, OnToolsFilters)
 198         ON_COMMAND(ID_VIEW_STATUS_BAR, OnViewStatusBar)
 199         ON_UPDATE_COMMAND_UI(ID_VIEW_TAB_BAR, OnUpdateViewTabBar)
 200         ON_COMMAND(ID_VIEW_TAB_BAR, OnViewTabBar)
 201         ON_UPDATE_COMMAND_UI(ID_VIEW_RESIZE_PANES, OnUpdateResizePanes)
 202         ON_COMMAND(ID_VIEW_RESIZE_PANES, OnResizePanes)
 203         ON_COMMAND(ID_FILE_OPENPROJECT, OnFileOpenProject)
 204         ON_MESSAGE(WM_COPYDATA, OnCopyData)
 205         ON_MESSAGE(WM_USER+1, OnUser1)
 206         ON_COMMAND(ID_WINDOW_CLOSEALL, OnWindowCloseAll)
 207         ON_UPDATE_COMMAND_UI(ID_WINDOW_CLOSEALL, OnUpdateWindowCloseAll)
 208         ON_COMMAND(ID_FILE_SAVEPROJECT, OnSaveProject)
 209         ON_WM_ACTIVATEAPP()
 210         ON_COMMAND_RANGE(ID_TOOLBAR_NONE, ID_TOOLBAR_HUGE, OnToolbarSize)
 211         ON_UPDATE_COMMAND_UI_RANGE(ID_TOOLBAR_NONE, ID_TOOLBAR_HUGE, OnUpdateToolbarSize)
 212         ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTW, 0, 0xFFFF, OnToolTipText)
 213         ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, OnToolTipText)
 214         ON_COMMAND(ID_HELP_RELEASENOTES, OnHelpReleasenotes)
 215         ON_COMMAND(ID_HELP_TRANSLATIONS, OnHelpTranslations)
 216         ON_COMMAND(ID_FILE_OPENCONFLICT, OnFileOpenConflict)
 217         ON_COMMAND(ID_PLUGINS_LIST, OnPluginsList)
 218         ON_UPDATE_COMMAND_UI(ID_STATUS_PLUGIN, OnUpdatePluginName)
 219         ON_NOTIFY(TBN_DROPDOWN, AFX_IDW_TOOLBAR, OnDiffOptionsDropDown)
 220         ON_COMMAND_RANGE(IDC_DIFF_WHITESPACE_COMPARE, IDC_DIFF_WHITESPACE_IGNOREALL, OnDiffWhitespace)
 221         ON_UPDATE_COMMAND_UI_RANGE(IDC_DIFF_WHITESPACE_COMPARE, IDC_DIFF_WHITESPACE_IGNOREALL, OnUpdateDiffWhitespace)
 222         ON_COMMAND(IDC_DIFF_CASESENSITIVE, OnDiffCaseSensitive)
 223         ON_UPDATE_COMMAND_UI(IDC_DIFF_CASESENSITIVE, OnUpdateDiffCaseSensitive)
 224         ON_COMMAND(IDC_DIFF_IGNOREEOL, OnDiffIgnoreEOL)
 225         ON_UPDATE_COMMAND_UI(IDC_DIFF_IGNOREEOL, OnUpdateDiffIgnoreEOL)
 226         ON_COMMAND(IDC_RECURS_CHECK, OnIncludeSubfolders)
 227         ON_UPDATE_COMMAND_UI(IDC_RECURS_CHECK, OnUpdateIncludeSubfolders)
 228         ON_COMMAND_RANGE(ID_COMPMETHOD_FULL_CONTENTS, ID_COMPMETHOD_SIZE, OnCompareMethod)
 229         ON_UPDATE_COMMAND_UI_RANGE(ID_COMPMETHOD_FULL_CONTENTS, ID_COMPMETHOD_SIZE, OnUpdateCompareMethod)
 230         ON_COMMAND_RANGE(ID_MRU_FIRST, ID_MRU_LAST, OnMRUs)
 231         ON_UPDATE_COMMAND_UI(ID_MRU_FIRST, OnUpdateNoMRUs)
 232         ON_UPDATE_COMMAND_UI(ID_NO_MRU, OnUpdateNoMRUs)
 233         //}}AFX_MSG_MAP
 234 END_MESSAGE_MAP()
 235
 236 /**
 237  * @brief MainFrame statusbar panels/indicators
 238  */
 239 static UINT StatusbarIndicators[] =
 240 {
 241         ID_SEPARATOR,           // Plugin name
 242         ID_SEPARATOR,           // status line indicator
 243         ID_SEPARATOR,           // Merge mode
 244         ID_SEPARATOR,           // Diff number
 245         ID_INDICATOR_CAPS,      // Caps Lock
 246         ID_INDICATOR_NUM,       // Num Lock
 247         ID_INDICATOR_OVR,       // Insert
 248 };
 249
 250 /**
 251   * @brief Return a const reference to a CMultiDocTemplate's list of documents.
 252   */
 253 static CPtrList &GetDocList(CMultiDocTemplate *pTemplate)
 254 {
 255         struct Template : public CMultiDocTemplate
 256         {
 257         public:
 258                 using CMultiDocTemplate::m_docList;
 259         };
 260         return static_cast<struct Template *>(pTemplate)->m_docList;
 261 }
 262
 263 /////////////////////////////////////////////////////////////////////////////
 264 // CMainFrame construction/destruction
 265
 266 /**
 267  * @brief MainFrame constructor. Loads settings from registry.
 268  * @todo Preference for logging?
 269  */
 270 CMainFrame::CMainFrame()
 271 : m_bFirstTime(true)
 272 , m_pDropHandler(nullptr)
 273 , m_bShowErrors(false)
 274 {
 275 }
 276
 277 CMainFrame::~CMainFrame()
 278 {
 279         GetOptionsMgr()->SaveOption(OPT_TABBAR_AUTO_MAXWIDTH, m_wndTabBar.GetAutoMaxWidth());
 280         strdiff::Close();
 281 }
 282
 283 #ifdef _UNICODE
 284 const TCHAR CMainFrame::szClassName[] = _T("WinMergeWindowClassW");
 285 #else
 286 const TCHAR CMainFrame::szClassName[] = _T("WinMergeWindowClassA");
 287 #endif
 288 /**
 289  * @brief Change MainFrame window class name
 290  *        see http://support.microsoft.com/kb/403825/ja
 291  */
 292 BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
 293 {
 294         WNDCLASS wndcls;
 295         BOOL bRes = CMDIFrameWnd::PreCreateWindow(cs);
 296         HINSTANCE hInst = AfxGetInstanceHandle();
 297         // see if the class already exists
 298         if (!::GetClassInfo(hInst, szClassName, &wndcls))
 299         {
 300                 // get default stuff
 301                 ::GetClassInfo(hInst, cs.lpszClass, &wndcls);
 302                 // register a new class
 303                 wndcls.lpszClassName = szClassName;
 304                 wndcls.hIcon = ::LoadIcon(hInst, MAKEINTRESOURCE(IDR_MAINFRAME));
 305                 ::RegisterClass(&wndcls);
 306         }
 307         cs.lpszClass = szClassName;
 308         return bRes;
 309 }
 310
 311 int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
 312 {
 313         if (CMDIFrameWnd::OnCreate(lpCreateStruct) == -1)
 314                 return -1;
 315
 316         m_wndMDIClient.SubclassWindow(m_hWndMDIClient);
 317
 318         m_lfDiff = Options::Font::Load(GetOptionsMgr(), OPT_FONT_FILECMP);
 319         m_lfDir = Options::Font::Load(GetOptionsMgr(), OPT_FONT_DIRCMP);
 320
 321         if (!CreateToolbar())
 322         {
 323                 TRACE0("Failed to create toolbar\n");
 324                 return -1;      // fail to create
 325         }
 326
 327         if (!m_wndTabBar.Create(this))
 328         {
 329                 TRACE0("Failed to create tab bar\n");
 330                 return -1;      // fail to create
 331         }
 332         m_wndTabBar.SetAutoMaxWidth(GetOptionsMgr()->GetBool(OPT_TABBAR_AUTO_MAXWIDTH));
 333
 334         if (!GetOptionsMgr()->GetBool(OPT_SHOW_TABBAR))
 335                 CMDIFrameWnd::ShowControlBar(&m_wndTabBar, false, 0);
 336
 337         if (!m_wndStatusBar.Create(this))
 338         {
 339                 TRACE0("Failed to create status bar\n");
 340                 return -1;      // fail to create
 341         }
 342         theApp.SetIndicators(m_wndStatusBar, StatusbarIndicators,
 343                         countof(StatusbarIndicators));
 344
 345         const int lpx = CClientDC(this).GetDeviceCaps(LOGPIXELSX);
 346         auto pointToPixel = [lpx](int point) { return MulDiv(point, lpx, 72); };
 347         m_wndStatusBar.SetPaneInfo(0, 0, SBPS_STRETCH | SBPS_NOBORDERS, 0);
 348         m_wndStatusBar.SetPaneInfo(1, ID_STATUS_PLUGIN, 0, pointToPixel(225));
 349         m_wndStatusBar.SetPaneInfo(2, ID_STATUS_MERGINGMODE, 0, pointToPixel(75));
 350         m_wndStatusBar.SetPaneInfo(3, ID_STATUS_DIFFNUM, 0, pointToPixel(112));
 351
 352         if (!GetOptionsMgr()->GetBool(OPT_SHOW_STATUSBAR))
 353                 CMDIFrameWnd::ShowControlBar(&m_wndStatusBar, false, 0);
 354
 355         m_pDropHandler = new DropHandler(std::bind(&CMainFrame::OnDropFiles, this, std::placeholders::_1));
 356         RegisterDragDrop(m_hWnd, m_pDropHandler);
 357
 358         return 0;
 359 }
 360
 361 void CMainFrame::OnDestroy(void)
 362 {
 363         if (m_pDropHandler != nullptr)
 364                 RevokeDragDrop(m_hWnd);
 365 }
 366
 367 static HMENU GetSubmenu(HMENU mainMenu, UINT nIDFirstMenuItem, bool bFirstSubmenu)
 368 {
 369         int i;
 370         for (i = 0 ; i < ::GetMenuItemCount(mainMenu) ; i++)
 371                 if (::GetMenuItemID(::GetSubMenu(mainMenu, i), 0) == nIDFirstMenuItem)
 372                         break;
 373         HMENU menu = ::GetSubMenu(mainMenu, i);
 374
 375         if (!bFirstSubmenu)
 376         {
 377                 // look for last submenu
 378                 for (i = ::GetMenuItemCount(menu) ; i >= 0  ; i--)
 379                         if (::GetSubMenu(menu, i) != nullptr)
 380                                 return ::GetSubMenu(menu, i);
 381         }
 382         else
 383         {
 384                 // look for first submenu
 385                 for (i = 0 ; i < ::GetMenuItemCount(menu) ; i++)
 386                         if (::GetSubMenu(menu, i) != nullptr)
 387                                 return ::GetSubMenu(menu, i);
 388         }
 389
 390         // error, submenu not found
 391         return nullptr;
 392 }
 393
 394 /**
 395  * @brief Find the scripts submenu from the main menu
 396  * As now this is the first submenu in "Edit" menu
 397  * We find the "Edit" menu by looking for a menu
 398  *  starting with ID_EDIT_UNDO.
 399  */
 400 HMENU CMainFrame::GetScriptsSubmenu(HMENU mainMenu)
 401 {
 402         return GetSubmenu(mainMenu, ID_PLUGINS_LIST, false);
 403 }
 404
 405 /**
 406  * @brief Find the scripts submenu from the main menu
 407  * As now this is the first submenu in "Plugins" menu
 408  * We find the "Plugins" menu by looking for a menu
 409  *  starting with ID_UNPACK_MANUAL.
 410  */
 411 HMENU CMainFrame::GetPrediffersSubmenu(HMENU mainMenu)
 412 {
 413         return GetSubmenu(mainMenu, ID_PLUGINS_LIST, true);
 414 }
 415
 416 /**
 417  * @brief Create a new menu for the view..
 418  * @param [in] view Menu view either MENU_DEFAULT, MENU_MERGEVIEW or MENU_DIRVIEW.
 419  * @param [in] ID Menu's resource ID.
 420  * @return Menu for the view.
 421  */
 422 HMENU CMainFrame::NewMenu(int view, int ID)
 423 {
 424         int menu_view, index;
 425         if (m_pMenus[view] == nullptr)
 426         {
 427                 m_pMenus[view].reset(new BCMenu());
 428                 if (m_pMenus[view] == nullptr)
 429                         return nullptr;
 430         }
 431
 432         switch (view)
 433         {
 434         case MENU_MERGEVIEW:
 435                 menu_view = MENU_FILECMP;
 436                 break;
 437         case MENU_DIRVIEW:
 438                 menu_view = MENU_FOLDERCMP;
 439                 break;
 440         case MENU_DEFAULT:
 441         default:
 442                 menu_view = MENU_MAINFRM;
 443                 break;
 444         };
 445
 446         if (!m_pMenus[view]->LoadMenu(ID))
 447         {
 448                 ASSERT(false);
 449                 return nullptr;
 450         }
 451
 452         if (view == MENU_IMGMERGEVIEW)
 453         {
 454                 BCMenu *pMenu = new BCMenu;
 455                 pMenu->LoadMenu(MAKEINTRESOURCE(IDR_POPUP_IMGMERGEVIEW));
 456                 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()));
 457         }
 458
 459         // Load bitmaps to menuitems
 460         for (index = 0; index < countof(m_MenuIcons); index ++)
 461         {
 462                 if (menu_view == (m_MenuIcons[index].menusToApply & menu_view))
 463                 {
 464                         m_pMenus[view]->ModifyODMenu(nullptr, m_MenuIcons[index].menuitemID, m_MenuIcons[index].iconResID);
 465                 }
 466         }
 467
 468         m_pMenus[view]->LoadToolbar(IDR_MAINFRAME);
 469
 470         theApp.TranslateMenu(m_pMenus[view]->m_hMenu);
 471
 472         return (m_pMenus[view]->Detach());
 473
 474 }
 475 /**
 476 * @brief Create new default (CMainFrame) menu.
 477 */
 478 HMENU CMainFrame::NewDefaultMenu(int ID /*=0*/)
 479 {
 480         if (ID == 0)
 481                 ID = IDR_MAINFRAME;
 482         return NewMenu( MENU_DEFAULT, ID );
 483 }
 484
 485 /**
 486  * @brief Create new File compare (CMergeEditView) menu.
 487  */
 488 HMENU CMainFrame::NewMergeViewMenu()
 489 {
 490         return NewMenu( MENU_MERGEVIEW, IDR_MERGEDOCTYPE);
 491 }
 492
 493 /**
 494  * @brief Create new Dir compare (CDirView) menu
 495  */
 496 HMENU CMainFrame::NewDirViewMenu()
 497 {
 498         return NewMenu(MENU_DIRVIEW, IDR_DIRDOCTYPE );
 499 }
 500
 501 /**
 502  * @brief Create new File compare (CHexMergeView) menu.
 503  */
 504 HMENU CMainFrame::NewHexMergeViewMenu()
 505 {
 506         return NewMenu( MENU_HEXMERGEVIEW, IDR_MERGEDOCTYPE);
 507 }
 508
 509 /**
 510  * @brief Create new Image compare (CImgMergeView) menu.
 511  */
 512 HMENU CMainFrame::NewImgMergeViewMenu()
 513 {
 514         return NewMenu( MENU_IMGMERGEVIEW, IDR_MERGEDOCTYPE);
 515 }
 516
 517 /**
 518  * @brief Create new File compare (COpenView) menu.
 519  */
 520 HMENU CMainFrame::NewOpenViewMenu()
 521 {
 522         return NewMenu( MENU_OPENVIEW, IDR_MAINFRAME);
 523 }
 524
 525 /**
 526  * @brief This handler ensures that the popup menu items are drawn correctly.
 527  */
 528 void CMainFrame::OnMeasureItem(int nIDCtl,
 529         LPMEASUREITEMSTRUCT lpMeasureItemStruct)
 530 {
 531         bool setflag = false;
 532         if (lpMeasureItemStruct->CtlType == ODT_MENU)
 533         {
 534                 if (IsMenu(reinterpret_cast<HMENU>(static_cast<uintptr_t>(lpMeasureItemStruct->itemID))))
 535                 {
 536                         CMenu* cmenu =
 537                                 CMenu::FromHandle(reinterpret_cast<HMENU>(static_cast<uintptr_t>(lpMeasureItemStruct->itemID)));
 538
 539                         if (m_pMenus[MENU_DEFAULT]->IsMenu(cmenu))
 540                         {
 541                                 m_pMenus[MENU_DEFAULT]->MeasureItem(lpMeasureItemStruct);
 542                                 setflag = true;
 543                         }
 544                 }
 545         }
 546
 547         if (!setflag)
 548                 CMDIFrameWnd::OnMeasureItem(nIDCtl, lpMeasureItemStruct);
 549 }
 550
 551 /**
 552  * @brief This handler ensures that keyboard shortcuts work.
 553  */
 554 LRESULT CMainFrame::OnMenuChar(UINT nChar, UINT nFlags,
 555         CMenu* pMenu)
 556 {
 557         LRESULT lresult;
 558         if(m_pMenus[MENU_DEFAULT]->IsMenu(pMenu))
 559                 lresult=BCMenu::FindKeyboardShortcut(nChar, nFlags, pMenu);
 560         else
 561                 lresult=CMDIFrameWnd::OnMenuChar(nChar, nFlags, pMenu);
 562         return lresult;
 563 }
 564
 565 /**
 566  * @brief This handler updates the menus from time to time.
 567  */
 568 void CMainFrame::OnInitMenuPopup(CMenu* pPopupMenu, UINT nIndex, BOOL bSysMenu)
 569 {
 570         CMDIFrameWnd::OnInitMenuPopup(pPopupMenu, nIndex, bSysMenu);
 571
 572         if (!bSysMenu)
 573         {
 574                 if (BCMenu::IsMenu(pPopupMenu))
 575                 {
 576                         BCMenu::UpdateMenu(pPopupMenu);
 577                 }
 578         }
 579 }
 580
 581 /////////////////////////////////////////////////////////////////////////////
 582 // CMainFrame message handlers
 583
 584 void CMainFrame::OnFileOpen()
 585 {
 586         DoFileOpen();
 587 }
 588
 589 /**
 590  * @brief Check for BOM, and also, if bGuessEncoding, try to deduce codepage
 591  *
 592  * Unpacks info from FileLocation & delegates all work to codepage_detect module
 593  */
 594 static void
 595 FileLocationGuessEncodings(FileLocation & fileloc, int iGuessEncoding)
 596 {
 597         fileloc.encoding = GuessCodepageEncoding(fileloc.filepath, iGuessEncoding);
 598 }
 599
 600 bool CMainFrame::ShowAutoMergeDoc(CDirDoc * pDirDoc,
 601         int nFiles, const FileLocation ifileloc[],
 602         const DWORD dwFlags[], const String strDesc[], const String& sReportFile /*= _T("")*/,
 603         const PackingInfo * infoUnpacker /*= nullptr*/)
 604 {
 605         int pane;
 606         FileFilterHelper filterImg, filterBin;
 607         filterImg.UseMask(true);
 608         filterImg.SetMask(GetOptionsMgr()->GetString(OPT_CMP_IMG_FILEPATTERNS));
 609         filterBin.UseMask(true);
 610         filterBin.SetMask(GetOptionsMgr()->GetString(OPT_CMP_BIN_FILEPATTERNS));
 611         for (pane = 0; pane < nFiles; ++pane)
 612         {
 613                 if (filterImg.includeFile(ifileloc[pane].filepath) && CImgMergeFrame::IsLoadable())
 614                         return ShowImgMergeDoc(pDirDoc, nFiles, ifileloc, dwFlags, strDesc, sReportFile, infoUnpacker);
 615                 else if (filterBin.includeFile(ifileloc[pane].filepath) && CHexMergeView::IsLoadable())
 616                         return ShowHexMergeDoc(pDirDoc, nFiles, ifileloc, dwFlags, strDesc, sReportFile, infoUnpacker);
 617         }
 618         return ShowMergeDoc(pDirDoc, nFiles, ifileloc, dwFlags, strDesc, sReportFile, infoUnpacker);
 619 }
 620
 621 std::array<bool, 3> GetROFromFlags(int nFiles, const DWORD dwFlags[])
 622 {
 623         std::array<bool, 3> bRO = { false, false, false };
 624         for (int pane = 0; pane < nFiles; pane++)
 625         {
 626                 if (dwFlags)
 627                         bRO[pane] = ((dwFlags[pane] & FFILEOPEN_READONLY) > 0);
 628         }
 629         return bRO;
 630 }
 631
 632 int GetActivePaneFromFlags(int nFiles, const DWORD dwFlags[])
 633 {
 634         int nActivePane = -1;
 635         for (int pane = 0; pane < nFiles; ++pane)
 636         {
 637                 if (dwFlags && (dwFlags[pane] & FFILEOPEN_SETFOCUS))
 638                         nActivePane = pane;
 639         }
 640         return nActivePane;
 641 }
 642
 643 /**
 644  * @brief Creates new MergeDoc instance and shows documents.
 645  * @param [in] pDirDoc Dir compare document to create a new Merge document for.
 646  * @param [in] ifilelocLeft Left side file location info.
 647  * @param [in] ifilelocRight Right side file location info.
 648  * @param [in] dwLeftFlags Left side flags.
 649  * @param [in] dwRightFlags Right side flags.
 650  * @param [in] infoUnpacker Plugin info.
 651  * @return success/failure
 652  */
 653 bool CMainFrame::ShowMergeDoc(CDirDoc * pDirDoc,
 654         int nFiles, const FileLocation ifileloc[],
 655         const DWORD dwFlags[], const String strDesc[], const String& sReportFile /*= _T("")*/,
 656         const PackingInfo * infoUnpacker /*= nullptr*/)
 657 {
 658         if (m_pMenus[MENU_MERGEVIEW] == nullptr)
 659                 theApp.m_pDiffTemplate->m_hMenuShared = NewMergeViewMenu();
 660         CMergeDoc * pMergeDoc = GetMergeDocForDiff<CMergeDoc>(theApp.m_pDiffTemplate, pDirDoc, nFiles, false);
 661
 662         // Make local copies, so we can change encoding if we guess it below
 663         FileLocation fileloc[3];
 664         std::copy_n(ifileloc, nFiles, fileloc);
 665
 666         ASSERT(pMergeDoc != nullptr);           // must ASSERT to get an answer to the question below ;-)
 667         if (pMergeDoc == nullptr)
 668                 return false; // when does this happen ?
 669
 670         // if an unpacker is selected, it must be used during LoadFromFile
 671         // MergeDoc must memorize it for SaveToFile
 672         // Warning : this unpacker may differ from the pDirDoc one
 673         // (through menu : "Plugins"->"Open with unpacker")
 674         pMergeDoc->SetUnpacker(infoUnpacker);
 675
 676         // detect codepage
 677         int iGuessEncodingType = GetOptionsMgr()->GetInt(OPT_CP_DETECT);
 678         for (int pane = 0; pane < nFiles; pane++)
 679         {
 680                 if (fileloc[pane].encoding.m_unicoding == -1)
 681                         fileloc[pane].encoding.m_unicoding = ucr::NONE;
 682                 if (fileloc[pane].encoding.m_unicoding == ucr::NONE && fileloc[pane].encoding.m_codepage == -1)
 683                 {
 684                         FileLocationGuessEncodings(fileloc[pane], iGuessEncodingType);
 685                 }
 686
 687                 // TODO (Perry, 2005-12-04)
 688                 // Should we do any unification if unicodings are different?
 689
 690
 691 #ifndef _UNICODE
 692                 // In ANSI (8-bit) build, character loss can occur in merging
 693                 // if the two buffers use different encodings
 694                 if (pane > 0 && fileloc[pane - 1].encoding.m_codepage != fileloc[pane].encoding.m_codepage)
 695                 {
 696                         CString msg;
 697                         msg.Format(theApp.LoadString(IDS_SUGGEST_IGNORECODEPAGE).c_str(), fileloc[pane - 1].encoding.m_codepage,fileloc[pane].encoding.m_codepage);
 698                         int msgflags = MB_YESNO | MB_ICONQUESTION | MB_DONT_ASK_AGAIN;
 699                         // Two files with different codepages
 700                         // Warn and propose to use the default codepage for both
 701                         int userChoice = AfxMessageBox(msg, msgflags);
 702                         if (userChoice == IDYES)
 703                         {
 704                                 fileloc[pane - 1].encoding.SetCodepage(ucr::getDefaultCodepage());
 705                                 fileloc[pane - 1].encoding.m_bom = false;
 706                                 fileloc[pane].encoding.SetCodepage(ucr::getDefaultCodepage());
 707                                 fileloc[pane].encoding.m_bom = false;
 708                         }
 709                 }
 710 #endif
 711         }
 712
 713         // Note that OpenDocs() takes care of closing compare window when needed.
 714         bool bResult = pMergeDoc->OpenDocs(nFiles, fileloc, GetROFromFlags(nFiles, dwFlags).data(), strDesc, GetActivePaneFromFlags(nFiles, dwFlags));
 715
 716         if (CChildFrame *pFrame = pMergeDoc->GetParentFrame())
 717         {
 718                 if (!pFrame->IsActivated())
 719                         pFrame->InitialUpdateFrame(pMergeDoc, true);
 720         }
 721
 722         if (!bResult)
 723                 return false;
 724
 725         for (int pane = 0; pane < nFiles; pane++)
 726         {
 727                 if (dwFlags)
 728                 {
 729                         bool bModified = (dwFlags[pane] & FFILEOPEN_MODIFIED) > 0;
 730                         if (bModified)
 731                         {
 732                                 pMergeDoc->m_ptBuf[pane]->SetModified(true);
 733                                 pMergeDoc->UpdateHeaderPath(pane);
 734                         }
 735                         if (dwFlags[pane] & FFILEOPEN_AUTOMERGE)
 736                         {
 737                                 pMergeDoc->DoAutoMerge(pane);
 738                         }
 739                 }
 740         }
 741
 742         if (!sReportFile.empty())
 743                 pMergeDoc->GenerateReport(sReportFile);
 744
 745         return true;
 746 }
 747
 748 bool CMainFrame::ShowHexMergeDoc(CDirDoc * pDirDoc, int nFiles, const FileLocation fileloc[],
 749         const DWORD dwFlags[], const String strDesc[], const String& sReportFile /*= _T("")*/,
 750         const PackingInfo * infoUnpacker /*= nullptr*/)
 751 {
 752         if (m_pMenus[MENU_HEXMERGEVIEW] == nullptr)
 753                 theApp.m_pHexMergeTemplate->m_hMenuShared = NewHexMergeViewMenu();
 754         CHexMergeDoc *pHexMergeDoc = GetMergeDocForDiff<CHexMergeDoc>(theApp.m_pHexMergeTemplate, pDirDoc, nFiles);
 755         if (pHexMergeDoc == nullptr)
 756                 return false;
 757
 758         if (!pHexMergeDoc->OpenDocs(nFiles, fileloc, GetROFromFlags(nFiles, dwFlags).data(), strDesc, GetActivePaneFromFlags(nFiles, dwFlags)))
 759                 return false;
 760
 761         if (!sReportFile.empty())
 762                 pHexMergeDoc->GenerateReport(sReportFile);
 763
 764         return true;
 765 }
 766
 767 bool CMainFrame::ShowImgMergeDoc(CDirDoc * pDirDoc, int nFiles, const FileLocation fileloc[],
 768         const DWORD dwFlags[], const String strDesc[], const String& sReportFile /*= _T("")*/,
 769         const PackingInfo * infoUnpacker /*= nullptr*/)
 770 {
 771         CImgMergeFrame *pImgMergeFrame = new CImgMergeFrame();
 772         if (!CImgMergeFrame::menu.m_hMenu)
 773                 CImgMergeFrame::menu.m_hMenu = NewImgMergeViewMenu();
 774         pImgMergeFrame->SetSharedMenu(CImgMergeFrame::menu.m_hMenu);
 775
 776         pImgMergeFrame->SetDirDoc(pDirDoc);
 777         pDirDoc->AddMergeDoc(pImgMergeFrame);
 778
 779         if (!pImgMergeFrame->OpenDocs(nFiles, fileloc, GetROFromFlags(nFiles, dwFlags).data(), strDesc, GetActivePaneFromFlags(nFiles, dwFlags), this))
 780                 return ShowMergeDoc(pDirDoc, nFiles, fileloc, dwFlags, strDesc, sReportFile, infoUnpacker);
 781
 782         for (int pane = 0; pane < nFiles; pane++)
 783         {
 784                 if (dwFlags && (dwFlags[pane] & FFILEOPEN_AUTOMERGE))
 785                         pImgMergeFrame->DoAutoMerge(pane);
 786         }
 787
 788         if (!sReportFile.empty())
 789                 pImgMergeFrame->GenerateReport(sReportFile);
 790
 791         return true;
 792 }
 793
 794 /**
 795  * @brief Show GNU licence information in notepad (local file) or in Web Browser
 796  */
 797 void CMainFrame::OnHelpGnulicense()
 798 {
 799         const String spath = paths::ConcatPath(env::GetProgPath(), LicenseFile);
 800         theApp.OpenFileOrUrl(spath.c_str(), LicenceUrl);
 801 }
 802
 803 /**
 804  * @brief Opens Options-dialog and saves changed options
 805  */
 806 void CMainFrame::OnOptions()
 807 {
 808         // Using singleton shared syntax colors
 809         CPreferencesDlg dlg(GetOptionsMgr(), theApp.GetMainSyntaxColors());
 810         INT_PTR rv = dlg.DoModal();
 811
 812         if (rv == IDOK)
 813         {
 814                 LANGID lang = static_cast<LANGID>(GetOptionsMgr()->GetInt(OPT_SELECTED_LANGUAGE));
 815                 if (lang != theApp.m_pLangDlg->GetLangId())
 816                 {
 817                         theApp.m_pLangDlg->SetLanguage(lang, true);
 818
 819                         // Update status bar inicator texts
 820                         theApp.SetIndicators(m_wndStatusBar, 0, 0);
 821
 822                         // Update the current menu
 823                         ReloadMenu();
 824
 825                         // update the title text of the document
 826                         UpdateDocTitle();
 827
 828                         UpdateResources();
 829                 }
 830
 831                 // Set new temporary path
 832                 theApp.SetupTempPath();
 833
 834                 // Set new filterpath
 835                 String filterPath = GetOptionsMgr()->GetString(OPT_FILTER_USERPATH);
 836                 theApp.m_pGlobalFileFilter->SetUserFilterPath(filterPath);
 837
 838                 theApp.UpdateCodepageModule();
 839
 840                 strdiff::SetBreakChars(GetOptionsMgr()->GetString(OPT_BREAK_SEPARATORS).c_str());
 841
 842                 // make an attempt at rescanning any open diff sessions
 843                 ApplyDiffOptions();
 844
 845                 // Update all dirdoc settings
 846                 for (auto pDirDoc : GetAllDirDocs())
 847                         pDirDoc->RefreshOptions();
 848                 for (auto pOpenDoc : GetAllOpenDocs())
 849                         pOpenDoc->RefreshOptions();
 850                 for (auto pMergeDoc : GetAllHexMergeDocs())
 851                         pMergeDoc->RefreshOptions();
 852         }
 853 }
 854
 855 static bool AddToRecentDocs(const PathContext& paths, const unsigned flags[], bool recurse, const String& filter)
 856 {
 857         String params, title;
 858         for (int nIndex = 0; nIndex < paths.GetSize(); ++nIndex)
 859         {
 860                 if (flags && (flags[nIndex] & FFILEOPEN_READONLY))
 861                 {
 862                         switch (nIndex)
 863                         {
 864                         case 0: params += _T("/wl "); break;
 865                         case 1: params += paths.GetSize() == 2 ? _T("/wr ") : _T("/wm "); break;
 866                         case 2: params += _T("/wr "); break;
 867                         }
 868                 }
 869                 params += _T("\"") + paths[nIndex] + _T("\" ");
 870
 871                 String path = paths[nIndex];
 872                 paths::normalize(path);
 873                 title += paths::FindFileName(path);
 874                 if (nIndex < paths.GetSize() - 1)
 875                         title += _T(" - ");
 876         }
 877         if (recurse)
 878                 params += _T("/r ");
 879         if (!filter.empty())
 880                 params += _T("/f \"") + filter + _T("\" ");
 881         return JumpList::AddToRecentDocs(_T(""), params, title, params, 0);
 882 }
 883
 884 /**
 885  * @brief Begin a diff: open dirdoc if it is directories, else open a mergedoc for editing.
 886  * @param [in] pszLeft Left-side path.
 887  * @param [in] pszRight Right-side path.
 888  * @param [in] dwLeftFlags Left-side flags.
 889  * @param [in] dwRightFlags Right-side flags.
 890  * @param [in] bRecurse Do we run recursive (folder) compare?
 891  * @param [in] pDirDoc Dir compare document to use.
 892  * @param [in] prediffer Prediffer plugin name.
 893  * @return `true` if opening files and compare succeeded, `false` otherwise.
 894  */
 895 bool CMainFrame::DoFileOpen(const PathContext * pFiles /*= nullptr*/,
 896         const DWORD dwFlags[] /*= nullptr*/, const String strDesc[] /*= nullptr*/, const String& sReportFile /*= T("")*/, bool bRecurse /*= false*/, CDirDoc *pDirDoc/*= nullptr*/,
 897         String prediffer /*= _T("")*/, const PackingInfo *infoUnpacker /*= nullptr*/)
 898 {
 899         if (pDirDoc != nullptr && !pDirDoc->CloseMergeDocs())
 900                 return false;
 901
 902         FileTransform::g_UnpackerMode = static_cast<PLUGIN_MODE>(theApp.GetProfileInt(_T("Settings"), _T("UnpackerMode"), PLUGIN_MANUAL));
 903         FileTransform::g_PredifferMode = static_cast<PLUGIN_MODE>(theApp.GetProfileInt(_T("Settings"), _T("PredifferMode"), PLUGIN_MANUAL));
 904
 905         Merge7zFormatMergePluginScope scope(infoUnpacker);
 906
 907         PathContext tFiles;
 908         if (pFiles != nullptr)
 909                 tFiles = *pFiles;
 910         bool bRO[3] = {0};
 911         if (dwFlags)
 912         {
 913                 bRO[0] = (dwFlags[0] & FFILEOPEN_READONLY) != 0;
 914                 bRO[1] = (dwFlags[1] & FFILEOPEN_READONLY) != 0;
 915                 bRO[2] = (dwFlags[2] & FFILEOPEN_READONLY) != 0;
 916         };
 917
 918         // pop up dialog unless arguments exist (and are compatible)
 919         paths::PATH_EXISTENCE pathsType = paths::GetPairComparability(tFiles, IsArchiveFile);
 920         if (pathsType == paths::DOES_NOT_EXIST)
 921         {
 922                 if (m_pMenus[MENU_OPENVIEW] == nullptr)
 923                         theApp.m_pOpenTemplate->m_hMenuShared = NewOpenViewMenu();
 924                 COpenDoc *pOpenDoc = static_cast<COpenDoc *>(theApp.m_pOpenTemplate->CreateNewDocument());
 925                 if (dwFlags)
 926                 {
 927                         pOpenDoc->m_dwFlags[0] = dwFlags[0];
 928                         pOpenDoc->m_dwFlags[1] = dwFlags[1];
 929                         pOpenDoc->m_dwFlags[2] = dwFlags[2];
 930                 }
 931                 pOpenDoc->m_files = tFiles;
 932                 pOpenDoc->m_bRecurse = bRecurse;
 933                 if (infoUnpacker)
 934                         pOpenDoc->m_infoHandler = *infoUnpacker;
 935                 CFrameWnd *pFrame = theApp.m_pOpenTemplate->CreateNewFrame(pOpenDoc, nullptr);
 936                 theApp.m_pOpenTemplate->InitialUpdateFrame(pFrame, pOpenDoc);
 937                 return true;
 938         }
 939         else
 940         {
 941                 // Add trailing '\' for directories if its missing
 942                 if (pathsType == paths::IS_EXISTING_DIR)
 943                 {
 944                         if (!paths::EndsWithSlash(tFiles[0]) && !IsArchiveFile(tFiles[0]))
 945                                 tFiles[0] = paths::AddTrailingSlash(tFiles[0]);
 946                         if (!paths::EndsWithSlash(tFiles[1]) && !IsArchiveFile(tFiles[1]))
 947                                 tFiles[1] = paths::AddTrailingSlash(tFiles[1]);
 948                         if (tFiles.GetSize() == 3 && !paths::EndsWithSlash(tFiles[2]) && !IsArchiveFile(tFiles[1]))
 949                                 tFiles[2] = paths::AddTrailingSlash(tFiles[2]);
 950                 }
 951
 952                 //save the MRU left and right files.
 953                 if (dwFlags)
 954                 {
 955                         if (!(dwFlags[0] & FFILEOPEN_NOMRU))
 956                                 addToMru(tFiles[0].c_str(), _T("Files\\Left"));
 957                         if (!(dwFlags[1] & FFILEOPEN_NOMRU))
 958                                 addToMru(tFiles[1].c_str(), _T("Files\\Right"));
 959                         if (tFiles.GetSize() == 3 && !(dwFlags[2] & FFILEOPEN_NOMRU))
 960                                 addToMru(tFiles[2].c_str(), _T("Files\\Option"));
 961                 }
 962         }
 963
 964         CTempPathContext *pTempPathContext = nullptr;
 965         if (pathsType == paths::IS_EXISTING_DIR)
 966         {
 967                 DecompressResult res= DecompressArchive(m_hWnd, tFiles);
 968                 if (res.pTempPathContext)
 969                 {
 970                         pathsType = res.pathsType;
 971                         tFiles = res.files;
 972                         pTempPathContext = res.pTempPathContext;
 973                 }
 974         }
 975
 976         // Determine if we want a new dirview open, now that we know if it was
 977         // an archive. Don't open a new dirview if we are comparing files.
 978         if (pDirDoc == nullptr)
 979         {
 980                 if (pathsType == paths::IS_EXISTING_DIR)
 981                 {
 982                         CDirDoc::m_nDirsTemp = tFiles.GetSize();
 983                         if (m_pMenus[MENU_DIRVIEW] == nullptr)
 984                                 theApp.m_pDirTemplate->m_hMenuShared = NewDirViewMenu();
 985                         pDirDoc = static_cast<CDirDoc*>(theApp.m_pDirTemplate->OpenDocumentFile(nullptr));
 986                 }
 987                 else
 988                 {
 989                         pDirDoc = static_cast<CDirDoc*>(theApp.m_pDirTemplate->CreateNewDocument());
 990                 }
 991         }
 992
 993         // open the diff
 994         if (pathsType == paths::IS_EXISTING_DIR)
 995         {
 996                 if (pDirDoc != nullptr)
 997                 {
 998                         // Anything that can go wrong inside InitCompare() will yield an
 999                         // exception. There is no point in checking return value.
1000                         pDirDoc->InitCompare(tFiles, bRecurse, pTempPathContext);
1001
1002                         pDirDoc->SetReportFile(sReportFile);
1003                         pDirDoc->SetDescriptions(strDesc);
1004                         pDirDoc->SetTitle(nullptr);
1005                         for (int nIndex = 0; nIndex < tFiles.GetSize(); nIndex++)
1006                                 pDirDoc->SetReadOnly(nIndex, bRO[nIndex]);
1007
1008                         pDirDoc->Rescan();
1009                 }
1010         }
1011         else
1012         {
1013                 FileLocation fileloc[3];
1014
1015                 for (int nPane = 0; nPane < tFiles.GetSize(); nPane++)
1016                         fileloc[nPane].setPath(tFiles[nPane]);
1017
1018                 if (!prediffer.empty())
1019                 {
1020                         String strBothFilenames = strutils::join(tFiles.begin(), tFiles.end(), _T("|"));
1021                         pDirDoc->GetPluginManager().SetPrediffer(strBothFilenames, prediffer);
1022                 }
1023
1024                 ShowAutoMergeDoc(pDirDoc, tFiles.GetSize(), fileloc, dwFlags, strDesc, sReportFile,
1025                                 infoUnpacker);
1026         }
1027
1028         if (pFiles != nullptr && (!dwFlags || !(dwFlags[0] & FFILEOPEN_NOMRU)))
1029         {
1030                 String filter = GetOptionsMgr()->GetString(OPT_FILEFILTER_CURRENT);
1031                 AddToRecentDocs(*pFiles, (unsigned *)dwFlags, bRecurse, filter);
1032         }
1033
1034         return true;
1035 }
1036
1037 void CMainFrame::UpdateFont(FRAMETYPE frame)
1038 {
1039         if (frame == FRAME_FOLDER)
1040         {
1041                 for (auto pDoc : GetAllDirDocs())
1042                 {
1043                         if (pDoc != nullptr)
1044                         {
1045                                 CDirView *pView = pDoc->GetMainView();
1046                                 if (pView != nullptr)
1047                                         pView->SetFont(m_lfDir);
1048                         }
1049                 }
1050         }
1051         else
1052         {
1053                 for (auto pDoc : GetAllMergeDocs())
1054                 {
1055                         CMergeDoc *pMergeDoc = dynamic_cast<CMergeDoc *>(pDoc);
1056                         if (pMergeDoc != nullptr)
1057                                 for (auto& pView: pMergeDoc->GetViewList())
1058                                         pView->SetFont(m_lfDiff);
1059                 }
1060         }
1061 }
1062
1063 /**
1064  * @brief Select font for Merge/Dir view
1065  *
1066  * Shows font selection dialog to user, sets current font and saves
1067  * selected font properties to registry. Selects fon type to active
1068  * view (Merge/Dir compare). If there is no open views, then font
1069  * is selected for Merge view (for example user may want to change to
1070  * unicode font before comparing files).
1071  */
1072 void CMainFrame::OnViewSelectfont()
1073 {
1074         FRAMETYPE frame = GetFrameType(GetActiveFrame());
1075         CHOOSEFONT cf = { sizeof CHOOSEFONT };
1076         LOGFONT *lf = nullptr;
1077         cf.Flags = CF_INITTOLOGFONTSTRUCT|CF_FORCEFONTEXIST|CF_SCREENFONTS;
1078         if (frame == FRAME_FILE)
1079                 cf.Flags |= CF_FIXEDPITCHONLY; // Only fixed-width fonts for merge view
1080
1081         // CF_FIXEDPITCHONLY = 0x00004000L
1082         // in case you are a developer and want to disable it to test with, eg, a Chinese capable font
1083         if (frame == FRAME_FOLDER)
1084                 lf = &m_lfDir;
1085         else
1086                 lf = &m_lfDiff;
1087
1088         cf.lpLogFont = lf;
1089
1090         if (ChooseFont(&cf))
1091         {
1092                 Options::Font::Save(GetOptionsMgr(), frame == FRAME_FOLDER ? OPT_FONT_DIRCMP : OPT_FONT_FILECMP, lf, true);
1093                 UpdateFont(frame);
1094         }
1095 }
1096
1097 /**
1098  * @brief Use default font for active view type
1099  *
1100  * Disable user-selected font for active view type (Merge/Dir compare).
1101  * If there is no open views, then Merge view font is changed.
1102  */
1103 void CMainFrame::OnViewUsedefaultfont()
1104 {
1105         FRAMETYPE frame = GetFrameType(GetActiveFrame());
1106
1107         if (frame == FRAME_FOLDER)
1108         {
1109                 Options::Font::Reset(GetOptionsMgr(), OPT_FONT_DIRCMP);
1110                 m_lfDir = Options::Font::Load(GetOptionsMgr(), OPT_FONT_DIRCMP);
1111                 Options::Font::Save(GetOptionsMgr(), OPT_FONT_DIRCMP, &m_lfDir, false);
1112         }
1113         else
1114         {
1115                 Options::Font::Reset(GetOptionsMgr(), OPT_FONT_FILECMP);
1116                 m_lfDiff = Options::Font::Load(GetOptionsMgr(), OPT_FONT_FILECMP);
1117                 Options::Font::Save(GetOptionsMgr(), OPT_FONT_FILECMP, &m_lfDiff, false);
1118         }
1119
1120         UpdateFont(frame);
1121 }
1122
1123 /**
1124  * @brief Update any resources necessary after a GUI language change
1125  */
1126 void CMainFrame::UpdateResources()
1127 {
1128         m_wndStatusBar.SetPaneText(0, theApp.LoadString(AFX_IDS_IDLEMESSAGE).c_str());
1129
1130         for (auto pDoc : GetAllDirDocs())
1131                 pDoc->UpdateResources();
1132         for (auto pDoc : GetAllMergeDocs())
1133                 pDoc->UpdateResources();
1134         for (auto pDoc : GetAllOpenDocs())
1135                 pDoc->UpdateResources();
1136 }
1137
1138 /**
1139  * @brief Open WinMerge help.
1140  *
1141  * If local HTMLhelp file is found, open it, otherwise open HTML page from web.
1142  */
1143 void CMainFrame::OnHelpContents()
1144 {
1145         theApp.ShowHelp();
1146 }
1147
1148 /**
1149  * @brief Handle translation of default messages on the status bar
1150  */
1151 void CMainFrame::GetMessageString(UINT nID, CString& rMessage) const
1152 {
1153         // load appropriate string
1154         const String s = theApp.LoadString(nID);
1155         if (s.length() > 0)
1156                 AfxExtractSubString(rMessage, s.c_str(), 0);
1157 }
1158
1159 void CMainFrame::ActivateFrame(int nCmdShow)
1160 {
1161         if (!m_bFirstTime)
1162         {
1163                 CMDIFrameWnd::ActivateFrame(nCmdShow);
1164                 return;
1165         }
1166
1167         m_bFirstTime = false;
1168
1169         WINDOWPLACEMENT wp;
1170         wp.length = sizeof(WINDOWPLACEMENT);
1171         GetWindowPlacement(&wp);
1172         wp.rcNormalPosition.left=theApp.GetProfileInt(_T("Settings"), _T("MainLeft"),0);
1173         wp.rcNormalPosition.top=theApp.GetProfileInt(_T("Settings"), _T("MainTop"),0);
1174         wp.rcNormalPosition.right=theApp.GetProfileInt(_T("Settings"), _T("MainRight"),0);
1175         wp.rcNormalPosition.bottom=theApp.GetProfileInt(_T("Settings"), _T("MainBottom"),0);
1176         if (nCmdShow != SW_MINIMIZE && theApp.GetProfileInt(_T("Settings"), _T("MainMax"), FALSE))
1177                 wp.showCmd = SW_MAXIMIZE;
1178         else
1179                 wp.showCmd = nCmdShow;
1180
1181         CRect dsk_rc,rc(wp.rcNormalPosition);
1182
1183         dsk_rc.left = ::GetSystemMetrics(SM_XVIRTUALSCREEN);
1184         dsk_rc.top = ::GetSystemMetrics(SM_YVIRTUALSCREEN);
1185         dsk_rc.right = dsk_rc.left + ::GetSystemMetrics(SM_CXVIRTUALSCREEN);
1186         dsk_rc.bottom = dsk_rc.top + ::GetSystemMetrics(SM_CYVIRTUALSCREEN);
1187         if (rc.Width() != 0 && rc.Height() != 0)
1188         {
1189                 // Ensure top-left corner is on visible area,
1190                 // 20 points margin is added to prevent "lost" window
1191                 CPoint ptTopLeft(rc.TopLeft());
1192                 ptTopLeft += CPoint(20, 20);
1193
1194                 if (dsk_rc.PtInRect(ptTopLeft))
1195                         SetWindowPlacement(&wp);
1196                 else
1197                         CMDIFrameWnd::ActivateFrame(nCmdShow);
1198         }
1199         else
1200                 CMDIFrameWnd::ActivateFrame(nCmdShow);
1201 }
1202
1203 /**
1204  * @brief Called when mainframe is about to be closed.
1205  * This function is called when mainframe is to be closed (not for
1206  * file/compare windows.
1207  */
1208 void CMainFrame::OnClose()
1209 {
1210         if (theApp.GetActiveOperations())
1211                 return;
1212
1213         // Check if there are multiple windows open and ask for closing them
1214         bool bAskClosing = GetOptionsMgr()->GetBool(OPT_ASK_MULTIWINDOW_CLOSE);
1215         if (bAskClosing)
1216         {
1217                 bool quit = AskCloseConfirmation();
1218                 if (!quit)
1219                         return;
1220         }
1221
1222         // Save last selected filter
1223         String filter = theApp.m_pGlobalFileFilter->GetFilterNameOrMask();
1224         GetOptionsMgr()->SaveOption(OPT_FILEFILTER_CURRENT, filter);
1225
1226         // save main window position
1227         WINDOWPLACEMENT wp;
1228         wp.length = sizeof(WINDOWPLACEMENT);
1229         GetWindowPlacement(&wp);
1230         theApp.WriteProfileInt(_T("Settings"), _T("MainLeft"),wp.rcNormalPosition.left);
1231         theApp.WriteProfileInt(_T("Settings"), _T("MainTop"),wp.rcNormalPosition.top);
1232         theApp.WriteProfileInt(_T("Settings"), _T("MainRight"),wp.rcNormalPosition.right);
1233         theApp.WriteProfileInt(_T("Settings"), _T("MainBottom"),wp.rcNormalPosition.bottom);
1234         theApp.WriteProfileInt(_T("Settings"), _T("MainMax"), (wp.showCmd == SW_MAXIMIZE));
1235
1236         // Close Non-Document/View frame with confirmation
1237         CMDIChildWnd *pChild = static_cast<CMDIChildWnd *>(CWnd::FromHandle(m_hWndMDIClient)->GetWindow(GW_CHILD));
1238         while (pChild != nullptr)
1239         {
1240                 CMDIChildWnd *pNextChild = static_cast<CMDIChildWnd *>(pChild->GetWindow(GW_HWNDNEXT));
1241                 if (GetFrameType(pChild) == FRAME_IMGFILE)
1242                 {
1243                         if (!static_cast<CImgMergeFrame *>(pChild)->CloseNow())
1244                                 return;
1245                 }
1246                 pChild = pNextChild;
1247         }
1248
1249         CMDIFrameWnd::OnClose();
1250 }
1251
1252 /**
1253  * @brief Utility function to update CSuperComboBox format MRU
1254  */
1255 void CMainFrame::addToMru(LPCTSTR szItem, LPCTSTR szRegSubKey, UINT nMaxItems)
1256 {
1257         std::vector<CString> list;
1258         CString s;
1259         UINT cnt = AfxGetApp()->GetProfileInt(szRegSubKey, _T("Count"), 0);
1260         list.push_back(szItem);
1261         for (UINT i=0 ; i<cnt; ++i)
1262         {
1263                 s = AfxGetApp()->GetProfileString(szRegSubKey, strutils::format(_T("Item_%d"), i).c_str());
1264                 if (s != szItem)
1265                         list.push_back(s);
1266         }
1267         cnt = list.size() > nMaxItems ? nMaxItems : static_cast<UINT>(list.size());
1268         for (UINT i=0 ; i<cnt; ++i)
1269                 AfxGetApp()->WriteProfileString(szRegSubKey, strutils::format(_T("Item_%d"), i).c_str(), list[i]);
1270         // update count
1271         AfxGetApp()->WriteProfileInt(szRegSubKey, _T("Count"), cnt);
1272 }
1273
1274 void CMainFrame::ApplyDiffOptions()
1275 {
1276         for (auto pMergeDoc : GetAllMergeDocs())
1277         {
1278                 // Re-read MergeDoc settings (also updates view settings)
1279                 // and rescan using new options
1280                 pMergeDoc->RefreshOptions();
1281                 pMergeDoc->FlushAndRescan(true);
1282         }
1283 }
1284
1285 /// Get list of OpenDocs (documents underlying edit sessions)
1286 OpenDocList &CMainFrame::GetAllOpenDocs()
1287 {
1288         return static_cast<OpenDocList &>(GetDocList(theApp.m_pOpenTemplate));
1289 }
1290
1291 /// Get list of MergeDocs (documents underlying edit sessions)
1292 MergeDocList &CMainFrame::GetAllMergeDocs()
1293 {
1294         return static_cast<MergeDocList &>(GetDocList(theApp.m_pDiffTemplate));
1295 }
1296
1297 /// Get list of DirDocs (documents underlying a scan)
1298 DirDocList &CMainFrame::GetAllDirDocs()
1299 {
1300         return static_cast<DirDocList &>(GetDocList(theApp.m_pDirTemplate));
1301 }
1302
1303 /// Get list of HexMergeDocs (documents underlying edit sessions)
1304 HexMergeDocList &CMainFrame::GetAllHexMergeDocs()
1305 {
1306         return static_cast<HexMergeDocList &>(GetDocList(theApp.m_pHexMergeTemplate));
1307 }
1308
1309 /**
1310  * @brief Obtain a merge doc to display a difference in files.
1311  * @return Pointer to CMergeDoc to use.
1312  */
1313 template<class DocClass>
1314 DocClass * GetMergeDocForDiff(CMultiDocTemplate *pTemplate, CDirDoc *pDirDoc, int nFiles, bool bMakeVisible)
1315 {
1316         // Create a new merge doc
1317         DocClass::m_nBuffersTemp = nFiles;
1318         DocClass *pMergeDoc = static_cast<DocClass*>(pTemplate->OpenDocumentFile(nullptr, bMakeVisible));
1319         if (pMergeDoc != nullptr)
1320         {
1321                 pDirDoc->AddMergeDoc(pMergeDoc);
1322                 pMergeDoc->SetDirDoc(pDirDoc);
1323         }
1324         return pMergeDoc;
1325 }
1326
1327 // Clear the item count in the main status pane
1328 void CMainFrame::ClearStatusbarItemCount()
1329 {
1330         m_wndStatusBar.SetPaneText(2, _T(""));
1331 }
1332
1333 /**
1334  * @brief Generate patch from files selected.
1335  *
1336  * Creates a patch from selected files in active directory compare, or
1337  * active file compare. Files in file compare must be saved before
1338  * creating a patch.
1339  */
1340 void CMainFrame::OnToolsGeneratePatch()
1341 {
1342         CPatchTool patcher;
1343         patcher.CreatePatch();
1344 }
1345
1346 void CMainFrame::OnDropFiles(const std::vector<String>& dropped_files)
1347 {
1348         PathContext tFiles(dropped_files);
1349         const size_t fileCount = tFiles.GetSize();
1350
1351         // If Ctrl pressed, do recursive compare
1352         bool recurse = !!::GetAsyncKeyState(VK_CONTROL) || GetOptionsMgr()->GetBool(OPT_CMP_INCLUDE_SUBDIRS);
1353
1354         // If user has <Shift> pressed with one file selected,
1355         // assume it is an archive and set filenames to same
1356         if (::GetAsyncKeyState(VK_SHIFT) < 0 && fileCount == 1)
1357         {
1358                 tFiles.SetRight(tFiles[0]);
1359         }
1360
1361         // Check if they dropped a project file
1362         DWORD dwFlags[3] = {FFILEOPEN_NONE, FFILEOPEN_NONE, FFILEOPEN_NONE};
1363         if (fileCount == 1)
1364         {
1365                 if (theApp.IsProjectFile(tFiles[0]))
1366                 {
1367                         theApp.LoadAndOpenProjectFile(tFiles[0]);
1368                         return;
1369                 }
1370                 if (IsConflictFile(tFiles[0]))
1371                 {
1372                         DoOpenConflict(tFiles[0], nullptr, true);
1373                         return;
1374                 }
1375         }
1376
1377         DoFileOpen(&tFiles, dwFlags, nullptr, _T(""), recurse);
1378 }
1379
1380 void CMainFrame::OnPluginUnpackMode(UINT nID )
1381 {
1382         switch (nID)
1383         {
1384         case ID_UNPACK_MANUAL:
1385                 FileTransform::g_UnpackerMode = PLUGIN_MANUAL;
1386                 break;
1387         case ID_UNPACK_AUTO:
1388                 FileTransform::g_UnpackerMode = PLUGIN_AUTO;
1389                 break;
1390         }
1391         theApp.WriteProfileInt(_T("Settings"), _T("UnpackerMode"), FileTransform::g_UnpackerMode);
1392 }
1393
1394 void CMainFrame::OnUpdatePluginUnpackMode(CCmdUI* pCmdUI)
1395 {
1396         pCmdUI->Enable(GetOptionsMgr()->GetBool(OPT_PLUGINS_ENABLED));
1397
1398         if (pCmdUI->m_nID == ID_UNPACK_MANUAL)
1399                 pCmdUI->SetRadio(PLUGIN_MANUAL == FileTransform::g_UnpackerMode);
1400         if (pCmdUI->m_nID == ID_UNPACK_AUTO)
1401                 pCmdUI->SetRadio(PLUGIN_AUTO == FileTransform::g_UnpackerMode);
1402 }
1403 void CMainFrame::OnPluginPrediffMode(UINT nID )
1404 {
1405         switch (nID)
1406         {
1407         case ID_PREDIFFER_MANUAL:
1408                 FileTransform::g_PredifferMode = PLUGIN_MANUAL;
1409                 break;
1410         case ID_PREDIFFER_AUTO:
1411                 FileTransform::g_PredifferMode = PLUGIN_AUTO;
1412                 break;
1413         }
1414         PrediffingInfo infoPrediffer;
1415         for (auto pMergeDoc : GetAllMergeDocs())
1416                 pMergeDoc->SetPrediffer(&infoPrediffer);
1417         for (auto pDirDoc : GetAllDirDocs())
1418                 pDirDoc->GetPluginManager().SetPrediffSettingAll(FileTransform::g_PredifferMode);
1419         theApp.WriteProfileInt(_T("Settings"), _T("PredifferMode"), FileTransform::g_PredifferMode);
1420 }
1421
1422 void CMainFrame::OnUpdatePluginPrediffMode(CCmdUI* pCmdUI)
1423 {
1424         pCmdUI->Enable(GetOptionsMgr()->GetBool(OPT_PLUGINS_ENABLED));
1425
1426         if (pCmdUI->m_nID == ID_PREDIFFER_MANUAL)
1427                 pCmdUI->SetRadio(PLUGIN_MANUAL == FileTransform::g_PredifferMode);
1428         if (pCmdUI->m_nID == ID_PREDIFFER_AUTO)
1429                 pCmdUI->SetRadio(PLUGIN_AUTO == FileTransform::g_PredifferMode);
1430 }
1431 /**
1432  * @brief Called when "Reload Plugins" item is updated
1433  */
1434 void CMainFrame::OnUpdateReloadPlugins(CCmdUI* pCmdUI)
1435 {
1436         pCmdUI->Enable(GetOptionsMgr()->GetBool(OPT_PLUGINS_ENABLED));
1437 }
1438
1439 void CMainFrame::OnReloadPlugins()
1440 {
1441         // delete all script interfaces
1442         // (interfaces will be created again automatically when WinMerge needs them)
1443         CAllThreadsScripts::GetActiveSet()->FreeAllScripts();
1444
1445         // update the editor scripts submenu
1446         HMENU scriptsSubmenu = GetScriptsSubmenu(m_hMenuDefault);
1447         if (scriptsSubmenu != nullptr)
1448                 CMergeEditView::createScriptsSubmenu(scriptsSubmenu);
1449         UpdatePrediffersMenu();
1450 }
1451
1452 /** @brief Return active merge edit view, if can figure it out/is available */
1453 CMergeEditView * CMainFrame::GetActiveMergeEditView()
1454 {
1455         // NB: GetActiveDocument does not return the Merge Doc
1456         //     even when the merge edit view is in front
1457         // NB: CChildFrame::GetActiveView returns `nullptr` when location view active
1458         // So we have this rather complicated logic to try to get a merge edit view
1459         // We look at the front child window, which should be a frame
1460         // and we can get a MergeEditView from it, if it is a CChildFrame
1461         // (DirViews use a different frame type)
1462         CChildFrame * pFrame = dynamic_cast<CChildFrame *>(GetActiveFrame());
1463         if (pFrame == nullptr) return nullptr;
1464         // Try to get the active MergeEditView (ie, left or right)
1465         if (pFrame->GetActiveView() != nullptr && pFrame->GetActiveView()->IsKindOf(RUNTIME_CLASS(CMergeEditView)))
1466         {
1467                 return dynamic_cast<CMergeEditView *>(pFrame->GetActiveView());
1468         }
1469         return pFrame->GetMergeDoc()->GetActiveMergeView();
1470 }
1471
1472 void CMainFrame::UpdatePrediffersMenu()
1473 {
1474         CMenu* menu = GetMenu();
1475         if (menu == nullptr)
1476         {
1477                 return;
1478         }
1479
1480         HMENU hMainMenu = menu->m_hMenu;
1481         HMENU prediffersSubmenu = GetPrediffersSubmenu(hMainMenu);
1482         if (prediffersSubmenu != nullptr)
1483         {
1484                 CMergeEditView * pEditView = GetActiveMergeEditView();
1485                 if (pEditView != nullptr)
1486                         pEditView->createPrediffersSubmenu(prediffersSubmenu);
1487                 else
1488                 {
1489                         // no view or dir view : display an empty submenu
1490                         int i = GetMenuItemCount(prediffersSubmenu);
1491                         while (i --)
1492                                 ::DeleteMenu(prediffersSubmenu, 0, MF_BYPOSITION);
1493                         ::AppendMenu(prediffersSubmenu, MF_SEPARATOR, 0, nullptr);
1494                 }
1495         }
1496 }
1497
1498 /**
1499  * @brief Save WinMerge configuration and info to file
1500  */
1501 void CMainFrame::OnSaveConfigData()
1502 {
1503         CConfigLog configLog;
1504         String sError;
1505
1506         if (configLog.WriteLogFile(sError))
1507         {
1508                 String sFileName = configLog.GetFileName();
1509                 theApp.OpenFileToExternalEditor(sFileName);
1510         }
1511         else
1512         {
1513                 String sFileName = configLog.GetFileName();
1514                 String msg = strutils::format_string2(_("Cannot open file\n%1\n\n%2"), sFileName, sError);
1515                 AfxMessageBox(msg.c_str(), MB_OK | MB_ICONSTOP);
1516         }
1517 }
1518
1519 /**
1520  * @brief Open two new empty docs, 'Scratchpads'
1521  *
1522  * Allows user to open two empty docs, to paste text to
1523  * compare from clipboard.
1524  * @note File filenames are set emptys and filedescriptors
1525  * are loaded from resource.
1526  * @sa CMergeDoc::OpenDocs()
1527  * @sa CMergeDoc::TrySaveAs()
1528  */
1529 void CMainFrame::FileNew(int nPanes)
1530 {
1531         CDirDoc *pDirDoc = static_cast<CDirDoc*>(theApp.m_pDirTemplate->CreateNewDocument());
1532
1533         // Load emptyfile descriptors and open empty docs
1534         // Use default codepage
1535         DWORD dwFlags[3] = {0, 0, 0};
1536         String strDesc[3];
1537         FileLocation fileloc[3];
1538         if (nPanes == 2)
1539         {
1540                 strDesc[0] = _("Untitled left");
1541                 strDesc[1] = _("Untitled right");
1542                 fileloc[0].encoding.SetCodepage(ucr::getDefaultCodepage());
1543                 fileloc[1].encoding.SetCodepage(ucr::getDefaultCodepage());
1544                 ShowMergeDoc(pDirDoc, 2, fileloc, dwFlags, strDesc);
1545         }
1546         else
1547         {
1548                 strDesc[0] = _("Untitled left");
1549                 strDesc[1] = _("Untitled middle");
1550                 strDesc[2] = _("Untitled right");
1551                 fileloc[0].encoding.SetCodepage(ucr::getDefaultCodepage());
1552                 fileloc[1].encoding.SetCodepage(ucr::getDefaultCodepage());
1553                 fileloc[2].encoding.SetCodepage(ucr::getDefaultCodepage());
1554                 ShowMergeDoc(pDirDoc, 3, fileloc, dwFlags, strDesc);
1555         }
1556 }
1557
1558 /**
1559  * @brief Open two new empty docs, 'Scratchpads'
1560  *
1561  * Allows user to open two empty docs, to paste text to
1562  * compare from clipboard.
1563  * @note File filenames are set emptys and filedescriptors
1564  * are loaded from resource.
1565  * @sa CMergeDoc::OpenDocs()
1566  * @sa CMergeDoc::TrySaveAs()
1567  */
1568 void CMainFrame::OnFileNew()
1569 {
1570         FileNew(2);
1571 }
1572
1573 void CMainFrame::OnFileNew3()
1574 {
1575         FileNew(3);
1576 }
1577
1578 /**
1579  * @brief Open Filters dialog
1580  */
1581 void CMainFrame::OnToolsFilters()
1582 {
1583         String title = _("Filters");
1584         CPropertySheet sht(title.c_str());
1585         LineFiltersDlg lineFiltersDlg;
1586         FileFiltersDlg fileFiltersDlg;
1587         vector<FileFilterInfo> fileFilters;
1588         std::unique_ptr<LineFiltersList> lineFilters(new LineFiltersList());
1589         String selectedFilter;
1590         const String origFilter = theApp.m_pGlobalFileFilter->GetFilterNameOrMask();
1591         sht.AddPage(&fileFiltersDlg);
1592         sht.AddPage(&lineFiltersDlg);
1593         sht.m_psh.dwFlags |= PSH_NOAPPLYNOW; // Hide 'Apply' button since we don't need it
1594
1595         // Make sure all filters are up-to-date
1596         theApp.m_pGlobalFileFilter->ReloadUpdatedFilters();
1597
1598         theApp.m_pGlobalFileFilter->GetFileFilters(&fileFilters, selectedFilter);
1599         fileFiltersDlg.SetFilterArray(&fileFilters);
1600         fileFiltersDlg.SetSelected(selectedFilter);
1601         const bool lineFiltersEnabledOrig = GetOptionsMgr()->GetBool(OPT_LINEFILTER_ENABLED);
1602         lineFiltersDlg.m_bIgnoreRegExp = lineFiltersEnabledOrig;
1603
1604         lineFilters->CloneFrom(theApp.m_pLineFilters.get());
1605         lineFiltersDlg.SetList(lineFilters.get());
1606
1607         if (sht.DoModal() == IDOK)
1608         {
1609                 String strNone = _("<None>");
1610                 String path = fileFiltersDlg.GetSelected();
1611                 if (path.find(strNone) != String::npos)
1612                 {
1613                         // Don't overwrite mask we already have
1614                         if (!theApp.m_pGlobalFileFilter->IsUsingMask())
1615                         {
1616                                 String sFilter(_T("*.*"));
1617                                 theApp.m_pGlobalFileFilter->SetFilter(sFilter);
1618                                 GetOptionsMgr()->SaveOption(OPT_FILEFILTER_CURRENT, sFilter);
1619                         }
1620                 }
1621                 else
1622                 {
1623                         theApp.m_pGlobalFileFilter->SetFileFilterPath(path);
1624                         theApp.m_pGlobalFileFilter->UseMask(false);
1625                         String sFilter = theApp.m_pGlobalFileFilter->GetFilterNameOrMask();
1626                         GetOptionsMgr()->SaveOption(OPT_FILEFILTER_CURRENT, sFilter);
1627                 }
1628                 bool linefiltersEnabled = lineFiltersDlg.m_bIgnoreRegExp;
1629                 GetOptionsMgr()->SaveOption(OPT_LINEFILTER_ENABLED, linefiltersEnabled);
1630
1631                 // Check if compare documents need rescanning
1632                 bool bFileCompareRescan = false;
1633                 bool bFolderCompareRescan = false;
1634                 CFrameWnd * pFrame = GetActiveFrame();
1635                 FRAMETYPE frame = GetFrameType(pFrame);
1636                 if (frame == FRAME_FILE)
1637                 {
1638                         if (lineFiltersEnabledOrig != linefiltersEnabled ||
1639                                         !theApp.m_pLineFilters->Compare(lineFilters.get()))
1640                         {
1641                                 bFileCompareRescan = true;
1642                         }
1643                 }
1644                 else if (frame == FRAME_FOLDER)
1645                 {
1646                         const String newFilter = theApp.m_pGlobalFileFilter->GetFilterNameOrMask();
1647                         if (lineFiltersEnabledOrig != linefiltersEnabled ||
1648                                         !theApp.m_pLineFilters->Compare(lineFilters.get()) || origFilter != newFilter)
1649                         {
1650                                 int res = LangMessageBox(IDS_FILTERCHANGED, MB_ICONWARNING | MB_YESNO);
1651                                 if (res == IDYES)
1652                                         bFolderCompareRescan = true;
1653                         }
1654                 }
1655
1656                 // Save new filters before (possibly) rescanning
1657                 theApp.m_pLineFilters->CloneFrom(lineFilters.get());
1658                 theApp.m_pLineFilters->SaveFilters();
1659
1660                 if (bFileCompareRescan)
1661                 {
1662                         for (auto pMergeDoc : GetAllMergeDocs())
1663                                 pMergeDoc->FlushAndRescan(true);
1664                 }
1665                 else if (bFolderCompareRescan)
1666                 {
1667                         for (auto pDirDoc : GetAllDirDocs())
1668                                 pDirDoc->Rescan();
1669                 }
1670         }
1671 }
1672
1673 /**
1674  * @brief Open Filters dialog.
1675  */
1676 void CMainFrame::SelectFilter()
1677 {
1678         OnToolsFilters();
1679 }
1680
1681 /**
1682  * @brief Closes application with ESC.
1683  *
1684  * Application is closed if:
1685  * - 'Close Windows with ESC' option is enabled and
1686  *    there is no open document windows
1687  * - '-e' commandline switch is given
1688  */
1689 BOOL CMainFrame::PreTranslateMessage(MSG* pMsg)
1690 {
1691         // Check if we got 'ESC pressed' -message
1692         if ((pMsg->message == WM_KEYDOWN) && (pMsg->wParam == VK_ESCAPE))
1693         {
1694                 if (theApp.m_bEscShutdown && m_wndTabBar.GetItemCount() <= 1)
1695                 {
1696                         AfxGetMainWnd()->SendMessage(WM_COMMAND, ID_APP_EXIT);
1697                         return TRUE;
1698                 }
1699                 else if (GetOptionsMgr()->GetBool(OPT_CLOSE_WITH_ESC) && m_wndTabBar.GetItemCount() == 0)
1700                 {
1701                         AfxGetMainWnd()->PostMessage(WM_COMMAND, ID_APP_EXIT);
1702                         return FALSE;
1703                 }
1704         }
1705         return CMDIFrameWnd::PreTranslateMessage(pMsg);
1706 }
1707
1708 /**
1709  * @brief Show/hide statusbar.
1710  */
1711 void CMainFrame::OnViewStatusBar()
1712 {
1713         bool bShow = !GetOptionsMgr()->GetBool(OPT_SHOW_STATUSBAR);
1714         GetOptionsMgr()->SaveOption(OPT_SHOW_STATUSBAR, bShow);
1715
1716         CMDIFrameWnd::ShowControlBar(&m_wndStatusBar, bShow, 0);
1717 }
1718
1719 /**
1720  * @brief Updates "Show Tabbar" menuitem.
1721  */
1722 void CMainFrame::OnUpdateViewTabBar(CCmdUI* pCmdUI)
1723 {
1724         pCmdUI->SetCheck(GetOptionsMgr()->GetBool(OPT_SHOW_TABBAR));
1725 }
1726
1727 /**
1728  * @brief Show/hide tabbar.
1729  */
1730 void CMainFrame::OnViewTabBar()
1731 {
1732         bool bShow = !GetOptionsMgr()->GetBool(OPT_SHOW_TABBAR);
1733         GetOptionsMgr()->SaveOption(OPT_SHOW_TABBAR, bShow);
1734
1735         CMDIFrameWnd::ShowControlBar(&m_wndTabBar, bShow, 0);
1736 }
1737
1738 /**
1739  * @brief Updates "Automatically Resize Panes" menuitem.
1740  */
1741 void CMainFrame::OnUpdateResizePanes(CCmdUI* pCmdUI)
1742 {
1743         pCmdUI->SetCheck(GetOptionsMgr()->GetBool(OPT_RESIZE_PANES));
1744 }
1745
1746
1747 /**
1748  * @brief Enable/disable automatic pane resizing.
1749  */
1750 void CMainFrame::OnResizePanes()
1751 {
1752         bool bResize = !GetOptionsMgr()->GetBool(OPT_RESIZE_PANES);
1753         GetOptionsMgr()->SaveOption(OPT_RESIZE_PANES, bResize);
1754         // TODO: Introduce a common merge frame superclass?
1755         CFrameWnd *pActiveFrame = GetActiveFrame();
1756         if (CChildFrame *pFrame = DYNAMIC_DOWNCAST(CChildFrame, pActiveFrame))
1757         {
1758                 pFrame->UpdateAutoPaneResize();
1759                 if (bResize)
1760                         pFrame->UpdateSplitter();
1761         }
1762         else if (CHexMergeFrame *pFrame1 = DYNAMIC_DOWNCAST(CHexMergeFrame, pActiveFrame))
1763         {
1764                 pFrame1->UpdateAutoPaneResize();
1765                 if (bResize)
1766                         pFrame1->UpdateSplitter();
1767         }
1768 }
1769
1770 /**
1771  * @brief Open project-file.
1772  */
1773 void CMainFrame::OnFileOpenProject()
1774 {
1775         String sFilepath;
1776
1777         // get the default projects path
1778         String strProjectPath = GetOptionsMgr()->GetString(OPT_PROJECTS_PATH);
1779         if (!SelectFile(GetSafeHwnd(), sFilepath, true, strProjectPath.c_str(), _T(""),
1780                         _("WinMerge Project Files (*.WinMerge)|*.WinMerge||")))
1781                 return;
1782
1783         strProjectPath = paths::GetParentPath(sFilepath);
1784         // store this as the new project path
1785         GetOptionsMgr()->SaveOption(OPT_PROJECTS_PATH, strProjectPath);
1786
1787         theApp.LoadAndOpenProjectFile(sFilepath.c_str());
1788 }
1789
1790 /**
1791  * @brief Receive command line from another instance.
1792  *
1793  * This function receives command line when only single-instance
1794  * is allowed. New instance tried to start sends its command line
1795  * to here so we can open paths it was meant to.
1796  */
1797 LRESULT CMainFrame::OnCopyData(WPARAM wParam, LPARAM lParam)
1798 {
1799         COPYDATASTRUCT *pCopyData = (COPYDATASTRUCT*)lParam;
1800         LPCTSTR pchData = (LPCTSTR)pCopyData->lpData;
1801         // Bail out if data isn't zero-terminated
1802         DWORD cchData = pCopyData->cbData / sizeof(TCHAR);
1803         if (cchData == 0 || pchData[cchData - 1] != _T('\0'))
1804                 return FALSE;
1805         ReplyMessage(TRUE);
1806         MergeCmdLineInfo cmdInfo(pchData);
1807         theApp.ApplyCommandLineConfigOptions(cmdInfo);
1808         theApp.ParseArgsAndDoOpen(cmdInfo, this);
1809         return TRUE;
1810 }
1811
1812 LRESULT CMainFrame::OnUser1(WPARAM wParam, LPARAM lParam)
1813 {
1814         CFrameWnd * pFrame = GetActiveFrame();
1815         if (pFrame != nullptr)
1816         {
1817                 IMergeDoc *pMergeDoc = dynamic_cast<IMergeDoc *>(pFrame->GetActiveDocument());
1818                 if (pMergeDoc == nullptr)
1819                         pMergeDoc = dynamic_cast<IMergeDoc *>(pFrame);
1820                 if (pMergeDoc != nullptr)
1821                         pMergeDoc->CheckFileChanged();
1822         }
1823         return 0;
1824 }
1825
1826 /**
1827  * @brief Close all open windows.
1828  *
1829  * Asks about saving unsaved files and then closes all open windows.
1830  */
1831 void CMainFrame::OnWindowCloseAll()
1832 {
1833         CMDIChildWnd *pChild = MDIGetActive();
1834         while (pChild != nullptr)
1835         {
1836                 CDocument* pDoc;
1837                 if ((pDoc = pChild->GetActiveDocument()) != nullptr)
1838                 {
1839                         if (!pDoc->SaveModified())
1840                                 return;
1841                         pDoc->OnCloseDocument();
1842                 }
1843                 else if (GetFrameType(pChild) == FRAME_IMGFILE)
1844                 {
1845                         if (!static_cast<CImgMergeFrame *>(pChild)->CloseNow())
1846                                 return;
1847                 }
1848                 else
1849                 {
1850                         pChild->DestroyWindow();
1851                 }
1852                 pChild = MDIGetActive();
1853         }
1854         return;
1855 }
1856
1857 /**
1858  * @brief Enables Window/Close All item if there are open windows.
1859  */
1860 void CMainFrame::OnUpdateWindowCloseAll(CCmdUI* pCmdUI)
1861 {
1862         const MergeDocList &mergedocs = GetAllMergeDocs();
1863         if (!mergedocs.IsEmpty())
1864         {
1865                 pCmdUI->Enable(TRUE);
1866                 return;
1867         }
1868
1869         const DirDocList &dirdocs = GetAllDirDocs();
1870         pCmdUI->Enable(!dirdocs.IsEmpty());
1871 }
1872
1873 /**
1874  * @brief Access to the singleton main frame (where we have some globals)
1875  */
1876 CMainFrame * GetMainFrame()
1877 {
1878         CWnd * mainwnd = AfxGetMainWnd();
1879         ASSERT(mainwnd != nullptr);
1880         CMainFrame *pMainframe = dynamic_cast<CMainFrame*>(mainwnd);
1881         ASSERT(pMainframe != nullptr);
1882         return pMainframe;
1883 }
1884
1885 /**
1886  * @brief Opens dialog for user to Load, edit and save project files.
1887  * This dialog gets current compare paths and filter (+other properties
1888  * possible in project files) and initializes the dialog with them.
1889  */
1890 void CMainFrame::OnSaveProject()
1891 {
1892         if (m_pMenus[MENU_OPENVIEW] == nullptr)
1893                 theApp.m_pOpenTemplate->m_hMenuShared = NewOpenViewMenu();
1894         COpenDoc *pOpenDoc = static_cast<COpenDoc *>(theApp.m_pOpenTemplate->CreateNewDocument());
1895
1896         PathContext paths;
1897         CFrameWnd * pFrame = GetActiveFrame();
1898         FRAMETYPE frame = GetFrameType(pFrame);
1899
1900         if (frame == FRAME_FILE)
1901         {
1902                 CMergeDoc * pMergeDoc = static_cast<CMergeDoc *>(pFrame->GetActiveDocument());
1903                 pOpenDoc->m_files = pMergeDoc->m_filePaths;
1904                 for (size_t pane = 0; pane < pOpenDoc->m_files.size(); ++pane)
1905                         pOpenDoc->m_dwFlags[pane] = FFILEOPEN_PROJECT | (pMergeDoc->m_ptBuf[pane]->GetReadOnly() ? FFILEOPEN_PROJECT : 0);
1906                 pOpenDoc->m_bRecurse = GetOptionsMgr()->GetBool(OPT_CMP_INCLUDE_SUBDIRS);
1907                 pOpenDoc->m_strExt = theApp.m_pGlobalFileFilter->GetFilterNameOrMask();
1908         }
1909         else if (frame == FRAME_FOLDER)
1910         {
1911                 // Get paths currently in compare
1912                 const CDirDoc * pDoc = static_cast<const CDirDoc*>(pFrame->GetActiveDocument());
1913                 const CDiffContext& ctxt = pDoc->GetDiffContext();
1914
1915                 // Set-up the dialog
1916                 for (int pane = 0; pane < ctxt.GetCompareDirs(); ++pane)
1917                 {
1918                         pOpenDoc->m_dwFlags[pane] = FFILEOPEN_PROJECT | (pDoc->GetReadOnly(pane) ? FFILEOPEN_READONLY : 0);
1919                         pOpenDoc->m_files.SetPath(pane, paths::AddTrailingSlash(ctxt.GetNormalizedPath(pane)));
1920                 }
1921                 pOpenDoc->m_bRecurse = ctxt.m_bRecursive;
1922                 pOpenDoc->m_strExt = static_cast<FileFilterHelper *>(ctxt.m_piFilterGlobal)->GetFilterNameOrMask();
1923         }
1924
1925         CFrameWnd *pOpenFrame = theApp.m_pOpenTemplate->CreateNewFrame(pOpenDoc, nullptr);
1926         theApp.m_pOpenTemplate->InitialUpdateFrame(pOpenFrame, pOpenDoc);
1927 }
1928
1929 /**
1930  * @brief Start flashing window if window is inactive.
1931  */
1932 void CMainFrame::StartFlashing()
1933 {
1934         CWnd * activeWindow = GetActiveWindow();
1935         if (activeWindow != this)
1936                 FlashWindowEx(FLASHW_ALL | FLASHW_TIMERNOFG, 0, 0);
1937 }
1938
1939 #if _MFC_VER > 0x0600
1940 void CMainFrame::OnActivateApp(BOOL bActive, DWORD dwThreadID)
1941 #else
1942 void CMainFrame::OnActivateApp(BOOL bActive, HTASK hTask)
1943 #endif
1944 {
1945 #if _MFC_VER > 0x0600
1946         CMDIFrameWnd::OnActivateApp(bActive, dwThreadID);
1947 #else
1948         CMDIFrameWnd::OnActivateApp(bActive, hTask);
1949 #endif
1950
1951         CFrameWnd * pFrame = GetActiveFrame();
1952         if (pFrame != nullptr)
1953         {
1954                 IMergeDoc *pMergeDoc = dynamic_cast<IMergeDoc *>(pFrame->GetActiveDocument());
1955                 if (pMergeDoc == nullptr)
1956                         pMergeDoc = dynamic_cast<IMergeDoc *>(pFrame);
1957                 if (pMergeDoc != nullptr)
1958                         PostMessage(WM_USER+1);
1959         }
1960 }
1961
1962 BOOL CMainFrame::CreateToolbar()
1963 {
1964         if (!m_wndToolBar.CreateEx(this) ||
1965                 !m_wndToolBar.LoadToolBar(IDR_MAINFRAME))
1966         {
1967                 return FALSE;
1968         }
1969
1970         if (!m_wndReBar.Create(this))
1971         {
1972                 return FALSE;
1973         }
1974
1975         VERIFY(m_wndToolBar.ModifyStyle(0, TBSTYLE_FLAT|TBSTYLE_TRANSPARENT));
1976
1977         // Remove this if you don't want tool tips or a resizable toolbar
1978         m_wndToolBar.SetBarStyle(m_wndToolBar.GetBarStyle() |
1979                 CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
1980         m_wndToolBar.GetToolBarCtrl().SetExtendedStyle(TBSTYLE_EX_DRAWDDARROWS);
1981
1982         m_wndReBar.AddBar(&m_wndToolBar);
1983
1984         LoadToolbarImages();
1985
1986         UINT nID, nStyle;
1987         int iImage;
1988         int index = m_wndToolBar.GetToolBarCtrl().CommandToIndex(ID_OPTIONS);
1989         m_wndToolBar.GetButtonInfo(index, nID, nStyle, iImage);
1990         nStyle |= TBSTYLE_DROPDOWN;
1991         m_wndToolBar.SetButtonInfo(index, nID, nStyle, iImage);
1992
1993         if (!GetOptionsMgr()->GetBool(OPT_SHOW_TOOLBAR))
1994         {
1995                 CMDIFrameWnd::ShowControlBar(&m_wndToolBar, false, 0);
1996         }
1997
1998         return TRUE;
1999 }
2000
2001 /** @brief Load toolbar images from the resource. */
2002 void CMainFrame::LoadToolbarImages()
2003 {
2004         const int toolbarSize = 16 << GetOptionsMgr()->GetInt(OPT_TOOLBAR_SIZE);
2005         CToolBarCtrl& BarCtrl = m_wndToolBar.GetToolBarCtrl();
2006
2007         m_ToolbarImages[TOOLBAR_IMAGES_ENABLED].DeleteImageList();
2008         m_ToolbarImages[TOOLBAR_IMAGES_DISABLED].DeleteImageList();
2009         CSize sizeButton(0, 0);
2010
2011         LoadToolbarImageList(toolbarSize,
2012                 toolbarSize <= 16 ? IDB_TOOLBAR_ENABLED : IDB_TOOLBAR_ENABLED32,
2013                 toolbarSize <= 16 ? IDB_TOOLBAR_ENABLED_MASK : IDB_TOOLBAR_ENABLED_MASK32,
2014                 false, m_ToolbarImages[TOOLBAR_IMAGES_ENABLED]);
2015         LoadToolbarImageList(toolbarSize,
2016                 toolbarSize <= 16 ? IDB_TOOLBAR_ENABLED : IDB_TOOLBAR_ENABLED32,
2017                 toolbarSize <= 16 ? IDB_TOOLBAR_ENABLED_MASK : IDB_TOOLBAR_ENABLED_MASK32,
2018                 true, m_ToolbarImages[TOOLBAR_IMAGES_DISABLED]);
2019         sizeButton = CSize(toolbarSize + 8, toolbarSize + 8);
2020
2021         BarCtrl.SetButtonSize(sizeButton);
2022         BarCtrl.SetImageList(&m_ToolbarImages[TOOLBAR_IMAGES_ENABLED]);
2023         BarCtrl.SetDisabledImageList(&m_ToolbarImages[TOOLBAR_IMAGES_DISABLED]);
2024         m_ToolbarImages[TOOLBAR_IMAGES_ENABLED].Detach();
2025         m_ToolbarImages[TOOLBAR_IMAGES_DISABLED].Detach();
2026
2027         // resize the rebar.
2028         REBARBANDINFO rbbi = { sizeof REBARBANDINFO };
2029         rbbi.fMask = RBBIM_CHILDSIZE;
2030         rbbi.cyMinChild = sizeButton.cy;
2031         m_wndReBar.GetReBarCtrl().SetBandInfo(0, &rbbi);
2032 }
2033
2034
2035 /**
2036  * @brief Load a transparent 24-bit color image list.
2037  */
2038 static void LoadHiColImageList(UINT nIDResource, UINT nIDResourceMask, int nWidth, int nHeight, int nCount, bool bGrayscale, CImageList& ImgList)
2039 {
2040         CBitmap bm, bmMask;
2041         bm.Attach(LoadImage(AfxGetInstanceHandle(), MAKEINTRESOURCE(nIDResource), IMAGE_BITMAP, nWidth * nCount, nHeight, LR_DEFAULTCOLOR));
2042         bmMask.Attach(LoadImage(AfxGetInstanceHandle(), MAKEINTRESOURCE(nIDResourceMask), IMAGE_BITMAP, nWidth * nCount, nHeight, LR_MONOCHROME));
2043         if (bGrayscale)
2044                 GrayScale(&bm);
2045         VERIFY(ImgList.Create(nWidth, nHeight, ILC_COLORDDB|ILC_MASK, nCount, 0));
2046         int nIndex = ImgList.Add(&bm, &bmMask);
2047         ASSERT(-1 != nIndex);
2048 }
2049
2050 /**
2051  * @brief Load toolbar image list.
2052  */
2053 static void LoadToolbarImageList(int imageWidth, UINT nIDResource, UINT nIDResourceMask, bool bGrayscale,
2054                 CImageList& ImgList)
2055 {
2056         const int ImageCount = 22;
2057         const int imageHeight = imageWidth - 1;
2058         LoadHiColImageList(nIDResource, nIDResourceMask, imageWidth, imageHeight, ImageCount, bGrayscale, ImgList);
2059 }
2060
2061 /**
2062  * @brief Called when the document title is modified.
2063  */
2064 void CMainFrame::OnUpdateFrameTitle(BOOL bAddToTitle)
2065 {
2066         CFrameWnd::OnUpdateFrameTitle(bAddToTitle);
2067
2068         if (m_wndTabBar.m_hWnd != nullptr)
2069                 m_wndTabBar.UpdateTabs();
2070 }
2071
2072 /** @brief Show none/small/big/huge toolbar. */
2073 void CMainFrame::OnToolbarSize(UINT id)
2074 {
2075         if (id == ID_TOOLBAR_NONE)
2076         {
2077                 GetOptionsMgr()->SaveOption(OPT_SHOW_TOOLBAR, false);
2078                 CMDIFrameWnd::ShowControlBar(&m_wndToolBar, false, 0);
2079         }
2080         else
2081         {
2082                 GetOptionsMgr()->SaveOption(OPT_SHOW_TOOLBAR, true);
2083                 GetOptionsMgr()->SaveOption(OPT_TOOLBAR_SIZE, id - ID_TOOLBAR_SMALL);
2084
2085                 LoadToolbarImages();
2086
2087                 CMDIFrameWnd::ShowControlBar(&m_wndToolBar, true, 0);
2088         }
2089 }
2090
2091 /** @brief Show none/small/big/huge toolbar. */
2092 void CMainFrame::OnUpdateToolbarSize(CCmdUI *pCmdUI)
2093 {
2094         if (!GetOptionsMgr()->GetBool(OPT_SHOW_TOOLBAR))
2095                 pCmdUI->SetRadio(pCmdUI->m_nID == ID_TOOLBAR_NONE);
2096         else
2097                 pCmdUI->SetRadio((pCmdUI->m_nID - ID_TOOLBAR_SMALL) == static_cast<UINT>(GetOptionsMgr()->GetInt(OPT_TOOLBAR_SIZE)));
2098 }
2099
2100 /** @brief Lang aware version of CFrameWnd::OnToolTipText() */
2101 BOOL CMainFrame::OnToolTipText(UINT, NMHDR* pNMHDR, LRESULT* pResult)
2102 {
2103         ASSERT(pNMHDR->code == TTN_NEEDTEXTA || pNMHDR->code == TTN_NEEDTEXTW);
2104
2105         // need to handle both ANSI and UNICODE versions of the message
2106         TOOLTIPTEXTA* pTTTA = (TOOLTIPTEXTA*)pNMHDR;
2107         TOOLTIPTEXTW* pTTTW = (TOOLTIPTEXTW*)pNMHDR;
2108         String strFullText;
2109         CString strTipText;
2110         UINT_PTR nID = pNMHDR->idFrom;
2111         if (pNMHDR->code == TTN_NEEDTEXTA && (pTTTA->uFlags & TTF_IDISHWND) ||
2112                 pNMHDR->code == TTN_NEEDTEXTW && (pTTTW->uFlags & TTF_IDISHWND))
2113         {
2114                 // idFrom is actually the HWND of the tool
2115                 nID = ::GetDlgCtrlID((HWND)nID);
2116         }
2117
2118         if (nID != 0) // will be zero on a separator
2119         {
2120                 strFullText = theApp.LoadString(static_cast<UINT>(nID));
2121                 // don't handle the message if no string resource found
2122                 if (strFullText.empty())
2123                         return FALSE;
2124
2125                 // this is the command id, not the button index
2126                 AfxExtractSubString(strTipText, strFullText.c_str(), 1, '\n');
2127         }
2128 #ifndef _UNICODE
2129         if (pNMHDR->code == TTN_NEEDTEXTA)
2130                 lstrcpyn(pTTTA->szText, strTipText, countof(pTTTA->szText));
2131         else
2132                 _mbstowcsz(pTTTW->szText, strTipText, countof(pTTTW->szText));
2133 #else
2134         if (pNMHDR->code == TTN_NEEDTEXTA)
2135                 _wcstombsz(pTTTA->szText, strTipText, countof(pTTTA->szText));
2136         else
2137                 lstrcpyn(pTTTW->szText, strTipText, countof(pTTTW->szText));
2138 #endif
2139         *pResult = 0;
2140
2141         // bring the tooltip window above other popup windows
2142         ::SetWindowPos(pNMHDR->hwndFrom, HWND_TOP, 0, 0, 0, 0,
2143                 SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOOWNERZORDER);
2144
2145         return TRUE;    // message was handled
2146 }
2147
2148 /**
2149  * @brief Ask user for close confirmation when closing the mainframe.
2150  * This function asks if user wants to close multiple open windows when user
2151  * selects (perhaps accidentally) to close WinMerge (application).
2152  * @return true if user agreeds to close all windows.
2153  */
2154 bool CMainFrame::AskCloseConfirmation()
2155 {
2156         const DirDocList &dirdocs = GetAllDirDocs();
2157         const MergeDocList &mergedocs = GetAllMergeDocs();
2158
2159         int ret = IDYES;
2160         const size_t count = dirdocs.GetCount() + mergedocs.GetCount();
2161         if (count > 1)
2162         {
2163                 // Check that we don't have one empty dirdoc + mergedoc situation.
2164                 // That happens since we open "hidden" dirdoc for every file compare.
2165                 if (dirdocs.GetCount() == 1)
2166                 {
2167                         CDirDoc *pDoc = dirdocs.GetHead();
2168                         if (!pDoc->HasDiffs())
2169                                 return true;
2170                 }
2171                 ret = LangMessageBox(IDS_CLOSEALL_WINDOWS, MB_YESNO | MB_ICONWARNING);
2172         }
2173         return (ret == IDYES);
2174 }
2175
2176 /**
2177  * @brief Shows the release notes for user.
2178  * This function opens release notes HTML document into browser.
2179  */
2180 void CMainFrame::OnHelpReleasenotes()
2181 {
2182         const String sPath = paths::ConcatPath(env::GetProgPath(), RelNotes);
2183         ShellExecute(nullptr, _T("open"), sPath.c_str(), nullptr, nullptr, SW_SHOWNORMAL);
2184 }
2185
2186 /**
2187  * @brief Shows the translations page.
2188  * This function opens translations page URL into browser.
2189  */
2190 void CMainFrame::OnHelpTranslations()
2191 {
2192         ShellExecute(nullptr, _T("open"), TranslationsUrl, nullptr, nullptr, SW_SHOWNORMAL);
2193 }
2194
2195 /**
2196  * @brief Called when user selects File/Open Conflict...
2197  */
2198 void CMainFrame::OnFileOpenConflict()
2199 {
2200         String conflictFile;
2201         if (SelectFile(GetSafeHwnd(), conflictFile))
2202         {
2203                 DoOpenConflict(conflictFile);
2204         }
2205 }
2206
2207 /**
2208  * @brief Select and open conflict file for resolving.
2209  * This function lets user to select conflict file to resolve.
2210  * Then we parse conflict file to two files to "merge" and
2211  * save resulting file over original file.
2212  *
2213  * Set left-side file read-only as it is the repository file which cannot
2214  * be modified anyway. Right-side file is user's file which is set as
2215  * modified by default so user can just save it and accept workspace
2216  * file as resolved file.
2217  * @param [in] conflictFile Full path to conflict file to open.
2218  * @param [in] checked If true, do not check if it really is project file.
2219  * @return `true` if conflict file was opened for resolving.
2220  */
2221 bool CMainFrame::DoOpenConflict(const String& conflictFile, const String strDesc[] /*= nullptr*/, bool checked /*= false*/)
2222 {
2223         bool conflictCompared = false;
2224
2225         if (!checked)
2226         {
2227                 bool confFile = IsConflictFile(conflictFile);
2228                 if (!confFile)
2229                 {
2230                         String message = strutils::format_string1(_("The file\n%1\nis not a conflict file."), conflictFile);
2231                         AfxMessageBox(message.c_str(), MB_ICONSTOP);
2232                         return false;
2233                 }
2234         }
2235
2236         // Create temp files and put them into the list,
2237         // from where they get deleted when MainFrame is deleted.
2238         String ext = paths::FindExtension(conflictFile);
2239         TempFilePtr wTemp(new TempFile());
2240         String workFile = wTemp->Create(_T("confw_"), ext);
2241         m_tempFiles.push_back(wTemp);
2242         TempFilePtr vTemp(new TempFile());
2243         String revFile = vTemp->Create(_T("confv_"), ext);
2244         m_tempFiles.push_back(vTemp);
2245         TempFilePtr bTemp(new TempFile());
2246         String baseFile = vTemp->Create(_T("confb_"), ext);
2247         m_tempFiles.push_back(bTemp);
2248
2249         // Parse conflict file into two files.
2250         bool inners, threeWay;
2251         int iGuessEncodingType = GetOptionsMgr()->GetInt(OPT_CP_DETECT);
2252         bool success = ParseConflictFile(conflictFile, workFile, revFile, baseFile, iGuessEncodingType, inners, threeWay);
2253
2254         if (success)
2255         {
2256                 // Open two parsed files to WinMerge, telling WinMerge to
2257                 // save over original file (given as third filename).
2258                 theApp.m_strSaveAsPath = conflictFile;
2259                 if (!threeWay)
2260                 {
2261                         String strDesc2[2] = {
2262                                 (strDesc && !strDesc[0].empty()) ? strDesc[0] : _("Theirs File"),
2263                                 (strDesc && !strDesc[2].empty()) ? strDesc[2] : _("Mine File") };
2264                         DWORD dwFlags[2] = {FFILEOPEN_READONLY | FFILEOPEN_NOMRU, FFILEOPEN_NOMRU | FFILEOPEN_MODIFIED};
2265                         PathContext tmpPathContext(revFile, workFile);
2266                         conflictCompared = DoFileOpen(&tmpPathContext, dwFlags, strDesc2);
2267                 }
2268                 else
2269                 {
2270                         String strDesc3[3] = {
2271                                 (strDesc && !strDesc[0].empty()) ? strDesc[0] : _("Base File"),
2272                                 (strDesc && !strDesc[1].empty()) ? strDesc[1] : _("Theirs File"),
2273                                 (strDesc && !strDesc[2].empty()) ? strDesc[2] : _("Mine File") };
2274                         PathContext tmpPathContext(baseFile, revFile, workFile);
2275                         DWORD dwFlags[3] = {FFILEOPEN_READONLY | FFILEOPEN_NOMRU, FFILEOPEN_READONLY | FFILEOPEN_NOMRU, FFILEOPEN_NOMRU | FFILEOPEN_MODIFIED};
2276                         conflictCompared = DoFileOpen(&tmpPathContext, dwFlags, strDesc3);
2277                 }
2278         }
2279         else
2280         {
2281                 LangMessageBox(IDS_ERROR_CONF_RESOLVE, MB_ICONSTOP);
2282         }
2283         return conflictCompared;
2284 }
2285
2286 /**
2287  * @brief Get type of frame (File/Folder compare).
2288  * @param [in] pFrame Pointer to frame to check.
2289  * @return FRAMETYPE of the given frame.
2290 */
2291 CMainFrame::FRAMETYPE CMainFrame::GetFrameType(const CFrameWnd * pFrame) const
2292 {
2293         bool bMergeFrame = !!pFrame->IsKindOf(RUNTIME_CLASS(CChildFrame));
2294         bool bHexMergeFrame = !!pFrame->IsKindOf(RUNTIME_CLASS(CHexMergeFrame));
2295         bool bImgMergeFrame = !!pFrame->IsKindOf(RUNTIME_CLASS(CImgMergeFrame));
2296         bool bDirFrame = !!pFrame->IsKindOf(RUNTIME_CLASS(CDirFrame));
2297
2298         if (bMergeFrame)
2299                 return FRAME_FILE;
2300         else if (bHexMergeFrame)
2301                 return FRAME_HEXFILE;
2302         else if (bImgMergeFrame)
2303                 return FRAME_IMGFILE;
2304         else if (bDirFrame)
2305                 return FRAME_FOLDER;
2306         else
2307                 return FRAME_OTHER;
2308 }
2309
2310 /**
2311  * @brief Show the plugins list dialog.
2312  */
2313 void CMainFrame::OnPluginsList()
2314 {
2315         PluginsListDlg dlg;
2316         dlg.DoModal();
2317 }
2318
2319 void CMainFrame::OnDiffOptionsDropDown(NMHDR* pNMHDR, LRESULT* pResult)
2320 {
2321         LPNMTOOLBAR pToolBar = reinterpret_cast<LPNMTOOLBAR>(pNMHDR);
2322         ClientToScreen(&(pToolBar->rcButton));
2323         BCMenu menu;
2324         VERIFY(menu.LoadMenu(IDR_POPUP_DIFF_OPTIONS));
2325         theApp.TranslateMenu(menu.m_hMenu);
2326         CMenu* pPopup = menu.GetSubMenu(0);
2327         if (pPopup != nullptr)
2328         {
2329                 pPopup->TrackPopupMenu(TPM_RIGHTALIGN | TPM_RIGHTBUTTON,
2330                         pToolBar->rcButton.right, pToolBar->rcButton.bottom, this);
2331         }
2332         *pResult = 0;
2333 }
2334 void CMainFrame::OnDiffWhitespace(UINT nID)
2335 {
2336         GetOptionsMgr()->SaveOption(OPT_CMP_IGNORE_WHITESPACE, nID - IDC_DIFF_WHITESPACE_COMPARE);
2337         ApplyDiffOptions();
2338 }
2339
2340 void CMainFrame::OnUpdateDiffWhitespace(CCmdUI* pCmdUI)
2341 {
2342         pCmdUI->SetRadio((pCmdUI->m_nID - IDC_DIFF_WHITESPACE_COMPARE) == static_cast<UINT>(GetOptionsMgr()->GetInt(OPT_CMP_IGNORE_WHITESPACE)));
2343         pCmdUI->Enable();
2344 }
2345
2346 void CMainFrame::OnDiffCaseSensitive()
2347 {
2348         GetOptionsMgr()->SaveOption(OPT_CMP_IGNORE_CASE, !GetOptionsMgr()->GetBool(OPT_CMP_IGNORE_CASE));
2349         ApplyDiffOptions();
2350 }
2351
2352 void CMainFrame::OnUpdateDiffCaseSensitive(CCmdUI* pCmdUI)
2353 {
2354         pCmdUI->SetCheck(!GetOptionsMgr()->GetBool(OPT_CMP_IGNORE_CASE));
2355         pCmdUI->Enable();
2356 }
2357
2358 void CMainFrame::OnDiffIgnoreEOL()
2359 {
2360         GetOptionsMgr()->SaveOption(OPT_CMP_IGNORE_EOL, !GetOptionsMgr()->GetBool(OPT_CMP_IGNORE_EOL));
2361         ApplyDiffOptions();
2362 }
2363
2364 void CMainFrame::OnUpdateDiffIgnoreEOL(CCmdUI* pCmdUI)
2365 {
2366         pCmdUI->SetCheck(GetOptionsMgr()->GetBool(OPT_CMP_IGNORE_EOL));
2367         pCmdUI->Enable();
2368 }
2369
2370 void CMainFrame::OnIncludeSubfolders()
2371 {
2372         GetOptionsMgr()->SaveOption(OPT_CMP_INCLUDE_SUBDIRS, !GetOptionsMgr()->GetBool(OPT_CMP_INCLUDE_SUBDIRS));
2373         // Update all dirdoc settings
2374         for (auto pDirDoc : GetAllDirDocs())
2375                 pDirDoc->RefreshOptions();
2376         for (auto pOpenDoc : GetAllOpenDocs())
2377                 pOpenDoc->RefreshOptions();
2378 }
2379
2380 void CMainFrame::OnUpdateIncludeSubfolders(CCmdUI* pCmdUI)
2381 {
2382         pCmdUI->SetCheck(GetOptionsMgr()->GetBool(OPT_CMP_INCLUDE_SUBDIRS));
2383         pCmdUI->Enable();
2384 }
2385
2386 void CMainFrame::OnCompareMethod(UINT nID)
2387 {
2388         GetOptionsMgr()->SaveOption(OPT_CMP_METHOD, nID - ID_COMPMETHOD_FULL_CONTENTS);
2389 }
2390
2391 void CMainFrame::OnUpdateCompareMethod(CCmdUI* pCmdUI)
2392 {
2393         pCmdUI->SetRadio((pCmdUI->m_nID - ID_COMPMETHOD_FULL_CONTENTS) == static_cast<UINT>(GetOptionsMgr()->GetInt(OPT_CMP_METHOD)));
2394         pCmdUI->Enable();
2395 }
2396
2397 void CMainFrame::OnMRUs(UINT nID)
2398 {
2399         std::vector<JumpList::Item> mrus = JumpList::GetRecentDocs(GetOptionsMgr()->GetInt(OPT_MRU_MAX));
2400         const size_t idx = nID - ID_MRU_FIRST;
2401         if (idx < mrus.size())
2402         {
2403                 MergeCmdLineInfo cmdInfo((_T("\"") + mrus[idx].path + _T("\" ") + mrus[idx].params).c_str());
2404                 theApp.ParseArgsAndDoOpen(cmdInfo, this);
2405         }
2406 }
2407
2408 void CMainFrame::OnUpdateNoMRUs(CCmdUI* pCmdUI)
2409 {
2410         // append the MRU submenu
2411         HMENU hMenu = GetSubmenu(AfxGetMainWnd()->GetMenu()->m_hMenu, ID_FILE_NEW, false);
2412         if (hMenu == nullptr)
2413                 return;
2414
2415         // empty the menu
2416         size_t i = ::GetMenuItemCount(hMenu);
2417         while (i --)
2418                 ::DeleteMenu(hMenu, 0, MF_BYPOSITION);
2419
2420         std::vector<JumpList::Item> mrus = JumpList::GetRecentDocs(GetOptionsMgr()->GetInt(OPT_MRU_MAX));
2421
2422         if (mrus.size() == 0)
2423         {
2424                 // no script : create a <empty> entry
2425                 ::AppendMenu(hMenu, MF_STRING, ID_NO_EDIT_SCRIPTS, theApp.LoadString(IDS_NO_EDIT_SCRIPTS).c_str());
2426         }
2427         else
2428         {
2429                 // or fill in the submenu with the scripts names
2430                 int ID = ID_MRU_FIRST;  // first ID in menu
2431                 for (i = 0 ; i < mrus.size() ; i++, ID++)
2432                         ::AppendMenu(hMenu, MF_STRING, ID,
2433                                 ((i < 9 ? strutils::format(_T("&%d "), i+1) : strutils::format(_T("&%c "), 'a' + i - 9))
2434                                         + mrus[i].title).c_str());
2435         }
2436
2437         pCmdUI->Enable(true);
2438 }
2439
2440 /**
2441  * @brief Update plugin name
2442  * @param [in] pCmdUI UI component to update.
2443  */
2444 void CMainFrame::OnUpdatePluginName(CCmdUI* pCmdUI)
2445 {
2446         pCmdUI->SetText(_T(""));
2447 }
2448
2449 void CMainFrame::ReloadMenu()
2450 {
2451         // set the menu of the main frame window
2452         UINT idMenu = IDR_MAINFRAME;
2453         CMergeApp *pApp = dynamic_cast<CMergeApp *> (AfxGetApp());
2454         CMainFrame * pMainFrame = dynamic_cast<CMainFrame *> ((CFrameWnd*)pApp->m_pMainWnd);
2455         HMENU hNewDefaultMenu = pMainFrame->NewDefaultMenu(idMenu);
2456         HMENU hNewMergeMenu = pMainFrame->NewMergeViewMenu();
2457         HMENU hNewImgMergeMenu = pMainFrame->NewImgMergeViewMenu();
2458         HMENU hNewDirMenu = pMainFrame->NewDirViewMenu();
2459         if (hNewDefaultMenu != nullptr && hNewMergeMenu != nullptr && hNewDirMenu != nullptr)
2460         {
2461                 // Note : for Windows98 compatibility, use FromHandle and not Attach/Detach
2462                 CMenu * pNewDefaultMenu = CMenu::FromHandle(hNewDefaultMenu);
2463                 CMenu * pNewMergeMenu = CMenu::FromHandle(hNewMergeMenu);
2464                 CMenu * pNewImgMergeMenu = CMenu::FromHandle(hNewImgMergeMenu);
2465                 CMenu * pNewDirMenu = CMenu::FromHandle(hNewDirMenu);
2466
2467                 CWnd *pFrame = CWnd::FromHandle(::GetWindow(pMainFrame->m_hWndMDIClient, GW_CHILD));
2468                 while (pFrame != nullptr)
2469                 {
2470                         if (pFrame->IsKindOf(RUNTIME_CLASS(CChildFrame)))
2471                                 static_cast<CChildFrame *>(pFrame)->SetSharedMenu(hNewMergeMenu);
2472                         if (pFrame->IsKindOf(RUNTIME_CLASS(CHexMergeFrame)))
2473                                 static_cast<CHexMergeFrame *>(pFrame)->SetSharedMenu(hNewMergeMenu);
2474                         if (pFrame->IsKindOf(RUNTIME_CLASS(CImgMergeFrame)))
2475                                 static_cast<CImgMergeFrame *>(pFrame)->SetSharedMenu(hNewImgMergeMenu);
2476                         else if (pFrame->IsKindOf(RUNTIME_CLASS(COpenFrame)))
2477                                 static_cast<COpenFrame *>(pFrame)->SetSharedMenu(hNewDefaultMenu);
2478                         else if (pFrame->IsKindOf(RUNTIME_CLASS(CDirFrame)))
2479                                 static_cast<CDirFrame *>(pFrame)->SetSharedMenu(hNewDirMenu);
2480                         pFrame = pFrame->GetNextWindow();
2481                 }
2482
2483                 CFrameWnd *pActiveFrame = pMainFrame->GetActiveFrame();
2484                 if (pActiveFrame != nullptr)
2485                 {
2486                         if (pActiveFrame->IsKindOf(RUNTIME_CLASS(CChildFrame)))
2487                                 pMainFrame->MDISetMenu(pNewMergeMenu, nullptr);
2488                         else if (pActiveFrame->IsKindOf(RUNTIME_CLASS(CHexMergeFrame)))
2489                                 pMainFrame->MDISetMenu(pNewMergeMenu, nullptr);
2490                         else if (pActiveFrame->IsKindOf(RUNTIME_CLASS(CImgMergeFrame)))
2491                                 pMainFrame->MDISetMenu(pNewImgMergeMenu, nullptr);
2492                         else if (pActiveFrame->IsKindOf(RUNTIME_CLASS(CDirFrame)))
2493                                 pMainFrame->MDISetMenu(pNewDirMenu, nullptr);
2494                         else
2495                                 pMainFrame->MDISetMenu(pNewDefaultMenu, nullptr);
2496                 }
2497                 else
2498                         pMainFrame->MDISetMenu(pNewDefaultMenu, nullptr);
2499
2500                 // Don't delete the old menu
2501                 // There is a bug in BCMenu or in Windows98 : the new menu does not
2502                 // appear correctly if we destroy the old one
2503                 //                      if (pOldDefaultMenu != nullptr)
2504                 //                              pOldDefaultMenu->DestroyMenu();
2505                 //                      if (pOldMergeMenu != nullptr)
2506                 //                              pOldMergeMenu->DestroyMenu();
2507                 //                      if (pOldDirMenu = nullptr)
2508                 //                              pOldDirMenu->DestroyMenu();
2509
2510                 // m_hMenuDefault is used to redraw the main menu when we close a child frame
2511                 // if this child frame had a different menu
2512                 pMainFrame->m_hMenuDefault = hNewDefaultMenu;
2513                 pApp->m_pOpenTemplate->m_hMenuShared = hNewDefaultMenu;
2514                 pApp->m_pDiffTemplate->m_hMenuShared = hNewMergeMenu;
2515                 pApp->m_pDirTemplate->m_hMenuShared = hNewDirMenu;
2516
2517                 // force redrawing the menu bar
2518                 pMainFrame->DrawMenuBar();
2519         }
2520 }
2521
2522 void CMainFrame::UpdateDocTitle()
2523 {
2524         CDocManager* pDocManager = AfxGetApp()->m_pDocManager;
2525         POSITION posTemplate = pDocManager->GetFirstDocTemplatePosition();
2526         ASSERT(posTemplate != nullptr);
2527
2528         while (posTemplate != nullptr)
2529         {
2530                 CDocTemplate* pTemplate = pDocManager->GetNextDocTemplate(posTemplate);
2531
2532                 ASSERT(pTemplate != nullptr);
2533
2534                 for (auto pDoc : GetDocList(static_cast<CMultiDocTemplate *>(pTemplate)))
2535                 {
2536                         static_cast<CDocument *>(const_cast<void *>(pDoc))->SetTitle(nullptr);
2537                         ((CFrameWnd*)AfxGetApp()->m_pMainWnd)->OnUpdateFrameTitle(TRUE);
2538                 }
2539         }
2540 }