src/TortoiseProc/ProgressDlg.cpp

   1 // ProgressDlg.cpp : implementation file
   2 //
   3
   4 #include "stdafx.h"
   5 #include "TortoiseProc.h"
   6 #include "ProgressDlg.h"
   7 #include "Git.h"
   8 #include "atlconv.h"
   9 #include "UnicodeUtils.h"
  10 // CProgressDlg dialog
  11
  12 IMPLEMENT_DYNAMIC(CProgressDlg, CResizableStandAloneDialog)
  13
  14 CProgressDlg::CProgressDlg(CWnd* pParent /*=NULL*/)
  15         : CResizableStandAloneDialog(CProgressDlg::IDD, pParent), m_bShowCommand(true), m_bAutoCloseOnSuccess(false), m_bAbort(false), m_bDone(false)
  16 {
  17         m_pThread = NULL;
  18         m_bAltAbortPress=false;
  19         m_bBufferAll=false;
  20 }
  21
  22 CProgressDlg::~CProgressDlg()
  23 {
  24         if(m_pThread != NULL)
  25         {
  26                 delete m_pThread;
  27         }
  28 }
  29
  30 void CProgressDlg::DoDataExchange(CDataExchange* pDX)
  31 {
  32         CDialog::DoDataExchange(pDX);
  33         DDX_Control(pDX, IDC_CURRENT, this->m_CurrentWork);
  34         DDX_Control(pDX, IDC_TITLE_ANIMATE, this->m_Animate);
  35         DDX_Control(pDX, IDC_RUN_PROGRESS, this->m_Progress);
  36         DDX_Control(pDX, IDC_LOG, this->m_Log);
  37         DDX_Control(pDX, IDC_PROGRESS_BUTTON1, this->m_ctrlPostCmd);
  38 }
  39
  40
  41 BEGIN_MESSAGE_MAP(CProgressDlg, CResizableStandAloneDialog)
  42         ON_MESSAGE(MSG_PROGRESSDLG_UPDATE_UI, OnProgressUpdateUI)
  43         ON_BN_CLICKED(IDOK, &CProgressDlg::OnBnClickedOk)
  44         ON_BN_CLICKED(IDC_PROGRESS_BUTTON1,&CProgressDlg::OnBnClickedButton1)
  45 END_MESSAGE_MAP()
  46
  47 BOOL CProgressDlg::OnInitDialog()
  48 {
  49         CResizableStandAloneDialog::OnInitDialog();
  50
  51         AddAnchor(IDC_TITLE_ANIMATE, TOP_LEFT, TOP_RIGHT);
  52         AddAnchor(IDC_RUN_PROGRESS, TOP_LEFT,TOP_RIGHT);
  53         AddAnchor(IDC_LOG, TOP_LEFT,BOTTOM_RIGHT);
  54
  55         AddAnchor(IDOK,BOTTOM_RIGHT);
  56         AddAnchor(IDCANCEL,BOTTOM_RIGHT);
  57         AddAnchor(IDC_PROGRESS_BUTTON1,BOTTOM_LEFT);
  58         AddAnchor(IDC_CURRENT,TOP_LEFT);
  59
  60         this->GetDlgItem(IDC_PROGRESS_BUTTON1)->ShowWindow(SW_HIDE);
  61         m_Animate.Open(IDR_DOWNLOAD);
  62
  63         CString InitialText;
  64         if ( !m_PreText.IsEmpty() )
  65         {
  66                 InitialText = m_PreText + _T("\r\n");
  67         }
  68 #if 0
  69         if (m_bShowCommand && (!m_GitCmd.IsEmpty() ))
  70         {
  71                 InitialText += m_GitCmd+_T("\r\n\r\n");
  72         }
  73 #endif
  74         m_Log.SetWindowTextW(InitialText);
  75         m_CurrentWork.SetWindowTextW(_T(""));
  76
  77         EnableSaveRestore(_T("ProgressDlg"));
  78
  79         m_pThread = AfxBeginThread(ProgressThreadEntry, this, THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED);
  80         if (m_pThread==NULL)
  81         {
  82 //              ReportError(CString(MAKEINTRESOURCE(IDS_ERR_THREADSTARTFAILED)));
  83         }
  84         else
  85         {
  86                 m_pThread->m_bAutoDelete = FALSE;
  87                 m_pThread->ResumeThread();
  88         }
  89
  90         if(!m_Title.IsEmpty())
  91                 this->SetWindowText(m_Title);
  92
  93         if(m_PostCmdList.GetCount()>0)
  94                 m_ctrlPostCmd.AddEntries(m_PostCmdList);
  95
  96         return TRUE;
  97 }
  98
  99 UINT CProgressDlg::ProgressThreadEntry(LPVOID pVoid)
 100 {
 101         return ((CProgressDlg*)pVoid)->ProgressThread();
 102 }
 103
 104 //static function, Share with SyncDialog
 105 UINT CProgressDlg::RunCmdList(CWnd *pWnd,std::vector<CString> &cmdlist,bool bShowCommand,CString *pfilename,bool *bAbort,CGitByteArray *pdata)
 106 {
 107         UINT ret=0;
 108
 109         PROCESS_INFORMATION pi;
 110         HANDLE hRead;
 111
 112         pWnd->PostMessage(MSG_PROGRESSDLG_UPDATE_UI,MSG_PROGRESSDLG_START,0);
 113
 114         if(pdata)
 115                 pdata->clear();
 116
 117         for(int i=0;i<cmdlist.size();i++)
 118         {
 119                 if(cmdlist[i].IsEmpty())
 120                         continue;
 121
 122                 if (bShowCommand)
 123                 {
 124                         CString str;
 125                         str+= cmdlist[i]+_T("\n\n");
 126                         for(int j=0;j<str.GetLength();j++)
 127                         {
 128                                 if(pdata)
 129                                 {
 130                                         pdata->m_critSec.Lock();
 131                                         pdata->push_back(str[j]);
 132                                         pdata->m_critSec.Unlock();
 133                                 }
 134                                 else
 135                                         pWnd->PostMessage(MSG_PROGRESSDLG_UPDATE_UI,MSG_PROGRESSDLG_RUN,str[j]);
 136                         }
 137                         if(pdata)
 138                                 pWnd->PostMessage(MSG_PROGRESSDLG_UPDATE_UI,MSG_PROGRESSDLG_RUN,0);
 139                 }
 140
 141                 g_Git.RunAsync(cmdlist[i],&pi, &hRead,pfilename);
 142
 143                 DWORD readnumber;
 144                 char byte;
 145                 CString output;
 146                 while(ReadFile(hRead,&byte,1,&readnumber,NULL))
 147                 {
 148                         if(pdata)
 149                         {
 150                                 if(byte == 0)
 151                                         byte = '\n';
 152
 153                                 pdata->m_critSec.Lock();
 154                                 pdata->push_back( byte);
 155                                 pdata->m_critSec.Unlock();
 156
 157                                 if(byte == '\r' || byte == '\n')
 158                                         pWnd->PostMessage(MSG_PROGRESSDLG_UPDATE_UI,MSG_PROGRESSDLG_RUN,0);
 159                         }else
 160                                 pWnd->PostMessage(MSG_PROGRESSDLG_UPDATE_UI,MSG_PROGRESSDLG_RUN,byte);
 161                 }
 162
 163                 CloseHandle(pi.hThread);
 164
 165                 WaitForSingleObject(pi.hProcess, INFINITE);
 166
 167                 DWORD status=0;
 168                 if(!GetExitCodeProcess(pi.hProcess,&status) || *bAbort)
 169                 {
 170                         CloseHandle(pi.hProcess);
 171
 172                         CloseHandle(hRead);
 173
 174                         pWnd->PostMessage(MSG_PROGRESSDLG_UPDATE_UI,MSG_PROGRESSDLG_FAILED,0);
 175                         return GIT_ERROR_GET_EXIT_CODE;
 176                 }
 177                 ret |= status;
 178         }
 179
 180         CloseHandle(pi.hProcess);
 181
 182         CloseHandle(hRead);
 183
 184         pWnd->PostMessage(MSG_PROGRESSDLG_UPDATE_UI,MSG_PROGRESSDLG_END,0);
 185
 186         return ret;
 187
 188 }
 189
 190 UINT CProgressDlg::ProgressThread()
 191 {
 192
 193         m_GitCmdList.push_back(m_GitCmd);
 194
 195         CString *pfilename;
 196
 197         if(m_LogFile.IsEmpty())
 198                 pfilename=NULL;
 199         else
 200                 pfilename=&m_LogFile;
 201
 202         m_GitStatus = RunCmdList(this,m_GitCmdList,m_bShowCommand,pfilename,&m_bAbort,&this->m_Databuf);;
 203         return 0;
 204 }
 205
 206 LRESULT CProgressDlg::OnProgressUpdateUI(WPARAM wParam,LPARAM lParam)
 207 {
 208         if(wParam == MSG_PROGRESSDLG_START)
 209         {
 210                 m_BufStart = 0 ;
 211                 m_Animate.Play(0,-1,-1);
 212                 this->DialogEnableWindow(IDOK,FALSE);
 213         }
 214         if(wParam == MSG_PROGRESSDLG_END || wParam == MSG_PROGRESSDLG_FAILED)
 215         {
 216                 if(m_bBufferAll)
 217                 {
 218                         m_Databuf.m_critSec.Lock();
 219                         m_Databuf.push_back(0);
 220                         m_Databuf.m_critSec.Unlock();
 221                         InsertCRLF();
 222                         m_Databuf.m_critSec.Lock();
 223                         m_Log.SetWindowText(Convert2UnionCode((char*)&m_Databuf[0]));
 224                         m_Databuf.m_critSec.Unlock();
 225                         m_Log.LineScroll(m_Log.GetLineCount() - m_Log.GetFirstVisibleLine() - 4);
 226                 }
 227                 m_BufStart=0;
 228                 m_Databuf.m_critSec.Lock();
 229                 this->m_Databuf.clear();
 230                 m_Databuf.m_critSec.Unlock();
 231
 232                 m_bDone = true;
 233                 m_Animate.Stop();
 234                 m_Progress.SetPos(100);
 235                 this->DialogEnableWindow(IDOK,TRUE);
 236
 237                 CString err;
 238                 err.Format(_T("\r\nFailed 0x%x(git return wrong reture code at sometime )\r\n"),m_GitStatus);
 239                 if(this->m_GitStatus)
 240                 {
 241                         //InsertColorText(this->m_Log,err,RGB(255,0,0));
 242                 }
 243                 else
 244                         InsertColorText(this->m_Log,_T("\r\nSuccess\r\n"),RGB(0,0,255));
 245
 246                 if(wParam == MSG_PROGRESSDLG_END && m_GitStatus == 0)
 247                 {
 248                         if(m_bAutoCloseOnSuccess)
 249                                 EndDialog(IDOK);
 250
 251                         if(m_PostCmdList.GetCount() > 0)
 252                         {
 253                                 //GetDlgItem(IDC_PROGRESS_BUTTON1)->SetWindowText(m_changeAbortButtonOnSuccessTo);
 254                                 GetDlgItem(IDC_PROGRESS_BUTTON1)->ShowWindow(SW_SHOW);
 255                                 //GetDlgItem(IDCANCEL)->ShowWindow(SW_HIDE);
 256                                 //Set default button is "close" rather than "push"
 257                                 this->SendMessage(WM_NEXTDLGCTL, (WPARAM)GetDlgItem(IDOK)->m_hWnd, TRUE);
 258                         }
 259                         else
 260                                 DialogEnableWindow(IDCANCEL, FALSE);
 261                 }
 262                 else
 263                         DialogEnableWindow(IDCANCEL, FALSE);
 264         }
 265
 266         if(!m_bBufferAll)
 267         {
 268                 if(lParam == 0)
 269                 {
 270                         m_Databuf.m_critSec.Lock();
 271                         for(int i=this->m_BufStart;i<this->m_Databuf.size();i++)
 272                         {
 273                                 char c = this->m_Databuf[m_BufStart];
 274                                 m_BufStart++;
 275                                 m_Databuf.m_critSec.Unlock();
 276
 277                                 ParserCmdOutput(c);
 278
 279                                 m_Databuf.m_critSec.Lock();
 280                         }
 281
 282                         if(m_BufStart>1000)
 283                         {
 284                                 m_Databuf.empty();
 285                                 m_BufStart =0;
 286                         }
 287                         m_Databuf.m_critSec.Unlock();
 288
 289                 }else
 290                         ParserCmdOutput((char)lParam);
 291         }
 292         return 0;
 293 }
 294
 295 //static function, Share with SyncDialog
 296 int CProgressDlg::FindPercentage(CString &log)
 297 {
 298         int s1=log.Find(_T('%'));
 299         if(s1<0)
 300                 return -1;
 301
 302         int s2=s1-1;
 303         for(int i=s1-1;i>=0;i--)
 304         {
 305                 if(log[i]>=_T('0') && log[i]<=_T('9'))
 306                         s2=i;
 307                 else
 308                         break;
 309         }
 310         return _ttol(log.Mid(s2,s1-s2));
 311 }
 312
 313 #if 0
 314 void CProgressDlg::ParserCmdOutput(TCHAR ch)
 315 {
 316         TRACE(_T("%c"),ch);
 317         if( ch == _T('\r') || ch == _T('\n'))
 318         {
 319                 TRACE(_T("End Char %s \r\n"),ch==_T('\r')?_T("lf"):_T(""));
 320                 TRACE(_T("End Char %s \r\n"),ch==_T('\n')?_T("cr"):_T(""));
 321
 322                 int lines=m_Log.GetLineCount();
 323
 324                 if(ch == _T('\r'))
 325                 {
 326                         int start=m_Log.LineIndex(lines-1);
 327                         int length=m_Log.LineLength(lines-1);
 328                         m_Log.SetSel( start,start+length);
 329                         m_Log.ReplaceSel(m_LogText);
 330
 331                 }else
 332                 {
 333                         m_Log.SetSel(m_Log.GetWindowTextLength(),
 334                                              m_Log.GetWindowTextLength());
 335                         m_Log.ReplaceSel(CString(_T("\r\n"))+m_LogText);
 336                 }
 337
 338                 if( lines > 500 ) //limited log length
 339                 {
 340                         int end=m_Log.LineIndex(1);
 341                         m_Log.SetSel(0,end);
 342                         m_Log.ReplaceSel(_T(""));
 343                 }
 344                 m_Log.LineScroll(m_Log.GetLineCount());
 345
 346                 int s1=m_LogText.Find(_T(':'));
 347                 int s2=m_LogText.Find(_T('%'));
 348                 if(s1>0 && s2>0)
 349                 {
 350                         this->m_CurrentWork.SetWindowTextW(m_LogText.Left(s1));
 351                         int pos=FindPercentage(m_LogText);
 352                         TRACE(_T("Pos %d\r\n"),pos);
 353                         if(pos>0)
 354                                 this->m_Progress.SetPos(pos);
 355                 }
 356
 357                 m_LogText=_T("");
 358
 359         }else
 360         {
 361                 m_LogText+=ch;
 362         }
 363
 364 }
 365 #endif
 366
 367 void CProgressDlg::ParserCmdOutput(char ch)
 368 {
 369         ParserCmdOutput(this->m_Log,this->m_Progress,this->m_LogTextA,ch,&this->m_CurrentWork);
 370 }
 371 void CProgressDlg::ClearESC(CStringA &str)
 372 {
 373         int start=0;
 374         str.Replace("\033[K","");
 375 }
 376 void CProgressDlg::ParserCmdOutput(CRichEditCtrl &log,CProgressCtrl &progressctrl,CStringA &oneline, char ch, CWnd *CurrentWork)
 377 {
 378         //TRACE(_T("%c"),ch);
 379         TRACE(_T("%c"),ch);
 380         CString str;
 381         if( ch == ('\r') || ch == ('\n'))
 382         {
 383                 TRACE(_T("End Char %s \r\n"),ch==_T('\r')?_T("lf"):_T(""));
 384                 TRACE(_T("End Char %s \r\n"),ch==_T('\n')?_T("cr"):_T(""));
 385
 386                 ClearESC(oneline);
 387
 388                 int lines=log.GetLineCount();
 389                 g_Git.StringAppend(&str,(BYTE*)oneline.GetBuffer(),CP_ACP);
 390
 391                 if(ch == ('\r'))
 392                 {
 393                         int start=log.LineIndex(lines-1);
 394                         int length=log.LineLength(lines-1);
 395                         log.SetSel( start,start+length);
 396                         log.ReplaceSel(str);
 397
 398                 }else
 399                 {
 400                         log.SetSel(log.GetWindowTextLength(),
 401                                              log.GetWindowTextLength());
 402                         log.ReplaceSel(CString(_T("\r\n"))+str);
 403                 }
 404
 405                 if( lines > 500 ) //limited log length
 406                 {
 407                         int end=log.LineIndex(1);
 408                         log.SetSel(0,end);
 409                         log.ReplaceSel(_T(""));
 410                 }
 411                 log.LineScroll(log.GetLineCount() - log.GetFirstVisibleLine() - 4);
 412
 413                 int s1=oneline.Find(_T(':'));
 414                 int s2=oneline.Find(_T('%'));
 415                 if(s1>0 && s2>0)
 416                 {
 417                         if(CurrentWork)
 418                                 CurrentWork->SetWindowTextW(str.Left(s1));
 419
 420                         int pos=FindPercentage(str);
 421                         TRACE(_T("Pos %d\r\n"),pos);
 422                         if(pos>0)
 423                                 progressctrl.SetPos(pos);
 424                 }
 425
 426                 oneline="";
 427
 428         }else
 429         {
 430                 oneline+=ch;
 431         }
 432
 433 }
 434 void CProgressDlg::RemoveLastLine(CString &str)
 435 {
 436         int start;
 437         start=str.ReverseFind(_T('\n'));
 438         if(start>0)
 439                 str=str.Left(start);
 440         return;
 441 }
 442 // CProgressDlg message handlers
 443
 444 void CProgressDlg::OnBnClickedOk()
 445 {
 446         // TODO: Add your control notification handler code here
 447         m_Log.GetWindowText(this->m_LogText);
 448         OnOK();
 449 }
 450
 451 void CProgressDlg::OnBnClickedButton1()
 452 {
 453         this->EndDialog(IDC_PROGRESS_BUTTON1 + this->m_ctrlPostCmd.GetCurrentEntry());
 454
 455 }
 456 void CProgressDlg::OnCancel()
 457 {
 458         m_bAbort = true;
 459         if(m_bDone)
 460         {
 461                 CResizableStandAloneDialog::OnCancel();
 462                 return;
 463         }
 464
 465         if( g_Git.m_CurrentGitPi.hProcess )
 466         {
 467                 if(::GenerateConsoleCtrlEvent(CTRL_C_EVENT,0))
 468                 {
 469                         ::WaitForSingleObject(g_Git.m_CurrentGitPi.hProcess ,10000);
 470                 }else
 471                 {
 472                         int error=::GetLastError();
 473                 }
 474
 475                 HANDLE  hProcessHandle = ::OpenProcess( PROCESS_TERMINATE, FALSE,g_Git.m_CurrentGitPi.dwProcessId);
 476                 if( hProcessHandle )
 477                         if(!::TerminateProcess(hProcessHandle,-1) )
 478                         {
 479                                 int error =::GetLastError();
 480                         }
 481         }
 482
 483         ::WaitForSingleObject(g_Git.m_CurrentGitPi.hProcess ,10000);
 484         CResizableStandAloneDialog::OnCancel();
 485
 486 }
 487
 488 void CProgressDlg::InsertCRLF()
 489 {
 490         m_Databuf.m_critSec.Lock();
 491         for(int i=0;i<m_Databuf.size();i++)
 492         {
 493                 if(m_Databuf[i]==('\n'))
 494                 {
 495                         if(i==0 || m_Databuf[i-1]!= ('\r'))
 496                         {
 497                                 m_Databuf.insert(m_Databuf.begin()+i,('\r'));
 498                                 i++;
 499                         }
 500                 }
 501         }
 502         m_Databuf.m_critSec.Unlock();
 503 }
 504
 505 void CProgressDlg::InsertColorText(CRichEditCtrl &edit,CString text,COLORREF rgb)
 506 {
 507         CHARFORMAT old,cf;
 508         edit.GetDefaultCharFormat(cf);
 509         old=cf;
 510         cf.dwMask|=CFM_COLOR;
 511         cf.crTextColor=rgb;
 512         cf.dwEffects|=CFE_BOLD;
 513         cf.dwEffects &= ~CFE_AUTOCOLOR ;
 514         edit.SetSel(edit.GetTextLength()-1,edit.GetTextLength());
 515         edit.ReplaceSel(text);
 516         edit.SetSel(edit.LineIndex(edit.GetLineCount()-2),edit.GetTextLength());
 517         edit.SetSelectionCharFormat(cf);
 518         edit.SetSel(edit.GetTextLength(),edit.GetTextLength());
 519         edit.SetDefaultCharFormat(old);
 520         edit.LineScroll(edit.GetLineCount() - edit.GetFirstVisibleLine() - 4);
 521 }
 522
 523 CString CCommitProgressDlg::Convert2UnionCode(char *buff, int size)
 524 {
 525         CString str;
 526
 527         CString cmd,output;
 528         int cp=CP_UTF8;
 529
 530         cmd=_T("git.exe config i18n.logOutputEncoding");
 531         if(g_Git.Run(cmd,&output,CP_ACP))
 532                 cp=CP_UTF8;
 533
 534         int start=0;
 535         output=output.Tokenize(_T("\n"),start);
 536         cp=CUnicodeUtils::GetCPCode(output);
 537
 538         start =0;
 539         if(size == -1)
 540                 size=strlen(buff);
 541
 542         for(int i=0;i<size;i++)
 543         {
 544                 if(buff[i] == ']')
 545                         start = i;
 546                 if( start >0 && buff[i] =='\n' )
 547                 {
 548                         start =i;
 549                         break;
 550                 }
 551         }
 552
 553         str.Empty();
 554         g_Git.StringAppend(&str, (BYTE*)buff, cp, start);
 555         g_Git.StringAppend(&str, (BYTE*)buff+start, CP_ACP,size - start);
 556
 557         return str;
 558
 559 }