src/TortoiseProc/GitStatusListCtrlHelpers.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2008, 2014 - TortoiseSVN
   4 // Copyright (C) 2008-2016 - TortoiseGit
   5
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License
   8 // as published by the Free Software Foundation; either version 2
   9 // of the License, or (at your option) any later version.
  10
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software Foundation,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20
  21 #include "stdafx.h"
  22 #include "resource.h"
  23 #include "GitStatusListCtrl.h"
  24 #include <iterator>
  25
  26 // registry version number of column-settings of GitLogListBase
  27 #define GITSLC_COL_VERSION 5
  28
  29 #ifndef assert
  30 #define assert(x) ATLASSERT(x)
  31 #endif
  32 // assign property list
  33 #if 0
  34 PropertyList&
  35 PropertyList::operator= (const char* rhs)
  36 {
  37         // do you really want to replace the property list?
  38
  39         assert (properties.empty());
  40         properties.clear();
  41
  42         // add all properties in the list
  43
  44         while (rhs && *rhs)
  45         {
  46                 const char* next = strchr (rhs, ' ');
  47
  48                 CString name (rhs, static_cast<int>(!next ? strlen (rhs) : next - rhs));
  49                 properties.insert (std::make_pair (name, CString()));
  50
  51                 rhs = !next ? nullptr : next + 1;
  52         }
  53
  54         // done
  55
  56         return *this;
  57 }
  58
  59 // collect property names in a set
  60
  61 void PropertyList::GetPropertyNames (std::set<CString>& names)
  62 {
  63         for (CIT iter = properties.cbegin(), end = properties.cend()
  64                 ; iter != end
  65                 ; ++iter)
  66         {
  67                 names.insert (iter->first);
  68         }
  69 }
  70
  71 // get a property value.
  72
  73 CString PropertyList::operator[](const CString& name) const
  74 {
  75         CIT iter = properties.find (name);
  76
  77         return iter == properties.end()
  78                 ? CString()
  79                 : iter->second;
  80 }
  81
  82 // set a property value.
  83
  84 CString& PropertyList::operator[](const CString& name)
  85 {
  86         return properties[name];
  87 }
  88
  89 /// check whether that property has been set on this item.
  90
  91 bool PropertyList::HasProperty (const CString& name) const
  92 {
  93         return properties.find (name) != properties.end();
  94 }
  95
  96 // due to frequent use: special check for svn:needs-lock
  97
  98 bool PropertyList::IsNeedsLockSet() const
  99 {
 100         static const CString svnNeedsLock = _T("svn:needs-lock");
 101         return HasProperty (svnNeedsLock);
 102 }
 103
 104 #endif
 105 // registry access
 106
 107 void ColumnManager::ReadSettings
 108         ( DWORD defaultColumns
 109         , DWORD hideColumns
 110         , const CString& containerName
 111         , int maxsize
 112         , int * widthlist)
 113 {
 114         // defaults
 115         DWORD selectedStandardColumns = defaultColumns & ~hideColumns;
 116         m_dwDefaultColumns = defaultColumns & ~hideColumns;
 117
 118         columns.resize (maxsize);
 119         int power = 1;
 120         for (int i = 0; i < maxsize; ++i)
 121         {
 122                 columns[i].index = static_cast<int>(i);
 123                 if (!widthlist)
 124                         columns[i].width = 0;
 125                 else
 126                         columns[i].width = widthlist[i];
 127                 columns[i].visible = true;
 128                 columns[i].relevant = !(hideColumns & power);
 129                 power *= 2;
 130         }
 131
 132 //      userProps.clear();
 133
 134         // where the settings are stored within the registry
 135
 136         registryPrefix = _T("Software\\TortoiseGit\\StatusColumns\\") + containerName;
 137
 138         // we accept settings of current version only
 139         bool valid = (DWORD)CRegDWORD (registryPrefix + _T("Version"), 0xff) == GITSLC_COL_VERSION;
 140         if (valid)
 141         {
 142                 // read (possibly different) column selection
 143
 144                 selectedStandardColumns = CRegDWORD (registryPrefix, selectedStandardColumns) & ~hideColumns;
 145
 146                 // read column widths
 147
 148                 CString colWidths = CRegString (registryPrefix + _T("_Width"));
 149
 150                 ParseWidths (colWidths);
 151         }
 152
 153         // process old-style visibility setting
 154
 155         SetStandardColumnVisibility (selectedStandardColumns);
 156
 157         // clear all previously set header columns
 158
 159         int c = control->GetHeaderCtrl()->GetItemCount() - 1;
 160         while (c>=0)
 161                 control->DeleteColumn(c--);
 162
 163         // create columns
 164
 165         for (int i = 0, count = GetColumnCount(); i < count; ++i)
 166                 control->InsertColumn (i, GetName(i), LVCFMT_LEFT, IsVisible(i)&&IsRelevant(i) ? -1 : GetVisibleWidth(i, false));
 167
 168         // restore column ordering
 169
 170         if (valid)
 171                 ParseColumnOrder (CRegString (registryPrefix + _T("_Order")));
 172         else
 173                 ParseColumnOrder (CString());
 174
 175         ApplyColumnOrder();
 176
 177         // auto-size the columns so we can see them while fetching status
 178         // (seems the same values will not take affect in InsertColumn)
 179
 180         for (int i = 0, count = GetColumnCount(); i < count; ++i)
 181                 if (IsVisible(i))
 182                         control->SetColumnWidth (i, GetVisibleWidth (i, true));
 183 }
 184
 185 void ColumnManager::WriteSettings() const
 186 {
 187         CRegDWORD regVersion (registryPrefix + _T("Version"), 0, TRUE);
 188         regVersion = GITSLC_COL_VERSION;
 189
 190         // write (possibly different) column selection
 191
 192         CRegDWORD regStandardColumns (registryPrefix, 0, TRUE);
 193         regStandardColumns = GetSelectedStandardColumns();
 194
 195         // write column widths
 196
 197         CRegString regWidths (registryPrefix + _T("_Width"), CString(), TRUE);
 198         regWidths = GetWidthString();
 199
 200         // write column ordering
 201
 202         CRegString regColumnOrder (registryPrefix + _T("_Order"), CString(), TRUE);
 203         regColumnOrder = GetColumnOrderString();
 204 }
 205
 206 // read column definitions
 207
 208 int ColumnManager::GetColumnCount() const
 209 {
 210         return static_cast<int>(columns.size());
 211 }
 212
 213 bool ColumnManager::IsVisible (int column) const
 214 {
 215         size_t index = static_cast<size_t>(column);
 216         assert (columns.size() > index);
 217
 218         return columns[index].visible;
 219 }
 220
 221 int ColumnManager::GetInvisibleCount() const
 222 {
 223         int invisibleCount = 0;
 224         for (const auto& column : columns)
 225         {
 226                 if (!column.visible)
 227                         invisibleCount++;
 228         }
 229         return invisibleCount;
 230 }
 231
 232 bool ColumnManager::IsRelevant (int column) const
 233 {
 234         size_t index = static_cast<size_t>(column);
 235         assert (columns.size() > index);
 236
 237         return columns[index].relevant;
 238 }
 239
 240 int ColumnManager::SetNames(UINT* buffer, int size)
 241 {
 242         itemName.clear();
 243         for (int i = 0; i < size; ++i)
 244                 itemName.push_back(*buffer++);
 245         return 0;
 246 }
 247
 248 void ColumnManager::SetRightAlign(int column) const
 249 {
 250         assert(column < columns.size());
 251
 252         if (!IsVisible(column))
 253                 return;
 254
 255         LVCOLUMN col = { 0 };
 256         col.mask = LVCF_FMT;
 257         col.fmt = LVCFMT_RIGHT;
 258         control->SetColumn(column, &col);
 259
 260         control->Invalidate(FALSE);
 261 }
 262
 263 CString ColumnManager::GetName (int column) const
 264 {
 265         // standard columns
 266         size_t index = static_cast<size_t>(column);
 267         if (index < itemName.size())
 268         {
 269                 CString result;
 270                 result.LoadString (itemName[index]);
 271                 return result;
 272         }
 273
 274         // user-prop columns
 275
 276         //      if (index < columns.size())
 277         //              return userProps[columns[index].index - SVNSLC_USERPROPCOLOFFSET].name;
 278
 279         // default: empty
 280
 281         return CString();
 282 }
 283
 284 int ColumnManager::GetWidth (int column, bool useDefaults) const
 285 {
 286         size_t index = static_cast<size_t>(column);
 287         assert (columns.size() > index);
 288
 289         int width = columns[index].width;
 290         if ((width == 0) && useDefaults)
 291                 width = LVSCW_AUTOSIZE;
 292
 293         return width;
 294 }
 295
 296 int ColumnManager::GetVisibleWidth (int column, bool useDefaults) const
 297 {
 298         return IsVisible (column)
 299                 ? GetWidth (column, useDefaults)
 300                 : 0;
 301 }
 302
 303 // switch columns on and off
 304
 305 void ColumnManager::SetVisible
 306         ( int column
 307         , bool visible)
 308 {
 309         size_t index = static_cast<size_t>(column);
 310         assert (index < columns.size());
 311
 312         if (columns[index].visible != visible)
 313         {
 314                 columns[index].visible = visible;
 315                 columns[index].relevant |= visible;
 316                 if (!visible)
 317                         columns[index].width = 0;
 318
 319                 control->SetColumnWidth (column, GetVisibleWidth (column, true));
 320                 ApplyColumnOrder();
 321
 322                 control->Invalidate (FALSE);
 323         }
 324 }
 325
 326 // tracking column modifications
 327
 328 void ColumnManager::ColumnMoved (int column, int position)
 329 {
 330         // in front of what column has it been inserted?
 331
 332         int index = columns[column].index;
 333
 334         std::vector<int> gridColumnOrder = GetGridColumnOrder();
 335
 336         size_t visiblePosition = static_cast<size_t>(position);
 337         size_t columnCount = gridColumnOrder.size();
 338
 339         int next = -1;
 340         if (visiblePosition < columnCount - 1)
 341         {
 342                 // the new position (visiblePosition) is the column id w/o the moved column
 343                 gridColumnOrder.erase(std::find(gridColumnOrder.cbegin(), gridColumnOrder.cend(), index));
 344                 next = gridColumnOrder[visiblePosition];
 345         }
 346
 347         // move logical column index just in front of that "next" column
 348
 349         columnOrder.erase(std::find(columnOrder.cbegin(), columnOrder.cend(), index));
 350         columnOrder.insert(std::find(columnOrder.cbegin(), columnOrder.cend(), next), index);
 351
 352         // make sure, invisible columns are still put in front of all others
 353
 354         ApplyColumnOrder();
 355 }
 356
 357 void ColumnManager::ColumnResized (int column)
 358 {
 359         size_t index = static_cast<size_t>(column);
 360         assert (index < columns.size());
 361         assert (columns[index].visible);
 362
 363         int width = control->GetColumnWidth (column);
 364         columns[index].width = width;
 365
 366         control->Invalidate  (FALSE);
 367 }
 368
 369 void ColumnManager::RemoveUnusedProps()
 370 {
 371         // determine what column indexes / IDs to keep.
 372         // map them onto new IDs (we may delete some IDs in between)
 373
 374         std::map<int, int> validIndices;
 375
 376         for (size_t i = 0, count = columns.size(); i < count; ++i)
 377         {
 378                 int index = columns[i].index;
 379
 380                 if (itemProps.find (GetName((int)i)) != itemProps.end()
 381                         || columns[i].visible)
 382                 {
 383                         validIndices[index] = index;
 384                 }
 385         }
 386
 387         // remove everything else:
 388
 389         // remove from columns and control.
 390         // also update index values in columns
 391
 392         for (size_t i = columns.size(); i > 0; --i)
 393         {
 394                 std::map<int, int>::const_iterator iter
 395                         = validIndices.find (columns[i-1].index);
 396
 397                 if (iter == validIndices.end())
 398                 {
 399                         control->DeleteColumn (static_cast<int>(i-1));
 400                         columns.erase(columns.cbegin() + i - 1);
 401                 }
 402                 else
 403                 {
 404                         columns[i-1].index = iter->second;
 405                 }
 406         }
 407
 408         // remove from and update column order
 409
 410         for (size_t i = columnOrder.size(); i > 0; --i)
 411         {
 412                 std::map<int, int>::const_iterator iter
 413                         = validIndices.find (columnOrder[i-1]);
 414
 415                 if (iter == validIndices.end())
 416                         columnOrder.erase(columnOrder.cbegin() + i - 1);
 417                 else
 418                         columnOrder[i-1] = iter->second;
 419         }
 420 }
 421
 422 // bring everything back to its "natural" order
 423
 424 void ColumnManager::ResetColumns (DWORD defaultColumns)
 425 {
 426         // update internal data
 427
 428         std::sort(columnOrder.begin(), columnOrder.end());
 429
 430         for (size_t i = 0, count = columns.size(); i < count; ++i)
 431         {
 432                 columns[i].width = 0;
 433                 columns[i].visible = (i < 32) && (((defaultColumns >> i) & 1) != 0);
 434         }
 435
 436         // update UI
 437
 438         for (int i = 0, count = GetColumnCount(); i < count; ++i)
 439                 control->SetColumnWidth (i, GetVisibleWidth (i, true));
 440
 441         ApplyColumnOrder();
 442
 443         control->Invalidate (FALSE);
 444 }
 445
 446 // initialization utilities
 447
 448 void ColumnManager::ParseWidths (const CString& widths)
 449 {
 450         for (int i = 0, count = widths.GetLength() / 8; i < count; ++i)
 451         {
 452                 long width = _tcstol (widths.Mid (i * 8, 8), nullptr, 16);
 453                 if (i < (int)itemName.size())
 454                 {
 455                         // a standard column
 456
 457                         columns[i].width = width;
 458                 }
 459                 else
 460                 {
 461                         // there is no such column
 462
 463                         assert (width == 0);
 464                 }
 465         }
 466 }
 467
 468 void ColumnManager::SetStandardColumnVisibility
 469         (DWORD visibility)
 470 {
 471         for (size_t i = 0; i < itemName.size(); ++i)
 472         {
 473                 columns[i].visible = (visibility & 1) > 0;
 474                 visibility /= 2;
 475         }
 476 }
 477
 478 void ColumnManager::ParseColumnOrder
 479         (const CString& widths)
 480 {
 481         std::set<int> alreadyPlaced;
 482         columnOrder.clear();
 483
 484         // place columns according to valid entries in orderString
 485
 486         for (int i = 0, count = widths.GetLength() / 2; i < count; ++i)
 487         {
 488                 int index = _tcstol (widths.Mid (i * 2, 2), nullptr, 16);
 489                 if ((index < (int)itemName.size()))
 490                 {
 491                         alreadyPlaced.insert (index);
 492                         columnOrder.push_back (index);
 493                 }
 494         }
 495
 496         // place the remaining colums behind it
 497
 498         for (int i = 0; i < (int)itemName.size(); ++i)
 499                 if (alreadyPlaced.find (i) == alreadyPlaced.end())
 500                         columnOrder.push_back (i);
 501 }
 502
 503 // map internal column order onto visible column order
 504 // (all invisibles in front)
 505
 506 std::vector<int> ColumnManager::GetGridColumnOrder() const
 507 {
 508         // extract order of used columns from order of all columns
 509
 510         std::vector<int> result;
 511         result.reserve (GITSLC_MAXCOLUMNCOUNT+1);
 512
 513         size_t colCount = columns.size();
 514         bool visible = false;
 515
 516         do
 517         {
 518                 // put invisible cols in front
 519
 520                 for (size_t i = 0, count = columnOrder.size(); i < count; ++i)
 521                 {
 522                         int index = columnOrder[i];
 523                         for (size_t k = 0; k < colCount; ++k)
 524                         {
 525                                 const ColumnInfo& column = columns[k];
 526                                 if ((column.index == index) && (column.visible == visible))
 527                                         result.push_back (static_cast<int>(k));
 528                         }
 529                 }
 530
 531                 visible = !visible;
 532         }
 533         while (visible);
 534
 535         return result;
 536 }
 537
 538 void ColumnManager::ApplyColumnOrder()
 539 {
 540         // extract order of used columns from order of all columns
 541
 542         int order[GITSLC_MAXCOLUMNCOUNT + 1] = { 0 };
 543
 544         std::vector<int> gridColumnOrder = GetGridColumnOrder();
 545         std::copy(gridColumnOrder.cbegin(), gridColumnOrder.cend(), stdext::checked_array_iterator<int*>(&order[0], sizeof(order)));
 546
 547         // we must have placed all columns or something is really fishy ..
 548
 549         assert (gridColumnOrder.size() == columns.size());
 550         assert(GetColumnCount() == control->GetHeaderCtrl()->GetItemCount());
 551
 552         // o.k., apply our column ordering
 553
 554         control->SetColumnOrderArray (GetColumnCount(), order);
 555 }
 556
 557 // utilities used when writing data to the registry
 558
 559 DWORD ColumnManager::GetSelectedStandardColumns() const
 560 {
 561         DWORD result = 0;
 562         for (size_t i = itemName.size(); i > 0; --i)
 563                 result = result * 2 + (columns[i-1].visible ? 1 : 0);
 564
 565         return result;
 566 }
 567
 568 CString ColumnManager::GetWidthString() const
 569 {
 570         CString result;
 571
 572         // regular columns
 573
 574         TCHAR buf[10] = { 0 };
 575         for (size_t i = 0; i < itemName.size(); ++i)
 576         {
 577                 _stprintf_s (buf, 10, _T("%08X"), columns[i].width);
 578                 result += buf;
 579         }
 580
 581         return result;
 582 }
 583
 584 CString ColumnManager::GetColumnOrderString() const
 585 {
 586         CString result;
 587
 588         TCHAR buf[3] = { 0 };
 589         for (size_t i = 0, count = columnOrder.size(); i < count; ++i)
 590         {
 591                 _stprintf_s (buf, 3, _T("%02X"), columnOrder[i]);
 592                 result += buf;
 593         }
 594
 595         return result;
 596 }
 597
 598 // sorter utility class, only used by GitStatusList!
 599
 600 CSorter::CSorter ( ColumnManager* columnManager
 601                                                                         , int sortedColumn
 602                                                                         , bool ascending)
 603                                                                         : columnManager (columnManager)
 604                                                                         , sortedColumn (sortedColumn)
 605                                                                         , ascending (ascending)
 606 {
 607 }
 608
 609 bool CSorter::operator() (const CTGitPath* entry1 , const CTGitPath* entry2) const
 610 {
 611 #define SGN(x) ((x)==0?0:((x)>0?1:-1))
 612
 613         int result = 0;
 614         switch (sortedColumn)
 615         {
 616         case 7: // File size
 617                 {
 618                         if (result == 0)
 619                         {
 620                                 __int64 fileSize1 = entry1->IsDirectory() ? 0 : entry1->GetFileSize();
 621                                 __int64 fileSize2 = entry2->IsDirectory() ? 0 : entry2->GetFileSize();
 622
 623                                 result = int(fileSize1 - fileSize2);
 624                         }
 625                         break;
 626                 }
 627         case 6: //Last Modification Date
 628                 {
 629                         if (result == 0)
 630                         {
 631                                 __int64 writetime1 = entry1->GetLastWriteTime();
 632                                 __int64 writetime2 = entry2->GetLastWriteTime();
 633
 634                                 FILETIME* filetime1 = (FILETIME*)(__int64*)&writetime1;
 635                                 FILETIME* filetime2 = (FILETIME*)(__int64*)&writetime2;
 636
 637                                 result = CompareFileTime(filetime1, filetime2);
 638                         }
 639                         break;
 640                 }
 641         case 5: //Del Number
 642                 {
 643                         if (result == 0)
 644                         {
 645 //                              result = entry1->lock_comment.CompareNoCase(entry2->lock_comment);
 646                                 result = A2L(entry1->m_StatDel)-A2L(entry2->m_StatDel);
 647                         }
 648                         break;
 649                 }
 650         case 4: //Add Number
 651                 {
 652                         if (result == 0)
 653                         {
 654                                 //result = entry1->lock_owner.CompareNoCase(entry2->lock_owner);
 655                                 result = A2L(entry1->m_StatAdd)-A2L(entry2->m_StatAdd);
 656                         }
 657                         break;
 658                 }
 659
 660         case 3: // Status
 661                 {
 662                         if (result == 0)
 663                         {
 664                                 result = entry1->GetActionName(entry1->m_Action).CompareNoCase(entry2->GetActionName(entry2->m_Action));
 665                         }
 666                         break;
 667                 }
 668         case 2: //Ext file
 669                 {
 670                         if (result == 0)
 671                         {
 672                                 result = entry1->GetFileExtension().CompareNoCase(entry2->GetFileExtension());
 673                         }
 674                         break;
 675                 }
 676         case 1: // File name
 677                 {
 678                         if (result == 0)
 679                         {
 680                                 result = entry1->GetFileOrDirectoryName().CompareNoCase(entry2->GetFileOrDirectoryName());
 681                         }
 682                         break;
 683                 }
 684         case 0: // Full path column
 685                 {
 686                         if (result == 0)
 687                         {
 688                                 result = CTGitPath::Compare(entry1->GetGitPathString(), entry2->GetGitPathString());
 689                         }
 690                         break;
 691                 }
 692         } // switch (m_nSortedColumn)
 693         // sort by path name as second priority
 694         if (sortedColumn > 0 && result == 0)
 695                 result = CTGitPath::Compare(entry1->GetGitPathString(), entry2->GetGitPathString());
 696         if (!ascending)
 697                 result = -result;
 698
 699         return result < 0;
 700 }