src/TortoiseProc/ProgressDlg.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2008-2012 - TortoiseGit
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 // ProgressDlg.cpp : implementation file
  20 //
  21
  22 #include "stdafx.h"
  23 #include "TortoiseProc.h"
  24 #include "ProgressDlg.h"
  25 #include "Git.h"
  26 #include "atlconv.h"
  27 #include "UnicodeUtils.h"
  28 #include "IconMenu.h"
  29 #include "LoglistCommonResource.h"
  30 #include "Tlhelp32.h"
  31 #include "AppUtils.h"
  32 #include "SmartHandle.h"
  33 #include "../TGitCache/CacheInterface.h"
  34
  35 // CProgressDlg dialog
  36
  37 IMPLEMENT_DYNAMIC(CProgressDlg, CResizableStandAloneDialog)
  38
  39 CProgressDlg::CProgressDlg(CWnd* pParent /*=NULL*/)
  40         : CResizableStandAloneDialog(CProgressDlg::IDD, pParent), m_bShowCommand(true), m_bAutoCloseOnSuccess(false), m_bAbort(false), m_bDone(false)
  41 {
  42         m_pThread = NULL;
  43         m_bAltAbortPress=false;
  44         m_bBufferAll=false;
  45 }
  46
  47 CProgressDlg::~CProgressDlg()
  48 {
  49         if(m_pThread != NULL)
  50         {
  51                 delete m_pThread;
  52         }
  53 }
  54
  55 void CProgressDlg::DoDataExchange(CDataExchange* pDX)
  56 {
  57         CDialog::DoDataExchange(pDX);
  58         DDX_Control(pDX, IDC_CURRENT, this->m_CurrentWork);
  59         DDX_Control(pDX, IDC_TITLE_ANIMATE, this->m_Animate);
  60         DDX_Control(pDX, IDC_RUN_PROGRESS, this->m_Progress);
  61         DDX_Control(pDX, IDC_LOG, this->m_Log);
  62         DDX_Control(pDX, IDC_PROGRESS_BUTTON1, this->m_ctrlPostCmd);
  63 }
  64
  65 BEGIN_MESSAGE_MAP(CProgressDlg, CResizableStandAloneDialog)
  66         ON_WM_CLOSE()
  67         ON_MESSAGE(MSG_PROGRESSDLG_UPDATE_UI, OnProgressUpdateUI)
  68         ON_BN_CLICKED(IDOK, &CProgressDlg::OnBnClickedOk)
  69         ON_BN_CLICKED(IDC_PROGRESS_BUTTON1,&CProgressDlg::OnBnClickedButton1)
  70         ON_REGISTERED_MESSAGE(WM_TASKBARBTNCREATED, OnTaskbarBtnCreated)
  71 END_MESSAGE_MAP()
  72
  73 BOOL CProgressDlg::OnInitDialog()
  74 {
  75         CResizableStandAloneDialog::OnInitDialog();
  76
  77         // Let the TaskbarButtonCreated message through the UIPI filter. If we don't
  78         // do this, Explorer would be unable to send that message to our window if we
  79         // were running elevated. It's OK to make the call all the time, since if we're
  80         // not elevated, this is a no-op.
  81         CHANGEFILTERSTRUCT cfs = { sizeof(CHANGEFILTERSTRUCT) };
  82         typedef BOOL STDAPICALLTYPE ChangeWindowMessageFilterExDFN(HWND hWnd, UINT message, DWORD action, PCHANGEFILTERSTRUCT pChangeFilterStruct);
  83         CAutoLibrary hUser = ::LoadLibrary(_T("user32.dll"));
  84         if (hUser)
  85         {
  86                 ChangeWindowMessageFilterExDFN *pfnChangeWindowMessageFilterEx = (ChangeWindowMessageFilterExDFN*)GetProcAddress(hUser, "ChangeWindowMessageFilterEx");
  87                 if (pfnChangeWindowMessageFilterEx)
  88                 {
  89                         pfnChangeWindowMessageFilterEx(m_hWnd, WM_TASKBARBTNCREATED, MSGFLT_ALLOW, &cfs);
  90                 }
  91         }
  92         m_pTaskbarList.Release();
  93         m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList);
  94
  95         AddAnchor(IDC_TITLE_ANIMATE, TOP_LEFT, TOP_RIGHT);
  96         AddAnchor(IDC_RUN_PROGRESS, TOP_LEFT,TOP_RIGHT);
  97         AddAnchor(IDC_LOG, TOP_LEFT,BOTTOM_RIGHT);
  98
  99         AddAnchor(IDOK,BOTTOM_RIGHT);
 100         AddAnchor(IDCANCEL,BOTTOM_RIGHT);
 101         AddAnchor(IDC_PROGRESS_BUTTON1,BOTTOM_LEFT);
 102         AddAnchor(IDC_CURRENT,TOP_LEFT);
 103
 104         this->GetDlgItem(IDC_PROGRESS_BUTTON1)->ShowWindow(SW_HIDE);
 105         m_Animate.Open(IDR_DOWNLOAD);
 106
 107         CString InitialText;
 108         if ( !m_PreText.IsEmpty() )
 109         {
 110                 InitialText = m_PreText + _T("\r\n");
 111         }
 112 #if 0
 113         if (m_bShowCommand && (!m_GitCmd.IsEmpty() ))
 114         {
 115                 InitialText += m_GitCmd+_T("\r\n\r\n");
 116         }
 117 #endif
 118         m_Log.SetWindowTextW(InitialText);
 119         m_CurrentWork.SetWindowTextW(_T(""));
 120
 121         EnableSaveRestore(_T("ProgressDlg"));
 122
 123         m_pThread = AfxBeginThread(ProgressThreadEntry, this, THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED);
 124         if (m_pThread==NULL)
 125         {
 126 //              ReportError(CString(MAKEINTRESOURCE(IDS_ERR_THREADSTARTFAILED)));
 127         }
 128         else
 129         {
 130                 m_pThread->m_bAutoDelete = FALSE;
 131                 m_pThread->ResumeThread();
 132         }
 133
 134         if(!m_Title.IsEmpty())
 135                 this->SetWindowText(m_Title);
 136
 137         CString sWindowTitle;
 138         GetWindowText(sWindowTitle);
 139         CAppUtils::SetWindowTitle(m_hWnd, g_Git.m_CurrentDir, sWindowTitle);
 140
 141         if(m_PostCmdList.GetCount()>0)
 142                 m_ctrlPostCmd.AddEntries(m_PostCmdList);
 143
 144         return TRUE;
 145 }
 146
 147 UINT CProgressDlg::ProgressThreadEntry(LPVOID pVoid)
 148 {
 149         return ((CProgressDlg*)pVoid)->ProgressThread();
 150 }
 151
 152 //static function, Share with SyncDialog
 153 UINT CProgressDlg::RunCmdList(CWnd *pWnd,std::vector<CString> &cmdlist,bool bShowCommand,CString *pfilename,bool *bAbort,CGitByteArray *pdata)
 154 {
 155         UINT ret=0;
 156
 157         PROCESS_INFORMATION pi;
 158         HANDLE hRead = 0;
 159
 160         memset(&pi,0,sizeof(PROCESS_INFORMATION));
 161
 162         CBlockCacheForPath cacheBlock(g_Git.m_CurrentDir);
 163
 164         pWnd->PostMessage(MSG_PROGRESSDLG_UPDATE_UI,MSG_PROGRESSDLG_START,0);
 165
 166         if(pdata)
 167                 pdata->clear();
 168
 169         for(int i=0;i<cmdlist.size();i++)
 170         {
 171                 if(cmdlist[i].IsEmpty())
 172                         continue;
 173
 174                 if (bShowCommand)
 175                 {
 176                         CStringA str = CUnicodeUtils::GetMulti(cmdlist[i].Trim() + _T("\n\n"), CP_UTF8);
 177                         for(int j=0;j<str.GetLength();j++)
 178                         {
 179                                 if(pdata)
 180                                 {
 181                                         pdata->m_critSec.Lock();
 182                                         pdata->push_back(str[j]);
 183                                         pdata->m_critSec.Unlock();
 184                                 }
 185                                 else
 186                                         pWnd->PostMessage(MSG_PROGRESSDLG_UPDATE_UI,MSG_PROGRESSDLG_RUN,str[j]);
 187                         }
 188                         if(pdata)
 189                                 pWnd->PostMessage(MSG_PROGRESSDLG_UPDATE_UI,MSG_PROGRESSDLG_RUN,0);
 190                 }
 191
 192                 g_Git.RunAsync(cmdlist[i].Trim(),&pi, &hRead, NULL, pfilename);
 193
 194                 DWORD readnumber;
 195                 char byte;
 196                 CString output;
 197                 while(ReadFile(hRead,&byte,1,&readnumber,NULL))
 198                 {
 199                         if(pdata)
 200                         {
 201                                 if(byte == 0)
 202                                         byte = '\n';
 203
 204                                 pdata->m_critSec.Lock();
 205                                 pdata->push_back( byte);
 206                                 pdata->m_critSec.Unlock();
 207
 208                                 if(byte == '\r' || byte == '\n')
 209                                         pWnd->PostMessage(MSG_PROGRESSDLG_UPDATE_UI,MSG_PROGRESSDLG_RUN,0);
 210                         }
 211                         else
 212                                 pWnd->PostMessage(MSG_PROGRESSDLG_UPDATE_UI,MSG_PROGRESSDLG_RUN,byte);
 213                 }
 214
 215                 CloseHandle(pi.hThread);
 216
 217                 WaitForSingleObject(pi.hProcess, INFINITE);
 218
 219                 DWORD status=0;
 220                 if(!GetExitCodeProcess(pi.hProcess,&status) || *bAbort)
 221                 {
 222                         CloseHandle(pi.hProcess);
 223
 224                         CloseHandle(hRead);
 225
 226                         pWnd->PostMessage(MSG_PROGRESSDLG_UPDATE_UI, MSG_PROGRESSDLG_FAILED, status);
 227                         return TGIT_GIT_ERROR_GET_EXIT_CODE;
 228                 }
 229                 ret |= status;
 230         }
 231
 232         CloseHandle(pi.hProcess);
 233
 234         CloseHandle(hRead);
 235
 236         pWnd->PostMessage(MSG_PROGRESSDLG_UPDATE_UI, MSG_PROGRESSDLG_END, ret);
 237
 238         return ret;
 239
 240 }
 241
 242 UINT CProgressDlg::ProgressThread()
 243 {
 244
 245         m_GitCmdList.push_back(m_GitCmd);
 246
 247         CString *pfilename;
 248
 249         if(m_LogFile.IsEmpty())
 250                 pfilename=NULL;
 251         else
 252                 pfilename=&m_LogFile;
 253
 254         m_GitStatus = RunCmdList(this,m_GitCmdList,m_bShowCommand,pfilename,&m_bAbort,&this->m_Databuf);;
 255         return 0;
 256 }
 257
 258 LRESULT CProgressDlg::OnProgressUpdateUI(WPARAM wParam,LPARAM lParam)
 259 {
 260         if(wParam == MSG_PROGRESSDLG_START)
 261         {
 262                 m_BufStart = 0 ;
 263                 m_Animate.Play(0,-1,-1);
 264                 this->DialogEnableWindow(IDOK,FALSE);
 265                 if (m_pTaskbarList)
 266                 {
 267                         m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
 268                         m_pTaskbarList->SetProgressValue(m_hWnd, 0, 100);
 269                 }
 270         }
 271         if(wParam == MSG_PROGRESSDLG_END || wParam == MSG_PROGRESSDLG_FAILED)
 272         {
 273                 if(m_bBufferAll)
 274                 {
 275                         m_Databuf.m_critSec.Lock();
 276                         m_Databuf.push_back(0);
 277                         m_Databuf.m_critSec.Unlock();
 278                         InsertCRLF();
 279                         m_Databuf.m_critSec.Lock();
 280                         m_Log.SetWindowText(Convert2UnionCode((char*)&m_Databuf[0]));
 281                         m_Databuf.m_critSec.Unlock();
 282                         m_Log.LineScroll(m_Log.GetLineCount() - m_Log.GetFirstVisibleLine() - 4);
 283                 }
 284                 m_BufStart=0;
 285                 m_Databuf.m_critSec.Lock();
 286                 this->m_Databuf.clear();
 287                 m_Databuf.m_critSec.Unlock();
 288
 289                 m_bDone = true;
 290                 m_Animate.Stop();
 291                 m_Progress.SetPos(100);
 292                 this->DialogEnableWindow(IDOK,TRUE);
 293
 294                 m_GitStatus = lParam;
 295
 296                 // detect crashes of perl when performing git svn actions
 297                 if (m_GitStatus == 0 && m_GitCmd.Find(_T(" svn ")) > 1)
 298                 {
 299                         CString log;
 300                         m_Log.GetWindowText(log);
 301                         if (log.GetLength() > 18 && log.Mid(log.GetLength() - 18) == _T("perl.exe.stackdump"))
 302                                 m_GitStatus = -1;
 303                 }
 304
 305                 CString err;
 306                 err.Format(_T("\r\n\r\ngit did not exit cleanly (exit code %d)\r\n"), m_GitStatus);
 307                 if(this->m_GitStatus)
 308                 {
 309                         if (m_pTaskbarList)
 310                         {
 311                                 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_ERROR);
 312                                 m_pTaskbarList->SetProgressValue(m_hWnd, 100, 100);
 313                         }
 314                         InsertColorText(this->m_Log,err,RGB(255,0,0));
 315                 }
 316                 else {
 317                         if (m_pTaskbarList)
 318                                 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NOPROGRESS);
 319                         InsertColorText(this->m_Log,_T("\r\nSuccess\r\n"),RGB(0,0,255));
 320                         this->DialogEnableWindow(IDCANCEL,FALSE);
 321                 }
 322
 323                 if(wParam == MSG_PROGRESSDLG_END && m_GitStatus == 0)
 324                 {
 325                         if(m_bAutoCloseOnSuccess)
 326                         {
 327                                 m_Log.GetWindowText(this->m_LogText);
 328                                 EndDialog(IDOK);
 329                         }
 330
 331                         if(m_PostCmdList.GetCount() > 0)
 332                         {
 333                                 //GetDlgItem(IDC_PROGRESS_BUTTON1)->SetWindowText(m_changeAbortButtonOnSuccessTo);
 334                                 GetDlgItem(IDC_PROGRESS_BUTTON1)->ShowWindow(SW_SHOW);
 335                                 //GetDlgItem(IDCANCEL)->ShowWindow(SW_HIDE);
 336                                 //Set default button is "close" rather than "push"
 337                                 this->SendMessage(WM_NEXTDLGCTL, (WPARAM)GetDlgItem(IDOK)->m_hWnd, TRUE);
 338                         }
 339                 }
 340         }
 341
 342         if(!m_bBufferAll)
 343         {
 344                 if(lParam == 0)
 345                 {
 346                         m_Databuf.m_critSec.Lock();
 347                         for(int i=this->m_BufStart;i<this->m_Databuf.size();i++)
 348                         {
 349                                 char c = this->m_Databuf[m_BufStart];
 350                                 m_BufStart++;
 351                                 m_Databuf.m_critSec.Unlock();
 352                                 ParserCmdOutput(c);
 353
 354                                 m_Databuf.m_critSec.Lock();
 355                         }
 356
 357                         if(m_BufStart>1000)
 358                         {
 359                                 m_Databuf.erase(m_Databuf.begin(), m_Databuf.begin()+m_BufStart);
 360                                 m_BufStart =0;
 361                         }
 362                         m_Databuf.m_critSec.Unlock();
 363
 364                 }
 365                 else
 366                         ParserCmdOutput((char)lParam);
 367         }
 368         return 0;
 369 }
 370
 371 //static function, Share with SyncDialog
 372 int CProgressDlg::FindPercentage(CString &log)
 373 {
 374         int s1=log.Find(_T('%'));
 375         if(s1<0)
 376                 return -1;
 377
 378         int s2=s1-1;
 379         for(int i=s1-1;i>=0;i--)
 380         {
 381                 if(log[i]>=_T('0') && log[i]<=_T('9'))
 382                         s2=i;
 383                 else
 384                         break;
 385         }
 386         return _ttol(log.Mid(s2,s1-s2));
 387 }
 388
 389 void CProgressDlg::ParserCmdOutput(char ch)
 390 {
 391         ParserCmdOutput(this->m_Log,this->m_Progress,this->m_hWnd,this->m_pTaskbarList,this->m_LogTextA,ch,&this->m_CurrentWork);
 392 }
 393 void CProgressDlg::ClearESC(CString &str)
 394 {
 395         // see http://ascii-table.com/ansi-escape-sequences.php and http://tldp.org/HOWTO/Bash-Prompt-HOWTO/c327.html
 396         str.Replace(_T("\033[K"), _T("")); // erase until end of line; no need to care for this, because we always clear the whole line
 397
 398         // drop colors
 399         while (true)
 400         {
 401                 int escapePosition = str.Find(_T('\033'));
 402                 if (escapePosition >= 0 && str.GetLength() >= escapePosition + 3)
 403                 {
 404                         if (str.Mid(escapePosition, 2) == _T("\033["))
 405                         {
 406                                 int colorEnd = str.Find(_T('m'), escapePosition + 2);
 407                                 if (colorEnd > 0)
 408                                 {
 409                                         bool found = true;
 410                                         for (int i = escapePosition + 2; i < colorEnd; i++)
 411                                         {
 412                                                 if (str[i] != _T(';') && (str[i] < _T('0') && str[i] > _T('9')))
 413                                                 {
 414                                                         found = false;
 415                                                         break;
 416                                                 }
 417                                         }
 418                                         if (found)
 419                                         {
 420                                                 if (escapePosition > 0)
 421                                                         str = str.Left(escapePosition) + str.Mid(colorEnd + 1);
 422                                                 else
 423                                                         str = str.Mid(colorEnd);
 424                                                 continue;
 425                                         }
 426                                 }
 427                         }
 428                 }
 429                 break;
 430         }
 431 }
 432 void CProgressDlg::ParserCmdOutput(CRichEditCtrl &log,CProgressCtrl &progressctrl,HWND m_hWnd,CComPtr<ITaskbarList3> m_pTaskbarList,CStringA &oneline, char ch, CWnd *CurrentWork)
 433 {
 434         //TRACE(_T("%c"),ch);
 435         if( ch == ('\r') || ch == ('\n'))
 436         {
 437                 CString str;
 438
 439 //              TRACE(_T("End Char %s \r\n"),ch==_T('\r')?_T("lf"):_T(""));
 440 //              TRACE(_T("End Char %s \r\n"),ch==_T('\n')?_T("cr"):_T(""));
 441
 442                 int lines = log.GetLineCount();
 443                 g_Git.StringAppend(&str, (BYTE*)oneline.GetBuffer(), CP_UTF8);
 444                 str.Trim();
 445 //              TRACE(_T("%s"), str);
 446
 447                 ClearESC(str);
 448
 449                 if(ch == ('\r'))
 450                 {
 451                         int start=log.LineIndex(lines-1);
 452                         log.SetSel(start, log.GetTextLength());
 453                         log.ReplaceSel(str);
 454                 }
 455                 else
 456                 {
 457                         int length = log.GetWindowTextLength();
 458                         log.SetSel(length, length);
 459                         if (length > 0)
 460                                 log.ReplaceSel(_T("\r\n") + str);
 461                         else
 462                                 log.ReplaceSel(str);
 463                 }
 464
 465                 if (lines > 500) //limited log length
 466                 {
 467                         int end=log.LineIndex(1);
 468                         log.SetSel(0,end);
 469                         log.ReplaceSel(_T(""));
 470                 }
 471                 log.LineScroll(log.GetLineCount() - log.GetFirstVisibleLine() - 4);
 472
 473                 int s1=oneline.ReverseFind(_T(':'));
 474                 int s2=oneline.Find(_T('%'));
 475                 if (s1 > 0 && s2 > 0)
 476                 {
 477                         if(CurrentWork)
 478                                 CurrentWork->SetWindowTextW(str.Left(s1));
 479
 480                         int pos=FindPercentage(str);
 481                         TRACE(_T("Pos %d\r\n"),pos);
 482                         if(pos>0)
 483                         {
 484                                 progressctrl.SetPos(pos);
 485                                 if (m_pTaskbarList)
 486                                 {
 487                                         m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
 488                                         m_pTaskbarList->SetProgressValue(m_hWnd, pos, 100);
 489                                 }
 490                         }
 491                 }
 492
 493                 oneline="";
 494
 495         }
 496         else
 497         {
 498                 oneline+=ch;
 499         }
 500 }
 501 void CProgressDlg::RemoveLastLine(CString &str)
 502 {
 503         int start;
 504         start=str.ReverseFind(_T('\n'));
 505         if(start>0)
 506                 str=str.Left(start);
 507         return;
 508 }
 509 // CProgressDlg message handlers
 510
 511 void CProgressDlg::OnBnClickedOk()
 512 {
 513         m_Log.GetWindowText(this->m_LogText);
 514         OnOK();
 515 }
 516
 517 void CProgressDlg::OnBnClickedButton1()
 518 {
 519         this->EndDialog(IDC_PROGRESS_BUTTON1 + this->m_ctrlPostCmd.GetCurrentEntry());
 520 }
 521
 522 void CProgressDlg::OnClose()
 523 {
 524         DialogEnableWindow(IDCANCEL, TRUE);
 525         __super::OnClose();
 526 }
 527
 528 void CProgressDlg::OnCancel()
 529 {
 530         m_bAbort = true;
 531         if(m_bDone)
 532         {
 533                 CResizableStandAloneDialog::OnCancel();
 534                 return;
 535         }
 536
 537         if( g_Git.m_CurrentGitPi.hProcess )
 538         {
 539                 if(::GenerateConsoleCtrlEvent(CTRL_C_EVENT,0))
 540                 {
 541                         ::WaitForSingleObject(g_Git.m_CurrentGitPi.hProcess ,10000);
 542                 }
 543                 else
 544                 {
 545                         GetLastError();
 546                 }
 547
 548                 KillProcessTree(g_Git.m_CurrentGitPi.dwProcessId);
 549         }
 550
 551         ::WaitForSingleObject(g_Git.m_CurrentGitPi.hProcess ,10000);
 552         CResizableStandAloneDialog::OnCancel();
 553 }
 554
 555 void CProgressDlg::KillProcessTree(DWORD dwProcessId)
 556 {
 557         // recursively kills a process tree
 558         // This is not optimized, but works and isn't called very often ;)
 559         PROCESSENTRY32 pe;
 560         memset(&pe, 0, sizeof(PROCESSENTRY32));
 561         pe.dwSize = sizeof(PROCESSENTRY32);
 562
 563         HANDLE hSnap = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
 564
 565         if (::Process32First(hSnap, &pe))
 566         {
 567                 do
 568                 {
 569                         if (pe.th32ParentProcessID == dwProcessId)
 570                                 KillProcessTree(pe.th32ProcessID);
 571                 } while (::Process32Next(hSnap, &pe));
 572
 573                 HANDLE hProc = ::OpenProcess(PROCESS_TERMINATE, FALSE, dwProcessId);
 574                 if (hProc)
 575                 {
 576                         ::TerminateProcess(hProc, 1);
 577                         ::CloseHandle(hProc);
 578                 }
 579         }
 580         ::CloseHandle(hSnap);
 581 }
 582
 583 void CProgressDlg::InsertCRLF()
 584 {
 585         m_Databuf.m_critSec.Lock();
 586         for(int i=0;i<m_Databuf.size();i++)
 587         {
 588                 if(m_Databuf[i]==('\n'))
 589                 {
 590                         if(i==0 || m_Databuf[i-1]!= ('\r'))
 591                         {
 592                                 m_Databuf.insert(m_Databuf.begin()+i,('\r'));
 593                                 i++;
 594                         }
 595                 }
 596         }
 597         m_Databuf.m_critSec.Unlock();
 598 }
 599
 600 void CProgressDlg::InsertColorText(CRichEditCtrl &edit,CString text,COLORREF rgb)
 601 {
 602         CHARFORMAT old,cf;
 603         edit.GetDefaultCharFormat(cf);
 604         old=cf;
 605         cf.dwMask|=CFM_COLOR;
 606         cf.crTextColor=rgb;
 607         cf.dwEffects|=CFE_BOLD;
 608         cf.dwEffects &= ~CFE_AUTOCOLOR ;
 609         edit.SetSel(edit.GetTextLength()-1,edit.GetTextLength());
 610         edit.ReplaceSel(text);
 611         edit.SetSel(edit.LineIndex(edit.GetLineCount()-2),edit.GetTextLength());
 612         edit.SetSelectionCharFormat(cf);
 613         edit.SetSel(edit.GetTextLength(),edit.GetTextLength());
 614         edit.SetDefaultCharFormat(old);
 615         edit.LineScroll(edit.GetLineCount() - edit.GetFirstVisibleLine() - 4);
 616 }
 617
 618 CString CCommitProgressDlg::Convert2UnionCode(char *buff, int size)
 619 {
 620         CString str;
 621
 622         CString cmd, output;
 623         int cp=CP_UTF8;
 624
 625         cmd=_T("git.exe config i18n.logOutputEncoding");
 626         if (g_Git.Run(cmd, &output, NULL, CP_UTF8))
 627                 cp=CP_UTF8;
 628
 629         int start=0;
 630         output=output.Tokenize(_T("\n"),start);
 631         cp=CUnicodeUtils::GetCPCode(output);
 632
 633         start =0;
 634         if(size == -1)
 635                 size=strlen(buff);
 636
 637         for(int i=0;i<size;i++)
 638         {
 639                 if(buff[i] == ']')
 640                         start = i;
 641                 if( start >0 && buff[i] =='\n' )
 642                 {
 643                         start =i;
 644                         break;
 645                 }
 646         }
 647
 648         str.Empty();
 649         g_Git.StringAppend(&str, (BYTE*)buff, cp, start);
 650         g_Git.StringAppend(&str, (BYTE*)buff + start, CP_UTF8, size - start);
 651
 652         ClearESC(str);
 653
 654         return str;
 655 }
 656
 657 LRESULT CProgressDlg::OnTaskbarBtnCreated(WPARAM /*wParam*/, LPARAM /*lParam*/)
 658 {
 659         m_pTaskbarList.Release();
 660         m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList);
 661         return 0;
 662 }
 663
 664 BOOL CProgressDlg::PreTranslateMessage(MSG* pMsg)
 665 {
 666         if (pMsg->message == WM_KEYDOWN)
 667         {
 668                 if (pMsg->wParam == VK_ESCAPE)
 669                 {
 670                         // pressing the ESC key should close the dialog. But since we disabled the escape
 671                         // key (so the user doesn't get the idea that he could simply undo an e.g. update)
 672                         // this won't work.
 673                         // So if the user presses the ESC key, change it to VK_RETURN so the dialog gets
 674                         // the impression that the OK button was pressed.
 675                         if ((!GetDlgItem(IDCANCEL)->IsWindowEnabled())
 676                                 &&(GetDlgItem(IDOK)->IsWindowEnabled())&&(GetDlgItem(IDOK)->IsWindowVisible()))
 677                         {
 678                                 // since we convert ESC to RETURN, make sure the OK button has the focus.
 679                                 GetDlgItem(IDOK)->SetFocus();
 680                                 pMsg->wParam = VK_RETURN;
 681                         }
 682                 }
 683         }
 684         else if (pMsg->message == WM_CONTEXTMENU || pMsg->message == WM_RBUTTONDOWN)
 685         {
 686                 CWnd * pWnd = (CWnd*) GetDlgItem(IDC_LOG);
 687                 if (pWnd == GetFocus())
 688                 {
 689                         CIconMenu popup;
 690                         if (popup.CreatePopupMenu())
 691                         {
 692                                 popup.AppendMenuIcon(WM_COPY, IDS_SCIEDIT_COPY, IDI_COPYCLIP);
 693                                 if (m_Log.GetSelText().IsEmpty())
 694                                         popup.EnableMenuItem(WM_COPY, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
 695                                 popup.AppendMenu(MF_SEPARATOR);
 696                                 popup.AppendMenuIcon(EM_SETSEL, IDS_SCIEDIT_SELECTALL);
 697                                 int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, pMsg->pt.x, pMsg->pt.y, this);
 698                                 switch (cmd)
 699                                 {
 700                                         case 0: // no command selected
 701                                                 break;
 702                                         case EM_SETSEL:
 703                                         case WM_COPY:
 704                                                 ::SendMessage(GetDlgItem(IDC_LOG)->GetSafeHwnd(), cmd, 0, -1);
 705                                                 break;
 706                                 }
 707                                 return TRUE;
 708                         }
 709                 }
 710         }
 711         return __super::PreTranslateMessage(pMsg);
 712 }