Src/MainFrm.cpp

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