src/TortoiseUDiff/MainWindow.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2012 - TortoiseGit
   4 // Copyright (C) 2003-2013 - TortoiseSVN
   5
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License
   8 // as published by the Free Software Foundation; either version 2
   9 // of the License, or (at your option) any later version.
  10
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software Foundation,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20 #include "stdafx.h"
  21 #include "MainWindow.h"
  22 #include "UnicodeUtils.h"
  23 #include "StringUtils.h"
  24 #include "TaskbarUUID.h"
  25 #include "CreateProcessHelper.h"
  26 #include "SysInfo.h"
  27
  28 const UINT TaskBarButtonCreated = RegisterWindowMessage(L"TaskbarButtonCreated");
  29
  30 CMainWindow::CMainWindow(HINSTANCE hInst, const WNDCLASSEX* wcx /* = NULL*/)
  31         : CWindow(hInst, wcx)
  32         , m_bShowFindBar(false)
  33         , m_directFunction(0)
  34         , m_directPointer(0)
  35         , m_hWndEdit(NULL)
  36         , m_bMatchCase(false)
  37 {
  38         SetWindowTitle(_T("TortoiseGitUDiff"));
  39 }
  40
  41 CMainWindow::~CMainWindow(void)
  42 {
  43 }
  44
  45 bool CMainWindow::RegisterAndCreateWindow()
  46 {
  47         WNDCLASSEX wcx;
  48
  49         // Fill in the window class structure with default parameters
  50         wcx.cbSize = sizeof(WNDCLASSEX);
  51         wcx.style = CS_HREDRAW | CS_VREDRAW;
  52         wcx.lpfnWndProc = CWindow::stWinMsgHandler;
  53         wcx.cbClsExtra = 0;
  54         wcx.cbWndExtra = 0;
  55         wcx.hInstance = hResource;
  56         wcx.hCursor = NULL;
  57         ResString clsname(hResource, IDS_APP_TITLE);
  58         wcx.lpszClassName = clsname;
  59         wcx.hIcon = LoadIcon(hResource, MAKEINTRESOURCE(IDI_TORTOISEUDIFF));
  60         wcx.hbrBackground = (HBRUSH)(COLOR_3DFACE+1);
  61         wcx.lpszMenuName = MAKEINTRESOURCE(IDC_TORTOISEUDIFF);
  62         wcx.hIconSm = LoadIcon(wcx.hInstance, MAKEINTRESOURCE(IDI_TORTOISEUDIFF));
  63         if (RegisterWindow(&wcx))
  64         {
  65                 if (Create(WS_CAPTION | WS_MAXIMIZEBOX | WS_MINIMIZEBOX | WS_SIZEBOX | WS_SYSMENU | WS_CLIPCHILDREN, NULL))
  66                 {
  67                         m_FindBar.SetParent(*this);
  68                         m_FindBar.Create(hResource, IDD_FINDBAR, *this);
  69                         UpdateWindow(*this);
  70                         return true;
  71                 }
  72         }
  73         return false;
  74 }
  75
  76 LRESULT CALLBACK CMainWindow::WinMsgHandler(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  77 {
  78         if (uMsg == TaskBarButtonCreated)
  79         {
  80                 SetUUIDOverlayIcon(hwnd);
  81         }
  82         switch (uMsg)
  83         {
  84         case WM_CREATE:
  85                 {
  86                         m_hwnd = hwnd;
  87                         Initialize();
  88                 }
  89                 break;
  90         case WM_COMMAND:
  91                 {
  92                         return DoCommand(LOWORD(wParam));
  93                 }
  94                 break;
  95         case WM_MOUSEWHEEL:
  96                 {
  97                         if (GET_KEYSTATE_WPARAM(wParam) == MK_SHIFT)
  98                         {
  99                                 // scroll sideways
 100                                 SendEditor(SCI_LINESCROLL, -GET_WHEEL_DELTA_WPARAM(wParam)/40, 0);
 101                         }
 102                         else
 103                                 return DefWindowProc(hwnd, uMsg, wParam, lParam);
 104                 }
 105                 break;
 106         case WM_SIZE:
 107                 {
 108                         RECT rect;
 109                         GetClientRect(*this, &rect);
 110                         if (m_bShowFindBar)
 111                         {
 112                                 ::SetWindowPos(m_hWndEdit, HWND_TOP,
 113                                         rect.left, rect.top,
 114                                         rect.right-rect.left, rect.bottom-rect.top-30,
 115                                         SWP_SHOWWINDOW);
 116                                 ::SetWindowPos(m_FindBar, HWND_TOP,
 117                                         rect.left, rect.bottom-30,
 118                                         rect.right-rect.left, 30,
 119                                         SWP_SHOWWINDOW);
 120                         }
 121                         else
 122                         {
 123                                 ::SetWindowPos(m_hWndEdit, HWND_TOP,
 124                                         rect.left, rect.top,
 125                                         rect.right-rect.left, rect.bottom-rect.top,
 126                                         SWP_SHOWWINDOW);
 127                                 ::ShowWindow(m_FindBar, SW_HIDE);
 128                         }
 129                 }
 130                 break;
 131         case WM_GETMINMAXINFO:
 132                 {
 133                         MINMAXINFO * mmi = (MINMAXINFO*)lParam;
 134                         mmi->ptMinTrackSize.x = 100;
 135                         mmi->ptMinTrackSize.y = 100;
 136                         return 0;
 137                 }
 138                 break;
 139         case WM_DESTROY:
 140                 PostQuitMessage(0);
 141                 break;
 142         case WM_CLOSE:
 143                 ::DestroyWindow(m_hwnd);
 144                 break;
 145         case WM_SETFOCUS:
 146                 SetFocus(m_hWndEdit);
 147                 break;
 148         case COMMITMONITOR_FINDMSGNEXT:
 149                 {
 150                         SendEditor(SCI_CHARRIGHT);
 151                         SendEditor(SCI_SEARCHANCHOR);
 152                         m_bMatchCase = !!wParam;
 153                         m_findtext = (LPCTSTR)lParam;
 154                         SendEditor(SCI_SEARCHNEXT, m_bMatchCase ? SCFIND_MATCHCASE : 0, (LPARAM)CUnicodeUtils::StdGetUTF8(m_findtext).c_str());
 155                         SendEditor(SCI_SCROLLCARET);
 156                 }
 157                 break;
 158         case COMMITMONITOR_FINDMSGPREV:
 159                 {
 160                         SendEditor(SCI_SEARCHANCHOR);
 161                         m_bMatchCase = !!wParam;
 162                         m_findtext = (LPCTSTR)lParam;
 163                         SendEditor(SCI_SEARCHPREV, m_bMatchCase ? SCFIND_MATCHCASE : 0, (LPARAM)CUnicodeUtils::StdGetUTF8(m_findtext).c_str());
 164                         SendEditor(SCI_SCROLLCARET);
 165                 }
 166                 break;
 167         case COMMITMONITOR_FINDEXIT:
 168                 {
 169                         RECT rect;
 170                         GetClientRect(*this, &rect);
 171                         m_bShowFindBar = false;
 172                         ::ShowWindow(m_FindBar, SW_HIDE);
 173                         ::SetWindowPos(m_hWndEdit, HWND_TOP,
 174                                 rect.left, rect.top,
 175                                 rect.right-rect.left, rect.bottom-rect.top,
 176                                 SWP_SHOWWINDOW);
 177                 }
 178                 break;
 179         case COMMITMONITOR_FINDRESET:
 180                 SendEditor(SCI_SETSELECTIONSTART, 0);
 181                 SendEditor(SCI_SETSELECTIONEND, 0);
 182                 SendEditor(SCI_SEARCHANCHOR);
 183                 break;
 184         default:
 185                 return DefWindowProc(hwnd, uMsg, wParam, lParam);
 186         }
 187
 188         return 0;
 189 };
 190
 191 LRESULT CMainWindow::DoCommand(int id)
 192 {
 193         switch (id)
 194         {
 195         case ID_FILE_OPEN:
 196                 loadOrSaveFile(true);
 197                 break;
 198         case ID_FILE_SAVEAS:
 199                 loadOrSaveFile(false);
 200                 break;
 201         case ID_FILE_SAVE:
 202                 loadOrSaveFile(false, m_filename);
 203                 break;
 204         case ID_FILE_EXIT:
 205                 ::PostQuitMessage(0);
 206                 return 0;
 207         case IDM_SHOWFINDBAR:
 208                 {
 209                         m_bShowFindBar = true;
 210                         ::ShowWindow(m_FindBar, SW_SHOW);
 211                         RECT rect;
 212                         GetClientRect(*this, &rect);
 213                         ::SetWindowPos(m_hWndEdit, HWND_TOP,
 214                                 rect.left, rect.top,
 215                                 rect.right-rect.left, rect.bottom-rect.top-30,
 216                                 SWP_SHOWWINDOW);
 217                         ::SetWindowPos(m_FindBar, HWND_TOP,
 218                                 rect.left, rect.bottom-30,
 219                                 rect.right-rect.left, 30,
 220                                 SWP_SHOWWINDOW);
 221                         ::SetFocus(m_FindBar);
 222                         SendEditor(SCI_SETSELECTIONSTART, 0);
 223                         SendEditor(SCI_SETSELECTIONEND, 0);
 224                         SendEditor(SCI_SEARCHANCHOR);
 225                 }
 226                 break;
 227         case IDM_FINDNEXT:
 228                 SendEditor(SCI_CHARRIGHT);
 229                 SendEditor(SCI_SEARCHANCHOR);
 230                 SendEditor(SCI_SEARCHNEXT, m_bMatchCase ? SCFIND_MATCHCASE : 0, (LPARAM)CUnicodeUtils::StdGetUTF8(m_findtext).c_str());
 231                 SendEditor(SCI_SCROLLCARET);
 232                 break;
 233         case IDM_FINDPREV:
 234                 SendEditor(SCI_SEARCHANCHOR);
 235                 SendEditor(SCI_SEARCHPREV, m_bMatchCase ? SCFIND_MATCHCASE : 0, (LPARAM)CUnicodeUtils::StdGetUTF8(m_findtext).c_str());
 236                 SendEditor(SCI_SCROLLCARET);
 237                 break;
 238         case IDM_FINDEXIT:
 239                 if (IsWindowVisible(m_FindBar))
 240                 {
 241                         RECT rect;
 242                         GetClientRect(*this, &rect);
 243                         m_bShowFindBar = false;
 244                         ::ShowWindow(m_FindBar, SW_HIDE);
 245                         ::SetWindowPos(m_hWndEdit, HWND_TOP,
 246                                 rect.left, rect.top,
 247                                 rect.right-rect.left, rect.bottom-rect.top,
 248                                 SWP_SHOWWINDOW);
 249                 }
 250                 else
 251                         PostQuitMessage(0);
 252                 break;
 253         case ID_FILE_SETTINGS:
 254                 {
 255                         tstring gitCmd = _T(" /command:settings /page:blame");
 256                         RunCommand(gitCmd);
 257                 }
 258                 break;
 259         default:
 260                 break;
 261         };
 262         return 1;
 263 }
 264
 265 std::wstring CMainWindow::GetAppDirectory()
 266 {
 267         std::wstring path;
 268         DWORD len = 0;
 269         DWORD bufferlen = MAX_PATH;             // MAX_PATH is not the limit here!
 270         do
 271         {
 272                 bufferlen += MAX_PATH;          // MAX_PATH is not the limit here!
 273                 std::unique_ptr<TCHAR[]> pBuf(new TCHAR[bufferlen]);
 274                 len = GetModuleFileName(NULL, pBuf.get(), bufferlen);
 275                 path = pBuf.get();
 276         } while(len == bufferlen);
 277         path = path.substr(0, path.rfind('\\') + 1);
 278
 279         return path;
 280 }
 281
 282 void CMainWindow::RunCommand(const std::wstring& command)
 283 {
 284         tstring tortoiseProcPath = GetAppDirectory() + _T("TortoiseGitProc.exe");
 285         CCreateProcessHelper::CreateProcessDetached(tortoiseProcPath.c_str(), const_cast<TCHAR*>(command.c_str()));
 286 }
 287
 288 LRESULT CMainWindow::SendEditor(UINT Msg, WPARAM wParam, LPARAM lParam)
 289 {
 290         if (m_directFunction)
 291         {
 292                 return ((SciFnDirect) m_directFunction)(m_directPointer, Msg, wParam, lParam);
 293         }
 294         return ::SendMessage(m_hWndEdit, Msg, wParam, lParam);
 295 }
 296
 297 bool CMainWindow::Initialize()
 298 {
 299         m_hWndEdit = ::CreateWindow(
 300                 _T("Scintilla"),
 301                 _T("Source"),
 302                 WS_CHILD | WS_VSCROLL | WS_HSCROLL | WS_CLIPCHILDREN,
 303                 CW_USEDEFAULT, CW_USEDEFAULT,
 304                 CW_USEDEFAULT, CW_USEDEFAULT,
 305                 *this,
 306                 0,
 307                 hResource,
 308                 0);
 309         if (m_hWndEdit == NULL)
 310                 return false;
 311
 312         RECT rect;
 313         GetClientRect(*this, &rect);
 314         ::SetWindowPos(m_hWndEdit, HWND_TOP,
 315                 rect.left, rect.top,
 316                 rect.right-rect.left, rect.bottom-rect.top,
 317                 SWP_SHOWWINDOW);
 318
 319         m_directFunction = SendMessage(m_hWndEdit, SCI_GETDIRECTFUNCTION, 0, 0);
 320         m_directPointer = SendMessage(m_hWndEdit, SCI_GETDIRECTPOINTER, 0, 0);
 321
 322         // Set up the global default style. These attributes are used wherever no explicit choices are made.
 323         SetAStyle(STYLE_DEFAULT, ::GetSysColor(COLOR_WINDOWTEXT), ::GetSysColor(COLOR_WINDOW),
 324                 // Reusing TortoiseBlame's setting which already have an user friendly
 325                 // pane in TortoiseSVN's Settings dialog, while there is no such
 326                 // pane for TortoiseUDiff.
 327                 CRegStdDWORD(_T("Software\\TortoiseGit\\BlameFontSize"), 10),
 328                 CUnicodeUtils::StdGetUTF8(CRegStdString(_T("Software\\TortoiseGit\\BlameFontName"), _T("Courier New"))).c_str());
 329         SendEditor(SCI_SETTABWIDTH, 4);
 330         SendEditor(SCI_SETREADONLY, TRUE);
 331         LRESULT pix = SendEditor(SCI_TEXTWIDTH, STYLE_LINENUMBER, (LPARAM)"_99999");
 332         SendEditor(SCI_SETMARGINWIDTHN, 0, pix);
 333         SendEditor(SCI_SETMARGINWIDTHN, 1);
 334         SendEditor(SCI_SETMARGINWIDTHN, 2);
 335         //Set the default windows colors for edit controls
 336         SendEditor(SCI_STYLESETFORE, STYLE_DEFAULT, ::GetSysColor(COLOR_WINDOWTEXT));
 337         SendEditor(SCI_STYLESETBACK, STYLE_DEFAULT, ::GetSysColor(COLOR_WINDOW));
 338         SendEditor(SCI_SETSELFORE, TRUE, ::GetSysColor(COLOR_HIGHLIGHTTEXT));
 339         SendEditor(SCI_SETSELBACK, TRUE, ::GetSysColor(COLOR_HIGHLIGHT));
 340         SendEditor(SCI_SETCARETFORE, ::GetSysColor(COLOR_WINDOWTEXT));
 341         CRegStdDWORD used2d(L"Software\\TortoiseGit\\ScintillaDirect2D", FALSE);
 342         if (SysInfo::Instance().IsWin7OrLater() && DWORD(used2d))
 343         {
 344                 SendEditor(SCI_SETTECHNOLOGY, SC_TECHNOLOGY_DIRECTWRITE);
 345                 SendEditor(SCI_SETBUFFEREDDRAW, 0);
 346         }
 347         SendEditor(SCI_SETFONTQUALITY, SC_EFF_QUALITY_LCD_OPTIMIZED);
 348
 349         return true;
 350 }
 351
 352 bool CMainWindow::LoadFile(HANDLE hFile)
 353 {
 354         InitEditor();
 355         char data[4096];
 356         DWORD dwRead = 0;
 357
 358         BOOL bRet = ReadFile(hFile, data, sizeof(data), &dwRead, NULL);
 359         bool bUTF8 = IsUTF8(data, dwRead);
 360         while ((dwRead > 0) && (bRet))
 361         {
 362                 SendEditor(SCI_ADDTEXT, dwRead,
 363                         reinterpret_cast<LPARAM>(static_cast<char *>(data)));
 364                 bRet = ReadFile(hFile, data, sizeof(data), &dwRead, NULL);
 365         }
 366         SetupWindow(bUTF8);
 367         return true;
 368 }
 369
 370 bool CMainWindow::LoadFile(LPCTSTR filename)
 371 {
 372         InitEditor();
 373         FILE *fp = NULL;
 374         _tfopen_s(&fp, filename, _T("rb"));
 375         if (!fp)
 376                 return false;
 377
 378         //SetTitle();
 379         char data[4096];
 380         size_t lenFile = fread(data, 1, sizeof(data), fp);
 381         bool bUTF8 = IsUTF8(data, lenFile);
 382         while (lenFile > 0)
 383         {
 384                 SendEditor(SCI_ADDTEXT, lenFile,
 385                         reinterpret_cast<LPARAM>(static_cast<char *>(data)));
 386                 lenFile = fread(data, 1, sizeof(data), fp);
 387         }
 388         fclose(fp);
 389         SetupWindow(bUTF8);
 390         m_filename = filename;
 391         return true;
 392 }
 393
 394 void CMainWindow::InitEditor()
 395 {
 396         SendEditor(SCI_SETREADONLY, FALSE);
 397         SendEditor(SCI_CLEARALL);
 398         SendEditor(EM_EMPTYUNDOBUFFER);
 399         SendEditor(SCI_SETSAVEPOINT);
 400         SendEditor(SCI_CANCEL);
 401         SendEditor(SCI_SETUNDOCOLLECTION, 0);
 402 }
 403
 404 void CMainWindow::SetupWindow(bool bUTF8)
 405 {
 406         SendEditor(SCI_SETCODEPAGE, bUTF8 ? SC_CP_UTF8 : GetACP());
 407
 408         SendEditor(SCI_SETUNDOCOLLECTION, 1);
 409         ::SetFocus(m_hWndEdit);
 410         SendEditor(EM_EMPTYUNDOBUFFER);
 411         SendEditor(SCI_SETSAVEPOINT);
 412         SendEditor(SCI_GOTOPOS, 0);
 413
 414         SendEditor(SCI_CLEARDOCUMENTSTYLE, 0, 0);
 415         SendEditor(SCI_SETSTYLEBITS, 5, 0);
 416
 417         //SetAStyle(SCE_DIFF_DEFAULT, RGB(0, 0, 0));
 418         SetAStyle(SCE_DIFF_COMMAND, RGB(0x0A, 0x24, 0x36));
 419         SetAStyle(SCE_DIFF_POSITION, RGB(0xFF, 0, 0));
 420         SetAStyle(SCE_DIFF_HEADER, RGB(0x80, 0, 0), RGB(0xFF, 0xFF, 0x80));
 421         SetAStyle(SCE_DIFF_COMMENT, RGB(0, 0x80, 0));
 422         SendEditor(SCI_STYLESETBOLD, SCE_DIFF_COMMENT, TRUE);
 423         SetAStyle(SCE_DIFF_DELETED, ::GetSysColor(COLOR_WINDOWTEXT), RGB(0xFF, 0x80, 0x80));
 424         SetAStyle(SCE_DIFF_ADDED, ::GetSysColor(COLOR_WINDOWTEXT), RGB(0x80, 0xFF, 0x80));
 425
 426         SendEditor(SCI_SETLEXER, SCLEX_DIFF);
 427         SendEditor(SCI_SETKEYWORDS, 0, (LPARAM)"revision");
 428         SendEditor(SCI_COLOURISE, 0, -1);
 429         ::ShowWindow(m_hWndEdit, SW_SHOW);
 430 }
 431
 432 bool CMainWindow::SaveFile(LPCTSTR filename)
 433 {
 434         FILE *fp = NULL;
 435         _tfopen_s(&fp, filename, _T("w+b"));
 436         if (!fp)
 437                 return false;
 438
 439         LRESULT len = SendEditor(SCI_GETTEXT, 0, 0);
 440         std::unique_ptr<char[]> data (new char[len+1]);
 441         SendEditor(SCI_GETTEXT, len, reinterpret_cast<LPARAM>(static_cast<char *>(data.get())));
 442         fwrite(data.get(), sizeof(char), len-1, fp);
 443         fclose(fp);
 444
 445         SendEditor(SCI_SETSAVEPOINT);
 446         ::ShowWindow(m_hWndEdit, SW_SHOW);
 447         return true;
 448 }
 449
 450 void CMainWindow::SetTitle(LPCTSTR title)
 451 {
 452         size_t len = _tcslen(title);
 453         std::unique_ptr<TCHAR[]> pBuf(new TCHAR[len + 40]);
 454         _stprintf_s(pBuf.get(), len + 40, _T("%s - TortoiseGitUDiff"), title);
 455         SetWindowTitle(std::wstring(pBuf.get()));
 456 }
 457
 458 void CMainWindow::SetAStyle(int style, COLORREF fore, COLORREF back, int size, const char *face)
 459 {
 460         SendEditor(SCI_STYLESETFORE, style, fore);
 461         SendEditor(SCI_STYLESETBACK, style, back);
 462         if (size >= 1)
 463                 SendEditor(SCI_STYLESETSIZE, style, size);
 464         if (face)
 465                 SendEditor(SCI_STYLESETFONT, style, reinterpret_cast<LPARAM>(face));
 466 }
 467
 468 bool CMainWindow::IsUTF8(LPVOID pBuffer, size_t cb)
 469 {
 470         if (cb < 2)
 471                 return true;
 472         UINT16 * pVal16 = (UINT16 *)pBuffer;
 473         UINT8 * pVal8 = (UINT8 *)(pVal16+1);
 474         // scan the whole buffer for a 0x0000 sequence
 475         // if found, we assume a binary file
 476         for (size_t i=0; i<(cb-2); i=i+2)
 477         {
 478                 if (0x0000 == *pVal16++)
 479                         return false;
 480         }
 481         pVal16 = (UINT16 *)pBuffer;
 482         if (*pVal16 == 0xFEFF)
 483                 return false;
 484         if (cb < 3)
 485                 return false;
 486         if (*pVal16 == 0xBBEF)
 487         {
 488                 if (*pVal8 == 0xBF)
 489                         return true;
 490         }
 491         // check for illegal UTF8 chars
 492         pVal8 = (UINT8 *)pBuffer;
 493         for (size_t i=0; i<cb; ++i)
 494         {
 495                 if ((*pVal8 == 0xC0)||(*pVal8 == 0xC1)||(*pVal8 >= 0xF5))
 496                         return false;
 497                 pVal8++;
 498         }
 499         pVal8 = (UINT8 *)pBuffer;
 500         bool bUTF8 = false;
 501         for (size_t i=0; i<(cb-3); ++i)
 502         {
 503                 if ((*pVal8 & 0xE0)==0xC0)
 504                 {
 505                         pVal8++;i++;
 506                         if ((*pVal8 & 0xC0)!=0x80)
 507                                 return false;
 508                         bUTF8 = true;
 509                 }
 510                 if ((*pVal8 & 0xF0)==0xE0)
 511                 {
 512                         pVal8++;i++;
 513                         if ((*pVal8 & 0xC0)!=0x80)
 514                                 return false;
 515                         pVal8++;i++;
 516                         if ((*pVal8 & 0xC0)!=0x80)
 517                                 return false;
 518                         bUTF8 = true;
 519                 }
 520                 if ((*pVal8 & 0xF8)==0xF0)
 521                 {
 522                         pVal8++;i++;
 523                         if ((*pVal8 & 0xC0)!=0x80)
 524                                 return false;
 525                         pVal8++;i++;
 526                         if ((*pVal8 & 0xC0)!=0x80)
 527                                 return false;
 528                         pVal8++;i++;
 529                         if ((*pVal8 & 0xC0)!=0x80)
 530                                 return false;
 531                         bUTF8 = true;
 532                 }
 533                 pVal8++;
 534         }
 535         if (bUTF8)
 536                 return true;
 537         return false;
 538 }
 539
 540 void CMainWindow::loadOrSaveFile(bool doLoad, const wstring& filename /* = L"" */)
 541 {
 542         OPENFILENAME ofn = {0};                         // common dialog box structure
 543         TCHAR szFile[MAX_PATH] = {0};           // buffer for file name
 544         // Initialize OPENFILENAME
 545         ofn.lStructSize = sizeof(OPENFILENAME);
 546         ofn.hwndOwner = *this;
 547         ofn.lpstrFile = szFile;
 548         ofn.nMaxFile = sizeof(szFile)/sizeof(TCHAR);
 549         TCHAR filter[1024];
 550         LoadString(hResource, IDS_PATCHFILEFILTER, filter, sizeof(filter)/sizeof(TCHAR));
 551         CStringUtils::PipesToNulls(filter);
 552         ofn.lpstrFilter = filter;
 553         ofn.nFilterIndex = 1;
 554         ofn.lpstrFileTitle = NULL;
 555         ofn.nMaxFileTitle = 0;
 556         ofn.lpstrInitialDir = NULL;
 557         TCHAR fileTitle[1024];
 558         LoadString(hResource, doLoad ? IDS_OPENPATCH : IDS_SAVEPATCH, fileTitle, sizeof(fileTitle)/sizeof(TCHAR));
 559         ofn.lpstrTitle = fileTitle;
 560         ofn.Flags = OFN_ENABLESIZING | OFN_EXPLORER;
 561         if(doLoad)
 562                 ofn.Flags |= OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
 563         else
 564                 ofn.Flags |= OFN_OVERWRITEPROMPT;
 565         // Display the Open dialog box.
 566         if( doLoad )
 567         {
 568                 if (GetOpenFileName(&ofn)==TRUE)
 569                 {
 570                         LoadFile(ofn.lpstrFile);
 571                 }
 572         }
 573         else
 574         {
 575                 if (filename.empty())
 576                 {
 577                         if (GetSaveFileName(&ofn)==TRUE)
 578                         {
 579                                 SaveFile(ofn.lpstrFile);
 580                         }
 581                 }
 582                 else
 583                         SaveFile(filename.c_str());
 584         }
 585 }