src/generic/listctrl.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        listctrl.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 1998 Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 #ifdef __GNUG__
  11 #pragma implementation "listctrl.h"
  12 #endif
  13
  14 // For compilers that support precompilation, includes "wx.h".
  15 #include "wx/wxprec.h"
  16
  17 #ifdef __BORLANDC__
  18 #pragma hdrstop
  19 #endif
  20
  21 #include "wx/dcscreen.h"
  22 #include "wx/app.h"
  23 #include "wx/listctrl.h"
  24 #include "wx/generic/imaglist.h"
  25
  26 #ifndef wxUSE_GENERIC_LIST_EXTENSIONS
  27 #define wxUSE_GENERIC_LIST_EXTENSIONS 0
  28 #endif
  29
  30 //-----------------------------------------------------------------------------
  31 //  wxListItemData
  32 //-----------------------------------------------------------------------------
  33
  34 IMPLEMENT_DYNAMIC_CLASS(wxListItemData,wxObject);
  35
  36 wxListItemData::wxListItemData()
  37 {
  38     m_image = -1;
  39     m_data = 0;
  40     m_xpos = 0;
  41     m_ypos = 0;
  42     m_width = 0;
  43     m_height = 0;
  44     m_attr = NULL;
  45 }
  46
  47 wxListItemData::wxListItemData( const wxListItem &info )
  48 {
  49     m_image = -1;
  50     m_data = 0;
  51     m_attr = NULL;
  52
  53     SetItem( info );
  54 }
  55
  56 void wxListItemData::SetItem( const wxListItem &info )
  57 {
  58     if (info.m_mask & wxLIST_MASK_TEXT) m_text = info.m_text;
  59     if (info.m_mask & wxLIST_MASK_IMAGE) m_image = info.m_image;
  60     if (info.m_mask & wxLIST_MASK_DATA) m_data = info.m_data;
  61
  62     if ( info.HasAttributes() )
  63     {
  64         if ( m_attr )
  65             *m_attr = *info.GetAttributes();
  66         else
  67             m_attr = new wxListItemAttr(*info.GetAttributes());
  68     }
  69
  70     m_xpos = 0;
  71     m_ypos = 0;
  72     m_width = info.m_width;
  73     m_height = 0;
  74 }
  75
  76 void wxListItemData::SetText( const wxString &s )
  77 {
  78     m_text = s;
  79 }
  80
  81 void wxListItemData::SetImage( int image )
  82 {
  83     m_image = image;
  84 }
  85
  86 void wxListItemData::SetData( long data )
  87 {
  88     m_data = data;
  89 }
  90
  91 void wxListItemData::SetPosition( int x, int y )
  92 {
  93     m_xpos = x;
  94     m_ypos = y;
  95 }
  96
  97 void wxListItemData::SetSize( int width, int height )
  98 {
  99     if (width != -1) m_width = width;
 100     if (height != -1) m_height = height;
 101 }
 102
 103 bool wxListItemData::HasImage() const
 104 {
 105     return (m_image >= 0);
 106 }
 107
 108 bool wxListItemData::HasText() const
 109 {
 110     return (!m_text.IsNull());
 111 }
 112
 113 bool wxListItemData::IsHit( int x, int y ) const
 114 {
 115     return ((x >= m_xpos) && (x <= m_xpos+m_width) && (y >= m_ypos) && (y <= m_ypos+m_height));
 116 }
 117
 118 void wxListItemData::GetText( wxString &s )
 119 {
 120     s = m_text;
 121 }
 122
 123 int wxListItemData::GetX() const
 124 {
 125     return m_xpos;
 126 }
 127
 128 int wxListItemData::GetY() const
 129 {
 130     return m_ypos;
 131 }
 132
 133 int wxListItemData::GetWidth() const
 134 {
 135     return m_width;
 136 }
 137
 138 int wxListItemData::GetHeight() const
 139 {
 140     return m_height;
 141 }
 142
 143 int wxListItemData::GetImage() const
 144 {
 145     return m_image;
 146 }
 147
 148 void wxListItemData::GetItem( wxListItem &info ) const
 149 {
 150     info.m_text = m_text;
 151     info.m_image = m_image;
 152     info.m_data = m_data;
 153
 154     if ( m_attr )
 155     {
 156         if ( m_attr->HasTextColour() )
 157             info.SetTextColour(m_attr->GetTextColour());
 158         if ( m_attr->HasBackgroundColour() )
 159             info.SetBackgroundColour(m_attr->GetBackgroundColour());
 160         if ( m_attr->HasFont() )
 161             info.SetFont(m_attr->GetFont());
 162     }
 163 }
 164
 165 //-----------------------------------------------------------------------------
 166 //  wxListHeaderData
 167 //-----------------------------------------------------------------------------
 168
 169 IMPLEMENT_DYNAMIC_CLASS(wxListHeaderData,wxObject);
 170
 171 wxListHeaderData::wxListHeaderData()
 172 {
 173     m_mask = 0;
 174     m_image = 0;
 175     m_format = 0;
 176     m_width = 0;
 177     m_xpos = 0;
 178     m_ypos = 0;
 179     m_height = 0;
 180 }
 181
 182 wxListHeaderData::wxListHeaderData( const wxListItem &item )
 183 {
 184     SetItem( item );
 185     m_xpos = 0;
 186     m_ypos = 0;
 187     m_height = 0;
 188 }
 189
 190 void wxListHeaderData::SetItem( const wxListItem &item )
 191 {
 192     m_mask = item.m_mask;
 193     m_text = item.m_text;
 194     m_image = item.m_image;
 195     m_format = item.m_format;
 196     m_width = item.m_width;
 197     if (m_width < 0) m_width = 80;
 198     if (m_width < 6) m_width = 6;
 199 }
 200
 201 void wxListHeaderData::SetPosition( int x, int y )
 202 {
 203     m_xpos = x;
 204     m_ypos = y;
 205 }
 206
 207 void wxListHeaderData::SetHeight( int h )
 208 {
 209     m_height = h;
 210 }
 211
 212 void wxListHeaderData::SetWidth( int w )
 213 {
 214     m_width = w;
 215     if (m_width < 0) m_width = 80;
 216     if (m_width < 6) m_width = 6;
 217 }
 218
 219 void wxListHeaderData::SetFormat( int format )
 220 {
 221     m_format = format;
 222 }
 223
 224 bool wxListHeaderData::HasImage() const
 225 {
 226     return (m_image != 0);
 227 }
 228
 229 bool wxListHeaderData::HasText() const
 230 {
 231     return (m_text.Length() > 0);
 232 }
 233
 234 bool wxListHeaderData::IsHit( int x, int y ) const
 235 {
 236     return ((x >= m_xpos) && (x <= m_xpos+m_width) && (y >= m_ypos) && (y <= m_ypos+m_height));
 237 }
 238
 239 void wxListHeaderData::GetItem( wxListItem &item )
 240 {
 241     item.m_mask = m_mask;
 242     item.m_text = m_text;
 243     item.m_image = m_image;
 244     item.m_format = m_format;
 245     item.m_width = m_width;
 246 }
 247
 248 void wxListHeaderData::GetText( wxString &s )
 249 {
 250     s =  m_text;
 251 }
 252
 253 int wxListHeaderData::GetImage() const
 254 {
 255     return m_image;
 256 }
 257
 258 int wxListHeaderData::GetWidth() const
 259 {
 260     return m_width;
 261 }
 262
 263 int wxListHeaderData::GetFormat() const
 264 {
 265     return m_format;
 266 }
 267
 268 //-----------------------------------------------------------------------------
 269 //  wxListLineData
 270 //-----------------------------------------------------------------------------
 271
 272 IMPLEMENT_DYNAMIC_CLASS(wxListLineData,wxObject);
 273
 274 wxListLineData::wxListLineData( wxListMainWindow *owner, int mode, wxBrush *hilightBrush )
 275 {
 276     m_mode = mode;
 277     m_hilighted = FALSE;
 278     m_owner = owner;
 279     m_hilightBrush = hilightBrush;
 280     m_items.DeleteContents( TRUE );
 281     m_spacing = 0;
 282 }
 283
 284 void wxListLineData::CalculateSize( wxDC *dc, int spacing )
 285 {
 286     m_spacing = spacing;
 287     switch (m_mode)
 288     {
 289         case wxLC_ICON:
 290         {
 291             m_bound_all.width = m_spacing;
 292             m_bound_all.height = m_spacing+13;
 293             wxNode *node = m_items.First();
 294             if (node)
 295             {
 296                 wxListItemData *item = (wxListItemData*)node->Data();
 297                 wxString s = item->GetText();
 298                 wxCoord lw,lh;
 299                 dc->GetTextExtent( s, &lw, &lh );
 300                 if (lw > m_spacing) m_bound_all.width = lw;
 301             }
 302             break;
 303         }
 304         case wxLC_LIST:
 305         {
 306             wxNode *node = m_items.First();
 307             if (node)
 308             {
 309                 wxListItemData *item = (wxListItemData*)node->Data();
 310                 wxString s = item->GetText();
 311                 wxCoord lw,lh;
 312                 dc->GetTextExtent( s, &lw, &lh );
 313                 m_bound_all.width = lw;
 314                 m_bound_all.height = lh;
 315                 if (item->HasImage())
 316                 {
 317 #ifdef __WIN16__
 318                     int w = 0;
 319                     int h = 0;
 320 #else
 321                     wxCoord w = 0;
 322                     wxCoord h = 0;
 323 #endif
 324                     m_owner->GetImageSize( item->GetImage(), w, h );
 325                     m_bound_all.width += 4 + w;
 326                     if (h > m_bound_all.height) m_bound_all.height = h;
 327                 }
 328             }
 329             break;
 330         }
 331         case wxLC_REPORT:
 332         {
 333             m_bound_all.width = 0;
 334             m_bound_all.height = 0;
 335             wxNode *node = m_items.First();
 336             while (node)
 337             {
 338                 wxListItemData *item = (wxListItemData*)node->Data();
 339                 wxString s;
 340                 item->GetText( s );
 341                 if (s.IsNull()) s = "H";
 342                 wxCoord lw,lh;
 343                 dc->GetTextExtent( s, &lw, &lh );
 344                 item->SetSize( item->GetWidth(), lh );
 345                 m_bound_all.width += lw;
 346                 m_bound_all.height = lh;
 347                 node = node->Next();
 348             }
 349             break;
 350         }
 351     }
 352 }
 353
 354 void wxListLineData::SetPosition( wxDC *dc, int x, int y, int window_width )
 355 {
 356     m_bound_all.x = x;
 357     m_bound_all.y = y;
 358     switch (m_mode)
 359     {
 360         case wxLC_ICON:
 361         {
 362             AssignRect( m_bound_icon, 0, 0, 0, 0 );
 363             AssignRect( m_bound_label, 0, 0, 0, 0 );
 364             AssignRect( m_bound_hilight, m_bound_all );
 365             wxNode *node = m_items.First();
 366             if (node)
 367             {
 368                 wxListItemData *item = (wxListItemData*)node->Data();
 369                 if (item->HasImage())
 370                 {
 371                     wxListItemData *item = (wxListItemData*)node->Data();
 372                     int w = 0;
 373                     int h = 0;
 374                     m_owner->GetImageSize( item->GetImage(), w, h );
 375                     m_bound_icon.x = m_bound_all.x + (m_spacing/2) - (w/2);
 376                     m_bound_icon.y = m_bound_all.y + m_spacing - h - 5;
 377                     m_bound_icon.width = w;
 378                     m_bound_icon.height = h;
 379                     if (!item->HasText())
 380                     {
 381                         AssignRect( m_bound_hilight, m_bound_icon );
 382                         m_bound_hilight.x -= 5;
 383                         m_bound_hilight.y -= 5;
 384                         m_bound_hilight.width += 9;
 385                         m_bound_hilight.height += 9;
 386                     }
 387                 }
 388                 if (item->HasText())
 389                 {
 390                     wxString s;
 391                     item->GetText( s );
 392                     wxCoord lw,lh;
 393                     dc->GetTextExtent( s, &lw, &lh );
 394                     if (m_bound_all.width > m_spacing)
 395                         m_bound_label.x = m_bound_all.x;
 396                     else
 397                         m_bound_label.x = m_bound_all.x +  (m_spacing/2) - lw/2;
 398                     m_bound_label.y = m_bound_all.y + m_bound_all.height - lh;
 399                     m_bound_label.width = lw;
 400                     m_bound_label.height = lh;
 401                     AssignRect( m_bound_hilight, m_bound_label );
 402                     m_bound_hilight.x -= 2;
 403                     m_bound_hilight.y -= 2;
 404                     m_bound_hilight.width += 4;
 405                     m_bound_hilight.height += 4;
 406                 }
 407             }
 408             break;
 409         }
 410         case wxLC_LIST:
 411         {
 412             AssignRect( m_bound_label, m_bound_all );
 413             m_bound_all.x -= 2;
 414             m_bound_all.y -= 2;
 415             m_bound_all.width += 4;
 416             m_bound_all.height += 3;
 417             AssignRect( m_bound_hilight, m_bound_all );
 418             AssignRect( m_bound_icon, 0, 0, 0, 0 );
 419             wxNode *node = m_items.First();
 420             if (node)
 421             {
 422                 wxListItemData *item = (wxListItemData*)node->Data();
 423                 if (item->HasImage())
 424                 {
 425                     m_bound_icon.x = m_bound_all.x + 2;
 426                     m_bound_icon.y = m_bound_all.y + 2;
 427                     int w;
 428                     int h;
 429                     m_owner->GetImageSize( item->GetImage(), w, h );
 430                     m_bound_icon.width = w;
 431                     m_bound_icon.height = h;
 432                     m_bound_label.x += 4 + w;
 433                     m_bound_label.width -= 4 + w;
 434                 }
 435             }
 436             break;
 437         }
 438         case wxLC_REPORT:
 439         {
 440             wxCoord lw,lh;
 441             dc->GetTextExtent( "H", &lw, &lh );
 442             m_bound_all.x = 0;
 443             m_bound_all.y -= 0;
 444             m_bound_all.height = lh+3;
 445             m_bound_all.width = window_width;
 446             AssignRect( m_bound_hilight, m_bound_all );
 447             AssignRect( m_bound_label, m_bound_all );
 448             AssignRect( m_bound_icon, 0, 0, 0, 0 );
 449             wxNode *node = m_items.First();
 450             if (node)
 451             {
 452                 wxListItemData *item = (wxListItemData*)node->Data();
 453                 wxString s;
 454                 item->GetText( s );
 455                 if (s.IsEmpty()) s = wxT("H");
 456                 wxCoord lw,lh;
 457                 dc->GetTextExtent( s, &lw, &lh );
 458                 m_bound_label.width = lw;
 459                 m_bound_label.height = lh;
 460                 if (item->HasImage())
 461                 {
 462                     m_bound_icon.x = m_bound_all.x + 2;
 463                     m_bound_icon.y = m_bound_all.y + 2;
 464                     int w;
 465                     int h;
 466                     m_owner->GetImageSize( item->GetImage(), w, h );
 467                     m_bound_icon.width = w;
 468                     m_bound_icon.height = h;
 469                     m_bound_label.x += 4 + w;
 470                 }
 471             }
 472             break;
 473         }
 474     }
 475 }
 476
 477 void wxListLineData::SetColumnPosition( int index, int x )
 478 {
 479     wxNode *node = m_items.Nth( (size_t)index );
 480     if (node)
 481     {
 482         wxListItemData *item = (wxListItemData*)node->Data();
 483         item->SetPosition( x, m_bound_all.y+1 );
 484     }
 485 }
 486
 487 void wxListLineData::GetSize( int &width, int &height )
 488 {
 489     width = m_bound_all.width;
 490     height = m_bound_all.height;
 491 }
 492
 493 void wxListLineData::GetExtent( int &x, int &y, int &width, int &height )
 494 {
 495     x = m_bound_all.x;
 496     y = m_bound_all.y;
 497     width = m_bound_all.width;
 498     height = m_bound_all.height;
 499 }
 500
 501 void wxListLineData::GetLabelExtent( int &x, int &y, int &width, int &height )
 502 {
 503     x = m_bound_label.x;
 504     y = m_bound_label.y;
 505     width = m_bound_label.width;
 506     height = m_bound_label.height;
 507 }
 508
 509 void wxListLineData::GetRect( wxRect &rect )
 510 {
 511     AssignRect( rect, m_bound_all );
 512 }
 513
 514 long wxListLineData::IsHit( int x, int y )
 515 {
 516     wxNode *node = m_items.First();
 517     if (node)
 518     {
 519         wxListItemData *item = (wxListItemData*)node->Data();
 520         if (item->HasImage() && IsInRect( x, y, m_bound_icon )) return wxLIST_HITTEST_ONITEMICON;
 521         if (item->HasText() && IsInRect( x, y, m_bound_label )) return wxLIST_HITTEST_ONITEMLABEL;
 522 //      if (!(item->HasImage() || item->HasText())) return 0;
 523     }
 524     // if there is no icon or text = empty
 525     if (IsInRect( x, y, m_bound_all )) return wxLIST_HITTEST_ONITEMICON;
 526     return 0;
 527 }
 528
 529 void wxListLineData::InitItems( int num )
 530 {
 531     for (int i = 0; i < num; i++) m_items.Append( new wxListItemData() );
 532 }
 533
 534 void wxListLineData::SetItem( int index, const wxListItem &info )
 535 {
 536     wxNode *node = m_items.Nth( index );
 537     if (node)
 538     {
 539        wxListItemData *item = (wxListItemData*)node->Data();
 540        item->SetItem( info );
 541     }
 542 }
 543
 544 void wxListLineData::GetItem( int index, wxListItem &info )
 545 {
 546     int i = index;
 547     wxNode *node = m_items.Nth( i );
 548     if (node)
 549     {
 550         wxListItemData *item = (wxListItemData*)node->Data();
 551         item->GetItem( info );
 552     }
 553 }
 554
 555 void wxListLineData::GetText( int index, wxString &s )
 556 {
 557     int i = index;
 558     wxNode *node = m_items.Nth( i );
 559     s = "";
 560     if (node)
 561     {
 562         wxListItemData *item = (wxListItemData*)node->Data();
 563         item->GetText( s );
 564     }
 565 }
 566
 567 void wxListLineData::SetText( int index, const wxString s )
 568 {
 569     int i = index;
 570     wxNode *node = m_items.Nth( i );
 571     if (node)
 572     {
 573         wxListItemData *item = (wxListItemData*)node->Data();
 574         item->SetText( s );
 575     }
 576 }
 577
 578 int wxListLineData::GetImage( int index )
 579 {
 580     int i = index;
 581     wxNode *node = m_items.Nth( i );
 582     if (node)
 583     {
 584         wxListItemData *item = (wxListItemData*)node->Data();
 585         return item->GetImage();
 586     }
 587     return -1;
 588 }
 589
 590 void wxListLineData::SetAttributes(wxDC *dc,
 591                                    const wxListItemAttr *attr,
 592                                    const wxColour& colText,
 593                                    const wxFont& font,
 594                                    bool hilight)
 595 {
 596     // don't use foregroud colour for drawing highlighted items - this might
 597     // make them completely invisible (and there is no way to do bit
 598     // arithmetics on wxColour, unfortunately)
 599     if ( !hilight && attr && attr->HasTextColour() )
 600     {
 601         dc->SetTextForeground(attr->GetTextColour());
 602     }
 603     else
 604     {
 605         dc->SetTextForeground(colText);
 606     }
 607
 608     if ( attr && attr->HasFont() )
 609     {
 610         dc->SetFont(attr->GetFont());
 611     }
 612     else
 613     {
 614         dc->SetFont(font);
 615     }
 616 }
 617
 618 void wxListLineData::DoDraw( wxDC *dc, bool hilight, bool paintBG )
 619 {
 620     wxCoord dev_x = dc->LogicalToDeviceX( m_bound_all.x-2 );
 621     wxCoord dev_y = dc->LogicalToDeviceY( m_bound_all.y-2 );
 622     wxCoord dev_w = dc->LogicalToDeviceXRel( m_bound_all.width+4 );
 623     wxCoord dev_h = dc->LogicalToDeviceYRel( m_bound_all.height+4 );
 624
 625     if (!m_owner->IsExposed( dev_x, dev_y, dev_w, dev_h ))
 626     {
 627         return;
 628     }
 629
 630     wxWindow *listctrl = m_owner->GetParent();
 631
 632     // default foreground colour
 633     wxColour colText;
 634     if ( hilight )
 635     {
 636         colText = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_HIGHLIGHTTEXT );
 637     }
 638     else
 639     {
 640         colText = listctrl->GetForegroundColour();
 641     }
 642
 643     // default font
 644     wxFont font = listctrl->GetFont();
 645
 646     // VZ: currently we set the colours/fonts only once, but like this (i.e.
 647     //     using SetAttributes() inside the loop), it will be trivial to
 648     //     customize the subitems (in report mode) too.
 649     wxListItemData *item = (wxListItemData*)m_items.First()->Data();
 650     wxListItemAttr *attr = item->GetAttributes();
 651     SetAttributes(dc, attr, colText, font, hilight);
 652
 653     bool hasBgCol = attr && attr->HasBackgroundColour();
 654     if ( paintBG || hasBgCol )
 655     {
 656         if (hilight)
 657         {
 658             dc->SetBrush( * m_hilightBrush );
 659         }
 660         else
 661         {
 662             if ( hasBgCol )
 663                 dc->SetBrush(wxBrush(attr->GetBackgroundColour(), wxSOLID));
 664             else
 665                 dc->SetBrush( * wxWHITE_BRUSH );
 666         }
 667
 668         dc->SetPen( * wxTRANSPARENT_PEN );
 669         dc->DrawRectangle( m_bound_hilight.x, m_bound_hilight.y,
 670                            m_bound_hilight.width, m_bound_hilight.height );
 671     }
 672
 673     if (m_mode == wxLC_REPORT)
 674     {
 675         wxNode *node = m_items.First();
 676         while (node)
 677         {
 678             wxListItemData *item = (wxListItemData*)node->Data();
 679             dc->SetClippingRegion( item->GetX(), item->GetY(), item->GetWidth()-3, item->GetHeight() );
 680             int x = item->GetX();
 681             if (item->HasImage())
 682             {
 683                 int y = 0;
 684                 m_owner->DrawImage( item->GetImage(), dc, x, item->GetY() );
 685                 m_owner->GetImageSize( item->GetImage(), x, y );
 686                 x += item->GetX() + 5;
 687             }
 688             if (item->HasText())
 689             {
 690                 dc->DrawText( item->GetText(), x, item->GetY() );
 691             }
 692             dc->DestroyClippingRegion();
 693             node = node->Next();
 694         }
 695     }
 696     else
 697     {
 698         wxNode *node = m_items.First();
 699         if (node)
 700         {
 701             wxListItemData *item = (wxListItemData*)node->Data();
 702             if (item->HasImage())
 703             {
 704                 m_owner->DrawImage( item->GetImage(), dc, m_bound_icon.x, m_bound_icon.y );
 705             }
 706             if (item->HasText())
 707             {
 708                 dc->DrawText( item->GetText(), m_bound_label.x, m_bound_label.y );
 709             }
 710         }
 711     }
 712 }
 713
 714 void wxListLineData::Hilight( bool on )
 715 {
 716     if (on == m_hilighted) return;
 717     m_hilighted = on;
 718     if (on)
 719         m_owner->SelectLine( this );
 720     else
 721         m_owner->DeselectLine( this );
 722 }
 723
 724 void wxListLineData::ReverseHilight( void )
 725 {
 726     m_hilighted = !m_hilighted;
 727     if (m_hilighted)
 728         m_owner->SelectLine( this );
 729     else
 730         m_owner->DeselectLine( this );
 731 }
 732
 733 void wxListLineData::DrawRubberBand( wxDC *dc, bool on )
 734 {
 735     if (on)
 736     {
 737         dc->SetPen( * wxBLACK_PEN );
 738         dc->SetBrush( * wxTRANSPARENT_BRUSH );
 739         dc->DrawRectangle( m_bound_hilight.x, m_bound_hilight.y,
 740                            m_bound_hilight.width, m_bound_hilight.height );
 741     }
 742 }
 743
 744 void wxListLineData::Draw( wxDC *dc )
 745 {
 746     DoDraw( dc, m_hilighted, m_hilighted );
 747 }
 748
 749 bool wxListLineData::IsInRect( int x, int y, const wxRect &rect )
 750 {
 751     return ((x >= rect.x) && (x <= rect.x+rect.width) &&
 752             (y >= rect.y) && (y <= rect.y+rect.height));
 753 }
 754
 755 bool wxListLineData::IsHilighted( void )
 756 {
 757     return m_hilighted;
 758 }
 759
 760 void wxListLineData::AssignRect( wxRect &dest, int x, int y, int width, int height )
 761 {
 762     dest.x = x;
 763     dest.y = y;
 764     dest.width = width;
 765     dest.height = height;
 766 }
 767
 768 void wxListLineData::AssignRect( wxRect &dest, const wxRect &source )
 769 {
 770     dest.x = source.x;
 771     dest.y = source.y;
 772     dest.width = source.width;
 773     dest.height = source.height;
 774 }
 775
 776 //-----------------------------------------------------------------------------
 777 //  wxListHeaderWindow
 778 //-----------------------------------------------------------------------------
 779
 780 IMPLEMENT_DYNAMIC_CLASS(wxListHeaderWindow,wxWindow);
 781
 782 BEGIN_EVENT_TABLE(wxListHeaderWindow,wxWindow)
 783     EVT_PAINT         (wxListHeaderWindow::OnPaint)
 784     EVT_MOUSE_EVENTS  (wxListHeaderWindow::OnMouse)
 785     EVT_SET_FOCUS     (wxListHeaderWindow::OnSetFocus)
 786 END_EVENT_TABLE()
 787
 788 wxListHeaderWindow::wxListHeaderWindow( void )
 789 {
 790     m_owner = (wxListMainWindow *) NULL;
 791     m_currentCursor = (wxCursor *) NULL;
 792     m_resizeCursor = (wxCursor *) NULL;
 793     m_isDragging = FALSE;
 794 }
 795
 796 wxListHeaderWindow::wxListHeaderWindow( wxWindow *win, wxWindowID id, wxListMainWindow *owner,
 797       const wxPoint &pos, const wxSize &size,
 798       long style, const wxString &name ) :
 799   wxWindow( win, id, pos, size, style, name )
 800 {
 801     m_owner = owner;
 802 //  m_currentCursor = wxSTANDARD_CURSOR;
 803     m_currentCursor = (wxCursor *) NULL;
 804     m_resizeCursor = new wxCursor( wxCURSOR_SIZEWE );
 805     m_isDragging = FALSE;
 806     SetBackgroundColour( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE ) );
 807 }
 808
 809 wxListHeaderWindow::~wxListHeaderWindow( void )
 810 {
 811     delete m_resizeCursor;
 812 }
 813
 814 void wxListHeaderWindow::DoDrawRect( wxDC *dc, int x, int y, int w, int h )
 815 {
 816     const int m_corner = 1;
 817
 818     dc->SetBrush( *wxTRANSPARENT_BRUSH );
 819
 820     dc->SetPen( *wxBLACK_PEN );
 821     dc->DrawLine( x+w-m_corner+1, y, x+w, y+h );  // right (outer)
 822     dc->DrawRectangle( x, y+h, w+1, 1 );          // bottom (outer)
 823
 824     wxPen pen( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNSHADOW ), 1, wxSOLID );
 825
 826     dc->SetPen( pen );
 827     dc->DrawLine( x+w-m_corner, y, x+w-1, y+h );  // right (inner)
 828     dc->DrawRectangle( x+1, y+h-1, w-2, 1 );      // bottom (inner)
 829
 830     dc->SetPen( *wxWHITE_PEN );
 831     dc->DrawRectangle( x, y, w-m_corner+1, 1 );   // top (outer)
 832     dc->DrawRectangle( x, y, 1, h );              // left (outer)
 833     dc->DrawLine( x, y+h-1, x+1, y+h-1 );
 834     dc->DrawLine( x+w-1, y, x+w-1, y+1 );
 835 }
 836
 837 void wxListHeaderWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
 838 {
 839     wxPaintDC dc( this );
 840     PrepareDC( dc );
 841 #if wxUSE_GENERIC_LIST_EXTENSIONS
 842         if ( m_owner->GetMode() & wxLC_REPORT )
 843         {
 844                 int x , y ;
 845                 int xpix , ypix ;
 846
 847                 m_owner->GetScrollPixelsPerUnit( &xpix , &ypix ) ;
 848                 m_owner->ViewStart( &x, &y ) ;
 849             dc.SetDeviceOrigin( -x * xpix, 0 );
 850         }
 851 #endif
 852     dc.BeginDrawing();
 853
 854     dc.SetFont( GetFont() );
 855
 856     int w = 0;
 857     int h = 0;
 858     int x = 0;
 859     int y = 0;
 860     GetClientSize( &w, &h );
 861
 862     dc.SetBackgroundMode(wxTRANSPARENT);
 863     dc.SetTextForeground( *wxBLACK );
 864
 865     // do *not* use the listctrl colour for headers - one day we will have a
 866     // function to set it separately
 867
 868     x = 1;
 869     y = 1;
 870     int numColumns = m_owner->GetColumnCount();
 871     wxListItem item;
 872     for (int i = 0; i < numColumns; i++)
 873     {
 874         m_owner->GetColumn( i, item );
 875         int cw = item.m_width-2;
 876 #if wxUSE_GENERIC_LIST_EXTENSIONS
 877         if ((i+1 == numColumns) || ( dc.LogicalToDeviceX(x+item.m_width) > w-5))
 878             cw = dc.DeviceToLogicalX(w)-x-1;
 879 #else
 880         if ((i+1 == numColumns) || (x+item.m_width > w-5))
 881             cw = w-x-1;
 882 #endif
 883         dc.SetPen( *wxWHITE_PEN );
 884
 885         DoDrawRect( &dc, x, y, cw, h-2 );
 886         dc.SetClippingRegion( x, y, cw-5, h-4 );
 887         dc.DrawText( item.m_text, x+4, y+3 );
 888         dc.DestroyClippingRegion();
 889         x += item.m_width;
 890 #if wxUSE_GENERIC_LIST_EXTENSIONS
 891         if (dc.LogicalToDeviceX(x) > w+5) break;
 892 #else
 893         if (x > w+5) break;
 894 #endif
 895     }
 896     dc.EndDrawing();
 897 }
 898
 899 void wxListHeaderWindow::DrawCurrent()
 900 {
 901     int x1 = m_currentX;
 902     int y1 = 0;
 903     int x2 = m_currentX-1;
 904     int y2 = 0;
 905     int dummy;
 906     m_owner->GetClientSize( &dummy, &y2 );
 907     ClientToScreen( &x1, &y1 );
 908     m_owner->ClientToScreen( &x2, &y2 );
 909
 910     wxScreenDC dc;
 911     dc.SetLogicalFunction( wxINVERT );
 912     dc.SetPen( wxPen( *wxBLACK, 2, wxSOLID ) );
 913     dc.SetBrush( *wxTRANSPARENT_BRUSH );
 914
 915     dc.DrawLine( x1, y1, x2, y2 );
 916
 917     dc.SetLogicalFunction( wxCOPY );
 918
 919     dc.SetPen( wxNullPen );
 920     dc.SetBrush( wxNullBrush );
 921 }
 922
 923 void wxListHeaderWindow::OnMouse( wxMouseEvent &event )
 924 {
 925     wxCoord x = (wxCoord)event.GetX();
 926     wxCoord y = (wxCoord)event.GetY();
 927     if (m_isDragging)
 928     {
 929         DrawCurrent();
 930         if (event.ButtonUp())
 931         {
 932             ReleaseMouse();
 933             m_isDragging = FALSE;
 934             m_owner->SetColumnWidth( m_column, m_currentX-m_minX );
 935         }
 936         else
 937         {
 938             int size_x = 0;
 939             int dummy;
 940             GetClientSize( &size_x, & dummy );
 941             if (x > m_minX+7)
 942                 m_currentX = x;
 943             else
 944                 m_currentX = m_minX+7;
 945             if (m_currentX > size_x-7) m_currentX = size_x-7;
 946             DrawCurrent();
 947         }
 948         return;
 949     }
 950
 951     m_minX = 0;
 952     bool hit_border = FALSE;
 953     int xpos = 0;
 954     for (int j = 0; j < m_owner->GetColumnCount()-1; j++)
 955     {
 956         xpos += m_owner->GetColumnWidth( j );
 957         m_column = j;
 958         if ((abs(x-xpos) < 3) && (y < 22))
 959         {
 960             hit_border = TRUE;
 961             break;
 962         }
 963         if (x-xpos < 0)
 964         {
 965             break;
 966         }
 967         m_minX = xpos;
 968     }
 969
 970     if (event.LeftDown())
 971     {
 972         if (hit_border)
 973         {
 974             m_isDragging = TRUE;
 975             m_currentX = x;
 976             DrawCurrent();
 977             CaptureMouse();
 978             return;
 979         }
 980         else
 981         {
 982             wxListEvent le( wxEVT_COMMAND_LIST_COL_CLICK, GetParent()->GetId() );
 983             le.SetEventObject( GetParent() );
 984             le.m_col = m_column;
 985             GetParent()->GetEventHandler()->ProcessEvent( le );
 986             return;
 987         }
 988     }
 989
 990     if (event.Moving())
 991     {
 992         if (hit_border)
 993         {
 994             if (m_currentCursor == wxSTANDARD_CURSOR) SetCursor( * m_resizeCursor );
 995             m_currentCursor = m_resizeCursor;
 996         }
 997         else
 998         {
 999             if (m_currentCursor != wxSTANDARD_CURSOR) SetCursor( * wxSTANDARD_CURSOR );
1000             m_currentCursor = wxSTANDARD_CURSOR;
1001         }
1002     }
1003 }
1004
1005 void wxListHeaderWindow::OnSetFocus( wxFocusEvent &WXUNUSED(event) )
1006 {
1007     m_owner->SetFocus();
1008 }
1009
1010 //-----------------------------------------------------------------------------
1011 // wxListRenameTimer (internal)
1012 //-----------------------------------------------------------------------------
1013
1014 wxListRenameTimer::wxListRenameTimer( wxListMainWindow *owner )
1015 {
1016     m_owner = owner;
1017 }
1018
1019 void wxListRenameTimer::Notify()
1020 {
1021     m_owner->OnRenameTimer();
1022 }
1023
1024 //-----------------------------------------------------------------------------
1025 // wxListTextCtrl (internal)
1026 //-----------------------------------------------------------------------------
1027
1028 IMPLEMENT_DYNAMIC_CLASS(wxListTextCtrl,wxTextCtrl);
1029
1030 BEGIN_EVENT_TABLE(wxListTextCtrl,wxTextCtrl)
1031     EVT_CHAR           (wxListTextCtrl::OnChar)
1032     EVT_KILL_FOCUS     (wxListTextCtrl::OnKillFocus)
1033 END_EVENT_TABLE()
1034
1035 wxListTextCtrl::wxListTextCtrl( wxWindow *parent,
1036                                 const wxWindowID id,
1037                                 bool *accept,
1038                                 wxString *res,
1039                                 wxListMainWindow *owner,
1040                                 const wxString &value,
1041                                 const wxPoint &pos,
1042                                 const wxSize &size,
1043                                 int style,
1044                                 const wxValidator& validator,
1045                                 const wxString &name )
1046               : wxTextCtrl( parent, id, value, pos, size, style, validator, name )
1047 {
1048     m_res = res;
1049     m_accept = accept;
1050     m_owner = owner;
1051     (*m_accept) = FALSE;
1052     (*m_res) = "";
1053     m_startValue = value;
1054 }
1055
1056 void wxListTextCtrl::OnChar( wxKeyEvent &event )
1057 {
1058     if (event.m_keyCode == WXK_RETURN)
1059     {
1060         (*m_accept) = TRUE;
1061         (*m_res) = GetValue();
1062         m_owner->SetFocus();
1063         return;
1064     }
1065     if (event.m_keyCode == WXK_ESCAPE)
1066     {
1067         (*m_accept) = FALSE;
1068         (*m_res) = "";
1069         m_owner->SetFocus();
1070         return;
1071     }
1072     event.Skip();
1073 }
1074
1075 void wxListTextCtrl::OnKillFocus( wxFocusEvent &WXUNUSED(event) )
1076 {
1077     if (wxPendingDelete.Member(this)) return;
1078
1079     wxPendingDelete.Append(this);
1080
1081     if ((*m_accept) && ((*m_res) != m_startValue))
1082         m_owner->OnRenameAccept();
1083 }
1084
1085 //-----------------------------------------------------------------------------
1086 //  wxListMainWindow
1087 //-----------------------------------------------------------------------------
1088
1089 IMPLEMENT_DYNAMIC_CLASS(wxListMainWindow,wxScrolledWindow);
1090
1091 BEGIN_EVENT_TABLE(wxListMainWindow,wxScrolledWindow)
1092   EVT_PAINT          (wxListMainWindow::OnPaint)
1093   EVT_SIZE           (wxListMainWindow::OnSize)
1094   EVT_MOUSE_EVENTS   (wxListMainWindow::OnMouse)
1095   EVT_CHAR           (wxListMainWindow::OnChar)
1096   EVT_KEY_DOWN       (wxListMainWindow::OnKeyDown)
1097   EVT_SET_FOCUS      (wxListMainWindow::OnSetFocus)
1098   EVT_KILL_FOCUS     (wxListMainWindow::OnKillFocus)
1099   EVT_SCROLLWIN                 (wxListMainWindow::OnScroll)
1100 END_EVENT_TABLE()
1101
1102 wxListMainWindow::wxListMainWindow()
1103 {
1104     m_mode = 0;
1105     m_lines.DeleteContents( TRUE );
1106     m_columns.DeleteContents( TRUE );
1107     m_current = (wxListLineData *) NULL;
1108     m_visibleLines = 0;
1109     m_hilightBrush = (wxBrush *) NULL;
1110     m_xScroll = 0;
1111     m_yScroll = 0;
1112     m_dirty = TRUE;
1113     m_small_image_list = (wxImageList *) NULL;
1114     m_normal_image_list = (wxImageList *) NULL;
1115     m_small_spacing = 30;
1116     m_normal_spacing = 40;
1117     m_hasFocus = FALSE;
1118     m_usedKeys = TRUE;
1119     m_lastOnSame = FALSE;
1120     m_renameTimer = new wxListRenameTimer( this );
1121     m_isCreated = FALSE;
1122     m_dragCount = 0;
1123 }
1124
1125 wxListMainWindow::wxListMainWindow( wxWindow *parent, wxWindowID id,
1126       const wxPoint &pos, const wxSize &size,
1127       long style, const wxString &name ) :
1128   wxScrolledWindow( parent, id, pos, size, style|wxHSCROLL|wxVSCROLL, name )
1129 {
1130     m_mode = style;
1131     m_lines.DeleteContents( TRUE );
1132     m_columns.DeleteContents( TRUE );
1133     m_current = (wxListLineData *) NULL;
1134     m_dirty = TRUE;
1135     m_visibleLines = 0;
1136     m_hilightBrush = new wxBrush( wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHT), wxSOLID );
1137     m_small_image_list = (wxImageList *) NULL;
1138     m_normal_image_list = (wxImageList *) NULL;
1139     m_small_spacing = 30;
1140     m_normal_spacing = 40;
1141     m_hasFocus = FALSE;
1142     m_dragCount = 0;
1143     m_isCreated = FALSE;
1144     wxSize sz = size;
1145     sz.y = 25;
1146
1147     if (m_mode & wxLC_REPORT)
1148     {
1149 #if wxUSE_GENERIC_LIST_EXTENSIONS
1150         m_xScroll = 15;
1151 #else
1152         m_xScroll = 0;
1153 #endif
1154         m_yScroll = 15;
1155     }
1156     else
1157     {
1158         m_xScroll = 15;
1159         m_yScroll = 0;
1160     }
1161     SetScrollbars( m_xScroll, m_yScroll, 0, 0, 0, 0 );
1162
1163     m_usedKeys = TRUE;
1164     m_lastOnSame = FALSE;
1165     m_renameTimer = new wxListRenameTimer( this );
1166     m_renameAccept = FALSE;
1167
1168     SetBackgroundColour( *wxWHITE );
1169 }
1170
1171 wxListMainWindow::~wxListMainWindow()
1172 {
1173     if (m_hilightBrush) delete m_hilightBrush;
1174
1175     delete m_renameTimer;
1176 }
1177
1178 void wxListMainWindow::RefreshLine( wxListLineData *line )
1179 {
1180     if (m_dirty) return;
1181
1182     int x = 0;
1183     int y = 0;
1184     int w = 0;
1185     int h = 0;
1186     if (line)
1187     {
1188         wxClientDC dc(this);
1189         PrepareDC( dc );
1190         line->GetExtent( x, y, w, h );
1191         wxRect rect(
1192           dc.LogicalToDeviceX(x-3),
1193           dc.LogicalToDeviceY(y-3),
1194           dc.LogicalToDeviceXRel(w+6),
1195           dc.LogicalToDeviceXRel(h+6) );
1196         Refresh( TRUE, &rect );
1197     }
1198 }
1199
1200 void wxListMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
1201 {
1202     // Note: a wxPaintDC must be constructed even if no drawing is
1203     // done (a Windows requirement).
1204     wxPaintDC dc( this );
1205     PrepareDC( dc );
1206
1207     if (m_dirty) return;
1208
1209     if (m_lines.GetCount() == 0) return;
1210
1211     dc.BeginDrawing();
1212
1213     dc.SetFont( GetFont() );
1214
1215     if (m_mode & wxLC_REPORT)
1216     {
1217         int lineSpacing = 0;
1218         wxListLineData *line = (wxListLineData*)m_lines.First()->Data();
1219         int dummy = 0;
1220         line->GetSize( dummy, lineSpacing );
1221         lineSpacing += 1;
1222
1223         int y_s = m_yScroll*GetScrollPos( wxVERTICAL );
1224
1225         wxNode *node = m_lines.Nth( y_s / lineSpacing );
1226         for (int i = 0; i < m_visibleLines+2; i++)
1227         {
1228             if (!node) break;
1229
1230             line = (wxListLineData*)node->Data();
1231             line->Draw( &dc );
1232             node = node->Next();
1233         }
1234     }
1235     else
1236     {
1237         wxNode *node = m_lines.First();
1238         while (node)
1239         {
1240             wxListLineData *line = (wxListLineData*)node->Data();
1241             line->Draw( &dc );
1242             node = node->Next();
1243         }
1244     }
1245
1246     if (m_current) m_current->DrawRubberBand( &dc, m_hasFocus );
1247
1248     dc.EndDrawing();
1249 }
1250
1251 void wxListMainWindow::HilightAll( bool on )
1252 {
1253     wxNode *node = m_lines.First();
1254     while (node)
1255     {
1256         wxListLineData *line = (wxListLineData *)node->Data();
1257         if (line->IsHilighted() != on)
1258         {
1259             line->Hilight( on );
1260             RefreshLine( line );
1261         }
1262         node = node->Next();
1263     }
1264 }
1265
1266 void wxListMainWindow::SendNotify( wxListLineData *line, wxEventType command )
1267 {
1268     wxListEvent le( command, GetParent()->GetId() );
1269     le.SetEventObject( GetParent() );
1270     le.m_itemIndex = GetIndexOfLine( line );
1271     line->GetItem( 0, le.m_item );
1272     GetParent()->GetEventHandler()->ProcessEvent( le );
1273 //    GetParent()->GetEventHandler()->AddPendingEvent( le );
1274 }
1275
1276 void wxListMainWindow::FocusLine( wxListLineData *WXUNUSED(line) )
1277 {
1278 //  SendNotify( line, wxEVT_COMMAND_LIST_ITEM_FOCUSSED );
1279 }
1280
1281 void wxListMainWindow::UnfocusLine( wxListLineData *WXUNUSED(line) )
1282 {
1283 //  SendNotify( line, wxEVT_COMMAND_LIST_ITEM_UNFOCUSSED );
1284 }
1285
1286 void wxListMainWindow::SelectLine( wxListLineData *line )
1287 {
1288     SendNotify( line, wxEVT_COMMAND_LIST_ITEM_SELECTED );
1289 }
1290
1291 void wxListMainWindow::DeselectLine( wxListLineData *line )
1292 {
1293     SendNotify( line, wxEVT_COMMAND_LIST_ITEM_DESELECTED );
1294 }
1295
1296 void wxListMainWindow::DeleteLine( wxListLineData *line )
1297 {
1298     SendNotify( line, wxEVT_COMMAND_LIST_DELETE_ITEM );
1299 }
1300
1301 /* *** */
1302
1303 void wxListMainWindow::EditLabel( long item )
1304 {
1305     wxNode *node = m_lines.Nth( (size_t)item );
1306     wxCHECK_RET( node, wxT("wrong index in wxListCtrl::Edit()") );
1307
1308     m_currentEdit = (wxListLineData*) node->Data();
1309
1310     wxListEvent le( wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT, GetParent()->GetId() );
1311     le.SetEventObject( GetParent() );
1312     le.m_itemIndex = GetIndexOfLine( m_currentEdit );
1313     m_currentEdit->GetItem( 0, le.m_item );
1314     GetParent()->GetEventHandler()->ProcessEvent( le );
1315
1316     if (!le.IsAllowed())
1317         return;
1318
1319     // We have to call this here because the label in
1320     // question might just have been added and no screen
1321     // update taken place.
1322     if (m_dirty) wxYield();
1323
1324     wxString s;
1325     m_currentEdit->GetText( 0, s );
1326     int x = 0;
1327     int y = 0;
1328     int w = 0;
1329     int h = 0;
1330     m_currentEdit->GetLabelExtent( x, y, w, h );
1331
1332     wxClientDC dc(this);
1333     PrepareDC( dc );
1334     x = dc.LogicalToDeviceX( x );
1335     y = dc.LogicalToDeviceY( y );
1336
1337     wxListTextCtrl *text = new wxListTextCtrl(
1338       this, -1, &m_renameAccept, &m_renameRes, this, s, wxPoint(x-4,y-4), wxSize(w+11,h+8) );
1339     text->SetFocus();
1340 }
1341
1342 void wxListMainWindow::OnRenameTimer()
1343 {
1344     wxCHECK_RET( m_current, wxT("invalid m_current") );
1345
1346     Edit( m_lines.IndexOf( m_current ) );
1347 }
1348
1349 void wxListMainWindow::OnRenameAccept()
1350 {
1351     wxListEvent le( wxEVT_COMMAND_LIST_END_LABEL_EDIT, GetParent()->GetId() );
1352     le.SetEventObject( GetParent() );
1353     le.m_itemIndex = GetIndexOfLine( m_currentEdit );
1354     m_currentEdit->GetItem( 0, le.m_item );
1355     le.m_item.m_text = m_renameRes;
1356     GetParent()->GetEventHandler()->ProcessEvent( le );
1357
1358     if (!le.IsAllowed()) return;
1359
1360     wxListItem info;
1361     info.m_mask = wxLIST_MASK_TEXT;
1362     info.m_itemId = le.m_itemIndex;
1363     info.m_text = m_renameRes;
1364     info.SetTextColour(le.m_item.GetTextColour());
1365     SetItem( info );
1366 }
1367
1368 void wxListMainWindow::OnMouse( wxMouseEvent &event )
1369 {
1370     if (GetParent()->GetEventHandler()->ProcessEvent( event)) return;
1371
1372     if (!m_current) return;
1373     if (m_dirty) return;
1374     if ( !(event.Dragging() || event.ButtonDown() || event.LeftUp() || event.ButtonDClick()) ) return;
1375
1376     wxClientDC dc(this);
1377     PrepareDC(dc);
1378     wxCoord x = dc.DeviceToLogicalX( (wxCoord)event.GetX() );
1379     wxCoord y = dc.DeviceToLogicalY( (wxCoord)event.GetY() );
1380
1381     /* Did we actually hit an item ? */
1382     long hitResult = 0;
1383     wxNode *node = m_lines.First();
1384     wxListLineData *line = (wxListLineData *) NULL;
1385     while (node)
1386     {
1387         line = (wxListLineData*)node->Data();
1388         hitResult = line->IsHit( x, y );
1389         if (hitResult) break;
1390         line = (wxListLineData *) NULL;
1391         node = node->Next();
1392     }
1393
1394     if (event.Dragging())
1395     {
1396         if (m_dragCount == 0)
1397             m_dragStart = wxPoint(x,y);
1398
1399         m_dragCount++;
1400
1401         if (m_dragCount != 3) return;
1402
1403         int command = wxEVT_COMMAND_LIST_BEGIN_DRAG;
1404         if (event.RightIsDown()) command = wxEVT_COMMAND_LIST_BEGIN_RDRAG;
1405
1406         wxListEvent le( command, GetParent()->GetId() );
1407         le.SetEventObject( GetParent() );
1408         le.m_pointDrag = m_dragStart;
1409         GetParent()->GetEventHandler()->ProcessEvent( le );
1410
1411         return;
1412     }
1413     else
1414     {
1415         m_dragCount = 0;
1416     }
1417
1418     if (!line) return;
1419
1420     if (event.ButtonDClick())
1421     {
1422         m_usedKeys = FALSE;
1423         m_lastOnSame = FALSE;
1424         m_renameTimer->Stop();
1425
1426         SendNotify( line, wxEVT_COMMAND_LIST_ITEM_ACTIVATED );
1427
1428        return;
1429     }
1430
1431     if (event.LeftUp() && m_lastOnSame)
1432     {
1433         m_usedKeys = FALSE;
1434         if ((line == m_current) &&
1435             (hitResult == wxLIST_HITTEST_ONITEMLABEL) &&
1436             (m_mode & wxLC_EDIT_LABELS)  )
1437         {
1438             m_renameTimer->Start( 100, TRUE );
1439         }
1440         m_lastOnSame = FALSE;
1441         return;
1442     }
1443
1444     if (event.RightDown())
1445     {
1446         SendNotify( line, wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK );
1447         return;
1448     }
1449
1450     if (event.MiddleDown())
1451     {
1452         SendNotify( line, wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK );
1453         return;
1454     }
1455
1456     if (event.LeftDown())
1457     {
1458         m_usedKeys = FALSE;
1459         wxListLineData *oldCurrent = m_current;
1460         if (m_mode & wxLC_SINGLE_SEL)
1461         {
1462             m_current = line;
1463             HilightAll( FALSE );
1464             m_current->ReverseHilight();
1465             RefreshLine( m_current );
1466         }
1467         else
1468         {
1469             if (event.ShiftDown())
1470             {
1471                 m_current = line;
1472                 m_current->ReverseHilight();
1473                 RefreshLine( m_current );
1474             }
1475             else if (event.ControlDown())
1476             {
1477                 m_current = line;
1478
1479                 int numOfCurrent = -1;
1480                 node = m_lines.First();
1481                 while (node)
1482                 {
1483                     wxListLineData *test_line = (wxListLineData*)node->Data();
1484                     numOfCurrent++;
1485                     if (test_line == oldCurrent) break;
1486                     node = node->Next();
1487                 }
1488
1489                 int numOfLine = -1;
1490                 node = m_lines.First();
1491                 while (node)
1492                 {
1493                     wxListLineData *test_line = (wxListLineData*)node->Data();
1494                     numOfLine++;
1495                     if (test_line == line) break;
1496                     node = node->Next();
1497                 }
1498
1499                 if (numOfLine < numOfCurrent)
1500                 {
1501                     int i = numOfLine;
1502                     numOfLine = numOfCurrent;
1503                     numOfCurrent = i;
1504                 }
1505
1506                 wxNode *node = m_lines.Nth( numOfCurrent );
1507                 for (int i = 0; i <= numOfLine-numOfCurrent; i++)
1508                 {
1509                     wxListLineData *test_line= (wxListLineData*)node->Data();
1510                     test_line->Hilight(TRUE);
1511                     RefreshLine( test_line );
1512                     node = node->Next();
1513                 }
1514             }
1515             else
1516             {
1517                 m_current = line;
1518                 HilightAll( FALSE );
1519                 m_current->ReverseHilight();
1520                 RefreshLine( m_current );
1521             }
1522         }
1523         if (m_current != oldCurrent)
1524         {
1525             RefreshLine( oldCurrent );
1526             UnfocusLine( oldCurrent );
1527             FocusLine( m_current );
1528         }
1529         m_lastOnSame = (m_current == oldCurrent);
1530         return;
1531     }
1532 }
1533
1534 void wxListMainWindow::MoveToFocus()
1535 {
1536     if (!m_current) return;
1537
1538     int item_x = 0;
1539     int item_y = 0;
1540     int item_w = 0;
1541     int item_h = 0;
1542     m_current->GetExtent( item_x, item_y, item_w, item_h );
1543
1544     int client_w = 0;
1545     int client_h = 0;
1546     GetClientSize( &client_w, &client_h );
1547
1548     int view_x = m_xScroll*GetScrollPos( wxHORIZONTAL );
1549     int view_y = m_yScroll*GetScrollPos( wxVERTICAL );
1550
1551     if (m_mode & wxLC_REPORT)
1552     {
1553         if (item_y-5 < view_y )
1554             Scroll( -1, (item_y-5)/m_yScroll );
1555         if (item_y+item_h+5 > view_y+client_h)
1556             Scroll( -1, (item_y+item_h-client_h+15)/m_yScroll );
1557     }
1558     else
1559     {
1560         if (item_x-view_x < 5)
1561             Scroll( (item_x-5)/m_xScroll, -1 );
1562         if (item_x+item_w-5 > view_x+client_w)
1563             Scroll( (item_x+item_w-client_w+15)/m_xScroll, -1 );
1564     }
1565 }
1566
1567 void wxListMainWindow::OnArrowChar( wxListLineData *newCurrent, bool shiftDown )
1568 {
1569     if ((m_mode & wxLC_SINGLE_SEL) || (m_usedKeys == FALSE)) m_current->Hilight( FALSE );
1570     wxListLineData *oldCurrent = m_current;
1571     m_current = newCurrent;
1572     if (shiftDown || (m_mode & wxLC_SINGLE_SEL)) m_current->Hilight( TRUE );
1573     RefreshLine( m_current );
1574     RefreshLine( oldCurrent );
1575     FocusLine( m_current );
1576     UnfocusLine( oldCurrent );
1577     MoveToFocus();
1578 }
1579
1580 void wxListMainWindow::OnKeyDown( wxKeyEvent &event )
1581 {
1582     wxWindow *parent = GetParent();
1583
1584     /* we propagate the key event up */
1585     wxKeyEvent ke( wxEVT_KEY_DOWN );
1586     ke.m_shiftDown = event.m_shiftDown;
1587     ke.m_controlDown = event.m_controlDown;
1588     ke.m_altDown = event.m_altDown;
1589     ke.m_metaDown = event.m_metaDown;
1590     ke.m_keyCode = event.m_keyCode;
1591     ke.m_x = event.m_x;
1592     ke.m_y = event.m_y;
1593     ke.SetEventObject( parent );
1594     if (parent->GetEventHandler()->ProcessEvent( ke )) return;
1595
1596     event.Skip();
1597 }
1598
1599 void wxListMainWindow::OnChar( wxKeyEvent &event )
1600 {
1601     wxWindow *parent = GetParent();
1602
1603     /* we send a list_key event up */
1604     wxListEvent le( wxEVT_COMMAND_LIST_KEY_DOWN, GetParent()->GetId() );
1605     le.m_code = (int)event.KeyCode();
1606     le.SetEventObject( parent );
1607     parent->GetEventHandler()->ProcessEvent( le );
1608
1609     /* we propagate the char event up */
1610     wxKeyEvent ke( wxEVT_CHAR );
1611     ke.m_shiftDown = event.m_shiftDown;
1612     ke.m_controlDown = event.m_controlDown;
1613     ke.m_altDown = event.m_altDown;
1614     ke.m_metaDown = event.m_metaDown;
1615     ke.m_keyCode = event.m_keyCode;
1616     ke.m_x = event.m_x;
1617     ke.m_y = event.m_y;
1618     ke.SetEventObject( parent );
1619     if (parent->GetEventHandler()->ProcessEvent( ke )) return;
1620
1621     if (event.KeyCode() == WXK_TAB)
1622     {
1623         wxNavigationKeyEvent nevent;
1624         nevent.SetDirection( !event.ShiftDown() );
1625         nevent.SetCurrentFocus( m_parent );
1626         if (m_parent->GetEventHandler()->ProcessEvent( nevent )) return;
1627     }
1628
1629     /* no item -> nothing to do */
1630     if (!m_current)
1631     {
1632         event.Skip();
1633         return;
1634     }
1635
1636     switch (event.KeyCode())
1637     {
1638         case WXK_UP:
1639         {
1640             wxNode *node = m_lines.Member( m_current )->Previous();
1641             if (node) OnArrowChar( (wxListLineData*)node->Data(), event.ShiftDown() );
1642             break;
1643         }
1644         case WXK_DOWN:
1645         {
1646             wxNode *node = m_lines.Member( m_current )->Next();
1647             if (node) OnArrowChar( (wxListLineData*)node->Data(), event.ShiftDown() );
1648             break;
1649         }
1650         case WXK_END:
1651         {
1652             wxNode *node = m_lines.Last();
1653             OnArrowChar( (wxListLineData*)node->Data(), event.ShiftDown() );
1654             break;
1655         }
1656         case WXK_HOME:
1657         {
1658             wxNode *node = m_lines.First();
1659             OnArrowChar( (wxListLineData*)node->Data(), event.ShiftDown() );
1660             break;
1661         }
1662         case WXK_PRIOR:
1663         {
1664             int steps = 0;
1665             if (m_mode & wxLC_REPORT)
1666             {
1667                 steps = m_visibleLines-1;
1668             }
1669             else
1670             {
1671                 int pos = 0;
1672                 wxNode *node = m_lines.First();
1673                 for (;;) { if (m_current == (wxListLineData*)node->Data()) break; pos++; node = node->Next(); }
1674                 steps = pos % m_visibleLines;
1675             }
1676             wxNode *node = m_lines.Member( m_current );
1677             for (int i = 0; i < steps; i++) if (node->Previous()) node = node->Previous();
1678             if (node) OnArrowChar( (wxListLineData*)node->Data(), event.ShiftDown() );
1679             break;
1680         }
1681         case WXK_NEXT:
1682         {
1683             int steps = 0;
1684             if (m_mode & wxLC_REPORT)
1685             {
1686                 steps = m_visibleLines-1;
1687             }
1688             else
1689             {
1690                 int pos = 0; wxNode *node = m_lines.First();
1691                 for (;;) { if (m_current == (wxListLineData*)node->Data()) break; pos++; node = node->Next(); }
1692                 steps = m_visibleLines-(pos % m_visibleLines)-1;
1693             }
1694             wxNode *node = m_lines.Member( m_current );
1695             for (int i = 0; i < steps; i++) if (node->Next()) node = node->Next();
1696             if (node) OnArrowChar( (wxListLineData*)node->Data(), event.ShiftDown() );
1697             break;
1698         }
1699         case WXK_LEFT:
1700         {
1701             if (!(m_mode & wxLC_REPORT))
1702             {
1703                 wxNode *node = m_lines.Member( m_current );
1704                 for (int i = 0; i <m_visibleLines; i++) if (node->Previous()) node = node->Previous();
1705                 if (node) OnArrowChar( (wxListLineData*)node->Data(), event.ShiftDown() );
1706             }
1707             break;
1708         }
1709         case WXK_RIGHT:
1710         {
1711             if (!(m_mode & wxLC_REPORT))
1712             {
1713                 wxNode *node = m_lines.Member( m_current );
1714                 for (int i = 0; i <m_visibleLines; i++) if (node->Next()) node = node->Next();
1715                 if (node) OnArrowChar( (wxListLineData*)node->Data(), event.ShiftDown() );
1716             }
1717             break;
1718         }
1719         case WXK_SPACE:
1720         {
1721             m_current->ReverseHilight();
1722             RefreshLine( m_current );
1723             break;
1724         }
1725         case WXK_INSERT:
1726         {
1727             if (!(m_mode & wxLC_SINGLE_SEL))
1728             {
1729                 wxListLineData *oldCurrent = m_current;
1730                 m_current->ReverseHilight();
1731                 wxNode *node = m_lines.Member( m_current )->Next();
1732                 if (node) m_current = (wxListLineData*)node->Data();
1733                 RefreshLine( oldCurrent );
1734                 RefreshLine( m_current );
1735                 UnfocusLine( oldCurrent );
1736                 FocusLine( m_current );
1737                 MoveToFocus();
1738             }
1739             break;
1740         }
1741         case WXK_RETURN:
1742         case WXK_EXECUTE:
1743         {
1744             wxListEvent le( wxEVT_COMMAND_LIST_ITEM_ACTIVATED, GetParent()->GetId() );
1745             le.SetEventObject( GetParent() );
1746             le.m_itemIndex = GetIndexOfLine( m_current );
1747             m_current->GetItem( 0, le.m_item );
1748             GetParent()->GetEventHandler()->ProcessEvent( le );
1749             break;
1750         }
1751         default:
1752         {
1753             event.Skip();
1754             return;
1755         }
1756     }
1757     m_usedKeys = TRUE;
1758 }
1759
1760 #ifdef __WXGTK__
1761 extern wxWindow *g_focusWindow;
1762 #endif
1763
1764 void wxListMainWindow::OnSetFocus( wxFocusEvent &WXUNUSED(event) )
1765 {
1766     m_hasFocus = TRUE;
1767     RefreshLine( m_current );
1768
1769     if (!GetParent()) return;
1770
1771 #ifdef __WXGTK__
1772     g_focusWindow = GetParent();
1773 #endif
1774
1775     wxFocusEvent event( wxEVT_SET_FOCUS, GetParent()->GetId() );
1776     event.SetEventObject( GetParent() );
1777     GetParent()->GetEventHandler()->ProcessEvent( event );
1778 }
1779
1780 void wxListMainWindow::OnKillFocus( wxFocusEvent &WXUNUSED(event) )
1781 {
1782     m_hasFocus = FALSE;
1783     RefreshLine( m_current );
1784 }
1785
1786 void wxListMainWindow::OnSize( wxSizeEvent &WXUNUSED(event) )
1787 {
1788 /*
1789   We don't even allow the wxScrolledWindow::AdjustScrollbars() call
1790
1791 */
1792 }
1793
1794 void wxListMainWindow::DrawImage( int index, wxDC *dc, int x, int y )
1795 {
1796     if ((m_mode & wxLC_ICON) && (m_normal_image_list))
1797     {
1798         m_normal_image_list->Draw( index, *dc, x, y, wxIMAGELIST_DRAW_TRANSPARENT );
1799         return;
1800     }
1801     if ((m_mode & wxLC_SMALL_ICON) && (m_small_image_list))
1802     {
1803         m_small_image_list->Draw( index, *dc, x, y, wxIMAGELIST_DRAW_TRANSPARENT );
1804     }
1805     if ((m_mode & wxLC_LIST) && (m_small_image_list))
1806     {
1807         m_small_image_list->Draw( index, *dc, x, y, wxIMAGELIST_DRAW_TRANSPARENT );
1808     }
1809     if ((m_mode & wxLC_REPORT) && (m_small_image_list))
1810     {
1811         m_small_image_list->Draw( index, *dc, x, y, wxIMAGELIST_DRAW_TRANSPARENT );
1812         return;
1813     }
1814 }
1815
1816 void wxListMainWindow::GetImageSize( int index, int &width, int &height )
1817 {
1818     if ((m_mode & wxLC_ICON) && (m_normal_image_list))
1819     {
1820         m_normal_image_list->GetSize( index, width, height );
1821         return;
1822     }
1823     if ((m_mode & wxLC_SMALL_ICON) && (m_small_image_list))
1824     {
1825         m_small_image_list->GetSize( index, width, height );
1826         return;
1827     }
1828     if ((m_mode & wxLC_LIST) && (m_small_image_list))
1829     {
1830         m_small_image_list->GetSize( index, width, height );
1831         return;
1832     }
1833     if ((m_mode & wxLC_REPORT) && (m_small_image_list))
1834     {
1835         m_small_image_list->GetSize( index, width, height );
1836         return;
1837     }
1838     width = 0;
1839     height = 0;
1840 }
1841
1842 int wxListMainWindow::GetTextLength( wxString &s )
1843 {
1844     wxClientDC dc( this );
1845     wxCoord lw = 0;
1846     wxCoord lh = 0;
1847     dc.GetTextExtent( s, &lw, &lh );
1848     return lw + 6;
1849 }
1850
1851 int wxListMainWindow::GetIndexOfLine( const wxListLineData *line )
1852 {
1853     int i = 0;
1854     wxNode *node = m_lines.First();
1855     while (node)
1856     {
1857         if (line == (wxListLineData*)node->Data()) return i;
1858         i++;
1859         node = node->Next();
1860     }
1861     return -1;
1862 }
1863
1864 void wxListMainWindow::SetImageList( wxImageList *imageList, int which )
1865 {
1866     m_dirty = TRUE;
1867     if (which == wxIMAGE_LIST_NORMAL) m_normal_image_list = imageList;
1868     if (which == wxIMAGE_LIST_SMALL) m_small_image_list = imageList;
1869 }
1870
1871 void wxListMainWindow::SetItemSpacing( int spacing, bool isSmall )
1872 {
1873     m_dirty = TRUE;
1874     if (isSmall)
1875     {
1876         m_small_spacing = spacing;
1877     }
1878     else
1879     {
1880         m_normal_spacing = spacing;
1881     }
1882 }
1883
1884 int wxListMainWindow::GetItemSpacing( bool isSmall )
1885 {
1886     if (isSmall) return m_small_spacing; else return m_normal_spacing;
1887 }
1888
1889 void wxListMainWindow::SetColumn( int col, wxListItem &item )
1890 {
1891     m_dirty = TRUE;
1892     wxNode *node = m_columns.Nth( col );
1893     if (node)
1894     {
1895         if (item.m_width == wxLIST_AUTOSIZE_USEHEADER) item.m_width = GetTextLength( item.m_text )+7;
1896         wxListHeaderData *column = (wxListHeaderData*)node->Data();
1897         column->SetItem( item );
1898     }
1899     wxListCtrl *lc = (wxListCtrl*) GetParent();
1900     if (lc->m_headerWin) lc->m_headerWin->Refresh();
1901 }
1902
1903 void wxListMainWindow::SetColumnWidth( int col, int width )
1904 {
1905     if (!(m_mode & wxLC_REPORT)) return;
1906
1907     m_dirty = TRUE;
1908
1909     wxNode *node = (wxNode*) NULL;
1910
1911     if (width == wxLIST_AUTOSIZE_USEHEADER) width = 80;
1912     if (width == wxLIST_AUTOSIZE)
1913     {
1914         wxClientDC dc(this);
1915         dc.SetFont( GetFont() );
1916         int max = 10;
1917         node = m_lines.First();
1918         while (node)
1919         {
1920             wxListLineData *line = (wxListLineData*)node->Data();
1921             wxNode *n = line->m_items.Nth( col );
1922             if (n)
1923             {
1924                 wxListItemData *item = (wxListItemData*)n->Data();
1925                 int current = 0, ix = 0, iy = 0;
1926                 wxCoord lx = 0, ly = 0;
1927                 if (item->HasImage())
1928                 {
1929                     GetImageSize( item->GetImage(), ix, iy );
1930                     current = ix + 5;
1931                 }
1932                 if (item->HasText())
1933                 {
1934                     wxString str;
1935                     item->GetText( str );
1936                     dc.GetTextExtent( str, &lx, &ly );
1937                     current += lx;
1938                 }
1939                 if (current > max) max = current;
1940             }
1941             node = node->Next();
1942         }
1943         width = max+10;
1944     }
1945
1946     node = m_columns.Nth( col );
1947     if (node)
1948     {
1949         wxListHeaderData *column = (wxListHeaderData*)node->Data();
1950         column->SetWidth( width );
1951     }
1952
1953     node = m_lines.First();
1954     while (node)
1955     {
1956         wxListLineData *line = (wxListLineData*)node->Data();
1957         wxNode *n = line->m_items.Nth( col );
1958         if (n)
1959         {
1960             wxListItemData *item = (wxListItemData*)n->Data();
1961             item->SetSize( width, -1 );
1962         }
1963         node = node->Next();
1964     }
1965
1966     wxListCtrl *lc = (wxListCtrl*) GetParent();
1967     if (lc->m_headerWin) lc->m_headerWin->Refresh();
1968 }
1969
1970 void wxListMainWindow::GetColumn( int col, wxListItem &item )
1971 {
1972     wxNode *node = m_columns.Nth( col );
1973     if (node)
1974     {
1975         wxListHeaderData *column = (wxListHeaderData*)node->Data();
1976         column->GetItem( item );
1977     }
1978     else
1979     {
1980         item.m_format = 0;
1981         item.m_width = 0;
1982         item.m_text = "";
1983         item.m_image = 0;
1984         item.m_data = 0;
1985     }
1986 }
1987
1988 int wxListMainWindow::GetColumnWidth( int col )
1989 {
1990     wxNode *node = m_columns.Nth( col );
1991     if (node)
1992     {
1993         wxListHeaderData *column = (wxListHeaderData*)node->Data();
1994         return column->GetWidth();
1995     }
1996     else
1997     {
1998         return 0;
1999     }
2000 }
2001
2002 int wxListMainWindow::GetColumnCount()
2003 {
2004     return m_columns.Number();
2005 }
2006
2007 int wxListMainWindow::GetCountPerPage()
2008 {
2009     return m_visibleLines;
2010 }
2011
2012 void wxListMainWindow::SetItem( wxListItem &item )
2013 {
2014     m_dirty = TRUE;
2015     wxNode *node = m_lines.Nth( (size_t)item.m_itemId );
2016     if (node)
2017     {
2018         wxListLineData *line = (wxListLineData*)node->Data();
2019         if (m_mode & wxLC_REPORT) item.m_width = GetColumnWidth( item.m_col )-3;
2020         line->SetItem( item.m_col, item );
2021     }
2022 }
2023
2024 void wxListMainWindow::SetItemState( long item, long state, long stateMask )
2025 {
2026     // m_dirty = TRUE; no recalcs needed
2027
2028     wxListLineData *oldCurrent = m_current;
2029
2030     if (stateMask & wxLIST_STATE_FOCUSED)
2031     {
2032         wxNode *node = m_lines.Nth( (size_t)item );
2033         if (node)
2034         {
2035             wxListLineData *line = (wxListLineData*)node->Data();
2036             UnfocusLine( m_current );
2037             m_current = line;
2038             FocusLine( m_current );
2039             RefreshLine( m_current );
2040             if (oldCurrent) RefreshLine( oldCurrent );
2041         }
2042     }
2043
2044     if (stateMask & wxLIST_STATE_SELECTED)
2045     {
2046         bool on = (state & wxLIST_STATE_SELECTED) != 0;
2047         if (!on && (m_mode & wxLC_SINGLE_SEL)) return;
2048
2049         wxNode *node = m_lines.Nth( (size_t)item );
2050         if (node)
2051         {
2052             wxListLineData *line = (wxListLineData*)node->Data();
2053             if (m_mode & wxLC_SINGLE_SEL)
2054             {
2055                 UnfocusLine( m_current );
2056                 m_current = line;
2057                 FocusLine( m_current );
2058                 if (oldCurrent) oldCurrent->Hilight( FALSE );
2059                 RefreshLine( m_current );
2060                 if (oldCurrent) RefreshLine( oldCurrent );
2061             }
2062             bool on = (state & wxLIST_STATE_SELECTED) != 0;
2063             if (on != line->IsHilighted())
2064             {
2065                 line->Hilight( on );
2066                 RefreshLine( line );
2067             }
2068         }
2069     }
2070 }
2071
2072 int wxListMainWindow::GetItemState( long item, long stateMask )
2073 {
2074     int ret = wxLIST_STATE_DONTCARE;
2075     if (stateMask & wxLIST_STATE_FOCUSED)
2076     {
2077         wxNode *node = m_lines.Nth( (size_t)item );
2078         if (node)
2079         {
2080             wxListLineData *line = (wxListLineData*)node->Data();
2081             if (line == m_current) ret |= wxLIST_STATE_FOCUSED;
2082         }
2083     }
2084     if (stateMask & wxLIST_STATE_SELECTED)
2085     {
2086         wxNode *node = m_lines.Nth( (size_t)item );
2087         if (node)
2088         {
2089             wxListLineData *line = (wxListLineData*)node->Data();
2090             if (line->IsHilighted()) ret |= wxLIST_STATE_FOCUSED;
2091         }
2092     }
2093     return ret;
2094 }
2095
2096 void wxListMainWindow::GetItem( wxListItem &item )
2097 {
2098     wxNode *node = m_lines.Nth( (size_t)item.m_itemId );
2099     if (node)
2100     {
2101         wxListLineData *line = (wxListLineData*)node->Data();
2102         line->GetItem( item.m_col, item );
2103     }
2104     else
2105     {
2106         item.m_mask = 0;
2107         item.m_text = "";
2108         item.m_image = 0;
2109         item.m_data = 0;
2110     }
2111 }
2112
2113 int wxListMainWindow::GetItemCount()
2114 {
2115     return m_lines.Number();
2116 }
2117
2118 void wxListMainWindow::GetItemRect( long index, wxRect &rect )
2119 {
2120     wxNode *node = m_lines.Nth( (size_t)index );
2121     if (node)
2122     {
2123         wxListLineData *line = (wxListLineData*)node->Data();
2124         line->GetRect( rect );
2125     }
2126     else
2127     {
2128         rect.x = 0;
2129         rect.y = 0;
2130         rect.width = 0;
2131         rect.height = 0;
2132     }
2133 }
2134
2135 bool wxListMainWindow::GetItemPosition(long item, wxPoint& pos)
2136 {
2137     wxNode *node = m_lines.Nth( (size_t)item );
2138     if (node)
2139     {
2140         wxRect rect;
2141         wxListLineData *line = (wxListLineData*)node->Data();
2142         line->GetRect( rect );
2143         pos.x = rect.x;
2144         pos.y = rect.y;
2145     }
2146     else
2147     {
2148        pos.x = 0;
2149        pos.y = 0;
2150     }
2151     return TRUE;
2152 }
2153
2154 int wxListMainWindow::GetSelectedItemCount()
2155 {
2156     int ret = 0;
2157     wxNode *node = m_lines.First();
2158     while (node)
2159     {
2160         wxListLineData *line = (wxListLineData*)node->Data();
2161         if (line->IsHilighted()) ret++;
2162         node = node->Next();
2163     }
2164     return ret;
2165 }
2166
2167 void wxListMainWindow::SetMode( long mode )
2168 {
2169     m_dirty = TRUE;
2170     m_mode = mode;
2171
2172     DeleteEverything();
2173
2174     if (m_mode & wxLC_REPORT)
2175     {
2176 #if wxUSE_GENERIC_LIST_EXTENSIONS
2177         m_xScroll = 15;
2178 #else
2179         m_xScroll = 0;
2180 #endif
2181         m_yScroll = 15;
2182     }
2183     else
2184     {
2185         m_xScroll = 15;
2186         m_yScroll = 0;
2187     }
2188 }
2189
2190 long wxListMainWindow::GetMode() const
2191 {
2192     return m_mode;
2193 }
2194
2195 void wxListMainWindow::CalculatePositions()
2196 {
2197     if (!m_lines.First()) return;
2198
2199     wxClientDC dc( this );
2200     dc.SetFont( GetFont() );
2201
2202     int iconSpacing = 0;
2203     if (m_mode & wxLC_ICON) iconSpacing = m_normal_spacing;
2204     if (m_mode & wxLC_SMALL_ICON) iconSpacing = m_small_spacing;
2205
2206     // we take the first line (which also can be an icon or
2207     // an a text item in wxLC_ICON and wxLC_LIST modes) to
2208     // measure the size of the line
2209
2210     int lineWidth = 0;
2211     int lineHeight = 0;
2212     int lineSpacing = 0;
2213
2214     wxListLineData *line = (wxListLineData*)m_lines.First()->Data();
2215     line->CalculateSize( &dc, iconSpacing );
2216     int dummy = 0;
2217     line->GetSize( dummy, lineSpacing );
2218     lineSpacing += 4;
2219
2220     int clientWidth = 0;
2221     int clientHeight = 0;
2222
2223     if (m_mode & wxLC_REPORT)
2224     {
2225         int x = 4;
2226         int y = 1;
2227         int entireHeight = m_lines.Number() * lineSpacing + 2;
2228         int scroll_pos = GetScrollPos( wxVERTICAL );
2229 #if wxUSE_GENERIC_LIST_EXTENSIONS
2230         int x_scroll_pos = GetScrollPos( wxHORIZONTAL );
2231 #else
2232         SetScrollbars( m_xScroll, m_yScroll, 0, (entireHeight+15) / m_yScroll, 0, scroll_pos, TRUE );
2233 #endif
2234         GetClientSize( &clientWidth, &clientHeight );
2235
2236         wxNode* node = m_lines.First();
2237         int entireWidth = 0 ;
2238         while (node)
2239         {
2240             wxListLineData *line = (wxListLineData*)node->Data();
2241             line->CalculateSize( &dc, iconSpacing );
2242             line->SetPosition( &dc, x, y, clientWidth );
2243             int col_x = 2;
2244             for (int i = 0; i < GetColumnCount(); i++)
2245             {
2246                 line->SetColumnPosition( i, col_x );
2247                 col_x += GetColumnWidth( i );
2248             }
2249             entireWidth = wxMax( entireWidth , col_x ) ;
2250 #if wxUSE_GENERIC_LIST_EXTENSIONS
2251             line->SetPosition( &dc, x, y, col_x );
2252 #endif
2253             y += lineSpacing;  // one pixel blank line between items
2254             node = node->Next();
2255         }
2256                 m_visibleLines = clientHeight / lineSpacing;
2257 #if wxUSE_GENERIC_LIST_EXTENSIONS
2258                 SetScrollbars( m_xScroll, m_yScroll, entireWidth / m_xScroll , (entireHeight+15) / m_yScroll, x_scroll_pos  , scroll_pos, TRUE );
2259 #endif
2260     }
2261     else
2262     {
2263         // at first we try without any scrollbar. if the items don't
2264         // fit into the window, we recalculate after subtracting an
2265         // approximated 15 pt for the horizontal scrollbar
2266
2267         GetSize( &clientWidth, &clientHeight );
2268         clientHeight -= 4;  // sunken frame
2269
2270         int entireWidth = 0;
2271
2272         for (int tries = 0; tries < 2; tries++)
2273         {
2274             entireWidth = 0;
2275             int x = 5;  // painting is done at x-2
2276             int y = 5;  // painting is done at y-2
2277             int maxWidth = 0;
2278             m_visibleLines = 0;
2279             int m_currentVisibleLines = 0;
2280             wxNode *node = m_lines.First();
2281             while (node)
2282             {
2283                 m_currentVisibleLines++;
2284                 wxListLineData *line = (wxListLineData*)node->Data();
2285                 line->CalculateSize( &dc, iconSpacing );
2286                 line->SetPosition( &dc, x, y, clientWidth );
2287                 line->GetSize( lineWidth, lineHeight );
2288                 if (lineWidth > maxWidth) maxWidth = lineWidth;
2289                 y += lineSpacing;
2290                 if (m_currentVisibleLines > m_visibleLines)
2291                     m_visibleLines = m_currentVisibleLines;
2292                 if (y+lineSpacing-6 >= clientHeight) // -6 for earlier "line breaking"
2293                 {
2294                     m_currentVisibleLines = 0;
2295                     y = 5;
2296                     x += maxWidth+6;
2297                     entireWidth += maxWidth+6;
2298                     maxWidth = 0;
2299                 }
2300                 node = node->Next();
2301                 if (!node) entireWidth += maxWidth;
2302                 if ((tries == 0) && (entireWidth > clientWidth))
2303                 {
2304                     clientHeight -= 15; // scrollbar height
2305                     m_visibleLines = 0;
2306                     m_currentVisibleLines = 0;
2307                     break;
2308                 }
2309                 if (!node) tries = 1;  // everything fits, no second try required
2310             }
2311         }
2312
2313         int scroll_pos = GetScrollPos( wxHORIZONTAL );
2314         SetScrollbars( m_xScroll, m_yScroll, (entireWidth+15) / m_xScroll, 0, scroll_pos, 0, TRUE );
2315     }
2316 }
2317
2318 void wxListMainWindow::RealizeChanges( void )
2319 {
2320     if (!m_current)
2321     {
2322         wxNode *node = m_lines.First();
2323         if (node) m_current = (wxListLineData*)node->Data();
2324     }
2325     if (m_current)
2326     {
2327         FocusLine( m_current );
2328         if (m_mode & wxLC_SINGLE_SEL) m_current->Hilight( TRUE );
2329     }
2330 }
2331
2332 long wxListMainWindow::GetNextItem( long item, int WXUNUSED(geometry), int state )
2333 {
2334     long ret = 0;
2335     if (item > 0) ret = item;
2336     if(ret >= GetItemCount()) return -1;
2337     wxNode *node = m_lines.Nth( (size_t)++ret );
2338     while (node)
2339     {
2340         wxListLineData *line = (wxListLineData*)node->Data();
2341         if ((state & wxLIST_STATE_FOCUSED) && (line == m_current)) return ret;
2342         if ((state & wxLIST_STATE_SELECTED) && (line->IsHilighted())) return ret;
2343         if (!state) return ret;
2344         ret++;
2345         node = node->Next();
2346     }
2347     return -1;
2348 }
2349
2350 void wxListMainWindow::DeleteItem( long index )
2351 {
2352     m_dirty = TRUE;
2353     wxNode *node = m_lines.Nth( (size_t)index );
2354     if (node)
2355     {
2356         wxListLineData *line = (wxListLineData*)node->Data();
2357         if (m_current == line) m_current = (wxListLineData *) NULL;
2358         DeleteLine( line );
2359         m_lines.DeleteNode( node );
2360     }
2361 }
2362
2363 void wxListMainWindow::DeleteColumn( int col )
2364 {
2365     wxCHECK_RET( col < (int)m_columns.GetCount(),
2366                wxT("attempting to delete inexistent column in wxListView") );
2367
2368     m_dirty = TRUE;
2369     wxNode *node = m_columns.Nth( col );
2370     if (node) m_columns.DeleteNode( node );
2371 }
2372
2373 void wxListMainWindow::DeleteAllItems( void )
2374 {
2375     m_dirty = TRUE;
2376     m_current = (wxListLineData *) NULL;
2377
2378     // to make the deletion of all items faster, we don't send the
2379     // notifications in this case: this is compatible with wxMSW and
2380     // documented in DeleteAllItems() description
2381 #if 0
2382     wxNode *node = m_lines.First();
2383     while (node)
2384     {
2385         wxListLineData *line = (wxListLineData*)node->Data();
2386
2387         DeleteLine( line );
2388
2389         node = node->Next();
2390     }
2391 #endif // 0
2392
2393     m_lines.Clear();
2394 }
2395
2396 void wxListMainWindow::DeleteEverything( void )
2397 {
2398     m_dirty = TRUE;
2399     m_current = (wxListLineData *) NULL;
2400     wxNode *node = m_lines.First();
2401     while (node)
2402     {
2403         wxListLineData *line = (wxListLineData*)node->Data();
2404         DeleteLine( line );
2405         node = node->Next();
2406     }
2407     m_lines.Clear();
2408     m_current = (wxListLineData *) NULL;
2409     m_columns.Clear();
2410 }
2411
2412 void wxListMainWindow::EnsureVisible( long index )
2413 {
2414     // We have to call this here because the label in
2415     // question might just have been added and no screen
2416     // update taken place.
2417     if (m_dirty) wxYield();
2418
2419     wxListLineData *oldCurrent = m_current;
2420     m_current = (wxListLineData *) NULL;
2421     wxNode *node = m_lines.Nth( (size_t)index );
2422     if (node) m_current = (wxListLineData*)node->Data();
2423     if (m_current) MoveToFocus();
2424     m_current = oldCurrent;
2425 }
2426
2427 long wxListMainWindow::FindItem(long start, const wxString& str, bool WXUNUSED(partial) )
2428 {
2429     long pos = start;
2430     wxString tmp = str;
2431     if (pos < 0) pos = 0;
2432     wxNode *node = m_lines.Nth( (size_t)pos );
2433     while (node)
2434     {
2435         wxListLineData *line = (wxListLineData*)node->Data();
2436         wxString s = "";
2437         line->GetText( 0, s );
2438         if (s == tmp) return pos;
2439         node = node->Next();
2440         pos++;
2441     }
2442     return -1;
2443 }
2444
2445 long wxListMainWindow::FindItem(long start, long data)
2446 {
2447     long pos = start;
2448     if (pos < 0) pos = 0;
2449     wxNode *node = m_lines.Nth( (size_t)pos );
2450     while (node)
2451     {
2452         wxListLineData *line = (wxListLineData*)node->Data();
2453         wxListItem item;
2454         line->GetItem( 0, item );
2455         if (item.m_data == data) return pos;
2456         node = node->Next();
2457         pos++;
2458     }
2459     return -1;
2460 }
2461
2462 long wxListMainWindow::HitTest( int x, int y, int &flags )
2463 {
2464     wxNode *node = m_lines.First();
2465     int count = 0;
2466     while (node)
2467     {
2468         wxListLineData *line = (wxListLineData*)node->Data();
2469         long ret = line->IsHit( x, y );
2470         if (ret & flags)
2471         {
2472             flags = (int)ret;
2473             return count;
2474         }
2475         node = node->Next();
2476         count++;
2477     }
2478     return -1;
2479 }
2480
2481 void wxListMainWindow::InsertItem( wxListItem &item )
2482 {
2483     m_dirty = TRUE;
2484     int mode = 0;
2485     if (m_mode & wxLC_REPORT) mode = wxLC_REPORT;
2486     else if (m_mode & wxLC_LIST) mode = wxLC_LIST;
2487     else if (m_mode & wxLC_ICON) mode = wxLC_ICON;
2488     else if (m_mode & wxLC_SMALL_ICON) mode = wxLC_ICON;  // no typo
2489
2490     wxListLineData *line = new wxListLineData( this, mode, m_hilightBrush );
2491
2492     if (m_mode & wxLC_REPORT)
2493     {
2494         line->InitItems( GetColumnCount() );
2495         item.m_width = GetColumnWidth( 0 )-3;
2496     }
2497     else
2498     {
2499         line->InitItems( 1 );
2500     }
2501
2502     line->SetItem( 0, item );
2503     if ((item.m_itemId >= 0) && (item.m_itemId < (int)m_lines.GetCount()))
2504     {
2505         wxNode *node = m_lines.Nth( (size_t)item.m_itemId );
2506         if (node) m_lines.Insert( node, line );
2507     }
2508     else
2509     {
2510         m_lines.Append( line );
2511     }
2512 }
2513
2514 void wxListMainWindow::InsertColumn( long col, wxListItem &item )
2515 {
2516     m_dirty = TRUE;
2517     if (m_mode & wxLC_REPORT)
2518     {
2519         if (item.m_width == wxLIST_AUTOSIZE_USEHEADER) item.m_width = GetTextLength( item.m_text );
2520         wxListHeaderData *column = new wxListHeaderData( item );
2521         if ((col >= 0) && (col < (int)m_columns.GetCount()))
2522         {
2523             wxNode *node = m_columns.Nth( (size_t)col );
2524             if (node)
2525                  m_columns.Insert( node, column );
2526         }
2527         else
2528         {
2529             m_columns.Append( column );
2530         }
2531     }
2532 }
2533
2534 wxListCtrlCompare list_ctrl_compare_func_2;
2535 long              list_ctrl_compare_data;
2536
2537 int LINKAGEMODE list_ctrl_compare_func_1( const void *arg1, const void *arg2 )
2538 {
2539     wxListLineData *line1 = *((wxListLineData**)arg1);
2540     wxListLineData *line2 = *((wxListLineData**)arg2);
2541     wxListItem item;
2542     line1->GetItem( 0, item );
2543     long data1 = item.m_data;
2544     line2->GetItem( 0, item );
2545     long data2 = item.m_data;
2546     return list_ctrl_compare_func_2( data1, data2, list_ctrl_compare_data );
2547 }
2548
2549 void wxListMainWindow::SortItems( wxListCtrlCompare fn, long data )
2550 {
2551     list_ctrl_compare_func_2 = fn;
2552     list_ctrl_compare_data = data;
2553     m_lines.Sort( list_ctrl_compare_func_1 );
2554 }
2555
2556 void wxListMainWindow::OnScroll(wxScrollWinEvent& event)
2557 {
2558         wxScrolledWindow::OnScroll( event ) ;
2559 #if wxUSE_GENERIC_LIST_EXTENSIONS
2560
2561     if (event.GetOrientation() == wxHORIZONTAL && ( m_mode & wxLC_REPORT ))
2562     {
2563             wxListCtrl* lc = wxDynamicCast( GetParent() , wxListCtrl ) ;
2564             if ( lc )
2565             {
2566                     lc->m_headerWin->Refresh() ;
2567 #ifdef __WXMAC__
2568                         lc->m_headerWin->MacUpdateImmediately() ;
2569 #endif
2570             }
2571     }
2572 #endif
2573 }
2574
2575 // -------------------------------------------------------------------------------------
2576 // wxListItem
2577 // -------------------------------------------------------------------------------------
2578
2579 IMPLEMENT_DYNAMIC_CLASS(wxListItem, wxObject)
2580
2581 wxListItem::wxListItem()
2582 {
2583     m_mask = 0;
2584     m_itemId = 0;
2585     m_col = 0;
2586     m_state = 0;
2587     m_stateMask = 0;
2588     m_image = 0;
2589     m_data = 0;
2590     m_format = wxLIST_FORMAT_CENTRE;
2591     m_width = 0;
2592
2593     m_attr = NULL;
2594 }
2595
2596 void wxListItem::Clear()
2597 {
2598     m_mask = 0;
2599     m_itemId = 0;
2600     m_col = 0;
2601     m_state = 0;
2602     m_stateMask = 0;
2603     m_image = 0;
2604     m_data = 0;
2605     m_format = wxLIST_FORMAT_CENTRE;
2606     m_width = 0;
2607     m_text = wxEmptyString;
2608
2609     if (m_attr) delete m_attr;
2610     m_attr = NULL;
2611 }
2612
2613 void wxListItem::ClearAttributes()
2614 {
2615     if (m_attr) delete m_attr;
2616     m_attr = NULL;
2617 }
2618
2619 // -------------------------------------------------------------------------------------
2620 // wxListEvent
2621 // -------------------------------------------------------------------------------------
2622
2623 IMPLEMENT_DYNAMIC_CLASS(wxListEvent, wxNotifyEvent)
2624
2625 wxListEvent::wxListEvent( wxEventType commandType, int id ):
2626   wxNotifyEvent( commandType, id )
2627 {
2628     m_code = 0;
2629     m_itemIndex = 0;
2630     m_oldItemIndex = 0;
2631     m_col = 0;
2632     m_cancelled = FALSE;
2633     m_pointDrag.x = 0;
2634     m_pointDrag.y = 0;
2635 }
2636
2637 void wxListEvent::CopyObject(wxObject& object_dest) const
2638 {
2639     wxListEvent *obj = (wxListEvent *)&object_dest;
2640
2641     wxNotifyEvent::CopyObject(object_dest);
2642
2643     obj->m_code = m_code;
2644     obj->m_itemIndex = m_itemIndex;
2645     obj->m_oldItemIndex = m_oldItemIndex;
2646     obj->m_col = m_col;
2647     obj->m_cancelled = m_cancelled;
2648     obj->m_pointDrag = m_pointDrag;
2649     obj->m_item.m_mask = m_item.m_mask;
2650     obj->m_item.m_itemId = m_item.m_itemId;
2651     obj->m_item.m_col = m_item.m_col;
2652     obj->m_item.m_state = m_item.m_state;
2653     obj->m_item.m_stateMask = m_item.m_stateMask;
2654     obj->m_item.m_text = m_item.m_text;
2655     obj->m_item.m_image = m_item.m_image;
2656     obj->m_item.m_data = m_item.m_data;
2657     obj->m_item.m_format = m_item.m_format;
2658     obj->m_item.m_width = m_item.m_width;
2659
2660     if ( m_item.HasAttributes() )
2661     {
2662         obj->m_item.SetTextColour(m_item.GetTextColour());
2663     }
2664 }
2665
2666 // -------------------------------------------------------------------------------------
2667 // wxListCtrl
2668 // -------------------------------------------------------------------------------------
2669
2670 IMPLEMENT_DYNAMIC_CLASS(wxListCtrl, wxControl)
2671
2672 BEGIN_EVENT_TABLE(wxListCtrl,wxControl)
2673   EVT_SIZE          (wxListCtrl::OnSize)
2674   EVT_IDLE          (wxListCtrl::OnIdle)
2675 END_EVENT_TABLE()
2676
2677 wxListCtrl::wxListCtrl()
2678 {
2679     m_imageListNormal = (wxImageList *) NULL;
2680     m_imageListSmall = (wxImageList *) NULL;
2681     m_imageListState = (wxImageList *) NULL;
2682     m_mainWin = (wxListMainWindow*) NULL;
2683     m_headerWin = (wxListHeaderWindow*) NULL;
2684 }
2685
2686 wxListCtrl::~wxListCtrl()
2687 {
2688 }
2689
2690 bool wxListCtrl::Create(wxWindow *parent,
2691                         wxWindowID id,
2692                         const wxPoint &pos,
2693                         const wxSize &size,
2694                         long style,
2695                         const wxValidator &validator,
2696                         const wxString &name)
2697 {
2698     m_imageListNormal = (wxImageList *) NULL;
2699     m_imageListSmall = (wxImageList *) NULL;
2700     m_imageListState = (wxImageList *) NULL;
2701     m_mainWin = (wxListMainWindow*) NULL;
2702     m_headerWin = (wxListHeaderWindow*) NULL;
2703
2704     if ( !(style & (wxLC_REPORT | wxLC_LIST | wxLC_ICON)) )
2705     {
2706         style = style | wxLC_LIST;
2707     }
2708
2709     bool ret = wxControl::Create( parent, id, pos, size, style, validator, name );
2710
2711
2712     if (style & wxSUNKEN_BORDER)
2713         style -= wxSUNKEN_BORDER;
2714
2715     m_mainWin = new wxListMainWindow( this, -1, wxPoint(0,0), size, style );
2716
2717     if (HasFlag(wxLC_REPORT))
2718     {
2719         m_headerWin = new wxListHeaderWindow( this, -1, m_mainWin, wxPoint(0,0), wxSize(size.x,23), wxTAB_TRAVERSAL );
2720         if (HasFlag(wxLC_NO_HEADER))
2721             m_headerWin->Show( FALSE );
2722     }
2723     else
2724     {
2725         m_headerWin = (wxListHeaderWindow *) NULL;
2726     }
2727
2728     SetBackgroundColour( *wxWHITE );
2729
2730     return ret;
2731 }
2732
2733 void wxListCtrl::OnSize( wxSizeEvent &WXUNUSED(event) )
2734 {
2735     /* handled in OnIdle */
2736
2737     if (m_mainWin) m_mainWin->m_dirty = TRUE;
2738 }
2739
2740 void wxListCtrl::SetSingleStyle( long style, bool add )
2741 {
2742     long flag = GetWindowStyle();
2743
2744     if (add)
2745     {
2746         if (style & wxLC_MASK_TYPE)  flag = flag & ~wxLC_MASK_TYPE;
2747         if (style & wxLC_MASK_ALIGN) flag = flag & ~wxLC_MASK_ALIGN;
2748         if (style & wxLC_MASK_SORT) flag = flag & ~wxLC_MASK_SORT;
2749     }
2750
2751     if (add)
2752     {
2753         flag |= style;
2754     }
2755     else
2756     {
2757         if (flag & style) flag -= style;
2758     }
2759
2760     SetWindowStyleFlag( flag );
2761 }
2762
2763 void wxListCtrl::SetWindowStyleFlag( long flag )
2764 {
2765     if (m_mainWin)
2766     {
2767         m_mainWin->DeleteEverything();
2768
2769         int width = 0;
2770         int height = 0;
2771         GetClientSize( &width, &height );
2772
2773         m_mainWin->SetMode( flag );
2774
2775         if (flag & wxLC_REPORT)
2776         {
2777             if (!HasFlag(wxLC_REPORT))
2778             {
2779                 if (!m_headerWin)
2780                 {
2781                     m_headerWin = new wxListHeaderWindow( this, -1, m_mainWin,
2782                       wxPoint(0,0), wxSize(width,23), wxTAB_TRAVERSAL );
2783                     if (HasFlag(wxLC_NO_HEADER))
2784                         m_headerWin->Show( FALSE );
2785                 }
2786                 else
2787                 {
2788                     if (flag & wxLC_NO_HEADER)
2789                         m_headerWin->Show( FALSE );
2790                     else
2791                         m_headerWin->Show( TRUE );
2792                 }
2793             }
2794         }
2795         else
2796         {
2797             if (HasFlag(wxLC_REPORT) && !(HasFlag(wxLC_NO_HEADER)))
2798             {
2799                 m_headerWin->Show( FALSE );
2800             }
2801         }
2802     }
2803
2804     wxWindow::SetWindowStyleFlag( flag );
2805 }
2806
2807 bool wxListCtrl::GetColumn(int col, wxListItem &item) const
2808 {
2809     m_mainWin->GetColumn( col, item );
2810     return TRUE;
2811 }
2812
2813 bool wxListCtrl::SetColumn( int col, wxListItem& item )
2814 {
2815     m_mainWin->SetColumn( col, item );
2816     return TRUE;
2817 }
2818
2819 int wxListCtrl::GetColumnWidth( int col ) const
2820 {
2821     return m_mainWin->GetColumnWidth( col );
2822 }
2823
2824 bool wxListCtrl::SetColumnWidth( int col, int width )
2825 {
2826     m_mainWin->SetColumnWidth( col, width );
2827     return TRUE;
2828 }
2829
2830 int wxListCtrl::GetCountPerPage() const
2831 {
2832   return m_mainWin->GetCountPerPage();  // different from Windows ?
2833 }
2834
2835 bool wxListCtrl::GetItem( wxListItem &info ) const
2836 {
2837     m_mainWin->GetItem( info );
2838     return TRUE;
2839 }
2840
2841 bool wxListCtrl::SetItem( wxListItem &info )
2842 {
2843     m_mainWin->SetItem( info );
2844     return TRUE;
2845 }
2846
2847 long wxListCtrl::SetItem( long index, int col, const wxString& label, int imageId )
2848 {
2849     wxListItem info;
2850     info.m_text = label;
2851     info.m_mask = wxLIST_MASK_TEXT;
2852     info.m_itemId = index;
2853     info.m_col = col;
2854     if ( imageId > -1 )
2855     {
2856         info.m_image = imageId;
2857         info.m_mask |= wxLIST_MASK_IMAGE;
2858     };
2859     m_mainWin->SetItem(info);
2860     return TRUE;
2861 }
2862
2863 int wxListCtrl::GetItemState( long item, long stateMask ) const
2864 {
2865     return m_mainWin->GetItemState( item, stateMask );
2866 }
2867
2868 bool wxListCtrl::SetItemState( long item, long state, long stateMask )
2869 {
2870     m_mainWin->SetItemState( item, state, stateMask );
2871     return TRUE;
2872 }
2873
2874 bool wxListCtrl::SetItemImage( long item, int image, int WXUNUSED(selImage) )
2875 {
2876     wxListItem info;
2877     info.m_image = image;
2878     info.m_mask = wxLIST_MASK_IMAGE;
2879     info.m_itemId = item;
2880     m_mainWin->SetItem( info );
2881     return TRUE;
2882 }
2883
2884 wxString wxListCtrl::GetItemText( long item ) const
2885 {
2886     wxListItem info;
2887     info.m_itemId = item;
2888     m_mainWin->GetItem( info );
2889     return info.m_text;
2890 }
2891
2892 void wxListCtrl::SetItemText( long item, const wxString &str )
2893 {
2894     wxListItem info;
2895     info.m_mask = wxLIST_MASK_TEXT;
2896     info.m_itemId = item;
2897     info.m_text = str;
2898     m_mainWin->SetItem( info );
2899 }
2900
2901 long wxListCtrl::GetItemData( long item ) const
2902 {
2903     wxListItem info;
2904     info.m_itemId = item;
2905     m_mainWin->GetItem( info );
2906     return info.m_data;
2907 }
2908
2909 bool wxListCtrl::SetItemData( long item, long data )
2910 {
2911     wxListItem info;
2912     info.m_mask = wxLIST_MASK_DATA;
2913     info.m_itemId = item;
2914     info.m_data = data;
2915     m_mainWin->SetItem( info );
2916     return TRUE;
2917 }
2918
2919 bool wxListCtrl::GetItemRect( long item, wxRect &rect,  int WXUNUSED(code) ) const
2920 {
2921     m_mainWin->GetItemRect( item, rect );
2922     return TRUE;
2923 }
2924
2925 bool wxListCtrl::GetItemPosition( long item, wxPoint& pos ) const
2926 {
2927     m_mainWin->GetItemPosition( item, pos );
2928     return TRUE;
2929 }
2930
2931 bool wxListCtrl::SetItemPosition( long WXUNUSED(item), const wxPoint& WXUNUSED(pos) )
2932 {
2933     return 0;
2934 }
2935
2936 int wxListCtrl::GetItemCount() const
2937 {
2938     return m_mainWin->GetItemCount();
2939 }
2940
2941 int wxListCtrl::GetColumnCount() const
2942 {
2943     return m_mainWin->GetColumnCount();
2944 }
2945
2946 void wxListCtrl::SetItemSpacing( int spacing, bool isSmall )
2947 {
2948     m_mainWin->SetItemSpacing( spacing, isSmall );
2949 }
2950
2951 int wxListCtrl::GetItemSpacing( bool isSmall ) const
2952 {
2953     return m_mainWin->GetItemSpacing( isSmall );
2954 }
2955
2956 int wxListCtrl::GetSelectedItemCount() const
2957 {
2958     return m_mainWin->GetSelectedItemCount();
2959 }
2960
2961 wxColour wxListCtrl::GetTextColour() const
2962 {
2963     return GetForegroundColour();
2964 }
2965
2966 void wxListCtrl::SetTextColour(const wxColour& col)
2967 {
2968     SetForegroundColour(col);
2969 }
2970
2971 long wxListCtrl::GetTopItem() const
2972 {
2973     return 0;
2974 }
2975
2976 long wxListCtrl::GetNextItem( long item, int geom, int state ) const
2977 {
2978     return m_mainWin->GetNextItem( item, geom, state );
2979 }
2980
2981 wxImageList *wxListCtrl::GetImageList(int which) const
2982 {
2983     if (which == wxIMAGE_LIST_NORMAL)
2984     {
2985         return m_imageListNormal;
2986     }
2987     else if (which == wxIMAGE_LIST_SMALL)
2988     {
2989         return m_imageListSmall;
2990     }
2991     else if (which == wxIMAGE_LIST_STATE)
2992     {
2993         return m_imageListState;
2994     }
2995     return (wxImageList *) NULL;
2996 }
2997
2998 void wxListCtrl::SetImageList( wxImageList *imageList, int which )
2999 {
3000     m_mainWin->SetImageList( imageList, which );
3001 }
3002
3003 bool wxListCtrl::Arrange( int WXUNUSED(flag) )
3004 {
3005     return 0;
3006 }
3007
3008 bool wxListCtrl::DeleteItem( long item )
3009 {
3010     m_mainWin->DeleteItem( item );
3011     return TRUE;
3012 }
3013
3014 bool wxListCtrl::DeleteAllItems()
3015 {
3016     m_mainWin->DeleteAllItems();
3017     return TRUE;
3018 }
3019
3020 bool wxListCtrl::DeleteAllColumns()
3021 {
3022     for ( size_t n = 0; n < m_mainWin->m_columns.GetCount(); n++ )
3023         DeleteColumn(n);
3024
3025     return TRUE;
3026 }
3027
3028 void wxListCtrl::ClearAll()
3029 {
3030     m_mainWin->DeleteEverything();
3031 }
3032
3033 bool wxListCtrl::DeleteColumn( int col )
3034 {
3035     m_mainWin->DeleteColumn( col );
3036     return TRUE;
3037 }
3038
3039 void wxListCtrl::Edit( long item )
3040 {
3041     m_mainWin->Edit( item );
3042 }
3043
3044 bool wxListCtrl::EnsureVisible( long item )
3045 {
3046     m_mainWin->EnsureVisible( item );
3047     return TRUE;
3048 }
3049
3050 long wxListCtrl::FindItem( long start, const wxString& str,  bool partial )
3051 {
3052     return m_mainWin->FindItem( start, str, partial );
3053 }
3054
3055 long wxListCtrl::FindItem( long start, long data )
3056 {
3057     return m_mainWin->FindItem( start, data );
3058 }
3059
3060 long wxListCtrl::FindItem( long WXUNUSED(start), const wxPoint& WXUNUSED(pt),
3061                            int WXUNUSED(direction))
3062 {
3063     return 0;
3064 }
3065
3066 long wxListCtrl::HitTest( const wxPoint &point, int &flags )
3067 {
3068     return m_mainWin->HitTest( (int)point.x, (int)point.y, flags );
3069 }
3070
3071 long wxListCtrl::InsertItem( wxListItem& info )
3072 {
3073     m_mainWin->InsertItem( info );
3074     return info.m_itemId;
3075 }
3076
3077 long wxListCtrl::InsertItem( long index, const wxString &label )
3078 {
3079     wxListItem info;
3080     info.m_text = label;
3081     info.m_mask = wxLIST_MASK_TEXT;
3082     info.m_itemId = index;
3083     return InsertItem( info );
3084 }
3085
3086 long wxListCtrl::InsertItem( long index, int imageIndex )
3087 {
3088     wxListItem info;
3089     info.m_mask = wxLIST_MASK_IMAGE;
3090     info.m_image = imageIndex;
3091     info.m_itemId = index;
3092     return InsertItem( info );
3093 }
3094
3095 long wxListCtrl::InsertItem( long index, const wxString &label, int imageIndex )
3096 {
3097     wxListItem info;
3098     info.m_text = label;
3099     info.m_image = imageIndex;
3100     info.m_mask = wxLIST_MASK_TEXT | wxLIST_MASK_IMAGE;
3101     info.m_itemId = index;
3102     return InsertItem( info );
3103 }
3104
3105 long wxListCtrl::InsertColumn( long col, wxListItem &item )
3106 {
3107     wxASSERT( m_headerWin );
3108     m_mainWin->InsertColumn( col, item );
3109     m_headerWin->Refresh();
3110
3111     return 0;
3112 }
3113
3114 long wxListCtrl::InsertColumn( long col, const wxString &heading,
3115                                int format, int width )
3116 {
3117     wxListItem item;
3118     item.m_mask = wxLIST_MASK_TEXT | wxLIST_MASK_FORMAT;
3119     item.m_text = heading;
3120     if (width >= -2)
3121     {
3122         item.m_mask |= wxLIST_MASK_WIDTH;
3123         item.m_width = width;
3124     }
3125     item.m_format = format;
3126
3127     return InsertColumn( col, item );
3128 }
3129
3130 bool wxListCtrl::ScrollList( int WXUNUSED(dx), int WXUNUSED(dy) )
3131 {
3132     return 0;
3133 }
3134
3135 // Sort items.
3136 // fn is a function which takes 3 long arguments: item1, item2, data.
3137 // item1 is the long data associated with a first item (NOT the index).
3138 // item2 is the long data associated with a second item (NOT the index).
3139 // data is the same value as passed to SortItems.
3140 // The return value is a negative number if the first item should precede the second
3141 // item, a positive number of the second item should precede the first,
3142 // or zero if the two items are equivalent.
3143 // data is arbitrary data to be passed to the sort function.
3144
3145 bool wxListCtrl::SortItems( wxListCtrlCompare fn, long data )
3146 {
3147     m_mainWin->SortItems( fn, data );
3148     return TRUE;
3149 }
3150
3151 void wxListCtrl::OnIdle( wxIdleEvent &WXUNUSED(event) )
3152 {
3153     if (!m_mainWin->m_dirty) return;
3154
3155     int cw = 0;
3156     int ch = 0;
3157     GetClientSize( &cw, &ch );
3158
3159     int x = 0;
3160     int y = 0;
3161     int w = 0;
3162     int h = 0;
3163
3164     if (HasFlag(wxLC_REPORT) && !HasFlag(wxLC_NO_HEADER))
3165     {
3166         m_headerWin->GetPosition( &x, &y );
3167         m_headerWin->GetSize( &w, &h );
3168         if ((x != 0) || (y != 0) || (w != cw) || (h != 23))
3169             m_headerWin->SetSize( 0, 0, cw, 23 );
3170
3171         m_mainWin->GetPosition( &x, &y );
3172         m_mainWin->GetSize( &w, &h );
3173         if ((x != 0) || (y != 24) || (w != cw) || (h != ch-24))
3174             m_mainWin->SetSize( 0, 24, cw, ch-24 );
3175     }
3176     else
3177     {
3178         m_mainWin->GetPosition( &x, &y );
3179         m_mainWin->GetSize( &w, &h );
3180         if ((x != 0) || (y != 24) || (w != cw) || (h != ch))
3181             m_mainWin->SetSize( 0, 0, cw, ch );
3182     }
3183
3184     m_mainWin->CalculatePositions();
3185     m_mainWin->RealizeChanges();
3186     m_mainWin->m_dirty = FALSE;
3187     m_mainWin->Refresh();
3188 }
3189
3190 bool wxListCtrl::SetBackgroundColour( const wxColour &colour )
3191 {
3192     if ( !wxWindow::SetBackgroundColour( colour ) )
3193         return FALSE;
3194
3195     if (m_mainWin)
3196     {
3197         m_mainWin->SetBackgroundColour( colour );
3198         m_mainWin->m_dirty = TRUE;
3199     }
3200
3201     if (m_headerWin)
3202     {
3203 //        m_headerWin->SetBackgroundColour( colour );
3204     }
3205
3206     return TRUE;
3207 }
3208
3209 bool wxListCtrl::SetForegroundColour( const wxColour &colour )
3210 {
3211     if ( !wxWindow::SetForegroundColour( colour ) )
3212         return FALSE;
3213
3214     if (m_mainWin)
3215     {
3216         m_mainWin->SetForegroundColour( colour );
3217         m_mainWin->m_dirty = TRUE;
3218     }
3219
3220     if (m_headerWin)
3221     {
3222         m_headerWin->SetForegroundColour( colour );
3223     }
3224
3225     return TRUE;
3226 }
3227
3228 bool wxListCtrl::SetFont( const wxFont &font )
3229 {
3230     if ( !wxWindow::SetFont( font ) )
3231         return FALSE;
3232
3233     if (m_mainWin)
3234     {
3235         m_mainWin->SetFont( font );
3236         m_mainWin->m_dirty = TRUE;
3237     }
3238
3239     if (m_headerWin)
3240     {
3241         m_headerWin->SetFont( font );
3242     }
3243
3244     return TRUE;
3245 }
3246