src/Utils/ACListWnd.cpp

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