src/Utils/ACListWnd.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (c) 2003 by Andreas Kapust <info@akinstaller.de>; <http://www.codeproject.com/Articles/2607/AutoComplete-without-IAutoComplete>
   4 // Copyright (C) 2009, 2012-2013, 2015-2016, 2018 - TortoiseGit
   5
   6 // Licensed under: The Code Project Open License (CPOL); <http://www.codeproject.com/info/cpol10.aspx>
   7
   8 // ACWnd.cpp: Implementierungsdatei
   9 //
  10
  11 #include "stdafx.h"
  12 #include "ACListWnd.h"
  13 #include "StringUtils.h"
  14
  15 #ifdef _DEBUG
  16 #define new DEBUG_NEW
  17 #undef THIS_FILE
  18 static char THIS_FILE[] = __FILE__;
  19 #endif
  20
  21 static UINT auIDStatusBar[] =
  22 {
  23         ID_SEPARATOR
  24 };
  25
  26 #define _MAX_ENTRYS_ 8
  27 #define _MODE_FIND_ALL_                 (1L << 5)
  28
  29 /////////////////////////////////////////////////////////////////////////////
  30 // CACListWnd
  31
  32 void DoPaintMessageLoop()
  33 {
  34         MSG message1;
  35         while (::PeekMessage(&message1, nullptr, WM_PAINT, WM_PAINT, PM_REMOVE))
  36         {
  37                 ::TranslateMessage(&message1);
  38                 ::DispatchMessage(&message1);
  39         }
  40 }
  41
  42 /**********************************************************************/
  43
  44 CACListWnd::CACListWnd()
  45 {
  46         m_lTopIndex = 0;
  47         m_lCount = 0;
  48         m_ItemHeight = 16;
  49         m_lSelItem = -1;
  50         m_VisibleItems = 0;
  51         m_pEditParent = nullptr;
  52         m_LastSize.SetRectEmpty();
  53         m_PrefixChar = 0;
  54         m_lMode = 0;
  55         pFontDC = nullptr;
  56         m_nIDTimer = 0;
  57         SecureZeroMemory(&logfont, sizeof(LOGFONT));
  58
  59         NONCLIENTMETRICS metrics = { 0 };
  60         metrics.cbSize = sizeof(NONCLIENTMETRICS);
  61         SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &metrics, FALSE);
  62         m_uiFont.CreateFontIndirect(&metrics.lfMessageFont);
  63 }
  64
  65 /**********************************************************************/
  66
  67 CACListWnd::~CACListWnd()
  68 {
  69         m_SearchList.RemoveAll();
  70         m_DisplayList.RemoveAll();
  71         DestroyWindow();
  72 }
  73
  74 /*********************************************************************/
  75
  76 void CACListWnd::OnActivateApp(BOOL bActive, DWORD dwThreadID)
  77 {
  78 #if (_MSC_VER >= 1300)
  79         CWnd::OnActivateApp(bActive, dwThreadID);  //vc7    FIX 1.2
  80 #else
  81         CWnd::OnActivateApp(bActive, (HTASK)dwThreadID); //vc6        FIX 1.2
  82 #endif
  83
  84         ShowWindow(false);
  85 }
  86
  87
  88 BEGIN_MESSAGE_MAP(CACListWnd, CWnd)
  89         //{{AFX_MSG_MAP(CACListWnd)
  90         ON_WM_PAINT()
  91         ON_WM_SIZE()
  92         ON_WM_ERASEBKGND()
  93         ON_WM_NCPAINT()
  94         ON_WM_KEYDOWN()
  95         ON_WM_NCCALCSIZE()
  96         ON_WM_VSCROLL()
  97         ON_WM_ACTIVATEAPP()
  98         ON_WM_NCHITTEST()
  99         ON_WM_LBUTTONDOWN()
 100         ON_WM_RBUTTONDOWN()
 101         ON_WM_SETCURSOR()
 102         ON_WM_SHOWWINDOW()
 103         ON_WM_NCLBUTTONDOWN()
 104         ON_WM_MOUSEMOVE()
 105         ON_WM_TIMER()
 106         ON_WM_GETMINMAXINFO()
 107         //}}AFX_MSG_MAP
 108 END_MESSAGE_MAP()
 109
 110
 111 /////////////////////////////////////////////////////////////////////////////
 112 // Behandlungsroutinen für Nachrichten CACListWnd
 113
 114 void CACListWnd::DrawItem(CDC* pDC,long m_lItem,long width)
 115 {
 116         long y = m_lItem - m_lTopIndex;
 117         CRect rcLabel(2,y*m_ItemHeight,width,(y+1)*m_ItemHeight);
 118
 119         pDC->SetTextColor(::GetSysColor(COLOR_WINDOWTEXT));
 120
 121         if(m_lItem == m_lSelItem)
 122         {
 123                 rcLabel.left = 0;
 124                 pDC->FillSolidRect(rcLabel,::GetSysColor(COLOR_HIGHLIGHT));
 125                 pDC->SetTextColor(::GetSysColor(COLOR_HIGHLIGHTTEXT));
 126                 rcLabel.left = 2;
 127         }
 128
 129         if(m_PrefixChar)
 130                 m_DisplayStr = m_PrefixChar + m_DisplayList.GetAt(m_lItem);
 131         else
 132                 m_DisplayStr = m_DisplayList.GetAt(m_lItem);
 133
 134         pDC->DrawText(m_DisplayStr, -1, rcLabel, DT_LEFT | DT_SINGLELINE |
 135                 DT_NOPREFIX | DT_VCENTER | DT_END_ELLIPSIS);
 136 }
 137
 138 /*********************************************************************/
 139
 140 void CACListWnd::OnPaint()
 141 {
 142         CPaintDC dc(this);
 143         CRect rcWnd,m_rect, rc;
 144         CDC MemDC, *pDC = nullptr;
 145         CBitmap  m_bitmap, *m_pOldBitmap;
 146         int i;
 147
 148         GetClientRect(rc);
 149         rcWnd = m_rect = rc;
 150
 151         rc.left = rc.right-GetSystemMetrics(SM_CXHSCROLL);
 152         rc.top = rc.bottom-GetSystemMetrics(SM_CYVSCROLL);
 153
 154         m_rect.right -= ScrollBarWidth();
 155
 156         MemDC.CreateCompatibleDC(&dc);
 157
 158         m_bitmap.CreateCompatibleBitmap(&dc, m_rect.Width(), m_rect.Height());
 159         m_pOldBitmap = MemDC.SelectObject(&m_bitmap);
 160
 161         MemDC.SetWindowOrg(m_rect.left, m_rect.top);
 162
 163         long width = rcWnd.Width() - ScrollBarWidth();
 164
 165         MemDC.FillSolidRect(rcWnd,::GetSysColor(COLOR_WINDOW));
 166         MemDC.SelectObject(m_uiFont);
 167         MemDC.SetBkMode(TRANSPARENT);
 168
 169         for(i = m_lTopIndex; i < m_lCount;i++)
 170         {
 171                 DrawItem(&MemDC,i,width);
 172         }
 173
 174
 175         CPen m_Pen1(PS_SOLID, 1, ::GetSysColor(COLOR_WINDOW));
 176         CPen m_Pen2(PS_SOLID, 1, ::GetSysColor(COLOR_BTNFACE));
 177         CPen m_Pen3(PS_SOLID, 1, ::GetSysColor(COLOR_3DSHADOW));
 178
 179         pDC = &dc;
 180
 181         if(m_VertBar.IsWindowVisible())
 182                 dc.FillSolidRect(rc, ::GetSysColor(COLOR_BTNFACE) );
 183         else
 184                 pDC = &MemDC;
 185
 186         CPen *pOldPen = (CPen*)pDC->SelectObject(&m_Pen1);
 187         int a = 1,bottom;
 188
 189         width = GetSystemMetrics(SM_CXHSCROLL);
 190         bottom = (rcWnd.bottom-GetSystemMetrics(SM_CXHSCROLL))-1;
 191
 192         //gripper
 193         for( i = 0; i < 20 ;i++,a++)
 194         {
 195                 if(a==1)
 196                         pDC->SelectObject(&m_Pen1);
 197                 if(a==2)
 198                         pDC->SelectObject(&m_Pen2);
 199                 if(a==3)
 200                         pDC->SelectObject(&m_Pen3);
 201                 if(a > 3)
 202                         a = 0;
 203
 204                 pDC->MoveTo(rc.left + i - 1, rcWnd.bottom);
 205                 pDC->LineTo(rc.left + i + width, bottom);
 206         }
 207
 208         dc.BitBlt(m_rect.left, m_rect.top, m_rect.Width(), m_rect.Height(),
 209                 &MemDC, m_rect.left, m_rect.top, SRCCOPY);
 210
 211         pDC->SelectObject( pOldPen );
 212         MemDC.SelectObject(m_pOldBitmap);
 213 }
 214
 215 /*********************************************************************/
 216
 217 void CACListWnd::Init(CWnd *pWnd)
 218 {
 219         VERIFY(m_VertBar.Create(WS_VISIBLE|SBS_VERT|SBS_LEFTALIGN,
 220                 CRect(0,0,GetSystemMetrics(SM_CYVSCROLL),100),this,0));
 221
 222         SetScroller();
 223         m_pEditParent = (CEdit*)pWnd;
 224
 225         m_lCount = (long)m_DisplayList.GetSize();
 226         m_VertBar.SetScrollPos(0,false);
 227         SetProp();
 228
 229         CDC *m_pDC;
 230         m_pDC = GetDC();
 231         if(m_pDC)
 232         {
 233                 m_pDC->SelectObject(GetStockObject(DEFAULT_GUI_FONT));
 234                 CSize m_Size = m_pDC->GetOutputTextExtent(L"Hg");
 235                 m_ItemHeight = m_Size.cy;
 236                 ReleaseDC(m_pDC);
 237         }
 238 }
 239
 240 /*********************************************************************/
 241
 242 void CACListWnd::SetScroller()
 243 {
 244         CRect rcWnd,rcBar;
 245         GetClientRect(rcWnd);
 246
 247         if(m_VertBar.GetSafeHwnd())
 248         {
 249                 rcBar = rcWnd;
 250                 rcBar.top=-1;
 251                 rcBar.left = (rcWnd.Width()-GetSystemMetrics(SM_CYVSCROLL));
 252                 rcBar.bottom-= GetSystemMetrics(SM_CYHSCROLL);
 253                 m_VertBar.MoveWindow(rcBar);
 254                 rcBar.top = rcWnd.bottom-20;
 255                 rcBar.bottom = rcWnd.bottom;
 256
 257                 m_VertBar.SetScrollPos(m_lTopIndex,true);
 258         }
 259 }
 260
 261 /*********************************************************************/
 262
 263 void CACListWnd::OnSize(UINT nType, int cx, int cy)
 264 {
 265         CWnd::OnSize(nType, cx, cy);
 266         SetScroller();
 267         SetProp();
 268
 269         if(!m_LastSize.IsRectEmpty())
 270                 GetWindowRect(m_LastSize);
 271 }
 272
 273 /*********************************************************************/
 274
 275 long CACListWnd::ScrollBarWidth()
 276 {
 277         if(m_VertBar.IsWindowVisible())
 278                 return GetSystemMetrics(SM_CYVSCROLL);
 279         else
 280                 return 0;
 281 }
 282
 283 /*********************************************************************/
 284
 285 void CACListWnd::SetProp()
 286 {
 287         CRect rcWnd,rcBar;
 288
 289         if(!m_lCount)
 290                 return;
 291
 292         CWnd::GetWindowRect(rcWnd);
 293         ScreenToClient(rcWnd);
 294
 295         SCROLLINFO si;
 296         si.cbSize = sizeof(SCROLLINFO);
 297         si.fMask =  SIF_PAGE|SIF_RANGE;
 298         si.nMin = 0;
 299         si.nMax =  m_lCount-1;
 300         m_VisibleItems = si.nPage = rcWnd.Height()/m_ItemHeight;
 301         si.nTrackPos = 2;
 302         m_VertBar.SetScrollRange(0,m_lCount-1);
 303         m_VertBar.SetScrollInfo(&si);
 304
 305         if(m_VisibleItems > m_lCount-1)
 306                 m_VertBar.ShowWindow(false);
 307         else
 308                 m_VertBar.ShowWindow(true);
 309
 310         if(m_lTopIndex+m_VisibleItems > m_lCount)
 311         {
 312                 m_lTopIndex = m_lCount-m_VisibleItems;
 313                 if(m_lTopIndex < 0)
 314                         m_lTopIndex = 0;
 315                 m_VertBar.SetScrollPos(m_lTopIndex,true);
 316         }
 317 }
 318
 319 /*********************************************************************/
 320
 321 BOOL CACListWnd::OnEraseBkgnd(CDC* /*pDC*/)
 322 {
 323         return false;
 324 }
 325
 326 /*********************************************************************/
 327
 328 void CACListWnd::OnNcPaint()
 329 {
 330         CWindowDC dc(this);
 331         CRect rectClient, rectWindow,rcWnd;
 332
 333         GetClientRect(rectClient);
 334         GetWindowRect(rectWindow);
 335         ScreenToClient(rectWindow);
 336
 337         rectClient.OffsetRect(-(rectWindow.left), -(rectWindow.top));
 338         dc.ExcludeClipRect(rectClient);
 339
 340         rectWindow.OffsetRect(-rectWindow.left, -rectWindow.top);
 341
 342         dc.FillSolidRect(rectWindow,::GetSysColor(COLOR_WINDOWTEXT));
 343 }
 344
 345 /*********************************************************************/
 346
 347 void CACListWnd::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
 348 {
 349         CWnd::OnKeyDown(nChar, nRepCnt, nFlags);
 350
 351         if (nChar == VK_ESCAPE)
 352                 ShowWindow(false);
 353 }
 354
 355 /*********************************************************************/
 356
 357 void CACListWnd::OnNcCalcSize(BOOL /*bCalcValidRects*/, NCCALCSIZE_PARAMS FAR* lpncsp)
 358 {
 359         ::InflateRect(lpncsp->rgrc,
 360                 -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
 361 }
 362
 363 /*********************************************************************/
 364
 365 int CACListWnd::HitTest(CPoint point)
 366 {
 367         CRect rcItem;
 368         CRect rcWnd;
 369
 370         GetClientRect(rcWnd);
 371         long width = rcWnd.Width() - ScrollBarWidth();
 372
 373         for(int i = m_lTopIndex; i < m_lCount; i++)
 374         {
 375                 long y = i - m_lTopIndex;
 376                 rcItem.SetRect(2,y*m_ItemHeight,width,(y+1)*m_ItemHeight);
 377
 378                 if(PtInRect(&rcItem, point))
 379                         return (m_lSelItem = (y+m_lTopIndex));
 380         }
 381
 382         return -1;
 383 }
 384
 385 /*********************************************************************/
 386
 387 LRESULT CACListWnd::OnNcHitTest(CPoint point)
 388 {
 389         CRect rectClient;
 390         GetWindowRect(rectClient);
 391
 392         rectClient.left = rectClient.right - GetSystemMetrics(SM_CYVSCROLL);
 393         rectClient.top = rectClient.bottom - GetSystemMetrics(SM_CXVSCROLL);
 394
 395         if(rectClient.PtInRect(point))
 396                 return HTBOTTOMRIGHT;
 397         else
 398                 return HTCLIENT;
 399 }
 400
 401 /*********************************************************************/
 402
 403 void CACListWnd::OnLButtonDown(UINT nFlags, CPoint point)
 404 {
 405         CWnd::OnLButtonDown(nFlags, point);
 406         int sel = HitTest(point);
 407
 408         if(sel >= 0)
 409         {
 410                 if(!EnsureVisible(sel,true))
 411                         Invalidate();
 412                 m_lSelItem = sel;
 413                 m_pEditParent->SendMessage(ENAC_UPDATE, WM_KEYDOWN, GetDlgCtrlID());
 414                 DoPaintMessageLoop();
 415                 Sleep(500);
 416                 ShowWindow(false);
 417         }
 418         else
 419         {
 420                 CRect rc;
 421                 GetClientRect(rc);
 422                 if(!rc.PtInRect(point))
 423                         ShowWindow(false);
 424         }
 425 }
 426
 427 /*********************************************************************/
 428
 429 void CACListWnd::OnRButtonDown(UINT nFlags, CPoint point)
 430 {
 431         CWnd::OnRButtonDown(nFlags, point);
 432         ShowWindow(false);
 433 }
 434
 435 /*********************************************************************/
 436
 437 BOOL CACListWnd::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
 438 {
 439         CRect rectClient;
 440         CPoint ptCursor;
 441
 442         GetWindowRect(rectClient);
 443         ScreenToClient(&rectClient);
 444
 445         rectClient.left = rectClient.right - GetSystemMetrics(SM_CYVSCROLL);
 446         rectClient.top = rectClient.bottom - GetSystemMetrics(SM_CXVSCROLL);
 447
 448
 449         GetCursorPos(&ptCursor);
 450         ScreenToClient(&ptCursor);
 451
 452         if(rectClient.PtInRect(ptCursor)) // Vergrößerungs-Cursor
 453         {
 454                 return CWnd::OnSetCursor(pWnd, nHitTest, message);
 455         }
 456
 457         ::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
 458         return TRUE;
 459 }
 460
 461 /*********************************************************************/
 462
 463 void CACListWnd::InvalidateAndScroll()
 464 {
 465         m_VertBar.SetScrollPos(m_lTopIndex,true);
 466         Invalidate();
 467         DoPaintMessageLoop();
 468 }
 469
 470 /*********************************************************************/
 471
 472 bool CACListWnd::EnsureVisible(int item, bool m_bWait)
 473 {
 474         if(item > m_lTopIndex && item < m_lTopIndex + m_VisibleItems)
 475                 return false; // ist visible
 476
 477         if(item > m_lTopIndex)  // scroll down
 478         {
 479                 long m_len = item;
 480                 for(int i = m_lTopIndex; i < m_len; i++)
 481                 {
 482                         if(i >= m_lCount-m_VisibleItems)
 483                                 break;
 484                         if(i >= m_lCount-m_VisibleItems || i + m_VisibleItems > item)
 485                         {
 486                                 break;
 487                         }
 488
 489                         m_lTopIndex++;
 490
 491                         if(m_bWait)
 492                         {
 493                                 InvalidateAndScroll();
 494                                 Sleep(10);
 495                                 DoPaintMessageLoop();
 496                         }
 497                 }
 498                 InvalidateAndScroll();
 499                 return true;
 500         }
 501
 502         if(item < m_lTopIndex)  // scroll up
 503         {
 504                 while(item < m_lTopIndex)
 505                 {
 506                         if(m_lTopIndex > 0)
 507                                 m_lTopIndex--;
 508                         else
 509                         {
 510                                 break;
 511                         }
 512
 513                         if(m_bWait)
 514                         {
 515                                 InvalidateAndScroll();
 516                                 Sleep(10);
 517                                 DoPaintMessageLoop();
 518                         }
 519                 }
 520
 521                 InvalidateAndScroll();
 522                 return true;
 523         }
 524
 525         return false;
 526 }
 527
 528 /*********************************************************************/
 529
 530 bool CACListWnd::SelectItem(int item)
 531 {
 532         if(item > m_lCount)
 533                 return false;
 534
 535         if(item == -1)
 536         {
 537                 EnsureVisible(m_lSelItem,false);
 538                 Invalidate();
 539                 return false;
 540         }
 541
 542         m_lSelItem = item;
 543
 544         if(!EnsureVisible(item,true))
 545                 Invalidate();
 546
 547         return true;
 548 }
 549
 550 /*********************************************************************/
 551
 552 int CACListWnd::FindStringExact( int nStartAfter, LPCTSTR lpszString )
 553 {
 554         if(nStartAfter > m_SearchList.GetSize())
 555                 return -1;
 556
 557         for(int i = nStartAfter+1; i < m_SearchList.GetSize(); i++)
 558                 if(m_SearchList.GetAt(i).Compare(lpszString) == 0)
 559                         return i;
 560         return -1;
 561 }
 562
 563 /*********************************************************************/
 564 /*
 565 ** Vers. 1.1
 566 * NEW: m_bDisplayOnly
 567 */
 568 int CACListWnd::FindString(int nStartAfter, LPCTSTR lpszString, bool m_bDisplayOnly)
 569 {
 570         long m_AktCount = (long)m_DisplayList.GetSize();
 571
 572         if(!m_bDisplayOnly)
 573         {
 574                 CString m_Str1,m_Str2 = lpszString;
 575                 if(!m_pEditParent)
 576                 {
 577                         ShowWindow(false);
 578                         return -1;
 579                 }
 580
 581                 if(nStartAfter > m_SearchList.GetSize())
 582                 {
 583                         ShowWindow(false);
 584                         return -1;
 585                 }
 586
 587                 if(m_Str2.IsEmpty())
 588                 {
 589                         ShowWindow(false);
 590                         return -1;
 591                 }
 592
 593                 m_DisplayList.RemoveAll();
 594
 595                 m_Str2.MakeUpper();
 596
 597                 for(int i = nStartAfter+1; i < m_SearchList.GetSize(); i++)
 598                 {
 599                         if(m_PrefixChar)
 600                                 m_Str1 = m_PrefixChar;
 601                         else
 602                                 m_Str1.Empty();
 603
 604                         m_Str1 += m_SearchList.GetAt(i);
 605
 606                         m_Str1.MakeUpper();
 607
 608                         if(m_lMode & _MODE_FIND_ALL_)
 609                         {
 610                                 if(m_Str1.Find(m_Str2) >= 0)
 611                                 {
 612                                         m_DisplayList.Add(m_SearchList.GetAt(i));
 613                                 }
 614                         }
 615                         else  // _MODE_FIND_EXACT_
 616                         {
 617                                 if (CStringUtils::StartsWith(m_Str1, m_Str2))
 618                                 {
 619                                         m_DisplayList.Add(m_SearchList.GetAt(i));
 620                                 }
 621                         }
 622                 }
 623         }
 624         m_lCount = (long)m_DisplayList.GetSize();
 625
 626         if(m_lCount)
 627         {
 628                 CRect rcWnd;
 629                 int iHeight,iWight;
 630
 631                 m_pEditParent->GetWindowRect(rcWnd);
 632
 633                 SetScroller();
 634                 SetProp();
 635
 636                 ShowWindow(true);
 637                 Invalidate();
 638
 639                 iHeight = m_lCount*m_ItemHeight+(GetSystemMetrics(SM_CYBORDER)*2);
 640
 641                 if(m_lCount > _MAX_ENTRYS_)
 642                         iHeight = _MAX_ENTRYS_*m_ItemHeight+(GetSystemMetrics(SM_CYBORDER)*2);
 643
 644                 if(!m_LastSize.IsRectEmpty())
 645                 {
 646                         iWight = m_LastSize.Width();
 647                         iHeight = m_LastSize.Height();
 648                         rcWnd.top += rcWnd.Height();
 649                         rcWnd.right = rcWnd.left+iWight;
 650                         rcWnd.bottom = rcWnd.top+iHeight;
 651
 652                         SetWindowPos(&CWnd::wndTopMost, rcWnd.left,
 653                                 rcWnd.top,
 654                                 rcWnd.Width(),
 655                                 rcWnd.Height(), 0);
 656                 }
 657                 else
 658                 {
 659                         SetWindowPos(&CWnd::wndTopMost, rcWnd.left,
 660                                 rcWnd.top + rcWnd.Height(),
 661                                 rcWnd.Width(),
 662                                 iHeight, 0);
 663                 }
 664
 665                 if(m_AktCount != m_DisplayList.GetSize())
 666                         m_lSelItem = -1;
 667
 668                 SortList(m_DisplayList);
 669         }
 670         else
 671         {
 672                 ShowWindow(false);
 673         }
 674
 675         return 1;
 676 }
 677
 678 /*********************************************************************/
 679
 680 int CACListWnd::SelectString(LPCTSTR lpszString )
 681 {
 682         int item = FindString(-1, lpszString);
 683         SelectItem(item);
 684         return item;
 685 }
 686
 687 /*********************************************************************/
 688
 689 bool CACListWnd::GetText(int item, CString& m_Text)
 690 {
 691         if(item < 0 || item > m_SearchList.GetSize())
 692                 return false;
 693         m_Text = m_SearchList.GetAt(item);
 694         return true;
 695 }
 696
 697 /*********************************************************************/
 698
 699 void CACListWnd::OnShowWindow(BOOL bShow, UINT nStatus)
 700 {
 701         if(bShow)
 702         {
 703                 m_nIDTimer = (long)SetTimer(IDTimerInstall, 200, nullptr);
 704                 m_pEditParent->GetParent()->GetWindowRect(m_ParentRect);
 705         }
 706         else
 707         {
 708                 if(m_nIDTimer)
 709                         KillTimer(IDTimerInstall);
 710                 m_nIDTimer = 0;
 711                 m_lSelItem = -1;
 712                 m_lTopIndex = 0;
 713         }
 714
 715         CWnd::OnShowWindow(bShow, nStatus);
 716         ::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
 717 }
 718
 719 /*********************************************************************/
 720
 721 void CACListWnd::OnNcLButtonDown(UINT nHitTest, CPoint point)
 722 {
 723         if(OnNcHitTest(point) == HTBOTTOMRIGHT)
 724                 GetWindowRect(m_LastSize);
 725         CWnd::OnNcLButtonDown(nHitTest, point);
 726 }
 727
 728 /*********************************************************************/
 729
 730 CString CACListWnd::GetString()
 731 {
 732         int i = (int)m_DisplayList.GetSize();
 733
 734         if(!i)
 735                 return L"";
 736         if(i <= m_lSelItem || m_lSelItem == -1)
 737                 i = 0;
 738         else
 739                 i = m_lSelItem;
 740
 741         return m_DisplayList.GetAt(i);
 742 }
 743
 744 /*********************************************************************/
 745
 746 void CACListWnd::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
 747 {
 748         CWnd::OnVScroll(nSBCode, nPos, pScrollBar);
 749         long m_oldlTopIndex = m_lTopIndex;
 750
 751         switch(nSBCode)
 752         {
 753         case SB_ENDSCROLL:
 754                 break;
 755
 756         case SB_PAGEUP:
 757                 m_lTopIndex -= m_VisibleItems;
 758                 if(m_lTopIndex < 0)
 759                         m_lTopIndex = 0;
 760                 break;
 761
 762         case SB_PAGEDOWN:
 763                 m_lTopIndex += m_VisibleItems;
 764                 if(m_lTopIndex >= m_lCount-m_VisibleItems)
 765                         m_lTopIndex = m_lCount-m_VisibleItems;
 766                 break;
 767
 768         case SB_LINEUP:
 769                 m_lTopIndex--;
 770                 if(m_lTopIndex < 0)
 771                         m_lTopIndex = 0;
 772                 break;
 773
 774         case SB_LINEDOWN:
 775                 m_lTopIndex++;
 776                 if(m_lTopIndex >= m_lCount-m_VisibleItems)
 777                         m_lTopIndex = m_lCount-m_VisibleItems;
 778                 break;
 779
 780         case SB_THUMBTRACK:
 781                 m_lTopIndex = nPos;
 782                 break;
 783         }
 784
 785         m_VertBar.SetScrollPos(m_lTopIndex,true);
 786
 787         if(m_oldlTopIndex != m_lTopIndex)
 788                 Invalidate();
 789 }
 790
 791 /*********************************************************************/
 792
 793 CString CACListWnd::GetNextString(int nChar)
 794 {
 795         switch(nChar)
 796         {
 797         case VK_DOWN:
 798                 m_lSelItem++;
 799                 break;
 800
 801         case VK_UP:
 802                 m_lSelItem--;
 803                 break;
 804
 805         case VK_PRIOR:
 806                 m_lSelItem -= m_VisibleItems;
 807                 if(m_lSelItem < 0)
 808                         m_lSelItem = 0;
 809                 break;
 810
 811         case VK_NEXT:
 812                 m_lSelItem += m_VisibleItems;
 813                 if(m_lSelItem >= m_lCount-1)
 814                         m_lSelItem = m_lCount-1;
 815                 break;
 816
 817         case VK_HOME:
 818                 m_lSelItem = 0;
 819                 break;
 820
 821         case VK_END:
 822                 m_lSelItem = m_lCount-1;
 823                 break;
 824         }
 825
 826         if(m_lSelItem < 0)
 827                 m_lSelItem = m_lCount-1;
 828
 829         if(m_lSelItem >= m_lCount)
 830                 m_lSelItem = 0;
 831
 832         if(EnsureVisible(m_lSelItem,(m_lCount > 50) ? false : true))
 833                 InvalidateAndScroll();
 834
 835         return GetString();
 836 }
 837
 838 /*********************************************************************/
 839
 840 void CACListWnd::OnMouseMove(UINT nFlags, CPoint point)
 841 {
 842         CWnd::OnMouseMove(nFlags, point);
 843         int sel = HitTest(point);
 844         if(sel >= 0)
 845         {
 846                 Invalidate();
 847         }
 848 }
 849
 850 /*********************************************************************/
 851
 852 void CACListWnd::OnTimer(UINT_PTR nIDEvent)
 853 {
 854         CWnd::OnTimer(nIDEvent);
 855
 856         CRect m_ParentRect1;
 857         m_pEditParent->GetParent()->GetWindowRect(m_ParentRect1);
 858         if(!m_ParentRect1.EqualRect(m_ParentRect))
 859                 ShowWindow(false);
 860 }
 861
 862 /*********************************************************************/
 863
 864 void CACListWnd::OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI)
 865 {
 866         if(GetSafeHwnd())
 867         {
 868                 // Vers. 1.2
 869                 long m_lMinY1 = GetSystemMetrics(SM_CYHSCROLL)*2 + GetSystemMetrics(SM_CYSIZEFRAME) + GetSystemMetrics(SM_CXHTHUMB),
 870                         m_lMinY2 = m_lCount * m_ItemHeight + (GetSystemMetrics(SM_CYBORDER)*2);
 871
 872                 if(m_VisibleItems > m_lCount-1 &&  m_lMinY2 < m_lMinY1)
 873                         lpMMI->ptMinTrackSize.y = m_lMinY2;
 874                 else
 875                         lpMMI->ptMinTrackSize.y = m_lMinY1;
 876                 //---------
 877
 878                 lpMMI->ptMinTrackSize.x = GetSystemMetrics(SM_CXHSCROLL)*4;
 879
 880
 881                 // Vers. 1.2
 882                 if (m_pEditParent)
 883                 {
 884                         RECT rc;
 885                         m_pEditParent->GetWindowRect (&rc);
 886                         lpMMI->ptMinTrackSize.x = rc.right - rc.left;
 887                 }
 888         }
 889         else
 890                 CWnd::OnGetMinMaxInfo(lpMMI);
 891 }
 892
 893 /*********************************************************************/
 894
 895 int CACListWnd::CompareString(const void* p1, const void* p2)
 896 {
 897         return _stricmp( * ( char** ) p1, * ( char** ) p2 );
 898 }
 899
 900 /*********************************************************************/
 901
 902 void CACListWnd::SortList(CStringArray& list)
 903 {
 904         int m_Count = (int)list.GetSize();
 905         int i;
 906
 907         if (m_Count > 1)
 908         {
 909                 CStringArray m_Liste1;
 910                 m_Liste1.Copy(list);
 911
 912                 LPCTSTR* ppSortArray = new LPCTSTR[m_Count+1];
 913
 914
 915                 for(i=0; i < m_Count; i++)
 916                 {
 917                         ppSortArray[i] = (LPCTSTR)m_Liste1.GetAt(i);
 918                 }
 919
 920                 list.RemoveAll();
 921
 922                 qsort(ppSortArray, m_Count, sizeof(LPCTSTR), CompareString);
 923
 924                 for(i=0; i < m_Count; i++)
 925                 {
 926                         list.Add((LPCTSTR) ppSortArray[i]);
 927                 }
 928                 m_Liste1.RemoveAll();
 929                 delete [] ppSortArray;
 930         }
 931 }
 932
 933 /*********************************************************************/
 934 /*
 935 ** Vers. 1.1
 936 ** NEW: CopyList()
 937 */
 938 void CACListWnd::CopyList()
 939 {
 940         m_DisplayList.Copy(m_SearchList);
 941         m_lCount = (long)m_DisplayList.GetSize();
 942         if(m_lCount)
 943                 FindString(0, L"", true);
 944 }
 945
 946 /*********************************************************************/
 947