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