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