src/TortoiseProc/GitStatusListCtrlHelpers.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2008 - TortoiseSVN
   4 // Copyright (C) 2008-2011 - 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 BLAME_COLUMN_VERSION 4
  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 != NULL) && (*rhs != 0))
  45         {
  46                 const char* next = strchr (rhs, ' ');
  47
  48                 CString name (rhs, static_cast<int>(next == NULL ? strlen (rhs) : next - rhs));
  49                 properties.insert (std::make_pair (name, CString()));
  50
  51                 rhs = next == NULL ? NULL : 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.begin(), end = properties.end()
  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 (size_t i = 0; i < maxsize; ++i)
 121         {
 122                 columns[i].index = static_cast<int>(i);
 123                 if(widthlist==NULL)
 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) == BLAME_COLUMN_VERSION;
 140         if (valid)
 141         {
 142                 // read (possibly different) column selection
 143
 144                 selectedStandardColumns = CRegDWORD (registryPrefix, selectedStandardColumns) & ~hideColumns;
 145
 146                 // read user-prop lists
 147
 148                 CString userPropList = CRegString (registryPrefix + _T("UserProps"));
 149                 CString shownUserProps = CRegString (registryPrefix + _T("ShownUserProps"));
 150
 151                 ParseUserPropSettings (userPropList, shownUserProps);
 152
 153                 // read column widths
 154
 155                 CString colWidths = CRegString (registryPrefix + _T("_Width"));
 156
 157                 ParseWidths (colWidths);
 158         }
 159
 160         // process old-style visibility setting
 161
 162         SetStandardColumnVisibility (selectedStandardColumns);
 163
 164         // clear all previously set header columns
 165
 166         int c = ((CHeaderCtrl*)(control->GetDlgItem(0)))->GetItemCount()-1;
 167         while (c>=0)
 168                 control->DeleteColumn(c--);
 169
 170         // create columns
 171
 172         for (int i = 0, count = GetColumnCount(); i < count; ++i)
 173                 control->InsertColumn (i, GetName(i), LVCFMT_LEFT, IsVisible(i)&&IsRelevant(i) ? -1 : GetVisibleWidth(i, false));
 174
 175         // restore column ordering
 176
 177         if (valid)
 178                 ParseColumnOrder (CRegString (registryPrefix + _T("_Order")));
 179         else
 180                 ParseColumnOrder (CString());
 181
 182         ApplyColumnOrder();
 183
 184         // auto-size the columns so we can see them while fetching status
 185         // (seems the same values will not take affect in InsertColumn)
 186
 187         for (int i = 0, count = GetColumnCount(); i < count; ++i)
 188                 if (IsVisible(i))
 189                         control->SetColumnWidth (i, GetVisibleWidth (i, true));
 190 }
 191
 192 void ColumnManager::WriteSettings() const
 193 {
 194         CRegDWORD regVersion (registryPrefix + _T("Version"), 0, TRUE);
 195         regVersion = BLAME_COLUMN_VERSION;
 196
 197         // write (possibly different) column selection
 198
 199         CRegDWORD regStandardColumns (registryPrefix, 0, TRUE);
 200         regStandardColumns = GetSelectedStandardColumns();
 201
 202         // write user-prop lists
 203
 204         CRegString regUserProps (registryPrefix + _T("UserProps"), CString(), TRUE);
 205         regUserProps = GetUserPropList();
 206
 207         CRegString regShownUserProps (registryPrefix + _T("ShownUserProps"), CString(), TRUE);
 208         regShownUserProps = GetShownUserProps();
 209
 210         // write column widths
 211
 212         CRegString regWidths (registryPrefix + _T("_Width"), CString(), TRUE);
 213         regWidths = GetWidthString();
 214
 215         // write column ordering
 216
 217         CRegString regColumnOrder (registryPrefix + _T("_Order"), CString(), TRUE);
 218         regColumnOrder = GetColumnOrderString();
 219 }
 220
 221 // read column definitions
 222
 223 int ColumnManager::GetColumnCount() const
 224 {
 225         return static_cast<int>(columns.size());
 226 }
 227
 228 bool ColumnManager::IsVisible (int column) const
 229 {
 230         size_t index = static_cast<size_t>(column);
 231         assert (columns.size() > index);
 232
 233         return columns[index].visible;
 234 }
 235
 236 int ColumnManager::GetInvisibleCount() const
 237 {
 238         int invisibleCount = 0;
 239         for (std::vector<ColumnInfo>::const_iterator it = columns.begin(); it != columns.end(); ++it)
 240         {
 241                 if (!it->visible)
 242                         invisibleCount++;
 243         }
 244         return invisibleCount;
 245 }
 246
 247 bool ColumnManager::IsRelevant (int column) const
 248 {
 249         size_t index = static_cast<size_t>(column);
 250         assert (columns.size() > index);
 251
 252         return columns[index].relevant;
 253 }
 254
 255 bool ColumnManager::IsUserProp (int column) const
 256 {
 257         size_t index = static_cast<size_t>(column);
 258         assert (columns.size() > index);
 259
 260         return columns[index].index >= GITSLC_USERPROPCOLOFFSET;
 261 }
 262
 263 int ColumnManager::SetNames(UINT* buffer, int size)
 264 {
 265         itemName.clear();
 266         for(int i=0;i<size;i++)
 267                 itemName.push_back(*buffer++);
 268         return 0;
 269 }
 270
 271 CString ColumnManager::GetName (int column) const
 272 {
 273         // standard columns
 274         size_t index = static_cast<size_t>(column);
 275         if (index < itemName.size())
 276         {
 277                 CString result;
 278                 result.LoadString (itemName[index]);
 279                 return result;
 280         }
 281
 282         // user-prop columns
 283
 284         //      if (index < columns.size())
 285         //              return userProps[columns[index].index - SVNSLC_USERPROPCOLOFFSET].name;
 286
 287         // default: empty
 288
 289         return CString();
 290 }
 291
 292 int ColumnManager::GetWidth (int column, bool useDefaults) const
 293 {
 294         size_t index = static_cast<size_t>(column);
 295         assert (columns.size() > index);
 296
 297         int width = columns[index].width;
 298         if ((width == 0) && useDefaults)
 299                 width = LVSCW_AUTOSIZE_USEHEADER;
 300
 301         return width;
 302 }
 303
 304 int ColumnManager::GetVisibleWidth (int column, bool useDefaults) const
 305 {
 306         return IsVisible (column)
 307                 ? GetWidth (column, useDefaults)
 308                 : 0;
 309 }
 310
 311 // switch columns on and off
 312
 313 void ColumnManager::SetVisible
 314         ( int column
 315         , bool visible)
 316 {
 317         size_t index = static_cast<size_t>(column);
 318         assert (index < columns.size());
 319
 320         if (columns[index].visible != visible)
 321         {
 322                 columns[index].visible = visible;
 323                 columns[index].relevant |= visible;
 324                 if (!visible)
 325                         columns[index].width = 0;
 326
 327                 control->SetColumnWidth (column, GetVisibleWidth (column, true));
 328                 ApplyColumnOrder();
 329
 330                 control->Invalidate (FALSE);
 331         }
 332 }
 333
 334 // tracking column modifications
 335
 336 void ColumnManager::ColumnMoved (int column, int position)
 337 {
 338         // in front of what column has it been inserted?
 339
 340         int index = columns[column].index;
 341
 342         std::vector<int> gridColumnOrder = GetGridColumnOrder();
 343
 344         size_t visiblePosition = static_cast<size_t>(position);
 345         size_t columnCount = gridColumnOrder.size();
 346
 347         for (; (visiblePosition < columnCount)
 348                         && !columns[gridColumnOrder[visiblePosition]].visible
 349                         ; ++visiblePosition )
 350         {
 351         }
 352
 353         int next = -1;
 354         if (visiblePosition != columnCount)
 355         {
 356                 next = gridColumnOrder[visiblePosition];
 357         }
 358
 359         // move logical column index just in front of that "next" column
 360
 361         columnOrder.erase (std::find ( columnOrder.begin(), columnOrder.end(), index));
 362         columnOrder.insert ( std::find ( columnOrder.begin(), columnOrder.end(), next), index);
 363
 364         // make sure, invisible columns are still put in front of all others
 365
 366         ApplyColumnOrder();
 367 }
 368
 369 void ColumnManager::ColumnResized (int column)
 370 {
 371         size_t index = static_cast<size_t>(column);
 372         assert (index < columns.size());
 373         assert (columns[index].visible);
 374
 375         int width = control->GetColumnWidth (column);
 376         columns[index].width = width;
 377
 378         int propertyIndex = columns[index].index;
 379         if (propertyIndex >= GITSLC_USERPROPCOLOFFSET)
 380                 userProps[propertyIndex - GITSLC_USERPROPCOLOFFSET].width = width;
 381
 382         control->Invalidate  (FALSE);
 383 }
 384
 385 // call these to update the user-prop list
 386 // (will also auto-insert /-remove new list columns)
 387 #if 0
 388 void ColumnManager::UpdateUserPropList
 389         (const std::vector<FileEntry*>& files)
 390 {
 391         // collect all user-defined props
 392
 393         std::set<CString> aggregatedProps;
 394         for (size_t i = 0, count = files.size(); i < count; ++i)
 395                 files[i]->present_props.GetPropertyNames (aggregatedProps);
 396
 397         aggregatedProps.erase (_T("svn:needs-lock"));
 398         itemProps = aggregatedProps;
 399
 400         // add new ones to the internal list
 401
 402         std::set<CString> newProps = aggregatedProps;
 403         for (size_t i = 0, count = userProps.size(); i < count; ++i)
 404                 newProps.erase (userProps[i].name);
 405
 406         while (newProps.size() + userProps.size()
 407                         > SVNSLC_MAXCOLUMNCOUNT - SVNSLC_USERPROPCOLOFFSET)
 408                 newProps.erase (--newProps.end());
 409
 410         typedef std::set<CString>::const_iterator CIT;
 411         for ( CIT iter = newProps.begin(), end = newProps.end()
 412                 ; iter != end
 413                 ; ++iter)
 414         {
 415                 int index = static_cast<int>(userProps.size())
 416                                   + SVNSLC_USERPROPCOLOFFSET;
 417                 columnOrder.push_back (index);
 418
 419                 UserProp userProp;
 420                 userProp.name = *iter;
 421                 userProp.width = 0;
 422
 423                 userProps.push_back (userProp);
 424         }
 425
 426         // remove unused columns from control.
 427         // remove used ones from the set of aggregatedProps.
 428
 429         for (size_t i = columns.size(); i > 0; --i)
 430                 if ((columns[i-1].index >= SVNSLC_USERPROPCOLOFFSET)
 431                         && (aggregatedProps.erase (GetName ((int)i-1)) == 0))
 432                 {
 433                         // this user-prop has not been set on any item
 434
 435                         if (!columns[i-1].visible)
 436                         {
 437                                 control->DeleteColumn (static_cast<int>(i-1));
 438                                 columns.erase (columns.begin() + i-1);
 439                         }
 440                 }
 441
 442         // aggregatedProps now contains new columns only.
 443         // we can't use newProps here because some props may have been used
 444         // earlier but were not in the recent list of used props.
 445         // -> they are neither in columns[] nor in newProps.
 446
 447         for ( CIT iter = aggregatedProps.begin(), end = aggregatedProps.end()
 448                 ; iter != end
 449                 ; ++iter)
 450         {
 451                 // get the logical column index / ID
 452
 453                 int index = -1;
 454                 int width = 0;
 455                 for (size_t i = 0, count = userProps.size(); i < count; ++i)
 456                         if (userProps[i].name == *iter)
 457                         {
 458                                 index = static_cast<int>(i) + SVNSLC_USERPROPCOLOFFSET;
 459                                 width = userProps[i].width;
 460                                 break;
 461                         }
 462
 463                 assert (index != -1);
 464
 465                 // find insertion position
 466
 467                 std::vector<ColumnInfo>::iterator columnIter = columns.begin();
 468                 std::vector<ColumnInfo>::iterator end = columns.end();
 469                 for (; (columnIter != end) && columnIter->index < index; ++columnIter);
 470                 int pos = static_cast<int>(columnIter - columns.begin());
 471
 472                 ColumnInfo column;
 473                 column.index = index;
 474                 column.width = width;
 475                 column.visible = false;
 476
 477                 columns.insert (columnIter, column);
 478
 479                 // update control
 480
 481                 int result = control->InsertColumn (pos, *iter, LVCFMT_LEFT, GetVisibleWidth(pos, false));
 482                 assert (result != -1);
 483                 UNREFERENCED_PARAMETER(result);
 484         }
 485
 486         // update column order
 487
 488         ApplyColumnOrder();
 489 }
 490 #endif
 491 #if 0
 492 void ColumnManager::UpdateRelevance
 493         ( const std::vector<FileEntry*>& files
 494         , const std::vector<size_t>& visibleFiles)
 495 {
 496         // collect all user-defined props that belong to shown files
 497
 498         std::set<CString> aggregatedProps;
 499         for (size_t i = 0, count = visibleFiles.size(); i < count; ++i)
 500                 files[visibleFiles[i]]->present_props.GetPropertyNames (aggregatedProps);
 501
 502         aggregatedProps.erase (_T("svn:needs-lock"));
 503         itemProps = aggregatedProps;
 504
 505         // invisible columns for unused props are not relevant
 506
 507         for (int i = 0, count = GetColumnCount(); i < count; ++i)
 508                 if (IsUserProp(i) && !IsVisible(i))
 509                 {
 510                         columns[i].relevant
 511                                 = aggregatedProps.find (GetName(i)) != aggregatedProps.end();
 512                 }
 513
 514 }
 515 #endif
 516 // don't clutter the context menu with irrelevant prop info
 517
 518 bool ColumnManager::AnyUnusedProperties() const
 519 {
 520         return columns.size() < userProps.size() + itemName.size();
 521 }
 522
 523 void ColumnManager::RemoveUnusedProps()
 524 {
 525         // determine what column indexes / IDs to keep.
 526         // map them onto new IDs (we may delete some IDs in between)
 527
 528         std::map<int, int> validIndices;
 529         int userPropID = GITSLC_USERPROPCOLOFFSET;
 530
 531         for (size_t i = 0, count = columns.size(); i < count; ++i)
 532         {
 533                 int index = columns[i].index;
 534
 535                 if (itemProps.find (GetName((int)i)) != itemProps.end()
 536                         || columns[i].visible
 537                         || index < GITSLC_USERPROPCOLOFFSET)
 538                 {
 539                         validIndices[index] = index < GITSLC_USERPROPCOLOFFSET
 540                                                                 ? index
 541                                                                 : userPropID++;
 542                 }
 543         }
 544
 545         // remove everything else:
 546
 547         // remove from columns and control.
 548         // also update index values in columns
 549
 550         for (size_t i = columns.size(); i > 0; --i)
 551         {
 552                 std::map<int, int>::const_iterator iter
 553                         = validIndices.find (columns[i-1].index);
 554
 555                 if (iter == validIndices.end())
 556                 {
 557                         control->DeleteColumn (static_cast<int>(i-1));
 558                         columns.erase (columns.begin() + i-1);
 559                 }
 560                 else
 561                 {
 562                         columns[i-1].index = iter->second;
 563                 }
 564         }
 565
 566         // remove from user props
 567
 568         for (size_t i = userProps.size(); i > 0; --i)
 569         {
 570                 int index = static_cast<int>(i)-1 + GITSLC_USERPROPCOLOFFSET;
 571                 if (validIndices.find (index) == validIndices.end())
 572                         userProps.erase (userProps.begin() + i-1);
 573         }
 574
 575         // remove from and update column order
 576
 577         for (size_t i = columnOrder.size(); i > 0; --i)
 578         {
 579                 std::map<int, int>::const_iterator iter
 580                         = validIndices.find (columnOrder[i-1]);
 581
 582                 if (iter == validIndices.end())
 583                         columnOrder.erase (columnOrder.begin() + i-1);
 584                 else
 585                         columnOrder[i-1] = iter->second;
 586         }
 587 }
 588
 589 // bring everything back to its "natural" order
 590
 591 void ColumnManager::ResetColumns (DWORD defaultColumns)
 592 {
 593         // update internal data
 594
 595         std::sort (columnOrder.begin(), columnOrder.end());
 596
 597         for (size_t i = 0, count = columns.size(); i < count; ++i)
 598         {
 599                 columns[i].width = 0;
 600                 columns[i].visible = (i < 32) && (((defaultColumns >> i) & 1) != 0);
 601         }
 602
 603         for (size_t i = 0, count = userProps.size(); i < count; ++i)
 604                 userProps[i].width = 0;
 605
 606         // update UI
 607
 608         for (int i = 0, count = GetColumnCount(); i < count; ++i)
 609                 control->SetColumnWidth (i, GetVisibleWidth (i, true));
 610
 611         ApplyColumnOrder();
 612
 613         control->Invalidate (FALSE);
 614 }
 615
 616 // initialization utilities
 617
 618 void ColumnManager::ParseUserPropSettings(const CString& userPropList, const CString& shownUserProps)
 619 {
 620         assert (userProps.empty());
 621
 622         static CString delimiters (_T(" "));
 623
 624         // parse list of visible user-props
 625
 626         std::set<CString> visibles;
 627
 628         int pos = 0;
 629         CString name = shownUserProps.Tokenize (delimiters, pos);
 630         while (!name.IsEmpty())
 631         {
 632                 visibles.insert (name);
 633                 name = shownUserProps.Tokenize (delimiters, pos);
 634         }
 635
 636         // create list of all user-props
 637
 638         pos = 0;
 639         name = userPropList.Tokenize (delimiters, pos);
 640         while (!name.IsEmpty())
 641         {
 642                 bool visible = visibles.find (name) != visibles.end();
 643
 644                 UserProp newEntry;
 645                 newEntry.name = name;
 646                 newEntry.width = 0;
 647
 648                 userProps.push_back (newEntry);
 649
 650                 // auto-create columns for visible user-props
 651                 // (others may be added later)
 652
 653                 if (visible)
 654                 {
 655                         ColumnInfo newColumn;
 656                         newColumn.width = 0;
 657                         newColumn.visible = true;
 658                         newColumn.relevant = true;
 659                         newColumn.index = static_cast<int>(userProps.size())
 660                                                         + GITSLC_USERPROPCOLOFFSET - 1;
 661
 662                         columns.push_back (newColumn);
 663                 }
 664
 665                 name = userPropList.Tokenize (delimiters, pos);
 666         }
 667 }
 668
 669 void ColumnManager::ParseWidths (const CString& widths)
 670 {
 671         for (int i = 0, count = widths.GetLength() / 8; i < count; ++i)
 672         {
 673                 long width = _tcstol (widths.Mid (i*8, 8), NULL, 16);
 674                 if (i < itemName.size())
 675                 {
 676                         // a standard column
 677
 678                         columns[i].width = width;
 679                 }
 680                 else if (i >= GITSLC_USERPROPCOLOFFSET)
 681                 {
 682                         // a user-prop column
 683
 684                         size_t index = static_cast<size_t>(i - GITSLC_USERPROPCOLOFFSET);
 685                         assert (index < userProps.size());
 686                         userProps[index].width = width;
 687
 688                         for (size_t k = 0, count = columns.size(); k < count; ++k)
 689                                 if (columns[k].index == i)
 690                                         columns[k].width = width;
 691                 }
 692                 else
 693                 {
 694                         // there is no such column
 695
 696                         assert (width == 0);
 697                 }
 698         }
 699 }
 700
 701 void ColumnManager::SetStandardColumnVisibility
 702         (DWORD visibility)
 703 {
 704         for (size_t i = 0; i < itemName.size(); ++i)
 705         {
 706                 columns[i].visible = (visibility & 1) > 0;
 707                 visibility /= 2;
 708         }
 709 }
 710
 711 void ColumnManager::ParseColumnOrder
 712         (const CString& widths)
 713 {
 714         std::set<int> alreadyPlaced;
 715         columnOrder.clear();
 716
 717         // place columns according to valid entries in orderString
 718
 719         int limit = static_cast<int>(GITSLC_USERPROPCOLOFFSET + userProps.size());
 720         for (int i = 0, count = widths.GetLength() / 2; i < count; ++i)
 721         {
 722                 int index = _tcstol (widths.Mid (i*2, 2), NULL, 16);
 723                 if ((index < itemName.size())
 724                         || ((index >= GITSLC_USERPROPCOLOFFSET) && (index < limit)))
 725                 {
 726                         alreadyPlaced.insert (index);
 727                         columnOrder.push_back (index);
 728                 }
 729         }
 730
 731         // place the remaining colums behind it
 732
 733         for (int i = 0; i < itemName.size(); ++i)
 734                 if (alreadyPlaced.find (i) == alreadyPlaced.end())
 735                         columnOrder.push_back (i);
 736
 737         for (int i = GITSLC_USERPROPCOLOFFSET; i < limit; ++i)
 738                 if (alreadyPlaced.find (i) == alreadyPlaced.end())
 739                         columnOrder.push_back (i);
 740 }
 741
 742 // map internal column order onto visible column order
 743 // (all invisibles in front)
 744
 745 std::vector<int> ColumnManager::GetGridColumnOrder()
 746 {
 747         // extract order of used columns from order of all columns
 748
 749         std::vector<int> result;
 750         result.reserve (GITSLC_MAXCOLUMNCOUNT+1);
 751
 752         size_t colCount = columns.size();
 753         bool visible = false;
 754
 755         do
 756         {
 757                 // put invisible cols in front
 758
 759                 for (size_t i = 0, count = columnOrder.size(); i < count; ++i)
 760                 {
 761                         int index = columnOrder[i];
 762                         for (size_t k = 0; k < colCount; ++k)
 763                         {
 764                                 const ColumnInfo& column = columns[k];
 765                                 if ((column.index == index) && (column.visible == visible))
 766                                         result.push_back (static_cast<int>(k));
 767                         }
 768                 }
 769
 770                 visible = !visible;
 771         }
 772         while (visible);
 773
 774         return result;
 775 }
 776
 777 void ColumnManager::ApplyColumnOrder()
 778 {
 779         // extract order of used columns from order of all columns
 780
 781         int order[GITSLC_MAXCOLUMNCOUNT+1];
 782         SecureZeroMemory (order, sizeof (order));
 783
 784         std::vector<int> gridColumnOrder = GetGridColumnOrder();
 785         std::copy (gridColumnOrder.begin(), gridColumnOrder.end(), stdext::checked_array_iterator<int*>(&order[0], sizeof(order)));
 786
 787         // we must have placed all columns or something is really fishy ..
 788
 789         assert (gridColumnOrder.size() == columns.size());
 790         assert (GetColumnCount() == ((CHeaderCtrl*)(control->GetDlgItem(0)))->GetItemCount());
 791
 792         // o.k., apply our column ordering
 793
 794         control->SetColumnOrderArray (GetColumnCount(), order);
 795 }
 796
 797 // utilities used when writing data to the registry
 798
 799 DWORD ColumnManager::GetSelectedStandardColumns() const
 800 {
 801         DWORD result = 0;
 802         for (size_t i = itemName.size(); i > 0; --i)
 803                 result = result * 2 + (columns[i-1].visible ? 1 : 0);
 804
 805         return result;
 806 }
 807
 808 CString ColumnManager::GetUserPropList() const
 809 {
 810         CString result;
 811
 812         for (size_t i = 0, count = userProps.size(); i < count; ++i)
 813                 result += userProps[i].name + _T(' ');
 814
 815         return result;
 816 }
 817
 818 CString ColumnManager::GetShownUserProps() const
 819 {
 820         CString result;
 821
 822         for (size_t i = 0, count = columns.size(); i < count; ++i)
 823         {
 824                 size_t index = static_cast<size_t>(columns[i].index);
 825                 if (columns[i].visible && (index >= GITSLC_USERPROPCOLOFFSET))
 826                         result += userProps[index - GITSLC_USERPROPCOLOFFSET].name
 827                                         + _T(' ');
 828         }
 829
 830         return result;
 831 }
 832
 833 CString ColumnManager::GetWidthString() const
 834 {
 835         CString result;
 836
 837         // regular columns
 838
 839         TCHAR buf[10];
 840         for (size_t i = 0; i < itemName.size(); ++i)
 841         {
 842                 _stprintf_s (buf, 10, _T("%08X"), columns[i].width);
 843                 result += buf;
 844         }
 845
 846         // range with no column IDs
 847
 848         result += CString ('0', 8 * (GITSLC_USERPROPCOLOFFSET - itemName.size()));
 849
 850         // user-prop columns
 851
 852         for (size_t i = 0, count = userProps.size(); i < count; ++i)
 853         {
 854                 _stprintf_s (buf, 10, _T("%08X"), userProps[i].width);
 855                 result += buf;
 856         }
 857
 858         return result;
 859 }
 860
 861 CString ColumnManager::GetColumnOrderString() const
 862 {
 863         CString result;
 864
 865         TCHAR buf[3];
 866         for (size_t i = 0, count = columnOrder.size(); i < count; ++i)
 867         {
 868                 _stprintf_s (buf, 3, _T("%02X"), columnOrder[i]);
 869                 result += buf;
 870         }
 871
 872         return result;
 873 }
 874
 875 // sorter utility class, only used by GitStatusList!
 876
 877 CSorter::CSorter ( ColumnManager* columnManager
 878                                                                         , int sortedColumn
 879                                                                         , bool ascending)
 880                                                                         : columnManager (columnManager)
 881                                                                         , sortedColumn (sortedColumn)
 882                                                                         , ascending (ascending)
 883 {
 884 }
 885
 886 bool CSorter::operator() (const CTGitPath* entry1 , const CTGitPath* entry2) const
 887 {
 888 #define SGN(x) ((x)==0?0:((x)>0?1:-1))
 889
 890         int result = 0;
 891         switch (sortedColumn)
 892         {
 893         case 5: //Del Number
 894                 {
 895                         if (result == 0)
 896                         {
 897 //                              result = entry1->lock_comment.CompareNoCase(entry2->lock_comment);
 898                                 result = A2L(entry1->m_StatDel)-A2L(entry2->m_StatDel);
 899                         }
 900                 }
 901         case 4: //Add Number
 902                 {
 903                         if (result == 0)
 904                         {
 905                                 //result = entry1->lock_owner.CompareNoCase(entry2->lock_owner);
 906                                 result = A2L(entry1->m_StatAdd)-A2L(entry2->m_StatAdd);
 907                         }
 908                 }
 909
 910         case 3: // Status
 911                 {
 912                         if (result == 0)
 913                         {
 914                                 result = entry1->GetActionName(entry1->m_Action).CompareNoCase(entry2->GetActionName(entry2->m_Action));
 915                         }
 916                 }
 917         case 2: //Ext file
 918                 {
 919                         if (result == 0)
 920                         {
 921                                 result = entry1->GetFileExtension().CompareNoCase(entry2->GetFileExtension());
 922                         }
 923                 }
 924         case 1: // File name
 925                 {
 926                         if (result == 0)
 927                         {
 928                                 result = entry1->GetFileOrDirectoryName().CompareNoCase(entry2->GetFileOrDirectoryName());
 929                         }
 930                 }
 931         case 0: // Full path column
 932                 {
 933                         if (result == 0)
 934                         {
 935                                 result = CTGitPath::Compare(entry1->GetGitPathString(), entry2->GetGitPathString());
 936                         }
 937                 }
 938         default:
 939                 if ((result == 0) && (sortedColumn > 0))
 940                 {
 941                         // N/A props are "less than" empty props
 942
 943 //                      const CString& propName = columnManager->GetName (sortedColumn);
 944
 945 //                      bool entry1HasProp = entry1->present_props.HasProperty (propName);
 946 //                      bool entry2HasProp = entry2->present_props.HasProperty (propName);
 947
 948 //                      if (entry1HasProp)
 949 //                      {
 950 //                              result = entry2HasProp
 951 //                                      ? entry1->present_props[propName].Compare
 952 //                                      (entry2->present_props[propName])
 953 //                                      : 1;
 954 //                      }
 955 //                      else
 956 //                      {
 957 //                              result = entry2HasProp ? -1 : 0;
 958 //                      }
 959                 }
 960         } // switch (m_nSortedColumn)
 961         if (!ascending)
 962                 result = -result;
 963
 964         return result < 0;
 965 }