Code/Sandbox/Plugins/PerforcePlugin/PerforceSourceControl.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "stdafx.h"
   4 #include <CrySystem/File/CryFile.h>
   5 #include "PerforceSourceControl.h"
   6 #include "PasswordDlg.h"
   7 #include <CryCore/Platform/platform_impl.inl>
   8 #include <CryThreading/IThreadManager.h>
   9
  10 // EditorCommon
  11 #include <EditorFramework/TrayArea.h>
  12 #include <CryIcon.h>
  13 #include <Controls/QPopupWidget.h>
  14
  15 // Qt
  16 #include <QHBoxLayout>
  17 #include <QVBoxLayout>
  18 #include <QCheckBox>
  19 #include <QLabel>
  20 #include <QLineEdit>
  21 #include <QtUtil.h>
  22
  23 extern CPerforceSourceControl* g_pPerforceControl;
  24
  25 REGISTER_TRAY_AREA_WIDGET(CPerforceTrayWidget, 100)
  26
  27 class PerforceSettings : public QWidget
  28 {
  29 public:
  30         PerforceSettings(QWidget* pParent = nullptr)
  31         {
  32                 QHBoxLayout* pMainLayout = new QHBoxLayout();
  33
  34                 m_pLabelLayout = new QVBoxLayout();
  35                 m_pInputLayout = new QVBoxLayout();
  36                 pMainLayout->addLayout(m_pLabelLayout);
  37                 pMainLayout->addLayout(m_pInputLayout);
  38
  39                 m_pLabelLayout->addWidget(new QLabel("Online"));
  40                 m_pConnectionCheckBox = new QCheckBox();
  41                 m_pConnectionCheckBox->setChecked(!g_pPerforceControl->IsWorkOffline());
  42                 connect(m_pConnectionCheckBox, &QCheckBox::toggled, [this](bool bChecked)
  43                 {
  44                         g_pPerforceControl->SetWorkOffline(!bChecked);
  45                         m_pServerInput->setEnabled(bChecked);
  46                         m_pUserInput->setEnabled(bChecked);
  47                         m_pWorkspaceInput->setEnabled(bChecked);
  48                         m_pPasswordInput->setEnabled(bChecked);
  49
  50                 });
  51                 m_pInputLayout->addWidget(m_pConnectionCheckBox);
  52
  53                 CMyClientApi& clientApi = g_pPerforceControl->GetClientApi();
  54                 m_pServerInput = CreateSection("Server", clientApi.GetPort().Value());
  55                 m_pUserInput = CreateSection("User", clientApi.GetUser().Value());
  56                 m_pWorkspaceInput = CreateSection("Workspace", clientApi.GetClient().Value());
  57                 m_pPasswordInput = CreateSection("Password", clientApi.GetPassword().Value(), true);
  58
  59                 g_pPerforceControl->signalWorkOfflineChanged.Connect(this, &PerforceSettings::OnConnectionStatusChanged);
  60
  61                 setLayout(pMainLayout);
  62         }
  63
  64 private:
  65         QLineEdit* CreateSection(const char* szLabel, const char* szInput, bool bIsPassword = false)
  66         {
  67                 m_pLabelLayout->addWidget(new QLabel(szLabel));
  68                 QLineEdit* pLineEdit = new QLineEdit();
  69                 if (bIsPassword)
  70                         pLineEdit->setEchoMode(QLineEdit::Password);
  71                 pLineEdit->setText(szInput);
  72                 connect(pLineEdit, &QLineEdit::textChanged, this, &PerforceSettings::OnSettingsChanged);
  73                 m_pInputLayout->addWidget(pLineEdit);
  74
  75                 return pLineEdit;
  76         }
  77
  78         void OnConnectionStatusChanged()
  79         {
  80                 m_pConnectionCheckBox->setChecked(!g_pPerforceControl->IsWorkOffline());
  81         }
  82
  83         void OnSettingsChanged() const
  84         {
  85                 CMyClientApi& clientApi = g_pPerforceControl->GetClientApi();
  86                 Error e;
  87                 clientApi.DefinePassword(m_pPasswordInput->text().toLocal8Bit(), &e);
  88                 clientApi.DefineClient(m_pWorkspaceInput->text().toLocal8Bit(), &e);
  89                 clientApi.DefinePort(m_pServerInput->text().toLocal8Bit(), &e);
  90                 clientApi.DefineUser(m_pUserInput->text().toLocal8Bit(), &e);
  91         }
  92
  93 private:
  94         QVBoxLayout* m_pLabelLayout;
  95         QVBoxLayout* m_pInputLayout;
  96
  97         QCheckBox* m_pConnectionCheckBox;
  98         QLineEdit* m_pServerInput;
  99         QLineEdit* m_pUserInput;
 100         QLineEdit* m_pWorkspaceInput;
 101         QLineEdit* m_pPasswordInput;
 102 };
 103
 104 CPerforceTrayWidget::CPerforceTrayWidget(QWidget* pParent /*= nullptr*/)
 105 {
 106         CMyClientApi& clientApi = g_pPerforceControl->GetClientApi();
 107         m_pPopUpMenu = new QPopupWidget("PerforceSettingsPopUp", QtUtil::MakeScrollable(new PerforceSettings()), QSize(340, 150), true);
 108         m_pPopUpMenu->SetFocusShareWidget(this);
 109         connect(this, &QToolButton::clicked, this, &CPerforceTrayWidget::OnClicked);
 110         g_pPerforceControl->signalWorkOfflineChanged.Connect(this, &CPerforceTrayWidget::OnConnectionStatusChanged);
 111         OnConnectionStatusChanged();
 112 }
 113
 114 void CPerforceTrayWidget::OnConnectionStatusChanged()
 115 {
 116         CryIconColorMap colorMap;
 117         colorMap[QIcon::Selected] = QColor(125, 198, 83);
 118         if (!g_pPerforceControl->IsWorkOffline())
 119                 setIcon(CryIcon("icons:p4.ico", colorMap).pixmap(24, 24, QIcon::Normal, QIcon::On));
 120         else
 121                 setIcon(CryIcon("icons:p4.ico"));
 122 }
 123
 124 void CPerforceTrayWidget::OnClicked(bool bChecked)
 125 {
 126         if (m_pPopUpMenu->isVisible())
 127         {
 128                 m_pPopUpMenu->hide();
 129                 return;
 130         }
 131
 132         m_pPopUpMenu->ShowAt(mapToGlobal(QPoint(width(), height())));
 133 }
 134
 135 namespace
 136 {
 137         CryCriticalSection g_cPerforceValues;
 138 }
 139
 140 struct CPerforceThread : public IThread
 141 {
 142         const char*             m_filename;
 143         CPerforceSourceControl* m_pSourceControl;
 144
 145         CPerforceThread(CPerforceSourceControl* pSourceControl, const char* filename)
 146         {
 147                 m_pSourceControl = pSourceControl;
 148                 m_filename = filename;
 149         }
 150
 151         virtual ~CPerforceThread()
 152         {
 153                 gEnv->pThreadManager->JoinThread(this, eJM_Join);
 154         }
 155
 156 protected:
 157
 158         // Start accepting work on thread
 159         virtual void ThreadEntry()
 160         {
 161                 m_pSourceControl->GetFileAttributesThread(m_filename);
 162         }
 163 };
 164
 165 void CMyClientUser::HandleError(Error* e)
 166 {
 167         /*
 168            StrBuf  m;
 169            e->Fmt( &m );
 170            if ( strstr( m.Text(), "file(s) not in client view." ) )
 171            e->Clear();
 172            else if ( strstr( m.Text(), "no such file(s)" ) )
 173            e->Clear();
 174            else if ( strstr( m.Text(), "access denied" ) )
 175            e->Clear();
 176            /**/
 177         m_e = *e;
 178 }
 179
 180 void CMyClientUser::Init()
 181 {
 182         m_bIsClientUnknown = false;
 183         m_bIsSetup = false;
 184         m_bIsPreCreateFile = false;
 185         m_output.Empty();
 186         m_input.Empty();
 187         m_e.Clear();
 188 }
 189
 190 void CMyClientUser::PreCreateFileName(const char* file)
 191 {
 192         m_bIsPreCreateFile = true;
 193         cry_strcpy(m_file, file);
 194         m_findedFile[0] = 0;
 195 }
 196
 197 void CMyClientUser::OutputStat(StrDict* varList)
 198 {
 199         if (m_bIsSetup && !m_bIsPreCreateFile)
 200                 return;
 201
 202         StrRef var, val;
 203         *m_action = 0;
 204         *m_headAction = 0;
 205         *m_otherAction = 0;
 206         *m_depotFile = 0;
 207         *m_otherUser = 0;
 208         m_lockStatus = SCC_LOCK_STATUS_UNLOCKED;
 209
 210         for (int i = 0; varList->GetVar(i, var, val); i++)
 211         {
 212                 if (m_bIsPreCreateFile)
 213                 {
 214                         if (var == "clientFile")
 215                         {
 216                                 char tmpval[MAX_PATH];
 217                                 cry_strcpy(tmpval, val.Text());
 218                                 char* ch = tmpval;
 219                                 while (ch = strchr(ch, '/'))
 220                                         *ch = '\\';
 221
 222                                 if (!stricmp(tmpval, m_file))
 223                                 {
 224                                         cry_strcpy(m_findedFile, val.Text());
 225                                         m_bIsPreCreateFile = false;
 226                                 }
 227                         }
 228                 }
 229                 else
 230                 {
 231                         if (var == "action")
 232                                 cry_strcpy(m_action, val.Text());
 233                         else if (var == "headAction")
 234                                 cry_strcpy(m_headAction, val.Text());
 235                         else if (var == "headRev")
 236                         {
 237                                 cry_strcpy(m_clientHasLatestRev, val.Text());
 238                                 m_nFileHeadRev = val.Atoi64();
 239                         }
 240                         else if (!strncmp(var.Text(), "otherAction", 11) && !strcmp(val.Text(), "edit"))
 241                                 cry_strcpy(m_otherAction, val.Text());
 242                         else if (var == "haveRev")
 243                         {
 244                                 if (val != m_clientHasLatestRev)
 245                                         m_clientHasLatestRev[0] = 0;
 246                                 m_nFileHaveRev = val.Atoi64();
 247                         }
 248                         else if (var == "depotFile")
 249                                 cry_strcpy(m_depotFile, val.Text());
 250                         else if (var == "otherOpen0")
 251                                 cry_strcpy(m_otherUser, val.Text());
 252                         else if (!strncmp(var.Text(), "otherLock0", 10))
 253                         {
 254                                 m_lockStatus = SCC_LOCK_STATUS_LOCKED_BY_OTHERS;
 255                                 cry_strcpy(m_lockedBy, val.Text());
 256                         }
 257                         else if (var == "ourLock")
 258                                 m_lockStatus = SCC_LOCK_STATUS_LOCKED_BY_US;
 259                 }
 260         }
 261         m_bIsSetup = true;
 262 }
 263
 264 void CMyClientUser::OutputInfo(char level, const char* data)
 265 {
 266         m_output.Append(data);
 267
 268         string strData(data);
 269         if ("Client unknown." == strData)
 270         {
 271                 m_bIsClientUnknown = true;
 272                 return;
 273         }
 274
 275         int nStart = 0;
 276         string var = strData.Tokenize(":", nStart);
 277         string val;
 278         if (!var.IsEmpty() && nStart > 1)
 279                 val = strData.Mid(nStart).Trim(" ");
 280
 281         if ("Client root" == var)
 282                 m_clientRoot = val;
 283         else if ("Client host" == var)
 284                 m_clientHost = val;
 285         else if ("Client name" == var)
 286                 m_clientName = val;
 287         else if ("Current directory" == var)
 288                 m_currentDirectory = val;
 289
 290         if (!m_bIsPreCreateFile)
 291                 return;
 292
 293         const char* ch = strrchr(data, '/');
 294         if (ch)
 295         {
 296                 if (!stricmp(ch + 1, m_file))
 297                 {
 298                         cry_strcpy(m_findedFile, ch + 1);
 299                         m_bIsPreCreateFile = false;
 300                 }
 301         }
 302 }
 303
 304 void CMyClientUser::InputData(StrBuf* buf, Error* e)
 305 {
 306         if (m_bIsCreatingChangelist)
 307                 buf->Set(m_input);
 308 }
 309
 310 void CMyClientUser::Edit(FileSys* f1, Error* e)
 311 {
 312         char msrc[4000];
 313         char mdst[4000];
 314
 315         char* src = &msrc[0];
 316         char* dst = &mdst[0];
 317
 318         f1->Open(FOM_READ, e);
 319         int size = f1->Read(msrc, 10240, e);
 320         msrc[size] = 0;
 321         f1->Close(e);
 322
 323         while (*dst = *src)
 324         {
 325                 if (!strnicmp(src, "\nDescription", 11))
 326                 {
 327                         src++;
 328                         while (*src != '\n' && *src != '\0')
 329                                 src++;
 330                         src++;
 331                         while (*src != '\n' && *src != '\0')
 332                                 src++;
 333                         strcpy(dst, "\nDescription:\n\t");
 334                         dst += 15;
 335                         strcpy(dst, m_desc);
 336                         dst += strlen(m_desc);
 337                         strcpy(dst, " (by Perforce Plug-in)");
 338                         dst += 22;
 339                 }
 340                 else
 341                 {
 342                         src++;
 343                         dst++;
 344                 }
 345         }
 346
 347         f1->Open(FOM_WRITE, e);
 348         f1->Write(mdst, strlen(mdst), e);
 349         f1->Close(e);
 350
 351         cry_strcpy(m_desc, m_initDesc);
 352 }
 353
 354 ////////////////////////////////////////////////////////////
 355
 356 void CMyClientApi::Run(const char* func)
 357 {
 358         // The "enableStreams" var has to be set prior to any Run call in order to be able to support Perforce streams
 359         ClientApi::SetVar("enableStreams");
 360         ClientApi::Run(func);
 361 }
 362
 363 void CMyClientApi::Run(const char* func, ClientUser* ui)
 364 {
 365         ClientApi::SetVar("enableStreams");
 366         ClientApi::Run(func, ui);
 367 }
 368
 369 ////////////////////////////////////////////////////////////
 370
 371 CPerforceSourceControl::CPerforceSourceControl() : m_ref(0)
 372 {
 373         m_thread = 0;
 374         m_bIsWorkOffline = false;
 375         m_bIsFailConnectionLogged = false;
 376         m_dwLastAccessTime = 0;
 377         m_isSecondThread = false;
 378         Connect();
 379         InitCommonControls();
 380 }
 381
 382 CPerforceSourceControl::~CPerforceSourceControl()
 383 {
 384         if (m_thread)
 385         {
 386                 gEnv->pThreadManager->JoinThread(m_thread, eJM_Join);
 387                 delete m_thread;
 388         }
 389 }
 390
 391 bool CPerforceSourceControl::Connect()
 392 {
 393         m_client.Init(&m_e);
 394         if (m_e.Test())
 395         {
 396                 SetWorkOffline(true);
 397                 if (!m_bIsFailConnectionLogged)
 398                 {
 399                         CryWarning(VALIDATOR_MODULE_EDITOR, VALIDATOR_ERROR, "\nPerforce plugin: Failed to connect.");
 400                         m_bIsFailConnectionLogged = true;
 401                 }
 402                 return false;
 403         }
 404         else
 405         {
 406                 CryLog("\nPerforce plugin: Connected.");
 407                 m_bIsFailConnectionLogged = false;
 408         }
 409         return true;
 410 }
 411
 412 bool CPerforceSourceControl::Reconnect()
 413 {
 414         if (m_client.Dropped())
 415         {
 416                 if (!m_bIsFailConnectionLogged)
 417                 {
 418                         CryWarning(VALIDATOR_MODULE_EDITOR, VALIDATOR_ERROR, "\nPerforce connection dropped: attempting reconnect");
 419                 }
 420                 FreeData();
 421                 if (!Connect())
 422                 {
 423                         SetWorkOffline(true);
 424                         return false;
 425                 }
 426         }
 427         return true;
 428 }
 429
 430 void CPerforceSourceControl::FreeData()
 431 {
 432         m_client.Final(&m_e);
 433         m_e.Clear();
 434 }
 435
 436 void CPerforceSourceControl::Init()
 437 {
 438         CheckConnection();
 439 }
 440
 441 /*
 442    Note:
 443
 444    ConvertFileNameCS doesn't seem to do any conversion.
 445
 446    First it checks if the path is available on local HDD, then if it hasn't found
 447    the path locally it looks in perforce (passing in local paths to P4v's API).
 448
 449    The path stored in sDst is the location which either exists and was found, or
 450    will exist once you get latest...
 451
 452    If the file neither exists locally or in the depot, sDst will be as far as exists in Perforce...
 453    Why is this a problem? Well, if you called GetFileAttributes on a file that doesn't exist in P4V
 454    you'll be given the attributes for the deepest folder of the path you provided which exists on
 455    your local machine - which is probably why you're here reading this comment :)
 456
 457  */
 458 void CPerforceSourceControl::ConvertFileNameCS(char* sDst, const char* sSrcFilename)
 459 {
 460         *sDst = 0;
 461         bool bFinded = true;
 462
 463         char szAdjustedFile[ICryPak::g_nMaxPath];
 464         cry_strcpy(szAdjustedFile, sSrcFilename);
 465
 466         //_finddata_t fd;
 467         WIN32_FIND_DATA fd;
 468
 469         char csPath[ICryPak::g_nMaxPath] = { 0 };
 470
 471         char* ch, * ch1;
 472
 473         ch = strrchr(szAdjustedFile, '\\');
 474         ch1 = strrchr(szAdjustedFile, '/');
 475         if (ch < ch1) ch = ch1;
 476         bool bIsFirstTime = true;
 477
 478         bool bIsEndSlash = false;
 479         if (ch && ch - szAdjustedFile + 1 == strlen(szAdjustedFile))
 480                 bIsEndSlash = true;
 481
 482         while (ch)
 483         {
 484                 //intptr_t handle;
 485                 //handle = gEnv->pCryPak->FindFirst( szAdjustedFile, &fd );
 486                 HANDLE handle = FindFirstFile(szAdjustedFile, &fd);
 487                 //if (handle != -1)
 488                 if (handle != INVALID_HANDLE_VALUE)
 489                 {
 490                         char tmp[ICryPak::g_nMaxPath];
 491                         cry_strcpy(tmp, csPath);
 492                         //cry_strcpy(csPath, fd.name);
 493                         cry_strcpy(csPath, fd.cFileName);
 494                         if (!bIsFirstTime)
 495                                 cry_strcat(csPath, "\\");
 496                         bIsFirstTime = false;
 497                         cry_strcat(csPath, tmp);
 498
 499                         //gEnv->pCryPak->FindClose( handle );
 500                         FindClose(handle);
 501                 }
 502
 503                 *ch = 0;
 504                 ch = strrchr(szAdjustedFile, '\\');
 505                 ch1 = strrchr(szAdjustedFile, '/');
 506                 if (ch < ch1) ch = ch1;
 507         }
 508
 509         if (!*csPath)
 510                 return;
 511
 512         cry_strcat(szAdjustedFile, "\\");
 513         cry_strcat(szAdjustedFile, csPath);
 514         if (bIsEndSlash || strlen(szAdjustedFile) < strlen(sSrcFilename))
 515                 cry_strcat(szAdjustedFile, "\\");
 516
 517         // if we have only folder on disk find in perforce
 518         if (strlen(szAdjustedFile) < strlen(sSrcFilename))
 519         {
 520                 if (IsFileManageable(szAdjustedFile))
 521                 {
 522                         char file[MAX_PATH];
 523                         char clienFile[MAX_PATH] = { 0 };
 524
 525                         bool bCont = true;
 526                         while (bCont)
 527                         {
 528                                 cry_strcpy(file, &sSrcFilename[strlen(szAdjustedFile)]);
 529                                 char* ch = strchr(file, '/');
 530                                 char* ch1 = strchr(file, '\\');
 531                                 if (ch < ch1) ch = ch1;
 532
 533                                 if (ch)
 534                                 {
 535                                         *ch = 0;
 536                                         bFinded = bCont = FindDir(clienFile, szAdjustedFile, file);
 537                                 }
 538                                 else
 539                                 {
 540                                         bFinded = FindFile(clienFile, szAdjustedFile, file);
 541                                         bCont = false;
 542                                 }
 543                                 cry_strcpy(szAdjustedFile, clienFile);
 544                                 if (bCont && strlen(clienFile) >= strlen(sSrcFilename))
 545                                         bCont = false;
 546                         }
 547                 }
 548         }
 549
 550         if (bFinded)
 551                 strcpy(sDst, szAdjustedFile);
 552 }
 553
 554 void CPerforceSourceControl::MakePathCS(char* sDst, const char* sSrcFilename)
 555 {
 556         char szAdjustedFile[ICryPak::g_nMaxPath];
 557         char szCheckedPath[ICryPak::g_nMaxPath];
 558         cry_strcpy(szAdjustedFile, sSrcFilename);
 559
 560         char* ch = &szAdjustedFile[0];
 561
 562         while (ch)
 563         {
 564                 char* ch1 = strchr(ch, '/');
 565                 ch = strchr(ch, '\\');
 566
 567                 if (ch1 && ch > ch1) ch = ch1;
 568
 569                 if (ch)
 570                 {
 571                         cry_strcpy(szCheckedPath, szAdjustedFile, ch - szAdjustedFile + 1);
 572
 573                         if (strlen(szCheckedPath) == 3 && szCheckedPath[1] == ':')
 574                         {
 575                                 ch++;
 576                                 continue;
 577                         }
 578
 579                         if (IsFileManageable(szCheckedPath, false))
 580                         {
 581                                 cry_strcpy(szAdjustedFile, szCheckedPath);
 582                                 break;
 583                         }
 584                         ch++;
 585                 }
 586         }
 587
 588         if (strlen(szAdjustedFile) < strlen(sSrcFilename))
 589         {
 590                 if (IsFileManageable(szAdjustedFile))
 591                 {
 592                         char file[MAX_PATH];
 593                         char clienFile[MAX_PATH] = { 0 };
 594
 595                         bool bCont = true;
 596                         while (bCont)
 597                         {
 598                                 cry_strcpy(file, &sSrcFilename[strlen(szAdjustedFile)]);
 599                                 char* ch = strchr(file, '/');
 600                                 char* ch1 = strchr(file, '\\');
 601                                 if (ch < ch1) ch = ch1;
 602
 603                                 bool bFinded = false;
 604
 605                                 if (ch)
 606                                 {
 607                                         *ch = 0;
 608                                         bFinded = bCont = FindDir(clienFile, szAdjustedFile, file);
 609                                 }
 610
 611                                 if (!bFinded)
 612                                 {
 613                                         strcpy(&szAdjustedFile[strlen(szAdjustedFile)], &sSrcFilename[strlen(szAdjustedFile)]);
 614                                         break;
 615                                 }
 616
 617                                 cry_strcpy(szAdjustedFile, clienFile);
 618                                 if (bCont && strlen(clienFile) >= strlen(sSrcFilename))
 619                                         bCont = false;
 620                         }
 621                 }
 622         }
 623
 624         if (strlen(szAdjustedFile) == strlen(sSrcFilename))
 625                 strcpy(sDst, szAdjustedFile);
 626         else
 627                 strcpy(sDst, sSrcFilename);
 628 }
 629
 630 void CPerforceSourceControl::RenameFolders(const char* path, const char* pathOld)
 631 {
 632         const char* ch = strchr(pathOld, '\\');
 633         if (ch)
 634                 ch = strchr(ch + 1, '\\');
 635         while (ch)
 636         {
 637                 ch++;
 638                 const char* const ch1 = strchr(ch, '\\');
 639                 if (ch1 && strncmp(ch, &path[ch - pathOld], ch1 - ch))
 640                 {
 641                         char newpath[ICryPak::g_nMaxPath];
 642                         char newpathOld[ICryPak::g_nMaxPath];
 643                         cry_strcpy(newpath, path, (size_t)(ch1 - pathOld));
 644                         cry_strcpy(newpathOld, pathOld, (size_t)(ch1 - pathOld));
 645                         MoveFile(newpathOld, newpath);
 646                 }
 647                 ch = ch1;
 648         }
 649 }
 650
 651 bool CPerforceSourceControl::FindDir(char* clientFile, const char* folder, const char* dir)
 652 {
 653         if (!Reconnect())
 654                 return false;
 655
 656         char fl[MAX_PATH];
 657         cry_strcpy(fl, folder);
 658         cry_strcat(fl, "*");
 659         char* argv[] = { fl };
 660         m_ui.PreCreateFileName(dir);
 661
 662         m_client.SetArgv(1, argv);
 663         m_client.Run("dirs", &m_ui);
 664         m_client.WaitTag();
 665
 666         if (m_ui.m_e.Test())
 667                 return false;
 668
 669         strcpy(clientFile, folder);
 670         strcat(clientFile, m_ui.m_findedFile);
 671         strcat(clientFile, "\\");
 672         if (*m_ui.m_findedFile)
 673                 return true;
 674
 675         return false;
 676 }
 677
 678 bool CPerforceSourceControl::FindFile(char* clientFile, const char* folder, const char* file)
 679 {
 680         if (!Reconnect())
 681                 return false;
 682
 683         char fullPath[MAX_PATH];
 684
 685         cry_strcpy(fullPath, folder);
 686         cry_strcat(fullPath, file);
 687
 688         char fl[MAX_PATH];
 689         cry_strcpy(fl, folder);
 690         cry_strcat(fl, "*");
 691         char* argv[] = { fl };
 692         m_ui.PreCreateFileName(fullPath);
 693
 694         m_client.SetArgv(1, argv);
 695         m_client.Run("fstat", &m_ui);
 696         m_client.WaitTag();
 697
 698         if (m_ui.m_e.Test())
 699                 return false;
 700
 701         strcpy(clientFile, m_ui.m_findedFile);
 702         if (*clientFile)
 703                 return true;
 704
 705         return false;
 706 }
 707
 708 bool CPerforceSourceControl::IsFileManageable(const char* sFilename, bool bCheckFatal)
 709 {
 710         if (!Reconnect())
 711                 return false;
 712
 713         bool bRet = false;
 714         bool fatal = false;
 715
 716         if (m_bIsWorkOffline)
 717                 return false;
 718
 719         char fl[MAX_PATH];
 720         cry_strcpy(fl, sFilename);
 721         //ConvertFileNameCS(fl, sFilename);
 722
 723         char* argv[] = { fl };
 724         Run("fstat", 1, argv, true);
 725
 726         m_ui.Init();
 727         m_client.SetArgv(1, argv);
 728         m_client.Run("fstat", &m_ui);
 729         m_client.WaitTag();
 730
 731         if (bCheckFatal && m_ui.m_e.IsFatal())
 732         {
 733                 fatal = true;
 734         }
 735
 736         if (!fatal && !m_ui.m_e.IsError())
 737         {
 738                 bRet = true;
 739         }
 740
 741         m_ui.m_e.Clear();
 742         return bRet;
 743 }
 744
 745 bool CPerforceSourceControl::IsFileExistsInDatabase(const char* sFilename)
 746 {
 747         if (!Reconnect())
 748                 return false;
 749
 750         bool bRet = false;
 751
 752         char fl[MAX_PATH];
 753         cry_strcpy(fl, sFilename);
 754         char* argv[] = { fl };
 755         m_ui.Init();
 756         m_client.SetArgv(1, argv);
 757         m_client.Run("fstat", &m_ui);
 758         m_client.WaitTag();
 759
 760         if (!m_ui.m_e.Test())
 761         {
 762                 if (strcmp(m_ui.m_headAction, "delete"))
 763                         bRet = true;
 764         }
 765         else
 766         {
 767                 //  StrBuf errorMsg;
 768                 //  m_ui.m_e.Fmt(&errorMsg);
 769         }
 770         m_ui.m_e.Clear();
 771         return bRet;
 772 }
 773
 774 bool CPerforceSourceControl::IsFileCheckedOutByUser(const char* sFilename, bool* pIsByAnotherUser)
 775 {
 776         if (!Reconnect())
 777                 return false;
 778
 779         bool bRet = false;
 780
 781         char fl[MAX_PATH];
 782         cry_strcpy(fl, sFilename);
 783         char* argv[] = { fl };
 784         m_ui.Init();
 785         m_client.SetArgv(1, argv);
 786         m_client.Run("fstat", &m_ui);
 787         m_client.WaitTag();
 788
 789         if ((!strcmp(m_ui.m_action, "edit") || !strcmp(m_ui.m_action, "add")) && !m_ui.m_e.Test())
 790                 bRet = true;
 791
 792         if (pIsByAnotherUser)
 793         {
 794                 *pIsByAnotherUser = false;
 795                 if (!strcmp(m_ui.m_otherAction, "edit") && !m_ui.m_e.Test())
 796                         *pIsByAnotherUser = true;
 797         }
 798
 799         m_ui.m_e.Clear();
 800         return bRet;
 801 }
 802
 803 bool CPerforceSourceControl::IsFileLatestVersion(const char* sFilename)
 804 {
 805         if (!Reconnect())
 806                 return false;
 807
 808         bool bRet = false;
 809
 810         char fl[MAX_PATH];
 811         cry_strcpy(fl, sFilename);
 812         char* argv[] = { fl };
 813         m_ui.Init();
 814         m_client.SetArgv(1, argv);
 815         m_client.Run("fstat", &m_ui);
 816         m_client.WaitTag();
 817
 818         if (m_ui.m_clientHasLatestRev[0] != 0)
 819                 bRet = true;
 820         m_ui.m_e.Clear();
 821         return bRet;
 822 }
 823
 824 uint32 CPerforceSourceControl::GetFileAttributesAndFileName(const char* filename, char* FullFileName)
 825 {
 826         //      g_pSystem->GetILog()->Log("\n checking connection");
 827         if (!Reconnect())
 828                 return false;
 829
 830         if (FullFileName)
 831                 FullFileName[0] = 0;
 832
 833         CCryFile file;
 834         bool bCryFile = file.Open(filename, "rb");
 835
 836         uint32 attributes = 0;
 837
 838         char sFullFilenameLC[MAX_PATH];
 839         GetCurrentDirectory(MAX_PATH, sFullFilenameLC);
 840         cry_strcat(sFullFilenameLC, "\\");
 841         if (bCryFile)
 842         {
 843                 if (*sFullFilenameLC && !strnicmp(sFullFilenameLC, filename, strlen(sFullFilenameLC)))
 844                         cry_strcpy(sFullFilenameLC, file.GetAdjustedFilename());
 845                 else
 846                         cry_strcat(sFullFilenameLC, file.GetAdjustedFilename());
 847         }
 848         else
 849                 cry_strcat(sFullFilenameLC, filename);
 850
 851         char sFullFilename[ICryPak::g_nMaxPath];
 852         ConvertFileNameCS(sFullFilename, sFullFilenameLC);
 853
 854         if (FullFileName)
 855                 strcpy(FullFileName, sFullFilename);
 856
 857         if (bCryFile && file.IsInPak())
 858         {
 859                 //              g_pSystem->GetILog()->Log("\n file is in pak");
 860                 attributes = SCC_FILE_ATTRIBUTE_READONLY | SCC_FILE_ATTRIBUTE_INPAK;
 861
 862                 if (IsFileManageable(sFullFilename) && IsFileExistsInDatabase(sFullFilename))
 863                 {
 864                         //                      g_pSystem->GetILog()->Log("\n file is managable and also exists in the database");
 865                         attributes |= SCC_FILE_ATTRIBUTE_MANAGED;
 866                         bool isByAnotherUser;
 867                         if (IsFileCheckedOutByUser(sFullFilename, &isByAnotherUser))
 868                                 attributes |= SCC_FILE_ATTRIBUTE_CHECKEDOUT;
 869                         if (isByAnotherUser)
 870                                 attributes |= SCC_FILE_ATTRIBUTE_BYANOTHER;
 871                 }
 872         }
 873         else
 874         {
 875                 DWORD dwAttrib = ::GetFileAttributes(sFullFilename);
 876                 if (dwAttrib != INVALID_FILE_ATTRIBUTES)
 877                 {
 878                         //              g_pSystem->GetILog()->Log("\n we have valid file attributes");
 879                         attributes = SCC_FILE_ATTRIBUTE_NORMAL;
 880                         if (dwAttrib & FILE_ATTRIBUTE_READONLY)
 881                                 attributes |= SCC_FILE_ATTRIBUTE_READONLY;
 882
 883                         if (IsFileManageable(sFullFilename))
 884                         {
 885                                 //                      g_pSystem->GetILog()->Log("\n file is manageable");
 886                                 if (IsFileExistsInDatabase(sFullFilename))
 887                                 {
 888                                         attributes |= SCC_FILE_ATTRIBUTE_MANAGED;
 889                                         //                              g_pSystem->GetILog()->Log("\n file exists in database");
 890                                         bool isByAnotherUser;
 891                                         if (IsFileCheckedOutByUser(sFullFilename, &isByAnotherUser))
 892                                         {
 893                                                 //                                      g_pSystem->GetILog()->Log("\n file is checked out");
 894                                                 attributes |= SCC_FILE_ATTRIBUTE_CHECKEDOUT;
 895                                         }
 896                                         if (isByAnotherUser)
 897                                         {
 898                                                 //                                      g_pSystem->GetILog()->Log("\n by another user");
 899                                                 attributes |= SCC_FILE_ATTRIBUTE_BYANOTHER;
 900                                         }
 901                                 }
 902                                 else
 903                                 {
 904                                         if (*sFullFilename && sFullFilename[strlen(sFullFilename) - 1] == '\\')
 905                                         {
 906                                                 attributes |= SCC_FILE_ATTRIBUTE_MANAGED | SCC_FILE_ATTRIBUTE_FOLDER;
 907                                         }
 908                                 }
 909                         }
 910                 }
 911         }
 912
 913         //      g_pSystem->GetILog()->Log("\n file has invalid file attributes");
 914         if (!attributes && !bCryFile)
 915         {
 916                 if (IsFileManageable(sFullFilename))
 917                 {
 918                         if (IsFileExistsInDatabase(sFullFilename))
 919                         {
 920                                 //                              g_pSystem->GetILog()->Log("\n file is managable and exists in the database");
 921                                 attributes = SCC_FILE_ATTRIBUTE_MANAGED | SCC_FILE_ATTRIBUTE_NORMAL | SCC_FILE_ATTRIBUTE_READONLY;
 922                                 bool isByAnotherUser;
 923                                 if (IsFileCheckedOutByUser(sFullFilename, &isByAnotherUser))
 924                                         attributes |= SCC_FILE_ATTRIBUTE_CHECKEDOUT;
 925                                 if (isByAnotherUser)
 926                                         attributes |= SCC_FILE_ATTRIBUTE_BYANOTHER;
 927                         }
 928                         else
 929                         {
 930                                 if (*sFullFilename && sFullFilename[strlen(sFullFilename) - 1] == '\\')
 931                                 {
 932                                         attributes |= SCC_FILE_ATTRIBUTE_MANAGED | SCC_FILE_ATTRIBUTE_FOLDER;
 933                                 }
 934                         }
 935                 }
 936         }
 937
 938         if (!attributes && IsFolder(filename, FullFileName))
 939                 attributes = SCC_FILE_ATTRIBUTE_FOLDER;
 940
 941         if ((attributes & SCC_FILE_ATTRIBUTE_FOLDER) && FullFileName)
 942                 strcat(FullFileName, "...");
 943
 944         return attributes ? attributes : SCC_FILE_ATTRIBUTE_INVALID;
 945 }
 946
 947 void CPerforceSourceControl::GetFileAttributesThread(const char* filename)
 948 {
 949         uint32 unRetValue = GetFileAttributesAndFileName(filename, 0);
 950
 951         AUTO_LOCK(g_cPerforceValues);
 952         m_unRetValue = unRetValue;
 953         m_isSetuped = true;
 954 }
 955
 956 uint32 CPerforceSourceControl::GetFileAttributes(const char* filename)
 957 {
 958         //return GetFileAttributesAndFileName(filename, 0);
 959
 960         DWORD dwTime = GetTickCount();
 961
 962         if (m_bIsWorkOffline || dwTime - m_dwLastAccessTime < 1000)
 963         {
 964                 m_dwLastAccessTime = dwTime;
 965                 return GetFileAttributesAndFileName(filename, 0);
 966         }
 967
 968         m_isSkipThread = false;
 969         m_isSetuped = false;
 970         uint32 unRetValue = SCC_FILE_ATTRIBUTE_INVALID;
 971
 972         if (m_thread)
 973         {
 974                 gEnv->pThreadManager->JoinThread(m_thread, eJM_Join);
 975                 delete m_thread;
 976         }
 977
 978         m_isSecondThread = true;
 979
 980         m_thread = new CPerforceThread(this, filename);
 981         if (!gEnv->pThreadManager->SpawnThread(m_thread, "PerforcePlugin"))
 982         {
 983                 CryFatalError("Error spawning \"PerforcePlugin\" thread.");
 984         }
 985
 986         DWORD dwWaitTime = 10000; // 10 sec
 987         DWORD dwCurTime = dwTime;
 988
 989         while (1)
 990         {
 991                 if (!m_isSkipThread && GetTickCount() - dwCurTime > dwWaitTime)
 992                 {
 993                         if (CryMessageBox(_T("Connection to Perforce is not responding. Do you want to switch to the offline mode?"), _T("Perforce Plug-in Error"), eMB_YesCancel) == eQR_Yes)
 994                         {
 995                                 SetWorkOffline(true);
 996                                 CheckConnection();
 997                                 break;
 998                         }
 999                         dwCurTime = GetTickCount();
1000                         dwWaitTime = 10000; // 10 sec
1001                 }
1002
1003                 CrySleep(50);
1004
1005                 if (m_isSetuped)
1006                 {
1007                         AUTO_LOCK(g_cPerforceValues);
1008                         unRetValue = m_unRetValue;
1009                         break;
1010                 }
1011         }
1012
1013         m_isSecondThread = false;
1014         m_dwLastAccessTime = dwTime;
1015
1016         return unRetValue;
1017 }
1018
1019 bool CPerforceSourceControl::IsFolder(const char* filename, char* FullFileName)
1020 {
1021         bool bFolder = false;
1022
1023         char sFullFilename[ICryPak::g_nMaxPath];
1024         ConvertFileNameCS(sFullFilename, filename);
1025
1026         uint32 attr = ::GetFileAttributes(sFullFilename);
1027         if (attr == INVALID_FILE_ATTRIBUTES)
1028         {
1029                 if (*sFullFilename && sFullFilename[strlen(sFullFilename) - 1] == '\\')
1030                         bFolder = true;
1031                 else
1032                         return false;
1033         }
1034         else if ((attr & FILE_ATTRIBUTE_DIRECTORY))
1035                 bFolder = true;
1036
1037         if (bFolder && FullFileName)
1038                 strcpy(FullFileName, sFullFilename);
1039
1040         return bFolder;
1041 }
1042
1043 bool CPerforceSourceControl::DoesChangeListExist(const char* pDesc, char* changeid, int nLen)
1044 {
1045         if (!Reconnect())
1046                 return false;
1047
1048         bool ret = false;
1049
1050         char* argv[] = { "-c", m_client.GetClient().Text(), "-s", "pending", "-l" };
1051         m_ui.Init();
1052         m_client.SetArgv(5, argv);
1053         m_client.Run("changes", &m_ui);
1054
1055         string id("");
1056         bool foundChange = false;
1057         string changes(m_ui.m_output);
1058         string token("\r\n");
1059         int nStart = 0;
1060         string item = changes.Tokenize(token, nStart);
1061         while (!item.IsEmpty())
1062         {
1063                 int idx = item.Find("Change ");
1064                 if (idx != -1)
1065                 {
1066                         int last = item.Find(" on ");
1067                         int first = item.Find(" ");
1068                         id = item.Left(last);
1069                         id = id.Right(id.GetLength() - (first + 1));
1070                 }
1071                 idx = item.Find(pDesc);
1072                 if (idx != -1)
1073                 {
1074                         foundChange = true;
1075                         break;
1076                 }
1077
1078                 item = changes.Tokenize(token, nStart);
1079         }
1080
1081         m_ui.m_output.Empty();
1082         m_ui.m_input.Empty();
1083
1084         if (!m_ui.m_e.Test() && !id.IsEmpty() && foundChange)
1085         {
1086                 cry_sprintf(changeid, nLen, "%s", id.GetBuffer());
1087                 ret = true;
1088         }
1089
1090         return ret;
1091 }
1092
1093 bool CPerforceSourceControl::CreateChangeList(const char* pDesc, char* changeid, int nLen)
1094 {
1095         if (!Reconnect())
1096                 return false;
1097
1098         bool ret = false;
1099
1100         char* argv[] = { "-o" };
1101         m_ui.Init();
1102         m_client.SetArgv(1, argv);
1103         m_client.Run("change", &m_ui);
1104
1105         string change(m_ui.m_output);
1106         string description;
1107         description.Format("%s", pDesc);
1108         change.Replace("<enter description here>", description);
1109
1110         string files("Files:");
1111         int end = change.Find(files.GetBuffer()) + files.GetLength();
1112         int iFiles = change.Find(files, end);
1113         if (iFiles >= 0)
1114         {
1115                 end = iFiles;
1116                 if (change.GetLength() > end)
1117                         change = change.Left(end);
1118         }
1119
1120         m_ui.Init();
1121         m_ui.m_input = change;
1122         m_ui.m_bIsCreatingChangelist = true;
1123         char* argv2[] = { "-i" };
1124         m_client.SetArgv(1, argv2);
1125         m_client.Run("change", &m_ui);
1126         m_ui.m_bIsCreatingChangelist = false;
1127
1128         string changeId(m_ui.m_output);
1129         int lastIdx = changeId.ReverseFind(' ');
1130         int firstIdx = changeId.Find(' ');
1131         string left = changeId.Left(lastIdx);
1132         string id(left.Right(left.GetLength() - (firstIdx + 1)));
1133         cry_sprintf(changeid, nLen, "%s", id.GetBuffer());
1134
1135         if (!m_ui.m_e.Test())
1136                 ret = true;
1137
1138         return ret;
1139 }
1140
1141 bool CPerforceSourceControl::SubmitChangeList(char* changeid)
1142 {
1143         if (!Reconnect())
1144                 return false;
1145
1146         bool bRet = false;
1147
1148         char* argv[] = { "-c", changeid };
1149         m_ui.Init();
1150         m_client.SetArgv(2, argv);
1151         m_client.Run("submit", &m_ui);
1152
1153         if (!m_ui.m_e.Test())
1154                 bRet = true;
1155
1156         return bRet;
1157 }
1158
1159 bool CPerforceSourceControl::DeleteChangeList(char* changeid)
1160 {
1161         if (!Reconnect())
1162                 return false;
1163
1164         bool bRet = false;
1165
1166         char* argv[] = { "-d", changeid };
1167         m_ui.Init();
1168         m_client.SetArgv(2, argv);
1169         m_client.Run("change", &m_ui);
1170
1171         if (!m_ui.m_e.Test())
1172                 bRet = true;
1173
1174         return bRet;
1175 }
1176
1177 bool CPerforceSourceControl::Reopen(const char* filename, char* changeid)
1178 {
1179         if (!Reconnect())
1180                 return false;
1181
1182         bool bRet = false;
1183
1184         char FullFileName[MAX_PATH];
1185         string files = filename;
1186         int curPos = 0;
1187         string file = files.Tokenize(";", curPos);
1188         for (; !file.IsEmpty(); file = files.Tokenize(";", curPos))
1189         {
1190                 if (file.Trim().IsEmpty())
1191                         continue;
1192                 uint32 attrib = GetFileAttributesAndFileName(file, FullFileName);
1193
1194                 if ((attrib != SCC_FILE_ATTRIBUTE_INVALID) && (attrib & SCC_FILE_ATTRIBUTE_MANAGED) && (attrib & SCC_FILE_ATTRIBUTE_CHECKEDOUT))
1195                 {
1196                         char* argv[] = { "-c", changeid, FullFileName };
1197                         m_ui.Init();
1198                         m_client.SetArgv(3, argv);
1199                         m_client.Run("reopen", &m_ui);
1200
1201                         if (!m_ui.m_e.Test())
1202                                 bRet = true;
1203                 }
1204         }
1205
1206         return bRet;
1207 }
1208
1209 bool CPerforceSourceControl::Add(const char* filename, const char* desc, int nFlags, char* changelistId)
1210 {
1211         if (!Reconnect())
1212                 return false;
1213
1214         bool bRet = false;
1215
1216         char FullFileName[MAX_PATH];
1217         string files = filename;
1218         int curPos = 0;
1219         string file = files.Tokenize(";", curPos);
1220         for (; !file.IsEmpty(); file = files.Tokenize(";", curPos))
1221         {
1222                 if (file.Trim().IsEmpty())
1223                         continue;
1224                 uint32 attrib = GetFileAttributesAndFileName(file, FullFileName);
1225                 char sFullFilename[ICryPak::g_nMaxPath];
1226                 if (attrib & SCC_FILE_ATTRIBUTE_FOLDER)
1227                 {
1228                         cry_strcpy(sFullFilename, filename);
1229                         cry_strcat(sFullFilename, "*");
1230                 }
1231                 else
1232                 {
1233                         MakePathCS(sFullFilename, FullFileName);
1234                         if (strcmp(sFullFilename, FullFileName))
1235                                 RenameFolders(sFullFilename, FullFileName);
1236                 }
1237
1238                 if ((attrib & SCC_FILE_ATTRIBUTE_FOLDER) || ((attrib != SCC_FILE_ATTRIBUTE_INVALID) && !(attrib & SCC_FILE_ATTRIBUTE_MANAGED) && IsFileManageable(sFullFilename)))
1239                 {
1240                         if (nFlags & ADD_CHANGELIST && changelistId)
1241                         {
1242                                 char* argv[] = { "-c", changelistId, sFullFilename };
1243                                 m_ui.Init();
1244                                 m_client.SetArgv(3, argv);
1245                                 m_client.Run("add", &m_ui);
1246
1247                                 if (desc && !(nFlags & ADD_WITHOUT_SUBMIT))
1248                                 {
1249                                         cry_strcpy(m_ui.m_desc, desc);
1250                                         m_ui.Init();
1251                                         m_client.SetArgv(2, argv);
1252                                         m_client.Run("submit", &m_ui);
1253                                 }
1254                         }
1255                         else
1256                         {
1257                                 char* argv[] = { sFullFilename };
1258                                 m_ui.Init();
1259                                 m_client.SetArgv(1, argv);
1260                                 m_client.Run("add", &m_ui);
1261
1262                                 if (desc && !(nFlags & ADD_WITHOUT_SUBMIT))
1263                                 {
1264                                         cry_strcpy(m_ui.m_desc, desc);
1265                                         m_ui.Init();
1266                                         m_client.SetArgv(1, argv);
1267                                         m_client.Run("submit", &m_ui);
1268                                 }
1269                         }
1270
1271                         if (!m_ui.m_e.Test())
1272                                 bRet = true;
1273                 }
1274         }
1275
1276         return bRet;
1277 }
1278
1279 bool CPerforceSourceControl::CheckIn(const char* filename, const char* desc, int nFlags)
1280 {
1281         if (!Reconnect())
1282                 return false;
1283
1284         bool bRet = false;
1285
1286         char FullFileName[MAX_PATH];
1287
1288         string files = filename;
1289         int curPos = 0;
1290         string file = files.Tokenize(";", curPos);
1291         for (; !file.IsEmpty(); file = files.Tokenize(";", curPos))
1292         {
1293                 if (file.Trim().IsEmpty())
1294                         continue;
1295                 uint32 attrib = GetFileAttributesAndFileName(file, FullFileName);
1296
1297                 if ((attrib & SCC_FILE_ATTRIBUTE_FOLDER) || ((attrib != SCC_FILE_ATTRIBUTE_INVALID) && (attrib & SCC_FILE_ATTRIBUTE_MANAGED) && (attrib & SCC_FILE_ATTRIBUTE_CHECKEDOUT)))
1298                 {
1299                         {
1300                                 char* argv[] = { "-c", "default", FullFileName };
1301                                 m_client.SetArgv(3, argv);
1302                                 m_client.Run("reopen", &m_ui);
1303                         }
1304
1305                         if (desc)
1306                                 cry_strcpy(m_ui.m_desc, desc);
1307                         {
1308                                 char* argv[] = { FullFileName };
1309                                 m_client.SetArgv(1, argv);
1310                                 m_client.Run("submit", &m_ui);
1311                         }
1312
1313                         if (!m_ui.m_e.Test())
1314                                 bRet = true;
1315                 }
1316         }
1317
1318         return bRet;
1319 }
1320
1321 bool CPerforceSourceControl::CheckOut(const char* filename, int nFlags, char* changelistId)
1322 {
1323         if (!Reconnect())
1324                 return false;
1325
1326         bool bRet = false;
1327
1328         char FullFileName[MAX_PATH];
1329
1330         string files = filename;
1331         int curPos = 0;
1332         string file = files.Tokenize(";", curPos);
1333         for (; !file.IsEmpty(); file = files.Tokenize(";", curPos))
1334         {
1335                 if (file.Trim().IsEmpty())
1336                         continue;
1337                 uint32 attrib = GetFileAttributesAndFileName(file, FullFileName);
1338
1339                 if ((attrib & SCC_FILE_ATTRIBUTE_FOLDER) || ((attrib & SCC_FILE_ATTRIBUTE_MANAGED) && !(attrib & SCC_FILE_ATTRIBUTE_CHECKEDOUT)))
1340                 {
1341                         if (nFlags & ADD_CHANGELIST && changelistId)
1342                         {
1343                                 char* argv[] = { "-c", changelistId, FullFileName };
1344                                 m_client.SetArgv(3, argv);
1345                                 m_client.Run("edit", &m_ui);
1346                         }
1347                         else
1348                         {
1349                                 char* argv[] = { FullFileName };
1350                                 m_client.SetArgv(1, argv);
1351                                 m_client.Run("edit", &m_ui);
1352                         }
1353
1354                         if (!m_ui.m_e.Test())
1355                                 bRet = true;
1356                 }
1357         }
1358         return bRet;
1359 }
1360
1361 bool CPerforceSourceControl::UndoCheckOut(const char* filename, int nFlags)
1362 {
1363         if (!Reconnect())
1364                 return false;
1365
1366         bool bRet = false;
1367
1368         char FullFileName[MAX_PATH];
1369
1370         string files = filename;
1371         int curPos = 0;
1372         string file = files.Tokenize(";", curPos);
1373         for (; !file.IsEmpty(); file = files.Tokenize(";", curPos))
1374         {
1375                 if (file.Trim().IsEmpty())
1376                         continue;
1377                 uint32 attrib = GetFileAttributesAndFileName(file, FullFileName);
1378
1379                 if ((attrib & SCC_FILE_ATTRIBUTE_FOLDER) || ((attrib & SCC_FILE_ATTRIBUTE_MANAGED) && (attrib & SCC_FILE_ATTRIBUTE_CHECKEDOUT)))
1380                 {
1381                         char* argv[] = { FullFileName };
1382                         m_client.SetArgv(1, argv);
1383                         m_client.Run("revert", &m_ui);
1384                         if (!m_ui.m_e.Test())
1385                                 bRet = true;
1386                 }
1387         }
1388         return true; // always return true to avoid error message box on folder operation
1389 }
1390
1391 bool CPerforceSourceControl::Rename(const char* filename, const char* newname, const char* desc, int nFlags)
1392 {
1393         if (!Reconnect())
1394                 return false;
1395
1396         bool bRet = false;
1397         char FullFileName[MAX_PATH];
1398         uint32 attrib = GetFileAttributesAndFileName(filename, FullFileName);
1399
1400         if (!(attrib & SCC_FILE_ATTRIBUTE_MANAGED))
1401                 return true;
1402
1403         if (attrib & SCC_FILE_ATTRIBUTE_CHECKEDOUT)
1404                 UndoCheckOut(filename, 0);
1405
1406         //if(m_pIntegrator->FileCheckedOutByAnotherUser(FullFileName))
1407         //return false;
1408
1409         char FullNewFileName[MAX_PATH];
1410         cry_strcpy(FullNewFileName, newname);
1411
1412         {
1413                 char* argv[] = { FullFileName, FullNewFileName };
1414                 m_client.SetArgv(2, argv);
1415                 m_client.Run("integrate", &m_ui);
1416         }
1417
1418         {
1419                 char* argv[] = { FullFileName };
1420                 m_client.SetArgv(1, argv);
1421                 m_client.Run("delete", &m_ui);
1422         }
1423         if (desc)
1424                 cry_strcpy(m_ui.m_desc, desc);
1425         {
1426                 char* argv[] = { FullFileName };
1427                 m_client.SetArgv(1, argv);
1428                 m_client.Run("submit", &m_ui);
1429         }
1430
1431         if (desc)
1432                 cry_strcpy(m_ui.m_desc, desc);
1433         {
1434                 char* argv[] = { FullNewFileName };
1435                 m_client.SetArgv(1, argv);
1436                 m_client.Run("submit", &m_ui);
1437         }
1438
1439         if (!m_ui.m_e.Test())
1440                 bRet = true;
1441
1442         //p4 integrate source_file target_file
1443         //p4 delete source_file
1444         //p4 submit
1445
1446         return bRet;
1447 }
1448
1449 bool CPerforceSourceControl::Delete(const char* filename, const char* desc, int nFlags, char* changelistId /*= NULL*/)
1450 {
1451         if (!Reconnect())
1452                 return false;
1453
1454         bool bRet = false;
1455         char FullFileName[MAX_PATH];
1456         uint32 attrib = GetFileAttributesAndFileName(filename, FullFileName);
1457
1458         if (!(attrib & SCC_FILE_ATTRIBUTE_MANAGED))
1459                 return true;
1460
1461         if ((attrib & SCC_FILE_ATTRIBUTE_MANAGED) && (attrib & SCC_FILE_ATTRIBUTE_CHECKEDOUT))
1462         {
1463                 char* argv[] = { FullFileName };
1464                 m_client.SetArgv(1, argv);
1465                 m_client.Run("revert", &m_ui);
1466         }
1467
1468         if ((nFlags & ADD_CHANGELIST) && (changelistId != NULL))
1469         {
1470                 char* argv[] = { "-c", changelistId, FullFileName };
1471                 m_client.SetArgv(3, argv);
1472                 m_client.Run("delete", &m_ui);
1473
1474                 if (desc && !(nFlags & DELETE_WITHOUT_SUBMIT))
1475                 {
1476                         cry_strcpy(m_ui.m_desc, desc);
1477                         m_client.SetArgv(2, argv);
1478                         m_client.Run("submit", &m_ui);
1479                 }
1480         }
1481         else
1482         {
1483                 char* argv[] = { FullFileName };
1484                 m_client.SetArgv(1, argv);
1485                 m_client.Run("delete", &m_ui);
1486
1487                 if (desc && !(nFlags & DELETE_WITHOUT_SUBMIT))
1488                 {
1489                         cry_strcpy(m_ui.m_desc, desc);
1490                         m_client.SetArgv(1, argv);
1491                         m_client.Run("submit", &m_ui);
1492                 }
1493         }
1494
1495         if (!m_ui.m_e.Test())
1496                 bRet = true;
1497
1498         return bRet;
1499 }
1500
1501 void CPerforceSourceControl::SetWorkOffline(bool bWorkOffline)
1502 {
1503         m_bIsWorkOffline = bWorkOffline;
1504         signalWorkOfflineChanged();
1505 }
1506
1507 void CPerforceSourceControl::ShowSettings()
1508 {
1509         m_isSkipThread = true;
1510
1511         string strPassword(m_client.GetPassword().Value());
1512         string strClient(m_client.GetClient().Value());
1513         string strUser(m_client.GetUser().Value());
1514         string strPort(m_client.GetPort().Value());
1515
1516         if (PerforceConnection::OpenPasswordDlg(strPort, strUser, strClient, strPassword, m_bIsWorkOffline))
1517         {
1518                 Error e;
1519                 m_client.DefinePassword(strPassword, &e);
1520                 m_client.DefineClient(strClient, &e);
1521                 m_client.DefinePort(strPort, &e);
1522                 m_client.DefineUser(strUser, &e);
1523                 CheckConnection();
1524         }
1525 }
1526
1527 const char* CPerforceSourceControl::GetErrorByGenericCode(int nGeneric)
1528 {
1529         switch (nGeneric)
1530         {
1531         case EV_USAGE:
1532                 return "Request is not consistent with documentation or cannot support a server version";
1533         case EV_UNKNOWN:
1534                 return "Using unknown entity";
1535         case EV_CONTEXT:
1536                 return "Using entity in wrong context";
1537         case EV_ILLEGAL:
1538                 return "Trying to do something you can't";
1539         case EV_NOTYET:
1540                 return "Something must be corrected first";
1541         case EV_PROTECT:
1542                 return "Operation was prevented by protection level";
1543
1544         // No fault at all
1545         case EV_EMPTY:
1546                 return "Action returned empty results";
1547
1548         // not the fault of the user
1549         case EV_FAULT:
1550                 return "Inexplicable program fault";
1551         case EV_CLIENT:
1552                 return "Client side program errors";
1553         case EV_ADMIN:
1554                 return "Server administrative action required";
1555         case EV_CONFIG:
1556                 return "Client configuration is inadequate";
1557         case EV_UPGRADE:
1558                 return "Client or server is too old to interact";
1559         case EV_COMM:
1560                 return "Communication error";
1561         case EV_TOOBIG:
1562                 return "File is too big";
1563         }
1564
1565         return "Undefined";
1566 }
1567
1568 bool CPerforceSourceControl::Run(const char* func, int nArgs, char* argv[], bool bOnlyFatal)
1569 {
1570         for (int x = 0; x < nArgs; ++x)
1571         {
1572                 if (argv[x][0] == '\0')
1573                         return false;
1574         }
1575
1576         if (!Reconnect())
1577                 return false;
1578
1579         bool bRet = false;
1580
1581         m_ui.Init();
1582         m_client.SetArgv(nArgs, argv);
1583         m_client.Run(func, &m_ui);
1584         m_client.WaitTag();
1585
1586 #if 0 // connection debug
1587         for (int argid = 0; argid < nArgs; argid++)
1588         {
1589                 CryLog("\n arg %d : %s", argid, argv[argid]);
1590         }
1591 #endif // connection debug
1592
1593         if (bOnlyFatal)
1594         {
1595                 if (!m_ui.m_e.IsFatal())
1596                         bRet = true;
1597         }
1598         else
1599         {
1600                 if (!m_ui.m_e.Test())
1601                         bRet = true;
1602         }
1603
1604         if (m_ui.m_e.GetSeverity() == E_FAILED || m_ui.m_e.GetSeverity() == E_FATAL)
1605         {
1606                 static int nGenericPrev = 0;
1607                 const int nGeneric = m_ui.m_e.GetGeneric();
1608
1609                 if (IsSomeTimePassed())
1610                         nGenericPrev = 0;
1611
1612                 if (nGenericPrev != nGeneric)
1613                 {
1614                         CryWarning(VALIDATOR_MODULE_EDITOR, VALIDATOR_ERROR, "Perforce plugin: %s", GetErrorByGenericCode(nGeneric));
1615
1616                         StrBuf m;
1617                         m_ui.m_e.Fmt(&m);
1618                         CryWarning(VALIDATOR_MODULE_EDITOR, VALIDATOR_ERROR, "Perforce plugin: %s", m.Text());
1619                         nGenericPrev = nGeneric;
1620                 }
1621         }
1622
1623         m_ui.m_e.Clear();
1624         return bRet;
1625 }
1626
1627 bool CPerforceSourceControl::CheckConnection()
1628 {
1629         m_ui.m_bIsClientUnknown = false;
1630         bool bRet = false;
1631
1632         if (!m_bIsWorkOffline)
1633         {
1634                 bRet = Run("info", 0, 0);
1635         }
1636
1637         if (m_bIsWorkOffline)
1638         {
1639                 CryWarning(VALIDATOR_MODULE_EDITOR, VALIDATOR_ERROR, "Perforce plugin: Perforce is offline");
1640                 return false;
1641         }
1642
1643         if (m_ui.m_bIsClientUnknown || m_ui.m_clientRoot.IsEmpty())
1644         {
1645                 string errorMsg;
1646                 errorMsg.Format("Workspace %s for host %s is unknown. Check Perforce settings.", m_ui.m_clientName, m_ui.m_clientHost);
1647                 CryWarning(VALIDATOR_MODULE_EDITOR, VALIDATOR_ERROR, string("Perforce plugin: ") + errorMsg);
1648                 bRet = false;
1649         }
1650         else if (m_ui.m_clientRoot.CompareNoCase(m_ui.m_currentDirectory.Left(m_ui.m_clientRoot.GetLength())))
1651         {
1652                 string errorMsg;
1653                 errorMsg.Format("Working folder (%s) is out of Perforce root (%s). Change Perforce settings or start Editor from %s...", m_ui.m_currentDirectory, m_ui.m_clientRoot, m_ui.m_clientRoot);
1654                 CryWarning(VALIDATOR_MODULE_EDITOR, VALIDATOR_ERROR, string("Perforce plugin: ") + errorMsg);
1655                 bRet = false;
1656         }
1657         return bRet;
1658 }
1659
1660 bool CPerforceSourceControl::GetLatestVersion(const char* filename, int nFlags)
1661 {
1662         if (!Reconnect())
1663                 return false;
1664
1665         bool bRet = false;
1666         char FullFileName[MAX_PATH];
1667
1668         string files = filename;
1669         int curPos = 0;
1670         string file = files.Tokenize(";", curPos);
1671         for (; !file.IsEmpty(); file = files.Tokenize(";", curPos))
1672         {
1673                 if (file.Trim().IsEmpty())
1674                         continue;
1675                 uint32 attrib = GetFileAttributesAndFileName(file, FullFileName);
1676
1677                 if (!(attrib & SCC_FILE_ATTRIBUTE_MANAGED))
1678                         continue;
1679
1680                 if ((attrib & SCC_FILE_ATTRIBUTE_CHECKEDOUT) && ((nFlags & GETLATEST_REVERT) == 0))
1681                         continue;
1682
1683                 if (nFlags & GETLATEST_REVERT)
1684                 {
1685                         char* argv[] = { FullFileName };
1686                         m_client.SetArgv(1, argv);
1687                         m_client.Run("revert", &m_ui);
1688                 }
1689
1690                 if (nFlags & GETLATEST_ONLY_CHECK)
1691                 {
1692                         if (attrib & SCC_FILE_ATTRIBUTE_FOLDER)
1693                                 bRet = true;
1694                         else
1695                                 bRet = IsFileLatestVersion(FullFileName);
1696                 }
1697                 else
1698                 {
1699                         char* argv[] = { "-f", FullFileName };
1700                         m_client.SetArgv(2, argv);
1701                         m_client.Run("sync", &m_ui);
1702                         bRet = true;
1703                 }
1704         }
1705
1706         return bRet;
1707 }
1708
1709 bool CPerforceSourceControl::GetInternalPath(const char* filename, char* outPath, int nOutPathSize)
1710 {
1711         if (!filename || !outPath)
1712                 return false;
1713
1714         uint32 attrib = GetFileAttributesAndFileName(filename, 0);
1715
1716         if (attrib & SCC_FILE_ATTRIBUTE_MANAGED && *m_ui.m_depotFile)
1717         {
1718                 cry_strcpy(outPath, nOutPathSize, m_ui.m_depotFile);
1719                 return true;
1720         }
1721         return false;
1722 }
1723
1724 bool CPerforceSourceControl::GetOtherUser(const char* filename, char* outUser, int nOutUserSize)
1725 {
1726         if (!filename || !outUser)
1727                 return false;
1728
1729         uint32 attrib = GetFileAttributesAndFileName(filename, 0);
1730
1731         if (attrib & SCC_FILE_ATTRIBUTE_MANAGED && *m_ui.m_otherUser)
1732         {
1733                 cry_strcpy(outUser, nOutUserSize, m_ui.m_otherUser);
1734                 return true;
1735         }
1736         return false;
1737 }
1738
1739 bool CPerforceSourceControl::History(const char* filename)
1740 {
1741         if (!filename)
1742                 return false;
1743
1744         uint32 attrib = GetFileAttributesAndFileName(filename, 0);
1745
1746         if (attrib & SCC_FILE_ATTRIBUTE_MANAGED && *m_ui.m_depotFile)
1747         {
1748                 string commandLine = string("-cmd \"history ") + string(m_ui.m_depotFile) + "\"";
1749                 ShellExecute(NULL, NULL, "p4v.exe", commandLine, NULL, SW_SHOW);
1750                 return true;
1751         }
1752         return false;
1753 }
1754
1755 bool CPerforceSourceControl::IsSomeTimePassed()
1756 {
1757         const DWORD dwSomeTime = 10000; // 10 sec
1758         static DWORD dwLastTime = 0;
1759         DWORD dwCurTime = GetTickCount();
1760
1761         if (dwCurTime - dwLastTime > dwSomeTime)
1762         {
1763                 dwLastTime = dwCurTime;
1764                 return true;
1765         }
1766
1767         return false;
1768 }
1769
1770 bool CPerforceSourceControl::GetOtherLockOwner(const char* filename, char* outUser, int nOutUserSize)
1771 {
1772         if (NULL == filename || NULL == outUser)
1773                 return false;
1774
1775         uint32 attrib = GetFileAttributesAndFileName(filename, 0);
1776         if (attrib & SCC_FILE_ATTRIBUTE_LOCKEDBYANOTHER && *m_ui.m_lockedBy)
1777         {
1778                 cry_strcpy(outUser, nOutUserSize, m_ui.m_lockedBy);
1779                 return true;
1780         }
1781
1782         return false;
1783 }
1784
1785 ESccLockStatus CPerforceSourceControl::GetLockStatus(const char* filename)
1786 {
1787         Reconnect();
1788         ESccLockStatus nRet = SCC_LOCK_STATUS_UNLOCKED;
1789
1790         m_ui.m_e.Clear();
1791
1792         char fl[MAX_PATH];
1793         cry_strcpy(fl, filename);
1794         char* argv[] = { fl };
1795         m_ui.Init();
1796         m_client.SetArgv(1, argv);
1797         m_client.Run("fstat", &m_ui);
1798         m_client.WaitTag();
1799
1800         if (!m_ui.m_e.Test())
1801                 nRet = SCC_LOCK_STATUS_UNLOCKED; // default to not locked
1802
1803         if (nRet >= 0                                                                    // if no error
1804             && (0 == strcmp(m_ui.m_action, "edit") || 0 == strcmp(m_ui.m_action, "add")) // checked out
1805             )
1806         {
1807                 nRet = m_ui.m_lockStatus;
1808         }
1809
1810         m_ui.m_e.Clear();
1811         return nRet;
1812 }
1813
1814 bool CPerforceSourceControl::Lock(const char* filename, int nFlags)
1815 {
1816         Reconnect();
1817         char fullFileName[MAX_PATH];
1818         uint32 attrib = GetFileAttributesAndFileName(filename, fullFileName);
1819
1820         if (!(attrib & SCC_FILE_ATTRIBUTE_MANAGED))
1821                 return false;
1822
1823         if (!(attrib & SCC_FILE_ATTRIBUTE_CHECKEDOUT))
1824         {
1825                 if (false == CheckOut(filename, 0))
1826                         return false;
1827         }
1828
1829         if (attrib & SCC_FILE_ATTRIBUTE_LOCKEDBYANOTHER)
1830                 return false;
1831
1832         char* argv[] = { fullFileName };
1833         m_client.SetArgv(1, argv);
1834         m_client.Run("lock", &m_ui);
1835         return !m_ui.m_e.Test();
1836 }
1837
1838 bool CPerforceSourceControl::Unlock(const char* filename, int nFlags)
1839 {
1840         Reconnect();
1841         char fullFileName[MAX_PATH];
1842         uint32 attrib = GetFileAttributesAndFileName(filename, fullFileName);
1843
1844         if (!(attrib & SCC_FILE_ATTRIBUTE_MANAGED))
1845                 return false;
1846
1847         if (attrib & SCC_FILE_ATTRIBUTE_LOCKEDBYANOTHER)
1848                 return false;
1849
1850         if (!(attrib & SCC_FILE_ATTRIBUTE_CHECKEDOUT))
1851                 return true;
1852
1853         char* argv[] = { fullFileName };
1854         m_client.SetArgv(1, argv);
1855         m_client.Run("unlock", &m_ui);
1856         return !m_ui.m_e.Test();
1857 }
1858
1859 bool CPerforceSourceControl::GetUserName(char* outUser, int nOutUserSize)
1860 {
1861         cry_strcpy(outUser, nOutUserSize, m_client.GetUser().Text());
1862         return true;
1863 }
1864
1865 bool CPerforceSourceControl::GetFileRev(const char* sFilename, int64* pHaveRev, int64* pHeadRev)
1866 {
1867         Reconnect();
1868         bool bRet = false;
1869
1870         m_ui.Init();
1871         m_ui.m_nFileHaveRev = -1;
1872         m_ui.m_nFileHeadRev = -1;
1873
1874         char fl[MAX_PATH];
1875         cry_strcpy(fl, sFilename);
1876         char* argv[] = { fl };
1877         m_client.SetArgv(1, argv);
1878         m_client.Run("fstat", &m_ui);
1879         m_client.WaitTag();
1880
1881         if (m_ui.m_nFileHaveRev >= 0 || m_ui.m_nFileHeadRev >= 0)
1882                 bRet = true;
1883
1884         if (pHaveRev)
1885                 *pHaveRev = m_ui.m_nFileHaveRev;
1886         if (pHeadRev)
1887                 *pHeadRev = m_ui.m_nFileHeadRev;
1888
1889         m_ui.m_e.Clear();
1890         return bRet;
1891 }
1892
1893 bool CPerforceSourceControl::GetRevision(const char* filename, int64 nRev, int nFlags)
1894 {
1895         bool bRet = false;
1896         char FullFileName[MAX_PATH];
1897
1898         string files = filename;
1899         int curPos = 0;
1900         string file = files.Tokenize(";", curPos);
1901         for (; !file.IsEmpty(); file = files.Tokenize(";", curPos))
1902         {
1903                 if (file.Trim().IsEmpty())
1904                         continue;
1905                 uint32 attrib = GetFileAttributesAndFileName(file, FullFileName);
1906
1907                 cry_sprintf(&FullFileName[strlen(FullFileName)], sizeof(FullFileName) - strlen(FullFileName), "#%I64d", nRev);
1908
1909                 if (!(attrib & SCC_FILE_ATTRIBUTE_MANAGED))
1910                         continue;
1911
1912                 if (attrib & SCC_FILE_ATTRIBUTE_CHECKEDOUT && (nFlags & GETLATEST_REVERT))
1913                 {
1914                         char* argv[] = { FullFileName };
1915                         m_client.SetArgv(1, argv);
1916                         m_client.Run("revert", &m_ui);
1917                 }
1918                 if (nFlags & GETLATEST_ONLY_CHECK)
1919                 {
1920                         if (attrib & SCC_FILE_ATTRIBUTE_FOLDER)
1921                                 bRet = true;
1922                         else
1923                                 bRet = IsFileLatestVersion(FullFileName);
1924                 }
1925                 else
1926                 {
1927                         char* argv[] = { "-f", FullFileName };
1928                         m_client.SetArgv(2, argv);
1929                         m_client.Run("sync", &m_ui);
1930                         bRet = true;
1931                 }
1932         }
1933
1934         return bRet;
1935 }