PageRenderTime 54ms CodeModel.GetById 31ms RepoModel.GetById 0ms app.codeStats 2ms

/ObjectListView/ObjectListView.cs

https://bitbucket.org/BlueRaja/starbank
C# | 9075 lines | 4805 code | 980 blank | 3290 comment | 1146 complexity | e2e03e0bad28347f094bdfcc5b9c1412 MD5 | raw file
    

  1. /*

    2. 

  2.  * ObjectListView - A listview to show various aspects of a collection of objects

    3. 

  3.  *

    4. 

  4.  * Author: Phillip Piper

    5. 

  5.  * Date: 9/10/2006 11:15 AM

    6. 

  6.  *

    7. 

  7.  * Change log

    8. 

  8.  * 2011-05-31  JPP  - SelectObject() and SelectObjects() no longer deselect all other rows.

    9. 

  9.                       Set the SelectedObject or SelectedObjects property to do that.

    10. 

  10.  *                  - Added CheckedObjectsEnumerable

    11. 

  11.  *                  - Made setting CheckedObjects more efficient on large collections

    12. 

  12.  *                  - Deprecated GetSelectedObject() and GetSelectedObjects()

    13. 

  13.  * 2011-04-25  JPP  - Added SubItemChecking event

    14. 

  14.  *                  - Fixed bug in handling of NewValue on CellEditFinishing event

    15. 

  15.  * 2011-04-12  JPP  - Added UseFilterIndicator 

    16. 

  16.  *                  - Added some more localizable messages

    17. 

  17.  * 2011-04-10  JPP  - FormatCellEventArgs now has a CellValue property, which is the model value displayed

    18. 

  18.  *                    by the cell. For example, for the Birthday column, the CellValue might be 

    19. 

  19.  *                    DateTime(1980, 12, 31), whereas the cell's text might be 'Dec 31, 1980'.

    20. 

  20.  * 2011-04-04  JPP  - Tweaked UseTranslucentSelection and UseTranslucentHotItem to look (a little) more

    21. 

  21.  *                    like Vista/Win7.

    22. 

  22.  *                  - Alternate colours are now only applied in Details view (as they always should have been)

    23. 

  23.  *                  - Alternate colours are now correctly recalculated after removing objects

    24. 

  24.  * 2011-03-29  JPP  - Added SelectColumnsOnRightClickBehaviour to allow the selecting of columns mechanism 

    25. 

  25.  *                    to be changed. Can now be InlineMenu (the default), SubMenu, or ModelDialog.

    26. 

  26.  *                  - ColumnSelectionForm was moved from the demo into the ObjectListView project itself.

    27. 

  27.  *                  - Ctrl-C copying is now able to use the DragSource to create the data transfer object.

    28. 

  28.  * 2011-03-19  JPP  - All model object comparisons now use Equals rather than == (thanks to vulkanino)

    29. 

  29.  *                  - [Small Break] GetNextItem() and GetPreviousItem() now accept and return OLVListView

    30. 

  30.  *                    rather than ListViewItems.

    31. 

  31.  * 2011-03-07  JPP  - [Big] Added Excel-style filtering. Right click on a header to show a Filtering menu.

    32. 

  32.  *                  - Added CellEditKeyEngine to allow key handling when cell editing to be completely customised.

    33. 

  33.  *                    Add CellEditTabChangesRows and CellEditEnterChangesRows to show some of these abilities.

    34. 

  34.  * 2011-03-06  JPP  - Added OLVColumn.AutoCompleteEditorMode in preference to AutoCompleteEditor 

    35. 

  35.  *                    (which is now just a wrapper). Thanks to Clive Haskins 

    36. 

  36.  *                  - Added lots of docs to new classes

    37. 

  37.  * 2011-02-25  JPP  - Preserve word wrap settings on TreeListView

    38. 

  38.  *                  - Resize last group to keep it on screen (thanks to ?)

    39. 

  39.  * 2010-11-16  JPP  - Fixed (once and for all) DisplayIndex problem with Generator

    40. 

  40.  *                  - Changed the serializer used in SaveState()/RestoreState() so that it resolves on

    41. 

  41.  *                    class name alone.

    42. 

  42.  *                  - Fixed bug in GroupWithItemCountSingularFormatOrDefault

    43. 

  43.  *                  - Fixed strange flickering in grouped, owner drawn OLV's using RefreshObject()

    44. 

  44.  * v2.4.1

    45. 

  45.  * 2010-08-25  JPP  - Fixed bug where setting OLVColumn.CheckBoxes to false gave it a renderer

    46. 

  46.  *                    specialized for checkboxes. Oddly, this made Generator created owner drawn

    47. 

  47.  *                    lists appear to be completely empty.

    48. 

  48.  *                  - In IDE, all ObjectListView properties are now in a single "ObjectListView" category,

    49. 

  49.  *                    rather than splitting them between "Appearance" and "Behavior" categories.

    50. 

  50.  *                  - Added GroupingParameters.GroupComparer to allow groups to be sorted in a customizable fashion.

    51. 

  51.  *                  - Sorting of items within a group can be disabled by setting 

    52. 

  52.  *                    GroupingParameters.PrimarySortOrder to None.

    53. 

  53.  * 2010-08-24  JPP  - Added OLVColumn.IsHeaderVertical to make a column draw its header vertical.

    54. 

  54.  *                  - Added OLVColumn.HeaderTextAlign to control the alignment of a column's header text.

    55. 

  55.  *                  - Added HeaderMaximumHeight to limit how tall the header section can become

    56. 

  56.  * 2010-08-18  JPP  - Fixed long standing bug where having 0 columns caused a InvalidCast exception.

    57. 

  57.  *                  - Added IncludeAllColumnsInDataObject property

    58. 

  58.  *                  - Improved BuildList(bool) so that it preserves scroll position even when

    59. 

  59.  *                    the listview is grouped.

    60. 

  60.  * 2010-08-08  JPP  - Added OLVColumn.HeaderImageKey to allow column headers to have an image.

    61. 

  61.  *                  - CellEdit validation and finish events now have NewValue property.

    62. 

  62.  * 2010-08-03  JPP  - Subitem checkboxes improvments: obey IsEditable, can be hot, can be disabled.

    63. 

  63.  *                  - No more flickering of selection when tabbing between cells

    64. 

  64.  *                  - Added EditingCellBorderDecoration to make it clearer which cell is being edited.

    65. 

  65.  * 2010-08-01  JPP  - Added ObjectListView.SmoothingMode to control the smoothing of all graphics

    66. 

  66.  *                    operations

    67. 

  67.  *                  - Columns now cache their group item format strings so that they still work as 

    68. 

  68.  *                    grouping columns after they have been removed from the listview. This cached

    69. 

  69.  *                    value is only used when the column is not part of the listview.

    70. 

  70.  * 2010-07-25  JPP  - Correctly trigger a Click event when the mouse is clicked.

    71. 

  71.  * 2010-07-16  JPP  - Invalidate the control before and after cell editing to make sure it looks right

    72. 

  72.  * 2010-06-23  JPP  - Right mouse clicks on checkboxes no longer confuse them

    73. 

  73.  * 2010-06-21  JPP  - Avoid bug in underlying ListView control where virtual lists in SmallIcon view

    74. 

  74.  *                    generate GETTOOLINFO msgs with invalid item indicies.

    75. 

  75.  *                  - Fixed bug where FastObjectListView would throw an exception when showing hyperlinks

    76. 

  76.  *                    in any view except Details.

    77. 

  77.  * 2010-06-15  JPP  - Fixed bug in ChangeToFilteredColumns() that resulted in column display order

    78. 

  78.  *                    being lost when a column was hidden.

    79. 

  79.  *                  - Renamed IsVista property to IsVistaOrLater which more accurately describes its function.

    80. 

  80.  * v2.4

    81. 

  81.  * 2010-04-14  JPP  - Prevent object disposed errors when mouse event handlers cause the

    82. 

  82.  *                    ObjectListView to be destroyed (e.g. closing a form during a 

    83. 

  83.  *                    double click event).

    84. 

  84.  *                  - Avoid checkbox munging bug in standard ListView when shift clicking on non-primary

    85. 

  85.  *                    columns when FullRowSelect is true.

    86. 

  86.  * 2010-04-12  JPP  - Fixed bug in group sorting (thanks Mike).

    87. 

  87.  * 2010-04-07  JPP  - Prevent hyperlink processing from triggering spurious MouseUp events.

    88. 

  88.  *                    This showed itself by launching the same url multiple times.

    89. 

  89.  * 2010-04-06  JPP  - Space filling columns correctly resize upon initial display

    90. 

  90.  *                  - ShowHeaderInAllViews is better but still not working reliably.

    91. 

  91.  *                    See comments on property for more details.

    92. 

  92.  * 2010-03-23  JPP  - Added ObjectListView.HeaderFormatStyle and OLVColumn.HeaderFormatStyle.

    93. 

  93.  *                    This makes HeaderFont and HeaderForeColor properties unnecessary -- 

    94. 

  94.  *                    they will be marked obsolete in the next version and removed after that.

    95. 

  95.  * 2010-03-16  JPP  - Changed object checking so that objects can be pre-checked before they

    96. 

  96.  *                    are added to the list. Normal ObjectListViews managed "checkedness" in

    97. 

  97.  *                    the ListViewItem, so this won't work for them, unless check state getters

    98. 

  98.  *                    and putters have been installed. It will work on on virtual lists (thus fast lists and

    99. 

  99.  *                    tree views) since they manage their own check state.

    100. 

  100.  * 2010-03-06  JPP  - Hide "Items" and "Groups" from the IDE properties grid since they shouldn't be set like that.

    101. 

  101.  *                    They can still be accessed through "Custom Commands" and there's nothing we can do

    102. 

  102.  *                    about that.

    103. 

  103.  * 2010-03-05  JPP  - Added filtering

    104. 

  104.  * 2010-01-18  JPP  - Overlays can be turned off. They also only work on 32-bit displays

    105. 

  105.  * v2.3

    106. 

  106.  * 2009-10-30  JPP  - Plugged possible resource leak by using using() with CreateGraphics()

    107. 

  107.  * 2009-10-28  JPP  - Fix bug when right clicking in the empty area of the header

    108. 

  108.  * 2009-10-20  JPP  - Redraw the control after setting EmptyListMsg property

    109. 

  109.  * v2.3

    110. 

  110.  * 2009-09-30  JPP  - Added Dispose() method to properly release resources

    111. 

  111.  * 2009-09-16  JPP  - Added OwnerDrawnHeader, which you can set to true if you want to owner draw

    112. 

  112.  *                    the header yourself.

    113. 

  113.  * 2009-09-15  JPP  - Added UseExplorerTheme, which allow complete visual compliance with Vista explorer.

    114. 

  114.  *                    But see property documentation for its many limitations.

    115. 

  115.  *                  - Added ShowHeaderInAllViews. To make this work, Columns are no longer

    116. 

  116.  *                    changed when switching to/from Tile view.

    117. 

  117.  * 2009-09-11  JPP  - Added OLVColumn.AutoCompleteEditor to allow the autocomplete of cell editors

    118. 

  118.  *                    to be disabled.

    119. 

  119.  * 2009-09-01  JPP  - Added ObjectListView.TextRenderingHint property which controls the

    120. 

  120.  *                    text rendering hint of all drawn text.

    121. 

  121.  * 2009-08-28  JPP  - [BIG] Added group formatting to supercharge what is possible with groups

    122. 

  122.  *                  - [BIG] Virtual groups now work

    123. 

  123.  *                  - Extended MakeGroupies() to handle more aspects of group creation

    124. 

  124.  * 2009-08-19  JPP  - Added ability to show basic column commands when header is right clicked

    125. 

  125.  *                  - Added SelectedRowDecoration, UseTranslucentSelection and UseTranslucentHotItem.

    126. 

  126.  *                  - Added PrimarySortColumn and PrimarySortOrder

    127. 

  127.  * 2009-08-15  JPP  - Correct problems with standard hit test and subitems

    128. 

  128.  * 2009-08-14  JPP  - [BIG] Support Decorations

    129. 

  129.  *                  - [BIG] Added header formatting capabilities: font, color, word wrap

    130. 

  130.  *                  - Gave ObjectListView its own designer to hide unwanted properties

    131. 

  131.  *                  - Separated design time stuff into separate file

    132. 

  132.  *                  - Added FormatRow and FormatCell events

    133. 

  133.  * 2009-08-09  JPP  - Get around bug in HitTest when not FullRowSelect

    134. 

  134.  *                  - Added OLVListItem.GetSubItemBounds() method which works correctly

    135. 

  135.  *                    for all columns including column 0

    136. 

  136.  * 2009-08-07  JPP  - Added Hot* properties that track where the mouse is

    137. 

  137.  *                  - Added HotItemChanged event

    138. 

  138.  *                  - Overrode TextAlign on columns so that column 0 can have something other

    139. 

  139.  *                    than just left alignment. This is only honored when owner drawn.

    140. 

  140.  * v2.2.1

    141. 

  141.  * 2009-08-03  JPP  - Subitem edit rectangles always allowed for an image in the cell, even if there was none.

    142. 

  142.  *                    Now they only allow for an image when there actually is one.

    143. 

  143.  *                  - Added Bounds property to OLVListItem which handles items being part of collapsed groups.

    144. 

  144.  * 2009-07-29  JPP  - Added GetSubItem() methods to ObjectListView and OLVListItem

    145. 

  145.  * 2009-07-26  JPP  - Avoided bug in .NET framework involving column 0 of owner drawn listviews not being

    146. 

  146.  *                    redrawn when the listview was scrolled horizontally (this was a LOT of work to track

    147. 

  147.  *                    down and fix!)

    148. 

  148.  *                  - The cell edit rectangle is now correctly calculated when the listview is scrolled

    149. 

  149.  *                    horizontally.

    150. 

  150.  * 2009-07-14  JPP  - If the user clicks/double clicks on a tree list cell, an edit operation will no longer begin

    151. 

  151.  *                    if the click was to the left of the expander. This is implemented in such a way that

    152. 

  152.  *                    other renderers can have similar "dead" zones.

    153. 

  153.  * 2009-07-11  JPP  - CalculateCellBounds() messed with the FullRowSelect property, which confused the

    154. 

  154.  *                    tooltip handling on the underlying control. It no longer does this.

    155. 

  155.  *                  - The cell edit rectangle is now correctly calculated for owner-drawn, non-Details views.

    156. 

  156.  * 2009-07-08  JPP  - Added Cell events (CellClicked, CellOver, CellRightClicked)

    157. 

  157.  *                  - Made BuildList(), AddObject() and RemoveObject() thread-safe

    158. 

  158.  * 2009-07-04  JPP  - Space bar now properly toggles checkedness of selected rows

    159. 

  159.  * 2009-07-02  JPP  - Fixed bug with tooltips when the underlying Windows control was destroyed.

    160. 

  160.  *                  - CellToolTipShowing events are now triggered in all views.

    161. 

  161.  * v2.2

    162. 

  162.  * 2009-06-02  JPP  - BeforeSortingEventArgs now has a Handled property to let event handlers do

    163. 

  163.  *                    the item sorting themselves.

    164. 

  164.  *                  - AlwaysGroupByColumn works again, as does SortGroupItemsByPrimaryColumn and all their

    165. 

  165.  *                    various permutations.

    166. 

  166.  *                  - SecondarySortOrder and SecondarySortColumn are now "null" by default

    167. 

  167.  * 2009-05-15  JPP  - Fixed bug so that KeyPress events are again triggered

    168. 

  168.  * 2009-05-10  JPP  - Removed all unsafe code

    169. 

  169.  * 2009-05-07  JPP  - Don't use glass panel for overlays when in design mode. It's too confusing.

    170. 

  170.  * 2009-05-05  JPP  - Added Scroll event (thanks to Christophe Hosten for the complete patch to implement this)

    171. 

  171.  *                  - Added Unfocused foreground and background colors (also thanks to Christophe Hosten)

    172. 

  172.  * 2009-04-29  JPP  - Added SelectedColumn property, which puts a slight tint on that column. Combine

    173. 

  173.  *                    this with TintSortColumn property and the sort column is automatically tinted.

    174. 

  174.  *                  - Use an overlay to implement "empty list" msg. Default empty list msg is now prettier.

    175. 

  175.  * 2009-04-28  JPP  - Fixed bug where DoubleClick events were not triggered when CheckBoxes was true

    176. 

  176.  * 2009-04-23  JPP  - Fixed various bugs under Vista.

    177. 

  177.  *                  - Made groups collapsible - Vista only. Thanks to Crustyapplesniffer.

    178. 

  178.  *                  - Forward events from DropSink to the control itself. This allows handlers to be defined

    179. 

  179.  *                    within the IDE for drop events

    180. 

  180.  * 2009-04-16  JPP  - Made several properties localizable.

    181. 

  181.  * 2009-04-11  JPP  - Correctly renderer checkboxes when RowHeight is non-standard

    182. 

  182.  * 2009-04-11  JPP  - Implemented overlay architecture, based on CustomDraw scheme.

    183. 

  183.  *                    This unified drag drop feedback, empty list msgs and overlay images.

    184. 

  184.  *                  - Added OverlayImage and friends, which allows an image to be drawn

    185. 

  185.  *                    transparently over the listview

    186. 

  186.  * 2009-04-10  JPP  - Fixed long-standing annoying flicker on owner drawn virtual lists!

    187. 

  187.  *                    This means, amongst other things, that grid lines no longer get confused,

    188. 

  188.  *                    and drag-select no longer flickers.

    189. 

  189.  * 2009-04-07  JPP  - Calculate edit rectangles more accurately

    190. 

  190.  * 2009-04-06  JPP  - Double-clicking no longer toggles the checkbox

    191. 

  191.  *                  - Double-clicking on a checkbox no longer confuses the checkbox

    192. 

  192.  * 2009-03-16  JPP  - Optimized the build of autocomplete lists

    193. 

  193.  * v2.1

    194. 

  194.  * 2009-02-24  JPP  - Fix bug where double-clicking VERY quickly on two different cells

    195. 

  195.  *                    could give two editors

    196. 

  196.  *                  - Maintain focused item when rebuilding list (SF #2547060)

    197. 

  197.  * 2009-02-22  JPP  - Reworked checkboxes so that events are triggered for virtual lists

    198. 

  198.  * 2009-02-15  JPP  - Added ObjectListView.ConfigureAutoComplete utility method

    199. 

  199.  * 2009-02-02  JPP  - Fixed bug with AlwaysGroupByColumn where column header clicks would not resort groups.

    200. 

  200.  * 2009-02-01  JPP  - OLVColumn.CheckBoxes and TriStateCheckBoxes now work.

    201. 

  201.  * 2009-01-28  JPP  - Complete overhaul of renderers!

    202. 

  202.  *                       - Use IRenderer

    203. 

  203.  *                       - Added ObjectListView.ItemRenderer to draw whole items

    204. 

  204.  * 2009-01-23  JPP  - Simple Checkboxes now work properly

    205. 

  205.  *                  - Added TriStateCheckBoxes property to control whether the user can

    206. 

  206.  *                    set the row checkbox to have the Indeterminate value

    207. 

  207.  *                  - CheckState property is now just a wrapper around the StateImageIndex property

    208. 

  208.  * 2009-01-20  JPP  - Changed to always draw columns when owner drawn, rather than falling back on DrawDefault.

    209. 

  209.  *                    This simplified several owner drawn problems

    210. 

  210.  *                  - Added DefaultRenderer property to help with the above

    211. 

  211.  *                  - HotItem background color is applied to all cells even when FullRowSelect is false

    212. 

  212.  *                  - Allow grouping by CheckedAspectName columns

    213. 

  213.  *                  - Commented out experimental animations. Still needs work.

    214. 

  214.  * 2009-01-17  JPP  - Added HotItemStyle and UseHotItem to highlight the row under the cursor

    215. 

  215.  *                  - Added UseCustomSelectionColors property

    216. 

  216.  *                  - Owner draw mode now honors ForeColor and BackColor settings on the list

    217. 

  217.  * 2009-01-16  JPP  - Changed to use EditorRegistry rather than hard coding cell editors

    218. 

  218.  * 2009-01-10  JPP  - Changed to use Equals() method rather than == to compare model objects.

    219. 

  219.  * v2.0.1

    220. 

  220.  * 2009-01-08  JPP  - Fixed long-standing "multiple columns generated" problem.

    221. 

  221.  *                    Thanks to pinkjones for his help with solving this one!

    222. 

  222.  *                  - Added EnsureGroupVisible()

    223. 

  223.  * 2009-01-07  JPP  - Made all public and protected methods virtual

    224. 

  224.  *                  - FinishCellEditing, PossibleFinishCellEditing and CancelCellEditing are now public

    225. 

  225.  * 2008-12-20  JPP  - Fixed bug with group comparisons when a group key was null (SF#2445761)

    226. 

  226.  * 2008-12-19  JPP  - Fixed bug with space filling columns and layout events

    227. 

  227.  *                  - Fixed RowHeight so that it only changes the row height, not the width of the images.

    228. 

  228.  * v2.0

    229. 

  229.  * 2008-12-10  JPP  - Handle Backspace key. Resets the seach-by-typing state without delay

    230. 

  230.  *                  - Made some changes to the column collection editor to try and avoid

    231. 

  231.  *                    the multiple column generation problem.

    232. 

  232.  *                  - Updated some documentation

    233. 

  233.  * 2008-12-07  JPP  - Search-by-typing now works when showing groups

    234. 

  234.  *                  - Added BeforeSearching and AfterSearching events which are triggered when the user types

    235. 

  235.  *                    into the list.

    236. 

  236.  *                  - Added secondary sort information to Before/AfterSorting events

    237. 

  237.  *                  - Reorganized group sorting code. Now triggers Sorting events.

    238. 

  238.  *                  - Added GetItemIndexInDisplayOrder()

    239. 

  239.  *                  - Tweaked in the interaction of the column editor with the IDE so that we (normally)

    240. 

  240.  *                    don't rely on a hack to find the owning ObjectListView

    241. 

  241.  *                  - Changed all 'DefaultValue(typeof(Color), "Empty")' to 'DefaultValue(typeof(Color), "")'

    242. 

  242.  *                    since the first does not given Color.Empty as I thought, but the second does.

    243. 

  243.  * 2008-11-28  JPP  - Fixed long standing bug with horizontal scrollbar when shrinking the window.

    244. 

  244.  *                    (thanks to Bartosz Borowik)

    245. 

  245.  * 2008-11-25  JPP  - Added support for dynamic tooltips

    246. 

  246.  *                  - Split out comparers and header controls stuff into their own files

    247. 

  247.  * 2008-11-21  JPP  - Fixed bug where enabling grouping when there was not a sort column would not

    248. 

  248.  *                    produce a grouped list. Grouping column now defaults to column 0.

    249. 

  249.  *                  - Preserve selection on virtual lists when sorting

    250. 

  250.  * 2008-11-20  JPP  - Added ability to search by sort column to ObjectListView. Unified this with

    251. 

  251.  *                    ability that was already in VirtualObjectListView

    252. 

  252.  * 2008-11-19  JPP  - Fixed bug in ChangeToFilteredColumns() where DisplayOrder was not always restored correctly.

    253. 

  253.  * 2008-10-29  JPP  - Event argument blocks moved to directly within the namespace, rather than being

    254. 

  254.  *                    nested inside ObjectListView class.

    255. 

  255.  *                  - Removed OLVColumn.CellEditor since it was never used.

    256. 

  256.  *                  - Marked OLVColumn.AspectGetterAutoGenerated as obsolete (it has not been used for

    257. 

  257.  *                    several versions now).

    258. 

  258.  * 2008-10-28  JPP  - SelectedObjects is now an IList, rather than an ArrayList. This allows

    259. 

  259.  *                    it to accept generic list (eg List<File>).

    260. 

  260.  * 2008-10-09  JPP  - Support indeterminate checkbox values.

    261. 

  261.  *                    [BREAKING CHANGE] CheckStateGetter/CheckStatePutter now use CheckState types only.

    262. 

  262.  *                    BooleanCheckStateGetter and BooleanCheckStatePutter added to ease transition.

    263. 

  263.  * 2008-10-08  JPP  - Added setFocus parameter to SelectObject(), which allows focus to be set

    264. 

  264.  *                    at the same time as selecting.

    265. 

  265.  * 2008-09-27  JPP  - BIG CHANGE: Fissioned this file into separate files for each component

    266. 

  266.  * 2008-09-24  JPP  - Corrected bug with owner drawn lists where a column 0 with a renderer

    267. 

  267.  *                    would draw at column 0 even if column 0 was dragged to another position.

    268. 

  268.  *                  - Correctly handle space filling columns when columns are added/removed

    269. 

  269.  * 2008-09-16  JPP  - Consistently use try..finally for BeginUpdate()/EndUpdate() pairs

    270. 

  270.  * 2008-08-24  JPP  - If LastSortOrder is None when adding objects, don't force a resort.

    271. 

  271.  * 2008-08-22  JPP  - Catch and ignore some problems with setting TopIndex on FastObjectListViews.

    272. 

  272.  * 2008-08-05  JPP  - In the right-click column select menu, columns are now sorted by display order, rather than alphabetically

    273. 

  273.  * v1.13

    274. 

  274.  * 2008-07-23  JPP  - Consistently use copy-on-write semantics with Add/RemoveObject methods

    275. 

  275.  * 2008-07-10  JPP  - Enable validation on cell editors through a CellEditValidating event.

    276. 

  276.  *                    (thanks to Artiom Chilaru for the initial suggestion and implementation).

    277. 

  277.  * 2008-07-09  JPP  - Added HeaderControl.Handle to allow OLV to be used within UserControls.

    278. 

  278.  *                    (thanks to Michael Coffey for tracking this down).

    279. 

  279.  * 2008-06-23  JPP  - Split the more generally useful CopyObjectsToClipboard() method

    280. 

  280.  *                    out of CopySelectionToClipboard()

    281. 

  281.  * 2008-06-22  JPP  - Added AlwaysGroupByColumn and AlwaysGroupBySortOrder, which

    282. 

  282.  *                    force the list view to always be grouped by a particular column.

    283. 

  283.  * 2008-05-31  JPP  - Allow check boxes on FastObjectListViews

    284. 

  284.  *                  - Added CheckedObject and CheckedObjects properties

    285. 

  285.  * 2008-05-11  JPP  - Allow selection foreground and background colors to be changed.

    286. 

  286.  *                    Windows doesn't allow this, so we can only make it happen when owner

    287. 

  287.  *                    drawing. Set the HighlightForegroundColor and  HighlightBackgroundColor

    288. 

  288.  *                    properties and then call EnableCustomSelectionColors().

    289. 

  289.  * v1.12

    290. 

  290.  * 2008-05-08  JPP  - Fixed bug where the column select menu would not appear if the

    291. 

  291.  *                    ObjectListView has a context menu installed.

    292. 

  292.  * 2008-05-05  JPP  - Non detail views can now be owner drawn. The renderer installed for

    293. 

  293.  *                    primary column is given the chance to render the whole item.

    294. 

  294.  *                    See BusinessCardRenderer in the demo for an example.

    295. 

  295.  *                  - BREAKING CHANGE: RenderDelegate now returns a bool to indicate if default

    296. 

  296.  *                    rendering should be done. Previously returned void. Only important if your

    297. 

  297.  *                    code used RendererDelegate directly. Renderers derived from BaseRenderer

    298. 

  298.  *                    are unchanged.

    299. 

  299.  * 2008-05-03  JPP  - Changed cell editing to use values directly when the values are Strings.

    300. 

  300.  *                    Previously, values were always handed to the AspectToStringConverter.

    301. 

  301.  *                  - When editing a cell, tabbing no longer tries to edit the next subitem

    302. 

  302.  *                    when not in details view!

    303. 

  303.  * 2008-05-02  JPP  - MappedImageRenderer can now handle a Aspects that return a collection

    304. 

  304.  *                    of values. Each value will be drawn as its own image.

    305. 

  305.  *                  - Made AddObjects() and RemoveObjects() work for all flavours (or at least not crash)

    306. 

  306.  *                  - Fixed bug with clearing virtual lists that has been scrolled vertically

    307. 

  307.  *                  - Made TopItemIndex work with virtual lists.

    308. 

  308.  * 2008-05-01  JPP  - Added AddObjects() and RemoveObjects() to allow faster mods to the list

    309. 

  309.  *                  - Reorganised public properties. Now alphabetical.

    310. 

  310.  *                  - Made the class ObjectListViewState internal, as it always should have been.

    311. 

  311.  * v1.11

    312. 

  312.  * 2008-04-29  JPP  - Preserve scroll position when building the list or changing columns.

    313. 

  313.  *                  - Added TopItemIndex property. Due to problems with the underlying control, this

    314. 

  314.  *                    property is not always reliable. See property docs for info.

    315. 

  315.  * 2008-04-27  JPP  - Added SelectedIndex property.

    316. 

  316.  *                  - Use a different, more general strategy to handle Invoke(). Removed all delegates

    317. 

  317.  *                    that were only declared to support Invoke().

    318. 

  318.  *                  - Check all native structures for 64-bit correctness.

    319. 

  319.  * 2008-04-25  JPP  - Released on SourceForge.

    320. 

  320.  * 2008-04-13  JPP  - Added ColumnRightClick event.

    321. 

  321.  *                  - Made the assembly CLS-compliant. To do this, our cell editors were made internal, and

    322. 

  322.  *                    the constraint on FlagRenderer template parameter was removed (the type must still

    323. 

  323.  *                    be an IConvertible, but if it isn't, the error will be caught at runtime, not compile time).

    324. 

  324.  * 2008-04-12  JPP  - Changed HandleHeaderRightClick() to have a columnIndex parameter, which tells

    325. 

  325.  *                    exactly which column was right-clicked.

    326. 

  326.  * 2008-03-31  JPP  - Added SaveState() and RestoreState()

    327. 

  327.  *                  - When cell editing, scrolling with a mouse wheel now ends the edit operation.

    328. 

  328.  * v1.10

    329. 

  329.  * 2008-03-25  JPP  - Added space filling columns. See OLVColumn.FreeSpaceProportion property for details.

    330. 

  330.  *                    A space filling columns fills all (or a portion) of the width unoccupied by other columns.

    331. 

  331.  * 2008-03-23  JPP  - Finished tinkering with support for Mono. Compile with conditional compilation symbol 'MONO'

    332. 

  332.  *                    to enable. On Windows, current problems with Mono:

    333. 

  333.  *                    - grid lines on virtual lists crashes

    334. 

  334.  *                    - when grouped, items sometimes are not drawn when any item is scrolled out of view

    335. 

  335.  *                    - i can't seem to get owner drawing to work

    336. 

  336.  *                    - when editing cell values, the editing controls always appear behind the listview,

    337. 

  337.  *                      where they function fine -- the user just can't see them :-)

    338. 

  338.  * 2008-03-16  JPP  - Added some methods suggested by Chris Marlowe (thanks for the suggestions Chris)

    339. 

  339.  *                    - ClearObjects()

    340. 

  340.  *                    - GetCheckedObject(), GetCheckedObjects()

    341. 

  341.  *                    - GetItemAt() variation that gets both the item and the column under a point

    342. 

  342.  * 2008-02-28  JPP  - Fixed bug with subitem colors when using OwnerDrawn lists and a RowFormatter.

    343. 

  343.  * v1.9.1

    344. 

  344.  * 2008-01-29  JPP  - Fixed bug that caused owner-drawn virtual lists to use 100% CPU

    345. 

  345.  *                  - Added FlagRenderer to help draw bitwise-OR'ed flag values

    346. 

  346.  * 2008-01-23  JPP  - Fixed bug (introduced in v1.9) that made alternate row colour with groups not quite right

    347. 

  347.  *                  - Ensure that DesignerSerializationVisibility.Hidden is set on all non-browsable properties

    348. 

  348.  *                  - Make sure that sort indicators are shown after changing which columns are visible

    349. 

  349.  * 2008-01-21  JPP  - Added FastObjectListView

    350. 

  350.  * v1.9

    351. 

  351.  * 2008-01-18  JPP  - Added IncrementalUpdate()

    352. 

  352.  * 2008-01-16  JPP  - Right clicking on column header will allow the user to choose which columns are visible.

    353. 

  353.  *                    Set SelectColumnsOnRightClick to false to prevent this behaviour.

    354. 

  354.  *                  - Added ImagesRenderer to draw more than one images in a column

    355. 

  355.  *                  - Changed the positioning of the empty list m to use all the client area. Thanks to Matze.

    356. 

  356.  * 2007-12-13  JPP  - Added CopySelectionToClipboard(). Ctrl-C invokes this method. Supports text

    357. 

  357.  *                    and HTML formats.

    358. 

  358.  * 2007-12-12  JPP  - Added support for checkboxes via CheckStateGetter and CheckStatePutter properties.

    359. 

  359.  *                  - Made ObjectListView and OLVColumn into partial classes so that others can extend them.

    360. 

  360.  * 2007-12-09  JPP  - Added ability to have hidden columns, i.e. columns that the ObjectListView knows

    361. 

  361.  *                    about but that are not visible to the user. Controlled by OLVColumn.IsVisible.

    362. 

  362.  *                    Added ColumnSelectionForm to the project to show how it could be used in an application.

    363. 

  363.  *

    364. 

  364.  * v1.8

    365. 

  365.  * 2007-11-26  JPP  - Cell editing fully functional

    366. 

  366.  * 2007-11-21  JPP  - Added SelectionChanged event. This event is triggered once when the

    367. 

  367.  *                    selection changes, no matter how many items are selected or deselected (in

    368. 

  368.  *                    contrast to SelectedIndexChanged which is called once for every row that

    369. 

  369.  *                    is selected or deselected). Thanks to lupokehl42 (Daniel) for his suggestions and

    370. 

  370.  *                    improvements on this idea.

    371. 

  371.  * 2007-11-19  JPP  - First take at cell editing

    372. 

  372.  * 2007-11-17  JPP  - Changed so that items within a group are not sorted if lastSortOrder == None

    373. 

  373.  *                  - Only call MakeSortIndicatorImages() if we haven't already made the sort indicators

    374. 

  374.  *                    (Corrected misspelling in the name of the method too)

    375. 

  375.  * 2007-11-06  JPP  - Added ability to have secondary sort criteria when sorting

    376. 

  376.  *                    (SecondarySortColumn and SecondarySortOrder properties)

    377. 

  377.  *                  - Added SortGroupItemsByPrimaryColumn to allow group items to be sorted by the

    378. 

  378.  *                    primary column. Previous default was to sort by the grouping column.

    379. 

  379.  * v1.7

    380. 

  380.  * No big changes to this version but made to work with ListViewPrinter and released with it.

    381. 

  381.  *

    382. 

  382.  * 2007-11-05  JPP  - Changed BaseRenderer to use DrawString() rather than TextRenderer, since TextRenderer

    383. 

  383.  *                    does not work when printing.

    384. 

  384.  * v1.6

    385. 

  385.  * 2007-11-03  JPP  - Fixed some bugs in the rebuilding of DataListView.

    386. 

  386.  * 2007-10-31  JPP  - Changed to use builtin sort indicators on XP and later. This also avoids alignment

    387. 

  387.  *                    problems on Vista. (thanks to gravybod for the suggestion and example implementation)

    388. 

  388.  * 2007-10-21  JPP  - Added MinimumWidth and MaximumWidth properties to OLVColumn.

    389. 

  389.  *                  - Added ability for BuildList() to preserve selection. Calling BuildList() directly

    390. 

  390.  *                    tries to preserve selection; calling SetObjects() does not.

    391. 

  391.  *                  - Added SelectAll() and DeselectAll() methods. Useful for working with large lists.

    392. 

  392.  * 2007-10-08  JPP  - Added GetNextItem() and GetPreviousItem(), which walk sequentially through the

    393. 

  393.  *                    listview items, even when the view is grouped.

    394. 

  394.  *                  - Added SelectedItem property

    395. 

  395.  * 2007-09-28  JPP  - Optimized aspect-to-string conversion. BuildList() 15% faster.

    396. 

  396.  *                  - Added empty implementation of RefreshObjects() to VirtualObjectListView since

    397. 

  397.  *                    RefreshObjects() cannot work on virtual lists.

    398. 

  398.  * 2007-09-13  JPP  - Corrected bug with custom sorter in VirtualObjectListView (thanks for mpgjunky)

    399. 

  399.  * 2007-09-07  JPP  - Corrected image scaling bug in DrawAlignedImage() (thanks to krita970)

    400. 

  400.  * 2007-08-29  JPP  - Allow item count labels on groups to be set per column (thanks to cmarlow for idea)

    401. 

  401.  * 2007-08-14  JPP  - Major rework of DataListView based on Ian Griffiths's great work

    402. 

  402.  * 2007-08-11  JPP  - When empty, the control can now draw a "List Empty" m

    403. 

  403.  *                  - Added GetColumn() and GetItem() methods

    404. 

  404.  * v1.5

    405. 

  405.  * 2007-08-03  JPP  - Support animated GIFs in ImageRenderer

    406. 

  406.  *                  - Allow height of rows to be specified - EXPERIMENTAL!

    407. 

  407.  * 2007-07-26  JPP  - Optimised redrawing of owner-drawn lists by remembering the update rect

    408. 

  408.  *                  - Allow sort indicators to be turned off

    409. 

  409.  * 2007-06-30  JPP  - Added RowFormatter delegate

    410. 

  410.  *                  - Allow a different label when there is only one item in a group (thanks to cmarlow)

    411. 

  411.  * v1.4

    412. 

  412.  * 2007-04-12  JPP  - Allow owner drawn on steriods!

    413. 

  413.  *                  - Column headers now display sort indicators

    414. 

  414.  *                  - ImageGetter delegates can now return ints, strings or Images

    415. 

  415.  *                    (Images are only visible if the list is owner drawn)

    416. 

  416.  *                  - Added OLVColumn.MakeGroupies to help with group partitioning

    417. 

  417.  *                  - All normal listview views are now supported

    418. 

  418.  *                  - Allow dotted aspect names, e.g. Owner.Workgroup.Name (thanks to OlafD)

    419. 

  419.  *                  - Added SelectedObject and SelectedObjects properties

    420. 

  420.  * v1.3

    421. 

  421.  * 2007-03-01  JPP  - Added DataListView

    422. 

  422.  *                  - Added VirtualObjectListView

    423. 

  423.  * 					- Added Freeze/Unfreeze capabilities

    424. 

  424.  *                  - Allowed sort handler to be installed

    425. 

  425.  *                  - Simplified sort comparisons: handles 95% of cases with only 6 lines of code!

    426. 

  426.  *                  - Fixed bug with alternative line colors on unsorted lists (thanks to cmarlow)

    427. 

  427.  * 2007-01-13  JPP  - Fixed bug with lastSortOrder (thanks to Kwan Fu Sit)

    428. 

  428.  *                  - Non-OLVColumns are no longer allowed

    429. 

  429.  * 2007-01-04  JPP  - Clear sorter before rebuilding list. 10x faster! (thanks to aaberg)

    430. 

  430.  *                  - Include GetField in GetAspectByName() so field values can be Invoked too.

    431. 

  431.  * 					- Fixed subtle bug in RefreshItem() that erased background colors.

    432. 

  432.  * 2006-11-01  JPP  - Added alternate line colouring

    433. 

  433.  * 2006-10-20  JPP  - Refactored all sorting comparisons and made it extendable. See ComparerManager.

    434. 

  434.  *                  - Improved IDE integration

    435. 

  435.  *                  - Made control DoubleBuffered

    436. 

  436.  *                  - Added object selection methods

    437. 

  437.  * 2006-10-13  JPP  Implemented grouping and column sorting

    438. 

  438.  * 2006-10-09  JPP  Initial version

    439. 

  439.  *

    440. 

  440.  * TO DO:

    441. 

  441.  * - Support undocumented group features: subseted groups, group footer items

    442. 

  442.  * - Complete custom designer

    443. 

  443.  *

    444. 

  444.  * Copyright (C) 2006-2011 Phillip Piper

    445. 

  445.  *

    446. 

  446.  * This program is free software: you can redistribute it and/or modify

    447. 

  447.  * it under the terms of the GNU General Public License as published by

    448. 

  448.  * the Free Software Foundation, either version 3 of the License, or

    449. 

  449.  * (at your option) any later version.

    450. 

  450.  *

    451. 

  451.  * This program is distributed in the hope that it will be useful,

    452. 

  452.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    453. 

  453.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    454. 

  454.  * GNU General Public License for more details.

    455. 

  455.  *

    456. 

  456.  * You should have received a copy of the GNU General Public License

    457. 

  457.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.

    458. 

  458.  *

    459. 

  459.  * If you wish to use this code in a closed source application, please contact phillip_piper@bigfoot.com.

    460. 

  460.  */

    461. 

  461. 

    462. 

  462. using System;

    463. 

  463. using System.Collections;

    464. 

  464. using System.Collections.Generic;

    465. 

  465. using System.ComponentModel;

    466. 

  466. using System.Drawing;

    467. 

  467. using System.IO;

    468. 

  468. using System.Reflection;

    469. 

  469. using System.Runtime.InteropServices;

    470. 

  470. using System.Runtime.Serialization.Formatters.Binary;

    471. 

  471. using System.Windows.Forms;

    472. 

  472. using System.Windows.Forms.VisualStyles;

    473. 

  473. using System.Runtime.Serialization.Formatters;

    474. 

  474. 

    475. 

  475. namespace BrightIdeasSoftware

    476. 

  476. {

    477. 

  477.     /// <summary>

    478. 

  478.     /// An ObjectListView is a much easier to use, and much more powerful, version of the ListView.

    479. 

  479.     /// </summary>

    480. 

  480.     /// <remarks>

    481. 

  481.     /// <para>

    482. 

  482.     /// An ObjectListView automatically populates a ListView control with information taken 

    483. 

  483.     /// from a given collection of objects. It can do this because each column is configured

    484. 

  484.     /// to know which bit of the model object (the "aspect") it should be displaying. Columns similarly

    485. 

  485.     /// understand how to sort the list based on their aspect, and how to construct groups

    486. 

  486.     /// using their aspect.

    487. 

  487.     /// </para>

    488. 

  488.     /// <para>

    489. 

  489.     /// Aspects are extracted by giving the name of a method to be called or a

    490. 

  490.     /// property to be fetched. These names can be simple names or they can be dotted

    491. 

  491.     /// to chain property access e.g. "Owner.Address.Postcode".

    492. 

  492.     /// Aspects can also be extracted by installing a delegate.

    493. 

  493.     /// </para>

    494. 

  494.     /// <para>

    495. 

  495.     /// An ObjectListView can show a "this list is empty" message when there is nothing to show in the list, 

    496. 

  496.     /// so that the user knows the control is supposed to be empty.

    497. 

  497.     /// </para>

    498. 

  498.     /// <para>

    499. 

  499.     /// Right clicking on a column header should present a menu which can contain:

    500. 

  500.     /// commands (sort, group, ungroup); filtering; and column selection. Whether these

    501. 

  501.     /// parts of the menu appear is controlled by ShowCommandMenuOnRightClick, 

    502. 

  502.     /// ShowFilterMenuOnRightClick and SelectColumnsOnRightClick respectively.

    503. 

  503.     /// </para>

    504. 

  504.     /// <para>

    505. 

  505.     /// The groups created by an ObjectListView can be configured to include other formatting

    506. 

  506.     /// information, including a group icon, subtitle and task button. Using some undocumented

    507. 

  507.     /// interfaces, these groups can even on virtual lists.

    508. 

  508.     /// </para>

    509. 

  509.     /// <para>

    510. 

  510.     /// ObjectListView supports dragging rows to other places, including other application. 

    511. 

  511.     /// Special support is provide for drops from other ObjectListViews in the same application. 

    512. 

  512.     /// In many cases, an ObjectListView becomes a full drag source by setting <see cref="IsSimpleDragSource"/> to 

    513. 

  513.     /// true. Similarly, to accept drops, it is usually enough to set <see cref="IsSimpleDropSink"/> to true, 

    514. 

  514.     /// and then handle the <see cref="CanDrop"/>  and <see cref="Dropped"/>  events (or the <see cref="ModelCanDrop"/>  and 

    515. 

  515.     /// <see cref="ModelDropped"/> events, if you only want to handle drops from other ObjectListViews in your application).

    516. 

  516.     /// </para>

    517. 

  517.     /// <para>

    518. 

  518.     /// For these classes to build correctly, the project must have references to these assemblies:

    519. 

  519.     /// </para>

    520. 

  520.     /// <list type="bullet">

    521. 

  521.     /// <item><description>System</description></item>

    522. 

  522.     /// <item><description>System.Data</description></item>

    523. 

  523.     /// <item><description>System.Design</description></item>

    524. 

  524.     /// <item><description>System.Drawing</description></item>

    525. 

  525.     /// <item><description>System.Windows.Forms (obviously)</description></item>

    526. 

  526.     /// </list>

    527. 

  527.     /// </remarks>

    528. 

  528.     //[Designer("BrightIdeasSoftware.Design.ObjectListViewDesigner")] // Uncomment this if you are feeling brave :)

    529. 

  529.     public partial class ObjectListView : ListView, ISupportInitialize {

    530. 

  530.         

    531. 

  531.         #region Life and death

    532. 

  532.         

    533. 

  533.         /// <summary>

    534. 

  534.         /// Create an ObjectListView

    535. 

  535.         /// </summary>

    536. 

  536.         public ObjectListView() {

    537. 

  537.             this.ColumnClick += new ColumnClickEventHandler(this.HandleColumnClick);

    538. 

  538.             this.Layout += new LayoutEventHandler(this.HandleLayout);

    539. 

  539.             this.ColumnWidthChanging += new ColumnWidthChangingEventHandler(this.HandleColumnWidthChanging);

    540. 

  540.             this.ColumnWidthChanged += new ColumnWidthChangedEventHandler(this.HandleColumnWidthChanged);

    541. 

  541. 

    542. 

  542.             base.View = View.Details;

    543. 

  543.             this.DoubleBuffered = true; // kill nasty flickers. hiss... me hates 'em

    544. 

  544.             this.ShowSortIndicators = true;

    545. 

  545. 

    546. 

  546.             // Setup the overlays that will be controlled by the IDE settings

    547. 

  547.             this.InitializeStandardOverlays();

    548. 

  548.             this.InitializeEmptyListMsgOverlay();

    549. 

  549.         }

    550. 

  550. 

    551. 

  551.         /// <summary>

    552. 

  552.         /// Dispose of any resources this instance has been using

    553. 

  553.         /// </summary>

    554. 

  554.         /// <param name="disposing"></param>

    555. 

  555.         protected override void Dispose(bool disposing) {

    556. 

  556.             base.Dispose(disposing);

    557. 

  557. 

    558. 

  558.             if (disposing) {

    559. 

  559.                 foreach (GlassPanelForm glassPanel in this.glassPanels) {

    560. 

  560.                     glassPanel.Unbind();

    561. 

  561.                     glassPanel.Dispose();

    562. 

  562.                 }

    563. 

  563.                 this.glassPanels.Clear();

    564. 

  564.             }

    565. 

  565.         }

    566. 

  566. 

    567. 

  567.         #endregion

    568. 

  568. 

    569. 

  569.         #region Static properties

    570. 

  570. 

    571. 

  571.         /// <summary>

    572. 

  572.         /// Gets whether the program running on Vista or later?

    573. 

  573.         /// </summary>

    574. 

  574.         static public bool IsVistaOrLater {

    575. 

  575.             get {

    576. 

  576.                 if (!ObjectListView.isVistaOrLater.HasValue)

    577. 

  577.                     ObjectListView.isVistaOrLater = Environment.OSVersion.Version.Major >= 6;

    578. 

  578.                 return ObjectListView.isVistaOrLater.Value;

    579. 

  579.             }

    580. 

  580.         }

    581. 

  581.         static private bool? isVistaOrLater;

    582. 

  582. 

    583. 

  583.         /// <summary>

    584. 

  584.         /// Gets whether the program running on Win7 or later?

    585. 

  585.         /// </summary>

    586. 

  586.         static public bool IsWin7OrLater {

    587. 

  587.             get {

    588. 

  588.                 if (!ObjectListView.isWin7OrLater.HasValue) {

    589. 

  589.                     // For some reason, Win7 is v6.1, not v7.0

    590. 

  590.                     Version version = Environment.OSVersion.Version;

    591. 

  591.                     ObjectListView.isWin7OrLater = version.Major > 6 || (version.Major == 6 && version.Minor > 0);

    592. 

  592.                 }

    593. 

  593.                 return ObjectListView.isWin7OrLater.Value;

    594. 

  594.             }

    595. 

  595.         }

    596. 

  596.         static private bool? isWin7OrLater;

    597. 

  597. 

    598. 

  598.         /// <summary>

    599. 

  599.         /// Gets or sets how what smoothing mode will be applied to graphic operations.

    600. 

  600.         /// </summary>

    601. 

  601.         static public System.Drawing.Drawing2D.SmoothingMode SmoothingMode {

    602. 

  602.             get { return ObjectListView.smoothingMode; }

    603. 

  603.             set { ObjectListView.smoothingMode = value; }

    604. 

  604.         }

    605. 

  605.         static private System.Drawing.Drawing2D.SmoothingMode smoothingMode =

    606. 

  606.             System.Drawing.Drawing2D.SmoothingMode.HighQuality;

    607. 

  607. 

    608. 

  608.         /// <summary>

    609. 

  609.         /// Gets or sets how should text be renderered.

    610. 

  610.         /// </summary>

    611. 

  611.         static public System.Drawing.Text.TextRenderingHint TextRenderingHint {

    612. 

  612.             get { return ObjectListView.textRendereringHint; }

    613. 

  613.             set { ObjectListView.textRendereringHint = value; }

    614. 

  614.         }

    615. 

  615.         static private System.Drawing.Text.TextRenderingHint textRendereringHint =

    616. 

  616.             System.Drawing.Text.TextRenderingHint.SystemDefault;

    617. 

  617. 

    618. 

  618.         /// <summary>

    619. 

  619.         /// Convert the given enumerable into an ArrayList as efficiently as possible

    620. 

  620.         /// </summary>

    621. 

  621.         /// <param name="collection">The source collection</param>

    622. 

  622.         /// <param name="alwaysCreate">If true, this method will always create a new

    623. 

  623.         /// collection.</param>

    624. 

  624.         /// <returns>An ArrayList with the same contents as the given collection.</returns>

    625. 

  625.         /// <remarks>

    626. 

  626.         /// <para>When we move to .NET 3.5, we can use LINQ and not need this method.</para>

    627. 

  627.         /// </remarks>

    628. 

  628.         public static ArrayList EnumerableToArray(IEnumerable collection, bool alwaysCreate) {

    629. 

  629.             if (collection == null)

    630. 

  630.                 return new ArrayList();

    631. 

  631. 

    632. 

  632.             if (!alwaysCreate) {

    633. 

  633.                 ArrayList array = collection as ArrayList;

    634. 

  634.                 if (array != null)

    635. 

  635.                     return array;

    636. 

  636. 

    637. 

  637.                 IList iList = collection as IList;

    638. 

  638.                 if (iList != null)

    639. 

  639.                     return ArrayList.Adapter(iList);

    640. 

  640.             }

    641. 

  641. 

    642. 

  642.             ICollection iCollection = collection as ICollection;

    643. 

  643.             if (iCollection != null)

    644. 

  644.                 return new ArrayList(iCollection);

    645. 

  645. 

    646. 

  646.             ArrayList newObjects = new ArrayList();

    647. 

  647.             foreach (object x in collection)

    648. 

  648.                 newObjects.Add(x);

    649. 

  649.             return newObjects;

    650. 

  650.         }

    651. 

  651. 

    652. 

  652.         ///// <summary>

    653. 

  653.         ///// Decide if the given enumerable is empty

    654. 

  654.         ///// </summary>

    655. 

  655.         ///// <param name="collection">The source collection</param>

    656. 

  656.         ///// <returns>True if the given enumerable is empty</returns>

    657. 

  657.         ///// <remarks>

    658. 

  658.         ///// <para>When we move to .NET 3.5, we can use LINQ and not need this method.</para>

    659. 

  659.         ///// </remarks>

    660. 

  660.         //public static bool IsEnumerableEmpty(IEnumerable collection) {

    661. 

  661.         //    if (collection == null)

    662. 

  662.         //        return true;

    663. 

  663. 

    664. 

  664.         //    IEnumerator enumerator = collection.GetEnumerator();

    665. 

  665.         //    return !enumerator.MoveNext();

    666. 

  666.         //}

    667. 

  667. 

    668. 

  668.         #endregion

    669. 

  669. 

    670. 

  670.         #region Public properties

    671. 

  671. 

    672. 

  672.         /// <summary>

    673. 

  673.         /// Get or set all the columns that this control knows about.

    674. 

  674.         /// Only those columns where IsVisible is true will be seen by the user.

    675. 

  675.         /// </summary>

    676. 

  676.         /// <remarks>

    677. 

  677.         /// <para>

    678. 

  678.         /// If you want to add new columns programmatically, add them to

    679. 

  679.         /// AllColumns and then call RebuildColumns(). Normally, you do not have to

    680. 

  680.         /// deal with this property directly. Just use the IDE.

    681. 

  681.         /// </para>

    682. 

  682.         /// <para>If you do add or remove columns from the AllColumns collection,

    683. 

  683.         /// you have to call RebuildColumns() to make those changes take effect.</para>

    684. 

  684.         /// </remarks>

    685. 

  685.         [Browsable(false),

    686. 

  686.         DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]

    687. 

  687.         public virtual List<OLVColumn> AllColumns {

    688. 

  688.             get { return this.allColumns; }

    689. 

  689.             set { this.allColumns = value ?? new List<OLVColumn>(); }

    690. 

  690.         }

    691. 

  691.         private List<OLVColumn> allColumns = new List<OLVColumn>();

    692. 

  692. 

    693. 

  693.         /// <summary>

    694. 

  694.         /// Gets or sets the background color of every second row 

    695. 

  695.         /// </summary>

    696. 

  696.         [Category("ObjectListView"),

    697. 

  697.          Description("If using alternate colors, what color should the background of alterate rows be?"),

    698. 

  698.          DefaultValue(typeof(Color), "")]

    699. 

  699.         public Color AlternateRowBackColor {

    700. 

  700.             get { return alternateRowBackColor; }

    701. 

  701.             set { alternateRowBackColor = value; }

    702. 

  702.         }

    703. 

  703.         private Color alternateRowBackColor = Color.Empty;

    704. 

  704. 

    705. 

  705.         /// <summary>

    706. 

  706.         /// Gets the alternate row background color that has been set, or the default color

    707. 

  707.         /// </summary>

    708. 

  708.         [Browsable(false)]

    709. 

  709.         public virtual Color AlternateRowBackColorOrDefault {

    710. 

  710.             get {

    711. 

  711.                 return this.alternateRowBackColor == Color.Empty ? Color.LemonChiffon : this.alternateRowBackColor;

    712. 

  712.             }

    713. 

  713.         }

    714. 

  714. 

    715. 

  715.         /// <summary>

    716. 

  716.         /// This property forces the ObjectListView to always group items by the given column.

    717. 

  717.         /// </summary>

    718. 

  718.         [Browsable(false),

    719. 

  719.         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    720. 

  720.         public virtual OLVColumn AlwaysGroupByColumn {

    721. 

  721.             get { return alwaysGroupByColumn; }

    722. 

  722.             set { alwaysGroupByColumn = value; }

    723. 

  723.         }

    724. 

  724.         private OLVColumn alwaysGroupByColumn;

    725. 

  725. 

    726. 

  726.         /// <summary>

    727. 

  727.         /// If AlwaysGroupByColumn is not null, this property will be used to decide how

    728. 

  728.         /// those groups are sorted. If this property has the value SortOrder.None, then

    729. 

  729.         /// the sort order will toggle according to the users last header click.

    730. 

  730.         /// </summary>

    731. 

  731.         [Browsable(false),

    732. 

  732.         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    733. 

  733.         public virtual SortOrder AlwaysGroupBySortOrder {

    734. 

  734.             get { return alwaysGroupBySortOrder; }

    735. 

  735.             set { alwaysGroupBySortOrder = value; }

    736. 

  736.         }

    737. 

  737.         private SortOrder alwaysGroupBySortOrder = SortOrder.None;

    738. 

  738. 

    739. 

  739.         /// <summary>

    740. 

  740.         /// Give access to the image list that is actually being used by the control

    741. 

  741.         /// </summary>

    742. 

  742.         /// <remarks>

    743. 

  743.         /// Normally, it is preferable to use SmallImageList. Only use this property

    744. 

  744.         /// if you know exactly what you are doing.

    745. 

  745.         /// </remarks>

    746. 

  746.         [Browsable(false),

    747. 

  747.         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    748. 

  748.         public virtual ImageList BaseSmallImageList {

    749. 

  749.             get { return base.SmallImageList; }

    750. 

  750.             set { base.SmallImageList = value; }

    751. 

  751.         }

    752. 

  752. 

    753. 

  753.         /// <summary>

    754. 

  754.         /// How does the user indicate that they want to edit a cell?

    755. 

  755.         /// None means that the listview cannot be edited.

    756. 

  756.         /// </summary>

    757. 

  757.         /// <remarks>Columns can also be marked as editable.</remarks>

    758. 

  758.         [Category("ObjectListView"),

    759. 

  759.         Description("How does the user indicate that they want to edit a cell?"),

    760. 

  760.         DefaultValue(CellEditActivateMode.None)]

    761. 

  761.         public virtual CellEditActivateMode CellEditActivation {

    762. 

  762.             get { return cellEditActivation; }

    763. 

  763.             set { 

    764. 

  764.                 cellEditActivation = value;

    765. 

  765.                 if (this.Created)

    766. 

  766.                     this.Invalidate();

    767. 

  767.             }

    768. 

  768.         }

    769. 

  769.         private CellEditActivateMode cellEditActivation = CellEditActivateMode.None;

    770. 

  770. 

    771. 

  771.         /// <summary>

    772. 

  772.         /// Gets or sets the engine that will handle key presses during a cell edit operation.

    773. 

  773.         /// Settings this to null will reset it to default value.

    774. 

  774.         /// </summary>

    775. 

  775.         [Browsable(false),

    776. 

  776.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    777. 

  777.         public CellEditKeyEngine CellEditKeyEngine {

    778. 

  778.             get {

    779. 

  779.                 if (this.cellEditKeyEngine == null)

    780. 

  780.                     this.cellEditKeyEngine = new CellEditKeyEngine();

    781. 

  781.                 return this.cellEditKeyEngine;

    782. 

  782.             }

    783. 

  783.             set { this.cellEditKeyEngine = value; }

    784. 

  784.         }

    785. 

  785.         private CellEditKeyEngine cellEditKeyEngine;

    786. 

  786. 

    787. 

  787.         /// <summary>

    788. 

  788.         /// Gets the control that is currently being used for editing a cell.

    789. 

  789.         /// </summary>

    790. 

  790.         /// <remarks>This will obviously be null if no cell is being edited.</remarks>

    791. 

  791.         [Browsable(false)]

    792. 

  792.         public Control CellEditor {

    793. 

  793.             get {

    794. 

  794.                 return this.cellEditor;

    795. 

  795.             }

    796. 

  796.         }

    797. 

  797. 

    798. 

  798.         /// <summary>

    799. 

  799.         /// Gets or sets the behaviour of the Tab key when editing a cell on the left or right

    800. 

  800.         /// edge of the control. If this is false (the default), pressing Tab will wrap to the other side

    801. 

  801.         /// of the same row. If this is true, pressing Tab when editing the right most cell will advance 

    802. 

  802.         /// to the next row 

    803. 

  803.         /// and Shift-Tab when editing the left-most cell will change to the previous row.

    804. 

  804.         /// </summary>

    805. 

  805.         [Category("ObjectListView"),

    806. 

  806.         Description("Should Tab/Shift-Tab change rows while cell editing?"),

    807. 

  807.         DefaultValue(false)]

    808. 

  808.         public virtual bool CellEditTabChangesRows {

    809. 

  809.             get { return cellEditTabChangesRows; }

    810. 

  810.             set {

    811. 

  811.                 cellEditTabChangesRows = value;

    812. 

  812.                 if (cellEditTabChangesRows) {

    813. 

  813.                     this.CellEditKeyEngine.SetKeyBehaviour(Keys.Tab, CellEditCharacterBehaviour.ChangeColumnRight, CellEditAtEdgeBehaviour.ChangeRow);

    814. 

  814.                     this.CellEditKeyEngine.SetKeyBehaviour(Keys.Tab|Keys.Shift, CellEditCharacterBehaviour.ChangeColumnLeft, CellEditAtEdgeBehaviour.ChangeRow);

    815. 

  815.                 } else {

    816. 

  816.                     this.CellEditKeyEngine.SetKeyBehaviour(Keys.Tab, CellEditCharacterBehaviour.ChangeColumnRight, CellEditAtEdgeBehaviour.Wrap);

    817. 

  817.                     this.CellEditKeyEngine.SetKeyBehaviour(Keys.Tab | Keys.Shift, CellEditCharacterBehaviour.ChangeColumnLeft, CellEditAtEdgeBehaviour.Wrap);

    818. 

  818.                 }

    819. 

  819.             }

    820. 

  820.         }

    821. 

  821.         private bool cellEditTabChangesRows = false;

    822. 

  822. 

    823. 

  823.         /// <summary>

    824. 

  824.         /// Gets or sets the behaviour of the Enter keys while editing a cell.

    825. 

  825.         /// If this is false (the default), pressing Enter will simply finish the editing operation.

    826. 

  826.         /// If this is true, Enter will finish the edit operation and start a new edit operation

    827. 

  827.         /// on the cell below the current cell, wrapping to the top of the next row when at the bottom cell.

    828. 

  828.         /// </summary>

    829. 

  829.         [Category("ObjectListView"),

    830. 

  830.         Description("Should Enter change rows while cell editing?"),

    831. 

  831.         DefaultValue(false)]

    832. 

  832.         public virtual bool CellEditEnterChangesRows {

    833. 

  833.             get { return cellEditEnterChangesRows; }

    834. 

  834.             set {

    835. 

  835.                 cellEditEnterChangesRows = value;

    836. 

  836.                 if (cellEditEnterChangesRows) {

    837. 

  837.                     this.CellEditKeyEngine.SetKeyBehaviour(Keys.Enter, CellEditCharacterBehaviour.ChangeRowDown, CellEditAtEdgeBehaviour.ChangeColumn);

    838. 

  838.                     this.CellEditKeyEngine.SetKeyBehaviour(Keys.Enter | Keys.Shift, CellEditCharacterBehaviour.ChangeRowUp, CellEditAtEdgeBehaviour.ChangeColumn);

    839. 

  839.                 } else {

    840. 

  840.                     this.CellEditKeyEngine.SetKeyBehaviour(Keys.Enter, CellEditCharacterBehaviour.EndEdit, CellEditAtEdgeBehaviour.EndEdit);

    841. 

  841.                     this.CellEditKeyEngine.SetKeyBehaviour(Keys.Enter | Keys.Shift, CellEditCharacterBehaviour.EndEdit, CellEditAtEdgeBehaviour.EndEdit);

    842. 

  842.                 }

    843. 

  843.             }

    844. 

  844.         }

    845. 

  845.         private bool cellEditEnterChangesRows = false;

    846. 

  846. 

    847. 

  847.         /// <summary>

    848. 

  848.         /// Gets the tool tip control that shows tips for the cells

    849. 

  849.         /// </summary>

    850. 

  850.         [Browsable(false)]

    851. 

  851.         public ToolTipControl CellToolTip {

    852. 

  852.             get {

    853. 

  853.                 if (this.cellToolTip == null) {

    854. 

  854.                     this.CreateCellToolTip();

    855. 

  855.                 }

    856. 

  856.                 return this.cellToolTip;

    857. 

  857.             }

    858. 

  858.         }

    859. 

  859.         private ToolTipControl cellToolTip;

    860. 

  860. 

    861. 

  861.         /// <summary>

    862. 

  862.         /// Should this list show checkboxes?

    863. 

  863.         /// </summary>

    864. 

  864.         public new bool CheckBoxes {

    865. 

  865.             get {

    866. 

  866.                 return base.CheckBoxes;

    867. 

  867.             }

    868. 

  868.             set {

    869. 

  869.                 base.CheckBoxes = value;

    870. 

  870. 

    871. 

  871.                 // Initialize the state image list so we can display indetermined values.

    872. 

  872.                 this.InitializeStateImageList();

    873. 

  873.             }

    874. 

  874.         }

    875. 

  875. 

    876. 

  876.         /// <summary>

    877. 

  877.         /// Return the model object of the row that is checked or null if no row is checked

    878. 

  878.         /// or more than one row is checked

    879. 

  879.         /// </summary>

    880. 

  880.         [Browsable(false),

    881. 

  881.         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    882. 

  882.         public virtual Object CheckedObject {

    883. 

  883.             get {

    884. 

  884.                 IList checkedObjects = this.CheckedObjects;

    885. 

  885.                 if (checkedObjects.Count == 1)

    886. 

  886.                     return checkedObjects[0];

    887. 

  887.                 else

    888. 

  888.                     return null;

    889. 

  889.             }

    890. 

  890.             set {

    891. 

  891.                 this.CheckedObjects = new ArrayList(new Object[] { value });

    892. 

  892.             }

    893. 

  893.         }

    894. 

  894. 

    895. 

  895.         /// <summary>

    896. 

  896.         /// Get or set the collection of model objects that are checked.

    897. 

  897.         /// When setting this property, any row whose model object isn't

    898. 

  898.         /// in the given collection will be unchecked. Setting to null is

    899. 

  899.         /// equivilent to unchecking all.

    900. 

  900.         /// </summary>

    901. 

  901.         /// <remarks>

    902. 

  902.         /// <para>

    903. 

  903.         /// This property returns a simple collection. Changes made to the returned

    904. 

  904.         /// collection do NOT affect the list. This is different to the behaviour of

    905. 

  905.         /// CheckedIndicies collection.

    906. 

  906.         /// </para>

    907. 

  907.         /// <para>

    908. 

  908.         /// .NET's CheckedItems property is not helpful. It is just a short-hand for

    909. 

  909.         /// iterating through the list looking for items that are checked.

    910. 

  910.         /// </para>

    911. 

  911.         /// <para>

    912. 

  912.         /// The performance of the get method is O(n), where n is the number of items

    913. 

  913.         /// in the control. The performance of the set method is

    914. 

  914.         /// O(n + m) where m is the number of objects being checked. Be careful on long lists.

    915. 

  915.         /// </para>

    916. 

  916.         /// </remarks>

    917. 

  917.         [Browsable(false),

    918. 

  918.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    919. 

  919.         public virtual IList CheckedObjects {

    920. 

  920.             get {

    921. 

  921.                 ArrayList objects = new ArrayList();

    922. 

  922.                 if (this.CheckBoxes) {

    923. 

  923.                     for (int i = 0; i < this.GetItemCount(); i++) {

    924. 

  924.                         OLVListItem olvi = this.GetItem(i);

    925. 

  925.                         if (olvi.CheckState == CheckState.Checked)

    926. 

  926.                             objects.Add(olvi.RowObject);

    927. 

  927.                     }

    928. 

  928.                 }

    929. 

  929.                 return objects;

    930. 

  930.             }

    931. 

  931.             set {

    932. 

  932.                 if (!this.CheckBoxes)

    933. 

  933.                     return;

    934. 

  934. 

    935. 

  935.                 // Set up an efficient way of testing for the presence of a particular model

    936. 

  936.                 Hashtable table = new Hashtable(this.GetItemCount());

    937. 

  937.                 if (value != null) {

    938. 

  938.                     foreach (object x in value)

    939. 

  939.                         table[x] = true;

    940. 

  940.                 }

    941. 

  941. 

    942. 

  942.                 foreach (Object x in this.Objects) {

    943. 

  943.                     this.SetObjectCheckedness(x, table.ContainsKey(x) ? CheckState.Checked : CheckState.Unchecked);

    944. 

  944.                 }

    945. 

  945.             }

    946. 

  946.         }

    947. 

  947. 

    948. 

  948.         /// <summary>

    949. 

  949.         /// Gets or sets the checked objects from an enumerable.

    950. 

  950.         /// </summary>

    951. 

  951.         /// <remarks>

    952. 

  952.         /// Useful for checking all objects in the list.

    953. 

  953.         /// </remarks>

    954. 

  954.         /// <example>

    955. 

  955.         /// this.olv1.CheckedObjectsEnumerable = this.olv1.Objects;

    956. 

  956.         /// </example>

    957. 

  957.         [Browsable(false),

    958. 

  958.         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    959. 

  959.         public virtual IEnumerable CheckedObjectsEnumerable {

    960. 

  960.             get {

    961. 

  961.                 return this.CheckedObjects;

    962. 

  962.             }

    963. 

  963.             set {

    964. 

  964.                 this.CheckedObjects = ObjectListView.EnumerableToArray(value, true);

    965. 

  965.             }

    966. 

  966.         }

    967. 

  967. 

    968. 

  968.         /// <summary>

    969. 

  969.         /// Gets Columns for this list. We hide the original so we can associate

    970. 

  970.         /// a specialised editor with it.

    971. 

  971.         /// </summary>

    972. 

  972.         [Editor("BrightIdeasSoftware.Design.OLVColumnCollectionEditor", "System.Drawing.Design.UITypeEditor")]

    973. 

  973.         new public ListView.ColumnHeaderCollection Columns {

    974. 

  974.             get {

    975. 

  975.                 return base.Columns;

    976. 

  976.             }

    977. 

  977.         }

    978. 

  978. 

    979. 

  979.         /// <summary>

    980. 

  980.         /// Get/set the list of columns that should be used when the list switches to tile view.

    981. 

  981.         /// </summary>

    982. 

  982.         [Browsable(false),

    983. 

  983.         Obsolete("Use GetFilteredColumns() and OLVColumn.IsTileViewColumn instead"),

    984. 

  984.         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    985. 

  985.         public List<OLVColumn> ColumnsForTileView {

    986. 

  986.             get { return this.GetFilteredColumns(View.Tile); }

    987. 

  987.         }

    988. 

  988. 

    989. 

  989.         /// <summary>

    990. 

  990.         /// Return the visible columns in the order they are displayed to the user

    991. 

  991.         /// </summary>

    992. 

  992.         [Browsable(false)]

    993. 

  993.         public virtual List<OLVColumn> ColumnsInDisplayOrder {

    994. 

  994.             get {

    995. 

  995.                 OLVColumn[] columnsInDisplayOrder = new OLVColumn[this.Columns.Count];

    996. 

  996.                 foreach (OLVColumn col in this.Columns) {

    997. 

  997.                     columnsInDisplayOrder[col.DisplayIndex] = col;

    998. 

  998.                 }

    999. 

  999.                 return new List<OLVColumn>(columnsInDisplayOrder);

    1000. 

  1000.             }

    1001. 

  1001.         }

    1002. 

  1002. 

    1003. 

  1003. 

    1004. 

  1004.         /// <summary>

    1005. 

  1005.         /// Get the area of the control that shows the list, minus any header control

    1006. 

  1006.         /// </summary>

    1007. 

  1007.         [Browsable(false)]

    1008. 

  1008.         public Rectangle ContentRectangle {

    1009. 

  1009.             get {

    1010. 

  1010.                 Rectangle r = this.ClientRectangle;

    1011. 

  1011. 

    1012. 

  1012.                 // If the listview has a header control, remove the header from the control area

    1013. 

  1013.                 if (this.View == View.Details && this.HeaderControl != null) {

    1014. 

  1014.                     Rectangle hdrBounds = new Rectangle();

    1015. 

  1015.                     NativeMethods.GetClientRect(this.HeaderControl.Handle, ref hdrBounds);

    1016. 

  1016.                     r.Y = hdrBounds.Height;

    1017. 

  1017.                     r.Height = r.Height - hdrBounds.Height;

    1018. 

  1018.                 }

    1019. 

  1019. 

    1020. 

  1020.                 return r;

    1021. 

  1021.             }

    1022. 

  1022.         }

    1023. 

  1023. 

    1024. 

  1024.         /// <summary>

    1025. 

  1025.         /// Gets or sets if the selected rows should be copied to the clipboard when the user presses Ctrl-C

    1026. 

  1026.         /// </summary>

    1027. 

  1027.         [Category("ObjectListView"),

    1028. 

  1028.         Description("Should the control copy the selection to the clipboard when the user presses Ctrl-C?"),

    1029. 

  1029.         DefaultValue(true)]

    1030. 

  1030.         public virtual bool CopySelectionOnControlC {

    1031. 

  1031.             get { return copySelectionOnControlC; }

    1032. 

  1032.             set { copySelectionOnControlC = value; }

    1033. 

  1033.         }

    1034. 

  1034.         private bool copySelectionOnControlC = true;

    1035. 

  1035. 

    1036. 

  1036. 

    1037. 

  1037.         /// <summary>

    1038. 

  1038.         /// Gets or sets whether the Control-C copy to clipboard functionality should use

    1039. 

  1039.         /// the installed DragSource to create the data object that is placed onto the clipboard.

    1040. 

  1040.         /// </summary>

    1041. 

  1041.         /// <remarks>This is normally what is desired, unless a custom DragSource is installed 

    1042. 

  1042.         /// that does some very specialized drag-drop behaviour.</remarks>

    1043. 

  1043.         [Category("ObjectListView"),

    1044. 

  1044.         Description("Should the Ctrl-C copy process use the DragSource to create the Clipboard data object?"),

    1045. 

  1045.         DefaultValue(true)]

    1046. 

  1046.         public bool CopySelectionOnControlCUsesDragSource {

    1047. 

  1047.             get { return this.copySelectionOnControlCUsesDragSource; }

    1048. 

  1048.             set { this.copySelectionOnControlCUsesDragSource = value; }

    1049. 

  1049.         }

    1050. 

  1050.         private bool copySelectionOnControlCUsesDragSource = true;

    1051. 

  1051. 

    1052. 

  1052.         /// <summary>

    1053. 

  1053.         /// Gets the list of decorations that will be drawn the ListView

    1054. 

  1054.         /// </summary>

    1055. 

  1055.         /// <remarks>

    1056. 

  1056.         /// <para>

    1057. 

  1057.         /// Do not modify the contents of this list directly. Use the AddDecoration() and RemoveDecoration() methods.

    1058. 

  1058.         /// </para>

    1059. 

  1059.         /// <para>

    1060. 

  1060.         /// A decoration scrolls with the list contents. An overlay is fixed in place.

    1061. 

  1061.         /// </para>

    1062. 

  1062.         /// </remarks>

    1063. 

  1063.         [Browsable(false)]

    1064. 

  1064.         protected IList<IDecoration> Decorations {

    1065. 

  1065.             get { return this.decorations; }

    1066. 

  1066.         }

    1067. 

  1067.         private List<IDecoration> decorations = new List<IDecoration>();

    1068. 

  1068. 

    1069. 

  1069.         /// <summary>

    1070. 

  1070.         /// When owner drawing, this renderer will draw columns that do not have specific renderer

    1071. 

  1071.         /// given to them

    1072. 

  1072.         /// </summary>

    1073. 

  1073.         /// <remarks>If you try to set this to null, it will revert to a BaseRenderer</remarks>

    1074. 

  1074.         [Browsable(false),

    1075. 

  1075.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    1076. 

  1076.         public IRenderer DefaultRenderer {

    1077. 

  1077.             get { return this.defaultRenderer; }

    1078. 

  1078.             set { this.defaultRenderer = value ?? new BaseRenderer(); }

    1079. 

  1079.         }

    1080. 

  1080.         private IRenderer defaultRenderer = new BaseRenderer();

    1081. 

  1081. 

    1082. 

  1082.         /// <summary>

    1083. 

  1083.         /// Gets or sets the object that controls how drags start from this control

    1084. 

  1084.         /// </summary>

    1085. 

  1085.         [Browsable(false),

    1086. 

  1086.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    1087. 

  1087.         public IDragSource DragSource {

    1088. 

  1088.             get { return this.dragSource; }

    1089. 

  1089.             set { this.dragSource = value; }

    1090. 

  1090.         }

    1091. 

  1091.         private IDragSource dragSource;

    1092. 

  1092. 

    1093. 

  1093.         /// <summary>

    1094. 

  1094.         /// Gets or sets the object that controls how drops are accepted and processed

    1095. 

  1095.         /// by this ListView.

    1096. 

  1096.         /// </summary>

    1097. 

  1097.         /// <remarks>

    1098. 

  1098.         /// <para>

    1099. 

  1099.         /// If the given sink is an instance of SimpleDropSink, then events from the drop sink

    1100. 

  1100.         /// will be automatically forwarded to the ObjectListView (which means that handlers

    1101. 

  1101.         /// for those event can be configured within the IDE).

    1102. 

  1102.         /// </para>

    1103. 

  1103.         /// <para>If this is set to null, the control will not accept drops.</para>

    1104. 

  1104.         /// </remarks>

    1105. 

  1105.         [Browsable(false),

    1106. 

  1106.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    1107. 

  1107.         public IDropSink DropSink {

    1108. 

  1108.             get { return this.dropSink; }

    1109. 

  1109.             set {

    1110. 

  1110.                 if (this.dropSink == value)

    1111. 

  1111.                     return;

    1112. 

  1112. 

    1113. 

  1113.                 // Stop listening for events on the old sink

    1114. 

  1114.                 SimpleDropSink oldSink = this.dropSink as SimpleDropSink;

    1115. 

  1115.                 if (oldSink != null) {

    1116. 

  1116.                     oldSink.CanDrop -= new EventHandler<OlvDropEventArgs>(dropSink_CanDrop);

    1117. 

  1117.                     oldSink.Dropped -= new EventHandler<OlvDropEventArgs>(dropSink_Dropped);

    1118. 

  1118.                     oldSink.ModelCanDrop -= new EventHandler<ModelDropEventArgs>(dropSink_ModelCanDrop);

    1119. 

  1119.                     oldSink.ModelDropped -= new EventHandler<ModelDropEventArgs>(dropSink_ModelDropped);

    1120. 

  1120.                 }

    1121. 

  1121. 

    1122. 

  1122.                 this.dropSink = value;

    1123. 

  1123.                 this.AllowDrop = (value != null);

    1124. 

  1124.                 if (this.dropSink != null)

    1125. 

  1125.                     this.dropSink.ListView = this;

    1126. 

  1126. 

    1127. 

  1127.                 // Start listening for events on the new sink

    1128. 

  1128.                 SimpleDropSink newSink = value as SimpleDropSink;

    1129. 

  1129.                 if (newSink != null) {

    1130. 

  1130.                     newSink.CanDrop += new EventHandler<OlvDropEventArgs>(dropSink_CanDrop);

    1131. 

  1131.                     newSink.Dropped += new EventHandler<OlvDropEventArgs>(dropSink_Dropped);

    1132. 

  1132.                     newSink.ModelCanDrop += new EventHandler<ModelDropEventArgs>(dropSink_ModelCanDrop);

    1133. 

  1133.                     newSink.ModelDropped += new EventHandler<ModelDropEventArgs>(dropSink_ModelDropped);

    1134. 

  1134.                 }

    1135. 

  1135.             }

    1136. 

  1136.         }

    1137. 

  1137.         private IDropSink dropSink;

    1138. 

  1138. 

    1139. 

  1139.         // Forward events from the drop sink to the control itself

    1140. 

  1140.         void dropSink_CanDrop(object sender, OlvDropEventArgs e) { this.OnCanDrop(e); }

    1141. 

  1141.         void dropSink_Dropped(object sender, OlvDropEventArgs e) { this.OnDropped(e); }

    1142. 

  1142.         void dropSink_ModelCanDrop(object sender, ModelDropEventArgs e) { this.OnModelCanDrop(e); }

    1143. 

  1143.         void dropSink_ModelDropped(object sender, ModelDropEventArgs e) { this.OnModelDropped(e); }

    1144. 

  1144. 

    1145. 

  1145.         /// <summary>

    1146. 

  1146.         /// This registry decides what control should be used to edit what cells, based

    1147. 

  1147.         /// on the type of the value in the cell.

    1148. 

  1148.         /// </summary>

    1149. 

  1149.         /// <see cref="EditorRegistry"/>

    1150. 

  1150.         /// <remarks>All instances of ObjectListView share the same editor registry.</remarks>

    1151. 

  1151.         static public EditorRegistry EditorRegistry = new EditorRegistry();

    1152. 

  1152. 

    1153. 

  1153.         /// <summary>

    1154. 

  1154.         /// Gets or sets the text that should be shown when there are no items in this list view.

    1155. 

  1155.         /// </summary>

    1156. 

  1156.         /// <remarks>If the EmptyListMsgOverlay has been changed to something other than a TextOverlay,

    1157. 

  1157.         /// this property does nothing</remarks>

    1158. 

  1158.         [Category("ObjectListView"),

    1159. 

  1159.          Description("When the list has no items, show this message in the control"),

    1160. 

  1160.          DefaultValue(null),

    1161. 

  1161.          Localizable(true)]

    1162. 

  1162.         public virtual String EmptyListMsg {

    1163. 

  1163.             get {

    1164. 

  1164.                 TextOverlay overlay = this.EmptyListMsgOverlay as TextOverlay;

    1165. 

  1165.                 if (overlay == null)

    1166. 

  1166.                     return null;

    1167. 

  1167.                 else

    1168. 

  1168.                     return overlay.Text;

    1169. 

  1169.             }

    1170. 

  1170.             set {

    1171. 

  1171.                 TextOverlay overlay = this.EmptyListMsgOverlay as TextOverlay;

    1172. 

  1172.                 if (overlay != null) {

    1173. 

  1173.                     overlay.Text = value;

    1174. 

  1174.                     this.Invalidate();

    1175. 

  1175.                 }

    1176. 

  1176.             }

    1177. 

  1177.         }

    1178. 

  1178. 

    1179. 

  1179.         /// <summary>

    1180. 

  1180.         /// Gets or sets the font in which the List Empty message should be drawn

    1181. 

  1181.         /// </summary>

    1182. 

  1182.         /// <remarks>If the EmptyListMsgOverlay has been changed to something other than a TextOverlay,

    1183. 

  1183.         /// this property does nothing</remarks>

    1184. 

  1184.         [Category("ObjectListView"),

    1185. 

  1185.         Description("What font should the 'list empty' message be drawn in?"),

    1186. 

  1186.         DefaultValue(null)]

    1187. 

  1187.         public virtual Font EmptyListMsgFont {

    1188. 

  1188.             get {

    1189. 

  1189.                 TextOverlay overlay = this.EmptyListMsgOverlay as TextOverlay;

    1190. 

  1190.                 if (overlay == null)

    1191. 

  1191.                     return null;

    1192. 

  1192.                 else

    1193. 

  1193.                     return overlay.Font;

    1194. 

  1194.             }

    1195. 

  1195.             set {

    1196. 

  1196.                 TextOverlay overlay = this.EmptyListMsgOverlay as TextOverlay;

    1197. 

  1197.                 if (overlay != null)

    1198. 

  1198.                     overlay.Font = value;

    1199. 

  1199.             }

    1200. 

  1200.         }

    1201. 

  1201. 

    1202. 

  1202.         /// <summary>

    1203. 

  1203.         /// Return the font for the 'list empty' message or a reasonable default

    1204. 

  1204.         /// </summary>

    1205. 

  1205.         [Browsable(false)]

    1206. 

  1206.         public virtual Font EmptyListMsgFontOrDefault {

    1207. 

  1207.             get {

    1208. 

  1208.                return this.EmptyListMsgFont ?? new Font("Tahoma", 14);

    1209. 

  1209.             }

    1210. 

  1210.         }

    1211. 

  1211. 

    1212. 

  1212.         /// <summary>

    1213. 

  1213.         /// Gets or sets the overlay responsible for drawing the List Empty msg.

    1214. 

  1214.         /// </summary>

    1215. 

  1215.         [Browsable(false),

    1216. 

  1216.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    1217. 

  1217.         public virtual IOverlay EmptyListMsgOverlay {

    1218. 

  1218.             get { return this.emptyListMsgOverlay; }

    1219. 

  1219.             set {

    1220. 

  1220.                 if (this.emptyListMsgOverlay != value) {

    1221. 

  1221.                     this.emptyListMsgOverlay = value;

    1222. 

  1222.                     this.Invalidate();

    1223. 

  1223.                 }

    1224. 

  1224.             }

    1225. 

  1225.         }

    1226. 

  1226.         private IOverlay emptyListMsgOverlay;

    1227. 

  1227. 

    1228. 

  1228.         /// <summary>

    1229. 

  1229.         /// Gets the collection of objects that survive any filtering that may be in place.

    1230. 

  1230.         /// </summary>

    1231. 

  1231.         /// <remarks>

    1232. 

  1232.         /// <para>

    1233. 

  1233.         /// This collection is the result of filtering the current list of objects. 

    1234. 

  1234.         /// It is not a snapshot of the filtered list that was last used to build the control. 

    1235. 

  1235.         /// </para>

    1236. 

  1236.         /// <para>

    1237. 

  1237.         /// Normal warnings apply when using this with virtual lists. It will work, but it

    1238. 

  1238.         /// may take a while.

    1239. 

  1239.         /// </para>

    1240. 

  1240.         /// </remarks>

    1241. 

  1241.         [Browsable(false),

    1242. 

  1242.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    1243. 

  1243.         virtual public IEnumerable FilteredObjects {

    1244. 

  1244.             get {

    1245. 

  1245.                 if (this.IsFiltering)

    1246. 

  1246.                     return this.FilterObjects(this.Objects, this.ModelFilter, this.ListFilter);

    1247. 

  1247.                 else

    1248. 

  1248.                     return this.Objects;

    1249. 

  1249.             }

    1250. 

  1250.         }

    1251. 

  1251. 

    1252. 

  1252.         /// <summary>

    1253. 

  1253.         /// Gets or sets the strategy object that will be used to build the Filter menu

    1254. 

  1254.         /// </summary>

    1255. 

  1255.         /// <remarks>If this is null, no filter menu will be built.</remarks>

    1256. 

  1256.         [Browsable(false),

    1257. 

  1257.         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    1258. 

  1258.         public FilterMenuBuilder FilterMenuBuildStrategy {

    1259. 

  1259.             get { return filterMenuBuilder; }

    1260. 

  1260.             set { filterMenuBuilder = value; }

    1261. 

  1261.         }

    1262. 

  1262.         private FilterMenuBuilder filterMenuBuilder = new FilterMenuBuilder();

    1263. 

  1263. 

    1264. 

  1264.         /// <summary>

    1265. 

  1265.         /// Get or set whether or not the listview is frozen. When the listview is

    1266. 

  1266.         /// frozen, it will not update itself.

    1267. 

  1267.         /// </summary>

    1268. 

  1268.         /// <remarks><para>The Frozen property is similar to the methods Freeze()/Unfreeze()

    1269. 

  1269.         /// except that changes to the Frozen property do not nest.</para></remarks>

    1270. 

  1270.         /// <example>objectListView1.Frozen = false; // unfreeze the control regardless of the number of Freeze() calls

    1271. 

  1271.         /// </example>

    1272. 

  1272.         [Browsable(false),

    1273. 

  1273.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    1274. 

  1274.         public virtual bool Frozen {

    1275. 

  1275.             get { return freezeCount > 0; }

    1276. 

  1276.             set {

    1277. 

  1277.                 if (value)

    1278. 

  1278.                     Freeze();

    1279. 

  1279.                 else if (freezeCount > 0) {

    1280. 

  1280.                     freezeCount = 1;

    1281. 

  1281.                     Unfreeze();

    1282. 

  1282.                 }

    1283. 

  1283.             }

    1284. 

  1284.         }

    1285. 

  1285.         private int freezeCount;

    1286. 

  1286. 

    1287. 

  1287.         /// <summary>

    1288. 

  1288.         /// Hide the Groups collection so it's not visible in the Properties grid.

    1289. 

  1289.         /// </summary>

    1290. 

  1290.         [Browsable(false),

    1291. 

  1291.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    1292. 

  1292.         new public ListViewGroupCollection Groups {

    1293. 

  1293.             get { return base.Groups; }

    1294. 

  1294.         }

    1295. 

  1295. 

    1296. 

  1296.         /// <summary>

    1297. 

  1297.         /// Gets or sets the image list from which group header will take their images

    1298. 

  1298.         /// </summary>

    1299. 

  1299.         /// <remarks>If this is not set, then group headers will not show any images.</remarks>

    1300. 

  1300.         [Category("ObjectListView"),

    1301. 

  1301.          Description("The image list from which group header will take their images"),

    1302. 

  1302.          DefaultValue(null)]

    1303. 

  1303.         public ImageList GroupImageList {

    1304. 

  1304.             get { return this.groupImageList; }

    1305. 

  1305.             set {

    1306. 

  1306.                 this.groupImageList = value;

    1307. 

  1307.                 if (this.Created) {

    1308. 

  1308.                     int x = NativeMethods.SetGroupImageList(this, value);

    1309. 

  1309.                 }

    1310. 

  1310.             }

    1311. 

  1311.         }

    1312. 

  1312.         private ImageList groupImageList;

    1313. 

  1313. 

    1314. 

  1314.         /// <summary>

    1315. 

  1315.         /// Gets how the group label should be formatted when a group is empty or

    1316. 

  1316.         /// contains more than one item

    1317. 

  1317.         /// </summary>

    1318. 

  1318.         /// <remarks>

    1319. 

  1319.         /// The given format string must have two placeholders:

    1320. 

  1320.         /// <list type="bullet">

    1321. 

  1321.         /// <item><description>{0} - the original group title</description></item>

    1322. 

  1322.         /// <item><description>{1} - the number of items in the group</description></item>

    1323. 

  1323.         /// </list>

    1324. 

  1324.         /// </remarks>

    1325. 

  1325.         /// <example>"{0} [{1} items]"</example>

    1326. 

  1326.         [Category("ObjectListView"),

    1327. 

  1327.          Description("The format to use when suffixing item counts to group titles"),

    1328. 

  1328.          DefaultValue(null),

    1329. 

  1329.          Localizable(true)]

    1330. 

  1330.         public virtual string GroupWithItemCountFormat {

    1331. 

  1331.             get { return groupWithItemCountFormat; }

    1332. 

  1332.             set { groupWithItemCountFormat = value; }

    1333. 

  1333.         }

    1334. 

  1334.         private string groupWithItemCountFormat;

    1335. 

  1335. 

    1336. 

  1336.         /// <summary>

    1337. 

  1337.         /// Return this.GroupWithItemCountFormat or a reasonable default

    1338. 

  1338.         /// </summary>

    1339. 

  1339.         [Browsable(false)]

    1340. 

  1340.         public virtual string GroupWithItemCountFormatOrDefault {

    1341. 

  1341.             get {

    1342. 

  1342.                 if (String.IsNullOrEmpty(this.GroupWithItemCountFormat))

    1343. 

  1343.                     return "{0} [{1} items]";

    1344. 

  1344.                 else

    1345. 

  1345.                     return this.GroupWithItemCountFormat;

    1346. 

  1346.             }

    1347. 

  1347.         }

    1348. 

  1348. 

    1349. 

  1349.         /// <summary>

    1350. 

  1350.         /// Gets how the group label should be formatted when a group contains only a single item

    1351. 

  1351.         /// </summary>

    1352. 

  1352.         /// <remarks>

    1353. 

  1353.         /// The given format string must have two placeholders:

    1354. 

  1354.         /// <list type="bullet">

    1355. 

  1355.         /// <item><description>{0} - the original group title</description></item>

    1356. 

  1356.         /// <item><description>{1} - the number of items in the group (always 1)</description></item>

    1357. 

  1357.         /// </list>

    1358. 

  1358.         /// </remarks>

    1359. 

  1359.         /// <example>"{0} [{1} item]"</example>

    1360. 

  1360.         [Category("ObjectListView"),

    1361. 

  1361.          Description("The format to use when suffixing item counts to group titles"),

    1362. 

  1362.          DefaultValue(null),

    1363. 

  1363.          Localizable(true)]

    1364. 

  1364.         public virtual string GroupWithItemCountSingularFormat {

    1365. 

  1365.             get { return groupWithItemCountSingularFormat; }

    1366. 

  1366.             set { groupWithItemCountSingularFormat = value; }

    1367. 

  1367.         }

    1368. 

  1368.         private string groupWithItemCountSingularFormat;

    1369. 

  1369. 

    1370. 

  1370.         /// <summary>

    1371. 

  1371.         /// Gets GroupWithItemCountSingularFormat or a reasonable default

    1372. 

  1372.         /// </summary>

    1373. 

  1373.         [Browsable(false)]

    1374. 

  1374.         public virtual string GroupWithItemCountSingularFormatOrDefault {

    1375. 

  1375.             get {

    1376. 

  1376.                 if (String.IsNullOrEmpty(this.GroupWithItemCountSingularFormat))

    1377. 

  1377.                     return "{0} [{1} item]";

    1378. 

  1378.                 else

    1379. 

  1379.                     return this.GroupWithItemCountSingularFormat;

    1380. 

  1380.             }

    1381. 

  1381.         }

    1382. 

  1382. 

    1383. 

  1383.         /// <summary>

    1384. 

  1384.         /// Gets or sets whether or not the groups in this ObjectListView should be collapsible.

    1385. 

  1385.         /// </summary>

    1386. 

  1386.         /// <remarks>

    1387. 

  1387.         /// This feature only works under Vista and later.

    1388. 

  1388.         /// </remarks>

    1389. 

  1389.         [Browsable(true),

    1390. 

  1390.          Category("ObjectListView"),

    1391. 

  1391.          Description("Should the groups in this control be collapsible (Vista and later only)."),

    1392. 

  1392.          DefaultValue(true)]

    1393. 

  1393.         public bool HasCollapsibleGroups {

    1394. 

  1394.             get { return hasCollapsibleGroups; }

    1395. 

  1395.             set { hasCollapsibleGroups = value; }

    1396. 

  1396.         }

    1397. 

  1397.         private bool hasCollapsibleGroups = true;

    1398. 

  1398. 

    1399. 

  1399.         /// <summary>

    1400. 

  1400.         /// Does this listview have a message that should be drawn when the list is empty?

    1401. 

  1401.         /// </summary>

    1402. 

  1402.         [Browsable(false)]

    1403. 

  1403.         public virtual bool HasEmptyListMsg {

    1404. 

  1404.             get { return !String.IsNullOrEmpty(this.EmptyListMsg); }

    1405. 

  1405.         }

    1406. 

  1406. 

    1407. 

  1407.         /// <summary>

    1408. 

  1408.         /// Get whether there are any overlays to be drawn

    1409. 

  1409.         /// </summary>

    1410. 

  1410.         [Browsable(false)]

    1411. 

  1411.         public bool HasOverlays {

    1412. 

  1412.             get {

    1413. 

  1413.                 return (this.Overlays.Count > 2 ||

    1414. 

  1414.                     this.imageOverlay.Image != null ||

    1415. 

  1415.                     !String.IsNullOrEmpty(this.textOverlay.Text));

    1416. 

  1416.             }

    1417. 

  1417.         }

    1418. 

  1418. 

    1419. 

  1419.         /// <summary>

    1420. 

  1420.         /// Gets the header control for the ListView

    1421. 

  1421.         /// </summary>

    1422. 

  1422.         [Browsable(false)]

    1423. 

  1423.         public HeaderControl HeaderControl {

    1424. 

  1424.             get {

    1425. 

  1425.                 if (this.headerControl == null)

    1426. 

  1426.                     this.headerControl = new HeaderControl(this);

    1427. 

  1427.                 return this.headerControl;

    1428. 

  1428.             }

    1429. 

  1429.         }

    1430. 

  1430.         private HeaderControl headerControl;

    1431. 

  1431. 

    1432. 

  1432.         /// <summary>

    1433. 

  1433.         /// Gets or sets the font in which the text of the column headers will be drawn

    1434. 

  1434.         /// </summary>

    1435. 

  1435.         /// <remarks>Individual columns can override this through their HeaderFormatStyle property.</remarks>

    1436. 

  1436.         [DefaultValue(null)]

    1437. 

  1437.         [Browsable(false)]

    1438. 

  1438.         [Obsolete("Use a HeaderFormatStyle instead", false)]

    1439. 

  1439.         public Font HeaderFont {

    1440. 

  1440.             get { return this.HeaderFormatStyle == null ? null : this.HeaderFormatStyle.Normal.Font; }

    1441. 

  1441.             set {

    1442. 

  1442.                 if (value == null && this.HeaderFormatStyle == null)

    1443. 

  1443.                     return;

    1444. 

  1444. 

    1445. 

  1445.                 if (this.HeaderFormatStyle == null)

    1446. 

  1446.                     this.HeaderFormatStyle = new HeaderFormatStyle();

    1447. 

  1447. 

    1448. 

  1448.                 this.HeaderFormatStyle.SetFont(value);

    1449. 

  1449.             }

    1450. 

  1450.         }

    1451. 

  1451. 

    1452. 

  1452.         /// <summary>

    1453. 

  1453.         /// Gets or sets the style that will be used to draw the columm headers of the listview

    1454. 

  1454.         /// </summary>

    1455. 

  1455.         /// <remarks>

    1456. 

  1456.         /// <para>

    1457. 

  1457.         /// This is only used when HeaderUsesThemes is false.

    1458. 

  1458.         /// </para>

    1459. 

  1459.         /// <para>

    1460. 

  1460.         /// Individual columns can override this through their HeaderFormatStyle property.

    1461. 

  1461.         /// </para>

    1462. 

  1462.         /// </remarks>

    1463. 

  1463.         [Category("ObjectListView"),

    1464. 

  1464.          Description("What style will be used to draw the control's header"),

    1465. 

  1465.          DefaultValue(null)]

    1466. 

  1466.         public HeaderFormatStyle HeaderFormatStyle {

    1467. 

  1467.             get { return this.headerFormatStyle; }

    1468. 

  1468.             set { this.headerFormatStyle = value; }

    1469. 

  1469.         }

    1470. 

  1470.         private HeaderFormatStyle headerFormatStyle;

    1471. 

  1471. 

    1472. 

  1472.         /// <summary>

    1473. 

  1473.         /// Gets or sets the maximum height of the header. -1 means no maximum.

    1474. 

  1474.         /// </summary>

    1475. 

  1475.         [Category("ObjectListView"),

    1476. 

  1476.          Description("What is the maximum height of the header? -1 means no maximum"),

    1477. 

  1477.          DefaultValue(-1)]

    1478. 

  1478.         public int HeaderMaximumHeight {

    1479. 

  1479.             get { return headerMaximumHeight; }

    1480. 

  1480.             set { headerMaximumHeight = value; }

    1481. 

  1481.         }

    1482. 

  1482.         private int headerMaximumHeight = -1;

    1483. 

  1483. 

    1484. 

  1484.         /// <summary>

    1485. 

  1485.         /// Gets or sets whether the header will be drawn strictly according to the OS's theme. 

    1486. 

  1486.         /// </summary>

    1487. 

  1487.         /// <remarks>

    1488. 

  1488.         /// <para>

    1489. 

  1489.         /// If this is set to true, the header will be rendered completely by the system, without

    1490. 

  1490.         /// any of ObjectListViews fancy processing -- no images in header, no filter indicators,

    1491. 

  1491.         /// no word wrapping, no header styling.

    1492. 

  1492.         /// </para>

    1493. 

  1493.         /// <para>If this is set to false, ObjectListView will render the header as it thinks best.

    1494. 

  1494.         /// If no special features are required, then ObjectListView will delegate rendering to the OS.

    1495. 

  1495.         /// Otherwise, ObjectListView will draw the header according to the configuration settings.

    1496. 

  1496.         /// </para>

    1497. 

  1497.         /// <para>

    1498. 

  1498.         /// The effect of not being themed will be different from OS to OS. At

    1499. 

  1499.         /// very least, the sort indicator will not be standard. 

    1500. 

  1500.         /// </para>

    1501. 

  1501.         /// </remarks>

    1502. 

  1502.         [Category("ObjectListView"),

    1503. 

  1503.          Description("Will the column headers be drawn strictly according to OS theme?"),

    1504. 

  1504.          DefaultValue(true)]

    1505. 

  1505.         public bool HeaderUsesThemes {

    1506. 

  1506.             get { return this.headerUsesThemes; }

    1507. 

  1507.             set { this.headerUsesThemes = value; }

    1508. 

  1508.         }

    1509. 

  1509.         private bool headerUsesThemes = true;

    1510. 

  1510. 

    1511. 

  1511.         /// <summary>

    1512. 

  1512.         /// Gets or sets the whether the text in the header will be word wrapped.

    1513. 

  1513.         /// </summary>

    1514. 

  1514.         /// <remarks>

    1515. 

  1515.         /// <para>THIS FEATURE IS EXPERIMENTAL (August 2009)</para>

    1516. 

  1516.         /// <para>Line breaks will be applied between words. Words that are too long

    1517. 

  1517.         /// will still be ellipsed.</para>

    1518. 

  1518.         /// <para>

    1519. 

  1519.         /// As with all settings that make the header look different, HeaderUsesThemes must be set to false, otherwise

    1520. 

  1520.         /// the OS will be responsible for drawing the header, and it does not allow word wrapped text.

    1521. 

  1521.         /// </para>

    1522. 

  1522.         /// </remarks>

    1523. 

  1523.         [Category("ObjectListView"),

    1524. 

  1524.          Description("Will the text of the column headers be word wrapped?"),

    1525. 

  1525.          DefaultValue(false)]

    1526. 

  1526.         public bool HeaderWordWrap {

    1527. 

  1527.             get { return this.headerWordWrap; }

    1528. 

  1528.             set {

    1529. 

  1529.                 this.headerWordWrap = value;

    1530. 

  1530.                 if (this.headerControl != null)

    1531. 

  1531.                     this.headerControl.WordWrap = value;

    1532. 

  1532.             }

    1533. 

  1533.         }

    1534. 

  1534.         private bool headerWordWrap;

    1535. 

  1535. 

    1536. 

  1536.         /// <summary>

    1537. 

  1537.         /// Gets the tool tip that shows tips for the column headers

    1538. 

  1538.         /// </summary>

    1539. 

  1539.         [Browsable(false)]

    1540. 

  1540.         public ToolTipControl HeaderToolTip {

    1541. 

  1541.             get {

    1542. 

  1542.                 return this.HeaderControl.ToolTip;

    1543. 

  1543.             }

    1544. 

  1544.         }

    1545. 

  1545. 

    1546. 

  1546.         /// <summary>

    1547. 

  1547.         /// Gets the index of the row that the mouse is currently over

    1548. 

  1548.         /// </summary>

    1549. 

  1549.         [Browsable(false),

    1550. 

  1550.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    1551. 

  1551.         public virtual int HotRowIndex {

    1552. 

  1552.             get { return this.hotRowIndex; }

    1553. 

  1553.             protected set { this.hotRowIndex = value; }

    1554. 

  1554.         }

    1555. 

  1555.         private int hotRowIndex;

    1556. 

  1556. 

    1557. 

  1557.         /// <summary>

    1558. 

  1558.         /// Gets the index of the subitem that the mouse is currently over

    1559. 

  1559.         /// </summary>

    1560. 

  1560.         [Browsable(false),

    1561. 

  1561.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    1562. 

  1562.         public virtual int HotColumnIndex {

    1563. 

  1563.             get { return this.hotColumnIndex; }

    1564. 

  1564.             protected set { this.hotColumnIndex = value; }

    1565. 

  1565.         }

    1566. 

  1566.         private int hotColumnIndex;

    1567. 

  1567. 

    1568. 

  1568.         /// <summary>

    1569. 

  1569.         /// Gets the part of the item/subitem that the mouse is currently over

    1570. 

  1570.         /// </summary>

    1571. 

  1571.         [Browsable(false),

    1572. 

  1572.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    1573. 

  1573.         public virtual HitTestLocation HotCellHitLocation {

    1574. 

  1574.             get { return this.hotCellHitLocation; }

    1575. 

  1575.             protected set { this.hotCellHitLocation = value; }

    1576. 

  1576.         }

    1577. 

  1577.         private HitTestLocation hotCellHitLocation;

    1578. 

  1578. 

    1579. 

  1579.         /// <summary>

    1580. 

  1580.         /// The index of the item that is 'hot', i.e. under the cursor. -1 means no item.

    1581. 

  1581.         /// </summary>

    1582. 

  1582.         [Browsable(false),

    1583. 

  1583.          Obsolete("Use HotRowIndex instead", false)]

    1584. 

  1584.         public virtual int HotItemIndex {

    1585. 

  1585.             get { return this.HotRowIndex; }

    1586. 

  1586.         }

    1587. 

  1587. 

    1588. 

  1588.         /// <summary>

    1589. 

  1589.         /// What sort of formatting should be applied to the row under the cursor?

    1590. 

  1590.         /// </summary>

    1591. 

  1591.         /// <remarks>This only takes effect when UseHotItem is true.</remarks>

    1592. 

  1592.         [Category("ObjectListView"),

    1593. 

  1593.          Description("How should the row under the cursor be highlighted"),

    1594. 

  1594.          DefaultValue(null)]

    1595. 

  1595.         public virtual HotItemStyle HotItemStyle {

    1596. 

  1596.             get { return this.hotItemStyle; }

    1597. 

  1597.             set {

    1598. 

  1598.                 if (this.HotItemStyle != null)

    1599. 

  1599.                     this.RemoveOverlay(this.HotItemStyle.Overlay);

    1600. 

  1600.                 this.hotItemStyle = value;

    1601. 

  1601.                 if (this.HotItemStyle != null)

    1602. 

  1602.                     this.AddOverlay(this.HotItemStyle.Overlay);

    1603. 

  1603.             }

    1604. 

  1604.         }

    1605. 

  1605.         private HotItemStyle hotItemStyle;

    1606. 

  1606. 

    1607. 

  1607.         /// <summary>

    1608. 

  1608.         /// What sort of formatting should be applied to hyperlinks?

    1609. 

  1609.         /// </summary>

    1610. 

  1610.         [Category("ObjectListView"),

    1611. 

  1611.          Description("How should hyperlinks be drawn"),

    1612. 

  1612.          DefaultValue(null)]

    1613. 

  1613.         public virtual HyperlinkStyle HyperlinkStyle {

    1614. 

  1614.             get { return this.hyperlinkStyle; }

    1615. 

  1615.             set { this.hyperlinkStyle = value; }

    1616. 

  1616.         }

    1617. 

  1617.         private HyperlinkStyle hyperlinkStyle;

    1618. 

  1618. 

    1619. 

  1619.         /// <summary>

    1620. 

  1620.         /// What color should be used for the background of selected rows?

    1621. 

  1621.         /// </summary>

    1622. 

  1622.         /// <remarks>Windows does not give the option of changing the selection background.

    1623. 

  1623.         /// So the control has to be owner drawn to see the result of this setting.

    1624. 

  1624.         /// Setting UseCustomSelectionColors = true will do this for you.</remarks>

    1625. 

  1625.         [Category("ObjectListView"),

    1626. 

  1626.          Description("The background foregroundColor of selected rows when the control is owner drawn"),

    1627. 

  1627.          DefaultValue(typeof(Color), "")]

    1628. 

  1628.         public virtual Color HighlightBackgroundColor {

    1629. 

  1629.             get { return highlightBackgroundColor; }

    1630. 

  1630.             set { highlightBackgroundColor = value; }

    1631. 

  1631.         }

    1632. 

  1632.         private Color highlightBackgroundColor = Color.Empty;

    1633. 

  1633. 

    1634. 

  1634.         /// <summary>

    1635. 

  1635.         /// Return the color should be used for the background of selected rows or a reasonable default

    1636. 

  1636.         /// </summary>

    1637. 

  1637.         [Browsable(false)]

    1638. 

  1638.         public virtual Color HighlightBackgroundColorOrDefault {

    1639. 

  1639.             get {

    1640. 

  1640.                 if (this.HighlightBackgroundColor.IsEmpty)

    1641. 

  1641.                     return SystemColors.Highlight;

    1642. 

  1642.                 else

    1643. 

  1643.                     return this.HighlightBackgroundColor;

    1644. 

  1644.             }

    1645. 

  1645.         }

    1646. 

  1646. 

    1647. 

  1647.         /// <summary>

    1648. 

  1648.         /// What color should be used for the foreground of selected rows?

    1649. 

  1649.         /// </summary>

    1650. 

  1650.         /// <remarks>Windows does not give the option of changing the selection foreground (text color).

    1651. 

  1651.         /// So the control has to be owner drawn to see the result of this setting.

    1652. 

  1652.         /// Setting UseCustomSelectionColors = true will do this for you.</remarks>

    1653. 

  1653.         [Category("ObjectListView"),

    1654. 

  1654.          Description("The foreground foregroundColor of selected rows when the control is owner drawn"),

    1655. 

  1655.          DefaultValue(typeof(Color), "")]

    1656. 

  1656.         public virtual Color HighlightForegroundColor {

    1657. 

  1657.             get { return highlightForegroundColor; }

    1658. 

  1658.             set { highlightForegroundColor = value; }

    1659. 

  1659.         }

    1660. 

  1660.         private Color highlightForegroundColor = Color.Empty;

    1661. 

  1661. 

    1662. 

  1662.         /// <summary>

    1663. 

  1663.         /// Return the color should be used for the foreground of selected rows or a reasonable default

    1664. 

  1664.         /// </summary>

    1665. 

  1665.         [Browsable(false)]

    1666. 

  1666.         public virtual Color HighlightForegroundColorOrDefault {

    1667. 

  1667.             get {

    1668. 

  1668.                 if (this.HighlightForegroundColor.IsEmpty)

    1669. 

  1669.                     return SystemColors.HighlightText;

    1670. 

  1670.                 else

    1671. 

  1671.                     return this.HighlightForegroundColor;

    1672. 

  1672.             }

    1673. 

  1673.         }

    1674. 

  1674. 

    1675. 

  1675.         /// <summary>

    1676. 

  1676.         /// Gets or sets whether or not hidden columns should be included in the text representation

    1677. 

  1677.         /// of rows that are copied or dragged to another application. If this is false (the default),

    1678. 

  1678.         /// only visible columns will be included.

    1679. 

  1679.         /// </summary>

    1680. 

  1680.         [Category("ObjectListView"),

    1681. 

  1681.         Description("When rows are copied or dragged, will data in hidden columns be included in the text? If this is false, only visible columns will be included."),

    1682. 

  1682.         DefaultValue(false)]

    1683. 

  1683.         public virtual bool IncludeHiddenColumnsInDataTransfer {

    1684. 

  1684.             get { return includeHiddenColumnsInDataTransfer; }

    1685. 

  1685.             set { includeHiddenColumnsInDataTransfer = value; }

    1686. 

  1686.         }

    1687. 

  1687.         private bool includeHiddenColumnsInDataTransfer = false;

    1688. 

  1688. 

    1689. 

  1689.         /// <summary>

    1690. 

  1690.         /// Gets or sets whether or not hidden columns should be included in the text representation

    1691. 

  1691.         /// of rows that are copied or dragged to another application. If this is false (the default),

    1692. 

  1692.         /// only visible columns will be included.

    1693. 

  1693.         /// </summary>

    1694. 

  1694.         [Category("ObjectListView"),

    1695. 

  1695.         Description("When rows are copied, will column headers be in the text?."),

    1696. 

  1696.         DefaultValue(false)]

    1697. 

  1697.         public virtual bool IncludeColumnHeadersInCopy

    1698. 

  1698.         {

    1699. 

  1699.             get { return includeColumnHeadersInCopy; }

    1700. 

  1700.             set { includeColumnHeadersInCopy = value; }

    1701. 

  1701.         }

    1702. 

  1702.         private bool includeColumnHeadersInCopy = false;

    1703. 

  1703. 

    1704. 

  1704.         /// <summary>

    1705. 

  1705.         /// Return true if a cell edit operation is currently happening

    1706. 

  1706.         /// </summary>

    1707. 

  1707.         [Browsable(false)]

    1708. 

  1708.         public virtual bool IsCellEditing {

    1709. 

  1709.             get { return this.cellEditor != null; }

    1710. 

  1710.         }

    1711. 

  1711. 

    1712. 

  1712.         /// <summary>

    1713. 

  1713.         /// Return true if the ObjectListView is being used within the development environment.

    1714. 

  1714.         /// </summary>

    1715. 

  1715.         [Browsable(false)]

    1716. 

  1716.         public virtual bool IsDesignMode {

    1717. 

  1717.             get { return this.DesignMode; }

    1718. 

  1718.         }

    1719. 

  1719. 

    1720. 

  1720.         /// <summary>

    1721. 

  1721.         /// Gets whether or not the current list is filtering its contents

    1722. 

  1722.         /// </summary>

    1723. 

  1723.         [Browsable(false),

    1724. 

  1724.         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    1725. 

  1725.         virtual public bool IsFiltering {

    1726. 

  1726.             get { return this.UseFiltering && (this.ModelFilter != null || this.ListFilter != null); }

    1727. 

  1727.         }

    1728. 

  1728. 

    1729. 

  1729.         /// <summary>

    1730. 

  1730.         /// When the user types into a list, should the values in the current sort column be searched to find a match?

    1731. 

  1731.         /// If this is false, the primary column will always be used regardless of the sort column.

    1732. 

  1732.         /// </summary>

    1733. 

  1733.         /// <remarks>When this is true, the behavior is like that of ITunes.</remarks>

    1734. 

  1734.         [Category("ObjectListView"),

    1735. 

  1735.         Description("When the user types into a list, should the values in the current sort column be searched to find a match?"),

    1736. 

  1736.         DefaultValue(true)]

    1737. 

  1737.         public virtual bool IsSearchOnSortColumn {

    1738. 

  1738.             get { return isSearchOnSortColumn; }

    1739. 

  1739.             set { isSearchOnSortColumn = value; }

    1740. 

  1740.         }

    1741. 

  1741.         private bool isSearchOnSortColumn = true;

    1742. 

  1742. 

    1743. 

  1743.         /// <summary>

    1744. 

  1744.         /// Gets or sets if this control will use a SimpleDropSink to receive drops

    1745. 

  1745.         /// </summary>

    1746. 

  1746.         /// <remarks>

    1747. 

  1747.         /// <para>

    1748. 

  1748.         /// Setting this replaces any previous DropSink.

    1749. 

  1749.         /// </para>

    1750. 

  1750.         /// <para>

    1751. 

  1751.         /// After setting this to true, the SimpleDropSink will still need to be configured

    1752. 

  1752.         /// to say when it can accept drops and what should happen when something is dropped.

    1753. 

  1753.         /// The need to do these things makes this property mostly useless :(

    1754. 

  1754.         /// </para>

    1755. 

  1755.         /// </remarks>

    1756. 

  1756.         [Category("ObjectListView"),

    1757. 

  1757.         Description("Should this control will use a SimpleDropSink to receive drops."),

    1758. 

  1758.         DefaultValue(false)]

    1759. 

  1759.         public virtual bool IsSimpleDropSink {

    1760. 

  1760.             get { return this.DropSink != null; }

    1761. 

  1761.             set {

    1762. 

  1762.                 if (value)

    1763. 

  1763.                     this.DropSink = new SimpleDropSink();

    1764. 

  1764.                 else

    1765. 

  1765.                     this.DropSink = null;

    1766. 

  1766.             }

    1767. 

  1767.         }

    1768. 

  1768. 

    1769. 

  1769.         /// <summary>

    1770. 

  1770.         /// Gets or sets if this control will use a SimpleDragSource to initiate drags

    1771. 

  1771.         /// </summary>

    1772. 

  1772.         /// <remarks>Setting this replaces any previous DragSource</remarks>

    1773. 

  1773.         [Category("ObjectListView"),

    1774. 

  1774.         Description("Should this control use a SimpleDragSource to initiate drags out from this control"),

    1775. 

  1775.         DefaultValue(false)]

    1776. 

  1776.         public virtual bool IsSimpleDragSource {

    1777. 

  1777.             get { return this.DragSource != null; }

    1778. 

  1778.             set {

    1779. 

  1779.                 if (value)

    1780. 

  1780.                     this.DragSource = new SimpleDragSource();

    1781. 

  1781.                 else

    1782. 

  1782.                     this.DragSource = null;

    1783. 

  1783.             }

    1784. 

  1784.         }

    1785. 

  1785. 

    1786. 

  1786.         /// <summary>

    1787. 

  1787.         /// Hide the Items collection so it's not visible in the Properties grid.

    1788. 

  1788.         /// </summary>

    1789. 

  1789.         [Browsable(false),

    1790. 

  1790.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    1791. 

  1791.         new public ListViewItemCollection Items {

    1792. 

  1792.             get { return base.Items; }

    1793. 

  1793.         }

    1794. 

  1794. 

    1795. 

  1795.         /// <summary>

    1796. 

  1796.         /// This renderer draws the items when in the list is in non-details view.

    1797. 

  1797.         /// In details view, the renderers for the individuals columns are responsible.

    1798. 

  1798.         /// </summary>

    1799. 

  1799.         [Category("ObjectListView"),

    1800. 

  1800.         Description("The owner drawn renderer that draws items when the list is in non-Details view."),

    1801. 

  1801.         DefaultValue(null)]

    1802. 

  1802.         public IRenderer ItemRenderer {

    1803. 

  1803.             get { return itemRenderer; }

    1804. 

  1804.             set { itemRenderer = value; }

    1805. 

  1805.         }

    1806. 

  1806.         private IRenderer itemRenderer;

    1807. 

  1807. 

    1808. 

  1808.         /// <summary>

    1809. 

  1809.         /// Which column did we last sort by

    1810. 

  1810.         /// </summary>

    1811. 

  1811.         /// <remarks>This is an alias for PrimarySortColumn</remarks>

    1812. 

  1812.         [Browsable(false),

    1813. 

  1813.         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    1814. 

  1814.         public virtual OLVColumn LastSortColumn {

    1815. 

  1815.             get { return this.PrimarySortColumn; }

    1816. 

  1816.             set { this.PrimarySortColumn = value; }

    1817. 

  1817.         }

    1818. 

  1818. 

    1819. 

  1819.         /// <summary>

    1820. 

  1820.         /// Which direction did we last sort

    1821. 

  1821.         /// </summary>

    1822. 

  1822.         /// <remarks>This is an alias for PrimarySortOrder</remarks>

    1823. 

  1823.         [Browsable(false),

    1824. 

  1824.         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    1825. 

  1825.         public virtual SortOrder LastSortOrder {

    1826. 

  1826.             get { return this.PrimarySortOrder; }

    1827. 

  1827.             set { this.PrimarySortOrder = value; }

    1828. 

  1828.         }

    1829. 

  1829. 

    1830. 

  1830.         /// <summary>

    1831. 

  1831.         /// Gets or  sets the filter that is applied to our whole list of objects.

    1832. 

  1832.         /// </summary>

    1833. 

  1833.         /// <remarks>

    1834. 

  1834.         /// The list is updated immediately to reflect this filter. 

    1835. 

  1835.         /// </remarks>

    1836. 

  1836.         [Browsable(false),

    1837. 

  1837.         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    1838. 

  1838.         public virtual IListFilter ListFilter {

    1839. 

  1839.             get { return listFilter; }

    1840. 

  1840.             set {

    1841. 

  1841.                 listFilter = value;

    1842. 

  1842.                 if (this.UseFiltering)

    1843. 

  1843.                     this.UpdateFiltering();

    1844. 

  1844.             }

    1845. 

  1845.         }

    1846. 

  1846.         private IListFilter listFilter;

    1847. 

  1847. 

    1848. 

  1848.         /// <summary>

    1849. 

  1849.         /// Gets or  sets the filter that is applied to each model objects in the list

    1850. 

  1850.         /// </summary>

    1851. 

  1851.         /// <remarks>

    1852. 

  1852.         /// The list is updated immediately to reflect this filter. 

    1853. 

  1853.         /// </remarks>

    1854. 

  1854.         [Browsable(false),

    1855. 

  1855.         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    1856. 

  1856.         public virtual IModelFilter ModelFilter {

    1857. 

  1857.             get { return modelFilter; }

    1858. 

  1858.             set {

    1859. 

  1859.                 modelFilter = value;

    1860. 

  1860.                 if (this.UseFiltering)

    1861. 

  1861.                     this.UpdateFiltering();

    1862. 

  1862.             }

    1863. 

  1863.         }

    1864. 

  1864.         private IModelFilter modelFilter;

    1865. 

  1865. 

    1866. 

  1866. 

    1867. 

  1867.         /// <summary>

    1868. 

  1868.         /// Gets the hit test info last time the mouse was moved.

    1869. 

  1869.         /// </summary>

    1870. 

  1870.         /// <remarks>Useful for hot item processing.</remarks>

    1871. 

  1871.         [Browsable(false),

    1872. 

  1872.         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    1873. 

  1873.         public virtual OlvListViewHitTestInfo MouseMoveHitTest {

    1874. 

  1874.             get { return mouseMoveHitTest; }

    1875. 

  1875.             private set { mouseMoveHitTest = value; }

    1876. 

  1876.         }

    1877. 

  1877.         private OlvListViewHitTestInfo mouseMoveHitTest;

    1878. 

  1878.         

    1879. 

  1879.         /// <summary>

    1880. 

  1880.         /// Gets or sets the list of groups shown by the listview.

    1881. 

  1881.         /// </summary>

    1882. 

  1882.         /// <remarks>

    1883. 

  1883.         /// This property does not work like the .NET Groups property. It should

    1884. 

  1884.         /// be treated as a read-only property.

    1885. 

  1885.         /// Changes made to the list are NOT reflected in the ListView itself -- it is pointless to add

    1886. 

  1886.         /// or remove groups to/from this list. Such modifications will do nothing.

    1887. 

  1887.         /// To do such things, you must listen for

    1888. 

  1888.         /// BeforeCreatingGroups or AboutToCreateGroups events, and change the list of

    1889. 

  1889.         /// groups in those events.

    1890. 

  1890.         /// </remarks>

    1891. 

  1891.         [Browsable(false),

    1892. 

  1892.         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    1893. 

  1893.         public IList<OLVGroup> OLVGroups {

    1894. 

  1894.             get { return this.olvGroups; }

    1895. 

  1895.             set { this.olvGroups = value; }

    1896. 

  1896.         }

    1897. 

  1897.         private IList<OLVGroup> olvGroups;

    1898. 

  1898. 

    1899. 

  1899.         /// <summary>

    1900. 

  1900.         /// Gets or sets whether the user wants to owner draw the header control

    1901. 

  1901.         /// themselves. If this is false (the default), ObjectListView will use

    1902. 

  1902.         /// custom drawing to render the header, if needed.

    1903. 

  1903.         /// </summary>

    1904. 

  1904.         /// <remarks>

    1905. 

  1905.         /// If you listen for the DrawColumnHeader event, you need to set this to true,

    1906. 

  1906.         /// otherwise your event handler will not be called.

    1907. 

  1907.         /// </remarks>

    1908. 

  1908.         [Category("ObjectListView"),

    1909. 

  1909.          Description("Should the DrawColumnHeader event be triggered"),

    1910. 

  1910.          DefaultValue(false)]

    1911. 

  1911.         public bool OwnerDrawnHeader {

    1912. 

  1912.             get { return ownerDrawnHeader; }

    1913. 

  1913.             set { ownerDrawnHeader = value; }

    1914. 

  1914.         }

    1915. 

  1915.         private bool ownerDrawnHeader;

    1916. 

  1916. 

    1917. 

  1917.         /// <summary>

    1918. 

  1918.         /// Get/set the collection of objects that this list will show

    1919. 

  1919.         /// </summary>

    1920. 

  1920.         /// <remarks>

    1921. 

  1921.         /// <para>

    1922. 

  1922.         /// The contents of the control will be updated immediately after setting this property.

    1923. 

  1923.         /// </para>

    1924. 

  1924.         /// <para>This method preserves selection, if possible. Use SetObjects() if

    1925. 

  1925.         /// you do not want to preserve the selection. Preserving selection is the slowest part of this

    1926. 

  1926.         /// code and performance is O(n) where n is the number of selected rows.</para>

    1927. 

  1927.         /// <para>This method is not thread safe.</para>

    1928. 

  1928.         /// <para>The property DOES work on virtual lists: setting is problem-free, but if you try to get it

    1929. 

  1929.         /// and the list has 10 million objects, it may take some time to return.</para>

    1930. 

  1930.         /// </remarks>

    1931. 

  1931.         [Browsable(false),

    1932. 

  1932.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    1933. 

  1933.         public virtual IEnumerable Objects {

    1934. 

  1934.             get {

    1935. 

  1935.                 return this.objects;

    1936. 

  1936.             }

    1937. 

  1937.             set {

    1938. 

  1938.                 this.BeginUpdate();

    1939. 

  1939.                 try {

    1940. 

  1940.                     IList previousSelection = this.SelectedObjects;

    1941. 

  1941.                     this.SetObjects(value);

    1942. 

  1942.                     this.SelectedObjects = previousSelection;

    1943. 

  1943.                 } finally {

    1944. 

  1944.                     this.EndUpdate();

    1945. 

  1945.                 }

    1946. 

  1946.             }

    1947. 

  1947.         }

    1948. 

  1948.         private IEnumerable objects;

    1949. 

  1949. 

    1950. 

  1950.         /// <summary>

    1951. 

  1951.         /// Gets or sets the image that will be drawn over the top of the ListView

    1952. 

  1952.         /// </summary>

    1953. 

  1953.         [Category("ObjectListView"),

    1954. 

  1954.          Description("The image that will be drawn over the top of the ListView"),

    1955. 

  1955.          DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]

    1956. 

  1956.         public ImageOverlay OverlayImage {

    1957. 

  1957.             get { return this.imageOverlay; }

    1958. 

  1958.             set {

    1959. 

  1959.                 if (this.imageOverlay == value)

    1960. 

  1960.                     return;

    1961. 

  1961. 

    1962. 

  1962.                 this.RemoveOverlay(this.imageOverlay);

    1963. 

  1963.                 this.imageOverlay = value;

    1964. 

  1964.                 this.AddOverlay(this.imageOverlay);

    1965. 

  1965.             }

    1966. 

  1966.         }

    1967. 

  1967.         private ImageOverlay imageOverlay;

    1968. 

  1968. 

    1969. 

  1969.         /// <summary>

    1970. 

  1970.         /// Gets or sets the text that will be drawn over the top of the ListView

    1971. 

  1971.         /// </summary>

    1972. 

  1972.         [Category("ObjectListView"),

    1973. 

  1973.          Description("The text that will be drawn over the top of the ListView"),

    1974. 

  1974.          DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]

    1975. 

  1975.         public TextOverlay OverlayText {

    1976. 

  1976.             get { return this.textOverlay; }

    1977. 

  1977.             set {

    1978. 

  1978.                 if (this.textOverlay == value)

    1979. 

  1979.                     return;

    1980. 

  1980. 

    1981. 

  1981.                 this.RemoveOverlay(this.textOverlay);

    1982. 

  1982.                 this.textOverlay = value;

    1983. 

  1983.                 this.AddOverlay(this.textOverlay);

    1984. 

  1984.             }

    1985. 

  1985.         }

    1986. 

  1986.         private TextOverlay textOverlay;

    1987. 

  1987. 

    1988. 

  1988.         /// <summary>

    1989. 

  1989.         /// Gets or sets the transparency of all the overlays.

    1990. 

  1990.         /// 0 is completely transparent, 255 is completely opaque.

    1991. 

  1991.         /// </summary>

    1992. 

  1992.         /// <remarks>

    1993. 

  1993.         /// This is obsolete. Use Transparency on each overlay.

    1994. 

  1994.         /// </remarks>

    1995. 

  1995.         [Browsable(false),

    1996. 

  1996.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    1997. 

  1997.         public int OverlayTransparency {

    1998. 

  1998.             get { return this.overlayTransparency; }

    1999. 

  1999.             set { this.overlayTransparency = Math.Min(255, Math.Max(0, value)); }

    2000. 

  2000.         }

    2001. 

  2001.         private int overlayTransparency = 128;

    2002. 

  2002. 

    2003. 

  2003.         /// <summary>

    2004. 

  2004.         /// Gets the list of overlays that will be drawn on top of the ListView

    2005. 

  2005.         /// </summary>

    2006. 

  2006.         /// <remarks>

    2007. 

  2007.         /// You can add new overlays and remove overlays that you have added, but

    2008. 

  2008.         /// don't mess with the overlays that you didn't create.

    2009. 

  2009.         /// </remarks>

    2010. 

  2010.         [Browsable(false)]

    2011. 

  2011.         protected IList<IOverlay> Overlays {

    2012. 

  2012.             get { return this.overlays; }

    2013. 

  2013.         }

    2014. 

  2014.         private List<IOverlay> overlays = new List<IOverlay>();

    2015. 

  2015. 

    2016. 

  2016.         /// <summary>

    2017. 

  2017.         /// Which column did we last sort by

    2018. 

  2018.         /// </summary>

    2019. 

  2019.         [Browsable(false),

    2020. 

  2020.         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    2021. 

  2021.         public virtual OLVColumn PrimarySortColumn {

    2022. 

  2022.             get { return this.primarySortColumn; }

    2023. 

  2023.             set {

    2024. 

  2024.                 this.primarySortColumn = value;

    2025. 

  2025.                 if (this.TintSortColumn) {

    2026. 

  2026.                     this.SelectedColumn = value;

    2027. 

  2027.                 }

    2028. 

  2028.             }

    2029. 

  2029.         }

    2030. 

  2030.         private OLVColumn primarySortColumn;

    2031. 

  2031. 

    2032. 

  2032.         /// <summary>

    2033. 

  2033.         /// Which direction did we last sort

    2034. 

  2034.         /// </summary>

    2035. 

  2035.         [Browsable(false),

    2036. 

  2036.         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    2037. 

  2037.         public virtual SortOrder PrimarySortOrder {

    2038. 

  2038.             get { return primarySortOrder; }

    2039. 

  2039.             set { primarySortOrder = value; }

    2040. 

  2040.         }

    2041. 

  2041.         private SortOrder primarySortOrder;

    2042. 

  2042. 

    2043. 

  2043.         /// <summary>

    2044. 

  2044.         /// Gets or sets if non-editable checkboxes are drawn as disabled.

    2045. 

  2045.         /// </summary>

    2046. 

  2046.         /// <remarks>

    2047. 

  2047.         /// <para>This only has effect in owner drawn mode.</para>

    2048. 

  2048.         /// </remarks>

    2049. 

  2049.         [Category("ObjectListView"),

    2050. 

  2050.          Description("Should non-editable checkboxes be drawn as disabled?"),

    2051. 

  2051.          DefaultValue(false)]

    2052. 

  2052.         public virtual bool RenderNonEditableCheckboxesAsDisabled {

    2053. 

  2053.             get { return renderNonEditableCheckboxesAsDisabled; }

    2054. 

  2054.             set { renderNonEditableCheckboxesAsDisabled = value; }

    2055. 

  2055.         }

    2056. 

  2056.         private bool renderNonEditableCheckboxesAsDisabled = false;

    2057. 

  2057. 

    2058. 

  2058.         /// <summary>

    2059. 

  2059.         /// Specify the height of each row in the control in pixels.

    2060. 

  2060.         /// </summary>

    2061. 

  2061.         /// <remarks><para>The row height in a listview is normally determined by the font size and the small image list size.

    2062. 

  2062.         /// This setting allows that calculation to be overridden (within reason: you still cannot set the line height to be

    2063. 

  2063.         /// less than the line height of the font used in the control). </para>

    2064. 

  2064.         /// <para>Setting it to -1 means use the normal calculation method.</para>

    2065. 

  2065.         /// <para><bold>This feature is experiemental!</bold> Strange things may happen to your program,

    2066. 

  2066.         /// your spouse or your pet if you use it.</para>

    2067. 

  2067.         /// </remarks>

    2068. 

  2068.         [Category("ObjectListView"),

    2069. 

  2069.          Description("Specify the height of each row in pixels. -1 indicates default height"),

    2070. 

  2070.          DefaultValue(-1)]

    2071. 

  2071.         public virtual int RowHeight {

    2072. 

  2072.             get { return rowHeight; }

    2073. 

  2073.             set {

    2074. 

  2074.                 if (value < 1)

    2075. 

  2075.                     rowHeight = -1;

    2076. 

  2076.                 else

    2077. 

  2077.                     rowHeight = value;

    2078. 

  2078.                 if (this.DesignMode)

    2079. 

  2079.                     return;

    2080. 

  2080.                 this.SetupBaseImageList();

    2081. 

  2081.                 if (this.CheckBoxes)

    2082. 

  2082.                     this.InitializeStateImageList();

    2083. 

  2083.             }

    2084. 

  2084.         }

    2085. 

  2085.         private int rowHeight = -1;

    2086. 

  2086. 

    2087. 

  2087.         /// <summary>

    2088. 

  2088.         /// How many pixels high is each row?

    2089. 

  2089.         /// </summary>

    2090. 

  2090.         [Browsable(false)]

    2091. 

  2091.         public virtual int RowHeightEffective {

    2092. 

  2092.             get {

    2093. 

  2093.                 switch (this.View) {

    2094. 

  2094.                     case View.List:

    2095. 

  2095.                     case View.SmallIcon:

    2096. 

  2096.                     case View.Details:

    2097. 

  2097.                         return Math.Max(this.SmallImageSize.Height, this.Font.Height);

    2098. 

  2098. 

    2099. 

  2099.                     case View.Tile:

    2100. 

  2100.                         return this.TileSize.Height;

    2101. 

  2101. 

    2102. 

  2102.                     case View.LargeIcon:

    2103. 

  2103.                         if (this.LargeImageList == null)

    2104. 

  2104.                             return this.Font.Height;

    2105. 

  2105.                         else

    2106. 

  2106.                             return Math.Max(this.LargeImageList.ImageSize.Height, this.Font.Height);

    2107. 

  2107. 

    2108. 

  2108.                     default:

    2109. 

  2109.                         // This should never happen

    2110. 

  2110.                         return 0;

    2111. 

  2111.                 }

    2112. 

  2112.             }

    2113. 

  2113.         }

    2114. 

  2114. 

    2115. 

  2115.         /// <summary>

    2116. 

  2116.         /// How many rows appear on each page of this control

    2117. 

  2117.         /// </summary>

    2118. 

  2118.         [Browsable(false)]

    2119. 

  2119.         public virtual int RowsPerPage {

    2120. 

  2120.             get {

    2121. 

  2121.                 return NativeMethods.GetCountPerPage(this);

    2122. 

  2122.             }

    2123. 

  2123.         }

    2124. 

  2124. 

    2125. 

  2125.         /// <summary>

    2126. 

  2126.         /// Get/set the column that will be used to resolve comparisons that are equal when sorting.

    2127. 

  2127.         /// </summary>

    2128. 

  2128.         /// <remarks>There is no user interface for this setting. It must be set programmatically.</remarks>

    2129. 

  2129.         [Browsable(false),

    2130. 

  2130.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    2131. 

  2131.         public virtual OLVColumn SecondarySortColumn {

    2132. 

  2132.             get { return this.secondarySortColumn; }

    2133. 

  2133.             set { this.secondarySortColumn = value; }

    2134. 

  2134.         }

    2135. 

  2135.         private OLVColumn secondarySortColumn;

    2136. 

  2136. 

    2137. 

  2137.         /// <summary>

    2138. 

  2138.         /// When the SecondarySortColumn is used, in what order will it compare results?

    2139. 

  2139.         /// </summary>

    2140. 

  2140.         [Browsable(false),

    2141. 

  2141.         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    2142. 

  2142.         public virtual SortOrder SecondarySortOrder {

    2143. 

  2143.             get { return this.secondarySortOrder; }

    2144. 

  2144.             set { this.secondarySortOrder = value; }

    2145. 

  2145.         }

    2146. 

  2146.         private SortOrder secondarySortOrder = SortOrder.None;

    2147. 

  2147. 

    2148. 

  2148.         /// <summary>

    2149. 

  2149.         /// Gets or sets if all rows should be selected when the user presses Ctrl-A

    2150. 

  2150.         /// </summary>

    2151. 

  2151.         [Category("ObjectListView"),

    2152. 

  2152.         Description("Should the control select all rows when the user presses Ctrl-A?"),

    2153. 

  2153.         DefaultValue(true)]

    2154. 

  2154.         public virtual bool SelectAllOnControlA {

    2155. 

  2155.             get { return selectAllOnControlA; }

    2156. 

  2156.             set { selectAllOnControlA = value; }

    2157. 

  2157.         }

    2158. 

  2158.         private bool selectAllOnControlA = true;

    2159. 

  2159. 

    2160. 

  2160.         /// <summary>

    2161. 

  2161.         /// When the user right clicks on the column headers, should a menu be presented which will allow

    2162. 

  2162.         /// them to choose which columns will be shown in the view?

    2163. 

  2163.         /// </summary>

    2164. 

  2164.         /// <remarks>This is just a compatibility wrapper for the SelectColumnsOnRightClickBehaviour

    2165. 

  2165.         /// property.</remarks>

    2166. 

  2166.         [Category("ObjectListView"),

    2167. 

  2167.         Description("When the user right clicks on the column headers, should a menu be presented which will allow them to choose which columns will be shown in the view?"),

    2168. 

  2168.         DefaultValue(true)]

    2169. 

  2169.         public virtual bool SelectColumnsOnRightClick {

    2170. 

  2170.             get { return this.SelectColumnsOnRightClickBehaviour != ColumnSelectBehaviour.None; }

    2171. 

  2171.             set {

    2172. 

  2172.                 if (value) {

    2173. 

  2173.                     if (this.SelectColumnsOnRightClickBehaviour == ColumnSelectBehaviour.None)

    2174. 

  2174.                         this.SelectColumnsOnRightClickBehaviour = ColumnSelectBehaviour.InlineMenu;

    2175. 

  2175.                 } else {

    2176. 

  2176.                     this.SelectColumnsOnRightClickBehaviour = ColumnSelectBehaviour.None;

    2177. 

  2177.                 }

    2178. 

  2178.             }

    2179. 

  2179.         }

    2180. 

  2180. 

    2181. 

  2181.         /// <summary>

    2182. 

  2182.         /// Gets or sets how the user will be able to select columns when the header is right clicked

    2183. 

  2183.         /// </summary>

    2184. 

  2184.         [Category("ObjectListView"),

    2185. 

  2185.         Description("When the user right clicks on the column headers, how will the user be able to select columns?"),

    2186. 

  2186.         DefaultValue(ColumnSelectBehaviour.InlineMenu)]

    2187. 

  2187.         public virtual ColumnSelectBehaviour SelectColumnsOnRightClickBehaviour {

    2188. 

  2188.             get { return selectColumnsOnRightClickBehaviour; }

    2189. 

  2189.             set { selectColumnsOnRightClickBehaviour = value; }

    2190. 

  2190.         }

    2191. 

  2191.         private ColumnSelectBehaviour selectColumnsOnRightClickBehaviour = ColumnSelectBehaviour.InlineMenu;

    2192. 

  2192. 

    2193. 

  2193.         /// <summary>

    2194. 

  2194.         /// When the column select menu is open, should it stay open after an item is selected?

    2195. 

  2195.         /// Staying open allows the user to turn more than one column on or off at a time.

    2196. 

  2196.         /// </summary>

    2197. 

  2197.         /// <remarks>This only works when SelectColumnsOnRightClickBehaviour is set to InlineMenu.

    2198. 

  2198.         /// It has no effect when the behaviour is set to SubMenu.</remarks>

    2199. 

  2199.         [Category("ObjectListView"),

    2200. 

  2200.         Description("When the column select inline menu is open, should it stay open after an item is selected?"),

    2201. 

  2201.         DefaultValue(true)]

    2202. 

  2202.         public virtual bool SelectColumnsMenuStaysOpen {

    2203. 

  2203.             get { return selectColumnsMenuStaysOpen; }

    2204. 

  2204.             set { selectColumnsMenuStaysOpen = value; }

    2205. 

  2205.         }

    2206. 

  2206.         private bool selectColumnsMenuStaysOpen = true;

    2207. 

  2207. 

    2208. 

  2208.         /// <summary>

    2209. 

  2209.         /// Gets or sets the column that is drawn with a slight tint.

    2210. 

  2210.         /// </summary>

    2211. 

  2211.         /// <remarks>

    2212. 

  2212.         /// <para>

    2213. 

  2213.         /// If TintSortColumn is true, the sort column will automatically

    2214. 

  2214.         /// be made the selected column.

    2215. 

  2215.         /// </para>

    2216. 

  2216.         /// <para>

    2217. 

  2217.         /// The colour of the tint is controlled by SelectedColumnTint.

    2218. 

  2218.         /// </para>

    2219. 

  2219.         /// </remarks>

    2220. 

  2220.         [Browsable(false),

    2221. 

  2221.         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    2222. 

  2222.         public OLVColumn SelectedColumn {

    2223. 

  2223.             get { return this.selectedColumn; }

    2224. 

  2224.             set {

    2225. 

  2225.                 this.selectedColumn = value;

    2226. 

  2226.                 if (value == null) {

    2227. 

  2227.                     this.RemoveDecoration(this.selectedColumnDecoration);

    2228. 

  2228.                 } else {

    2229. 

  2229.                     if (!this.HasDecoration(this.selectedColumnDecoration))

    2230. 

  2230.                         this.AddDecoration(this.selectedColumnDecoration);

    2231. 

  2231.                 }

    2232. 

  2232.             }

    2233. 

  2233.         }

    2234. 

  2234.         private OLVColumn selectedColumn;

    2235. 

  2235.         private TintedColumnDecoration selectedColumnDecoration = new TintedColumnDecoration();

    2236. 

  2236. 

    2237. 

  2237.         /// <summary>

    2238. 

  2238.         /// Gets or sets the decoration that will be drawn on all selected rows

    2239. 

  2239.         /// </summary>

    2240. 

  2240.         [Browsable(false),

    2241. 

  2241.         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    2242. 

  2242.         public virtual IDecoration SelectedRowDecoration {

    2243. 

  2243.             get { return this.selectedRowDecoration; }

    2244. 

  2244.             set { this.selectedRowDecoration = value; }

    2245. 

  2245.         }

    2246. 

  2246.         private IDecoration selectedRowDecoration;

    2247. 

  2247. 

    2248. 

  2248.         /// <summary>

    2249. 

  2249.         /// What color should be used to tint the selected column?

    2250. 

  2250.         /// </summary>

    2251. 

  2251.         /// <remarks>

    2252. 

  2252.         /// The tint color must be alpha-blendable, so if the given color is solid

    2253. 

  2253.         /// (i.e. alpha = 255), it will be changed to have a reasonable alpha value.

    2254. 

  2254.         /// </remarks>

    2255. 

  2255.         [Category("ObjectListView"),

    2256. 

  2256.          Description("The color that will be used to tint the selected column"),

    2257. 

  2257.          DefaultValue(typeof(Color), "")]

    2258. 

  2258.         public virtual Color SelectedColumnTint {

    2259. 

  2259.             get { return selectedColumnTint; }

    2260. 

  2260.             set {

    2261. 

  2261.                 if (value.A == 255)

    2262. 

  2262.                     this.selectedColumnTint = Color.FromArgb(15, value);

    2263. 

  2263.                 else

    2264. 

  2264.                     this.selectedColumnTint = value;

    2265. 

  2265.                 this.selectedColumnDecoration.Tint = this.selectedColumnTint;

    2266. 

  2266.             }

    2267. 

  2267.         }

    2268. 

  2268.         private Color selectedColumnTint = Color.Empty;

    2269. 

  2269. 

    2270. 

  2270.         /// <summary>

    2271. 

  2271.         /// Gets or sets the index of the row that is currently selected. 

    2272. 

  2272.         /// When getting the index, if no row is selected,or more than one is selected, return -1.

    2273. 

  2273.         /// </summary>

    2274. 

  2274.         [Browsable(false),

    2275. 

  2275.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    2276. 

  2276.         public virtual int SelectedIndex {

    2277. 

  2277.             get {

    2278. 

  2278.                 if (this.SelectedIndices.Count == 1)

    2279. 

  2279.                     return this.SelectedIndices[0];

    2280. 

  2280.                 else

    2281. 

  2281.                     return -1;

    2282. 

  2282.             }

    2283. 

  2283.             set {

    2284. 

  2284.                 this.SelectedIndices.Clear();

    2285. 

  2285.                 if (value >= 0 && value < this.Items.Count)

    2286. 

  2286.                     this.SelectedIndices.Add(value);

    2287. 

  2287.             }

    2288. 

  2288.         }

    2289. 

  2289. 

    2290. 

  2290.         /// <summary>

    2291. 

  2291.         /// Gets or sets the ListViewItem that is currently selected . If no row is selected, or more than one is selected, return null.

    2292. 

  2292.         /// </summary>

    2293. 

  2293.         [Browsable(false),

    2294. 

  2294.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    2295. 

  2295.         public virtual OLVListItem SelectedItem {

    2296. 

  2296.             get {

    2297. 

  2297.                 if (this.SelectedIndices.Count == 1)

    2298. 

  2298.                     return this.GetItem(this.SelectedIndices[0]);

    2299. 

  2299.                 else

    2300. 

  2300.                     return null;

    2301. 

  2301.             }

    2302. 

  2302.             set {

    2303. 

  2303.                 this.SelectedIndices.Clear();

    2304. 

  2304.                 if (value != null)

    2305. 

  2305.                     this.SelectedIndices.Add(value.Index);

    2306. 

  2306.             }

    2307. 

  2307.         }

    2308. 

  2308. 

    2309. 

  2309.         /// <summary>

    2310. 

  2310.         /// Gets the model object from the currently selected row, if there is only one row selected. 

    2311. 

  2311.         /// If no row is selected, or more than one is selected, returns null.

    2312. 

  2312.         /// When setting, this will select the row that is displaying the given model object and focus on it. 

    2313. 

  2313.         /// All other rows are deselected.

    2314. 

  2314.         /// </summary>

    2315. 

  2315.         [Browsable(false),

    2316. 

  2316.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    2317. 

  2317.         public virtual Object SelectedObject {

    2318. 

  2318.             get {

    2319. 

  2319.                 if (this.SelectedIndices.Count == 1)

    2320. 

  2320.                     return this.GetModelObject(this.SelectedIndices[0]);

    2321. 

  2321.                 else

    2322. 

  2322.                     return null;

    2323. 

  2323.             }

    2324. 

  2324.             set {

    2325. 

  2325.                 // If the given model is already selected, don't do anything else (prevents an flicker)

    2326. 

  2326.                 object selectedObject = this.SelectedObject;

    2327. 

  2327.                 if (selectedObject != null && selectedObject.Equals(value))

    2328. 

  2328.                     return;

    2329. 

  2329. 

    2330. 

  2330.                 this.SelectedIndices.Clear();

    2331. 

  2331.                 this.SelectObject(value, true); 

    2332. 

  2332.             }

    2333. 

  2333.         }

    2334. 

  2334. 

    2335. 

  2335.         /// <summary>

    2336. 

  2336.         /// Get the model objects from the currently selected rows. If no row is selected, the returned List will be empty.

    2337. 

  2337.         /// When setting this value, select the rows that is displaying the given model objects. All other rows are deselected.

    2338. 

  2338.         /// </summary>

    2339. 

  2339.         [Browsable(false),

    2340. 

  2340.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    2341. 

  2341.         public virtual IList SelectedObjects {

    2342. 

  2342.             get {

    2343. 

  2343.                 ArrayList objects = new ArrayList();

    2344. 

  2344.                 foreach (int index in this.SelectedIndices)

    2345. 

  2345.                   objects.Add(this.GetModelObject(index));

    2346. 

  2346.                 return objects;

    2347. 

  2347.             }

    2348. 

  2348.             set {

    2349. 

  2349.                 this.SelectedIndices.Clear();

    2350. 

  2350.                 this.SelectObjects(value); 

    2351. 

  2351.             }

    2352. 

  2352.         }

    2353. 

  2353. 

    2354. 

  2354.         /// <summary>

    2355. 

  2355.         /// When the user right clicks on the column headers, should a menu be presented which will allow

    2356. 

  2356.         /// them to choose common tasks to perform on the listview?

    2357. 

  2357.         /// </summary>

    2358. 

  2358.         [Category("ObjectListView"),

    2359. 

  2359.         Description("When the user right clicks on the column headers, should a menu be presented which will allow them to perform common tasks on the listview?"),

    2360. 

  2360.         DefaultValue(false)]

    2361. 

  2361.         public virtual bool ShowCommandMenuOnRightClick {

    2362. 

  2362.             get { return showCommandMenuOnRightClick; }

    2363. 

  2363.             set { showCommandMenuOnRightClick = value; }

    2364. 

  2364.         }

    2365. 

  2365.         private bool showCommandMenuOnRightClick = false;

    2366. 

  2366. 

    2367. 

  2367.         /// <summary>

    2368. 

  2368.         /// Gets or sets whether this ObjectListView will show Excel like filtering

    2369. 

  2369.         /// menus when the header control is right clicked

    2370. 

  2370.         /// </summary>

    2371. 

  2371.         [Category("ObjectListView"),

    2372. 

  2372.          Description("If this is true, right clicking on a column header will show a Filter menu option"),

    2373. 

  2373.          DefaultValue(true)]

    2374. 

  2374.         public bool ShowFilterMenuOnRightClick {

    2375. 

  2375.             get { return showFilterMenuOnRightClick; }

    2376. 

  2376.             set { showFilterMenuOnRightClick = value; }

    2377. 

  2377.         }

    2378. 

  2378.         private bool showFilterMenuOnRightClick = true;

    2379. 

  2379. 

    2380. 

  2380.         /// <summary>

    2381. 

  2381.         /// Should this list show its items in groups?

    2382. 

  2382.         /// </summary>

    2383. 

  2383.         [Category("Appearance"),

    2384. 

  2384.          Description("Should the list view show items in groups?"),

    2385. 

  2385.          DefaultValue(true)]

    2386. 

  2386.         new public virtual bool ShowGroups {

    2387. 

  2387.             get { return base.ShowGroups; }

    2388. 

  2388.             set {

    2389. 

  2389.                 this.GroupImageList = this.GroupImageList;

    2390. 

  2390.                 base.ShowGroups = value; 

    2391. 

  2391.             }

    2392. 

  2392.         }

    2393. 

  2393. 

    2394. 

  2394.         /// <summary>

    2395. 

  2395.         /// Should the list view show a bitmap in the column header to show the sort direction?

    2396. 

  2396.         /// </summary>

    2397. 

  2397.         /// <remarks>

    2398. 

  2398.         /// The only reason for not wanting to have sort indicators is that, on pre-XP versions of

    2399. 

  2399.         /// Windows, having sort indicators required the ListView to have a small image list, and

    2400. 

  2400.         /// as soon as you give a ListView a SmallImageList, the text of column 0 is bumped 16

    2401. 

  2401.         /// pixels to the right, even if you never used an image.

    2402. 

  2402.         /// </remarks>

    2403. 

  2403.         [Category("ObjectListView"),

    2404. 

  2404.          Description("Should the list view show sort indicators in the column headers?"),

    2405. 

  2405.          DefaultValue(true)]

    2406. 

  2406.         public virtual bool ShowSortIndicators {

    2407. 

  2407.             get { return showSortIndicators; }

    2408. 

  2408.             set { showSortIndicators = value; }

    2409. 

  2409.         }

    2410. 

  2410.         private bool showSortIndicators;

    2411. 

  2411. 

    2412. 

  2412.         /// <summary>

    2413. 

  2413.         /// Should the list view show images on subitems?

    2414. 

  2414.         /// </summary>

    2415. 

  2415.         /// <remarks>

    2416. 

  2416.         /// <para>Virtual lists have to be owner drawn in order to show images on subitems</para>

    2417. 

  2417.         /// </remarks>

    2418. 

  2418.         [Category("ObjectListView"),

    2419. 

  2419.          Description("Should the list view show images on subitems?"),

    2420. 

  2420.          DefaultValue(false)]

    2421. 

  2421.         public virtual bool ShowImagesOnSubItems {

    2422. 

  2422.             get { return showImagesOnSubItems; }

    2423. 

  2423.             set {

    2424. 

  2424.                 showImagesOnSubItems = value;

    2425. 

  2425.                 if (this.Created)

    2426. 

  2426.                     this.ApplyExtendedStyles();

    2427. 

  2427.                 if (value && this.VirtualMode)

    2428. 

  2428.                     this.OwnerDraw = true;

    2429. 

  2429.             }

    2430. 

  2430.         }

    2431. 

  2431.         private bool showImagesOnSubItems;

    2432. 

  2432. 

    2433. 

  2433.         /// <summary>

    2434. 

  2434.         /// This property controls whether group labels will be suffixed with a count of items.

    2435. 

  2435.         /// </summary>

    2436. 

  2436.         /// <remarks>

    2437. 

  2437.         /// The format of the suffix is controlled by GroupWithItemCountFormat/GroupWithItemCountSingularFormat properties

    2438. 

  2438.         /// </remarks>

    2439. 

  2439.         [Category("ObjectListView"),

    2440. 

  2440.          Description("Will group titles be suffixed with a count of the items in the group?"),

    2441. 

  2441.          DefaultValue(false)]

    2442. 

  2442.         public virtual bool ShowItemCountOnGroups {

    2443. 

  2443.             get { return showItemCountOnGroups; }

    2444. 

  2444.             set { showItemCountOnGroups = value; }

    2445. 

  2445.         }

    2446. 

  2446.         private bool showItemCountOnGroups;

    2447. 

  2447. 

    2448. 

  2448.         /// <summary>

    2449. 

  2449.         /// Gets or sets whether the control will show column headers in all

    2450. 

  2450.         /// views (true), or only in Details view (false)

    2451. 

  2451.         /// </summary>

    2452. 

  2452.         /// <remarks>

    2453. 

  2453.         /// <para>

    2454. 

  2454.         /// This property is not working correctly. JPP 2010/04/06.

    2455. 

  2455.         /// It works fine if it is set before the control is created.

    2456. 

  2456.         /// But if it turned off once the control is created, the control

    2457. 

  2457.         /// loses its checkboxes (weird!)

    2458. 

  2458.         /// </para>

    2459. 

  2459.         /// <para>

    2460. 

  2460.         /// To changed this setting after the control is created, things

    2461. 

  2461.         /// are complicated. If it is off and we want it on, we have

    2462. 

  2462.         /// to change the View and the header will appear. If it is currently

    2463. 

  2463.         /// on and we want to turn it off, we have to both change the view

    2464. 

  2464.         /// AND recreate the handle. Recreating the handle is a problem 

    2465. 

  2465.         /// since it makes our checkbox style disappear. 

    2466. 

  2466.         /// </para>

    2467. 

  2467.         /// </remarks>

    2468. 

  2468.         [Category("ObjectListView"),

    2469. 

  2469.         Description("Will the control will show column headers in all views?"),

    2470. 

  2470.         DefaultValue(true)]

    2471. 

  2471.         public bool ShowHeaderInAllViews {

    2472. 

  2472.             get { return showHeaderInAllViews; }

    2473. 

  2473.             set {

    2474. 

  2474.                 if (showHeaderInAllViews == value)

    2475. 

  2475.                     return;

    2476. 

  2476. 

    2477. 

  2477.                 showHeaderInAllViews = value;

    2478. 

  2478. 

    2479. 

  2479.                 // If the control isn't already created, everything is fine.

    2480. 

  2480.                 if (!this.Created)

    2481. 

  2481.                     return;

    2482. 

  2482. 

    2483. 

  2483.                 // If the header is being hidden, we have to recreate the control

    2484. 

  2484.                 // to remove the style (not sure why this is)

    2485. 

  2485.                 if (!showHeaderInAllViews)

    2486. 

  2486.                     this.RecreateHandle();

    2487. 

  2487. 

    2488. 

  2488.                 // Still more complications. The change doesn't become visible until the View is changed

    2489. 

  2489.                 if (this.View != View.Details) {

    2490. 

  2490.                     View temp = this.View;

    2491. 

  2491.                     this.View = View.Details;

    2492. 

  2492.                     this.View = temp;

    2493. 

  2493.                 }

    2494. 

  2494.             }

    2495. 

  2495.         }

    2496. 

  2496.         private bool showHeaderInAllViews = true;

    2497. 

  2497. 

    2498. 

  2498.         /// <summary>

    2499. 

  2499.         /// Override the SmallImageList property so we can correctly shadow its operations.

    2500. 

  2500.         /// </summary>

    2501. 

  2501.         /// <remarks><para>If you use the RowHeight property to specify the row height, the SmallImageList

    2502. 

  2502.         /// must be fully initialised before setting/changing the RowHeight. If you add new images to the image

    2503. 

  2503.         /// list after setting the RowHeight, you must assign the imagelist to the control again. Something as simple

    2504. 

  2504.         /// as this will work:

    2505. 

  2505.         /// <code>listView1.SmallImageList = listView1.SmallImageList;</code></para>

    2506. 

  2506.         /// </remarks>

    2507. 

  2507.         new public ImageList SmallImageList {

    2508. 

  2508.             get { return this.shadowedImageList; }

    2509. 

  2509.             set {

    2510. 

  2510.                 this.shadowedImageList = value;

    2511. 

  2511.                 if (this.UseSubItemCheckBoxes)

    2512. 

  2512.                     this.SetupSubItemCheckBoxes();

    2513. 

  2513.                 this.SetupBaseImageList();

    2514. 

  2514.             }

    2515. 

  2515.         }

    2516. 

  2516.         private ImageList shadowedImageList;

    2517. 

  2517. 

    2518. 

  2518.         /// <summary>

    2519. 

  2519.         /// Return the size of the images in the small image list or a reasonable default

    2520. 

  2520.         /// </summary>

    2521. 

  2521.         [Browsable(false)]

    2522. 

  2522.         public virtual Size SmallImageSize {

    2523. 

  2523.             get {

    2524. 

  2524.                 if (this.SmallImageList == null)

    2525. 

  2525.                     return new Size(16, 16);

    2526. 

  2526.                 else

    2527. 

  2527.                     return this.SmallImageList.ImageSize;

    2528. 

  2528.             }

    2529. 

  2529.         }

    2530. 

  2530. 

    2531. 

  2531.         /// <summary>

    2532. 

  2532.         /// When the listview is grouped, should the items be sorted by the primary column?

    2533. 

  2533.         /// If this is false, the items will be sorted by the same column as they are grouped.

    2534. 

  2534.         /// </summary>

    2535. 

  2535.         [Category("ObjectListView"),

    2536. 

  2536.          Description("When the listview is grouped, should the items be sorted by the primary column? If this is false, the items will be sorted by the same column as they are grouped."),

    2537. 

  2537.          DefaultValue(true)]

    2538. 

  2538.         public virtual bool SortGroupItemsByPrimaryColumn {

    2539. 

  2539.             get { return this.sortGroupItemsByPrimaryColumn; }

    2540. 

  2540.             set { this.sortGroupItemsByPrimaryColumn = value; }

    2541. 

  2541.         }

    2542. 

  2542.         private bool sortGroupItemsByPrimaryColumn = true;

    2543. 

  2543. 

    2544. 

  2544.         /// <summary>

    2545. 

  2545.         /// When the listview is grouped, how many pixels should exist between the end of one group and the

    2546. 

  2546.         /// beginning of the next?

    2547. 

  2547.         /// </summary>

    2548. 

  2548.         [Category("ObjectListView"),

    2549. 

  2549.          Description("How many pixels of space will be between groups"),

    2550. 

  2550.          DefaultValue(0)]

    2551. 

  2551.         public virtual int SpaceBetweenGroups {

    2552. 

  2552.             get { return this.spaceBetweenGroups; }

    2553. 

  2553.             set { this.spaceBetweenGroups = value; }

    2554. 

  2554.         }

    2555. 

  2555.         private int spaceBetweenGroups;

    2556. 

  2556. 

    2557. 

  2557.         /// <summary>

    2558. 

  2558.         /// Should the sort column show a slight tinge?

    2559. 

  2559.         /// </summary>

    2560. 

  2560.         [Category("ObjectListView"),

    2561. 

  2561.          Description("Should the sort column show a slight tinting?"),

    2562. 

  2562.          DefaultValue(false)]

    2563. 

  2563.         public virtual bool TintSortColumn {

    2564. 

  2564.             get { return this.tintSortColumn; }

    2565. 

  2565.             set {

    2566. 

  2566.                 this.tintSortColumn = value;

    2567. 

  2567.                 if (value && this.LastSortColumn != null)

    2568. 

  2568.                     this.SelectedColumn = this.LastSortColumn;

    2569. 

  2569.                 else

    2570. 

  2570.                     this.SelectedColumn = null;

    2571. 

  2571.             }

    2572. 

  2572.         }

    2573. 

  2573.         private bool tintSortColumn;

    2574. 

  2574. 

    2575. 

  2575.         /// <summary>

    2576. 

  2576.         /// Should each row have a tri-state checkbox?

    2577. 

  2577.         /// </summary>

    2578. 

  2578.         /// <remarks>

    2579. 

  2579.         /// If this is true, the user can choose the third state (normally Indeterminate). Otherwise, user clicks

    2580. 

  2580.         /// alternate between checked and unchecked. CheckStateGetter can still return Indeterminate when this

    2581. 

  2581.         /// setting is false.

    2582. 

  2582.         /// </remarks>

    2583. 

  2583.         [Category("ObjectListView"),

    2584. 

  2584.          Description("Should the primary column have a checkbox that behaves as a tri-state checkbox?"),

    2585. 

  2585.          DefaultValue(false)]

    2586. 

  2586.         public virtual bool TriStateCheckBoxes {

    2587. 

  2587.             get { return triStateCheckBoxes; }

    2588. 

  2588.             set {

    2589. 

  2589.                 triStateCheckBoxes = value;

    2590. 

  2590.                 if (value && !this.CheckBoxes)

    2591. 

  2591.                     this.CheckBoxes = true;

    2592. 

  2592.                 this.InitializeStateImageList();

    2593. 

  2593.             }

    2594. 

  2594.         }

    2595. 

  2595.         private bool triStateCheckBoxes;

    2596. 

  2596. 

    2597. 

  2597.         /// <summary>

    2598. 

  2598.         /// Get or set the index of the top item of this listview

    2599. 

  2599.         /// </summary>

    2600. 

  2600.         /// <remarks>

    2601. 

  2601.         /// <para>

    2602. 

  2602.         /// This property only works when the listview is in Details view and not showing groups.

    2603. 

  2603.         /// </para>

    2604. 

  2604.         /// <para>

    2605. 

  2605.         /// The reason that it does not work when showing groups is that, when groups are enabled,

    2606. 

  2606.         /// the Windows msg LVM_GETTOPINDEX always returns 0, regardless of the

    2607. 

  2607.         /// scroll position.

    2608. 

  2608.         /// </para>

    2609. 

  2609.         /// </remarks>

    2610. 

  2610.         [Browsable(false),

    2611. 

  2611.         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    2612. 

  2612.         public virtual int TopItemIndex {

    2613. 

  2613.             get {

    2614. 

  2614.                 if (this.View == View.Details && this.TopItem != null)

    2615. 

  2615.                     return this.TopItem.Index;

    2616. 

  2616.                 else

    2617. 

  2617.                     return -1;

    2618. 

  2618.             }

    2619. 

  2619.             set {

    2620. 

  2620.                 int newTopIndex = Math.Min(value, this.GetItemCount() - 1);

    2621. 

  2621.                 if (this.View == View.Details && newTopIndex >= 0) {

    2622. 

  2622.                     this.TopItem = this.Items[newTopIndex];

    2623. 

  2623. 

    2624. 

  2624.                     // Setting the TopItem sometimes gives off by one errors,

    2625. 

  2625.                     // that (bizarrely) are correct on a second attempt

    2626. 

  2626.                     if (this.TopItem != null && this.TopItem.Index != newTopIndex)

    2627. 

  2627.                         this.TopItem = this.GetItem(newTopIndex);

    2628. 

  2628.                 }

    2629. 

  2629.             }

    2630. 

  2630.         }

    2631. 

  2631. 

    2632. 

  2632.         /// <summary>

    2633. 

  2633.         /// When resizing a column by dragging its divider, should any space filling columns be

    2634. 

  2634.         /// resized at each mouse move? If this is false, the filling columns will be

    2635. 

  2635.         /// updated when the mouse is released.

    2636. 

  2636.         /// </summary>

    2637. 

  2637.         /// <remarks>

    2638. 

  2638.         /// <para>

    2639. 

  2639.         /// In previous versions, setting this to true produced ugly behaviour, because every

    2640. 

  2640.         /// column to the right of the divider being dragged was updated twice: once when

    2641. 

  2641.         /// the column be resized changes size (this moves all the columns slightly to the right);

    2642. 

  2642.         /// then again when the filling columns are updated - they are shrunk

    2643. 

  2643.         /// so that the combined width is not more than the control, so everything jumps slightly back to the left again.

    2644. 

  2644.         /// </para>

    2645. 

  2645.         /// <para>

    2646. 

  2646.         /// But, as of v2.0, the change the Windows messages in place, so there is now only one update,

    2647. 

  2647.         /// and everything looks nice and smooth.

    2648. 

  2648.         /// </para>

    2649. 

  2649.         /// <para>

    2650. 

  2650.         /// However, it still looks odd when the space filling column

    2651. 

  2651.         /// is in the left of the column that is being resized: the right edge of the column is dragged, but

    2652. 

  2652.         /// its <b>left</b> edge moves, since the space filling column is shrinking.

    2653. 

  2653.         /// </para>

    2654. 

  2654.         /// <para>Given the above behavior is probably best to turn this property off if your space filling

    2655. 

  2655.         /// columns aren't the right-most columns.</para>

    2656. 

  2656.         /// </remarks>

    2657. 

  2657.         [Category("ObjectListView"),

    2658. 

  2658.         Description("When resizing a column by dragging its divider, should any space filling columns be resized at each mouse move?"),

    2659. 

  2659.         DefaultValue(true)]

    2660. 

  2660.         public virtual bool UpdateSpaceFillingColumnsWhenDraggingColumnDivider {

    2661. 

  2661.             get { return updateSpaceFillingColumnsWhenDraggingColumnDivider; }

    2662. 

  2662.             set { updateSpaceFillingColumnsWhenDraggingColumnDivider = value; }

    2663. 

  2663.         }

    2664. 

  2664.         private bool updateSpaceFillingColumnsWhenDraggingColumnDivider = true;

    2665. 

  2665. 

    2666. 

  2666.         /// <summary>

    2667. 

  2667.         /// What color should be used for the background of selected rows when the control doesn't have the focus?

    2668. 

  2668.         /// </summary>

    2669. 

  2669.         /// <remarks>Windows does not give the option of changing the selection background.

    2670. 

  2670.         /// So the control has to be owner drawn to see the result of this setting.

    2671. 

  2671.         /// Setting UseCustomSelectionColors = true will do this for you.</remarks>

    2672. 

  2672.         [Category("ObjectListView"),

    2673. 

  2673.          Description("The background color of selected rows when the control is owner drawn and doesn't have the focus"),

    2674. 

  2674.          DefaultValue(typeof(Color), "")]

    2675. 

  2675.         public virtual Color UnfocusedHighlightBackgroundColor {

    2676. 

  2676.             get { return unfocusedHighlightBackgroundColor; }

    2677. 

  2677.             set { unfocusedHighlightBackgroundColor = value; }

    2678. 

  2678.         }

    2679. 

  2679.         private Color unfocusedHighlightBackgroundColor = Color.Empty;

    2680. 

  2680. 

    2681. 

  2681.         /// <summary>

    2682. 

  2682.         /// Return the color should be used for the background of selected rows when the control doesn't have the focus or a reasonable default

    2683. 

  2683.         /// </summary>

    2684. 

  2684.         [Browsable(false)]

    2685. 

  2685.         public virtual Color UnfocusedHighlightBackgroundColorOrDefault {

    2686. 

  2686.             get {

    2687. 

  2687.                 if (this.UnfocusedHighlightBackgroundColor.IsEmpty)

    2688. 

  2688.                     return SystemColors.Control;

    2689. 

  2689.                 else

    2690. 

  2690.                     return this.UnfocusedHighlightBackgroundColor;

    2691. 

  2691.             }

    2692. 

  2692.         }

    2693. 

  2693. 

    2694. 

  2694.         /// <summary>

    2695. 

  2695.         /// What color should be used for the foreground of selected rows when the control doesn't have the focus?

    2696. 

  2696.         /// </summary>

    2697. 

  2697.         /// <remarks>Windows does not give the option of changing the selection foreground (text color).

    2698. 

  2698.         /// So the control has to be owner drawn to see the result of this setting.

    2699. 

  2699.         /// Setting UseCustomSelectionColors = true will do this for you.</remarks>

    2700. 

  2700.         [Category("ObjectListView"),

    2701. 

  2701.          Description("The foreground color of selected rows when the control is owner drawn and doesn't have the focus"),

    2702. 

  2702.          DefaultValue(typeof(Color), "")]

    2703. 

  2703.         public virtual Color UnfocusedHighlightForegroundColor {

    2704. 

  2704.             get { return unfocusedHighlightForegroundColor; }

    2705. 

  2705.             set { unfocusedHighlightForegroundColor = value; }

    2706. 

  2706.         }

    2707. 

  2707.         private Color unfocusedHighlightForegroundColor = Color.Empty;

    2708. 

  2708. 

    2709. 

  2709.         /// <summary>

    2710. 

  2710.         /// Return the color should be used for the foreground of selected rows when the control doesn't have the focus or a reasonable default

    2711. 

  2711.         /// </summary>

    2712. 

  2712.         [Browsable(false)]

    2713. 

  2713.         public virtual Color UnfocusedHighlightForegroundColorOrDefault {

    2714. 

  2714.             get {

    2715. 

  2715.                 if (this.UnfocusedHighlightForegroundColor.IsEmpty)

    2716. 

  2716.                     return SystemColors.ControlText;

    2717. 

  2717.                 else

    2718. 

  2718.                     return this.UnfocusedHighlightForegroundColor;

    2719. 

  2719.             }

    2720. 

  2720.         }

    2721. 

  2721. 

    2722. 

  2722.         /// <summary>

    2723. 

  2723.         /// Should the list give a different background color to every second row?

    2724. 

  2724.         /// </summary>

    2725. 

  2725.         /// <remarks><para>The color of the alternate rows is given by AlternateRowBackColor.</para>

    2726. 

  2726.         /// <para>There is a "feature" in .NET for listviews in non-full-row-select mode, where

    2727. 

  2727.         /// selected rows are not drawn with their correct background color.</para></remarks>

    2728. 

  2728.         [Category("ObjectListView"),

    2729. 

  2729.          Description("Should the list view use a different backcolor to alternate rows?"),

    2730. 

  2730.          DefaultValue(false)]

    2731. 

  2731.         public virtual bool UseAlternatingBackColors {

    2732. 

  2732.             get { return useAlternatingBackColors; }

    2733. 

  2733.             set { useAlternatingBackColors = value; }

    2734. 

  2734.         }

    2735. 

  2735.         private bool useAlternatingBackColors;

    2736. 

  2736. 

    2737. 

  2737.         /// <summary>

    2738. 

  2738.         /// Should FormatCell events be called for each cell in the control?

    2739. 

  2739.         /// </summary>

    2740. 

  2740.         /// <remarks>Individual rows can decide whether to call FormatCell

    2741. 

  2741.         /// events. This is simply the default behaviour.</remarks>

    2742. 

  2742.         [Category("ObjectListView"),

    2743. 

  2743.          Description("Should FormatCell events be triggered to every cell that is built?"),

    2744. 

  2744.          DefaultValue(false)]

    2745. 

  2745.         public bool UseCellFormatEvents {

    2746. 

  2746.             get { return useCellFormatEvents; }

    2747. 

  2747.             set { useCellFormatEvents = value; }

    2748. 

  2748.         }

    2749. 

  2749.         private bool useCellFormatEvents;

    2750. 

  2750. 

    2751. 

  2751.         /// <summary>

    2752. 

  2752.         /// Should the selected row be drawn with non-standard foreground and background colors?

    2753. 

  2753.         /// </summary>

    2754. 

  2754.         /// <remarks>

    2755. 

  2755.         /// When this is enabled, the control becomes owner drawn.

    2756. 

  2756.         /// </remarks>

    2757. 

  2757.         [Category("ObjectListView"),

    2758. 

  2758.          Description("Should the selected row be drawn with non-standard foreground and background colors?"),

    2759. 

  2759.          DefaultValue(false)]

    2760. 

  2760.         public bool UseCustomSelectionColors {

    2761. 

  2761.             get { return this.useCustomSelectionColors; }

    2762. 

  2762.             set {

    2763. 

  2763.                 this.useCustomSelectionColors = value;

    2764. 

  2764. 

    2765. 

  2765.                 if (!this.DesignMode && value)

    2766. 

  2766.                     this.OwnerDraw = true;

    2767. 

  2767.             }

    2768. 

  2768.         }

    2769. 

  2769.         private bool useCustomSelectionColors;

    2770. 

  2770. 

    2771. 

  2771.         /// <summary>

    2772. 

  2772.         /// Gets or sets whether this ObjectListView will use the same hot item and selection 

    2773. 

  2773.         /// mechanism that Vista Explorer does.

    2774. 

  2774.         /// </summary>

    2775. 

  2775.         /// <remarks>This property has many imperfections:

    2776. 

  2776.         /// <list type="bullet">

    2777. 

  2777.         /// <item><description>This only works on Vista and later</description></item>

    2778. 

  2778.         /// <item><description>It does nothing for owner drawn lists.

    2779. 

  2779.         /// Owner drawn lists are (naturally) controlled by their renderers.</description></item>

    2780. 

  2780.         /// <item><description>It does not work well with AlternateRowBackColors.</description></item>

    2781. 

  2781.         /// <item><description>It does not play well with HotItemStyles.</description></item>

    2782. 

  2782.         /// <item><description>It looks a little bit silly is FullRowSelect is false.</description></item>

    2783. 

  2783.         /// </list>

    2784. 

  2784.         /// But if you absolutely have to look like Vista, this is your property. 

    2785. 

  2785.         /// Do not complain if settings this messes up other things.

    2786. 

  2786.         /// </remarks>

    2787. 

  2787.         [Category("ObjectListView"),

    2788. 

  2788.          Description("Should the list use the same hot item and selection mechanism as Vista?"),

    2789. 

  2789.          DefaultValue(false)]

    2790. 

  2790.         public bool UseExplorerTheme {

    2791. 

  2791.             get { return useExplorerTheme; }

    2792. 

  2792.             set {

    2793. 

  2793.                 useExplorerTheme = value;

    2794. 

  2794.                 if (this.Created)

    2795. 

  2795.                     NativeMethods.SetWindowTheme(this.Handle, value ? "explorer" : "", null);

    2796. 

  2796.             }

    2797. 

  2797.         }

    2798. 

  2798.         private bool useExplorerTheme;

    2799. 

  2799. 

    2800. 

  2800.         /// <summary>

    2801. 

  2801.         /// Gets or sets whether the list should enable filtering

    2802. 

  2802.         /// </summary>

    2803. 

  2803.         [Category("ObjectListView"),

    2804. 

  2804.         Description("Should the list enable filtering?"),

    2805. 

  2805.         DefaultValue(false)]

    2806. 

  2806.         virtual public bool UseFiltering {

    2807. 

  2807.             get { return useFiltering; }

    2808. 

  2808.             set {

    2809. 

  2809.                 useFiltering = value;

    2810. 

  2810.                 this.UpdateFiltering();

    2811. 

  2811.             }

    2812. 

  2812.         }

    2813. 

  2813.         private bool useFiltering;

    2814. 

  2814. 

    2815. 

  2815.         /// <summary>

    2816. 

  2816.         /// Gets or sets whether the list should put an indicator into a column's header to show that

    2817. 

  2817.         /// it is filtering on that column

    2818. 

  2818.         /// </summary>

    2819. 

  2819.         [Category("ObjectListView"),

    2820. 

  2820.         Description("Should an image be drawn in a column's header when that column is being used for filtering?"),

    2821. 

  2821.         DefaultValue(true)]

    2822. 

  2822.         virtual public bool UseFilterIndicator {

    2823. 

  2823.             get { return useFilterIndicator; }

    2824. 

  2824.             set { 

    2825. 

  2825.                 useFilterIndicator = value;

    2826. 

  2826.                 this.Invalidate();

    2827. 

  2827.             }

    2828. 

  2828.         }

    2829. 

  2829.         private bool useFilterIndicator = true;

    2830. 

  2830. 

    2831. 

  2831.         /// <summary>

    2832. 

  2832.         /// Should the item under the cursor be formatted in a special way?

    2833. 

  2833.         /// </summary>

    2834. 

  2834.         [Category("ObjectListView"),

    2835. 

  2835.          Description("Should HotTracking be used? Hot tracking applies special formatting to the row under the cursor"),

    2836. 

  2836.          DefaultValue(false)]

    2837. 

  2837.         public bool UseHotItem {

    2838. 

  2838.             get { return this.useHotItem; }

    2839. 

  2839.             set {

    2840. 

  2840.                 this.useHotItem = value;

    2841. 

  2841.                 if (this.HotItemStyle != null) {

    2842. 

  2842.                     if (value)

    2843. 

  2843.                         this.AddOverlay(this.HotItemStyle.Overlay);

    2844. 

  2844.                     else

    2845. 

  2845.                         this.RemoveOverlay(this.HotItemStyle.Overlay);

    2846. 

  2846.                 }

    2847. 

  2847.             }

    2848. 

  2848.         }

    2849. 

  2849.         private bool useHotItem;

    2850. 

  2850. 

    2851. 

  2851.         /// <summary>

    2852. 

  2852.         /// Gets or sets whether this listview should show hyperlinks in the cells.

    2853. 

  2853.         /// </summary>

    2854. 

  2854.         [Category("ObjectListView"),

    2855. 

  2855.          Description("Should hyperlinks be shown on this control?"),

    2856. 

  2856.          DefaultValue(false)]

    2857. 

  2857.         public bool UseHyperlinks {

    2858. 

  2858.             get { return this.useHyperlinks; }

    2859. 

  2859.             set {

    2860. 

  2860.                 this.useHyperlinks = value;

    2861. 

  2861.                 if (value && this.HyperlinkStyle == null)

    2862. 

  2862.                     this.HyperlinkStyle = new HyperlinkStyle();

    2863. 

  2863.             }

    2864. 

  2864.         }

    2865. 

  2865.         private bool useHyperlinks;

    2866. 

  2866. 

    2867. 

  2867.         /// <summary>

    2868. 

  2868.         /// Should this control show overlays

    2869. 

  2869.         /// </summary>

    2870. 

  2870.         /// <remarks>Overlays are enabled by default and would only need to be disabled

    2871. 

  2871.         /// if they were causing problems in your development environment.</remarks>

    2872. 

  2872.         [Category("ObjectListView"),

    2873. 

  2873.          Description("Should this control show overlays"),

    2874. 

  2874.          DefaultValue(true)]

    2875. 

  2875.         public bool UseOverlays {

    2876. 

  2876.             get { return this.useOverlays; }

    2877. 

  2877.             set { this.useOverlays = value; }

    2878. 

  2878.         }

    2879. 

  2879.         private bool useOverlays = true;

    2880. 

  2880. 

    2881. 

  2881.         /// <summary>

    2882. 

  2882.         /// Should this control be configured to show check boxes on subitems?

    2883. 

  2883.         /// </summary>

    2884. 

  2884.         /// <remarks>If this is set to True, the control will be given a SmallImageList if it

    2885. 

  2885.         /// doesn't already have one. Also, if it is a virtual list, it will be set to owner

    2886. 

  2886.         /// drawn, since virtual lists can't draw check boxes without being owner drawn.</remarks>

    2887. 

  2887.         [Category("ObjectListView"),

    2888. 

  2888.          Description("Should this control be configured to show check boxes on subitems."),

    2889. 

  2889.          DefaultValue(false)]

    2890. 

  2890.         public bool UseSubItemCheckBoxes {

    2891. 

  2891.             get { return this.useSubItemCheckBoxes; }

    2892. 

  2892.             set {

    2893. 

  2893.                 this.useSubItemCheckBoxes = value;

    2894. 

  2894.                 if (value)

    2895. 

  2895.                     this.SetupSubItemCheckBoxes();

    2896. 

  2896.             }

    2897. 

  2897.         }

    2898. 

  2898.         private bool useSubItemCheckBoxes;

    2899. 

  2899. 

    2900. 

  2900.         /// <summary>

    2901. 

  2901.         /// Gets or sets if the ObjectListView will use a translucent selection mechanism like Vista.

    2902. 

  2902.         /// </summary>

    2903. 

  2903.         /// <remarks>

    2904. 

  2904.         /// <para>

    2905. 

  2905.         /// Unlike UseExplorerTheme, this Vista-like scheme works on XP and for both

    2906. 

  2906.         /// owner and non-owner drawn lists.

    2907. 

  2907.         /// </para>

    2908. 

  2908.         /// <para>

    2909. 

  2909.         /// This will replace any SelectedRowDecoration that has been installed.

    2910. 

  2910.         /// </para>

    2911. 

  2911.         /// </remarks>

    2912. 

  2912.         [Category("ObjectListView"),

    2913. 

  2913.          Description("Should the list use a translucent selection mechanism (like Vista)"),

    2914. 

  2914.          DefaultValue(false)]

    2915. 

  2915.         public bool UseTranslucentSelection {

    2916. 

  2916.             get { return useTranslucentSelection; }

    2917. 

  2917.             set {

    2918. 

  2918.                 useTranslucentSelection = value;

    2919. 

  2919.                 if (value) {

    2920. 

  2920.                     RowBorderDecoration rbd = new RowBorderDecoration();

    2921. 

  2921.                     rbd.BorderPen = new Pen(Color.FromArgb(154, 223, 251));

    2922. 

  2922.                     rbd.FillBrush = new SolidBrush(Color.FromArgb(48, 163, 217, 225));

    2923. 

  2923.                     rbd.BoundsPadding = new Size(0, 0);

    2924. 

  2924.                     rbd.CornerRounding = 6.0f;

    2925. 

  2925.                     this.SelectedRowDecoration = rbd;

    2926. 

  2926.                 } else

    2927. 

  2927.                     this.SelectedRowDecoration = null;

    2928. 

  2928.             }

    2929. 

  2929.         }

    2930. 

  2930.         private bool useTranslucentSelection;

    2931. 

  2931.         

    2932. 

  2932.         /// <summary>

    2933. 

  2933.         /// Gets or sets if the ObjectListView will use a translucent hot row highlighting mechanism like Vista.

    2934. 

  2934.         /// </summary>

    2935. 

  2935.         /// <remarks>Setting this will replace any HotItemStyle that has been </remarks>

    2936. 

  2936.         [Category("ObjectListView"),

    2937. 

  2937.          Description("Should the list use a translucent hot row highlighting mechanism (like Vista)"),

    2938. 

  2938.          DefaultValue(false)]

    2939. 

  2939.         public bool UseTranslucentHotItem {

    2940. 

  2940.             get { return useTranslucentHotItem; }

    2941. 

  2941.             set {

    2942. 

  2942.                 useTranslucentHotItem = value;

    2943. 

  2943.                 if (value) {

    2944. 

  2944.                     this.HotItemStyle = new HotItemStyle();

    2945. 

  2945.                     RowBorderDecoration rbd = new RowBorderDecoration();

    2946. 

  2946.                     rbd.BorderPen = new Pen(Color.FromArgb(154, 223, 251));

    2947. 

  2947.                     rbd.BoundsPadding = new Size(0, 0);

    2948. 

  2948.                     rbd.CornerRounding = 6.0f;

    2949. 

  2949.                     rbd.FillGradientFrom = Color.FromArgb(0, 255, 255, 255);

    2950. 

  2950.                     rbd.FillGradientTo = Color.FromArgb(64, 183, 237, 240);

    2951. 

  2951.                     this.HotItemStyle.Decoration = rbd;

    2952. 

  2952.                 } else

    2953. 

  2953.                     this.HotItemStyle = null;

    2954. 

  2954.                 this.UseHotItem = value;

    2955. 

  2955.             }

    2956. 

  2956.         }

    2957. 

  2957.         private bool useTranslucentHotItem;

    2958. 

  2958. 

    2959. 

  2959.         /// <summary>

    2960. 

  2960.         /// Get/set the style of view that this listview is using

    2961. 

  2961.         /// </summary>

    2962. 

  2962.         /// <remarks>Switching to tile or details view installs the columns appropriate to that view.

    2963. 

  2963.         /// Confusingly, in tile view, every column is shown as a row of information.</remarks>

    2964. 

  2964.         new public View View {

    2965. 

  2965.             get { return base.View; }

    2966. 

  2966.             set {

    2967. 

  2967.                 if (base.View == value)

    2968. 

  2968.                     return;

    2969. 

  2969. 

    2970. 

  2970.                 if (this.Frozen) {

    2971. 

  2971.                     base.View = value;

    2972. 

  2972.                     this.SetupBaseImageList();

    2973. 

  2973.                 } else {

    2974. 

  2974.                     this.Freeze();

    2975. 

  2975. 

    2976. 

  2976.                     if (value == View.Tile)

    2977. 

  2977.                         this.CalculateReasonableTileSize();

    2978. 

  2978. 

    2979. 

  2979.                     base.View = value;

    2980. 

  2980.                     this.SetupBaseImageList();

    2981. 

  2981.                     this.Unfreeze();

    2982. 

  2982.                 }

    2983. 

  2983.             }

    2984. 

  2984.         }

    2985. 

  2985. 

    2986. 

  2986.         #endregion

    2987. 

  2987. 

    2988. 

  2988.         #region Callbacks

    2989. 

  2989. 

    2990. 

  2990.         /// <summary>

    2991. 

  2991.         /// This delegate fetches the checkedness of an object as a boolean only.

    2992. 

  2992.         /// </summary>

    2993. 

  2993.         /// <remarks>Use this if you never want to worry about the

    2994. 

  2994.         /// Indeterminate state (which is fairly common).

    2995. 

  2995.         /// <para>

    2996. 

  2996.         /// This is a convenience wrapper around the CheckStateGetter property.

    2997. 

  2997.         /// </para>

    2998. 

  2998.         /// </remarks>

    2999. 

  2999.         [Browsable(false),

    3000. 

  3000.         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    3001. 

  3001.         public virtual BooleanCheckStateGetterDelegate BooleanCheckStateGetter {

    3002. 

  3002.             set {

    3003. 

  3003.                 if (value == null)

    3004. 

  3004.                     this.CheckStateGetter = null;

    3005. 

  3005.                 else

    3006. 

  3006.                     this.CheckStateGetter = delegate(Object x) {

    3007. 

  3007.                         return value(x) ? CheckState.Checked : CheckState.Unchecked;

    3008. 

  3008.                     };

    3009. 

  3009.             }

    3010. 

  3010.         }

    3011. 

  3011. 

    3012. 

  3012.         /// <summary>

    3013. 

  3013.         /// This delegate sets the checkedness of an object as a boolean only. It must return

    3014. 

  3014.         /// true or false indicating if the object was checked or not.

    3015. 

  3015.         /// </summary>

    3016. 

  3016.         /// <remarks>Use this if you never want to worry about the

    3017. 

  3017.         /// Indeterminate state (which is fairly common).

    3018. 

  3018.         /// <para>

    3019. 

  3019.         /// This is a convenience wrapper around the CheckStatePutter property.

    3020. 

  3020.         /// </para>

    3021. 

  3021.         /// </remarks>

    3022. 

  3022.         [Browsable(false),

    3023. 

  3023.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    3024. 

  3024.         public virtual BooleanCheckStatePutterDelegate BooleanCheckStatePutter {

    3025. 

  3025.             set {

    3026. 

  3026.                 if (value == null)

    3027. 

  3027.                     this.CheckStatePutter = null;

    3028. 

  3028.                 else

    3029. 

  3029.                     this.CheckStatePutter = delegate(Object x, CheckState state) {

    3030. 

  3030.                         bool isChecked = (state == CheckState.Checked);

    3031. 

  3031.                         return value(x, isChecked) ? CheckState.Checked : CheckState.Unchecked;

    3032. 

  3032.                     };

    3033. 

  3033.             }

    3034. 

  3034.         }

    3035. 

  3035. 

    3036. 

  3036.         /// <summary>

    3037. 

  3037.         /// Gets whether or not this listview is capabale of showing groups

    3038. 

  3038.         /// </summary>

    3039. 

  3039.         [Browsable(false)]

    3040. 

  3040.         public virtual bool CanShowGroups {

    3041. 

  3041.             get {

    3042. 

  3042.                 return true;

    3043. 

  3043.             }

    3044. 

  3044.         }

    3045. 

  3045. 

    3046. 

  3046.         /// <summary>

    3047. 

  3047.         /// This delegate is called when the list wants to show a tooltip for a particular cell.

    3048. 

  3048.         /// The delegate should return the text to display, or null to use the default behavior

    3049. 

  3049.         /// (which is to show the full text of truncated cell values).

    3050. 

  3050.         /// </summary>

    3051. 

  3051.         /// <remarks>

    3052. 

  3052.         /// Displaying the full text of truncated cell values only work for FullRowSelect listviews.

    3053. 

  3053.         /// This is MS's behavior, not mine. Don't complain to me :)

    3054. 

  3054.         /// </remarks>

    3055. 

  3055.         [Browsable(false),

    3056. 

  3056.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    3057. 

  3057.         public virtual CellToolTipGetterDelegate CellToolTipGetter {

    3058. 

  3058.             get { return cellToolTipGetter; }

    3059. 

  3059.             set { cellToolTipGetter = value; }

    3060. 

  3060.         }

    3061. 

  3061.         private CellToolTipGetterDelegate cellToolTipGetter;

    3062. 

  3062. 

    3063. 

  3063.         /// <summary>

    3064. 

  3064.         /// The name of the property (or field) that holds whether or not a model is checked.

    3065. 

  3065.         /// </summary>

    3066. 

  3066.         /// <remarks>

    3067. 

  3067.         /// <para>The property be modifiable. It must have a return type of bool (or of bool? if

    3068. 

  3068.         /// TriStateCheckBoxes is true).</para>

    3069. 

  3069.         /// <para>Setting this property replaces any CheckStateGetter or CheckStatePutter that have been installed.

    3070. 

  3070.         /// Conversely, later setting the CheckStateGetter or CheckStatePutter properties will take precedence

    3071. 

  3071.         /// over the behavior of this property.</para>

    3072. 

  3072.         /// </remarks>

    3073. 

  3073.         [Category("ObjectListView"),

    3074. 

  3074.          Description("The name of the property or field that holds the 'checkedness' of the model"),

    3075. 

  3075.          DefaultValue(null)]

    3076. 

  3076.         public virtual string CheckedAspectName {

    3077. 

  3077.             get { return checkedAspectName; }

    3078. 

  3078.             set {

    3079. 

  3079.                 checkedAspectName = value;

    3080. 

  3080.                 if (String.IsNullOrEmpty(checkedAspectName)) {

    3081. 

  3081.                     this.checkedAspectMunger = null;

    3082. 

  3082.                     this.CheckStateGetter = null;

    3083. 

  3083.                     this.CheckStatePutter = null;

    3084. 

  3084.                 } else {

    3085. 

  3085.                     this.checkedAspectMunger = new Munger(checkedAspectName);

    3086. 

  3086.                     this.CheckStateGetter = delegate(Object modelObject) {

    3087. 

  3087.                         bool? result = this.checkedAspectMunger.GetValue(modelObject) as bool?;

    3088. 

  3088.                         if (result.HasValue)

    3089. 

  3089.                             if (result.Value)

    3090. 

  3090.                                 return CheckState.Checked;

    3091. 

  3091.                             else

    3092. 

  3092.                                 return CheckState.Unchecked;

    3093. 

  3093.                         else

    3094. 

  3094.                             if (this.TriStateCheckBoxes)

    3095. 

  3095.                                 return CheckState.Indeterminate;

    3096. 

  3096.                             else

    3097. 

  3097.                                 return CheckState.Unchecked;

    3098. 

  3098.                     };

    3099. 

  3099.                     this.CheckStatePutter = delegate(Object modelObject, CheckState newValue) {

    3100. 

  3100.                         if (this.TriStateCheckBoxes && newValue == CheckState.Indeterminate)

    3101. 

  3101.                             this.checkedAspectMunger.PutValue(modelObject, null);

    3102. 

  3102.                         else

    3103. 

  3103.                             this.checkedAspectMunger.PutValue(modelObject, newValue == CheckState.Checked);

    3104. 

  3104.                         return this.CheckStateGetter(modelObject);

    3105. 

  3105.                     };

    3106. 

  3106.                 }

    3107. 

  3107.             }

    3108. 

  3108.         }

    3109. 

  3109.         private string checkedAspectName;

    3110. 

  3110.         private Munger checkedAspectMunger;

    3111. 

  3111. 

    3112. 

  3112.         /// <summary>

    3113. 

  3113.         /// This delegate will be called whenever the ObjectListView needs to know the check state

    3114. 

  3114.         /// of the row associated with a given model object.

    3115. 

  3115.         /// </summary>

    3116. 

  3116.         /// <remarks>

    3117. 

  3117.         /// <para>.NET has no support for indeterminate values, but as of v2.0, this class allows

    3118. 

  3118.         /// indeterminate values.</para>

    3119. 

  3119.         /// </remarks>

    3120. 

  3120.         [Browsable(false),

    3121. 

  3121.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    3122. 

  3122.         public virtual CheckStateGetterDelegate CheckStateGetter {

    3123. 

  3123.             get { return checkStateGetter; }

    3124. 

  3124.             set { checkStateGetter = value; }

    3125. 

  3125.         }

    3126. 

  3126.         private CheckStateGetterDelegate checkStateGetter;

    3127. 

  3127. 

    3128. 

  3128.         /// <summary>

    3129. 

  3129.         /// This delegate will be called whenever the user tries to change the check state of a row.

    3130. 

  3130.         /// The delegate should return the state that was actually set, which may be different

    3131. 

  3131.         /// to the state given.

    3132. 

  3132.         /// </summary>

    3133. 

  3133.         [Browsable(false),

    3134. 

  3134.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    3135. 

  3135.         public virtual CheckStatePutterDelegate CheckStatePutter {

    3136. 

  3136.             get { return checkStatePutter; }

    3137. 

  3137.             set { checkStatePutter = value; }

    3138. 

  3138.         }

    3139. 

  3139.         private CheckStatePutterDelegate checkStatePutter;

    3140. 

  3140. 

    3141. 

  3141.         /// <summary>

    3142. 

  3142.         /// This delegate can be used to sort the table in a custom fasion.

    3143. 

  3143.         /// </summary>

    3144. 

  3144.         /// <remarks>

    3145. 

  3145.         /// <para>

    3146. 

  3146.         /// The delegate must install a ListViewItemSorter on the ObjectListView.

    3147. 

  3147.         /// Installing the ItemSorter does the actual work of sorting the ListViewItems.

    3148. 

  3148.         /// See ColumnComparer in the code for an example of what an ItemSorter has to do.

    3149. 

  3149.         /// </para>

    3150. 

  3150.         /// <para>

    3151. 

  3151.         /// Do not install a CustomSorter on a VirtualObjectListView. Override the SortObjects()

    3152. 

  3152.         /// method of the IVirtualListDataSource instead.

    3153. 

  3153.         /// </para>

    3154. 

  3154.         /// </remarks>

    3155. 

  3155.         [Browsable(false),

    3156. 

  3156.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    3157. 

  3157.         public virtual SortDelegate CustomSorter {

    3158. 

  3158.             get { return customSorter; }

    3159. 

  3159.             set { customSorter = value; }

    3160. 

  3160.         }

    3161. 

  3161.         private SortDelegate customSorter;

    3162. 

  3162. 

    3163. 

  3163.         /// <summary>

    3164. 

  3164.         /// This delegate is called when the list wants to show a tooltip for a particular header.

    3165. 

  3165.         /// The delegate should return the text to display, or null to use the default behavior

    3166. 

  3166.         /// (which is to not show any tooltip).

    3167. 

  3167.         /// </summary>

    3168. 

  3168.         /// <remarks>

    3169. 

  3169.         /// Installing a HeaderToolTipGetter takes precedence over any text in OLVColumn.ToolTipText.

    3170. 

  3170.         /// </remarks>

    3171. 

  3171.         [Browsable(false),

    3172. 

  3172.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    3173. 

  3173.         public virtual HeaderToolTipGetterDelegate HeaderToolTipGetter {

    3174. 

  3174.             get { return headerToolTipGetter; }

    3175. 

  3175.             set { headerToolTipGetter = value; }

    3176. 

  3176.         }

    3177. 

  3177.         private HeaderToolTipGetterDelegate headerToolTipGetter;

    3178. 

  3178. 

    3179. 

  3179.         /// <summary>

    3180. 

  3180.         /// This delegate can be used to format a OLVListItem before it is added to the control.

    3181. 

  3181.         /// </summary>

    3182. 

  3182.         /// <remarks>

    3183. 

  3183.         /// <para>The model object for the row can be found through the RowObject property of the OLVListItem object.</para>

    3184. 

  3184.         /// <para>All subitems normally have the same style as list item, so setting the forecolor on one

    3185. 

  3185.         /// subitem changes the forecolor of all subitems.

    3186. 

  3186.         /// To allow subitems to have different attributes, do this:

    3187. 

  3187.         /// <code>myListViewItem.UseItemStyleForSubItems = false;</code>.

    3188. 

  3188.         /// </para>

    3189. 

  3189.         /// <para>If UseAlternatingBackColors is true, the backcolor of the listitem will be calculated

    3190. 

  3190.         /// by the control and cannot be controlled by the RowFormatter delegate.

    3191. 

  3191.         /// In general, trying to use a RowFormatter

    3192. 

  3192.         /// when UseAlternatingBackColors is true does not work well.</para>

    3193. 

  3193.         /// <para>As it says in the summary, this is called <b>before</b> the item is added to the control.

    3194. 

  3194.         /// Many properties of the OLVListItem itself are not available at that point, including:

    3195. 

  3195.         /// Index, Selected, Focused, Bounds, Checked, DisplayIndex.</para>

    3196. 

  3196.         /// </remarks>

    3197. 

  3197.         [Browsable(false),

    3198. 

  3198.          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    3199. 

  3199.         public virtual RowFormatterDelegate RowFormatter {

    3200. 

  3200.             get { return rowFormatter; }

    3201. 

  3201.             set { rowFormatter = value; }

    3202. 

  3202.         }

    3203. 

  3203.         private RowFormatterDelegate rowFormatter;

    3204. 

  3204. 

    3205. 

  3205.         #endregion

    3206. 

  3206. 

    3207. 

  3207.         #region List commands

    3208. 

  3208. 

    3209. 

  3209.         /// <summary>

    3210. 

  3210.         /// Add the given model object to this control.

    3211. 

  3211.         /// </summary>

    3212. 

  3212.         /// <param name="modelObject">The model object to be displayed</param>

    3213. 

  3213.         /// <remarks>See AddObjects() for more details</remarks>

    3214. 

  3214.         public virtual void AddObject(object modelObject) {

    3215. 

  3215.             if (this.InvokeRequired)

    3216. 

  3216.                 this.Invoke((MethodInvoker)delegate() { this.AddObject(modelObject); });

    3217. 

  3217.             else

    3218. 

  3218.                 this.AddObjects(new object[] { modelObject });

    3219. 

  3219.         }

    3220. 

  3220. 

    3221. 

  3221.         /// <summary>

    3222. 

  3222.         /// Add the given collection of model objects to this control.

    3223. 

  3223.         /// </summary>

    3224. 

  3224.         /// <param name="modelObjects">A collection of model objects</param>

    3225. 

  3225.         /// <remarks>

    3226. 

  3226.         /// <para>The added objects will appear in their correct sort position, if sorting

    3227. 

  3227.         /// is active (i.e. if LastSortColumn is not null). Otherwise, they will appear at the end of the list.</para>

    3228. 

  3228.         /// <para>No check is performed to see if any of the objects are already in the ListView.</para>

    3229. 

  3229.         /// <para>Null objects are silently ignored.</para>

    3230. 

  3230.         /// </remarks>

    3231. 

  3231.         public virtual void AddObjects(ICollection modelObjects) {

    3232. 

  3232.             if (this.InvokeRequired) {

    3233. 

  3233.                 this.Invoke((MethodInvoker)delegate() { this.AddObjects(modelObjects); });

    3234. 

  3234.                 return;

    3235. 

  3235.             }

    3236. 

  3236.             this.InsertObjects(this.GetItemCount(), modelObjects);

    3237. 

  3237.             this.Sort(this.LastSortColumn, this.LastSortOrder);

    3238. 

  3238. 

    3239. 

  3239.         }

    3240. 

  3240. 

    3241. 

  3241.         /// <summary>

    3242. 

  3242.         /// Resize the columns to the maximum of the header width and the data.

    3243. 

  3243.         /// </summary>		

    3244. 

  3244.         public void AutoResizeColumns()

    3245. 

  3245.         {

    3246. 

  3246.             foreach (OLVColumn c in this.Columns)

    3247. 

  3247.             {

    3248. 

  3248.                 c.Width = -2;

    3249. 

  3249.             }

    3250. 

  3250.         }

    3251. 

  3251. 

    3252. 

  3252.         /// <summary>

    3253. 

  3253.         /// Organise the view items into groups, based on the last sort column or the first column

    3254. 

  3254.         /// if there is no last sort column

    3255. 

  3255.         /// </summary>

    3256. 

  3256.         public virtual void BuildGroups() {

    3257. 

  3257.             this.BuildGroups(this.LastSortColumn, this.LastSortOrder == SortOrder.None ? SortOrder.Ascending : this.LastSortOrder);

    3258. 

  3258.         }

    3259. 

  3259. 

    3260. 

  3260.         /// <summary>

    3261. 

  3261.         /// Organise the view items into groups, based on the given column

    3262. 

  3262.         /// </summary>

    3263. 

  3263.         /// <remarks>

    3264. 

  3264.         /// <para>

    3265. 

  3265.         /// If the AlwaysGroupByColumn property is not null,

    3266. 

  3266.         /// the list view items will be organisd by that column,

    3267. 

  3267.         /// and the 'column' parameter will be ignored.

    3268. 

  3268.         /// </para>

    3269. 

  3269.         /// <para>This method triggers sorting events: BeforeSorting and AfterSorting.</para>

    3270. 

  3270.         /// </remarks>

    3271. 

  3271.         /// <param name="column">The column whose values should be used for sorting.</param>

    3272. 

  3272.         /// <param name="order"></param>

    3273. 

  3273.         public virtual void BuildGroups(OLVColumn column, SortOrder order) {

    3274. 

  3274.             BeforeSortingEventArgs args = this.BuildBeforeSortingEventArgs(column, order);

    3275. 

  3275.             this.OnBeforeSorting(args);

    3276. 

  3276.             if (args.Canceled)

    3277. 

  3277.                 return;

    3278. 

  3278. 

    3279. 

  3279.             this.BuildGroups(args.ColumnToGroupBy, args.GroupByOrder,

    3280. 

  3280.                 args.ColumnToSort, args.SortOrder, args.SecondaryColumnToSort, args.SecondarySortOrder);

    3281. 

  3281. 

    3282. 

  3282.             this.OnAfterSorting(new AfterSortingEventArgs(args));

    3283. 

  3283.         }

    3284. 

  3284. 

    3285. 

  3285.         private BeforeSortingEventArgs BuildBeforeSortingEventArgs(OLVColumn column, SortOrder order) {

    3286. 

  3286.             OLVColumn groupBy = this.AlwaysGroupByColumn ?? column ?? this.GetColumn(0);

    3287. 

  3287.             SortOrder groupByOrder = this.AlwaysGroupBySortOrder;

    3288. 

  3288.             if (order == SortOrder.None) {

    3289. 

  3289.                 order = this.Sorting;

    3290. 

  3290.                 if (order == SortOrder.None)

    3291. 

  3291.                     order = SortOrder.Ascending;

    3292. 

  3292.             }

    3293. 

  3293.             if (groupByOrder == SortOrder.None)

    3294. 

  3294.                 groupByOrder = order;

    3295. 

  3295. 

    3296. 

  3296.             BeforeSortingEventArgs args = new BeforeSortingEventArgs(

    3297. 

  3297.                 groupBy, groupByOrder,

    3298. 

  3298.                 column, order,

    3299. 

  3299.                 this.SecondarySortColumn ?? this.GetColumn(0),

    3300. 

  3300.                 this.SecondarySortOrder == SortOrder.None ? order : this.SecondarySortOrder);

    3301. 

  3301.             if (column != null)

    3302. 

  3302.                 args.Canceled = !column.Sortable;

    3303. 

  3303.             return args;

    3304. 

  3304.         }

    3305. 

  3305. 

    3306. 

  3306.         /// <summary>

    3307. 

  3307.         /// Organise the view items into groups, based on the given columns

    3308. 

  3308.         /// </summary>

    3309. 

  3309.         /// <param name="groupByColumn">What column will be used for grouping</param>

    3310. 

  3310.         /// <param name="groupByOrder">What ordering will be used for groups</param>

    3311. 

  3311.         /// <param name="column">The column whose values should be used for sorting. Cannot be null</param>

    3312. 

  3312.         /// <param name="order">The order in which the values from column will be sorted</param>

    3313. 

  3313.         /// <param name="secondaryColumn">When the values from 'column' are equal, use the values provided by this column</param>

    3314. 

  3314.         /// <param name="secondaryOrder">How will the secondary values be sorted</param>

    3315. 

  3315.         /// <remarks>This method does not trigger sorting events. Use BuildGroups() to do that</remarks>

    3316. 

  3316.         public virtual void BuildGroups(OLVColumn groupByColumn, SortOrder groupByOrder,

    3317. 

  3317.             OLVColumn column, SortOrder order, OLVColumn secondaryColumn, SortOrder secondaryOrder) {

    3318. 

  3318.             // Sanity checks

    3319. 

  3319.             if (groupByColumn == null)

    3320. 

  3320.                 return;

    3321. 

  3321. 

    3322. 

  3322.             // Getting the Count forces any internal cache of the ListView to be flushed. Without

    3323. 

  3323.             // this, iterating over the Items will not work correctly if the ListView handle

    3324. 

  3324.             // has not yet been created.

    3325. 

  3325.             int dummy = this.Items.Count;

    3326. 

  3326. 

    3327. 

  3327.             // Collect all the information that governs the creation of groups

    3328. 

  3328.             GroupingParameters parms = this.CollectGroupingParameters(groupByColumn, groupByOrder,

    3329. 

  3329.                 column, order, secondaryColumn, secondaryOrder);

    3330. 

  3330. 

    3331. 

  3331.             // Trigger an event to let the world create groups if they want

    3332. 

  3332.             CreateGroupsEventArgs args = new CreateGroupsEventArgs(parms);

    3333. 

  3333.             if (parms.GroupByColumn != null)

    3334. 

  3334.                 args.Canceled = !parms.GroupByColumn.Groupable;

    3335. 

  3335.             this.OnBeforeCreatingGroups(args);

    3336. 

  3336.             if (args.Canceled)

    3337. 

  3337.                 return;

    3338. 

  3338. 

    3339. 

  3339.             // If the event didn't create them for us, use our default strategy

    3340. 

  3340.             if (args.Groups == null) 

    3341. 

  3341.                 args.Groups = this.MakeGroups(parms);

    3342. 

  3342. 

    3343. 

  3343.             // Give the world a chance to munge the groups before they are created

    3344. 

  3344.             this.OnAboutToCreateGroups(args);

    3345. 

  3345.             if (args.Canceled)

    3346. 

  3346.                 return;

    3347. 

  3347. 

    3348. 

  3348.             // Create the groups now

    3349. 

  3349.             this.OLVGroups = args.Groups;

    3350. 

  3350.             this.CreateGroups(args.Groups);

    3351. 

  3351. 

    3352. 

  3352.             // Tell the world that new groups have been created

    3353. 

  3353.             this.OnAfterCreatingGroups(args);

    3354. 

  3354.         }

    3355. 

  3355. 

    3356. 

  3356.         /// <summary>

    3357. 

  3357.         /// Collect and return all the variables that influence the creation of groups

    3358. 

  3358.         /// </summary>

    3359. 

  3359.         /// <returns></returns>

    3360. 

  3360.         protected virtual GroupingParameters CollectGroupingParameters(OLVColumn groupByColumn, SortOrder groupByOrder,

    3361. 

  3361.             OLVColumn column, SortOrder order, OLVColumn secondaryColumn, SortOrder secondaryOrder) {

    3362. 

  3362.             string titleFormat = this.ShowItemCountOnGroups ? groupByColumn.GroupWithItemCountFormatOrDefault : null;

    3363. 

  3363.             string titleSingularFormat = this.ShowItemCountOnGroups ? groupByColumn.GroupWithItemCountSingularFormatOrDefault : null;

    3364. 

  3364.             GroupingParameters parms = new GroupingParameters(this, groupByColumn, groupByOrder,

    3365. 

  3365.                 column, order, secondaryColumn, secondaryOrder,

    3366. 

  3366.                 titleFormat, titleSingularFormat, this.SortGroupItemsByPrimaryColumn);

    3367. 

  3367.             return parms;

    3368. 

  3368.         }

    3369. 

  3369. 

    3370. 

  3370.         /// <summary>

    3371. 

  3371.         /// Make a list of groups that should be shown according to the given parameters

    3372. 

  3372.         /// </summary>

    3373. 

  3373.         /// <param name="parms"></param>

    3374. 

  3374.         /// <returns>The list of groups to be created</returns>

    3375. 

  3375.         /// <remarks>This should not change the state of the control. It is possible that the

    3376. 

  3376.         /// groups created will not be used. They may simply be discarded.</remarks>

    3377. 

  3377.         protected virtual IList<OLVGroup> MakeGroups(GroupingParameters parms) {

    3378. 

  3378. 

    3379. 

  3379.             // There is a lot of overlap between this method and FastListGroupingStrategy.MakeGroups()

    3380. 

  3380.             // Any changes made here may need to be reflected there

    3381. 

  3381. 

    3382. 

  3382.             // Separate the list view items into groups, using the group key as the descrimanent

    3383. 

  3383.             NullableDictionary<object, List<OLVListItem>> map = new NullableDictionary<object, List<OLVListItem>>();

    3384. 

  3384.             foreach (OLVListItem olvi in parms.ListView.Items) {

    3385. 

  3385.                 object key = parms.GroupByColumn.GetGroupKey(olvi.RowObject);

    3386. 

  3386.                 if (!map.ContainsKey(key))

    3387. 

  3387.                     map[key] = new List<OLVListItem>();

    3388. 

  3388.                 map[key].Add(olvi);

    3389. 

  3389.             }

    3390. 

  3390. 

    3391. 

  3391.             // Sort the items within each group (unless specifically turned off)

    3392. 

  3392.             OLVColumn primarySortColumn = parms.SortItemsByPrimaryColumn ? parms.ListView.GetColumn(0) : parms.PrimarySort;

    3393. 

  3393.             if (primarySortColumn != null && parms.PrimarySortOrder != SortOrder.None) {

    3394. 

  3394.                 ColumnComparer itemSorter = new ColumnComparer(primarySortColumn, parms.PrimarySortOrder,

    3395. 

  3395.                     parms.SecondarySort, parms.SecondarySortOrder);

    3396. 

  3396.                 foreach (object key in map.Keys) {

    3397. 

  3397.                     map[key].Sort(parms.ItemComparer ?? itemSorter);

    3398. 

  3398.                 }

    3399. 

  3399.             }

    3400. 

  3400. 

    3401. 

  3401.             // Make a list of the required groups

    3402. 

  3402.             List<OLVGroup> groups = new List<OLVGroup>();

    3403. 

  3403.             foreach (object key in map.Keys) {

    3404. 

  3404.                 string title = parms.GroupByColumn.ConvertGroupKeyToTitle(key);

    3405. 

  3405.                 if (!String.IsNullOrEmpty(parms.TitleFormat)) {

    3406. 

  3406.                     int count = map[key].Count;

    3407. 

  3407.                     string format = (count == 1 ? parms.TitleSingularFormat : parms.TitleFormat);

    3408. 

  3408.                     try {

    3409. 

  3409.                         title = String.Format(format, title, count);

    3410. 

  3410.                     } catch (FormatException) {

    3411. 

  3411.                         title = "Invalid group format: " + format;

    3412. 

  3412.                     }

    3413. 

  3413.                 }

    3414. 

  3414. 

    3415. 

  3415.                 OLVGroup lvg = new OLVGroup(title);

    3416. 

  3416.                 lvg.Collapsible = this.HasCollapsibleGroups;

    3417. 

  3417.                 lvg.Key = key;

    3418. 

  3418.                 lvg.SortValue = key as IComparable;

    3419. 

  3419.                 lvg.Items = map[key];

    3420. 

  3420.                 if (parms.GroupByColumn.GroupFormatter != null)

    3421. 

  3421.                     parms.GroupByColumn.GroupFormatter(lvg, parms);

    3422. 

  3422.                 groups.Add(lvg);

    3423. 

  3423.             }

    3424. 

  3424. 

    3425. 

  3425.             // Sort the groups

    3426. 

  3426.             if (parms.GroupByOrder != SortOrder.None)

    3427. 

  3427.                 groups.Sort(parms.GroupComparer ?? new OLVGroupComparer(parms.GroupByOrder));

    3428. 

  3428. 

    3429. 

  3429.             return groups;

    3430. 

  3430.         }

    3431. 

  3431. 

    3432. 

  3432.         /// <summary>

    3433. 

  3433.         /// Build/rebuild all the list view items in the list

    3434. 

  3434.         /// </summary>

    3435. 

  3435.         public virtual void BuildList() {

    3436. 

  3436.             if (this.InvokeRequired)

    3437. 

  3437.                 this.Invoke(new MethodInvoker(this.BuildList));

    3438. 

  3438.             else

    3439. 

  3439.                 this.BuildList(true);

    3440. 

  3440.         }

    3441. 

  3441. 

    3442. 

  3442.         /// <summary>

    3443. 

  3443.         /// Build/rebuild all the list view items in the list

    3444. 

  3444.         /// </summary>

    3445. 

  3445.         /// <param name="shouldPreserveState">If this is true, the control will try to preserve the selection,

    3446. 

  3446.         /// focused item, and the scroll position (see Remarks)

    3447. 

  3447.         /// </param>

    3448. 

  3448.         /// <remarks>

    3449. 

  3449.         /// <para>

    3450. 

  3450.         /// Use this method in situations were the contents of the list is basically the same

    3451. 

  3451.         /// as previously.

    3452. 

  3452.         /// </para>

    3453. 

  3453.         /// <para>

    3454. 

  3454.         /// Due to limitations in .NET's ListView, the scroll position is only preserved if

    3455. 

  3455.         /// the control is in Details view AND it is not showing groups.

    3456. 

  3456.         /// </para>

    3457. 

  3457.         /// </remarks>

    3458. 

  3458.         public virtual void BuildList(bool shouldPreserveState) {

    3459. 

  3459.             if (this.Frozen)

    3460. 

  3460.                 return;

    3461. 

  3461. 

    3462. 

  3462.             this.ApplyExtendedStyles();

    3463. 

  3463.             this.ClearHotItem();

    3464. 

  3464.             int previousTopIndex = this.TopItemIndex;

    3465. 

  3465.             Point currentScrollPosition = this.LowLevelScrollPosition;

    3466. 

  3466. 

    3467. 

  3467.             IList previousSelection = new ArrayList();

    3468. 

  3468.             Object previousFocus = null;

    3469. 

  3469.             if (shouldPreserveState && this.objects != null) {

    3470. 

  3470.                 previousSelection = this.SelectedObjects;

    3471. 

  3471.                 OLVListItem focusedItem = this.FocusedItem as OLVListItem;

    3472. 

  3472.                 if (focusedItem != null)

    3473. 

  3473.                     previousFocus = focusedItem.RowObject;

    3474. 

  3474.             }

    3475. 

  3475. 

    3476. 

  3476.             IEnumerable objectsToDisplay = this.FilteredObjects;

    3477. 

  3477. 

    3478. 

  3478.             this.BeginUpdate();

    3479. 

  3479.             try {

    3480. 

  3480.                 this.Items.Clear();

    3481. 

  3481.                 this.ListViewItemSorter = null;

    3482. 

  3482. 

    3483. 

  3483.                 if (objectsToDisplay != null) {

    3484. 

  3484.                     // Build a list of all our items and then display them. (Building

    3485. 

  3485.                     // a list and then doing one AddRange is about 10-15% faster than individual adds)

    3486. 

  3486.                     List<OLVListItem> itemList = new List<OLVListItem>();

    3487. 

  3487.                     foreach (object rowObject in objectsToDisplay) {

    3488. 

  3488.                         OLVListItem lvi = new OLVListItem(rowObject);

    3489. 

  3489.                         this.FillInValues(lvi, rowObject);

    3490. 

  3490.                         itemList.Add(lvi);

    3491. 

  3491.                     }

    3492. 

  3492.                     this.Items.AddRange(itemList.ToArray());

    3493. 

  3493.                     this.Sort();

    3494. 

  3494. 

    3495. 

  3495.                     if (shouldPreserveState) {

    3496. 

  3496.                         this.SelectedObjects = previousSelection;

    3497. 

  3497.                         this.FocusedItem = this.ModelToItem(previousFocus);

    3498. 

  3498.                     }

    3499. 

  3499. 

    3500. 

  3500.                     this.RefreshHotItem();

    3501. 

  3501.                 }

    3502. 

  3502.             } finally {

    3503. 

  3503.                 this.EndUpdate();

    3504. 

  3504.             }

    3505. 

  3505. 

    3506. 

  3506.             // We can only restore the scroll position after the EndUpdate() because

    3507. 

  3507.             // of caching that the ListView does internally during a BeginUpdate/EndUpdate pair.

    3508. 

  3508.             if (shouldPreserveState) {

    3509. 

  3509.                 this.RefreshHotItem();

    3510. 

  3510. 

    3511. 

  3511.                 // Restore the scroll position. TopItemIndex is best, but doesn't work

    3512. 

  3512.                 // when the control is grouped.

    3513. 

  3513.                 if (this.ShowGroups)

    3514. 

  3514.                     this.LowLevelScroll(currentScrollPosition.X, currentScrollPosition.Y);

    3515. 

  3515.                 else

    3516. 

  3516.                     this.TopItemIndex = previousTopIndex;

    3517. 

  3517. 

    3518. 

  3518.             }

    3519. 

  3519.         }

    3520. 

  3520. 

    3521. 

  3521.         /// <summary>

    3522. 

  3522.         /// Apply all required extended styles to our control.

    3523. 

  3523.         /// </summary>

    3524. 

  3524.         /// <remarks>

    3525. 

  3525.         /// <para>

    3526. 

  3526.         /// Whenever .NET code sets an extended style, it erases all other extended styles

    3527. 

  3527.         /// that it doesn't use. So, we have to explicit reapply the styles that we have

    3528. 

  3528.         /// added.

    3529. 

  3529.         /// </para>

    3530. 

  3530.         /// <para>

    3531. 

  3531.         /// Normally, we would override CreateParms property and update

    3532. 

  3532.         /// the ExStyle member, but ListView seems to ignore all ExStyles that

    3533. 

  3533.         /// it doesn't already know about. Worse, when we set the LVS_EX_HEADERINALLVIEWS 

    3534. 

  3534.         /// value, bad things happen (the control crashes!).

    3535. 

  3535.         /// </para>

    3536. 

  3536.         /// </remarks>

    3537. 

  3537.         protected virtual void ApplyExtendedStyles() {

    3538. 

  3538.             const int LVS_EX_SUBITEMIMAGES = 0x00000002;

    3539. 

  3539.             //const int LVS_EX_TRANSPARENTBKGND = 0x00400000;

    3540. 

  3540.             const int LVS_EX_HEADERINALLVIEWS = 0x02000000;

    3541. 

  3541. 

    3542. 

  3542.             const int styleMask = LVS_EX_SUBITEMIMAGES | LVS_EX_HEADERINALLVIEWS;

    3543. 

  3543.             int style = 0;

    3544. 

  3544. 

    3545. 

  3545.             if (this.ShowImagesOnSubItems && !this.VirtualMode)

    3546. 

  3546.                 style ^= LVS_EX_SUBITEMIMAGES;

    3547. 

  3547. 

    3548. 

  3548.             if (this.ShowHeaderInAllViews)

    3549. 

  3549.                 style ^= LVS_EX_HEADERINALLVIEWS;

    3550. 

  3550. 

    3551. 

  3551.             NativeMethods.SetExtendedStyle(this, style, styleMask);

    3552. 

  3552.         }

    3553. 

  3553. 

    3554. 

  3554.         /// <summary>

    3555. 

  3555.         /// Give the listview a reasonable size of its tiles, based on the number of lines of

    3556. 

  3556.         /// information that each tile is going to display.

    3557. 

  3557.         /// </summary>

    3558. 

  3558.         public virtual void CalculateReasonableTileSize() {

    3559. 

  3559.             if (this.Columns.Count <= 0)

    3560. 

  3560.                 return;

    3561. 

  3561. 

    3562. 

  3562.             List<OLVColumn> columns = this.AllColumns.FindAll(delegate(OLVColumn x) {

    3563. 

  3563.                 return (x.Index == 0) || x.IsTileViewColumn;

    3564. 

  3564.             });

    3565. 

  3565. 

    3566. 

  3566.             int imageHeight = (this.LargeImageList == null ? 16 : this.LargeImageList.ImageSize.Height);

    3567. 

  3567.             int dataHeight = (this.Font.Height + 1) * columns.Count;

    3568. 

  3568.             int tileWidth = (this.TileSize.Width == 0 ? 200 : this.TileSize.Width);

    3569. 

  3569.             int tileHeight = Math.Max(this.TileSize.Height, Math.Max(imageHeight, dataHeight));

    3570. 

  3570.             this.TileSize = new Size(tileWidth, tileHeight);

    3571. 

  3571.         }

    3572. 

  3572. 

    3573. 

  3573.         /// <summary>

    3574. 

  3574.         /// Rebuild this list for the given view

    3575. 

  3575.         /// </summary>

    3576. 

  3576.         /// <param name="view"></param>

    3577. 

  3577.         public virtual void ChangeToFilteredColumns(View view) {

    3578. 

  3578.             // Store the state

    3579. 

  3579.             IList previousSelection = this.SelectedObjects;

    3580. 

  3580.             int previousTopIndex = this.TopItemIndex;

    3581. 

  3581. 

    3582. 

  3582.             this.Freeze();

    3583. 

  3583.             this.Clear();

    3584. 

  3584.             List<OLVColumn> columns = this.GetFilteredColumns(view);

    3585. 

  3585.             if (view == View.Details) {

    3586. 

  3586.                 // Make sure all columns have a reasonable LastDisplayIndex

    3587. 

  3587.                 for (int index = 0; index < columns.Count; index++)

    3588. 

  3588.                 {

    3589. 

  3589.                     if (columns[index].LastDisplayIndex == -1)

    3590. 

  3590.                         columns[index].LastDisplayIndex = index;

    3591. 

  3591.                 }

    3592. 

  3592.                 // ListView will ignore DisplayIndex FOR ALL COLUMNS if there are any errors, 

    3593. 

  3593.                 // e.g. duplicates (two columns with the same DisplayIndex) or gaps. 

    3594. 

  3594.                 // LastDisplayIndex isn't guaranteed to be unique, so we just sort the columns by

    3595. 

  3595.                 // the last position they were displayed and use that to generate a sequence 

    3596. 

  3596.                 // we can use for the DisplayIndex values.

    3597. 

  3597.                 List<OLVColumn> columnsInDisplayOrder = new List<OLVColumn>(columns);

    3598. 

  3598.                 columnsInDisplayOrder.Sort(delegate(OLVColumn x, OLVColumn y) { return (x.LastDisplayIndex - y.LastDisplayIndex); });

    3599. 

  3599.                 int i = 0;

    3600. 

  3600.                 foreach (OLVColumn col in columnsInDisplayOrder)

    3601. 

  3601.                     col.DisplayIndex = i++;

    3602. 

  3602.             }

    3603. 

  3603. 

    3604. 

  3604.             this.Columns.AddRange(columns.ToArray());

    3605. 

  3605.             if (view == View.Details)

    3606. 

  3606.                 this.ShowSortIndicator();

    3607. 

  3607.             this.BuildList();

    3608. 

  3608.             this.Unfreeze();

    3609. 

  3609. 

    3610. 

  3610.             // Restore the state

    3611. 

  3611.             this.SelectedObjects = previousSelection;

    3612. 

  3612.             this.TopItemIndex = previousTopIndex;

    3613. 

  3613.         }

    3614. 

  3614. 

    3615. 

  3615.         /// <summary>

    3616. 

  3616.         /// Remove all items from this list

    3617. 

  3617.         /// </summary>

    3618. 

  3618.         /// <remark>This method can safely be called from background threads.</remark>

    3619. 

  3619.         public virtual void ClearObjects() {

    3620. 

  3620.             if (this.InvokeRequired)

    3621. 

  3621.                 this.Invoke(new MethodInvoker(this.ClearObjects));

    3622. 

  3622.             else

    3623. 

  3623.                 this.SetObjects(null);

    3624. 

  3624.         }

    3625. 

  3625. 

    3626. 

  3626.         /// <summary>

    3627. 

  3627.         /// Reset the memory of which URLs have been visited

    3628. 

  3628.         /// </summary>

    3629. 

  3629.         public virtual void ClearUrlVisited() {

    3630. 

  3630.             this.visitedUrlMap = new Dictionary<string, bool>();

    3631. 

  3631.         }

    3632. 

  3632. 

    3633. 

  3633.         /// <summary>

    3634. 

  3634.         /// Copy a text and html representation of the selected rows onto the clipboard.

    3635. 

  3635.         /// </summary>

    3636. 

  3636.         /// <remarks>Be careful when using this with virtual lists. If the user has selected

    3637. 

  3637.         /// 10,000,000 rows, this method will faithfully try to copy all of them to the clipboard.

    3638. 

  3638.         /// From the user's point of view, your program will appear to have hung.</remarks>

    3639. 

  3639.         public virtual void CopySelectionToClipboard() {

    3640. 

  3640.             IList selection = this.SelectedObjects;

    3641. 

  3641.             if (selection.Count == 0)

    3642. 

  3642.                 return;

    3643. 

  3643. 

    3644. 

  3644.             // Use the DragSource object to create the data object, if so configured.

    3645. 

  3645.             // This relies on the assumption that DragSource will handle the selected objects only.

    3646. 

  3646.             // It is legal for StartDrag to return null.

    3647. 

  3647.             object data = null;

    3648. 

  3648.             if (this.CopySelectionOnControlCUsesDragSource && this.DragSource != null)

    3649. 

  3649.                 data = this.DragSource.StartDrag(this, MouseButtons.Left, this.ModelToItem(selection[0]));

    3650. 

  3650. 

    3651. 

  3651.             Clipboard.SetDataObject(data ?? new OLVDataObject(this, selection));

    3652. 

  3652.         }

    3653. 

  3653. 

    3654. 

  3654.         /// <summary>

    3655. 

  3655.         /// Copy a text and html representation of the given objects onto the clipboard.

    3656. 

  3656.         /// </summary>

    3657. 

  3657.         public virtual void CopyObjectsToClipboard(IList objectsToCopy) {

    3658. 

  3658.             if (objectsToCopy.Count == 0)

    3659. 

  3659.                 return;

    3660. 

  3660. 

    3661. 

  3661.             // We don't know where these objects came from, so we can't use the DragSource to create

    3662. 

  3662.             // the data object, like we do with CopySelectionToClipboard() above.

    3663. 

  3663.             OLVDataObject dataObject = new OLVDataObject(this, objectsToCopy);

    3664. 

  3664.             dataObject.CreateTextFormats();

    3665. 

  3665.             Clipboard.SetDataObject(dataObject);

    3666. 

  3666.         }

    3667. 

  3667. 

    3668. 

  3668.         /// <summary>

    3669. 

  3669.         /// Return a html representation of the given objects

    3670. 

  3670.         /// </summary>

    3671. 

  3671.         public virtual string ObjectsToHtml(IList objectsToConvert) {

    3672. 

  3672.             if (objectsToConvert.Count == 0)

    3673. 

  3673.                 return String.Empty;

    3674. 

  3674. 

    3675. 

  3675.             OLVDataObject dataObject = new OLVDataObject(this, objectsToConvert);

    3676. 

  3676.             return dataObject.CreateHtml();

    3677. 

  3677.         }

    3678. 

  3678. 

    3679. 

  3679.         /// <summary>

    3680. 

  3680.         /// Deselect all rows in the listview

    3681. 

  3681.         /// </summary>

    3682. 

  3682.         public virtual void DeselectAll() {

    3683. 

  3683.             NativeMethods.DeselectAllItems(this);

    3684. 

  3684.         }

    3685. 

  3685. 

    3686. 

  3686.         /// <summary>

    3687. 

  3687.         /// Setup the list so it will draw selected rows using custom colours.

    3688. 

  3688.         /// </summary>

    3689. 

  3689.         /// <remarks>

    3690. 

  3690.         /// This method makes the list owner drawn, and ensures that all columns have at

    3691. 

  3691.         /// least a BaseRender installed.

    3692. 

  3692.         /// </remarks>

    3693. 

  3693.         public virtual void EnableCustomSelectionColors() {

    3694. 

  3694.             this.UseCustomSelectionColors = true;

    3695. 

  3695.         }

    3696. 

  3696. 

    3697. 

  3697.         /// <summary>

    3698. 

  3698.         /// Return the ListViewItem that appears immediately after the given item.

    3699. 

  3699.         /// If the given item is null, the first item in the list will be returned.

    3700. 

  3700.         /// Return null if the given item is the last item.

    3701. 

  3701.         /// </summary>

    3702. 

  3702.         /// <param name="itemToFind">The item that is before the item that is returned, or null</param>

    3703. 

  3703.         /// <returns>A ListViewItem</returns>

    3704. 

  3704.         public virtual OLVListItem GetNextItem(OLVListItem itemToFind) {

    3705. 

  3705.             if (this.ShowGroups) {

    3706. 

  3706.                 bool isFound = (itemToFind == null);

    3707. 

  3707.                 foreach (ListViewGroup group in this.Groups) {

    3708. 

  3708.                     foreach (OLVListItem olvi in group.Items) {

    3709. 

  3709.                         if (isFound)

    3710. 

  3710.                             return olvi;

    3711. 

  3711.                         isFound = (itemToFind == olvi);

    3712. 

  3712.                     }

    3713. 

  3713.                 }

    3714. 

  3714.                 return null;

    3715. 

  3715.             } else {

    3716. 

  3716.                 if (this.GetItemCount() == 0)

    3717. 

  3717.                     return null;

    3718. 

  3718.                 if (itemToFind == null)

    3719. 

  3719.                     return this.GetItem(0);

    3720. 

  3720.                 if (itemToFind.Index == this.GetItemCount() - 1)

    3721. 

  3721.                     return null;

    3722. 

  3722.                 return this.GetItem(itemToFind.Index + 1);

    3723. 

  3723.             }

    3724. 

  3724.         }

    3725. 

  3725. 

    3726. 

  3726.         /// <summary>

    3727. 

  3727.         /// Return the last item in the order they are shown to the user.

    3728. 

  3728.         /// If the control is not grouped, the display order is the same as the

    3729. 

  3729.         /// sorted list order. But if the list is grouped, the display order is different.

    3730. 

  3730.         /// </summary>

    3731. 

  3731.         /// <returns></returns>

    3732. 

  3732.         public virtual OLVListItem GetLastItemInDisplayOrder() {

    3733. 

  3733.             if (!this.ShowGroups)

    3734. 

  3734.                 return this.GetItem(this.GetItemCount() - 1);

    3735. 

  3735.             

    3736. 

  3736.             if (this.Groups.Count > 0) {

    3737. 

  3737.                 ListViewGroup lastGroup = this.Groups[this.Groups.Count - 1];

    3738. 

  3738.                 if (lastGroup.Items.Count > 0)

    3739. 

  3739.                     return (OLVListItem)lastGroup.Items[lastGroup.Items.Count - 1];

    3740. 

  3740.             }

    3741. 

  3741. 

    3742. 

  3742.             return null;

    3743. 

  3743.         }

    3744. 

  3744. 

    3745. 

  3745.         /// <summary>

    3746. 

  3746.         /// Return the n'th item (0-based) in the order they are shown to the user.

    3747. 

  3747.         /// If the control is not grouped, the display order is the same as the

    3748. 

  3748.         /// sorted list order. But if the list is grouped, the display order is different.

    3749. 

  3749.         /// </summary>

    3750. 

  3750.         /// <param name="n"></param>

    3751. 

  3751.         /// <returns></returns>

    3752. 

  3752.         public virtual OLVListItem GetNthItemInDisplayOrder(int n) {

    3753. 

  3753.             if (!this.ShowGroups)

    3754. 

  3754.                 return this.GetItem(n);

    3755. 

  3755. 

    3756. 

  3756.             foreach (ListViewGroup group in this.Groups) {

    3757. 

  3757.                 if (n < group.Items.Count)

    3758. 

  3758.                     return (OLVListItem)group.Items[n];

    3759. 

  3759. 

    3760. 

  3760.                 n -= group.Items.Count;

    3761. 

  3761.             }

    3762. 

  3762. 

    3763. 

  3763.             return null;

    3764. 

  3764.         }

    3765. 

  3765. 

    3766. 

  3766.         /// <summary>

    3767. 

  3767.         /// Return the index of the given ListViewItem as it currently shown to the user.

    3768. 

  3768.         /// If the control is not grouped, the display order is the same as the

    3769. 

  3769.         /// sorted list order. But if the list is grouped, the display order is different.

    3770. 

  3770.         /// </summary>

    3771. 

  3771.         /// <param name="value"></param>

    3772. 

  3772.         /// <returns></returns>

    3773. 

  3773.         public virtual int GetItemIndexInDisplayOrder(ListViewItem value) {

    3774. 

  3774.             if (!this.ShowGroups)

    3775. 

  3775.                 return value.Index;

    3776. 

  3776. 

    3777. 

  3777.             // TODO: This could be optimized

    3778. 

  3778.             int i = 0;

    3779. 

  3779.             foreach (ListViewGroup lvg in this.Groups) {

    3780. 

  3780.                 foreach (ListViewItem lvi in lvg.Items) {

    3781. 

  3781.                     if (lvi == value)

    3782. 

  3782.                         return i;

    3783. 

  3783.                     i++;

    3784. 

  3784.                 }

    3785. 

  3785.             }

    3786. 

  3786. 

    3787. 

  3787.             return -1;

    3788. 

  3788.         }

    3789. 

  3789. 

    3790. 

  3790.         /// <summary>

    3791. 

  3791.         /// Return the ListViewItem that appears immediately before the given item.

    3792. 

  3792.         /// If the given item is null, the last item in the list will be returned.

    3793. 

  3793.         /// Return null if the given item is the first item.

    3794. 

  3794.         /// </summary>

    3795. 

  3795.         /// <param name="itemToFind">The item that is before the item that is returned</param>

    3796. 

  3796.         /// <returns>A ListViewItem</returns>

    3797. 

  3797.         public virtual OLVListItem GetPreviousItem(OLVListItem itemToFind) {

    3798. 

  3798.             if (this.ShowGroups) {

    3799. 

  3799.                 OLVListItem previousItem = null;

    3800. 

  3800.                 foreach (ListViewGroup group in this.Groups) {

    3801. 

  3801.                     foreach (OLVListItem lvi in group.Items) {

    3802. 

  3802.                         if (lvi == itemToFind)

    3803. 

  3803.                             return previousItem;

    3804. 

  3804.                         else

    3805. 

  3805.                             previousItem = lvi;

    3806. 

  3806.                     }

    3807. 

  3807.                 }

    3808. 

  3808.                 if (itemToFind == null)

    3809. 

  3809.                     return previousItem;

    3810. 

  3810.                 else

    3811. 

  3811.                     return null;

    3812. 

  3812.             } else {

    3813. 

  3813.                 if (this.GetItemCount() == 0)

    3814. 

  3814.                     return null;

    3815. 

  3815.                 if (itemToFind == null)

    3816. 

  3816.                     return this.GetItem(this.GetItemCount() - 1);

    3817. 

  3817.                 if (itemToFind.Index == 0)

    3818. 

  3818.                     return null;

    3819. 

  3819.                 return this.GetItem(itemToFind.Index - 1);

    3820. 

  3820.             }

    3821. 

  3821.         }

    3822. 

  3822. 

    3823. 

  3823.         /// <summary>

    3824. 

  3824.         /// Insert the given collection of objects before the given position

    3825. 

  3825.         /// </summary>

    3826. 

  3826.         /// <param name="index">Where to insert the objects</param>

    3827. 

  3827.         /// <param name="modelObjects">The objects to be inserted</param>

    3828. 

  3828.         /// <remarks>

    3829. 

  3829.         /// <para>

    3830. 

  3830.         /// This operation only makes sense of non-sorted, non-grouped

    3831. 

  3831.         /// lists, since any subsequent sort/group operation will rearrange

    3832. 

  3832.         /// the list.

    3833. 

  3833.         /// </para>

    3834. 

  3834.         /// <para>This method only works on ObjectListViews and FastObjectListViews.</para>

    3835. 

  3835.         ///</remarks>

    3836. 

  3836.         public virtual void InsertObjects(int index, ICollection modelObjects) {

    3837. 

  3837.             if (this.InvokeRequired) {

    3838. 

  3838.                 this.Invoke((MethodInvoker)delegate() {

    3839. 

  3839.                     this.InsertObjects(index, modelObjects);

    3840. 

  3840.                 });

    3841. 

  3841.                 return;

    3842. 

  3842.             }

    3843. 

  3843.             if (modelObjects == null)

    3844. 

  3844.                 return;

    3845. 

  3845. 

    3846. 

  3846.             this.BeginUpdate();

    3847. 

  3847.             try {

    3848. 

  3848.                 // Give the world a chance to cancel or change the added objects

    3849. 

  3849.                 ItemsAddingEventArgs args = new ItemsAddingEventArgs(modelObjects);

    3850. 

  3850.                 this.OnItemsAdding(args);

    3851. 

  3851.                 if (args.Canceled)

    3852. 

  3852.                     return;

    3853. 

  3853.                 modelObjects = args.ObjectsToAdd;

    3854. 

  3854. 

    3855. 

  3855.                 this.TakeOwnershipOfObjects();

    3856. 

  3856.                 ArrayList ourObjects = ObjectListView.EnumerableToArray(this.Objects, false);

    3857. 

  3857. 

    3858. 

  3858.                 // If we are filtering the list, there is no way to efficiently

    3859. 

  3859.                 // insert the objects, so just put them into our collection and rebuild.

    3860. 

  3860.                 if (this.IsFiltering) {

    3861. 

  3861.                     ourObjects.InsertRange(index, modelObjects);

    3862. 

  3862.                     this.BuildList(true);

    3863. 

  3863.                     return;

    3864. 

  3864.                 }

    3865. 

  3865. 

    3866. 

  3866.                 this.ListViewItemSorter = null;

    3867. 

  3867.                 index = Math.Max(0, Math.Min(index, this.GetItemCount()));

    3868. 

  3868.                 int i = index;

    3869. 

  3869.                 foreach (object modelObject in modelObjects) {

    3870. 

  3870.                     if (modelObject != null) {

    3871. 

  3871.                         ourObjects.Insert(i, modelObject);

    3872. 

  3872.                         OLVListItem lvi = new OLVListItem(modelObject);

    3873. 

  3873.                         this.FillInValues(lvi, modelObject);

    3874. 

  3874.                         this.Items.Insert(i, lvi);

    3875. 

  3875.                         i++;

    3876. 

  3876.                     }

    3877. 

  3877.                 }

    3878. 

  3878. 

    3879. 

  3879.                 for (i = index; i < this.GetItemCount(); i++) {

    3880. 

  3880.                     OLVListItem lvi = this.GetItem(i);

    3881. 

  3881.                     this.SetSubItemImages(lvi.Index, lvi);

    3882. 

  3882.                 }

    3883. 

  3883. 

    3884. 

  3884.                 // Tell the world that the list has changed

    3885. 

  3885.                 this.OnItemsChanged(new ItemsChangedEventArgs());

    3886. 

  3886.             } finally {

    3887. 

  3887.                 this.EndUpdate();

    3888. 

  3888.             }

    3889. 

  3889.         }

    3890. 

  3890. 

    3891. 

  3891.         /// <summary>

    3892. 

  3892.         /// Return true if the row representing the given model is selected

    3893. 

  3893.         /// </summary>

    3894. 

  3894.         /// <param name="model">The model object to look for</param>

    3895. 

  3895.         /// <returns>Is the row selected</returns>

    3896. 

  3896.         public bool IsSelected(object model) {

    3897. 

  3897.             OLVListItem item = this.ModelToItem(model);

    3898. 

  3898.             if (item == null)

    3899. 

  3899.                 return false;

    3900. 

  3900.             else

    3901. 

  3901.                 return item.Selected;

    3902. 

  3902.         }

    3903. 

  3903. 

    3904. 

  3904.         /// <summary>

    3905. 

  3905.         /// Has the given URL been visited?

    3906. 

  3906.         /// </summary>

    3907. 

  3907.         /// <param name="url">The string to be consider</param>

    3908. 

  3908.         /// <returns>Has it been visited</returns>

    3909. 

  3909.         public virtual bool IsUrlVisited(string url) {

    3910. 

  3910.             return this.visitedUrlMap.ContainsKey(url);

    3911. 

  3911.         }

    3912. 

  3912. 

    3913. 

  3913.         /// <summary>

    3914. 

  3914.         /// Scroll the ListView by the given deltas.

    3915. 

  3915.         /// </summary>

    3916. 

  3916.         /// <param name="dx">Horizontal delta</param>

    3917. 

  3917.         /// <param name="dy">Vertical delta</param>

    3918. 

  3918.         internal void LowLevelScroll(int dx, int dy) {

    3919. 

  3919.             NativeMethods.Scroll(this, dx, dy);

    3920. 

  3920.         }

    3921. 

  3921. 

    3922. 

  3922.         internal Point LowLevelScrollPosition {

    3923. 

  3923.             get {

    3924. 

  3924.                 return new Point(NativeMethods.GetScrollPosition(this, true), NativeMethods.GetScrollPosition(this, false));

    3925. 

  3925.             }

    3926. 

  3926.         }

    3927. 

  3927. 

    3928. 

  3928.         /// <summary>

    3929. 

  3929.         /// Remember that the given URL has been visited

    3930. 

  3930.         /// </summary>

    3931. 

  3931.         /// <param name="url">The url to be remembered</param>

    3932. 

  3932.         /// <remarks>This does not cause the control be redrawn</remarks>

    3933. 

  3933.         public virtual void MarkUrlVisited(string url) {

    3934. 

  3934.             this.visitedUrlMap[url] = true;

    3935. 

  3935.         }

    3936. 

  3936. 

    3937. 

  3937.         /// <summary>

    3938. 

  3938.         /// Move the given collection of objects to the given index.

    3939. 

  3939.         /// </summary>

    3940. 

  3940.         /// <remarks>This operation only makes sense on non-grouped ObjectListViews.</remarks>

    3941. 

  3941.         /// <param name="index"></param>

    3942. 

  3942.         /// <param name="modelObjects"></param>

    3943. 

  3943.         public virtual void MoveObjects(int index, ICollection modelObjects) {

    3944. 

  3944. 

    3945. 

  3945.             // We are going to remove all the given objects from our list

    3946. 

  3946.             // and then insert them at the given location

    3947. 

  3947.             this.TakeOwnershipOfObjects();

    3948. 

  3948.             ArrayList ourObjects = ObjectListView.EnumerableToArray(this.Objects, false);

    3949. 

  3949. 

    3950. 

  3950.             List<int> indicesToRemove = new List<int>();

    3951. 

  3951.             foreach (object modelObject in modelObjects) {

    3952. 

  3952.                 if (modelObject != null) {

    3953. 

  3953.                     int i = this.IndexOf(modelObject);

    3954. 

  3954.                     if (i >= 0) {

    3955. 

  3955.                         indicesToRemove.Add(i);

    3956. 

  3956.                         ourObjects.Remove(modelObject);

    3957. 

  3957.                         if (i <= index)

    3958. 

  3958.                             index--;

    3959. 

  3959.                     }

    3960. 

  3960.                 }

    3961. 

  3961.             }

    3962. 

  3962. 

    3963. 

  3963.             // Remove the objects in reverse order so earlier

    3964. 

  3964.             // deletes don't change the index of later ones

    3965. 

  3965.             indicesToRemove.Sort();

    3966. 

  3966.             indicesToRemove.Reverse();

    3967. 

  3967.             try {

    3968. 

  3968.                 this.BeginUpdate();

    3969. 

  3969.                 foreach (int i in indicesToRemove) {

    3970. 

  3970.                     this.Items.RemoveAt(i);

    3971. 

  3971.                 }

    3972. 

  3972.                 this.InsertObjects(index, modelObjects);

    3973. 

  3973.             } finally {

    3974. 

  3974.                 this.EndUpdate();

    3975. 

  3975.             }

    3976. 

  3976.         }

    3977. 

  3977. 

    3978. 

  3978.         /// <summary>

    3979. 

  3979.         /// Calculate what item is under the given point?

    3980. 

  3980.         /// </summary>

    3981. 

  3981.         /// <param name="x"></param>

    3982. 

  3982.         /// <param name="y"></param>

    3983. 

  3983.         /// <returns></returns>

    3984. 

  3984.         new public ListViewHitTestInfo HitTest(int x, int y) {

    3985. 

  3985.             // Everything costs something. Playing with the layout of the header can cause problems

    3986. 

  3986.             // with the hit testing. If the header shrinks

    3987. 

  3987.             try {

    3988. 

  3988.                 return base.HitTest(x, y);

    3989. 

  3989.             } catch (ArgumentOutOfRangeException) {

    3990. 

  3990.                 return new ListViewHitTestInfo(null, null, ListViewHitTestLocations.None);

    3991. 

  3991.             }

    3992. 

  3992.         }

    3993. 

  3993. 

    3994. 

  3994.         /// <summary>

    3995. 

  3995.         /// What is under the given point? This takes the various parts of a cell into accout, including

    3996. 

  3996.         /// any custom parts that a custom renderer might use

    3997. 

  3997.         /// </summary>

    3998. 

  3998.         /// <param name="x"></param>

    3999. 

  3999.         /// <param name="y"></param>

    4000. 

  4000.         /// <returns>An information block about what is under the point</returns>

    4001. 

  4001.         public virtual OlvListViewHitTestInfo OlvHitTest(int x, int y) {

    4002. 

  4002.             ListViewHitTestInfo hitTestInfo = this.HitTest(x, y);

    4003. 

  4003.             OlvListViewHitTestInfo hti = new OlvListViewHitTestInfo(hitTestInfo);

    4004. 

  4004. 

    4005. 

  4005.             // There is a bug/"feature" of the ListView concerning hit testing.

    4006. 

  4006.             // If FullRowSelect is false and the point is over cell 0 but not on

    4007. 

  4007.             // the text or icon, HitTest will not register a hit. We could turn

    4008. 

  4008.             // FullRowSelect on, do the HitTest, and then turn it off again, but

    4009. 

  4009.             // toggling FullRowSelect in that way messes up the tooltip in the

    4010. 

  4010.             // underlying control. So we have to find another way.

    4011. 

  4011.             //

    4012. 

  4012.             // It's too hard to try to write the hit test from scratch. Grouping (for

    4013. 

  4013.             // example) makes it just too complicated. So, we have to use HitTest

    4014. 

  4014.             // but try to get around its limits.

    4015. 

  4015.             //

    4016. 

  4016.             // First step is to determine if the point was within column 0.

    4017. 

  4017.             // If it was, then we only have to determine if there is an actual row

    4018. 

  4018.             // under the point. If there is, then we know that the point is over cell 0.

    4019. 

  4019.             // So we try a Battleship-style approach: is there a subcell to the right

    4020. 

  4020.             // of cell 0? This will return a false negative if column 0 is the rightmost column,

    4021. 

  4021.             // so we also check for a subcell to the left. But if only column 0 is visible,

    4022. 

  4022.             // then that will fail too, so we check for something at the very left of the

    4023. 

  4023.             // control.

    4024. 

  4024.             //

    4025. 

  4025.             // This will still fail under pathological conditions. If column 0 fills

    4026. 

  4026.             // the whole listview and no part of the text column 0 is visible

    4027. 

  4027.             // (because it is horizontally scrolled offscreen), then the hit test will fail.

    4028. 

  4028. 

    4029. 

  4029.             // Are we in the buggy context? Details view, not full row select, and

    4030. 

  4030.             // failing to find anything

    4031. 

  4031.             if (hitTestInfo.Item == null && !this.FullRowSelect && this.View == View.Details) {

    4032. 

  4032.                 // Is the point within the column 0? If it is, maybe it should have been a hit.

    4033. 

  4033.                 // Let's test slightly to the right and then to left of column 0. Hopefully one

    4034. 

  4034.                 // of those will hit a subitem

    4035. 

  4035.                 Point sides = NativeMethods.GetScrolledColumnSides(this, 0);

    4036. 

  4036.                 if (x >= sides.X && x <= sides.Y) {

    4037. 

  4037.                     // We look for:

    4038. 

  4038.                     // - any subitem to the right of cell 0?

    4039. 

  4039.                     // - any subitem to the left of cell 0?

    4040. 

  4040.                     // - cell 0 at the left edge of the screen

    4041. 

  4041.                     hitTestInfo = this.HitTest(sides.Y + 4, y);

    4042. 

  4042.                     if (hitTestInfo.Item == null)

    4043. 

  4043.                         hitTestInfo = this.HitTest(sides.X - 4, y);

    4044. 

  4044.                     if (hitTestInfo.Item == null)

    4045. 

  4045.                         hitTestInfo = this.HitTest(4, y);

    4046. 

  4046. 

    4047. 

  4047.                     if (hitTestInfo.Item != null) {

    4048. 

  4048.                         // We hit something! So, the original point must have been in cell 0

    4049. 

  4049.                         hti.Item = (OLVListItem)hitTestInfo.Item;

    4050. 

  4050.                         hti.SubItem = hti.Item.GetSubItem(0);

    4051. 

  4051.                         hti.Location = ListViewHitTestLocations.None;

    4052. 

  4052.                         hti.HitTestLocation = HitTestLocation.InCell;

    4053. 

  4053.                     }

    4054. 

  4054.                 }

    4055. 

  4055.             }

    4056. 

  4056. 

    4057. 

  4057.             if (this.OwnerDraw)

    4058. 

  4058.                 this.CalculateOwnerDrawnHitTest(hti, x, y);

    4059. 

  4059.             else

    4060. 

  4060.                 this.CalculateStandardHitTest(hti, x, y);

    4061. 

  4061. 

    4062. 

  4062.             return hti;

    4063. 

  4063.         }

    4064. 

  4064. 

    4065. 

  4065.         /// <summary>

    4066. 

  4066.         /// Perform a hit test when the control is not owner drawn

    4067. 

  4067.         /// </summary>

    4068. 

  4068.         /// <param name="hti"></param>

    4069. 

  4069.         /// <param name="x"></param>

    4070. 

  4070.         /// <param name="y"></param>

    4071. 

  4071.         protected virtual void CalculateStandardHitTest(OlvListViewHitTestInfo hti, int x, int y) {

    4072. 

  4072. 

    4073. 

  4073.             // Standard hit test works fine for the primary column

    4074. 

  4074.             if (this.View != View.Details || hti.ColumnIndex == 0 ||

    4075. 

  4075.                 hti.SubItem == null || hti.Column == null)

    4076. 

  4076.                 return;

    4077. 

  4077. 

    4078. 

  4078.             Rectangle cellBounds = hti.SubItem.Bounds;

    4079. 

  4079.             bool hasImage = (this.GetActualImageIndex(hti.SubItem.ImageSelector) != -1);

    4080. 

  4080. 

    4081. 

  4081.             // Unless we say otherwise, it was an general incell hit

    4082. 

  4082.             hti.HitTestLocation = HitTestLocation.InCell;

    4083. 

  4083. 

    4084. 

  4084.             // Check if the point is over where an image should be.

    4085. 

  4085.             // If there is a checkbox or image there, tag it and exit.

    4086. 

  4086.             Rectangle r = cellBounds;

    4087. 

  4087.             r.Width = this.SmallImageSize.Width;

    4088. 

  4088.             if (r.Contains(x, y)) {

    4089. 

  4089.                 if (hti.Column.CheckBoxes) {

    4090. 

  4090.                     hti.HitTestLocation = HitTestLocation.CheckBox;

    4091. 

  4091.                     return;

    4092. 

  4092.                 }

    4093. 

  4093.                 if (hasImage) {

    4094. 

  4094.                     hti.HitTestLocation = HitTestLocation.Image;

    4095. 

  4095.                     return;

    4096. 

  4096.                 }

    4097. 

  4097.             }

    4098. 

  4098. 

    4099. 

  4099.             // Figure out where the text actually is and if the point is in it

    4100. 

  4100.             // The standard HitTest assumes that any point inside a subitem is

    4101. 

  4101.             // a hit on Text -- which is clearly not true.

    4102. 

  4102.             Rectangle textBounds = cellBounds;

    4103. 

  4103.             textBounds.X += 4;

    4104. 

  4104.             if (hasImage)

    4105. 

  4105.                 textBounds.X += this.SmallImageSize.Width;

    4106. 

  4106. 

    4107. 

  4107.             Size proposedSize = new Size(textBounds.Width, textBounds.Height);

    4108. 

  4108.             Size textSize = TextRenderer.MeasureText(hti.SubItem.Text, this.Font, proposedSize, TextFormatFlags.EndEllipsis | TextFormatFlags.SingleLine | TextFormatFlags.NoPrefix);

    4109. 

  4109.             textBounds.Width = textSize.Width;

    4110. 

  4110. 

    4111. 

  4111.             switch (hti.Column.TextAlign) {

    4112. 

  4112.                 case HorizontalAlignment.Center:

    4113. 

  4113.                     textBounds.X += (cellBounds.Right - cellBounds.Left - textSize.Width) / 2;

    4114. 

  4114.                     break;

    4115. 

  4115.                 case HorizontalAlignment.Right:

    4116. 

  4116.                     textBounds.X = cellBounds.Right - textSize.Width;

    4117. 

  4117.                     break;

    4118. 

  4118.             }

    4119. 

  4119.             if (textBounds.Contains(x, y)) {

    4120. 

  4120.                 hti.HitTestLocation = HitTestLocation.Text;

    4121. 

  4121.             }

    4122. 

  4122.         }

    4123. 

  4123. 

    4124. 

  4124.         /// <summary>

    4125. 

  4125.         /// Perform a hit test when the control is owner drawn. This hands off responsibility

    4126. 

  4126.         /// to the renderer.

    4127. 

  4127.         /// </summary>

    4128. 

  4128.         /// <param name="hti"></param>

    4129. 

  4129.         /// <param name="x"></param>

    4130. 

  4130.         /// <param name="y"></param>

    4131. 

  4131.         protected virtual void CalculateOwnerDrawnHitTest(OlvListViewHitTestInfo hti, int x, int y) {

    4132. 

  4132.             // If the click wasn't on an item, give up

    4133. 

  4133.             if (hti.Item == null)

    4134. 

  4134.                 return;

    4135. 

  4135. 

    4136. 

  4136.             // If the list is showing column, but they clicked outside the columns, also give up

    4137. 

  4137.             if (this.View == View.Details && hti.Column == null)

    4138. 

  4138.                 return;

    4139. 

  4139. 

    4140. 

  4140.             // Which renderer was responsible for drawing that point

    4141. 

  4141.             IRenderer renderer = null;

    4142. 

  4142.             if (this.View == View.Details) {

    4143. 

  4143.                 renderer = hti.Column.Renderer ?? this.DefaultRenderer;

    4144. 

  4144.             } else {

    4145. 

  4145.                 renderer = this.ItemRenderer;

    4146. 

  4146.             }

    4147. 

  4147. 

    4148. 

  4148.             // We can't decide who was responsible. Give up

    4149. 

  4149.             if (renderer == null)

    4150. 

  4150.                 return;

    4151. 

  4151. 

    4152. 

  4152.             // Ask the responsible renderer what is at that point

    4153. 

  4153.             renderer.HitTest(hti, x, y);

    4154. 

  4154.         }

    4155. 

  4155. 

    4156. 

  4156.         /// <summary>

    4157. 

  4157.         /// Pause (or unpause) all animations in the list

    4158. 

  4158.         /// </summary>

    4159. 

  4159.         /// <param name="isPause">true to pause, false to unpause</param>

    4160. 

  4160.         public virtual void PauseAnimations(bool isPause) {

    4161. 

  4161.             for (int i = 0; i < this.Columns.Count; i++) {

    4162. 

  4162.                 OLVColumn col = this.GetColumn(i);

    4163. 

  4163.                 if (col.Renderer is ImageRenderer)

    4164. 

  4164.                     ((ImageRenderer)col.Renderer).Paused = isPause;

    4165. 

  4165.             }

    4166. 

  4166.         }

    4167. 

  4167. 

    4168. 

  4168.         /// <summary>

    4169. 

  4169.         /// Rebuild the columns based upon its current view and column visibility settings

    4170. 

  4170.         /// </summary>

    4171. 

  4171.         public virtual void RebuildColumns() {

    4172. 

  4172.             this.ChangeToFilteredColumns(this.View);

    4173. 

  4173.         }

    4174. 

  4174. 

    4175. 

  4175.         /// <summary>

    4176. 

  4176.         /// Remove the given model object from the ListView

    4177. 

  4177.         /// </summary>

    4178. 

  4178.         /// <param name="modelObject">The model to be removed</param>

    4179. 

  4179.         /// <remarks>See RemoveObjects() for more details

    4180. 

  4180.         /// <para>This method is thread-safe.</para>

    4181. 

  4181.         /// </remarks>

    4182. 

  4182.         public virtual void RemoveObject(object modelObject) {

    4183. 

  4183.             if (this.InvokeRequired)

    4184. 

  4184.                 this.Invoke((MethodInvoker)delegate() { this.RemoveObject(modelObject); });

    4185. 

  4185.             else

    4186. 

  4186.                 this.RemoveObjects(new object[] { modelObject });

    4187. 

  4187.         }

    4188. 

  4188. 

    4189. 

  4189.         /// <summary>

    4190. 

  4190.         /// Remove all of the given objects from the control.

    4191. 

  4191.         /// </summary>

    4192. 

  4192.         /// <param name="modelObjects">Collection of objects to be removed</param>

    4193. 

  4193.         /// <remarks>

    4194. 

  4194.         /// <para>Nulls and model objects that are not in the ListView are silently ignored.</para>

    4195. 

  4195.         /// <para>This method is thread-safe.</para>

    4196. 

  4196.         /// </remarks>

    4197. 

  4197.         public virtual void RemoveObjects(ICollection modelObjects) {

    4198. 

  4198.             if (this.InvokeRequired) {

    4199. 

  4199.                 this.Invoke((MethodInvoker)delegate() { this.RemoveObjects(modelObjects); });

    4200. 

  4200.                 return;

    4201. 

  4201.             }

    4202. 

  4202.             if (modelObjects == null)

    4203. 

  4203.                 return;

    4204. 

  4204. 

    4205. 

  4205.             this.BeginUpdate();

    4206. 

  4206.             try {

    4207. 

  4207.                 // Give the world a chance to cancel or change the added objects

    4208. 

  4208.                 ItemsRemovingEventArgs args = new ItemsRemovingEventArgs(modelObjects);

    4209. 

  4209.                 this.OnItemsRemoving(args);

    4210. 

  4210.                 if (args.Canceled)

    4211. 

  4211.                     return;

    4212. 

  4212.                 modelObjects = args.ObjectsToRemove;

    4213. 

  4213. 

    4214. 

  4214.                 this.TakeOwnershipOfObjects();

    4215. 

  4215.                 ArrayList ourObjects = (ArrayList)this.Objects;

    4216. 

  4216.                 foreach (object modelObject in modelObjects) {

    4217. 

  4217.                     if (modelObject != null) {

    4218. 

  4218.                         ourObjects.Remove(modelObject);

    4219. 

  4219.                         int i = this.IndexOf(modelObject);

    4220. 

  4220.                         if (i >= 0)

    4221. 

  4221.                             this.Items.RemoveAt(i);

    4222. 

  4222.                     }

    4223. 

  4223.                 }

    4224. 

  4224.                 this.PostProcessRows();

    4225. 

  4225. 

    4226. 

  4226.                 // Tell the world that the list has changed

    4227. 

  4227.                 this.OnItemsChanged(new ItemsChangedEventArgs());

    4228. 

  4228.             } finally {

    4229. 

  4229.                 this.EndUpdate();

    4230. 

  4230.             }

    4231. 

  4231.         }

    4232. 

  4232. 

    4233. 

  4233.         /// <summary>

    4234. 

  4234.         /// Select all rows in the listview

    4235. 

  4235.         /// </summary>

    4236. 

  4236.         public virtual void SelectAll() {

    4237. 

  4237.             NativeMethods.SelectAllItems(this);

    4238. 

  4238.         }

    4239. 

  4239. 

    4240. 

  4240.         /// <summary>

    4241. 

  4241.         /// Set the given image to be fixed in the bottom right of the list view.

    4242. 

  4242.         /// This image will not scroll when the list view scrolls.

    4243. 

  4243.         /// </summary>

    4244. 

  4244.         /// <remarks>

    4245. 

  4245.         /// <para>

    4246. 

  4246.         /// This method uses ListView's native ability to display a background image.

    4247. 

  4247.         /// It has a few limitations: 

    4248. 

  4248.         /// </para>

    4249. 

  4249.         /// <list type="bullet">

    4250. 

  4250.         /// <item><description>It doesn't work well with owner drawn mode. In owner drawn mode, each cell draws itself,

    4251. 

  4251.         /// including its background, which covers the background image.</description></item>

    4252. 

  4252.         /// <item><description>It doesn't look very good when grid lines are enabled, since the grid lines are drawn over the image.</description></item>

    4253. 

  4253.         /// <item><description>It does not work at all on XP.</description></item>

    4254. 

  4254.         /// <item><description>Obviously, it doesn't look good when alternate row background colors are enabled.</description></item>

    4255. 

  4255.         /// </list>

    4256. 

  4256.         /// <para>

    4257. 

  4257.         /// If you can live with these limitations, native watermarks are quite neat. They are true backgrounds, not

    4258. 

  4258.         /// translucent overlays like the OverlayImage uses. They also have the decided advantage over overlays in that

    4259. 

  4259.         /// they work correctly even in MDI applications.

    4260. 

  4260.         /// </para>

    4261. 

  4261.         /// <para>Setting this clears any background image.</para>

    4262. 

  4262.         /// </remarks>

    4263. 

  4263.         /// <param name="image">The image to be drawn. If null, any existing image will be removed.</param>

    4264. 

  4264.         public void SetNativeBackgroundWatermark(Image image) {

    4265. 

  4265.             NativeMethods.SetBackgroundImage(this, image, true, false, 0, 0);

    4266. 

  4266.         }

    4267. 

  4267. 

    4268. 

  4268.         /// <summary>

    4269. 

  4269.         /// Set the given image to be background of the ListView so that it appears at the given

    4270. 

  4270.         /// percentage offsets within the list.

    4271. 

  4271.         /// </summary>

    4272. 

  4272.         /// <remarks>

    4273. 

  4273.         /// <para>This has the same limitations as described in <see cref="SetNativeBackgroundWatermark"/>. Make sure those limitations

    4274. 

  4274.         /// are understood before using the method.</para>

    4275. 

  4275.         /// <para>This is very similar to setting the <see cref="System.Windows.Forms.Control.BackgroundImage"/> property of the standard .NET ListView, except that the standard

    4276. 

  4276.         /// BackgroundImage does not handle images with transparent areas properly -- it renders transparent areas as black. This 

    4277. 

  4277.         /// method does not have that problem.</para>

    4278. 

  4278.         /// <para>Setting this clears any background watermark.</para>

    4279. 

  4279.         /// </remarks>

    4280. 

  4280.         /// <param name="image">The image to be drawn. If null, any existing image will be removed.</param>

    4281. 

  4281.         /// <param name="xOffset">The horizontal percentage where the image will be placed. 0 is absolute left, 100 is absolute right.</param>

    4282. 

  4282.         /// <param name="yOffset">The vertical percentage where the image will be placed.</param>

    4283. 

  4283.         public void SetNativeBackgroundImage(Image image, int xOffset, int yOffset) {

    4284. 

  4284.             NativeMethods.SetBackgroundImage(this, image, false, false, xOffset, yOffset);

    4285. 

  4285.         }

    4286. 

  4286. 

    4287. 

  4287.         /// <summary>

    4288. 

  4288.         /// Set the given image to be the tiled background of the ListView.

    4289. 

  4289.         /// </summary>

    4290. 

  4290.         /// <remarks>

    4291. 

  4291.         /// <para>This has the same limitations as described in <see cref="SetNativeBackgroundWatermark"/> and <see cref="SetNativeBackgroundImage"/>.

    4292. 

  4292.         /// Make sure those limitations

    4293. 

  4293.         /// are understood before using the method.</para>

    4294. 

  4294.         /// </remarks>

    4295. 

  4295.         /// <param name="image">The image to be drawn. If null, any existing image will be removed.</param>

    4296. 

  4296.         public void SetNativeBackgroundTiledImage(Image image) {

    4297. 

  4297.             NativeMethods.SetBackgroundImage(this, image, false, true, 0, 0);

    4298. 

  4298.         }

    4299. 

  4299. 

    4300. 

  4300.         /// <summary>

    4301. 

  4301.         /// Set the collection of objects that will be shown in this list view.

    4302. 

  4302.         /// </summary>

    4303. 

  4303.         /// <remark>This method can safely be called from background threads.</remark>

    4304. 

  4304.         /// <remarks>The list is updated immediately</remarks>

    4305. 

  4305.         /// <param name="collection">The objects to be displayed</param>

    4306. 

  4306.         public virtual void SetObjects(IEnumerable collection) {

    4307. 

  4307.             this.SetObjects(collection, false);

    4308. 

  4308.         }

    4309. 

  4309. 

    4310. 

  4310.         /// <summary>

    4311. 

  4311.         /// Set the collection of objects that will be shown in this list view.

    4312. 

  4312.         /// </summary>

    4313. 

  4313.         /// <remark>This method can safely be called from background threads.</remark>

    4314. 

  4314.         /// <remarks>The list is updated immediately</remarks>

    4315. 

  4315.         /// <param name="collection">The objects to be displayed</param>

    4316. 

  4316.         /// <param name="preserveState">Should the state of the list be preserved as far as is possible.</param>

    4317. 

  4317.         public virtual void SetObjects(IEnumerable collection, bool preserveState) {

    4318. 

  4318.             if (this.InvokeRequired) {

    4319. 

  4319.                 this.Invoke((MethodInvoker)delegate { this.SetObjects(collection, preserveState); });

    4320. 

  4320.                 return;

    4321. 

  4321.             }

    4322. 

  4322. 

    4323. 

  4323.             // Give the world a chance to cancel or change the assigned collection

    4324. 

  4324.             ItemsChangingEventArgs args = new ItemsChangingEventArgs(this.objects, collection);

    4325. 

  4325.             this.OnItemsChanging(args);

    4326. 

  4326.             if (args.Canceled)

    4327. 

  4327.                 return;

    4328. 

  4328.             collection = args.NewObjects;

    4329. 

  4329. 

    4330. 

  4330.             // If we own the current list and they change to another list, we don't own it anymore

    4331. 

  4331.             if (this.isOwnerOfObjects && this.objects != collection)

    4332. 

  4332.                 this.isOwnerOfObjects = false;

    4333. 

  4333.             this.objects = collection;

    4334. 

  4334.             this.BuildList(preserveState);

    4335. 

  4335. 

    4336. 

  4336.             // Tell the world that the list has changed

    4337. 

  4337.             this.OnItemsChanged(new ItemsChangedEventArgs());

    4338. 

  4338.         }

    4339. 

  4339. 

    4340. 

  4340.         #endregion

    4341. 

  4341. 

    4342. 

  4342.         #region Save/Restore State

    4343. 

  4343. 

    4344. 

  4344.         /// <summary>

    4345. 

  4345.         /// Return a byte array that represents the current state of the ObjectListView, such

    4346. 

  4346.         /// that the state can be restored by RestoreState()

    4347. 

  4347.         /// </summary>

    4348. 

  4348.         /// <remarks>

    4349. 

  4349.         /// <para>The state of an ObjectListView includes the attributes that the user can modify:

    4350. 

  4350.         /// <list type="bullet">

    4351. 

  4351.         /// <item><description>current view (i.e. Details, Tile, Large Icon...)</description></item>

    4352. 

  4352.         /// <item><description>sort column and direction</description></item>

    4353. 

  4353.         /// <item><description>column order</description></item>

    4354. 

  4354.         /// <item><description>column widths</description></item>

    4355. 

  4355.         /// <item><description>column visibility</description></item>

    4356. 

  4356.         /// </list>

    4357. 

  4357.         /// </para>

    4358. 

  4358.         /// <para>

    4359. 

  4359.         /// It does not include selection or the scroll position.

    4360. 

  4360.         /// </para>

    4361. 

  4361.         /// </remarks>

    4362. 

  4362.         /// <returns>A byte array representing the state of the ObjectListView</returns>

    4363. 

  4363.         public virtual byte[] SaveState() {

    4364. 

  4364.             ObjectListViewState olvState = new ObjectListViewState();

    4365. 

  4365.             olvState.VersionNumber = 1;

    4366. 

  4366.             olvState.NumberOfColumns = this.AllColumns.Count;

    4367. 

  4367.             olvState.CurrentView = this.View;

    4368. 

  4368. 

    4369. 

  4369.             // If we have a sort column, it is possible that it is not currently being shown, in which

    4370. 

  4370.             // case, it's Index will be -1. So we calculate its index directly. Technically, the sort

    4371. 

  4371.             // column does not even have to a member of AllColumns, in which case IndexOf will return -1,

    4372. 

  4372.             // which is works fine since we have no way of restoring such a column anyway.

    4373. 

  4373.             if (this.LastSortColumn != null)

    4374. 

  4374.                 olvState.SortColumn = this.AllColumns.IndexOf(this.LastSortColumn);

    4375. 

  4375.             olvState.LastSortOrder = this.LastSortOrder;

    4376. 

  4376.             olvState.IsShowingGroups = this.ShowGroups;

    4377. 

  4377. 

    4378. 

  4378.             if (this.AllColumns.Count > 0 && this.AllColumns[0].LastDisplayIndex == -1)

    4379. 

  4379.                 this.RememberDisplayIndicies();

    4380. 

  4380. 

    4381. 

  4381.             foreach (OLVColumn column in this.AllColumns) {

    4382. 

  4382.                 olvState.ColumnIsVisible.Add(column.IsVisible);

    4383. 

  4383.                 olvState.ColumnDisplayIndicies.Add(column.LastDisplayIndex);

    4384. 

  4384.                 olvState.ColumnWidths.Add(column.Width);

    4385. 

  4385.             }

    4386. 

  4386. 

    4387. 

  4387.             // Now that we have stored our state, convert it to a byte array

    4388. 

  4388.             using (MemoryStream ms = new MemoryStream()) {

    4389. 

  4389.                 BinaryFormatter serializer = new BinaryFormatter();

    4390. 

  4390.                 serializer.AssemblyFormat = FormatterAssemblyStyle.Simple;

    4391. 

  4391.                 serializer.Serialize(ms, olvState);

    4392. 

  4392.                 return ms.ToArray();

    4393. 

  4393.             }

    4394. 

  4394.         }

    4395. 

  4395. 

    4396. 

  4396.         /// <summary>

    4397. 

  4397.         /// Restore the state of the control from the given string, which must have been

    4398. 

  4398.         /// produced by SaveState()

    4399. 

  4399.         /// </summary>

    4400. 

  4400.         /// <param name="state">A byte array returned from SaveState()</param>

    4401. 

  4401.         /// <returns>Returns true if the state was restored</returns>

    4402. 

  4402.         public virtual bool RestoreState(byte[] state) {

    4403. 

  4403.             using (MemoryStream ms = new MemoryStream(state)) {

    4404. 

  4404.                 BinaryFormatter deserializer = new BinaryFormatter();

    4405. 

  4405.                 ObjectListViewState olvState;

    4406. 

  4406.                 try {

    4407. 

  4407.                     olvState = deserializer.Deserialize(ms) as ObjectListViewState;

    4408. 

  4408.                 } catch (System.Runtime.Serialization.SerializationException) {

    4409. 

  4409.                     return false;

    4410. 

  4410.                 }

    4411. 

  4411.                 // The number of columns has changed. We have no way to match old

    4412. 

  4412.                 // columns to the new ones, so we just give up.

    4413. 

  4413.                 if (olvState.NumberOfColumns != this.AllColumns.Count)

    4414. 

  4414.                     return false;

    4415. 

  4415.                 if (olvState.SortColumn == -1) {

    4416. 

  4416.                     this.LastSortColumn = null;

    4417. 

  4417.                     this.LastSortOrder = SortOrder.None;

    4418. 

  4418.                 } else {

    4419. 

  4419.                     this.LastSortColumn = this.AllColumns[olvState.SortColumn];

    4420. 

  4420.                     this.LastSortOrder = olvState.LastSortOrder;

    4421. 

  4421.                 }

    4422. 

  4422.                 for (int i = 0; i < olvState.NumberOfColumns; i++) {

    4423. 

  4423.                     OLVColumn column = this.AllColumns[i];

    4424. 

  4424.                     column.Width = (int)olvState.ColumnWidths[i];

    4425. 

  4425.                     column.IsVisible = (bool)olvState.ColumnIsVisible[i];

    4426. 

  4426.                     column.LastDisplayIndex = (int)olvState.ColumnDisplayIndicies[i];

    4427. 

  4427.                 }

    4428. 

  4428.                 if (olvState.IsShowingGroups != this.ShowGroups)

    4429. 

  4429.                     this.ShowGroups = olvState.IsShowingGroups;

    4430. 

  4430.                 if (this.View == olvState.CurrentView)

    4431. 

  4431.                     this.RebuildColumns();

    4432. 

  4432.                 else

    4433. 

  4433.                     this.View = olvState.CurrentView;

    4434. 

  4434.             }

    4435. 

  4435. 

    4436. 

  4436.             return true;

    4437. 

  4437.         }

    4438. 

  4438. 

    4439. 

  4439.         /// <summary>

    4440. 

  4440.         /// Instances of this class are used to store the state of an ObjectListView.

    4441. 

  4441.         /// </summary>

    4442. 

  4442.         [Serializable]

    4443. 

  4443.         internal class ObjectListViewState

    4444. 

  4444.         {

    4445. 

  4445.             public int VersionNumber = 1;

    4446. 

  4446.             public int NumberOfColumns = 1;

    4447. 

  4447.             public View CurrentView;

    4448. 

  4448.             public int SortColumn = -1;

    4449. 

  4449.             public bool IsShowingGroups;

    4450. 

  4450.             public SortOrder LastSortOrder = SortOrder.None;

    4451. 

  4451.             public ArrayList ColumnIsVisible = new ArrayList();

    4452. 

  4452.             public ArrayList ColumnDisplayIndicies = new ArrayList();

    4453. 

  4453.             public ArrayList ColumnWidths = new ArrayList();

    4454. 

  4454.         }

    4455. 

  4455. 

    4456. 

  4456.         #endregion

    4457. 

  4457. 

    4458. 

  4458.         #region Event handlers

    4459. 

  4459. 

    4460. 

  4460.         /// <summary>

    4461. 

  4461.         /// The application is idle. Trigger a SelectionChanged event.

    4462. 

  4462.         /// </summary>

    4463. 

  4463.         /// <param name="sender"></param>

    4464. 

  4464.         /// <param name="e"></param>

    4465. 

  4465.         protected virtual void HandleApplicationIdle(object sender, EventArgs e) {

    4466. 

  4466.             // Remove the handler before triggering the event

    4467. 

  4467.             Application.Idle -= new EventHandler(HandleApplicationIdle);

    4468. 

  4468.             this.hasIdleHandler = false;

    4469. 

  4469. 

    4470. 

  4470.             this.OnSelectionChanged(new EventArgs());

    4471. 

  4471.         }

    4472. 

  4472. 

    4473. 

  4473.         /// <summary>

    4474. 

  4474.         /// The application is idle. Trigger a SelectionChanged event.

    4475. 

  4475.         /// </summary>

    4476. 

  4476.         /// <param name="sender"></param>

    4477. 

  4477.         /// <param name="e"></param>

    4478. 

  4478.         protected virtual void HandleApplicationIdle_ResizeColumns(object sender, EventArgs e) {

    4479. 

  4479.             // Remove the handler before triggering the event

    4480. 

  4480.             Application.Idle -= new EventHandler(HandleApplicationIdle_ResizeColumns);

    4481. 

  4481.             this.hasResizeColumnsHandler = false;

    4482. 

  4482. 

    4483. 

  4483.             this.ResizeFreeSpaceFillingColumns();

    4484. 

  4484.         }

    4485. 

  4485. 

    4486. 

  4486.         /// <summary>

    4487. 

  4487.         /// Handle the BeginScroll listview notification

    4488. 

  4488.         /// </summary>

    4489. 

  4489.         /// <param name="m"></param>

    4490. 

  4490.         /// <returns>True if the event was completely handled</returns>

    4491. 

  4491.         protected virtual bool HandleBeginScroll(ref Message m) {

    4492. 

  4492.             //System.Diagnostics.Debug.WriteLine("LVN_BEGINSCROLL");

    4493. 

  4493. 

    4494. 

  4494.             NativeMethods.NMLVSCROLL nmlvscroll = (NativeMethods.NMLVSCROLL)m.GetLParam(typeof(NativeMethods.NMLVSCROLL));

    4495. 

  4495.             if (nmlvscroll.dx != 0) {

    4496. 

  4496.                 int scrollPositionH = NativeMethods.GetScrollPosition(this, true);

    4497. 

  4497.                 ScrollEventArgs args = new ScrollEventArgs(ScrollEventType.EndScroll, scrollPositionH - nmlvscroll.dx, scrollPositionH, ScrollOrientation.HorizontalScroll);

    4498. 

  4498.                 this.OnScroll(args);

    4499. 

  4499. 

    4500. 

  4500.                 // Force any empty list msg to redraw when the list is scrolled horizontally

    4501. 

  4501.                 if (this.GetItemCount() == 0)

    4502. 

  4502.                     this.Invalidate();

    4503. 

  4503.             }

    4504. 

  4504.             if (nmlvscroll.dy != 0) {

    4505. 

  4505.                 int scrollPositionV = NativeMethods.GetScrollPosition(this, false);

    4506. 

  4506.                 ScrollEventArgs args = new ScrollEventArgs(ScrollEventType.EndScroll, scrollPositionV - nmlvscroll.dy, scrollPositionV, ScrollOrientation.VerticalScroll);

    4507. 

  4507.                 this.OnScroll(args);

    4508. 

  4508.             }

    4509. 

  4509. 

    4510. 

  4510.             return false;

    4511. 

  4511.         }

    4512. 

  4512. 

    4513. 

  4513.         /// <summary>

    4514. 

  4514.         /// Handle the EndScroll listview notification

    4515. 

  4515.         /// </summary>

    4516. 

  4516.         /// <param name="m"></param>

    4517. 

  4517.         /// <returns>True if the event was completely handled</returns>

    4518. 

  4518.         protected virtual bool HandleEndScroll(ref Message m) {

    4519. 

  4519.             //System.Diagnostics.Debug.WriteLine("LVN_BEGINSCROLL");

    4520. 

  4520. 

    4521. 

  4521.             // There is a bug in ListView under XP that causes the gridlines to be incorrectly scrolled

    4522. 

  4522.             // when the left button is clicked to scroll. This is supposedly documented at

    4523. 

  4523.             // KB 813791, but I couldn't find it anywhere. You can follow this thread to see the discussion

    4524. 

  4524.             // http://www.ureader.com/msg/1484143.aspx

    4525. 

  4525. 

    4526. 

  4526.             if (!ObjectListView.IsVistaOrLater && Control.MouseButtons == MouseButtons.Left && this.GridLines) {

    4527. 

  4527.                 this.Invalidate();

    4528. 

  4528.                 this.Update();

    4529. 

  4529.             }

    4530. 

  4530. 

    4531. 

  4531.             return false;

    4532. 

  4532.         }

    4533. 

  4533. 

    4534. 

  4534.         /// <summary>

    4535. 

  4535.         /// Handle the LinkClick listview notification

    4536. 

  4536.         /// </summary>

    4537. 

  4537.         /// <param name="m"></param>

    4538. 

  4538.         /// <returns>True if the event was completely handled</returns>

    4539. 

  4539.         protected virtual bool HandleLinkClick(ref Message m) {

    4540. 

  4540.             //System.Diagnostics.Debug.WriteLine("HandleLinkClick");

    4541. 

  4541. 

    4542. 

  4542.             NativeMethods.NMLVLINK nmlvlink = (NativeMethods.NMLVLINK)m.GetLParam(typeof(NativeMethods.NMLVLINK));

    4543. 

  4543. 

    4544. 

  4544.             // Find the group that was clicked and trigger an event

    4545. 

  4545.             foreach (OLVGroup x in this.OLVGroups) {

    4546. 

  4546.                 if (x.GroupId == nmlvlink.iSubItem) {

    4547. 

  4547.                     this.OnGroupTaskClicked(new GroupTaskClickedEventArgs(x));

    4548. 

  4548.                     return true;

    4549. 

  4549.                 }

    4550. 

  4550.             }

    4551. 

  4551. 

    4552. 

  4552.             return false;

    4553. 

  4553.         }

    4554. 

  4554. 

    4555. 

  4555.         /// <summary>

    4556. 

  4556.         /// The cell tooltip control wants information about the tool tip that it should show.

    4557. 

  4557.         /// </summary>

    4558. 

  4558.         /// <param name="sender"></param>

    4559. 

  4559.         /// <param name="e"></param>

    4560. 

  4560.         protected virtual void HandleCellToolTipShowing(object sender, ToolTipShowingEventArgs e) {

    4561. 

  4561.             this.BuildCellEvent(e, this.PointToClient(Cursor.Position));

    4562. 

  4562.             if (e.Item != null) {

    4563. 

  4563.                 e.Text = this.GetCellToolTip(e.ColumnIndex, e.RowIndex);

    4564. 

  4564.                 this.OnCellToolTip(e);

    4565. 

  4565.             }

    4566. 

  4566.         }

    4567. 

  4567. 

    4568. 

  4568.         /// <summary>

    4569. 

  4569.         /// Allow the HeaderControl to call back into HandleHeaderToolTipShowing without making that method public

    4570. 

  4570.         /// </summary>

    4571. 

  4571.         /// <param name="sender"></param>

    4572. 

  4572.         /// <param name="e"></param>

    4573. 

  4573.         internal void headerToolTip_Showing(object sender, ToolTipShowingEventArgs e) {

    4574. 

  4574.             this.HandleHeaderToolTipShowing(sender, e);

    4575. 

  4575.         }

    4576. 

  4576. 

    4577. 

  4577.         /// <summary>

    4578. 

  4578.         /// The header tooltip control wants information about the tool tip that it should show.

    4579. 

  4579.         /// </summary>

    4580. 

  4580.         /// <param name="sender"></param>

    4581. 

  4581.         /// <param name="e"></param>

    4582. 

  4582.         protected virtual void HandleHeaderToolTipShowing(object sender, ToolTipShowingEventArgs e) {

    4583. 

  4583.             e.ColumnIndex = this.HeaderControl.ColumnIndexUnderCursor;

    4584. 

  4584.             if (e.ColumnIndex < 0)

    4585. 

  4585.                 return;

    4586. 

  4586. 

    4587. 

  4587.             e.RowIndex = -1;

    4588. 

  4588.             e.Model = null;

    4589. 

  4589.             e.Column = this.GetColumn(e.ColumnIndex);

    4590. 

  4590.             e.Text = this.GetHeaderToolTip(e.ColumnIndex);

    4591. 

  4591.             e.ListView = this;

    4592. 

  4592.             this.OnHeaderToolTip(e);

    4593. 

  4593.         }

    4594. 

  4594. 

    4595. 

  4595.         /// <summary>

    4596. 

  4596.         /// Event handler for the column click event

    4597. 

  4597.         /// </summary>

    4598. 

  4598.         protected virtual void HandleColumnClick(object sender, ColumnClickEventArgs e) {

    4599. 

  4599.             if (!this.PossibleFinishCellEditing())

    4600. 

  4600.                 return;

    4601. 

  4601. 

    4602. 

  4602.             // Toggle the sorting direction on successive clicks on the same column

    4603. 

  4603.             if (this.LastSortColumn != null && e.Column == this.LastSortColumn.Index)

    4604. 

  4604.                 this.LastSortOrder = (this.LastSortOrder == SortOrder.Descending ? SortOrder.Ascending : SortOrder.Descending);

    4605. 

  4605.             else

    4606. 

  4606.                 this.LastSortOrder = SortOrder.Ascending;

    4607. 

  4607. 

    4608. 

  4608.             this.BeginUpdate();

    4609. 

  4609.             try {

    4610. 

  4610.                 this.Sort(e.Column);

    4611. 

  4611.             } finally {

    4612. 

  4612.                 this.EndUpdate();

    4613. 

  4613.             }

    4614. 

  4614.         }

    4615. 

  4615. 

    4616. 

  4616.         #endregion

    4617. 

  4617. 

    4618. 

  4618.         #region Low level Windows Message handling

    4619. 

  4619. 

    4620. 

  4620.         /// <summary>

    4621. 

  4621.         /// Override the basic message pump for this control

    4622. 

  4622.         /// </summary>

    4623. 

  4623.         /// <param name="m"></param>

    4624. 

  4624.         protected override void WndProc(ref Message m) {

    4625. 

  4625.             //System.Diagnostics.Debug.WriteLine(m.Msg);

    4626. 

  4626.             switch (m.Msg) {

    4627. 

  4627.                 case 2: // WM_DESTROY

    4628. 

  4628.                     if (!this.HandleDestroy(ref m))

    4629. 

  4629.                         base.WndProc(ref m);

    4630. 

  4630.                     break;

    4631. 

  4631.                 //case 0x14: // WM_ERASEBKGND

    4632. 

  4632.                 //    Can't do anything here since, when the control is double buffered, anything

    4633. 

  4633.                 //    done here is immediately over-drawn

    4634. 

  4634.                 //    break;

    4635. 

  4635.                 case 0x0F: // WM_PAINT

    4636. 

  4636.                     if (!this.HandlePaint(ref m))

    4637. 

  4637.                         base.WndProc(ref m);

    4638. 

  4638.                     break;

    4639. 

  4639.                 case 0x46: // WM_WINDOWPOSCHANGING

    4640. 

  4640.                     if (!this.HandleWindowPosChanging(ref m))

    4641. 

  4641.                         base.WndProc(ref m);

    4642. 

  4642.                     break;

    4643. 

  4643.                 case 0x4E: // WM_NOTIFY

    4644. 

  4644.                     if (!this.HandleNotify(ref m))

    4645. 

  4645.                         base.WndProc(ref m);

    4646. 

  4646.                     break;

    4647. 

  4647.                 case 0x0100: // WM_KEY_DOWN

    4648. 

  4648.                     if (!this.HandleKeyDown(ref m))

    4649. 

  4649.                         base.WndProc(ref m);

    4650. 

  4650.                     break;

    4651. 

  4651.                 case 0x0102: // WM_CHAR

    4652. 

  4652.                     if (!this.HandleChar(ref m))

    4653. 

  4653.                         base.WndProc(ref m);

    4654. 

  4654.                     break;

    4655. 

  4655.                 case 0x0201: // WM_LBUTTONDOWN

    4656. 

  4656.                     if (this.PossibleFinishCellEditing() && !this.HandleLButtonDown(ref m))

    4657. 

  4657.                         base.WndProc(ref m);

    4658. 

  4658.                     break;

    4659. 

  4659.                 case 0x202:  // WM_LBUTTONUP

    4660. 

  4660.                     if (ObjectListView.IsVistaOrLater && this.HasCollapsibleGroups)

    4661. 

  4661.                         base.DefWndProc(ref m);

    4662. 

  4662.                     base.WndProc(ref m);

    4663. 

  4663.                     break;

    4664. 

  4664.                 case 0x0203: // WM_LBUTTONDBLCLK

    4665. 

  4665.                     if (this.PossibleFinishCellEditing() && !this.HandleLButtonDoubleClick(ref m))

    4666. 

  4666.                         base.WndProc(ref m);

    4667. 

  4667.                     break;

    4668. 

  4668.                 case 0x0204: // WM_RBUTTONDOWN

    4669. 

  4669.                     if (this.PossibleFinishCellEditing() && !this.HandleRButtonDown(ref m))

    4670. 

  4670.                         base.WndProc(ref m);

    4671. 

  4671.                     break;

    4672. 

  4672.                 case 0x0206: // WM_RBUTTONDBLCLK

    4673. 

  4673.                     if (this.PossibleFinishCellEditing() && !this.HandleRButtonDoubleClick(ref m))

    4674. 

  4674.                         base.WndProc(ref m);

    4675. 

  4675.                     break;

    4676. 

  4676.                 case 0x204E: // WM_REFLECT_NOTIFY

    4677. 

  4677.                     if (!this.HandleReflectNotify(ref m))

    4678. 

  4678.                         base.WndProc(ref m);

    4679. 

  4679.                     break;

    4680. 

  4680.                 case 0x114: // WM_HSCROLL:

    4681. 

  4681.                 case 0x115: // WM_VSCROLL:

    4682. 

  4682.                     if (this.PossibleFinishCellEditing())

    4683. 

  4683.                         base.WndProc(ref m);

    4684. 

  4684.                     break;

    4685. 

  4685.                 case 0x20A: // WM_MOUSEWHEEL:

    4686. 

  4686.                 case 0x20E: // WM_MOUSEHWHEEL:

    4687. 

  4687.                     if (this.PossibleFinishCellEditing())

    4688. 

  4688.                         base.WndProc(ref m);

    4689. 

  4689.                     break;

    4690. 

  4690.                 case 0x7B: // WM_CONTEXTMENU

    4691. 

  4691.                     if (!this.HandleContextMenu(ref m))

    4692. 

  4692.                         base.WndProc(ref m);

    4693. 

  4693.                     break;

    4694. 

  4694.                 default:

    4695. 

  4695.                     base.WndProc(ref m);

    4696. 

  4696.                     break;

    4697. 

  4697.             }

    4698. 

  4698.         }

    4699. 

  4699. 

    4700. 

  4700.         /// <summary>

    4701. 

  4701.         /// Handle the search for item m if possible.

    4702. 

  4702.         /// </summary>

    4703. 

  4703.         /// <param name="m">The m to be processed</param>

    4704. 

  4704.         /// <returns>bool to indicate if the m has been handled</returns>

    4705. 

  4705.         protected virtual bool HandleChar(ref Message m) {

    4706. 

  4706. 

    4707. 

  4707.             // Trigger a normal KeyPress event, which listeners can handle if they want.

    4708. 

  4708.             // Handling the event stops ObjectListView's fancy search-by-typing.

    4709. 

  4709.             if (this.ProcessKeyEventArgs(ref m))

    4710. 

  4710.                 return true;

    4711. 

  4711. 

    4712. 

  4712.             const int MILLISECONDS_BETWEEN_KEYPRESSES = 1000;

    4713. 

  4713. 

    4714. 

  4714.             // What character did the user type and was it part of a longer string?

    4715. 

  4715.             char character = (char)m.WParam.ToInt32(); //TODO: Will this work on 64 bit or MBCS?

    4716. 

  4716.             if (character == (char)Keys.Back) {

    4717. 

  4717.                 // Backspace forces the next key to be considered the start of a new search

    4718. 

  4718.                 this.timeLastCharEvent = 0;

    4719. 

  4719.                 return true;

    4720. 

  4720.             }

    4721. 

  4721. 

    4722. 

  4722.             if (System.Environment.TickCount < (this.timeLastCharEvent + MILLISECONDS_BETWEEN_KEYPRESSES))

    4723. 

  4723.                 this.lastSearchString += character;

    4724. 

  4724.             else

    4725. 

  4725.                 this.lastSearchString = character.ToString();

    4726. 

  4726. 

    4727. 

  4727.             // If this control is showing checkboxes, we want to ignore single space presses,

    4728. 

  4728.             // since they are used to toggle the selected checkboxes.

    4729. 

  4729.             if (this.CheckBoxes && this.lastSearchString == " ") {

    4730. 

  4730.                 this.timeLastCharEvent = 0;

    4731. 

  4731.                 return true;

    4732. 

  4732.             }

    4733. 

  4733. 

    4734. 

  4734.             // Where should the search start?

    4735. 

  4735.             int start = 0;

    4736. 

  4736.             ListViewItem focused = this.FocusedItem;

    4737. 

  4737.             if (focused != null) {

    4738. 

  4738.                 start = this.GetItemIndexInDisplayOrder(focused);

    4739. 

  4739. 

    4740. 

  4740.                 // If the user presses a single key, we search from after the focused item,

    4741. 

  4741.                 // being careful not to march past the end of the list

    4742. 

  4742.                 if (this.lastSearchString.Length == 1) {

    4743. 

  4743.                     start += 1;

    4744. 

  4744.                     if (start == this.GetItemCount())

    4745. 

  4745.                         start = 0;

    4746. 

  4746.                 }

    4747. 

  4747.             }

    4748. 

  4748. 

    4749. 

  4749.             // Give the world a chance to fiddle with or completely avoid the searching process

    4750. 

  4750.             BeforeSearchingEventArgs args = new BeforeSearchingEventArgs(this.lastSearchString, start);

    4751. 

  4751.             this.OnBeforeSearching(args);

    4752. 

  4752.             if (args.Canceled)

    4753. 

  4753.                 return true;

    4754. 

  4754. 

    4755. 

  4755.             // The parameters of the search may have been changed

    4756. 

  4756.             string searchString = args.StringToFind;

    4757. 

  4757.             start = args.StartSearchFrom;

    4758. 

  4758. 

    4759. 

  4759.             // Do the actual search

    4760. 

  4760.             int found = this.FindMatchingRow(searchString, start, SearchDirectionHint.Down);

    4761. 

  4761.             if (found >= 0) {

    4762. 

  4762.                 // Select and focus on the found item

    4763. 

  4763.                 this.BeginUpdate();

    4764. 

  4764.                 try {

    4765. 

  4765.                     this.SelectedIndices.Clear();

    4766. 

  4766.                     ListViewItem lvi = this.GetNthItemInDisplayOrder(found);

    4767. 

  4767.                     lvi.Selected = true;

    4768. 

  4768.                     lvi.Focused = true;

    4769. 

  4769.                     this.EnsureVisible(lvi.Index);

    4770. 

  4770.                 } finally {

    4771. 

  4771.                     this.EndUpdate();

    4772. 

  4772.                 }

    4773. 

  4773.             }

    4774. 

  4774. 

    4775. 

  4775.             // Tell the world that a search has occurred

    4776. 

  4776.             AfterSearchingEventArgs args2 = new AfterSearchingEventArgs(searchString, found);

    4777. 

  4777.             this.OnAfterSearching(args2);

    4778. 

  4778.             if (!args2.Handled) {

    4779. 

  4779.                 if (found < 0)

    4780. 

  4780.                     System.Media.SystemSounds.Beep.Play();

    4781. 

  4781.             }

    4782. 

  4782. 

    4783. 

  4783.             // When did this event occur?

    4784. 

  4784.             this.timeLastCharEvent = System.Environment.TickCount;

    4785. 

  4785.             return true;

    4786. 

  4786.         }

    4787. 

  4787.         private int timeLastCharEvent;

    4788. 

  4788.         private string lastSearchString;

    4789. 

  4789. 

    4790. 

  4790.         /// <summary>

    4791. 

  4791.         /// The user wants to see the context menu.

    4792. 

  4792.         /// </summary>

    4793. 

  4793.         /// <param name="m">The windows m</param>

    4794. 

  4794.         /// <returns>A bool indicating if this m has been handled</returns>

    4795. 

  4795.         /// <remarks>

    4796. 

  4796.         /// We want to ignore context menu requests that are triggered by right clicks on the header

    4797. 

  4797.         /// </remarks>

    4798. 

  4798.         protected virtual bool HandleContextMenu(ref Message m) {

    4799. 

  4799.             // Don't try to handle context menu commands at design time.

    4800. 

  4800.             if (this.DesignMode)

    4801. 

  4801.                 return false;

    4802. 

  4802. 

    4803. 

  4803.             // If the context menu command was generated by the keyboard, LParam will be -1.

    4804. 

  4804.             // We don't want to process these.

    4805. 

  4805.             if ((m.LParam.ToInt32()) == -1)

    4806. 

  4806.                 return false;

    4807. 

  4807. 

    4808. 

  4808.             // If the context menu came from somewhere other than the header control,

    4809. 

  4809.             // we also don't want to ignore it

    4810. 

  4810.             if (m.WParam != this.HeaderControl.Handle)

    4811. 

  4811.                 return false;

    4812. 

  4812. 

    4813. 

  4813.             // OK. Looks like a right click in the header

    4814. 

  4814.             if (!this.PossibleFinishCellEditing())

    4815. 

  4815.                 return true;

    4816. 

  4816. 

    4817. 

  4817.             int columnIndex = this.HeaderControl.ColumnIndexUnderCursor;

    4818. 

  4818.             return this.HandleHeaderRightClick(columnIndex);

    4819. 

  4819.         }

    4820. 

  4820. 

    4821. 

  4821.         /// <summary>

    4822. 

  4822.         /// Handle the Custom draw series of notifications

    4823. 

  4823.         /// </summary>

    4824. 

  4824.         /// <param name="m">The message</param>

    4825. 

  4825.         /// <returns>True if the message has been handled</returns>

    4826. 

  4826.         protected virtual bool HandleCustomDraw(ref Message m) {

    4827. 

  4827.             const int CDDS_PREPAINT = 1;

    4828. 

  4828.             const int CDDS_POSTPAINT = 2;

    4829. 

  4829.             const int CDDS_PREERASE = 3;

    4830. 

  4830.             const int CDDS_POSTERASE = 4;

    4831. 

  4831.             //const int CDRF_NEWFONT = 2;

    4832. 

  4832.             //const int CDRF_SKIPDEFAULT = 4;

    4833. 

  4833.             const int CDDS_ITEM = 0x00010000;

    4834. 

  4834.             const int CDDS_SUBITEM = 0x00020000;

    4835. 

  4835.             const int CDDS_ITEMPREPAINT = (CDDS_ITEM | CDDS_PREPAINT);

    4836. 

  4836.             const int CDDS_ITEMPOSTPAINT = (CDDS_ITEM | CDDS_POSTPAINT);

    4837. 

  4837.             const int CDDS_ITEMPREERASE = (CDDS_ITEM | CDDS_PREERASE);

    4838. 

  4838.             const int CDDS_ITEMPOSTERASE = (CDDS_ITEM | CDDS_POSTERASE);

    4839. 

  4839.             const int CDDS_SUBITEMPREPAINT = (CDDS_SUBITEM | CDDS_ITEMPREPAINT);

    4840. 

  4840.             const int CDDS_SUBITEMPOSTPAINT = (CDDS_SUBITEM | CDDS_ITEMPOSTPAINT);

    4841. 

  4841.             const int CDRF_NOTIFYPOSTPAINT = 0x10;

    4842. 

  4842.             //const int CDRF_NOTIFYITEMDRAW = 0x20;

    4843. 

  4843.             //const int CDRF_NOTIFYSUBITEMDRAW = 0x20; // same value as above!

    4844. 

  4844.             const int CDRF_NOTIFYPOSTERASE = 0x40;

    4845. 

  4845. 

    4846. 

  4846.             NativeMethods.NMLVCUSTOMDRAW nmcustomdraw = (NativeMethods.NMLVCUSTOMDRAW)m.GetLParam(typeof(NativeMethods.NMLVCUSTOMDRAW));

    4847. 

  4847.             //System.Diagnostics.Debug.WriteLine(String.Format("cd: {0:x}, {1}, {2}", nmcustomdraw.nmcd.dwDrawStage, nmcustomdraw.dwItemType, nmcustomdraw.nmcd.dwItemSpec));

    4848. 

  4848. 

    4849. 

  4849.             // There is a bug in owner drawn virtual lists which causes lots of custom draw messages

    4850. 

  4850.             // to be sent to the control *outside* of a WmPaint event. AFAIK, these custom draw events

    4851. 

  4851.             // are spurious and only serve to make the control flicker annoyingly.

    4852. 

  4852.             // So, we ignore messages that are outside of a paint event.

    4853. 

  4853.             if (!this.isInWmPaintEvent)

    4854. 

  4854.                 return true;

    4855. 

  4855. 

    4856. 

  4856.             // One more complication! Sometimes with owner drawn virtual lists, the act of drawing

    4857. 

  4857.             // the overlays triggers a second attempt to paint the control -- which makes an annoying

    4858. 

  4858.             // flicker. So, we only do the custom drawing once per WmPaint event.

    4859. 

  4859.             if (!this.shouldDoCustomDrawing)

    4860. 

  4860.                 return true;

    4861. 

  4861. 

    4862. 

  4862.             switch (nmcustomdraw.nmcd.dwDrawStage) {

    4863. 

  4863.                 case CDDS_PREPAINT:

    4864. 

  4864.                     //System.Diagnostics.Debug.WriteLine("CDDS_PREPAINT");

    4865. 

  4865.                     // Remember which items were drawn during this paint cycle

    4866. 

  4866.                     if (this.prePaintLevel == 0)

    4867. 

  4867.                         this.drawnItems = new List<OLVListItem>();

    4868. 

  4868. 

    4869. 

  4869.                     // If there are any items, we have to wait until at least one has been painted

    4870. 

  4870.                     // before we draw the overlays. If there aren't any items, there will never be any

    4871. 

  4871.                     // item paint events, so we can draw the overlays whenever

    4872. 

  4872.                     this.isAfterItemPaint = (this.GetItemCount() == 0);

    4873. 

  4873.                     this.prePaintLevel++;

    4874. 

  4874.                     base.WndProc(ref m);

    4875. 

  4875. 

    4876. 

  4876.                     // Make sure that we get postpaint notifications

    4877. 

  4877.                     m.Result = (IntPtr)((int)m.Result | CDRF_NOTIFYPOSTPAINT | CDRF_NOTIFYPOSTERASE);

    4878. 

  4878.                     return true;

    4879. 

  4879. 

    4880. 

  4880.                 case CDDS_POSTPAINT:

    4881. 

  4881.                     //System.Diagnostics.Debug.WriteLine("CDDS_POSTPAINT");

    4882. 

  4882.                     this.prePaintLevel--;

    4883. 

  4883. 

    4884. 

  4884.                     // When in group view, we have two problems. On XP, the control sends

    4885. 

  4885.                     // a whole heap of PREPAINT/POSTPAINT messages before drawing any items.

    4886. 

  4886.                     // We have to wait until after the first item paint before we draw overlays.

    4887. 

  4887.                     // On Vista, we have a different problem. On Vista, the control nests calls

    4888. 

  4888.                     // to PREPAINT and POSTPAINT. We only want to draw overlays on the outermost

    4889. 

  4889.                     // POSTPAINT.

    4890. 

  4890.                     if (this.prePaintLevel == 0 && (this.isMarqueSelecting || this.isAfterItemPaint)) {

    4891. 

  4891.                         this.shouldDoCustomDrawing = false;

    4892. 

  4892. 

    4893. 

  4893.                         // Draw our overlays after everything has been drawn

    4894. 

  4894.                         using (Graphics g = Graphics.FromHdc(nmcustomdraw.nmcd.hdc)) {

    4895. 

  4895.                             this.DrawAllDecorations(g, this.drawnItems);

    4896. 

  4896.                         }

    4897. 

  4897.                     }

    4898. 

  4898.                     break;

    4899. 

  4899. 

    4900. 

  4900.                 case CDDS_ITEMPREPAINT:

    4901. 

  4901.                     //System.Diagnostics.Debug.WriteLine("CDDS_ITEMPREPAINT");

    4902. 

  4902. 

    4903. 

  4903.                     // When in group view on XP, the control send a whole heap of PREPAINT/POSTPAINT

    4904. 

  4904.                     // messages before drawing any items.

    4905. 

  4905.                     // We have to wait until after the first item paint before we draw overlays

    4906. 

  4906.                     this.isAfterItemPaint = true;

    4907. 

  4907. 

    4908. 

  4908.                     // This scheme of catching custom draw msgs works fine, except

    4909. 

  4909.                     // for Tile view. Something in .NET's handling of Tile view causes lots

    4910. 

  4910.                     // of invalidates and erases. So, we just ignore completely

    4911. 

  4911.                     // .NET's handling of Tile view and let the underlying control

    4912. 

  4912.                     // do its stuff. Strangely, if the Tile view is

    4913. 

  4913.                     // completely owner drawn, those erasures don't happen.

    4914. 

  4914.                     if (this.View == View.Tile) {

    4915. 

  4915.                         if (this.OwnerDraw && this.ItemRenderer != null)

    4916. 

  4916.                             base.WndProc(ref m);

    4917. 

  4917.                     } else {

    4918. 

  4918.                         base.WndProc(ref m);

    4919. 

  4919.                     }

    4920. 

  4920. 

    4921. 

  4921.                     m.Result = (IntPtr)((int)m.Result | CDRF_NOTIFYPOSTPAINT | CDRF_NOTIFYPOSTERASE);

    4922. 

  4922.                     return true;

    4923. 

  4923. 

    4924. 

  4924.                 case CDDS_ITEMPOSTPAINT:

    4925. 

  4925.                     //System.Diagnostics.Debug.WriteLine("CDDS_ITEMPOSTPAINT");

    4926. 

  4926.                     if (this.Columns.Count > 0) {

    4927. 

  4927.                         OLVListItem olvi = this.GetItem((int)nmcustomdraw.nmcd.dwItemSpec);

    4928. 

  4928.                         if (olvi != null)

    4929. 

  4929.                             this.drawnItems.Add(olvi);

    4930. 

  4930.                     }

    4931. 

  4931.                     break;

    4932. 

  4932. 

    4933. 

  4933.                 case CDDS_SUBITEMPREPAINT:

    4934. 

  4934.                     //System.Diagnostics.Debug.WriteLine(String.Format("CDDS_SUBITEMPREPAINT ({0},{1})", (int)nmcustomdraw.nmcd.dwItemSpec, nmcustomdraw.iSubItem));

    4935. 

  4935. 

    4936. 

  4936.                     // There is a bug in the .NET framework which appears when column 0 of an owner drawn listview

    4937. 

  4937.                     // is dragged to another column position.

    4938. 

  4938.                     // The bounds calculation always returns the left edge of column 0 as being 0.

    4939. 

  4939.                     // The effects of this bug become apparent

    4940. 

  4940.                     // when the listview is scrolled horizontally: the control can think that column 0

    4941. 

  4941.                     // is no longer visible (the horizontal scroll position is subtracted from the bounds, giving a

    4942. 

  4942.                     // rectangle that is offscreen). In those circumstances, column 0 is not redraw because

    4943. 

  4943.                     // the control thinks it is not visible and so does not trigger a DrawSubItem event.

    4944. 

  4944. 

    4945. 

  4945.                     // To fix this problem, we have to detected the situation -- owner drawing column 0 in any column except 0 --

    4946. 

  4946.                     // trigger our own DrawSubItem, and then prevent the default processing from occuring.

    4947. 

  4947. 

    4948. 

  4948.                     // Are we owner drawing column 0 when it's in any column except 0?

    4949. 

  4949.                     if (!this.OwnerDraw)

    4950. 

  4950.                         return false;

    4951. 

  4951. 

    4952. 

  4952.                     int columnIndex = nmcustomdraw.iSubItem;

    4953. 

  4953.                     if (columnIndex != 0)

    4954. 

  4954.                         return false;

    4955. 

  4955. 

    4956. 

  4956.                     int displayIndex = this.Columns[0].DisplayIndex;

    4957. 

  4957.                     if (displayIndex == 0)

    4958. 

  4958.                         return false;

    4959. 

  4959. 

    4960. 

  4960.                     int rowIndex = (int)nmcustomdraw.nmcd.dwItemSpec;

    4961. 

  4961.                     OLVListItem item = this.GetItem(rowIndex);

    4962. 

  4962.                     if (item == null)

    4963. 

  4963.                         return false;

    4964. 

  4964. 

    4965. 

  4965.                     // OK. We have the error condition, so lets do what the .NET framework should do.

    4966. 

  4966.                     // Trigger an event to draw column 0 when it is not at display index 0

    4967. 

  4967.                     using (Graphics g = Graphics.FromHdc(nmcustomdraw.nmcd.hdc)) {

    4968. 

  4968. 

    4969. 

  4969.                         // Correctly calculate the bounds of cell 0

    4970. 

  4970.                         Rectangle r = item.GetSubItemBounds(0);

    4971. 

  4971. 

    4972. 

  4972.                         // We can hardcode "0" here since we know we are only doing this for column 0

    4973. 

  4973.                         DrawListViewSubItemEventArgs args = new DrawListViewSubItemEventArgs(g, r, item, item.SubItems[0], rowIndex, 0,

    4974. 

  4974.                             this.Columns[0], (ListViewItemStates)nmcustomdraw.nmcd.uItemState);

    4975. 

  4975.                         this.OnDrawSubItem(args);

    4976. 

  4976. 

    4977. 

  4977.                         // If the event handler wants to do the default processing (i.e. DrawDefault = true), we are stuck.

    4978. 

  4978.                         // There is no way we can force the default drawing because of the bug in .NET we are trying to get around.

    4979. 

  4979.                         System.Diagnostics.Trace.Assert(!args.DrawDefault, "Default drawing is impossible in this situation");

    4980. 

  4980.                     }

    4981. 

  4981.                     m.Result = (IntPtr)4;

    4982. 

  4982. 

    4983. 

  4983.                     return true;

    4984. 

  4984. 

    4985. 

  4985.                 case CDDS_SUBITEMPOSTPAINT:

    4986. 

  4986.                     //System.Diagnostics.Debug.WriteLine("CDDS_SUBITEMPOSTPAINT");

    4987. 

  4987.                     break;

    4988. 

  4988. 

    4989. 

  4989.                 // I have included these stages, but it doesn't seem that they are sent for ListViews.

    4990. 

  4990.                 // http://www.tech-archive.net/Archive/VC/microsoft.public.vc.mfc/2006-08/msg00220.html

    4991. 

  4991. 

    4992. 

  4992.                 case CDDS_PREERASE:

    4993. 

  4993.                     //System.Diagnostics.Debug.WriteLine("CDDS_PREERASE");

    4994. 

  4994.                     break;

    4995. 

  4995. 

    4996. 

  4996.                 case CDDS_POSTERASE:

    4997. 

  4997.                     //System.Diagnostics.Debug.WriteLine("CDDS_POSTERASE");

    4998. 

  4998.                     break;

    4999. 

  4999. 

    5000. 

  5000.                 case CDDS_ITEMPREERASE:

    5001. 

  5001.                     //System.Diagnostics.Debug.WriteLine("CDDS_ITEMPREERASE");

    5002. 

  5002.                     break;

    5003. 

  5003. 

    5004. 

  5004.                 case CDDS_ITEMPOSTERASE:

    5005. 

  5005.                     //System.Diagnostics.Debug.WriteLine("CDDS_ITEMPOSTERASE");

    5006. 

  5006.                     break;

    5007. 

  5007.             }

    5008. 

  5008. 

    5009. 

  5009.             return false;

    5010. 

  5010.         }

    5011. 

  5011.         bool isAfterItemPaint;

    5012. 

  5012.         List<OLVListItem> drawnItems;

    5013. 

  5013. 

    5014. 

  5014.         /// <summary>

    5015. 

  5015.         /// Handle the underlying control being destroyed

    5016. 

  5016.         /// </summary>

    5017. 

  5017.         /// <param name="m"></param>

    5018. 

  5018.         /// <returns></returns>

    5019. 

  5019.         protected virtual bool HandleDestroy(ref Message m) {

    5020. 

  5020.             //System.Diagnostics.Debug.WriteLine("WM_DESTROY");

    5021. 

  5021. 

    5022. 

  5022.             // Recreate the header control when the listview control is destroyed

    5023. 

  5023.             this.BeginInvoke((MethodInvoker)delegate {

    5024. 

  5024.                 this.headerControl = null;

    5025. 

  5025.                 this.HeaderControl.WordWrap = this.HeaderWordWrap;

    5026. 

  5026.             });

    5027. 

  5027. 

    5028. 

  5028.             // When the underlying control is destroyed, we need to recreate

    5029. 

  5029.             // and reconfigure its tooltip

    5030. 

  5030.             if (this.cellToolTip == null)

    5031. 

  5031.                 return false;

    5032. 

  5032.             else {

    5033. 

  5033.                 this.cellToolTip.PushSettings();

    5034. 

  5034.                 base.WndProc(ref m);

    5035. 

  5035.                 this.BeginInvoke((MethodInvoker)delegate {

    5036. 

  5036.                     this.UpdateCellToolTipHandle();

    5037. 

  5037.                     this.cellToolTip.PopSettings();

    5038. 

  5038.                 });

    5039. 

  5039.                 return true;

    5040. 

  5040.             }

    5041. 

  5041.         }

    5042. 

  5042. 

    5043. 

  5043.         /// <summary>

    5044. 

  5044.         /// Handle the search for item m if possible.

    5045. 

  5045.         /// </summary>

    5046. 

  5046.         /// <param name="m">The m to be processed</param>

    5047. 

  5047.         /// <returns>bool to indicate if the m has been handled</returns>

    5048. 

  5048.         protected virtual bool HandleFindItem(ref Message m) {

    5049. 

  5049.             // NOTE: As far as I can see, this message is never actually sent to the control, making this

    5050. 

  5050.             // method redundant!

    5051. 

  5051. 

    5052. 

  5052.             const int LVFI_STRING = 0x0002;

    5053. 

  5053. 

    5054. 

  5054.             NativeMethods.LVFINDINFO findInfo = (NativeMethods.LVFINDINFO)m.GetLParam(typeof(NativeMethods.LVFINDINFO));

    5055. 

  5055. 

    5056. 

  5056.             // We can only handle string searches

    5057. 

  5057.             if ((findInfo.flags & LVFI_STRING) != LVFI_STRING)

    5058. 

  5058.                 return false;

    5059. 

  5059. 

    5060. 

  5060.             int start = m.WParam.ToInt32();

    5061. 

  5061.             m.Result = (IntPtr)this.FindMatchingRow(findInfo.psz, start, SearchDirectionHint.Down);

    5062. 

  5062.             return true;

    5063. 

  5063.         }

    5064. 

  5064. 

    5065. 

  5065.         /// <summary>

    5066. 

  5066.         /// Find the first row after the given start in which the text value in the

    5067. 

  5067.         /// comparison column begins with the given text. The comparison column is column 0,

    5068. 

  5068.         /// unless IsSearchOnSortColumn is true, in which case the current sort column is used.

    5069. 

  5069.         /// </summary>

    5070. 

  5070.         /// <param name="text">The text to be prefix matched</param>

    5071. 

  5071.         /// <param name="start">The index of the first row to consider</param>

    5072. 

  5072.         /// <param name="direction">Which direction should be searched?</param>

    5073. 

  5073.         /// <returns>The index of the first row that matched, or -1</returns>

    5074. 

  5074.         /// <remarks>The text comparison is a case-insensitive, prefix match. The search will

    5075. 

  5075.         /// search the every row until a match is found, wrapping at the end if needed.</remarks>

    5076. 

  5076.         public virtual int FindMatchingRow(string text, int start, SearchDirectionHint direction) {

    5077. 

  5077.             // We also can't do anything if we don't have data

    5078. 

  5078.             int rowCount = this.GetItemCount();

    5079. 

  5079.             if (rowCount == 0)

    5080. 

  5080.                 return -1;

    5081. 

  5081. 

    5082. 

  5082.             // Which column are we going to use for our comparing?

    5083. 

  5083.             OLVColumn column = this.GetColumn(0);

    5084. 

  5084.             if (this.IsSearchOnSortColumn && this.View == View.Details && this.LastSortColumn != null)

    5085. 

  5085.                 column = this.LastSortColumn;

    5086. 

  5086. 

    5087. 

  5087.             // Do two searches if necessary to find a match. The second search is the wrap-around part of searching

    5088. 

  5088.             int i;

    5089. 

  5089.             if (direction == SearchDirectionHint.Down) {

    5090. 

  5090.                 i = this.FindMatchInRange(text, start, rowCount - 1, column);

    5091. 

  5091.                 if (i == -1 && start > 0)

    5092. 

  5092.                     i = this.FindMatchInRange(text, 0, start - 1, column);

    5093. 

  5093.             } else {

    5094. 

  5094.                 i = this.FindMatchInRange(text, start, 0, column);

    5095. 

  5095.                 if (i == -1 && start != rowCount)

    5096. 

  5096.                     i = this.FindMatchInRange(text, rowCount - 1, start + 1, column);

    5097. 

  5097.             }

    5098. 

  5098. 

    5099. 

  5099.             return i;

    5100. 

  5100.         }

    5101. 

  5101. 

    5102. 

  5102.         /// <summary>

    5103. 

  5103.         /// Find the first row in the given range of rows that prefix matches the string value of the given column.

    5104. 

  5104.         /// </summary>

    5105. 

  5105.         /// <param name="text"></param>

    5106. 

  5106.         /// <param name="first"></param>

    5107. 

  5107.         /// <param name="last"></param>

    5108. 

  5108.         /// <param name="column"></param>

    5109. 

  5109.         /// <returns>The index of the matched row, or -1</returns>

    5110. 

  5110.         protected virtual int FindMatchInRange(string text, int first, int last, OLVColumn column) {

    5111. 

  5111.             if (first <= last) {

    5112. 

  5112.                 for (int i = first; i <= last; i++) {

    5113. 

  5113.                     string data = column.GetStringValue(this.GetNthItemInDisplayOrder(i).RowObject);

    5114. 

  5114.                     if (data.StartsWith(text, StringComparison.CurrentCultureIgnoreCase))

    5115. 

  5115.                         return i;

    5116. 

  5116.                 }

    5117. 

  5117.             } else {

    5118. 

  5118.                 for (int i = first; i >= last; i--) {

    5119. 

  5119.                     string data = column.GetStringValue(this.GetNthItemInDisplayOrder(i).RowObject);

    5120. 

  5120.                     if (data.StartsWith(text, StringComparison.CurrentCultureIgnoreCase))

    5121. 

  5121.                         return i;

    5122. 

  5122.                 }

    5123. 

  5123.             }

    5124. 

  5124. 

    5125. 

  5125.             return -1;

    5126. 

  5126.         }

    5127. 

  5127. 

    5128. 

  5128.         /// <summary>

    5129. 

  5129.         /// Handle a key down message

    5130. 

  5130.         /// </summary>

    5131. 

  5131.         /// <param name="m"></param>

    5132. 

  5132.         /// <returns>True if the msg has been handled</returns>

    5133. 

  5133.         protected virtual bool HandleKeyDown(ref Message m) {

    5134. 

  5134. 

    5135. 

  5135.             // If this is a checkbox list, toggle the selected rows when the user presses Space

    5136. 

  5136.             if (this.CheckBoxes && m.WParam.ToInt32() == (int)Keys.Space && this.SelectedIndices.Count > 0) {

    5137. 

  5137.                 this.ToggleSelectedRowCheckBoxes();

    5138. 

  5138.                 return true;

    5139. 

  5139.             }

    5140. 

  5140. 

    5141. 

  5141.             // Remember the scroll position so we can decide if the listview has scrolled in the

    5142. 

  5142.             // handling of the event.

    5143. 

  5143.             int scrollPositionH = NativeMethods.GetScrollPosition(this, true);

    5144. 

  5144.             int scrollPositionV = NativeMethods.GetScrollPosition(this, false);

    5145. 

  5145. 

    5146. 

  5146.             base.WndProc(ref m);

    5147. 

  5147. 

    5148. 

  5148.             // It's possible that the processing in base.WndProc has actually destroyed this control

    5149. 

  5149.             if (this.IsDisposed)

    5150. 

  5150.                 return true;

    5151. 

  5151. 

    5152. 

  5152.             // If the keydown processing changed the scroll position, trigger a Scroll event

    5153. 

  5153.             int newScrollPositionH = NativeMethods.GetScrollPosition(this, true);

    5154. 

  5154.             int newScrollPositionV = NativeMethods.GetScrollPosition(this, false);

    5155. 

  5155. 

    5156. 

  5156.             if (scrollPositionH != newScrollPositionH) {

    5157. 

  5157.                 ScrollEventArgs args = new ScrollEventArgs(ScrollEventType.EndScroll,

    5158. 

  5158.                     scrollPositionH, newScrollPositionH, ScrollOrientation.HorizontalScroll);

    5159. 

  5159.                 this.OnScroll(args);

    5160. 

  5160.                 this.RefreshHotItem();

    5161. 

  5161.             }

    5162. 

  5162.             if (scrollPositionV != newScrollPositionV) {

    5163. 

  5163.                 ScrollEventArgs args = new ScrollEventArgs(ScrollEventType.EndScroll,

    5164. 

  5164.                     scrollPositionV, newScrollPositionV, ScrollOrientation.VerticalScroll);

    5165. 

  5165.                 this.OnScroll(args);

    5166. 

  5166.                 this.RefreshHotItem();

    5167. 

  5167.             }

    5168. 

  5168. 

    5169. 

  5169.             return true;

    5170. 

  5170.         }

    5171. 

  5171. 

    5172. 

  5172.         private void ToggleSelectedRowCheckBoxes() {

    5173. 

  5173.             // This doesn't actually toggle all rows. It toggles the first row, and

    5174. 

  5174.             // all other rows get the check state of that first row.

    5175. 

  5175.             Object primaryModel = this.GetItem(this.SelectedIndices[0]).RowObject;

    5176. 

  5176.             this.ToggleCheckObject(primaryModel);

    5177. 

  5177.             CheckState? state = this.GetCheckState(primaryModel);

    5178. 

  5178.             if (state.HasValue) {

    5179. 

  5179.                 foreach (Object x in this.SelectedObjects)

    5180. 

  5180.                     this.SetObjectCheckedness(x, state.Value);

    5181. 

  5181.             }

    5182. 

  5182.         }

    5183. 

  5183. 

    5184. 

  5184.         /// <summary>

    5185. 

  5185.         /// Catch the Left Button down event.

    5186. 

  5186.         /// </summary>

    5187. 

  5187.         /// <param name="m">The m to be processed</param>

    5188. 

  5188.         /// <returns>bool to indicate if the m has been handled</returns>

    5189. 

  5189.         protected virtual bool HandleLButtonDown(ref Message m) {

    5190. 

  5190.             // We have to intercept this low level message rather than the more natural

    5191. 

  5191.             // overridding of OnMouseDown, since ListCtrl's internal mouse down behavior

    5192. 

  5192.             // is to select (or deselect) rows when the mouse is released. We don't

    5193. 

  5193.             // want the selection to change when the user checks or unchecks a checkbox, so if the

    5194. 

  5194.             // mouse down event was to check/uncheck, we have to hide this mouse

    5195. 

  5195.             // down event from the control.

    5196. 

  5196. 

    5197. 

  5197.             int x = m.LParam.ToInt32() & 0xFFFF;

    5198. 

  5198.             int y = (m.LParam.ToInt32() >> 16) & 0xFFFF;

    5199. 

  5199. 

    5200. 

  5200.             return this.ProcessLButtonDown(this.OlvHitTest(x, y));

    5201. 

  5201.         }

    5202. 

  5202. 

    5203. 

  5203.         /// <summary>

    5204. 

  5204.         /// Handle a left mouse down at the given hit test location

    5205. 

  5205.         /// </summary>

    5206. 

  5206.         /// <remarks>Subclasses can override this to do something unique</remarks>

    5207. 

  5207.         /// <param name="hti"></param>

    5208. 

  5208.         /// <returns>True if the message has been handled</returns>

    5209. 

  5209.         protected virtual bool ProcessLButtonDown(OlvListViewHitTestInfo hti) {

    5210. 

  5210.             if (hti.Item == null)

    5211. 

  5211.                 return false;

    5212. 

  5212. 

    5213. 

  5213.             // If they didn't click checkbox, we can just return

    5214. 

  5214.             if (this.View != View.Details || hti.HitTestLocation != HitTestLocation.CheckBox)

    5215. 

  5215.                 return false;

    5216. 

  5216. 

    5217. 

  5217.             // Did they click a sub item checkbox?

    5218. 

  5218.             if (hti.Column.Index > 0) {

    5219. 

  5219.                 if (hti.Column.IsEditable)

    5220. 

  5220.                     this.ToggleSubItemCheckBox(hti.RowObject, hti.Column);

    5221. 

  5221.                 return true;

    5222. 

  5222.             }

    5223. 

  5223. 

    5224. 

  5224.             // They must have clicked the primary checkbox

    5225. 

  5225.             this.ToggleCheckObject(hti.RowObject);

    5226. 

  5226. 

    5227. 

  5227.             // If they change the checkbox of a selecte row, all the rows in the selection

    5228. 

  5228.             // should be given the same state

    5229. 

  5229.             if (hti.Item.Selected) {

    5230. 

  5230.                 CheckState? state = this.GetCheckState(hti.RowObject);

    5231. 

  5231.                 if (state.HasValue) {

    5232. 

  5232.                     foreach (Object x in this.SelectedObjects)

    5233. 

  5233.                         this.SetObjectCheckedness(x, state.Value);

    5234. 

  5234.                 }

    5235. 

  5235.             }

    5236. 

  5236. 

    5237. 

  5237.             return true;

    5238. 

  5238.         }

    5239. 

  5239. 

    5240. 

  5240.         /// <summary>

    5241. 

  5241.         /// Catch the Right Button down event.

    5242. 

  5242.         /// </summary>

    5243. 

  5243.         /// <param name="m">The m to be processed</param>

    5244. 

  5244.         /// <returns>bool to indicate if the m has been handled</returns>

    5245. 

  5245.         protected virtual bool HandleRButtonDown(ref Message m) {

    5246. 

  5246.             int x = m.LParam.ToInt32() & 0xFFFF;

    5247. 

  5247.             int y = (m.LParam.ToInt32() >> 16) & 0xFFFF;

    5248. 

  5248. 

    5249. 

  5249.             return this.ProcessRButtonDown(this.OlvHitTest(x, y));

    5250. 

  5250.         }

    5251. 

  5251. 

    5252. 

  5252.         /// <summary>

    5253. 

  5253.         /// Handle a left mouse down at the given hit test location

    5254. 

  5254.         /// </summary>

    5255. 

  5255.         /// <remarks>Subclasses can override this to do something unique</remarks>

    5256. 

  5256.         /// <param name="hti"></param>

    5257. 

  5257.         /// <returns>True if the message has been handled</returns>

    5258. 

  5258.         protected virtual bool ProcessRButtonDown(OlvListViewHitTestInfo hti) {

    5259. 

  5259.             if (hti.Item == null)

    5260. 

  5260.                 return false;

    5261. 

  5261. 

    5262. 

  5262.             // Ignore clicks on checkboxes

    5263. 

  5263.             return (this.View == View.Details && hti.HitTestLocation == HitTestLocation.CheckBox);

    5264. 

  5264.         }

    5265. 

  5265. 

    5266. 

  5266.         /// <summary>

    5267. 

  5267.         /// Catch the Left Button double click event.

    5268. 

  5268.         /// </summary>

    5269. 

  5269.         /// <param name="m">The m to be processed</param>

    5270. 

  5270.         /// <returns>bool to indicate if the m has been handled</returns>

    5271. 

  5271.         protected virtual bool HandleLButtonDoubleClick(ref Message m) {

    5272. 

  5272.             int x = m.LParam.ToInt32() & 0xFFFF;

    5273. 

  5273.             int y = (m.LParam.ToInt32() >> 16) & 0xFFFF;

    5274. 

  5274. 

    5275. 

  5275.             return this.ProcessLButtonDoubleClick(this.OlvHitTest(x, y));

    5276. 

  5276.         }

    5277. 

  5277. 

    5278. 

  5278.         /// <summary>

    5279. 

  5279.         /// Handle a mouse double click at the given hit test location

    5280. 

  5280.         /// </summary>

    5281. 

  5281.         /// <remarks>Subclasses can override this to do something unique</remarks>

    5282. 

  5282.         /// <param name="hti"></param>

    5283. 

  5283.         /// <returns>True if the message has been handled</returns>

    5284. 

  5284.         protected virtual bool ProcessLButtonDoubleClick(OlvListViewHitTestInfo hti) {

    5285. 

  5285. 

    5286. 

  5286.             // If the user double clicked on a checkbox, ignore it

    5287. 

  5287.             return (hti.HitTestLocation == HitTestLocation.CheckBox);

    5288. 

  5288.         }

    5289. 

  5289. 

    5290. 

  5290.         /// <summary>

    5291. 

  5291.         /// Catch the right Button double click event.

    5292. 

  5292.         /// </summary>

    5293. 

  5293.         /// <param name="m">The m to be processed</param>

    5294. 

  5294.         /// <returns>bool to indicate if the m has been handled</returns>

    5295. 

  5295.         protected virtual bool HandleRButtonDoubleClick(ref Message m) {

    5296. 

  5296.             int x = m.LParam.ToInt32() & 0xFFFF;

    5297. 

  5297.             int y = (m.LParam.ToInt32() >> 16) & 0xFFFF;

    5298. 

  5298. 

    5299. 

  5299.             return this.ProcessRButtonDoubleClick(this.OlvHitTest(x, y));

    5300. 

  5300.         }

    5301. 

  5301. 

    5302. 

  5302.         /// <summary>

    5303. 

  5303.         /// Handle a right mouse double click at the given hit test location

    5304. 

  5304.         /// </summary>

    5305. 

  5305.         /// <remarks>Subclasses can override this to do something unique</remarks>

    5306. 

  5306.         /// <param name="hti"></param>

    5307. 

  5307.         /// <returns>True if the message has been handled</returns>

    5308. 

  5308.         protected virtual bool ProcessRButtonDoubleClick(OlvListViewHitTestInfo hti) {

    5309. 

  5309. 

    5310. 

  5310.             // If the user double clicked on a checkbox, ignore it

    5311. 

  5311.             return (hti.HitTestLocation == HitTestLocation.CheckBox);

    5312. 

  5312.         }

    5313. 

  5313. 

    5314. 

  5314.         /// <summary>

    5315. 

  5315.         /// In the notification messages, we handle change of state of list items

    5316. 

  5316.         /// </summary>

    5317. 

  5317.         /// <param name="m">The m to be processed</param>

    5318. 

  5318.         /// <returns>bool to indicate if the m has been handled</returns>

    5319. 

  5319.         protected virtual bool HandleReflectNotify(ref Message m) {

    5320. 

  5320.             const int NM_CLICK = -2;

    5321. 

  5321.             const int NM_DBLCLK = -3;

    5322. 

  5322.             const int NM_RDBLCLK = -6;

    5323. 

  5323.             const int NM_CUSTOMDRAW = -12;

    5324. 

  5324.             const int NM_RELEASEDCAPTURE = -16;

    5325. 

  5325.             const int LVN_ITEMCHANGED = -101;

    5326. 

  5326.             const int LVN_ITEMCHANGING = -100;

    5327. 

  5327.             const int LVN_MARQUEEBEGIN = -156;

    5328. 

  5328.             const int LVN_GETINFOTIP = -158;

    5329. 

  5329.             const int LVN_BEGINSCROLL = -180;

    5330. 

  5330.             const int LVN_ENDSCROLL = -181;

    5331. 

  5331.             const int LVN_LINKCLICK = -184;

    5332. 

  5332.             const int LVIF_STATE = 8;

    5333. 

  5333. 

    5334. 

  5334.             bool isMsgHandled = false;

    5335. 

  5335. 

    5336. 

  5336.             // TODO: Don't do any logic in this method. Create separate methods for each message

    5337. 

  5337. 

    5338. 

  5338.             NativeMethods.NMHDR nmhdr = (NativeMethods.NMHDR)m.GetLParam(typeof(NativeMethods.NMHDR));

    5339. 

  5339.             //System.Diagnostics.Debug.WriteLine(String.Format("rn: {0}", nmhdr->code));

    5340. 

  5340. 

    5341. 

  5341.             switch (nmhdr.code) {

    5342. 

  5342.                 case NM_CLICK:

    5343. 

  5343.                     // The standard ListView does some strange stuff here when the list has checkboxes.

    5344. 

  5344.                     // If you shift click on non-primary columns when FullRowSelect is true, the 

    5345. 

  5345.                     // checkedness of the selected rows changes. 

    5346. 

  5346.                     // We avoid all that by just saying we've handled this message.

    5347. 

  5347.                     //System.Diagnostics.Debug.WriteLine("NM_CLICK");

    5348. 

  5348.                     isMsgHandled = true;

    5349. 

  5349.                     this.OnClick(EventArgs.Empty);

    5350. 

  5350.                     break;

    5351. 

  5351. 

    5352. 

  5352.                 case LVN_BEGINSCROLL:

    5353. 

  5353.                     isMsgHandled = this.HandleBeginScroll(ref m);

    5354. 

  5354.                     break;

    5355. 

  5355. 

    5356. 

  5356.                 case LVN_ENDSCROLL:

    5357. 

  5357.                     isMsgHandled = this.HandleEndScroll(ref m);

    5358. 

  5358.                     break;

    5359. 

  5359. 

    5360. 

  5360.                 case LVN_LINKCLICK:

    5361. 

  5361.                     isMsgHandled = this.HandleLinkClick(ref m);

    5362. 

  5362.                     break;

    5363. 

  5363. 

    5364. 

  5364.                 case LVN_MARQUEEBEGIN:

    5365. 

  5365.                     //System.Diagnostics.Debug.WriteLine("LVN_MARQUEEBEGIN");

    5366. 

  5366.                     this.isMarqueSelecting = true;

    5367. 

  5367.                     break;

    5368. 

  5368. 

    5369. 

  5369.                 case LVN_GETINFOTIP:

    5370. 

  5370.                     //System.Diagnostics.Debug.WriteLine("LVN_GETINFOTIP");

    5371. 

  5371.                     // When virtual lists are in SmallIcon view, they generates tooltip message with invalid item indicies.

    5372. 

  5372.                     NativeMethods.NMLVGETINFOTIP nmGetInfoTip = (NativeMethods.NMLVGETINFOTIP)m.GetLParam(typeof(NativeMethods.NMLVGETINFOTIP));

    5373. 

  5373.                     isMsgHandled = nmGetInfoTip.iItem >= this.GetItemCount();

    5374. 

  5374.                     break;

    5375. 

  5375. 

    5376. 

  5376.                 case NM_RELEASEDCAPTURE:

    5377. 

  5377.                     //System.Diagnostics.Debug.WriteLine("NM_RELEASEDCAPTURE");

    5378. 

  5378.                     this.isMarqueSelecting = false;

    5379. 

  5379.                     this.Invalidate();

    5380. 

  5380.                     break;

    5381. 

  5381. 

    5382. 

  5382.                 case NM_CUSTOMDRAW:

    5383. 

  5383.                     //System.Diagnostics.Debug.WriteLine("NM_CUSTOMDRAW");

    5384. 

  5384.                     isMsgHandled = this.HandleCustomDraw(ref m);

    5385. 

  5385.                     break;

    5386. 

  5386. 

    5387. 

  5387.                 case NM_DBLCLK:

    5388. 

  5388.                     // The default behavior of a .NET ListView with checkboxes is to toggle the checkbox on

    5389. 

  5389.                     // double-click. That's just silly, if you ask me :)

    5390. 

  5390.                     if (this.CheckBoxes) {

    5391. 

  5391.                         // How do we make ListView not do that silliness? We could just ignore the message

    5392. 

  5392.                         // but the last part of the base code sets up state information, and without that

    5393. 

  5393.                         // state, the ListView doesn't trigger MouseDoubleClick events. So we fake a

    5394. 

  5394.                         // right button double click event, which sets up the same state, but without

    5395. 

  5395.                         // toggling the checkbox.

    5396. 

  5396.                         nmhdr.code = NM_RDBLCLK;

    5397. 

  5397.                         Marshal.StructureToPtr(nmhdr, m.LParam, false);

    5398. 

  5398.                     }

    5399. 

  5399.                     break;

    5400. 

  5400. 

    5401. 

  5401.                 case LVN_ITEMCHANGED:

    5402. 

  5402.                     //System.Diagnostics.Debug.WriteLine("LVN_ITEMCHANGED");

    5403. 

  5403.                     NativeMethods.NMLISTVIEW nmlistviewPtr2 = (NativeMethods.NMLISTVIEW)m.GetLParam(typeof(NativeMethods.NMLISTVIEW));

    5404. 

  5404.                     if ((nmlistviewPtr2.uChanged & LVIF_STATE) != 0) {

    5405. 

  5405.                         CheckState currentValue = this.CalculateCheckState(nmlistviewPtr2.uOldState);

    5406. 

  5406.                         CheckState newCheckValue = this.CalculateCheckState(nmlistviewPtr2.uNewState);

    5407. 

  5407.                         if (currentValue != newCheckValue) {

    5408. 

  5408.                             // Remove the state indicies so that we don't trigger the OnItemChecked method

    5409. 

  5409.                             // when we call our base method after exiting this method

    5410. 

  5410.                             nmlistviewPtr2.uOldState = (nmlistviewPtr2.uOldState & 0x0FFF);

    5411. 

  5411.                             nmlistviewPtr2.uNewState = (nmlistviewPtr2.uNewState & 0x0FFF);

    5412. 

  5412.                             Marshal.StructureToPtr(nmlistviewPtr2, m.LParam, false);

    5413. 

  5413.                         }

    5414. 

  5414.                     }

    5415. 

  5415.                     break;

    5416. 

  5416. 

    5417. 

  5417.                 case LVN_ITEMCHANGING:

    5418. 

  5418.                     //System.Diagnostics.Debug.WriteLine("LVN_ITEMCHANGING");

    5419. 

  5419.                     NativeMethods.NMLISTVIEW nmlistviewPtr = (NativeMethods.NMLISTVIEW)m.GetLParam(typeof(NativeMethods.NMLISTVIEW));

    5420. 

  5420.                     if ((nmlistviewPtr.uChanged & LVIF_STATE) != 0) {

    5421. 

  5421.                         CheckState currentValue = this.CalculateCheckState(nmlistviewPtr.uOldState);

    5422. 

  5422.                         CheckState newCheckValue = this.CalculateCheckState(nmlistviewPtr.uNewState);

    5423. 

  5423. 

    5424. 

  5424.                         if (currentValue != newCheckValue) {

    5425. 

  5425.                             // Prevent the base method from seeing the state change,

    5426. 

  5426.                             // since we handled it elsewhere

    5427. 

  5427.                             nmlistviewPtr.uChanged &= ~LVIF_STATE;

    5428. 

  5428.                             Marshal.StructureToPtr(nmlistviewPtr, m.LParam, false);

    5429. 

  5429.                         }

    5430. 

  5430.                     }

    5431. 

  5431.                     break;

    5432. 

  5432.             }

    5433. 

  5433. 

    5434. 

  5434.             return isMsgHandled;

    5435. 

  5435.         }

    5436. 

  5436. 

    5437. 

  5437.         private CheckState CalculateCheckState(int state) {

    5438. 

  5438.             switch ((state & 0xf000) >> 12) {

    5439. 

  5439.                 case 1:

    5440. 

  5440.                     return CheckState.Unchecked;

    5441. 

  5441.                 case 2:

    5442. 

  5442.                     return CheckState.Checked;

    5443. 

  5443.                 case 3:

    5444. 

  5444.                     return CheckState.Indeterminate;

    5445. 

  5445.                 default:

    5446. 

  5446.                     return CheckState.Checked;

    5447. 

  5447.             }

    5448. 

  5448.         }

    5449. 

  5449. 

    5450. 

  5450.         /// <summary>

    5451. 

  5451.         /// In the notification messages, we handle attempts to change the width of our columns

    5452. 

  5452.         /// </summary>

    5453. 

  5453.         /// <param name="m">The m to be processed</param>

    5454. 

  5454.         /// <returns>bool to indicate if the m has been handled</returns>

    5455. 

  5455.         protected bool HandleNotify(ref Message m) {

    5456. 

  5456.             bool isMsgHandled = false;

    5457. 

  5457. 

    5458. 

  5458.             const int NM_CUSTOMDRAW = -12;

    5459. 

  5459. 

    5460. 

  5460.             const int HDN_FIRST = (0 - 300);

    5461. 

  5461.             const int HDN_ITEMCHANGINGA = (HDN_FIRST - 0);

    5462. 

  5462.             const int HDN_ITEMCHANGINGW = (HDN_FIRST - 20);

    5463. 

  5463.             const int HDN_ITEMCLICKA = (HDN_FIRST - 2);

    5464. 

  5464.             const int HDN_ITEMCLICKW = (HDN_FIRST - 22);

    5465. 

  5465.             const int HDN_DIVIDERDBLCLICKA = (HDN_FIRST - 5);

    5466. 

  5466.             const int HDN_DIVIDERDBLCLICKW = (HDN_FIRST - 25);

    5467. 

  5467.             const int HDN_BEGINTRACKA = (HDN_FIRST - 6);

    5468. 

  5468.             const int HDN_BEGINTRACKW = (HDN_FIRST - 26);

    5469. 

  5469.             const int HDN_ENDTRACKA = (HDN_FIRST - 7);

    5470. 

  5470.             const int HDN_ENDTRACKW = (HDN_FIRST - 27);

    5471. 

  5471.             const int HDN_TRACKA = (HDN_FIRST - 8);

    5472. 

  5472.             const int HDN_TRACKW = (HDN_FIRST - 28);

    5473. 

  5473. 

    5474. 

  5474.             // Handle the notification, remembering to handle both ANSI and Unicode versions

    5475. 

  5475.             NativeMethods.NMHEADER nmheader = (NativeMethods.NMHEADER)m.GetLParam(typeof(NativeMethods.NMHEADER));

    5476. 

  5476.             //System.Diagnostics.Debug.WriteLine(String.Format("not: {0}", nmhdr->code));

    5477. 

  5477. 

    5478. 

  5478.             //if (nmhdr.code < HDN_FIRST)

    5479. 

  5479.             //    System.Diagnostics.Debug.WriteLine(nmhdr.code);

    5480. 

  5480. 

    5481. 

  5481.             // In KB Article #183258, MS states that when a header control has the HDS_FULLDRAG style, it will receive

    5482. 

  5482.             // ITEMCHANGING events rather than TRACK events. Under XP SP2 (at least) this is not always true, which may be

    5483. 

  5483.             // why MS has withdrawn that particular KB article. It is true that the header is always given the HDS_FULLDRAG

    5484. 

  5484.             // style. But even while window style set, the control doesn't always received ITEMCHANGING events.

    5485. 

  5485.             // The controlling setting seems to be the Explorer option "Show Window Contents While Dragging"!

    5486. 

  5486.             // In the category of "truly bizarre side effects", if the this option is turned on, we will receive

    5487. 

  5487.             // ITEMCHANGING events instead of TRACK events. But if it is turned off, we receive lots of TRACK events and

    5488. 

  5488.             // only one ITEMCHANGING event at the very end of the process.

    5489. 

  5489.             // If we receive HDN_TRACK messages, it's harder to control the resizing process. If we return a result of 1, we

    5490. 

  5490.             // cancel the whole drag operation, not just that particular track event, which is clearly not what we want.

    5491. 

  5491.             // If we are willing to compile with unsafe code enabled, we can modify the size of the column in place, using the

    5492. 

  5492.             // commented out code below. But without unsafe code, the best we can do is allow the user to drag the column to

    5493. 

  5493.             // any width, and then spring it back to within bounds once they release the mouse button. UI-wise it's very ugly.

    5494. 

  5494.             switch (nmheader.nhdr.code) {

    5495. 

  5495. 

    5496. 

  5496.                 case NM_CUSTOMDRAW:

    5497. 

  5497.                     if (!this.OwnerDrawnHeader)

    5498. 

  5498.                         isMsgHandled = this.HeaderControl.HandleHeaderCustomDraw(ref m);

    5499. 

  5499.                     break;

    5500. 

  5500. 

    5501. 

  5501.                 case HDN_ITEMCLICKA:

    5502. 

  5502.                 case HDN_ITEMCLICKW:

    5503. 

  5503.                     if (!this.PossibleFinishCellEditing()) {

    5504. 

  5504.                         m.Result = (IntPtr)1; // prevent the change from happening

    5505. 

  5505.                         isMsgHandled = true;

    5506. 

  5506.                     }

    5507. 

  5507.                     break;

    5508. 

  5508. 

    5509. 

  5509.                 case HDN_DIVIDERDBLCLICKA:

    5510. 

  5510.                 case HDN_DIVIDERDBLCLICKW:

    5511. 

  5511.                 case HDN_BEGINTRACKA:

    5512. 

  5512.                 case HDN_BEGINTRACKW:

    5513. 

  5513.                     if (!this.PossibleFinishCellEditing()) {

    5514. 

  5514.                         m.Result = (IntPtr)1; // prevent the change from happening

    5515. 

  5515.                         isMsgHandled = true;

    5516. 

  5516.                         break;

    5517. 

  5517.                     }

    5518. 

  5518.                     if (nmheader.iItem >= 0 && nmheader.iItem < this.Columns.Count) {

    5519. 

  5519.                         OLVColumn column = this.GetColumn(nmheader.iItem);

    5520. 

  5520.                         // Space filling columns can't be dragged or double-click resized

    5521. 

  5521.                         if (column.FillsFreeSpace) {

    5522. 

  5522.                             m.Result = (IntPtr)1; // prevent the change from happening

    5523. 

  5523.                             isMsgHandled = true;

    5524. 

  5524.                         }

    5525. 

  5525.                     }

    5526. 

  5526.                     break;

    5527. 

  5527.                 case HDN_ENDTRACKA:

    5528. 

  5528.                 case HDN_ENDTRACKW:

    5529. 

  5529.                     if (this.ShowGroups)

    5530. 

  5530.                         this.ResizeLastGroup();

    5531. 

  5531.                     break;

    5532. 

  5532.                 case HDN_TRACKA:

    5533. 

  5533.                 case HDN_TRACKW:

    5534. 

  5534.                     if (nmheader.iItem >= 0 && nmheader.iItem < this.Columns.Count) {

    5535. 

  5535.                         NativeMethods.HDITEM hditem = (NativeMethods.HDITEM)Marshal.PtrToStructure(nmheader.pHDITEM, typeof(NativeMethods.HDITEM));

    5536. 

  5536.                         OLVColumn column = this.GetColumn(nmheader.iItem);

    5537. 

  5537.                         if (hditem.cxy < column.MinimumWidth)

    5538. 

  5538.                             hditem.cxy = column.MinimumWidth;

    5539. 

  5539.                         else if (column.MaximumWidth != -1 && hditem.cxy > column.MaximumWidth)

    5540. 

  5540.                             hditem.cxy = column.MaximumWidth;

    5541. 

  5541.                         Marshal.StructureToPtr(hditem, nmheader.pHDITEM, false);

    5542. 

  5542.                     }

    5543. 

  5543.                     break;

    5544. 

  5544. 

    5545. 

  5545.                 case HDN_ITEMCHANGINGA:

    5546. 

  5546.                 case HDN_ITEMCHANGINGW:

    5547. 

  5547.                     nmheader = (NativeMethods.NMHEADER)m.GetLParam(typeof(NativeMethods.NMHEADER));

    5548. 

  5548.                     if (nmheader.iItem >= 0 && nmheader.iItem < this.Columns.Count) {

    5549. 

  5549.                         NativeMethods.HDITEM hditem = (NativeMethods.HDITEM)Marshal.PtrToStructure(nmheader.pHDITEM, typeof(NativeMethods.HDITEM));

    5550. 

  5550.                         OLVColumn column = this.GetColumn(nmheader.iItem);

    5551. 

  5551.                         // Check the mask to see if the width field is valid, and if it is, make sure it's within range

    5552. 

  5552.                         if ((hditem.mask & 1) == 1) {

    5553. 

  5553.                             if (hditem.cxy < column.MinimumWidth ||

    5554. 

  5554.                                 (column.MaximumWidth != -1 && hditem.cxy > column.MaximumWidth)) {

    5555. 

  5555.                                 m.Result = (IntPtr)1; // prevent the change from happening

    5556. 

  5556.                                 isMsgHandled = true;

    5557. 

  5557.                             }

    5558. 

  5558.                         }

    5559. 

  5559.                     }

    5560. 

  5560.                     break;

    5561. 

  5561. 

    5562. 

  5562.                 case ToolTipControl.TTN_SHOW:

    5563. 

  5563.                     //System.Diagnostics.Debug.WriteLine("olv TTN_SHOW");

    5564. 

  5564.                     System.Diagnostics.Trace.Assert(this.CellToolTip.Handle == nmheader.nhdr.hwndFrom);

    5565. 

  5565.                     isMsgHandled = this.CellToolTip.HandleShow(ref m);

    5566. 

  5566.                     break;

    5567. 

  5567. 

    5568. 

  5568.                 case ToolTipControl.TTN_POP:

    5569. 

  5569.                     //System.Diagnostics.Debug.WriteLine("olv TTN_POP");

    5570. 

  5570.                     System.Diagnostics.Trace.Assert(this.CellToolTip.Handle == nmheader.nhdr.hwndFrom);

    5571. 

  5571.                     isMsgHandled = this.CellToolTip.HandlePop(ref m);

    5572. 

  5572.                     break;

    5573. 

  5573. 

    5574. 

  5574.                 case ToolTipControl.TTN_GETDISPINFO:

    5575. 

  5575.                     //System.Diagnostics.Debug.WriteLine("olv TTN_GETDISPINFO");

    5576. 

  5576.                     System.Diagnostics.Trace.Assert(this.CellToolTip.Handle == nmheader.nhdr.hwndFrom);

    5577. 

  5577.                     isMsgHandled = this.CellToolTip.HandleGetDispInfo(ref m);

    5578. 

  5578.                     break;

    5579. 

  5579.             }

    5580. 

  5580. 

    5581. 

  5581.             return isMsgHandled;

    5582. 

  5582.         }

    5583. 

  5583. 

    5584. 

  5584.         /// <summary>

    5585. 

  5585.         /// Create a ToolTipControl to manage the tooltip control used by the listview control

    5586. 

  5586.         /// </summary>

    5587. 

  5587.         protected virtual void CreateCellToolTip() {

    5588. 

  5588.             this.cellToolTip = new ToolTipControl();

    5589. 

  5589.             this.cellToolTip.AssignHandle(NativeMethods.GetTooltipControl(this));

    5590. 

  5590.             this.cellToolTip.Showing += new EventHandler<ToolTipShowingEventArgs>(HandleCellToolTipShowing);

    5591. 

  5591.             this.cellToolTip.SetMaxWidth();

    5592. 

  5592.             NativeMethods.MakeTopMost(this.cellToolTip);

    5593. 

  5593.         }

    5594. 

  5594. 

    5595. 

  5595.         /// <summary>

    5596. 

  5596.         /// Update the handle used by our cell tooltip to be the tooltip used by

    5597. 

  5597.         /// the underlying Windows listview control.

    5598. 

  5598.         /// </summary>

    5599. 

  5599.         protected virtual void UpdateCellToolTipHandle() {

    5600. 

  5600.             if (this.cellToolTip != null && this.cellToolTip.Handle == IntPtr.Zero)

    5601. 

  5601.                 this.cellToolTip.AssignHandle(NativeMethods.GetTooltipControl(this));

    5602. 

  5602.         }

    5603. 

  5603. 

    5604. 

  5604.         /// <summary>

    5605. 

  5605.         /// Handle the WM_PAINT event

    5606. 

  5606.         /// </summary>

    5607. 

  5607.         /// <param name="m"></param>

    5608. 

  5608.         /// <returns>Return true if the msg has been handled and nothing further should be done</returns>

    5609. 

  5609.         protected virtual bool HandlePaint(ref Message m) {

    5610. 

  5610.             //System.Diagnostics.Debug.WriteLine("> WMPAINT");

    5611. 

  5611. 

    5612. 

  5612.             // We only want to custom draw the control within WmPaint message and only

    5613. 

  5613.             // once per paint event. We use these bools to insure this.

    5614. 

  5614.             this.isInWmPaintEvent = true;

    5615. 

  5615.             this.shouldDoCustomDrawing = true;

    5616. 

  5616.             this.prePaintLevel = 0;

    5617. 

  5617. 

    5618. 

  5618.             this.ShowOverlays();

    5619. 

  5619. 

    5620. 

  5620.             this.HandlePrePaint();

    5621. 

  5621.             base.WndProc(ref m);

    5622. 

  5622.             this.HandlePostPaint();

    5623. 

  5623.             this.isInWmPaintEvent = false;

    5624. 

  5624.             //System.Diagnostics.Debug.WriteLine("< WMPAINT");

    5625. 

  5625.             return true;

    5626. 

  5626.         }

    5627. 

  5627.         private int prePaintLevel;

    5628. 

  5628. 

    5629. 

  5629.         /// <summary>

    5630. 

  5630.         /// Perform any steps needed before painting the control

    5631. 

  5631.         /// </summary>

    5632. 

  5632.         protected virtual void HandlePrePaint() {

    5633. 

  5633.             // When we get a WM_PAINT msg, remember the rectangle that is being updated.

    5634. 

  5634.             // We can't get this information later, since the BeginPaint call wipes it out.

    5635. 

  5635.             this.lastUpdateRectangle = NativeMethods.GetUpdateRect(this);

    5636. 

  5636. 

    5637. 

  5637.             //// When the list is empty, we want to handle the drawing of the control by ourselves.

    5638. 

  5638.             //// Unfortunately, there is no easy way to tell our superclass that we want to do this.

    5639. 

  5639.             //// So we resort to guile and deception. We validate the list area of the control, which

    5640. 

  5640.             //// effectively tells our superclass that this area does not need to be painted.

    5641. 

  5641.             //// Our superclass will then not paint the control, leaving us free to do so ourselves.

    5642. 

  5642.             //// Without doing this trickery, the superclass will draw the list as empty,

    5643. 

  5643.             //// and then moments later, we will draw the empty list msg, giving a nasty flicker

    5644. 

  5644.             //if (this.GetItemCount() == 0 && this.HasEmptyListMsg)

    5645. 

  5645.             //    NativeMethods.ValidateRect(this, this.ClientRectangle);

    5646. 

  5646.         }

    5647. 

  5647. 

    5648. 

  5648.         /// <summary>

    5649. 

  5649.         /// Perform any steps needed after painting the control

    5650. 

  5650.         /// </summary>

    5651. 

  5651.         protected virtual void HandlePostPaint() {

    5652. 

  5652.             // This message is no longer necessary, but we keep it for compatibility

    5653. 

  5653.         }

    5654. 

  5654. 

    5655. 

  5655.         /// <summary>

    5656. 

  5656.         /// Handle the window position changing.

    5657. 

  5657.         /// </summary>

    5658. 

  5658.         /// <param name="m">The m to be processed</param>

    5659. 

  5659.         /// <returns>bool to indicate if the m has been handled</returns>

    5660. 

  5660.         protected virtual bool HandleWindowPosChanging(ref Message m) {

    5661. 

  5661.             const int SWP_NOSIZE = 1;

    5662. 

  5662. 

    5663. 

  5663.             NativeMethods.WINDOWPOS pos = (NativeMethods.WINDOWPOS)m.GetLParam(typeof(NativeMethods.WINDOWPOS));

    5664. 

  5664.             if ((pos.flags & SWP_NOSIZE) == 0) {

    5665. 

  5665.                 if (pos.cx < this.Bounds.Width) // only when shrinking

    5666. 

  5666.                     // pos.cx is the window width, not the client area width, so we have to subtract the border widths

    5667. 

  5667.                     this.ResizeFreeSpaceFillingColumns(pos.cx - (this.Bounds.Width - this.ClientSize.Width));

    5668. 

  5668.                 if (this.ShowGroups)

    5669. 

  5669.                     this.ResizeLastGroup();

    5670. 

  5670.             }

    5671. 

  5671. 

    5672. 

  5672.             return false;

    5673. 

  5673.         }

    5674. 

  5674. 

    5675. 

  5675.         #endregion

    5676. 

  5676. 

    5677. 

  5677.         #region Column header clicking, column hiding and resizing

    5678. 

  5678. 

    5679. 

  5679.         /// <summary>

    5680. 

  5680.         /// The user has right clicked on the column headers. Do whatever is required

    5681. 

  5681.         /// </summary>

    5682. 

  5682.         /// <returns>Return true if this event has been handle</returns>

    5683. 

  5683.         protected virtual bool HandleHeaderRightClick(int columnIndex) {

    5684. 

  5684.             ColumnClickEventArgs eventArgs = new ColumnClickEventArgs(columnIndex);

    5685. 

  5685.             this.OnColumnRightClick(eventArgs);

    5686. 

  5686. 

    5687. 

  5687.             return this.ShowHeaderRightClickMenu(columnIndex, Cursor.Position);

    5688. 

  5688.         }

    5689. 

  5689. 

    5690. 

  5690.         /// <summary>

    5691. 

  5691.         /// Show a menu that is appropriate when the given column header is clicked.

    5692. 

  5692.         /// </summary>

    5693. 

  5693.         /// <param name="columnIndex">The index of the header that was clicked. This

    5694. 

  5694.         /// can be -1, indicating that the header was clicked outside of a column</param>

    5695. 

  5695.         /// <param name="pt">Where should the menu be shown</param>

    5696. 

  5696.         /// <returns>True if a menu was displayed</returns>

    5697. 

  5697.         protected virtual bool ShowHeaderRightClickMenu(int columnIndex, Point pt) {

    5698. 

  5698.             ToolStripDropDown m = this.MakeHeaderRightClickMenu(columnIndex);

    5699. 

  5699.             if (m.Items.Count > 0) {

    5700. 

  5700.                 m.Show(pt);

    5701. 

  5701.                 return true;

    5702. 

  5702.             }

    5703. 

  5703. 

    5704. 

  5704.             return false;

    5705. 

  5705.         }

    5706. 

  5706. 

    5707. 

  5707.         /// <summary>

    5708. 

  5708.         /// Create the menu that should be displayed when the user right clicks

    5709. 

  5709.         /// on the given column header.

    5710. 

  5710.         /// </summary>

    5711. 

  5711.         /// <param name="columnIndex">Index of the column that was right clicked.

    5712. 

  5712.         /// This can be negative, which indicates a click outside of any header.</param>

    5713. 

  5713.         /// <returns>The toolstrip that should be displayed</returns>

    5714. 

  5714.         protected virtual ToolStripDropDown MakeHeaderRightClickMenu(int columnIndex) {

    5715. 

  5715.             ToolStripDropDown m = new ContextMenuStrip();

    5716. 

  5716. 

    5717. 

  5717.             if (columnIndex >= 0 && this.UseFiltering && this.ShowFilterMenuOnRightClick)

    5718. 

  5718.                 m = this.MakeFilteringMenu(m, columnIndex);

    5719. 

  5719. 

    5720. 

  5720.             if (columnIndex >= 0 && this.ShowCommandMenuOnRightClick) 

    5721. 

  5721.                 m = this.MakeColumnCommandMenu(m, columnIndex);

    5722. 

  5722. 

    5723. 

  5723.             if (this.SelectColumnsOnRightClickBehaviour != ColumnSelectBehaviour.None) {

    5724. 

  5724.                 m = this.MakeColumnSelectMenu(m);

    5725. 

  5725.             }

    5726. 

  5726. 

    5727. 

  5727.             return m;

    5728. 

  5728.         }

    5729. 

  5729. 

    5730. 

  5730.         /// <summary>

    5731. 

  5731.         /// The user has right clicked on the column headers. Do whatever is required

    5732. 

  5732.         /// </summary>

    5733. 

  5733.         /// <returns>Return true if this event has been handle</returns>

    5734. 

  5734.         [Obsolete("Use HandleHeaderRightClick(int) instead")]

    5735. 

  5735.         protected virtual bool HandleHeaderRightClick() {

    5736. 

  5736.             return false;

    5737. 

  5737.         }

    5738. 

  5738. 

    5739. 

  5739.         /// <summary>

    5740. 

  5740.         /// Show a popup menu at the given point which will allow the user to choose which columns

    5741. 

  5741.         /// are visible on this listview

    5742. 

  5742.         /// </summary>

    5743. 

  5743.         /// <param name="pt">Where should the menu be placed</param>

    5744. 

  5744.         [Obsolete("Use ShowHeaderRightClickMenu instead")]

    5745. 

  5745.         protected virtual void ShowColumnSelectMenu(Point pt) {

    5746. 

  5746.             ToolStripDropDown m = this.MakeColumnSelectMenu(new ContextMenuStrip());

    5747. 

  5747.             m.Show(pt);

    5748. 

  5748.         }

    5749. 

  5749. 

    5750. 

  5750.         /// <summary>

    5751. 

  5751.         /// Show a popup menu at the given point which will allow the user to choose which columns

    5752. 

  5752.         /// are visible on this listview

    5753. 

  5753.         /// </summary>

    5754. 

  5754.         /// <param name="columnIndex"></param>

    5755. 

  5755.         /// <param name="pt">Where should the menu be placed</param>

    5756. 

  5756.         [Obsolete("Use ShowHeaderRightClickMenu instead")]

    5757. 

  5757.         protected virtual void ShowColumnCommandMenu(int columnIndex, Point pt) {

    5758. 

  5758.             ToolStripDropDown m = this.MakeColumnCommandMenu(new ContextMenuStrip(), columnIndex);

    5759. 

  5759.             if (this.SelectColumnsOnRightClick) {

    5760. 

  5760.                 if (m.Items.Count > 0)

    5761. 

  5761.                     m.Items.Add(new ToolStripSeparator());

    5762. 

  5762.                 this.MakeColumnSelectMenu(m);

    5763. 

  5763.             }

    5764. 

  5764.             m.Show(pt);

    5765. 

  5765.         }

    5766. 

  5766. 

    5767. 

  5767.         /// <summary>

    5768. 

  5768.         /// Gets or set the text to be used for the sorting ascending command

    5769. 

  5769.         /// </summary>

    5770. 

  5770.         [Category("Labels - ObjectListView"), DefaultValue("Sort ascending by '{0}'"), Localizable(true)]

    5771. 

  5771.         public string MenuLabelSortAscending {

    5772. 

  5772.             get { return this.menuLabelSortAscending; }

    5773. 

  5773.             set { this.menuLabelSortAscending = value; }

    5774. 

  5774.         }

    5775. 

  5775.         private string menuLabelSortAscending = "Sort ascending by '{0}'";

    5776. 

  5776. 

    5777. 

  5777.         /// <summary>

    5778. 

  5778.         /// 

    5779. 

  5779.         /// </summary>

    5780. 

  5780.         [Category("Labels - ObjectListView"), DefaultValue("Sort descending by '{0}'"), Localizable(true)]

    5781. 

  5781.         public string MenuLabelSortDescending {

    5782. 

  5782.             get { return this.menuLabelSortDescending; }

    5783. 

  5783.             set { this.menuLabelSortDescending = value; }

    5784. 

  5784.         }

    5785. 

  5785.         private string menuLabelSortDescending = "Sort descending by '{0}'";

    5786. 

  5786. 

    5787. 

  5787.         /// <summary>

    5788. 

  5788.         /// 

    5789. 

  5789.         /// </summary>

    5790. 

  5790.         [Category("Labels - ObjectListView"), DefaultValue("Group by '{0}'"), Localizable(true)]

    5791. 

  5791.         public string MenuLabelGroupBy {

    5792. 

  5792.             get { return this.menuLabelGroupBy; }

    5793. 

  5793.             set { this.menuLabelGroupBy = value; }

    5794. 

  5794.         }

    5795. 

  5795.         private string menuLabelGroupBy = "Group by '{0}'";

    5796. 

  5796. 

    5797. 

  5797.         /// <summary>

    5798. 

  5798.         /// 

    5799. 

  5799.         /// </summary>

    5800. 

  5800.         [Category("Labels - ObjectListView"), DefaultValue("Lock grouping on '{0}'"), Localizable(true)]

    5801. 

  5801.         public string MenuLabelLockGroupingOn {

    5802. 

  5802.             get { return this.menuLabelLockGroupingOn; }

    5803. 

  5803.             set { this.menuLabelLockGroupingOn = value; }

    5804. 

  5804.         }

    5805. 

  5805.         private string menuLabelLockGroupingOn = "Lock grouping on '{0}'";

    5806. 

  5806. 

    5807. 

  5807.         /// <summary>

    5808. 

  5808.         /// 

    5809. 

  5809.         /// </summary>

    5810. 

  5810.         [Category("Labels - ObjectListView"), DefaultValue("Unlock grouping from '{0}'"), Localizable(true)]

    5811. 

  5811.         public string MenuLabelUnlockGroupingOn {

    5812. 

  5812.             get { return this.menuLabelUnlockGroupingOn; }

    5813. 

  5813.             set { this.menuLabelUnlockGroupingOn = value; }

    5814. 

  5814.         }

    5815. 

  5815.         private string menuLabelUnlockGroupingOn = "Unlock grouping from '{0}'";

    5816. 

  5816. 

    5817. 

  5817.         /// <summary>

    5818. 

  5818.         /// 

    5819. 

  5819.         /// </summary>

    5820. 

  5820.         [Category("Labels - ObjectListView"), DefaultValue("Turn off groups"), Localizable(true)]

    5821. 

  5821.         public string MenuLabelTurnOffGroups {

    5822. 

  5822.             get { return this.menuLabelTurnOffGroups; }

    5823. 

  5823.             set { this.menuLabelTurnOffGroups = value; }

    5824. 

  5824.         }

    5825. 

  5825.         private string menuLabelTurnOffGroups = "Turn off groups";

    5826. 

  5826. 

    5827. 

  5827.         /// <summary>

    5828. 

  5828.         /// 

    5829. 

  5829.         /// </summary>

    5830. 

  5830.         [Category("Labels - ObjectListView"), DefaultValue("Unsort"), Localizable(true)]

    5831. 

  5831.         public string MenuLabelUnsort {

    5832. 

  5832.             get { return this.menuLabelUnsort; }

    5833. 

  5833.             set { this.menuLabelUnsort = value; }

    5834. 

  5834.         }

    5835. 

  5835.         private string menuLabelUnsort = "Unsort";

    5836. 

  5836. 

    5837. 

  5837.         /// <summary>

    5838. 

  5838.         /// 

    5839. 

  5839.         /// </summary>

    5840. 

  5840.         [Category("Labels - ObjectListView"), DefaultValue("Columns"), Localizable(true)]

    5841. 

  5841.         public string MenuLabelColumns {

    5842. 

  5842.             get { return this.menuLabelColumns; }

    5843. 

  5843.             set { this.menuLabelColumns = value; }

    5844. 

  5844.         }

    5845. 

  5845.         private string menuLabelColumns = "Columns";

    5846. 

  5846. 

    5847. 

  5847.         /// <summary>

    5848. 

  5848.         /// 

    5849. 

  5849.         /// </summary>

    5850. 

  5850.         [Category("Labels - ObjectListView"), DefaultValue("Select Columns..."), Localizable(true)]

    5851. 

  5851.         public string MenuLabelSelectColumns {

    5852. 

  5852.             get { return this.menuLabelSelectColumns; }

    5853. 

  5853.             set { this.menuLabelSelectColumns = value; }

    5854. 

  5854.         }

    5855. 

  5855.         private string menuLabelSelectColumns = "Select Columns...";

    5856. 

  5856. 

    5857. 

  5857.         /// <summary>

    5858. 

  5858.         /// Gets or sets the image that will be place next to the Sort Ascending command

    5859. 

  5859.         /// </summary>

    5860. 

  5860.         static public Bitmap SortAscendingImage = BrightIdeasSoftware.Properties.Resources.SortAscending;

    5861. 

  5861. 

    5862. 

  5862.         /// <summary>

    5863. 

  5863.         /// Gets or sets the image that will be placed next to the Sort Descending command

    5864. 

  5864.         /// </summary>

    5865. 

  5865.         static public Bitmap SortDescendingImage = BrightIdeasSoftware.Properties.Resources.SortDescending;

    5866. 

  5866. 

    5867. 

  5867.         /// <summary>

    5868. 

  5868.         /// Append the column selection menu items to the given menu strip.

    5869. 

  5869.         /// </summary>

    5870. 

  5870.         /// <param name="strip">The menu to which the items will be added.</param>

    5871. 

  5871.         /// <param name="columnIndex"></param>

    5872. 

  5872.         /// <returns>Return the menu to which the items were added</returns>

    5873. 

  5873.         public virtual ToolStripDropDown MakeColumnCommandMenu(ToolStripDropDown strip, int columnIndex) {

    5874. 

  5874.             OLVColumn column = this.GetColumn(columnIndex);

    5875. 

  5875.             if (column == null)

    5876. 

  5876.                 return strip;

    5877. 

  5877. 

    5878. 

  5878.             if (strip.Items.Count > 0)

    5879. 

  5879.                 strip.Items.Add(new ToolStripSeparator());

    5880. 

  5880. 

    5881. 

  5881.             string label = String.Format(this.MenuLabelSortAscending, column.Text);

    5882. 

  5882.             if (column.Sortable && !String.IsNullOrEmpty(label)) {

    5883. 

  5883.                 strip.Items.Add(label, ObjectListView.SortAscendingImage, (EventHandler)delegate(object sender, EventArgs args) {

    5884. 

  5884.                     this.Sort(column, SortOrder.Ascending);

    5885. 

  5885.                 });

    5886. 

  5886.             }

    5887. 

  5887.             label = String.Format(this.MenuLabelSortDescending, column.Text);

    5888. 

  5888.             if (column.Sortable && !String.IsNullOrEmpty(label)) {

    5889. 

  5889.                 strip.Items.Add(label, ObjectListView.SortDescendingImage, (EventHandler)delegate(object sender, EventArgs args) {

    5890. 

  5890.                     this.Sort(column, SortOrder.Descending);

    5891. 

  5891.                 });

    5892. 

  5892.             }

    5893. 

  5893.             if (this.CanShowGroups) {

    5894. 

  5894.                 label = String.Format(this.MenuLabelGroupBy, column.Text);

    5895. 

  5895.                 if (column.Groupable && !String.IsNullOrEmpty(label)) {

    5896. 

  5896.                     strip.Items.Add(label, null, (EventHandler)delegate(object sender, EventArgs args) {

    5897. 

  5897.                         this.ShowGroups = true;

    5898. 

  5898.                         this.PrimarySortColumn = column;

    5899. 

  5899.                         this.PrimarySortOrder = SortOrder.Ascending;

    5900. 

  5900.                         this.BuildList();

    5901. 

  5901.                     });

    5902. 

  5902.                 }

    5903. 

  5903.             }

    5904. 

  5904.             if (this.ShowGroups) {

    5905. 

  5905.                 if (this.AlwaysGroupByColumn == column) {

    5906. 

  5906.                     label = String.Format(this.MenuLabelUnlockGroupingOn, column.Text);

    5907. 

  5907.                     if (!String.IsNullOrEmpty(label)) {

    5908. 

  5908.                         strip.Items.Add(label, null, (EventHandler)delegate(object sender, EventArgs args) {

    5909. 

  5909.                             this.AlwaysGroupByColumn = null;

    5910. 

  5910.                             this.AlwaysGroupBySortOrder = SortOrder.Ascending;

    5911. 

  5911.                             this.BuildList();

    5912. 

  5912.                         });

    5913. 

  5913.                     }

    5914. 

  5914.                 } else {

    5915. 

  5915.                     label = String.Format(this.MenuLabelLockGroupingOn, column.Text);

    5916. 

  5916.                     if (column.Groupable && !String.IsNullOrEmpty(label)) {

    5917. 

  5917.                         strip.Items.Add(label, null, (EventHandler)delegate(object sender, EventArgs args) {

    5918. 

  5918.                             this.ShowGroups = true;

    5919. 

  5919.                             this.AlwaysGroupByColumn = column;

    5920. 

  5920.                             this.AlwaysGroupBySortOrder = SortOrder.Ascending;

    5921. 

  5921.                             this.BuildList();

    5922. 

  5922.                         });

    5923. 

  5923.                     }

    5924. 

  5924.                 }

    5925. 

  5925.                 label = String.Format(this.MenuLabelTurnOffGroups, column.Text);

    5926. 

  5926.                 if (!String.IsNullOrEmpty(label)) {

    5927. 

  5927.                     strip.Items.Add(label, null, (EventHandler)delegate(object sender, EventArgs args) {

    5928. 

  5928.                         this.ShowGroups = false;

    5929. 

  5929.                         this.BuildList();

    5930. 

  5930.                     });

    5931. 

  5931.                 }

    5932. 

  5932.             } else {

    5933. 

  5933.                 label = String.Format(this.MenuLabelUnsort, column.Text);

    5934. 

  5934.                 if (column.Sortable && !String.IsNullOrEmpty(label) && this.PrimarySortOrder != SortOrder.None) {

    5935. 

  5935.                     strip.Items.Add(label, null, (EventHandler)delegate(object sender, EventArgs args) {

    5936. 

  5936.                         this.Unsort();

    5937. 

  5937.                     });

    5938. 

  5938.                 }

    5939. 

  5939.             }

    5940. 

  5940. 

    5941. 

  5941.             return strip;

    5942. 

  5942.         }

    5943. 

  5943. 

    5944. 

  5944.         /// <summary>

    5945. 

  5945.         /// Append the column selection menu items to the given menu strip.

    5946. 

  5946.         /// </summary>

    5947. 

  5947.         /// <param name="strip">The menu to which the items will be added.</param>

    5948. 

  5948.         /// <returns>Return the menu to which the items were added</returns>

    5949. 

  5949.         public virtual ToolStripDropDown MakeColumnSelectMenu(ToolStripDropDown strip) {

    5950. 

  5950. 

    5951. 

  5951.             System.Diagnostics.Debug.Assert(this.SelectColumnsOnRightClickBehaviour != ColumnSelectBehaviour.None);

    5952. 

  5952. 

    5953. 

  5953.             // Append a separator if the menu isn't empty and the last item isn't already a separator

    5954. 

  5954.             if (strip.Items.Count > 0 && (!(strip.Items[strip.Items.Count-1] is ToolStripSeparator)))

    5955. 

  5955.                 strip.Items.Add(new ToolStripSeparator());

    5956. 

  5956. 

    5957. 

  5957.             if (this.AllColumns.Count > 0 && this.AllColumns[0].LastDisplayIndex == -1)

    5958. 

  5958.                 this.RememberDisplayIndicies();

    5959. 

  5959. 

    5960. 

  5960.             if (this.SelectColumnsOnRightClickBehaviour == ColumnSelectBehaviour.ModelDialog) {

    5961. 

  5961.                 strip.Items.Add(this.MenuLabelSelectColumns, null, delegate(object sender, EventArgs args) {

    5962. 

  5962.                     (new ColumnSelectionForm()).OpenOn(this);

    5963. 

  5963.                 });

    5964. 

  5964.             }

    5965. 

  5965. 

    5966. 

  5966.             if (this.SelectColumnsOnRightClickBehaviour == ColumnSelectBehaviour.Submenu) {

    5967. 

  5967.                 ToolStripMenuItem menu = new ToolStripMenuItem(this.MenuLabelColumns);

    5968. 

  5968.                 menu.DropDownItemClicked += new ToolStripItemClickedEventHandler(ColumnSelectMenu_ItemClicked);

    5969. 

  5969.                 strip.Items.Add(menu);

    5970. 

  5970.                 this.AddItemsToColumnSelectMenu(menu.DropDownItems);

    5971. 

  5971.             }

    5972. 

  5972. 

    5973. 

  5973.             if (this.SelectColumnsOnRightClickBehaviour == ColumnSelectBehaviour.InlineMenu) {

    5974. 

  5974.                 strip.ItemClicked += new ToolStripItemClickedEventHandler(ColumnSelectMenu_ItemClicked);

    5975. 

  5975.                 strip.Closing += new ToolStripDropDownClosingEventHandler(ColumnSelectMenu_Closing);

    5976. 

  5976.                 this.AddItemsToColumnSelectMenu(strip.Items);

    5977. 

  5977.             }

    5978. 

  5978. 

    5979. 

  5979.             return strip;

    5980. 

  5980.         }

    5981. 

  5981. 

    5982. 

  5982.         /// <summary>

    5983. 

  5983.         /// Create the menu items that will allow columns to be choosen and add them to the 

    5984. 

  5984.         /// given collection

    5985. 

  5985.         /// </summary>

    5986. 

  5986.         /// <param name="items"></param>

    5987. 

  5987.         protected void AddItemsToColumnSelectMenu(ToolStripItemCollection items) {

    5988. 

  5988. 

    5989. 

  5989.             // Sort columns by display order

    5990. 

  5990.             List<OLVColumn> columns = new List<OLVColumn>(this.AllColumns);

    5991. 

  5991.             columns.Sort(delegate(OLVColumn x, OLVColumn y) { return (x.LastDisplayIndex - y.LastDisplayIndex); });

    5992. 

  5992. 

    5993. 

  5993.             // Build menu from sorted columns

    5994. 

  5994.             foreach (OLVColumn col in columns) {

    5995. 

  5995.                 ToolStripMenuItem mi = new ToolStripMenuItem(col.Text);

    5996. 

  5996.                 mi.Checked = col.IsVisible;

    5997. 

  5997.                 mi.Tag = col;

    5998. 

  5998. 

    5999. 

  5999.                 // The 'Index' property returns -1 when the column is not visible, so if the

    6000. 

  6000.                 // column isn't visible we have to enable the item. Also the first column can't be turned off

    6001. 

  6001.                 mi.Enabled = !col.IsVisible || col.CanBeHidden;

    6002. 

  6002.                 items.Add(mi);

    6003. 

  6003.             }

    6004. 

  6004.         }

    6005. 

  6005. 

    6006. 

  6006.         private void ColumnSelectMenu_ItemClicked(object sender, ToolStripItemClickedEventArgs e) {

    6007. 

  6007.             this.contextMenuStaysOpen = false;

    6008. 

  6008.             ToolStripMenuItem menuItemClicked = (ToolStripMenuItem)e.ClickedItem;

    6009. 

  6009.             OLVColumn col = menuItemClicked.Tag as OLVColumn;

    6010. 

  6010.             if (col == null)

    6011. 

  6011.                 return;

    6012. 

  6012.             menuItemClicked.Checked = !menuItemClicked.Checked;

    6013. 

  6013.             col.IsVisible = menuItemClicked.Checked;

    6014. 

  6014.             this.contextMenuStaysOpen = this.SelectColumnsMenuStaysOpen;

    6015. 

  6015.             this.BeginInvoke(new MethodInvoker(this.RebuildColumns));

    6016. 

  6016.         }

    6017. 

  6017.         internal bool contextMenuStaysOpen;

    6018. 

  6018. 

    6019. 

  6019.         private void ColumnSelectMenu_Closing(object sender, ToolStripDropDownClosingEventArgs e) {

    6020. 

  6020.             e.Cancel = this.contextMenuStaysOpen && e.CloseReason == ToolStripDropDownCloseReason.ItemClicked;

    6021. 

  6021.             this.contextMenuStaysOpen = false;

    6022. 

  6022.         }

    6023. 

  6023. 

    6024. 

  6024.         /// <summary>

    6025. 

  6025.         /// Create a Filtering menu

    6026. 

  6026.         /// </summary>

    6027. 

  6027.         /// <param name="strip"></param>

    6028. 

  6028.         /// <param name="columnIndex"></param>

    6029. 

  6029.         /// <returns></returns>

    6030. 

  6030.         public virtual ToolStripDropDown MakeFilteringMenu(ToolStripDropDown strip, int columnIndex) {

    6031. 

  6031.             OLVColumn column = this.GetColumn(columnIndex);

    6032. 

  6032.             if (column == null)

    6033. 

  6033.                 return strip;

    6034. 

  6034. 

    6035. 

  6035.             FilterMenuBuilder strategy = this.FilterMenuBuildStrategy;

    6036. 

  6036.             if (strategy == null)

    6037. 

  6037.                 return strip;

    6038. 

  6038. 

    6039. 

  6039.             return strategy.MakeFilterMenu(strip, this, column);

    6040. 

  6040.         }

    6041. 

  6041. 

    6042. 

  6042.         /// <summary>

    6043. 

  6043.         /// Override the OnColumnReordered method to do what we want

    6044. 

  6044.         /// </summary>

    6045. 

  6045.         /// <param name="e"></param>

    6046. 

  6046.         protected override void OnColumnReordered(ColumnReorderedEventArgs e) {

    6047. 

  6047.             base.OnColumnReordered(e);

    6048. 

  6048. 

    6049. 

  6049.             // The internal logic of the .NET code behind a ENDDRAG event means that,

    6050. 

  6050.             // at this point, the DisplayIndex's of the columns are not yet as they are

    6051. 

  6051.             // going to be. So we have to invoke a method to run later that will remember

    6052. 

  6052.             // what the real DisplayIndex's are.

    6053. 

  6053.             this.BeginInvoke(new MethodInvoker(this.RememberDisplayIndicies));

    6054. 

  6054.         }

    6055. 

  6055. 

    6056. 

  6056.         private void RememberDisplayIndicies() {

    6057. 

  6057.             // Remember the display indexes so we can put them back at a later date

    6058. 

  6058.             foreach (OLVColumn x in this.AllColumns)

    6059. 

  6059.                 x.LastDisplayIndex = x.DisplayIndex;

    6060. 

  6060.         }

    6061. 

  6061. 

    6062. 

  6062.         /// <summary>

    6063. 

  6063.         /// When the column widths are changing, resize the space filling columns

    6064. 

  6064.         /// </summary>

    6065. 

  6065.         /// <param name="sender"></param>

    6066. 

  6066.         /// <param name="e"></param>

    6067. 

  6067.         protected virtual void HandleColumnWidthChanging(object sender, ColumnWidthChangingEventArgs e) {

    6068. 

  6068.             if (this.UpdateSpaceFillingColumnsWhenDraggingColumnDivider && !this.GetColumn(e.ColumnIndex).FillsFreeSpace) {

    6069. 

  6069.                 // If the width of a column is increasing, resize any space filling columns allowing the extra

    6070. 

  6070.                 // space that the new column width is going to consume

    6071. 

  6071.                 int oldWidth = this.GetColumn(e.ColumnIndex).Width;

    6072. 

  6072.                 if (e.NewWidth > oldWidth)

    6073. 

  6073.                     this.ResizeFreeSpaceFillingColumns(this.ClientSize.Width - (e.NewWidth - oldWidth));

    6074. 

  6074.                 else

    6075. 

  6075.                     this.ResizeFreeSpaceFillingColumns();

    6076. 

  6076.             }

    6077. 

  6077.         }

    6078. 

  6078. 

    6079. 

  6079.         /// <summary>

    6080. 

  6080.         /// When the column widths change, resize the space filling columns

    6081. 

  6081.         /// </summary>

    6082. 

  6082.         /// <param name="sender"></param>

    6083. 

  6083.         /// <param name="e"></param>

    6084. 

  6084.         protected virtual void HandleColumnWidthChanged(object sender, ColumnWidthChangedEventArgs e) {

    6085. 

  6085.             if (!this.GetColumn(e.ColumnIndex).FillsFreeSpace)

    6086. 

  6086.                 this.ResizeFreeSpaceFillingColumns();

    6087. 

  6087.         }

    6088. 

  6088. 

    6089. 

  6089.         /// <summary>

    6090. 

  6090.         /// When the size of the control changes, we have to resize our space filling columns.

    6091. 

  6091.         /// </summary>

    6092. 

  6092.         /// <param name="sender"></param>

    6093. 

  6093.         /// <param name="e"></param>

    6094. 

  6094.         protected virtual void HandleLayout(object sender, LayoutEventArgs e) {

    6095. 

  6095.             // We have to delay executing the recalculation of the columns, since virtual lists

    6096. 

  6096.             // get terribly confused if we resize the column widths during this event.

    6097. 

  6097.             if (!this.hasResizeColumnsHandler) {

    6098. 

  6098.                 this.hasResizeColumnsHandler = true;

    6099. 

  6099.                 Application.Idle += new EventHandler(HandleApplicationIdle_ResizeColumns);

    6100. 

  6100.             }

    6101. 

  6101.         }

    6102. 

  6102. 

    6103. 

  6103.         /// <summary>

    6104. 

  6104.         /// Resize our space filling columns so they fill any unoccupied width in the control

    6105. 

  6105.         /// </summary>

    6106. 

  6106.         protected virtual void ResizeFreeSpaceFillingColumns() {

    6107. 

  6107.             this.ResizeFreeSpaceFillingColumns(this.ClientSize.Width);

    6108. 

  6108.         }

    6109. 

  6109. 

    6110. 

  6110.         /// <summary>

    6111. 

  6111.         /// Resize our space filling columns so they fill any unoccupied width in the control

    6112. 

  6112.         /// </summary>

    6113. 

  6113.         protected virtual void ResizeFreeSpaceFillingColumns(int freeSpace) {

    6114. 

  6114.             // It's too confusing to dynamically resize columns at design time.

    6115. 

  6115.             if (this.DesignMode)

    6116. 

  6116.                 return;

    6117. 

  6117. 

    6118. 

  6118.             if (this.Frozen)

    6119. 

  6119.                 return;

    6120. 

  6120. 

    6121. 

  6121.             // Calculate the free space available

    6122. 

  6122.             int totalProportion = 0;

    6123. 

  6123.             List<OLVColumn> spaceFillingColumns = new List<OLVColumn>();

    6124. 

  6124.             for (int i = 0; i < this.Columns.Count; i++) {

    6125. 

  6125.                 OLVColumn col = this.GetColumn(i);

    6126. 

  6126.                 if (col.FillsFreeSpace) {

    6127. 

  6127.                     spaceFillingColumns.Add(col);

    6128. 

  6128.                     totalProportion += col.FreeSpaceProportion;

    6129. 

  6129.                 } else

    6130. 

  6130.                     freeSpace -= col.Width;

    6131. 

  6131.             }

    6132. 

  6132.             freeSpace = Math.Max(0, freeSpace);

    6133. 

  6133. 

    6134. 

  6134.             // Any space filling column that would hit it's Minimum or Maximum

    6135. 

  6135.             // width must be treated as a fixed column.

    6136. 

  6136.             foreach (OLVColumn col in spaceFillingColumns.ToArray()) {

    6137. 

  6137.                 int newWidth = (freeSpace * col.FreeSpaceProportion) / totalProportion;

    6138. 

  6138. 

    6139. 

  6139.                 if (col.MinimumWidth != -1 && newWidth < col.MinimumWidth)

    6140. 

  6140.                     newWidth = col.MinimumWidth;

    6141. 

  6141.                 else if (col.MaximumWidth != -1 && newWidth > col.MaximumWidth)

    6142. 

  6142.                     newWidth = col.MaximumWidth;

    6143. 

  6143.                 else

    6144. 

  6144.                     newWidth = 0;

    6145. 

  6145. 

    6146. 

  6146.                 if (newWidth > 0) {

    6147. 

  6147.                     col.Width = newWidth;

    6148. 

  6148.                     freeSpace -= newWidth;

    6149. 

  6149.                     totalProportion -= col.FreeSpaceProportion;

    6150. 

  6150.                     spaceFillingColumns.Remove(col);

    6151. 

  6151.                 }

    6152. 

  6152.             }

    6153. 

  6153. 

    6154. 

  6154.             // Distribute the free space between the columns

    6155. 

  6155.             foreach (OLVColumn col in spaceFillingColumns) {

    6156. 

  6156.                 col.Width = (freeSpace * col.FreeSpaceProportion) / totalProportion;

    6157. 

  6157.             }

    6158. 

  6158.         }

    6159. 

  6159. 

    6160. 

  6160.         #endregion

    6161. 

  6161. 

    6162. 

  6162.         #region Checkboxes

    6163. 

  6163. 

    6164. 

  6164.         /// <summary>

    6165. 

  6165.         /// Mark the given object as indeterminate check state

    6166. 

  6166.         /// </summary>

    6167. 

  6167.         /// <param name="modelObject">The model object to be marked indeterminate</param>

    6168. 

  6168.         public virtual void CheckIndeterminateObject(object modelObject) {

    6169. 

  6169.             this.SetObjectCheckedness(modelObject, CheckState.Indeterminate);

    6170. 

  6170.         }

    6171. 

  6171. 

    6172. 

  6172.         /// <summary>

    6173. 

  6173.         /// Mark the given object as checked in the list

    6174. 

  6174.         /// </summary>

    6175. 

  6175.         /// <param name="modelObject">The model object to be checked</param>

    6176. 

  6176.         public virtual void CheckObject(object modelObject) {

    6177. 

  6177.             this.SetObjectCheckedness(modelObject, CheckState.Checked);

    6178. 

  6178.         }

    6179. 

  6179. 

    6180. 

  6180.         /// <summary>

    6181. 

  6181.         /// Mark the given objects as checked in the list

    6182. 

  6182.         /// </summary>

    6183. 

  6183.         /// <param name="modelObjects">The model object to be checked</param>

    6184. 

  6184.         public virtual void CheckObjects(IEnumerable modelObjects) {

    6185. 

  6185.             foreach (object model in modelObjects)

    6186. 

  6186.                 this.CheckObject(model);

    6187. 

  6187.         }

    6188. 

  6188. 

    6189. 

  6189.         /// <summary>

    6190. 

  6190.         /// Put a check into the check box at the given cell

    6191. 

  6191.         /// </summary>

    6192. 

  6192.         /// <param name="rowObject"></param>

    6193. 

  6193.         /// <param name="column"></param>

    6194. 

  6194.         public virtual void CheckSubItem(object rowObject, OLVColumn column) {

    6195. 

  6195.             if (column == null || rowObject == null || !column.CheckBoxes)

    6196. 

  6196.                 return;

    6197. 

  6197. 

    6198. 

  6198.             column.PutCheckState(rowObject, CheckState.Checked);

    6199. 

  6199.             this.RefreshObject(rowObject);

    6200. 

  6200.         }

    6201. 

  6201. 

    6202. 

  6202.         /// <summary>

    6203. 

  6203.         /// Put an indeterminate check into the check box at the given cell

    6204. 

  6204.         /// </summary>

    6205. 

  6205.         /// <param name="rowObject"></param>

    6206. 

  6206.         /// <param name="column"></param>

    6207. 

  6207.         public virtual void CheckIndeterminateSubItem(object rowObject, OLVColumn column) {

    6208. 

  6208.             if (column == null || rowObject == null || !column.CheckBoxes)

    6209. 

  6209.                 return;

    6210. 

  6210. 

    6211. 

  6211.             column.PutCheckState(rowObject, CheckState.Indeterminate);

    6212. 

  6212.             this.RefreshObject(rowObject);

    6213. 

  6213.         }

    6214. 

  6214. 

    6215. 

  6215.         /// <summary>

    6216. 

  6216.         /// Return true of the given object is checked

    6217. 

  6217.         /// </summary>

    6218. 

  6218.         /// <param name="modelObject">The model object whose checkedness is returned</param>

    6219. 

  6219.         /// <returns>Is the given object checked?</returns>

    6220. 

  6220.         /// <remarks>If the given object is not in the list, this method returns false.</remarks>

    6221. 

  6221.         public virtual bool IsChecked(object modelObject) {

    6222. 

  6222.             OLVListItem olvi = this.ModelToItem(modelObject);

    6223. 

  6223.             if (olvi == null)

    6224. 

  6224.                 return false;

    6225. 

  6225.             else

    6226. 

  6226.                 return olvi.CheckState == CheckState.Checked;

    6227. 

  6227.         }

    6228. 

  6228. 

    6229. 

  6229.         /// <summary>

    6230. 

  6230.         /// Return true of the given object is indeterminately checked

    6231. 

  6231.         /// </summary>

    6232. 

  6232.         /// <param name="modelObject">The model object whose checkedness is returned</param>

    6233. 

  6233.         /// <returns>Is the given object indeterminately checked?</returns>

    6234. 

  6234.         /// <remarks>If the given object is not in the list, this method returns false.</remarks>

    6235. 

  6235.         public virtual bool IsCheckedIndeterminate(object modelObject) {

    6236. 

  6236.             OLVListItem olvi = this.ModelToItem(modelObject);

    6237. 

  6237.             if (olvi == null)

    6238. 

  6238.                 return false;

    6239. 

  6239.             else

    6240. 

  6240.                 return (olvi.CheckState == CheckState.Indeterminate);

    6241. 

  6241.         }

    6242. 

  6242. 

    6243. 

  6243.         /// <summary>

    6244. 

  6244.         /// Is there a check at the check box at the given cell

    6245. 

  6245.         /// </summary>

    6246. 

  6246.         /// <param name="rowObject"></param>

    6247. 

  6247.         /// <param name="column"></param>

    6248. 

  6248.         public virtual bool IsSubItemChecked(object rowObject, OLVColumn column) {

    6249. 

  6249.             if (column != null && rowObject != null && column.CheckBoxes)

    6250. 

  6250.                 return (column.GetCheckState(rowObject) == CheckState.Checked);

    6251. 

  6251.             else

    6252. 

  6252.                 return false;

    6253. 

  6253.         }

    6254. 

  6254. 

    6255. 

  6255.         /// <summary>

    6256. 

  6256.         /// Get the checkedness of an object from the model. Returning null means the

    6257. 

  6257.         /// model does not know and the value from the control will be used.

    6258. 

  6258.         /// </summary>

    6259. 

  6259.         /// <param name="modelObject"></param>

    6260. 

  6260.         /// <returns></returns>

    6261. 

  6261.         protected virtual CheckState? GetCheckState(Object modelObject) {

    6262. 

  6262.             if (this.CheckStateGetter == null)

    6263. 

  6263.                 return null;

    6264. 

  6264.             else

    6265. 

  6265.                 return this.CheckStateGetter(modelObject);

    6266. 

  6266.         }

    6267. 

  6267. 

    6268. 

  6268.         /// <summary>

    6269. 

  6269.         /// Record the change of checkstate for the given object in the model.

    6270. 

  6270.         /// This does not update the UI -- only the model

    6271. 

  6271.         /// </summary>

    6272. 

  6272.         /// <param name="modelObject"></param>

    6273. 

  6273.         /// <param name="state"></param>

    6274. 

  6274.         /// <returns>The check state that was recorded and that should be used to update

    6275. 

  6275.         /// the control.</returns>

    6276. 

  6276.         protected virtual CheckState PutCheckState(Object modelObject, CheckState state) {

    6277. 

  6277.             if (this.CheckStatePutter == null)

    6278. 

  6278.                 return state;

    6279. 

  6279.             else

    6280. 

  6280.                 return this.CheckStatePutter(modelObject, state);

    6281. 

  6281.         }

    6282. 

  6282. 

    6283. 

  6283.         /// <summary>

    6284. 

  6284.         /// Change the check state of the given object to be the given state.

    6285. 

  6285.         /// </summary>

    6286. 

  6286.         /// <remarks>

    6287. 

  6287.         /// If the given model object isn't in the list, we still try to remember

    6288. 

  6288.         /// its state, in case it is referenced in the future.</remarks>

    6289. 

  6289.         /// <param name="modelObject"></param>

    6290. 

  6290.         /// <param name="state"></param>

    6291. 

  6291.         protected virtual void SetObjectCheckedness(object modelObject, CheckState state) {

    6292. 

  6292.             OLVListItem olvi = this.ModelToItem(modelObject);

    6293. 

  6293. 

    6294. 

  6294.             // If we didn't find the given, we still try to record the check state.

    6295. 

  6295.             if (olvi == null) {

    6296. 

  6296.                 this.PutCheckState(modelObject, state);

    6297. 

  6297.                 return;

    6298. 

  6298.             }

    6299. 

  6299. 

    6300. 

  6300.             if (olvi.CheckState == state)

    6301. 

  6301.                 return;

    6302. 

  6302. 

    6303. 

  6303.             // Trigger checkbox changing event. We only need to do this for virtual

    6304. 

  6304.             // lists, since setting CheckState triggers these events for non-virtual lists

    6305. 

  6305.             ItemCheckEventArgs ice = new ItemCheckEventArgs(olvi.Index, state, olvi.CheckState);

    6306. 

  6306.             this.OnItemCheck(ice);

    6307. 

  6307.             if (ice.NewValue == olvi.CheckState)

    6308. 

  6308.                 return;

    6309. 

  6309. 

    6310. 

  6310.             olvi.CheckState = this.PutCheckState(modelObject, state);

    6311. 

  6311.             this.RefreshItem(olvi);

    6312. 

  6312. 

    6313. 

  6313.             // Trigger check changed event

    6314. 

  6314.             this.OnItemChecked(new ItemCheckedEventArgs(olvi));

    6315. 

  6315.         }

    6316. 

  6316. 

    6317. 

  6317.         /// <summary>

    6318. 

  6318.         /// Toggle the checkedness of the given object. A checked object becomes

    6319. 

  6319.         /// unchecked; an unchecked or indeterminate object becomes checked.

    6320. 

  6320.         /// If the list has tristate checkboxes, the order is:

    6321. 

  6321.         ///    unchecked -> checked -> indeterminate -> unchecked ...

    6322. 

  6322.         /// </summary>

    6323. 

  6323.         /// <param name="modelObject">The model object to be checked</param>

    6324. 

  6324.         public virtual void ToggleCheckObject(object modelObject) {

    6325. 

  6325.             OLVListItem olvi = this.ModelToItem(modelObject);

    6326. 

  6326.             if (olvi == null)

    6327. 

  6327.                 return;

    6328. 

  6328. 

    6329. 

  6329.             CheckState newState = CheckState.Checked;

    6330. 

  6330. 

    6331. 

  6331.             if (olvi.CheckState == CheckState.Checked) {

    6332. 

  6332.                 if (this.TriStateCheckBoxes)

    6333. 

  6333.                     newState = CheckState.Indeterminate;

    6334. 

  6334.                 else

    6335. 

  6335.                     newState = CheckState.Unchecked;

    6336. 

  6336.             } else {

    6337. 

  6337.                 if (olvi.CheckState == CheckState.Indeterminate && this.TriStateCheckBoxes)

    6338. 

  6338.                     newState = CheckState.Unchecked;

    6339. 

  6339.             }

    6340. 

  6340.             this.SetObjectCheckedness(modelObject, newState);

    6341. 

  6341.         }

    6342. 

  6342. 

    6343. 

  6343.         /// <summary>

    6344. 

  6344.         /// Toggle the check at the check box of the given cell

    6345. 

  6345.         /// </summary>

    6346. 

  6346.         /// <param name="rowObject"></param>

    6347. 

  6347.         /// <param name="column"></param>

    6348. 

  6348.         public virtual void ToggleSubItemCheckBox(object rowObject, OLVColumn column) {

    6349. 

  6349.             CheckState currentState = column.GetCheckState(rowObject);

    6350. 

  6350.             CheckState newState = CalculateToggledCheckState(column, currentState);

    6351. 

  6351. 

    6352. 

  6352.             SubItemCheckingEventArgs args = new SubItemCheckingEventArgs(column, this.ModelToItem(rowObject), column.Index, currentState, newState);

    6353. 

  6353.             this.OnSubItemChecking(args);

    6354. 

  6354.             if (args.Canceled)

    6355. 

  6355.                 return;

    6356. 

  6356. 

    6357. 

  6357.             switch (args.NewValue) {

    6358. 

  6358.                 case CheckState.Checked:

    6359. 

  6359.                     this.CheckSubItem(rowObject, column);

    6360. 

  6360.                     break;

    6361. 

  6361.                 case CheckState.Indeterminate:

    6362. 

  6362.                     this.CheckIndeterminateSubItem(rowObject, column);

    6363. 

  6363.                     break;

    6364. 

  6364.                 case CheckState.Unchecked:

    6365. 

  6365.                     this.UncheckSubItem(rowObject, column);

    6366. 

  6366.                     break;

    6367. 

  6367.             }

    6368. 

  6368.         }

    6369. 

  6369. 

    6370. 

  6370.         CheckState CalculateToggledCheckState(OLVColumn column, CheckState currentState) {

    6371. 

  6371.             switch (currentState) {

    6372. 

  6372.                 case CheckState.Checked: return column.TriStateCheckBoxes ? CheckState.Indeterminate : CheckState.Unchecked;

    6373. 

  6373.                 case CheckState.Indeterminate: return CheckState.Unchecked;

    6374. 

  6374.                 case CheckState.Unchecked: 

    6375. 

  6375.                 default: return CheckState.Checked;

    6376. 

  6376.             }

    6377. 

  6377.         }

    6378. 

  6378. 

    6379. 

  6379.         /// <summary>

    6380. 

  6380.         /// Mark the given object as unchecked in the list

    6381. 

  6381.         /// </summary>

    6382. 

  6382.         /// <param name="modelObject">The model object to be unchecked</param>

    6383. 

  6383.         public virtual void UncheckObject(object modelObject) {

    6384. 

  6384.             this.SetObjectCheckedness(modelObject, CheckState.Unchecked);

    6385. 

  6385.         }

    6386. 

  6386. 

    6387. 

  6387. 

    6388. 

  6388.         /// <summary>

    6389. 

  6389.         /// Mark the given objects as unchecked in the list

    6390. 

  6390.         /// </summary>

    6391. 

  6391.         /// <param name="modelObjects">The model object to be checked</param>

    6392. 

  6392.         public virtual void UncheckObjects(IEnumerable modelObjects) {

    6393. 

  6393.             foreach (object model in modelObjects)

    6394. 

  6394.                 this.UncheckObject(model);

    6395. 

  6395.         }

    6396. 

  6396. 

    6397. 

  6397.         /// <summary>

    6398. 

  6398.         /// Uncheck the check at the given cell

    6399. 

  6399.         /// </summary>

    6400. 

  6400.         /// <param name="rowObject"></param>

    6401. 

  6401.         /// <param name="column"></param>

    6402. 

  6402.         public virtual void UncheckSubItem(object rowObject, OLVColumn column) {

    6403. 

  6403.             if (column == null || rowObject == null || !column.CheckBoxes)

    6404. 

  6404.                 return;

    6405. 

  6405. 

    6406. 

  6406.             column.PutCheckState(rowObject, CheckState.Unchecked);

    6407. 

  6407.             this.RefreshObject(rowObject);

    6408. 

  6408.         }

    6409. 

  6409. 

    6410. 

  6410.         #endregion

    6411. 

  6411. 

    6412. 

  6412.         #region OLV accessing

    6413. 

  6413. 

    6414. 

  6414.         /// <summary>

    6415. 

  6415.         /// Return the column at the given index

    6416. 

  6416.         /// </summary>

    6417. 

  6417.         /// <param name="index">Index of the column to be returned</param>

    6418. 

  6418.         /// <returns>An OLVColumn</returns>

    6419. 

  6419.         public virtual OLVColumn GetColumn(int index) {

    6420. 

  6420.             return (OLVColumn)this.Columns[index];

    6421. 

  6421.         }

    6422. 

  6422. 

    6423. 

  6423.         /// <summary>

    6424. 

  6424.         /// Return the column at the given title.

    6425. 

  6425.         /// </summary>

    6426. 

  6426.         /// <param name="name">Name of the column to be returned</param>

    6427. 

  6427.         /// <returns>An OLVColumn</returns>

    6428. 

  6428.         public virtual OLVColumn GetColumn(string name) {

    6429. 

  6429.             foreach (ColumnHeader column in this.Columns) {

    6430. 

  6430.                 if (column.Text == name)

    6431. 

  6431.                     return (OLVColumn)column;

    6432. 

  6432.             }

    6433. 

  6433.             return null;

    6434. 

  6434.         }

    6435. 

  6435. 

    6436. 

  6436.         /// <summary>

    6437. 

  6437.         /// Return a collection of columns that are visible to the given view.

    6438. 

  6438.         /// Only Tile and Details have columns; all other views have 0 columns.

    6439. 

  6439.         /// </summary>

    6440. 

  6440.         /// <param name="view">Which view are the columns being calculate for?</param>

    6441. 

  6441.         /// <returns>A list of columns</returns>

    6442. 

  6442.         public virtual List<OLVColumn> GetFilteredColumns(View view) {

    6443. 

  6443.             // For both detail and tile view, the first column must be included. Normally, we would

    6444. 

  6444.             // use the ColumnHeader.Index property, but if the header is not currently part of a ListView

    6445. 

  6445.             // that property returns -1. So, we track the index of

    6446. 

  6446.             // the column header, and always include the first header.

    6447. 

  6447. 

    6448. 

  6448.             switch (view) {

    6449. 

  6449.                 case View.Details:

    6450. 

  6450.                 case View.Tile:

    6451. 

  6451.                     int index = 0;

    6452. 

  6452.                     return this.AllColumns.FindAll(delegate(OLVColumn x) {

    6453. 

  6453.                         return (index++ == 0) || x.IsVisible;

    6454. 

  6454.                     });

    6455. 

  6455.                 //return this.AllColumns.FindAll(delegate(OLVColumn x) { return (index++ == 0) || x.IsTileViewColumn; });

    6456. 

  6456.                 default:

    6457. 

  6457.                     return new List<OLVColumn>();

    6458. 

  6458.             }

    6459. 

  6459.         }

    6460. 

  6460. 

    6461. 

  6461.         /// <summary>

    6462. 

  6462.         /// Return the number of items in the list

    6463. 

  6463.         /// </summary>

    6464. 

  6464.         /// <returns>the number of items in the list</returns>

    6465. 

  6465.         public virtual int GetItemCount() {

    6466. 

  6466.             return this.Items.Count;

    6467. 

  6467.         }

    6468. 

  6468. 

    6469. 

  6469.         /// <summary>

    6470. 

  6470.         /// Return the item at the given index

    6471. 

  6471.         /// </summary>

    6472. 

  6472.         /// <param name="index">Index of the item to be returned</param>

    6473. 

  6473.         /// <returns>An OLVListItem</returns>

    6474. 

  6474.         public virtual OLVListItem GetItem(int index) {

    6475. 

  6475.             if (index >= 0 && index < this.GetItemCount())

    6476. 

  6476.                 return (OLVListItem)this.Items[index];

    6477. 

  6477.             else

    6478. 

  6478.                 return null;

    6479. 

  6479.         }

    6480. 

  6480. 

    6481. 

  6481.         /// <summary>

    6482. 

  6482.         /// Return the model object at the given index

    6483. 

  6483.         /// </summary>

    6484. 

  6484.         /// <param name="index">Index of the model object to be returned</param>

    6485. 

  6485.         /// <returns>A model object</returns>

    6486. 

  6486.         public virtual object GetModelObject(int index) {

    6487. 

  6487.             OLVListItem item = this.GetItem(index);

    6488. 

  6488.             if (item == null)

    6489. 

  6489.                 return null;

    6490. 

  6490.             else

    6491. 

  6491.                 return item.RowObject;

    6492. 

  6492.         }

    6493. 

  6493. 

    6494. 

  6494.         /// <summary>

    6495. 

  6495.         /// Find the item and column that are under the given co-ords

    6496. 

  6496.         /// </summary>

    6497. 

  6497.         /// <param name="x">X co-ord</param>

    6498. 

  6498.         /// <param name="y">Y co-ord</param>

    6499. 

  6499.         /// <param name="selectedColumn">The column under the given point</param>

    6500. 

  6500.         /// <returns>The item under the given point. Can be null.</returns>

    6501. 

  6501.         public virtual OLVListItem GetItemAt(int x, int y, out OLVColumn selectedColumn) {

    6502. 

  6502.             selectedColumn = null;

    6503. 

  6503.             ListViewHitTestInfo info = this.HitTest(x, y);

    6504. 

  6504.             if (info.Item == null)

    6505. 

  6505.                 return null;

    6506. 

  6506. 

    6507. 

  6507.             if (info.SubItem != null) {

    6508. 

  6508.                 int subItemIndex = info.Item.SubItems.IndexOf(info.SubItem);

    6509. 

  6509.                 selectedColumn = this.GetColumn(subItemIndex);

    6510. 

  6510.             }

    6511. 

  6511. 

    6512. 

  6512.             return (OLVListItem)info.Item;

    6513. 

  6513.         }

    6514. 

  6514. 

    6515. 

  6515.         /// <summary>

    6516. 

  6516.         /// Return the sub item at the given index/column

    6517. 

  6517.         /// </summary>

    6518. 

  6518.         /// <param name="index">Index of the item to be returned</param>

    6519. 

  6519.         /// <param name="columnIndex">Index of the subitem to be returned</param>

    6520. 

  6520.         /// <returns>An OLVListSubItem</returns>

    6521. 

  6521.         public virtual OLVListSubItem GetSubItem(int index, int columnIndex) {

    6522. 

  6522.             OLVListItem olvi = this.GetItem(index);

    6523. 

  6523.             if (olvi == null)

    6524. 

  6524.                 return null;

    6525. 

  6525.             else

    6526. 

  6526.                 return olvi.GetSubItem(columnIndex);

    6527. 

  6527.         }

    6528. 

  6528. 

    6529. 

  6529.         #endregion

    6530. 

  6530. 

    6531. 

  6531.         #region Object manipulation

    6532. 

  6532. 

    6533. 

  6533.         /// <summary>

    6534. 

  6534.         /// Ensure that the given model object is visible

    6535. 

  6535.         /// </summary>

    6536. 

  6536.         /// <param name="modelObject">The model object to be revealed</param>

    6537. 

  6537.         public virtual void EnsureModelVisible(Object modelObject) {

    6538. 

  6538.             int index = this.IndexOf(modelObject);

    6539. 

  6539.             if (index >= 0)

    6540. 

  6540.                 this.EnsureVisible(index);

    6541. 

  6541.         }

    6542. 

  6542. 

    6543. 

  6543.         /// <summary>

    6544. 

  6544.         /// Return the model object of the row that is selected or null if there is no selection or more than one selection

    6545. 

  6545.         /// </summary>

    6546. 

  6546.         /// <returns>Model object or null</returns>

    6547. 

  6547.         [Obsolete("Use SelectedObject property instead of this method")]

    6548. 

  6548.         public virtual object GetSelectedObject() {

    6549. 

  6549.             return this.SelectedObject;

    6550. 

  6550.         }

    6551. 

  6551. 

    6552. 

  6552.         /// <summary>

    6553. 

  6553.         /// Return the model objects of the rows that are selected or an empty collection if there is no selection

    6554. 

  6554.         /// </summary>

    6555. 

  6555.         /// <returns>ArrayList</returns>

    6556. 

  6556.         [Obsolete("Use SelectedObjects property instead of this method")]

    6557. 

  6557.         public virtual ArrayList GetSelectedObjects() {

    6558. 

  6558.             return ObjectListView.EnumerableToArray(this.SelectedObjects, false);

    6559. 

  6559.         }

    6560. 

  6560. 

    6561. 

  6561.         /// <summary>

    6562. 

  6562.         /// Return the model object of the row that is checked or null if no row is checked

    6563. 

  6563.         /// or more than one row is checked

    6564. 

  6564.         /// </summary>

    6565. 

  6565.         /// <returns>Model object or null</returns>

    6566. 

  6566.         /// <remarks>Use CheckedObject property instead of this method</remarks>

    6567. 

  6567.         [Obsolete("Use CheckedObject property instead of this method")]

    6568. 

  6568.         public virtual object GetCheckedObject() {

    6569. 

  6569.             return this.CheckedObject;

    6570. 

  6570.         }

    6571. 

  6571. 

    6572. 

  6572.         /// <summary>

    6573. 

  6573.         /// Get the collection of model objects that are checked.

    6574. 

  6574.         /// </summary>

    6575. 

  6575.         /// <remarks>Use CheckedObjects property instead of this method</remarks>

    6576. 

  6576.         [Obsolete("Use CheckedObjects property instead of this method")]

    6577. 

  6577.         public virtual ArrayList GetCheckedObjects() {

    6578. 

  6578.             return ObjectListView.EnumerableToArray(this.CheckedObjects, false);

    6579. 

  6579.         }

    6580. 

  6580. 

    6581. 

  6581.         /// <summary>

    6582. 

  6582.         /// Find the given model object within the listview and return its index

    6583. 

  6583.         /// </summary>

    6584. 

  6584.         /// <param name="modelObject">The model object to be found</param>

    6585. 

  6585.         /// <returns>The index of the object. -1 means the object was not present</returns>

    6586. 

  6586.         public virtual int IndexOf(Object modelObject) {

    6587. 

  6587.             for (int i = 0; i < this.GetItemCount(); i++) {

    6588. 

  6588.                 if (this.GetModelObject(i).Equals(modelObject))

    6589. 

  6589.                     return i;

    6590. 

  6590.             }

    6591. 

  6591.             return -1;

    6592. 

  6592.         }

    6593. 

  6593. 

    6594. 

  6594.         /// <summary>

    6595. 

  6595.         /// Update the ListViewItem with the data from its associated model.

    6596. 

  6596.         /// </summary>

    6597. 

  6597.         /// <remarks>This method does not resort or regroup the view. It simply updates

    6598. 

  6598.         /// the displayed data of the given item</remarks>

    6599. 

  6599.         public virtual void RefreshItem(OLVListItem olvi) {

    6600. 

  6600.             olvi.UseItemStyleForSubItems = true;

    6601. 

  6601.             olvi.SubItems.Clear();

    6602. 

  6602.             this.FillInValues(olvi, olvi.RowObject);

    6603. 

  6603.             this.PostProcessOneRow(olvi.Index, this.GetItemIndexInDisplayOrder(olvi), olvi);

    6604. 

  6604.         }

    6605. 

  6605. 

    6606. 

  6606.         /// <summary>

    6607. 

  6607.         /// Update the rows that are showing the given objects

    6608. 

  6608.         /// </summary>

    6609. 

  6609.         /// <remarks>This method does not resort or regroup the view.</remarks>

    6610. 

  6610.         public virtual void RefreshObject(object modelObject) {

    6611. 

  6611.             this.RefreshObjects(new object[] { modelObject });

    6612. 

  6612.         }

    6613. 

  6613. 

    6614. 

  6614.         /// <summary>

    6615. 

  6615.         /// Update the rows that are showing the given objects

    6616. 

  6616.         /// </summary>

    6617. 

  6617.         /// <remarks>

    6618. 

  6618.         /// <para>This method does not resort or regroup the view.</para>

    6619. 

  6619.         /// <para>This method can safely be called from background threads.</para>

    6620. 

  6620.         /// </remarks>

    6621. 

  6621.         public virtual void RefreshObjects(IList modelObjects) {

    6622. 

  6622.             if (this.InvokeRequired) {

    6623. 

  6623.                 this.Invoke((MethodInvoker)delegate { this.RefreshObjects(modelObjects); });

    6624. 

  6624.                 return;

    6625. 

  6625.             }

    6626. 

  6626.             foreach (object modelObject in modelObjects) {

    6627. 

  6627.                 OLVListItem olvi = this.ModelToItem(modelObject);

    6628. 

  6628.                 if (olvi != null)

    6629. 

  6629.                     this.RefreshItem(olvi);

    6630. 

  6630.             }

    6631. 

  6631.         }

    6632. 

  6632. 

    6633. 

  6633.         /// <summary>

    6634. 

  6634.         /// Update the rows that are selected

    6635. 

  6635.         /// </summary>

    6636. 

  6636.         /// <remarks>This method does not resort or regroup the view.</remarks>

    6637. 

  6637.         public virtual void RefreshSelectedObjects() {

    6638. 

  6638.             foreach (ListViewItem lvi in this.SelectedItems)

    6639. 

  6639.                 this.RefreshItem((OLVListItem)lvi);

    6640. 

  6640.         }

    6641. 

  6641. 

    6642. 

  6642.         /// <summary>

    6643. 

  6643.         /// Scroll the listview so that the given group is at the top.

    6644. 

  6644.         /// </summary>

    6645. 

  6645.         /// <param name="lvg">The group to be revealed</param>

    6646. 

  6646.         /// <remarks><para>

    6647. 

  6647.         /// If the group is already visible, the list will still be scrolled to move

    6648. 

  6648.         /// the group to the top, if that is possible.

    6649. 

  6649.         /// </para>

    6650. 

  6650.         /// <para>This only works when the list is showing groups (obviously)</para>

    6651. 

  6651.         /// </remarks>

    6652. 

  6652.         public virtual void EnsureGroupVisible(ListViewGroup lvg) {

    6653. 

  6653.             if (!this.ShowGroups || lvg == null)

    6654. 

  6654.                 return;

    6655. 

  6655. 

    6656. 

  6656.             int groupIndex = this.Groups.IndexOf(lvg);

    6657. 

  6657.             if (groupIndex <= 0) {

    6658. 

  6658.                 // There is no easy way to scroll back to the beginning of the list

    6659. 

  6659.                 int delta = 0 - NativeMethods.GetScrollPosition(this, false);

    6660. 

  6660.                 NativeMethods.Scroll(this, 0, delta);

    6661. 

  6661.             } else {

    6662. 

  6662.                 // Find the display rectangle of the last item in the previous group

    6663. 

  6663.                 ListViewGroup previousGroup = this.Groups[groupIndex - 1];

    6664. 

  6664.                 ListViewItem lastItemInGroup = previousGroup.Items[previousGroup.Items.Count - 1];

    6665. 

  6665.                 Rectangle r = this.GetItemRect(lastItemInGroup.Index);

    6666. 

  6666. 

    6667. 

  6667.                 // Scroll so that the last item of the previous group is just out of sight,

    6668. 

  6668.                 // which will make the desired group header visible.

    6669. 

  6669.                 int delta = r.Y + r.Height / 2;

    6670. 

  6670.                 NativeMethods.Scroll(this, 0, delta);

    6671. 

  6671.             }

    6672. 

  6672.         }

    6673. 

  6673. 

    6674. 

  6674.         /// <summary>

    6675. 

  6675.         /// Select the row that is displaying the given model object, in addition to any current selection.

    6676. 

  6676.         /// </summary>

    6677. 

  6677.         /// <param name="modelObject">The object to be selected</param>

    6678. 

  6678.         /// <remarks>Use the <see cref="SelectedObject"/> property to deselect all other rows</remarks>

    6679. 

  6679.         public virtual void SelectObject(object modelObject) {

    6680. 

  6680.             this.SelectObject(modelObject, false);

    6681. 

  6681.         }

    6682. 

  6682. 

    6683. 

  6683.         /// <summary>

    6684. 

  6684.         /// Select the row that is displaying the given model object, in addition to any current selection.

    6685. 

  6685.         /// </summary>

    6686. 

  6686.         /// <param name="modelObject">The object to be selected</param>

    6687. 

  6687.         /// <param name="setFocus">Should the object be focused as well?</param>

    6688. 

  6688.         /// <remarks>Use the <see cref="SelectedObject"/> property to deselect all other rows</remarks>

    6689. 

  6689.         public virtual void SelectObject(object modelObject, bool setFocus) {

    6690. 

  6690.             OLVListItem olvi = this.ModelToItem(modelObject);

    6691. 

  6691.             if (olvi != null) {

    6692. 

  6692.                 olvi.Selected = true;

    6693. 

  6693.                 if (setFocus)

    6694. 

  6694.                     olvi.Focused = true;

    6695. 

  6695.             }

    6696. 

  6696.         }

    6697. 

  6697. 

    6698. 

  6698.         /// <summary>

    6699. 

  6699.         /// Select the rows that is displaying any of the given model object. All other rows are deselected.

    6700. 

  6700.         /// </summary>

    6701. 

  6701.         /// <param name="modelObjects">A collection of model objects</param>

    6702. 

  6702.         public virtual void SelectObjects(IList modelObjects) {

    6703. 

  6703.             this.SelectedIndices.Clear();

    6704. 

  6704. 

    6705. 

  6705.             if (modelObjects == null)

    6706. 

  6706.                 return;

    6707. 

  6707. 

    6708. 

  6708.             foreach (object modelObject in modelObjects) {

    6709. 

  6709.                 OLVListItem olvi = this.ModelToItem(modelObject);

    6710. 

  6710.                 if (olvi != null)

    6711. 

  6711.                     olvi.Selected = true;

    6712. 

  6712.             }

    6713. 

  6713.         }

    6714. 

  6714. 

    6715. 

  6715.         #endregion

    6716. 

  6716. 

    6717. 

  6717.         #region Freezing

    6718. 

  6718. 

    6719. 

  6719.         /// <summary>

    6720. 

  6720.         /// Freeze the listview so that it no longer updates itself.

    6721. 

  6721.         /// </summary>

    6722. 

  6722.         /// <remarks>Freeze()/Unfreeze() calls nest correctly</remarks>

    6723. 

  6723.         public virtual void Freeze() {

    6724. 

  6724.             freezeCount++;

    6725. 

  6725.             this.OnFreezing(new FreezeEventArgs(freezeCount));

    6726. 

  6726.         }

    6727. 

  6727. 

    6728. 

  6728.         /// <summary>

    6729. 

  6729.         /// Unfreeze the listview. If this call is the outermost Unfreeze(),

    6730. 

  6730.         /// the contents of the listview will be rebuilt.

    6731. 

  6731.         /// </summary>

    6732. 

  6732.         /// <remarks>Freeze()/Unfreeze() calls nest correctly</remarks>

    6733. 

  6733.         public virtual void Unfreeze() {

    6734. 

  6734.             if (freezeCount <= 0)

    6735. 

  6735.                 return;

    6736. 

  6736. 

    6737. 

  6737.             freezeCount--;

    6738. 

  6738.             if (freezeCount == 0)

    6739. 

  6739.                 DoUnfreeze();

    6740. 

  6740. 

    6741. 

  6741.             this.OnFreezing(new FreezeEventArgs(freezeCount));

    6742. 

  6742.         }

    6743. 

  6743. 

    6744. 

  6744.         /// <summary>

    6745. 

  6745.         /// Do the actual work required when the listview is unfrozen

    6746. 

  6746.         /// </summary>

    6747. 

  6747.         protected virtual void DoUnfreeze() {

    6748. 

  6748.             this.ResizeFreeSpaceFillingColumns();

    6749. 

  6749.             this.BuildList();

    6750. 

  6750.         }

    6751. 

  6751. 

    6752. 

  6752.         #endregion

    6753. 

  6753. 

    6754. 

  6754.         #region Column sorting

    6755. 

  6755. 

    6756. 

  6756.         /// <summary>

    6757. 

  6757.         /// Sort the items by the last sort column and order

    6758. 

  6758.         /// </summary>

    6759. 

  6759.         new public void Sort() {

    6760. 

  6760.             this.Sort(this.LastSortColumn, this.LastSortOrder);

    6761. 

  6761.         }

    6762. 

  6762. 

    6763. 

  6763.         /// <summary>

    6764. 

  6764.         /// Sort the items in the list view by the values in the given column and the last sort order

    6765. 

  6765.         /// </summary>

    6766. 

  6766.         /// <param name="columnToSortName">The name of the column whose values will be used for the sorting</param>

    6767. 

  6767.         public virtual void Sort(string columnToSortName) {

    6768. 

  6768.             this.Sort(this.GetColumn(columnToSortName), this.LastSortOrder);

    6769. 

  6769.         }

    6770. 

  6770. 

    6771. 

  6771.         /// <summary>

    6772. 

  6772.         /// Sort the items in the list view by the values in the given column and the last sort order

    6773. 

  6773.         /// </summary>

    6774. 

  6774.         /// <param name="columnToSortIndex">The index of the column whose values will be used for the sorting</param>

    6775. 

  6775.         public virtual void Sort(int columnToSortIndex) {

    6776. 

  6776.             if (columnToSortIndex >= 0 && columnToSortIndex < this.Columns.Count)

    6777. 

  6777.                 this.Sort(this.GetColumn(columnToSortIndex), this.LastSortOrder);

    6778. 

  6778.         }

    6779. 

  6779. 

    6780. 

  6780.         /// <summary>

    6781. 

  6781.         /// Sort the items in the list view by the values in the given column and the last sort order

    6782. 

  6782.         /// </summary>

    6783. 

  6783.         /// <param name="columnToSort">The column whose values will be used for the sorting</param>

    6784. 

  6784.         public virtual void Sort(OLVColumn columnToSort) {

    6785. 

  6785.             if (this.InvokeRequired) {

    6786. 

  6786.                 this.Invoke((MethodInvoker)delegate { this.Sort(columnToSort); });

    6787. 

  6787.             } else {

    6788. 

  6788.                 this.Sort(columnToSort, this.LastSortOrder);

    6789. 

  6789.             }

    6790. 

  6790.         }

    6791. 

  6791. 

    6792. 

  6792.         /// <summary>

    6793. 

  6793.         /// Sort the items in the list view by the values in the given column and by the given order.

    6794. 

  6794.         /// </summary>

    6795. 

  6795.         /// <param name="columnToSort">The column whose values will be used for the sorting.

    6796. 

  6796.         /// If null, the first column will be used.</param>

    6797. 

  6797.         /// <param name="order">The ordering to be used for sorting. If this is None,

    6798. 

  6798.         /// this.Sorting and then SortOrder.Ascending will be used</param>

    6799. 

  6799.         /// <remarks>If ShowGroups is true, the rows will be grouped by the given column.

    6800. 

  6800.         /// If AlwaysGroupsByColumn is not null, the rows will be grouped by that column,

    6801. 

  6801.         /// and the rows within each group will be sorted by the given column.</remarks>

    6802. 

  6802.         public virtual void Sort(OLVColumn columnToSort, SortOrder order) {

    6803. 

  6803.             if (this.InvokeRequired) {

    6804. 

  6804.                 this.Invoke((MethodInvoker)delegate { this.Sort(columnToSort, order); });

    6805. 

  6805.             } else {

    6806. 

  6806.                 this.DoSort(columnToSort, order);

    6807. 

  6807.                 this.PostProcessRows();

    6808. 

  6808.             }

    6809. 

  6809.         }

    6810. 

  6810. 

    6811. 

  6811.         private void DoSort(OLVColumn columnToSort, SortOrder order) {

    6812. 

  6812.             // Sanity checks

    6813. 

  6813.             if (this.GetItemCount() == 0 || this.Columns.Count == 0)

    6814. 

  6814.                 return;

    6815. 

  6815. 

    6816. 

  6816.             // Fill in default values, if the parameters don't make sense

    6817. 

  6817.             if (this.ShowGroups) {

    6818. 

  6818.                 columnToSort = columnToSort ?? this.GetColumn(0);

    6819. 

  6819.                 if (order == SortOrder.None) {

    6820. 

  6820.                     order = this.Sorting;

    6821. 

  6821.                     if (order == SortOrder.None)

    6822. 

  6822.                         order = SortOrder.Ascending;

    6823. 

  6823.                 }

    6824. 

  6824.             }

    6825. 

  6825. 

    6826. 

  6826.             // Give the world a chance to fiddle with or completely avoid the sorting process

    6827. 

  6827.             BeforeSortingEventArgs args = this.BuildBeforeSortingEventArgs(columnToSort, order);

    6828. 

  6828.             this.OnBeforeSorting(args);

    6829. 

  6829.             if (args.Canceled)

    6830. 

  6830.                 return;

    6831. 

  6831. 

    6832. 

  6832.             // Virtual lists don't preserve selection, so we have to do it specifically

    6833. 

  6833.             // THINK: Do we need to preserve focus too?

    6834. 

  6834.             IList selection = new ArrayList();

    6835. 

  6835.             if (this.VirtualMode)

    6836. 

  6836.                 selection = this.SelectedObjects;

    6837. 

  6837. 

    6838. 

  6838.             this.ClearHotItem();

    6839. 

  6839. 

    6840. 

  6840.             // Finally, do the work of sorting, unless an event handler has already done the sorting for us

    6841. 

  6841.             if (!args.Handled) {

    6842. 

  6842.                 // Sanity checks

    6843. 

  6843.                 if (args.ColumnToSort != null && args.SortOrder != SortOrder.None) {

    6844. 

  6844.                     if (this.ShowGroups)

    6845. 

  6845.                         this.BuildGroups(args.ColumnToGroupBy, args.GroupByOrder, args.ColumnToSort, args.SortOrder,

    6846. 

  6846.                             args.SecondaryColumnToSort, args.SecondarySortOrder);

    6847. 

  6847.                     else if (this.CustomSorter != null)

    6848. 

  6848.                         this.CustomSorter(columnToSort, order);

    6849. 

  6849.                     else

    6850. 

  6850.                         this.ListViewItemSorter = new ColumnComparer(args.ColumnToSort, args.SortOrder,

    6851. 

  6851.                             args.SecondaryColumnToSort, args.SecondarySortOrder);

    6852. 

  6852.                 }

    6853. 

  6853.             }

    6854. 

  6854. 

    6855. 

  6855.             if (this.ShowSortIndicators)

    6856. 

  6856.                 this.ShowSortIndicator(args.ColumnToSort, args.SortOrder);

    6857. 

  6857. 

    6858. 

  6858.             this.LastSortColumn = args.ColumnToSort;

    6859. 

  6859.             this.LastSortOrder = args.SortOrder;

    6860. 

  6860. 

    6861. 

  6861.             if (selection.Count > 0)

    6862. 

  6862.                 this.SelectedObjects = selection;

    6863. 

  6863. 

    6864. 

  6864.             this.RefreshHotItem();

    6865. 

  6865. 

    6866. 

  6866.             this.OnAfterSorting(new AfterSortingEventArgs(args));

    6867. 

  6867.         }

    6868. 

  6868. 

    6869. 

  6869.         /// <summary>

    6870. 

  6870.         /// Put a sort indicator next to the text of the sort column

    6871. 

  6871.         /// </summary>

    6872. 

  6872.         public virtual void ShowSortIndicator() {

    6873. 

  6873.             if (this.ShowSortIndicators && this.LastSortOrder != SortOrder.None)

    6874. 

  6874.                 this.ShowSortIndicator(this.LastSortColumn, this.LastSortOrder);

    6875. 

  6875.         }

    6876. 

  6876. 

    6877. 

  6877.         /// <summary>

    6878. 

  6878.         /// Put a sort indicator next to the text of the given given column

    6879. 

  6879.         /// </summary>

    6880. 

  6880.         /// <param name="columnToSort">The column to be marked</param>

    6881. 

  6881.         /// <param name="sortOrder">The sort order in effect on that column</param>

    6882. 

  6882.         protected virtual void ShowSortIndicator(OLVColumn columnToSort, SortOrder sortOrder) {

    6883. 

  6883.             int imageIndex = -1;

    6884. 

  6884. 

    6885. 

  6885.             if (!NativeMethods.HasBuiltinSortIndicators()) {

    6886. 

  6886.                 // If we can't use builtin image, we have to make and then locate the index of the

    6887. 

  6887.                 // sort indicator we want to use. SortOrder.None doesn't show an image.

    6888. 

  6888.                 if (this.SmallImageList == null || !this.SmallImageList.Images.ContainsKey(SORT_INDICATOR_UP_KEY))

    6889. 

  6889.                     MakeSortIndicatorImages();

    6890. 

  6890. 

    6891. 

  6891.                 if (sortOrder == SortOrder.Ascending)

    6892. 

  6892.                     imageIndex = this.SmallImageList.Images.IndexOfKey(SORT_INDICATOR_UP_KEY);

    6893. 

  6893.                 else if (sortOrder == SortOrder.Descending)

    6894. 

  6894.                     imageIndex = this.SmallImageList.Images.IndexOfKey(SORT_INDICATOR_DOWN_KEY);

    6895. 

  6895.             }

    6896. 

  6896. 

    6897. 

  6897.             // Set the image for each column

    6898. 

  6898.             for (int i = 0; i < this.Columns.Count; i++) {

    6899. 

  6899.                 if (columnToSort != null && i == columnToSort.Index)

    6900. 

  6900.                     NativeMethods.SetColumnImage(this, i, sortOrder, imageIndex);

    6901. 

  6901.                 else

    6902. 

  6902.                     NativeMethods.SetColumnImage(this, i, SortOrder.None, -1);

    6903. 

  6903.             }

    6904. 

  6904.         }

    6905. 

  6905. 

    6906. 

  6906.         /// <summary>

    6907. 

  6907.         /// The name of the image used when a column is sorted ascending

    6908. 

  6908.         /// </summary>

    6909. 

  6909.         /// <remarks>This image is only used on pre-XP systems. System images are used for XP and later</remarks>

    6910. 

  6910.         public const string SORT_INDICATOR_UP_KEY = "sort-indicator-up";

    6911. 

  6911. 

    6912. 

  6912.         /// <summary>

    6913. 

  6913.         /// The name of the image used when a column is sorted descending

    6914. 

  6914.         /// </summary>

    6915. 

  6915.         /// <remarks>This image is only used on pre-XP systems. System images are used for XP and later</remarks>

    6916. 

  6916.         public const string SORT_INDICATOR_DOWN_KEY = "sort-indicator-down";

    6917. 

  6917. 

    6918. 

  6918.         /// <summary>

    6919. 

  6919.         /// If the sort indicator images don't already exist, this method will make and install them

    6920. 

  6920.         /// </summary>

    6921. 

  6921.         protected virtual void MakeSortIndicatorImages() {

    6922. 

  6922.             // Don't mess with the image list in design mode

    6923. 

  6923.             if (this.DesignMode)

    6924. 

  6924.                 return;

    6925. 

  6925. 

    6926. 

  6926.             ImageList il = this.SmallImageList;

    6927. 

  6927.             if (il == null) {

    6928. 

  6928.                 il = new ImageList();

    6929. 

  6929.                 il.ImageSize = new Size(16, 16);

    6930. 

  6930.                 il.ColorDepth = ColorDepth.Depth32Bit;

    6931. 

  6931.             }

    6932. 

  6932. 

    6933. 

  6933.             // This arrangement of points works well with (16,16) images, and OK with others

    6934. 

  6934.             int midX = il.ImageSize.Width / 2;

    6935. 

  6935.             int midY = (il.ImageSize.Height / 2) - 1;

    6936. 

  6936.             int deltaX = midX - 2;

    6937. 

  6937.             int deltaY = deltaX / 2;

    6938. 

  6938. 

    6939. 

  6939.             if (il.Images.IndexOfKey(SORT_INDICATOR_UP_KEY) == -1) {

    6940. 

  6940.                 Point pt1 = new Point(midX - deltaX, midY + deltaY);

    6941. 

  6941.                 Point pt2 = new Point(midX, midY - deltaY - 1);

    6942. 

  6942.                 Point pt3 = new Point(midX + deltaX, midY + deltaY);

    6943. 

  6943.                 il.Images.Add(SORT_INDICATOR_UP_KEY, this.MakeTriangleBitmap(il.ImageSize, new Point[] { pt1, pt2, pt3 }));

    6944. 

  6944.             }

    6945. 

  6945. 

    6946. 

  6946.             if (il.Images.IndexOfKey(SORT_INDICATOR_DOWN_KEY) == -1) {

    6947. 

  6947.                 Point pt1 = new Point(midX - deltaX, midY - deltaY);

    6948. 

  6948.                 Point pt2 = new Point(midX, midY + deltaY);

    6949. 

  6949.                 Point pt3 = new Point(midX + deltaX, midY - deltaY);

    6950. 

  6950.                 il.Images.Add(SORT_INDICATOR_DOWN_KEY, this.MakeTriangleBitmap(il.ImageSize, new Point[] { pt1, pt2, pt3 }));

    6951. 

  6951.             }

    6952. 

  6952. 

    6953. 

  6953.             this.SmallImageList = il;

    6954. 

  6954.         }

    6955. 

  6955. 

    6956. 

  6956.         private Bitmap MakeTriangleBitmap(Size sz, Point[] pts) {

    6957. 

  6957.             Bitmap bm = new Bitmap(sz.Width, sz.Height);

    6958. 

  6958.             Graphics g = Graphics.FromImage(bm);

    6959. 

  6959.             g.FillPolygon(new SolidBrush(Color.Gray), pts);

    6960. 

  6960.             return bm;

    6961. 

  6961.         }

    6962. 

  6962. 

    6963. 

  6963.         /// <summary>

    6964. 

  6964.         /// Remove any sorting and revert to the given order of the model objects

    6965. 

  6965.         /// </summary>

    6966. 

  6966.         public virtual void Unsort() {

    6967. 

  6967.             this.ShowGroups = false;

    6968. 

  6968.             this.PrimarySortColumn = null;

    6969. 

  6969.             this.PrimarySortOrder = SortOrder.None;

    6970. 

  6970.             this.BuildList();

    6971. 

  6971.         }

    6972. 

  6972. 

    6973. 

  6973.         #endregion

    6974. 

  6974. 

    6975. 

  6975.         #region Utilities

    6976. 

  6976. 

    6977. 

  6977.         /// <summary>

    6978. 

  6978.         /// Do the actual work of creating the given list of groups

    6979. 

  6979.         /// </summary>

    6980. 

  6980.         /// <param name="groups"></param>

    6981. 

  6981.         protected virtual void CreateGroups(IList<OLVGroup> groups) {

    6982. 

  6982.             this.Groups.Clear();

    6983. 

  6983.             // The group must be added before it is given items, otherwise an exception is thrown (is this documented?)

    6984. 

  6984.             foreach (OLVGroup group in groups) {

    6985. 

  6985.                 group.InsertGroupOldStyle(this);

    6986. 

  6986.                 group.SetItemsOldStyle();

    6987. 

  6987.             }

    6988. 

  6988.             this.ResizeLastGroup();

    6989. 

  6989.         }

    6990. 

  6990. 

    6991. 

  6991.         internal void ResizeLastGroup()

    6992. 

  6992.         {

    6993. 

  6993.             // Don't mess with the control in design mode

    6994. 

  6994.             if (this.IsDesignMode) 

    6995. 

  6995.                 return;

    6996. 

  6996. 

    6997. 

  6997.             // Sanity checks

    6998. 

  6998.             if (this.GetItemCount() == 0 || !this.ShowGroups || this.Groups.Count == 0) 

    6999. 

  6999.                 return;

    7000. 

  7000.             

    7001. 

  7001.             // Get the last group and make sure we know which OLVGroup it came from

    7002. 

  7002.             ListViewGroup grp = this.Groups[this.Groups.Count-1];

    7003. 

  7003.             OLVGroup olvGroup = grp.Tag as OLVGroup;

    7004. 

  7004.             if (olvGroup == null)

    7005. 

  7005.                 return;

    7006. 

  7006. 

    7007. 

  7007.             int height = this.GetItem(0).Bounds.Height;

    7008. 

  7008. 

    7009. 

  7009.             // Is the Horizontal scrollbar visible

    7010. 

  7010.             if (NativeMethods.HasHorizontalScrollBar(this))

    7011. 

  7011.                 height += SystemInformation.HorizontalScrollBarHeight;

    7012. 

  7012.             

    7013. 

  7013.             if (this.SpaceBetweenGroups > height) 

    7014. 

  7014.                 return;

    7015. 

  7015.             

    7016. 

  7016.             NativeMethods.LVGROUPMETRICS metrics = new NativeMethods.LVGROUPMETRICS();

    7017. 

  7017.             metrics.cbSize = ((uint)Marshal.SizeOf(typeof(NativeMethods.LVGROUPMETRICS)));

    7018. 

  7018.             metrics.mask = (uint)GroupMetricsMask.LVGMF_BORDERSIZE;

    7019. 

  7019.             metrics.Bottom = (uint)height;

    7020. 

  7020.             NativeMethods.SetGroupMetrics(this, olvGroup.GroupId, metrics);

    7021. 

  7021.         }

    7022. 

  7022. 

    7023. 

  7023.         /// <summary>

    7024. 

  7024.         /// For some reason, UseItemStyleForSubItems doesn't work for the colors

    7025. 

  7025.         /// when owner drawing the list, so we have to specifically give each subitem

    7026. 

  7026.         /// the desired colors

    7027. 

  7027.         /// </summary>

    7028. 

  7028.         /// <param name="olvi">The item whose subitems are to be corrected</param>

    7029. 

  7029.         /// <remarks>Cells drawn via BaseRenderer don't need this, but it is needed

    7030. 

  7030.         /// when an owner drawn cell uses DrawDefault=true</remarks>

    7031. 

  7031.         protected virtual void CorrectSubItemColors(ListViewItem olvi) {

    7032. 

  7032.         }

    7033. 

  7033. 

    7034. 

  7034.         /// <summary>

    7035. 

  7035.         /// Fill in the given OLVListItem with values of the given row

    7036. 

  7036.         /// </summary>

    7037. 

  7037.         /// <param name="lvi">the OLVListItem that is to be stuff with values</param>

    7038. 

  7038.         /// <param name="rowObject">the model object from which values will be taken</param>

    7039. 

  7039.         protected virtual void FillInValues(OLVListItem lvi, object rowObject) {

    7040. 

  7040.             if (this.Columns.Count == 0)

    7041. 

  7041.                 return;

    7042. 

  7042. 

    7043. 

  7043.             OLVListSubItem subItem = this.MakeSubItem(rowObject, this.GetColumn(0));

    7044. 

  7044.             lvi.SubItems[0] = subItem;

    7045. 

  7045.             lvi.ImageSelector = subItem.ImageSelector;

    7046. 

  7046. 

    7047. 

  7047.             // Only Details and Tile views have subitems

    7048. 

  7048.             if (this.View == View.Details) {

    7049. 

  7049.                 for (int i = 1; i < this.Columns.Count; i++) {

    7050. 

  7050.                     lvi.SubItems.Add(this.MakeSubItem(rowObject, this.GetColumn(i)));

    7051. 

  7051.                 }

    7052. 

  7052.             } else {

    7053. 

  7053.                 if (this.View == View.Tile) {

    7054. 

  7054.                     for (int i = 1; i < this.Columns.Count; i++) {

    7055. 

  7055.                         OLVColumn column = this.GetColumn(i);

    7056. 

  7056.                         if (column.IsTileViewColumn)

    7057. 

  7057.                             lvi.SubItems.Add(this.MakeSubItem(rowObject, column));

    7058. 

  7058.                     }

    7059. 

  7059.                 }

    7060. 

  7060.             }

    7061. 

  7061. 

    7062. 

  7062.             // Give the item the same font/colors as the control

    7063. 

  7063.             lvi.Font = this.Font;

    7064. 

  7064.             lvi.BackColor = this.BackColor;

    7065. 

  7065.             lvi.ForeColor = this.ForeColor;

    7066. 

  7066. 

    7067. 

  7067.             // Set the check state of the row, if we are showing check boxes

    7068. 

  7068.             if (this.CheckBoxes) {

    7069. 

  7069.                 CheckState? state = this.GetCheckState(lvi.RowObject);

    7070. 

  7070.                 if (state.HasValue)

    7071. 

  7071.                     lvi.CheckState = (CheckState)state;

    7072. 

  7072.             }

    7073. 

  7073. 

    7074. 

  7074.             // Give the RowFormatter a chance to mess with the item

    7075. 

  7075.             if (this.RowFormatter != null) {

    7076. 

  7076.                 this.RowFormatter(lvi);

    7077. 

  7077.             }

    7078. 

  7078.         }

    7079. 

  7079. 

    7080. 

  7080.         private OLVListSubItem MakeSubItem(object rowObject, OLVColumn column) {

    7081. 

  7081.             object cellValue = column.GetValue(rowObject);

    7082. 

  7082.             OLVListSubItem subItem = new OLVListSubItem(cellValue,

    7083. 

  7083.                                                         column.ValueToString(cellValue),

    7084. 

  7084.                                                         column.GetImage(rowObject));

    7085. 

  7085.             if (this.UseHyperlinks && column.Hyperlink) {

    7086. 

  7086.                 IsHyperlinkEventArgs args = new IsHyperlinkEventArgs();

    7087. 

  7087.                 args.ListView = this;

    7088. 

  7088.                 args.Model = rowObject;

    7089. 

  7089.                 args.Column = column;

    7090. 

  7090.                 args.Text = subItem.Text;

    7091. 

  7091.                 args.Url = subItem.Text;

    7092. 

  7092.                 this.OnIsHyperlink(args);

    7093. 

  7093.                 subItem.Url = args.Url;

    7094. 

  7094.             }

    7095. 

  7095. 

    7096. 

  7096.             return subItem;

    7097. 

  7097.         }

    7098. 

  7098. 

    7099. 

  7099.         private void ApplyHyperlinkStyle(int rowIndex, OLVListItem olvi) {

    7100. 

  7100.             olvi.UseItemStyleForSubItems = false;

    7101. 

  7101. 

    7102. 

  7102.             // If subitem 0 is given a back color, the item back color is changed too.

    7103. 

  7103.             // So we have to remember it here so we can used it even if subitem 0 is changed.

    7104. 

  7104.             Color itemBackColor = olvi.BackColor;

    7105. 

  7105. 

    7106. 

  7106.             for (int i = 0; i < this.Columns.Count; i++) {

    7107. 

  7107.                 OLVListSubItem subItem = olvi.GetSubItem(i);

    7108. 

  7108.                 if (subItem == null)

    7109. 

  7109.                     continue;

    7110. 

  7110.                 OLVColumn column = this.GetColumn(i);

    7111. 

  7111.                 subItem.BackColor = itemBackColor;

    7112. 

  7112.                 if (column.Hyperlink && !String.IsNullOrEmpty(subItem.Url)) {

    7113. 

  7113.                     if (this.IsUrlVisited(subItem.Url))

    7114. 

  7114.                         this.ApplyCellStyle(olvi, i, this.HyperlinkStyle.Visited);

    7115. 

  7115.                     else

    7116. 

  7116.                         this.ApplyCellStyle(olvi, i, this.HyperlinkStyle.Normal);

    7117. 

  7117.                 }

    7118. 

  7118.             }

    7119. 

  7119.         }

    7120. 

  7120. 

    7121. 

  7121. 

    7122. 

  7122.         /// <summary>

    7123. 

  7123.         /// Make sure the ListView has the extended style that says to display subitem images.

    7124. 

  7124.         /// </summary>

    7125. 

  7125.         /// <remarks>This method must be called after any .NET call that update the extended styles

    7126. 

  7126.         /// since they seem to erase this setting.</remarks>

    7127. 

  7127.         protected virtual void ForceSubItemImagesExStyle() {

    7128. 

  7128.             // Virtual lists can't show subitem images natively, so don't turn on this flag

    7129. 

  7129.             if (!this.VirtualMode)

    7130. 

  7130.                 NativeMethods.ForceSubItemImagesExStyle(this);

    7131. 

  7131.         }

    7132. 

  7132. 

    7133. 

  7133.         /// <summary>

    7134. 

  7134.         /// Convert the given image selector to an index into our image list.

    7135. 

  7135.         /// Return -1 if that's not possible

    7136. 

  7136.         /// </summary>

    7137. 

  7137.         /// <param name="imageSelector"></param>

    7138. 

  7138.         /// <returns>Index of the image in the imageList, or -1</returns>

    7139. 

  7139.         protected virtual int GetActualImageIndex(Object imageSelector) {

    7140. 

  7140.             if (imageSelector == null)

    7141. 

  7141.                 return -1;

    7142. 

  7142. 

    7143. 

  7143.             if (imageSelector is Int32)

    7144. 

  7144.                 return (int)imageSelector;

    7145. 

  7145. 

    7146. 

  7146.             String imageSelectorAsString = imageSelector as String;

    7147. 

  7147.             if (imageSelectorAsString != null && this.SmallImageList != null)

    7148. 

  7148.                 return this.SmallImageList.Images.IndexOfKey(imageSelectorAsString);

    7149. 

  7149. 

    7150. 

  7150.             return -1;

    7151. 

  7151.         }

    7152. 

  7152. 

    7153. 

  7153.         /// <summary>

    7154. 

  7154.         /// Return the tooltip that should be shown when the mouse is hovered over the given column

    7155. 

  7155.         /// </summary>

    7156. 

  7156.         /// <param name="columnIndex">The column index whose tool tip is to be fetched</param>

    7157. 

  7157.         /// <returns>A string or null if no tool tip is to be shown</returns>

    7158. 

  7158.         public virtual String GetHeaderToolTip(int columnIndex) {

    7159. 

  7159.             OLVColumn column = this.GetColumn(columnIndex);

    7160. 

  7160.             if (column == null)

    7161. 

  7161.                 return null;

    7162. 

  7162.             String tooltip = column.ToolTipText;

    7163. 

  7163.             if (this.HeaderToolTipGetter != null)

    7164. 

  7164.                 tooltip = this.HeaderToolTipGetter(column);

    7165. 

  7165.             return tooltip;

    7166. 

  7166.         }

    7167. 

  7167. 

    7168. 

  7168.         /// <summary>

    7169. 

  7169.         /// Return the tooltip that should be shown when the mouse is hovered over the given cell

    7170. 

  7170.         /// </summary>

    7171. 

  7171.         /// <param name="columnIndex">The column index whose tool tip is to be fetched</param>

    7172. 

  7172.         /// <param name="rowIndex">The row index whose tool tip is to be fetched</param>

    7173. 

  7173.         /// <returns>A string or null if no tool tip is to be shown</returns>

    7174. 

  7174.         public virtual String GetCellToolTip(int columnIndex, int rowIndex) {

    7175. 

  7175.             if (this.CellToolTipGetter != null)

    7176. 

  7176.                 return this.CellToolTipGetter(this.GetColumn(columnIndex), this.GetModelObject(rowIndex));

    7177. 

  7177. 

    7178. 

  7178.             // Show the URL in the tooltip if it's different to the text

    7179. 

  7179.             if (columnIndex >= 0) {

    7180. 

  7180.                 OLVListSubItem subItem = this.GetSubItem(rowIndex, columnIndex);

    7181. 

  7181.                 if (subItem != null && !String.IsNullOrEmpty(subItem.Url) && subItem.Url != subItem.Text &&

    7182. 

  7182.                     this.HotCellHitLocation == HitTestLocation.Text)

    7183. 

  7183.                     return subItem.Url;

    7184. 

  7184.             }

    7185. 

  7185. 

    7186. 

  7186.             return null;

    7187. 

  7187.         }

    7188. 

  7188. 

    7189. 

  7189.         /// <summary>

    7190. 

  7190.         /// Return the OLVListItem that displays the given model object

    7191. 

  7191.         /// </summary>

    7192. 

  7192.         /// <param name="modelObject">The modelObject whose item is to be found</param>

    7193. 

  7193.         /// <returns>The OLVListItem that displays the model, or null</returns>

    7194. 

  7194.         /// <remarks>This method has O(n) performance.</remarks>

    7195. 

  7195.         public virtual OLVListItem ModelToItem(object modelObject) {

    7196. 

  7196.             if (modelObject == null)

    7197. 

  7197.                 return null;

    7198. 

  7198. 

    7199. 

  7199.             foreach (OLVListItem olvi in this.Items) {

    7200. 

  7200.                 if (olvi.RowObject != null && olvi.RowObject.Equals(modelObject))

    7201. 

  7201.                     return olvi;

    7202. 

  7202.             }

    7203. 

  7203.             return null;

    7204. 

  7204.         }

    7205. 

  7205. 

    7206. 

  7206.         /// <summary>

    7207. 

  7207.         /// Do the work required after the items in a listview have been created

    7208. 

  7208.         /// </summary>

    7209. 

  7209.         protected virtual void PostProcessRows() {

    7210. 

  7210.             // If this method is called during a BeginUpdate/EndUpdate pair, changes to the

    7211. 

  7211.             // Items collection are cached. Getting the Count flushes that cache.

    7212. 

  7212.             int count = this.Items.Count;

    7213. 

  7213. 

    7214. 

  7214.             int i = 0;

    7215. 

  7215.             if (this.ShowGroups) {

    7216. 

  7216.                 foreach (ListViewGroup group in this.Groups) {

    7217. 

  7217.                     foreach (OLVListItem olvi in group.Items) {

    7218. 

  7218.                         this.PostProcessOneRow(olvi.Index, i, olvi);

    7219. 

  7219.                         i++;

    7220. 

  7220.                     }

    7221. 

  7221.                 }

    7222. 

  7222.             } else {

    7223. 

  7223.                 foreach (OLVListItem olvi in this.Items) {

    7224. 

  7224.                     this.PostProcessOneRow(olvi.Index, i, olvi);

    7225. 

  7225.                     i++;

    7226. 

  7226.                 }

    7227. 

  7227.             }

    7228. 

  7228.         }

    7229. 

  7229. 

    7230. 

  7230.         /// <summary>

    7231. 

  7231.         /// Do the work required after one item in a listview have been created

    7232. 

  7232.         /// </summary>

    7233. 

  7233.         protected virtual void PostProcessOneRow(int rowIndex, int displayIndex, OLVListItem olvi) {

    7234. 

  7234.             if (this.UseAlternatingBackColors && this.View == View.Details) {

    7235. 

  7235.                 if (displayIndex % 2 == 1) {

    7236. 

  7236.                     olvi.BackColor = this.AlternateRowBackColorOrDefault;

    7237. 

  7237.                 } else {

    7238. 

  7238.                     olvi.BackColor = this.BackColor;

    7239. 

  7239.                 }

    7240. 

  7240.             }

    7241. 

  7241.             if (this.ShowImagesOnSubItems && !this.VirtualMode) {

    7242. 

  7242.                 this.SetSubItemImages(rowIndex, olvi);

    7243. 

  7243.             }

    7244. 

  7244.             if (this.UseHyperlinks) {

    7245. 

  7245.                 this.ApplyHyperlinkStyle(rowIndex, olvi);

    7246. 

  7246.             }

    7247. 

  7247.             this.TriggerFormatRowEvent(rowIndex, displayIndex, olvi);

    7248. 

  7248.         }

    7249. 

  7249. 

    7250. 

  7250.         /// <summary>

    7251. 

  7251.         /// Prepare the listview to show alternate row backcolors

    7252. 

  7252.         /// </summary>

    7253. 

  7253.         /// <remarks>We cannot rely on lvi.Index in this method.

    7254. 

  7254.         /// In a straight list, lvi.Index is the display index, and can be used to determine

    7255. 

  7255.         /// whether the row should be colored. But when organised by groups, lvi.Index is not

    7256. 

  7256.         /// useable because it still refers to the position in the overall list, not the display order.

    7257. 

  7257.         ///</remarks>

    7258. 

  7258.         [Obsolete("This method is no longer used. Override PostProcessOneRow() to achieve a similar result")]

    7259. 

  7259.         protected virtual void PrepareAlternateBackColors() {

    7260. 

  7260.         }

    7261. 

  7261. 

    7262. 

  7262.         /// <summary>

    7263. 

  7263.         /// Setup all subitem images on all rows

    7264. 

  7264.         /// </summary>

    7265. 

  7265.         [Obsolete("This method is not longer maintained and will be removed", false)]

    7266. 

  7266.         protected virtual void SetAllSubItemImages() {

    7267. 

  7267.             //if (!this.ShowImagesOnSubItems || this.OwnerDraw)

    7268. 

  7268.             //    return;

    7269. 

  7269. 

    7270. 

  7270.             //this.ForceSubItemImagesExStyle();

    7271. 

  7271. 

    7272. 

  7272.             //for (int rowIndex = 0; rowIndex < this.GetItemCount(); rowIndex++)

    7273. 

  7273.             //    SetSubItemImages(rowIndex, this.GetItem(rowIndex));

    7274. 

  7274.         }

    7275. 

  7275. 

    7276. 

  7276.         /// <summary>

    7277. 

  7277.         /// Tell the underlying list control which images to show against the subitems

    7278. 

  7278.         /// </summary>

    7279. 

  7279.         /// <param name="rowIndex">the index at which the item occurs</param>

    7280. 

  7280.         /// <param name="item">the item whose subitems are to be set</param>

    7281. 

  7281.         protected virtual void SetSubItemImages(int rowIndex, OLVListItem item) {

    7282. 

  7282.             this.SetSubItemImages(rowIndex, item, false);

    7283. 

  7283.         }

    7284. 

  7284. 

    7285. 

  7285.         /// <summary>

    7286. 

  7286.         /// Tell the underlying list control which images to show against the subitems

    7287. 

  7287.         /// </summary>

    7288. 

  7288.         /// <param name="rowIndex">the index at which the item occurs</param>

    7289. 

  7289.         /// <param name="item">the item whose subitems are to be set</param>

    7290. 

  7290.         /// <param name="shouldClearImages">will existing images be cleared if no new image is provided?</param>

    7291. 

  7291.         protected virtual void SetSubItemImages(int rowIndex, OLVListItem item, bool shouldClearImages) {

    7292. 

  7292.             if (!this.ShowImagesOnSubItems || this.OwnerDraw)

    7293. 

  7293.                 return;

    7294. 

  7294. 

    7295. 

  7295.             for (int i = 1; i < item.SubItems.Count; i++) {

    7296. 

  7296.                 this.SetSubItemImage(rowIndex, i, item.GetSubItem(i), shouldClearImages);

    7297. 

  7297.             }

    7298. 

  7298.         }

    7299. 

  7299. 

    7300. 

  7300.         /// <summary>

    7301. 

  7301.         /// Set the subitem image natively

    7302. 

  7302.         /// </summary>

    7303. 

  7303.         /// <param name="rowIndex"></param>

    7304. 

  7304.         /// <param name="subItemIndex"></param>

    7305. 

  7305.         /// <param name="subItem"></param>

    7306. 

  7306.         /// <param name="shouldClearImages"></param>

    7307. 

  7307.         public virtual void SetSubItemImage(int rowIndex, int subItemIndex, OLVListSubItem subItem, bool shouldClearImages) {

    7308. 

  7308.             int imageIndex = this.GetActualImageIndex(subItem.ImageSelector);

    7309. 

  7309.             if (shouldClearImages || imageIndex != -1)

    7310. 

  7310.                 NativeMethods.SetSubItemImage(this, rowIndex, subItemIndex, imageIndex);

    7311. 

  7311.         }

    7312. 

  7312. 

    7313. 

  7313.         /// <summary>

    7314. 

  7314.         /// Take ownership of the 'objects' collection. This separats our collection from the source.

    7315. 

  7315.         /// </summary>

    7316. 

  7316.         /// <remarks>

    7317. 

  7317.         /// <para>

    7318. 

  7318.         /// This method

    7319. 

  7319.         /// separates the 'objects' instance variable from its source, so that any AddObject/RemoveObject

    7320. 

  7320.         /// calls will modify our collection and not the original colleciton.

    7321. 

  7321.         /// </para>

    7322. 

  7322.         /// <para>

    7323. 

  7323.         /// This method has the intentional side-effect of converting our list of objects to an ArrayList.

    7324. 

  7324.         /// </para>

    7325. 

  7325.         /// </remarks>

    7326. 

  7326.         protected virtual void TakeOwnershipOfObjects() {

    7327. 

  7327.             if (this.isOwnerOfObjects)

    7328. 

  7328.                 return;

    7329. 

  7329. 

    7330. 

  7330.             this.isOwnerOfObjects = true;

    7331. 

  7331. 

    7332. 

  7332.             this.objects = ObjectListView.EnumerableToArray(this.objects, true);

    7333. 

  7333.         }

    7334. 

  7334. 

    7335. 

  7335.         /// <summary>

    7336. 

  7336.         /// Trigger FormatRow and possibly FormatCell events for the given item

    7337. 

  7337.         /// </summary>

    7338. 

  7338.         /// <param name="rowIndex"></param>

    7339. 

  7339.         /// <param name="displayIndex"></param>

    7340. 

  7340.         /// <param name="olvi"></param>

    7341. 

  7341.         protected virtual void TriggerFormatRowEvent(int rowIndex, int displayIndex, OLVListItem olvi) {

    7342. 

  7342.             FormatRowEventArgs args = new FormatRowEventArgs();

    7343. 

  7343.             args.ListView = this;

    7344. 

  7344.             args.RowIndex = rowIndex;

    7345. 

  7345.             args.DisplayIndex = displayIndex;

    7346. 

  7346.             args.Item = olvi;

    7347. 

  7347.             args.UseCellFormatEvents = this.UseCellFormatEvents;

    7348. 

  7348.             this.OnFormatRow(args);

    7349. 

  7349. 

    7350. 

  7350.             if (args.UseCellFormatEvents && this.View == View.Details) {

    7351. 

  7351.                 // If a cell isn't given its own color, it should use the color of the item.

    7352. 

  7352.                 // However, there is a bug in the .NET framework where the cell are given

    7353. 

  7353.                 // the color of the ListView instead. So we have to explicitly give each

    7354. 

  7354.                 // cell the back color that it should have.

    7355. 

  7355.                 olvi.UseItemStyleForSubItems = false;

    7356. 

  7356.                 Color backColor = olvi.BackColor;

    7357. 

  7357.                 for (int i = 0; i < this.Columns.Count; i++) {

    7358. 

  7358.                     olvi.SubItems[i].BackColor = backColor;

    7359. 

  7359.                 }

    7360. 

  7360. 

    7361. 

  7361.                 // Fire one event per cell

    7362. 

  7362.                 FormatCellEventArgs args2 = new FormatCellEventArgs();

    7363. 

  7363.                 args2.ListView = this;

    7364. 

  7364.                 args2.RowIndex = rowIndex;

    7365. 

  7365.                 args2.DisplayIndex = displayIndex;

    7366. 

  7366.                 args2.Item = olvi;

    7367. 

  7367.                 for (int i = 0; i < this.Columns.Count; i++) {

    7368. 

  7368.                     args2.ColumnIndex = i;

    7369. 

  7369.                     args2.Column = this.GetColumn(i);

    7370. 

  7370.                     args2.SubItem = olvi.GetSubItem(i);

    7371. 

  7371.                     this.OnFormatCell(args2);

    7372. 

  7372.                 }

    7373. 

  7373.             }

    7374. 

  7374.         }

    7375. 

  7375. 

    7376. 

  7376.         #endregion

    7377. 

  7377. 

    7378. 

  7378.         #region ISupportInitialize Members

    7379. 

  7379. 

    7380. 

  7380.         void ISupportInitialize.BeginInit() {

    7381. 

  7381.             this.Frozen = true;

    7382. 

  7382.         }

    7383. 

  7383. 

    7384. 

  7384.         void ISupportInitialize.EndInit() {

    7385. 

  7385.             if (this.RowHeight != -1) {

    7386. 

  7386.                 this.SmallImageList = this.SmallImageList;

    7387. 

  7387.                 if (this.CheckBoxes)

    7388. 

  7388.                     this.InitializeStateImageList();

    7389. 

  7389.             }

    7390. 

  7390. 

    7391. 

  7391.             if (this.UseCustomSelectionColors)

    7392. 

  7392.                 this.EnableCustomSelectionColors();

    7393. 

  7393. 

    7394. 

  7394.             if (this.UseSubItemCheckBoxes || (this.VirtualMode && this.CheckBoxes))

    7395. 

  7395.                 this.SetupSubItemCheckBoxes();

    7396. 

  7396. 

    7397. 

  7397.             this.Frozen = false;

    7398. 

  7398.         }

    7399. 

  7399. 

    7400. 

  7400.         #endregion

    7401. 

  7401. 

    7402. 

  7402.         #region Image list manipulation

    7403. 

  7403. 

    7404. 

  7404.         /// <summary>

    7405. 

  7405.         /// Update our externally visible image list so it holds the same images as our shadow list, but sized correctly

    7406. 

  7406.         /// </summary>

    7407. 

  7407.         private void SetupBaseImageList() {

    7408. 

  7408.             // If a row height hasn't been set, or an image list has been give which is the required size, just assign it

    7409. 

  7409.             if (rowHeight == -1 ||

    7410. 

  7410.                 this.View != View.Details ||

    7411. 

  7411.                 (this.shadowedImageList != null && this.shadowedImageList.ImageSize.Height == rowHeight))

    7412. 

  7412.                 this.BaseSmallImageList = this.shadowedImageList;

    7413. 

  7413.             else {

    7414. 

  7414.                 int width = (this.shadowedImageList == null ? 16 : this.shadowedImageList.ImageSize.Width);

    7415. 

  7415.                 this.BaseSmallImageList = this.MakeResizedImageList(width, rowHeight, shadowedImageList);

    7416. 

  7416.             }

    7417. 

  7417.         }

    7418. 

  7418. 

    7419. 

  7419.         /// <summary>

    7420. 

  7420.         /// Return a copy of the given source image list, where each image has been resized to be height x height in size.

    7421. 

  7421.         /// If source is null, an empty image list of the given size is returned

    7422. 

  7422.         /// </summary>

    7423. 

  7423.         /// <param name="width">Height and width of the new images</param>

    7424. 

  7424.         /// <param name="height">Height and width of the new images</param>

    7425. 

  7425.         /// <param name="source">Source of the images (can be null)</param>

    7426. 

  7426.         /// <returns>A new image list</returns>

    7427. 

  7427.         private ImageList MakeResizedImageList(int width, int height, ImageList source) {

    7428. 

  7428.             ImageList il = new ImageList();

    7429. 

  7429.             il.ImageSize = new Size(width, height);

    7430. 

  7430.             il.ColorDepth = ColorDepth.Depth32Bit;

    7431. 

  7431. 

    7432. 

  7432.             // If there's nothing to copy, just return the new list

    7433. 

  7433.             if (source == null)

    7434. 

  7434.                 return il;

    7435. 

  7435. 

    7436. 

  7436.             il.TransparentColor = source.TransparentColor;

    7437. 

  7437.             il.ColorDepth = source.ColorDepth;

    7438. 

  7438. 

    7439. 

  7439.             // Fill the imagelist with resized copies from the source

    7440. 

  7440.             for (int i = 0; i < source.Images.Count; i++) {

    7441. 

  7441.                 Bitmap bm = this.MakeResizedImage(width, height, source.Images[i], source.TransparentColor);

    7442. 

  7442.                 il.Images.Add(bm);

    7443. 

  7443.             }

    7444. 

  7444. 

    7445. 

  7445.             // Give each image the same key it has in the original

    7446. 

  7446.             foreach (String key in source.Images.Keys) {

    7447. 

  7447.                 il.Images.SetKeyName(source.Images.IndexOfKey(key), key);

    7448. 

  7448.             }

    7449. 

  7449. 

    7450. 

  7450.             return il;

    7451. 

  7451.         }

    7452. 

  7452. 

    7453. 

  7453.         /// <summary>

    7454. 

  7454.         /// Return a bitmap of the given height x height, which shows the given image, centred.

    7455. 

  7455.         /// </summary>

    7456. 

  7456.         /// <param name="width">Height and width of new bitmap</param>

    7457. 

  7457.         /// <param name="height">Height and width of new bitmap</param>

    7458. 

  7458.         /// <param name="image">Image to be centred</param>

    7459. 

  7459.         /// <param name="transparent">The background color</param>

    7460. 

  7460.         /// <returns>A new bitmap</returns>

    7461. 

  7461.         private Bitmap MakeResizedImage(int width, int height, Image image, Color transparent) {

    7462. 

  7462.             Bitmap bm = new Bitmap(width, height);

    7463. 

  7463.             Graphics g = Graphics.FromImage(bm);

    7464. 

  7464.             g.Clear(transparent);

    7465. 

  7465.             int x = Math.Max(0, (bm.Size.Width - image.Size.Width) / 2);

    7466. 

  7466.             int y = Math.Max(0, (bm.Size.Height - image.Size.Height) / 2);

    7467. 

  7467.             g.DrawImage(image, x, y, image.Size.Width, image.Size.Height);

    7468. 

  7468.             return bm;

    7469. 

  7469.         }

    7470. 

  7470. 

    7471. 

  7471.         /// <summary>

    7472. 

  7472.         /// Initialize the state image list with the required checkbox images

    7473. 

  7473.         /// </summary>

    7474. 

  7474.         protected virtual void InitializeStateImageList() {

    7475. 

  7475.             if (this.DesignMode)

    7476. 

  7476.                 return;

    7477. 

  7477. 

    7478. 

  7478.             if (this.StateImageList == null) {

    7479. 

  7479.                 this.StateImageList = new ImageList();

    7480. 

  7480.                 this.StateImageList.ImageSize = new Size(16, 16);

    7481. 

  7481.                 this.StateImageList.ColorDepth = ColorDepth.Depth32Bit;

    7482. 

  7482.             }

    7483. 

  7483. 

    7484. 

  7484.             if (this.RowHeight != -1 &&

    7485. 

  7485.                 this.View == View.Details &&

    7486. 

  7486.                 this.StateImageList.ImageSize.Height != this.RowHeight) {

    7487. 

  7487.                 this.StateImageList = new ImageList();

    7488. 

  7488.                 this.StateImageList.ImageSize = new Size(16, this.RowHeight);

    7489. 

  7489.                 this.StateImageList.ColorDepth = ColorDepth.Depth32Bit;

    7490. 

  7490.             }

    7491. 

  7491. 

    7492. 

  7492.             if (!this.CheckBoxes)

    7493. 

  7493.                 return;

    7494. 

  7494. 

    7495. 

  7495.             // The internal logic of ListView cycles through the state images when the primary

    7496. 

  7496.             // checkbox is clicked. So we have to get exactly the right number of images in the 

    7497. 

  7497.             // image list.

    7498. 

  7498.             if (this.StateImageList.Images.Count == 0)

    7499. 

  7499.                 this.AddCheckStateBitmap(this.StateImageList, UNCHECKED_KEY, CheckBoxState.UncheckedNormal);

    7500. 

  7500.             if (this.StateImageList.Images.Count <= 1)

    7501. 

  7501.                 this.AddCheckStateBitmap(this.StateImageList, CHECKED_KEY, CheckBoxState.CheckedNormal);

    7502. 

  7502.             if (this.TriStateCheckBoxes && this.StateImageList.Images.Count <= 2)

    7503. 

  7503.                 this.AddCheckStateBitmap(this.StateImageList, INDETERMINATE_KEY, CheckBoxState.MixedNormal);

    7504. 

  7504.             else {

    7505. 

  7505.                 if (this.StateImageList.Images.ContainsKey(INDETERMINATE_KEY))

    7506. 

  7506.                     this.StateImageList.Images.RemoveByKey(INDETERMINATE_KEY);

    7507. 

  7507.             }

    7508. 

  7508.         }

    7509. 

  7509. 

    7510. 

  7510.         /// <summary>

    7511. 

  7511.         /// The name of the image used when a check box is checked

    7512. 

  7512.         /// </summary>

    7513. 

  7513.         public const string CHECKED_KEY = "checkbox-checked";

    7514. 

  7514. 

    7515. 

  7515.         /// <summary>

    7516. 

  7516.         /// The name of the image used when a check box is unchecked

    7517. 

  7517.         /// </summary>

    7518. 

  7518.         public const string UNCHECKED_KEY = "checkbox-unchecked";

    7519. 

  7519. 

    7520. 

  7520.         /// <summary>

    7521. 

  7521.         /// The name of the image used when a check box is Indeterminate

    7522. 

  7522.         /// </summary>

    7523. 

  7523.         public const string INDETERMINATE_KEY = "checkbox-indeterminate";

    7524. 

  7524. 

    7525. 

  7525.         /// <summary>

    7526. 

  7526.         /// Setup this control so it can display check boxes on subitems

    7527. 

  7527.         /// (or primary checkboxes in virtual mode)

    7528. 

  7528.         /// </summary>

    7529. 

  7529.         /// <remarks>This gives the ListView a small image list, if it doesn't already have one.</remarks>

    7530. 

  7530.         public virtual void SetupSubItemCheckBoxes() {

    7531. 

  7531.             this.ShowImagesOnSubItems = true;

    7532. 

  7532.             if (this.SmallImageList == null || !this.SmallImageList.Images.ContainsKey(CHECKED_KEY))

    7533. 

  7533.                 this.InitializeCheckBoxImages();

    7534. 

  7534.         }

    7535. 

  7535. 

    7536. 

  7536.         /// <summary>

    7537. 

  7537.         /// Make sure the small image list for this control has checkbox images 

    7538. 

  7538.         /// (used for sub-item checkboxes).

    7539. 

  7539.         /// </summary>

    7540. 

  7540.         /// <remarks>This gives the ListView a small image list, if it doesn't already have one.</remarks>

    7541. 

  7541.         protected virtual void InitializeCheckBoxImages() {

    7542. 

  7542.             // Don't mess with the image list in design mode

    7543. 

  7543.             if (this.DesignMode)

    7544. 

  7544.                 return;

    7545. 

  7545. 

    7546. 

  7546.             ImageList il = this.SmallImageList;

    7547. 

  7547.             if (il == null) {

    7548. 

  7548.                 il = new ImageList();

    7549. 

  7549.                 il.ImageSize = new Size(16, 16);

    7550. 

  7550.                 il.ColorDepth = ColorDepth.Depth32Bit;

    7551. 

  7551.             }

    7552. 

  7552. 

    7553. 

  7553.             this.AddCheckStateBitmap(il, CHECKED_KEY, CheckBoxState.CheckedNormal);

    7554. 

  7554.             this.AddCheckStateBitmap(il, UNCHECKED_KEY, CheckBoxState.UncheckedNormal);

    7555. 

  7555.             this.AddCheckStateBitmap(il, INDETERMINATE_KEY, CheckBoxState.MixedNormal);

    7556. 

  7556. 

    7557. 

  7557.             this.SmallImageList = il;

    7558. 

  7558.         }

    7559. 

  7559. 

    7560. 

  7560.         private void AddCheckStateBitmap(ImageList il, string key, CheckBoxState boxState) {

    7561. 

  7561.             Bitmap b = new Bitmap(il.ImageSize.Width, il.ImageSize.Height);

    7562. 

  7562.             Graphics g = Graphics.FromImage(b);

    7563. 

  7563.             g.Clear(il.TransparentColor);

    7564. 

  7564.             Point location = new Point(b.Width / 2 - 5, b.Height / 2 - 6);

    7565. 

  7565.             CheckBoxRenderer.DrawCheckBox(g, location, boxState);

    7566. 

  7566.             il.Images.Add(key, b);

    7567. 

  7567.         }

    7568. 

  7568. 

    7569. 

  7569.         #endregion

    7570. 

  7570. 

    7571. 

  7571.         #region Owner drawing

    7572. 

  7572. 

    7573. 

  7573.         /// <summary>

    7574. 

  7574.         /// Owner draw the column header

    7575. 

  7575.         /// </summary>

    7576. 

  7576.         /// <param name="e"></param>

    7577. 

  7577.         protected override void OnDrawColumnHeader(DrawListViewColumnHeaderEventArgs e) {

    7578. 

  7578.             e.DrawDefault = true;

    7579. 

  7579.             base.OnDrawColumnHeader(e);

    7580. 

  7580.         }

    7581. 

  7581. 

    7582. 

  7582.         /// <summary>

    7583. 

  7583.         /// Owner draw the item

    7584. 

  7584.         /// </summary>

    7585. 

  7585.         /// <param name="e"></param>

    7586. 

  7586.         protected override void OnDrawItem(DrawListViewItemEventArgs e) {

    7587. 

  7587.             if (this.View == View.Details)

    7588. 

  7588.                 e.DrawDefault = false;

    7589. 

  7589.             else {

    7590. 

  7590.                 if (this.ItemRenderer == null)

    7591. 

  7591.                     e.DrawDefault = true;

    7592. 

  7592.                 else {

    7593. 

  7593.                     Object row = ((OLVListItem)e.Item).RowObject;

    7594. 

  7594.                     e.DrawDefault = !this.ItemRenderer.RenderItem(e, e.Graphics, e.Bounds, row);

    7595. 

  7595.                 }

    7596. 

  7596.             }

    7597. 

  7597. 

    7598. 

  7598.             if (e.DrawDefault)

    7599. 

  7599.                 base.OnDrawItem(e);

    7600. 

  7600.         }

    7601. 

  7601. 

    7602. 

  7602.         /// <summary>

    7603. 

  7603.         /// Owner draw a single subitem

    7604. 

  7604.         /// </summary>

    7605. 

  7605.         /// <param name="e"></param>

    7606. 

  7606.         protected override void OnDrawSubItem(DrawListViewSubItemEventArgs e) {

    7607. 

  7607.             //System.Diagnostics.Debug.WriteLine(String.Format("OnDrawSubItem ({0}, {1})", e.ItemIndex, e.ColumnIndex));

    7608. 

  7608.             // Don't try to do owner drawing at design time

    7609. 

  7609.             if (this.DesignMode) {

    7610. 

  7610.                 e.DrawDefault = true;

    7611. 

  7611.                 return;

    7612. 

  7612.             }

    7613. 

  7613. 

    7614. 

  7614.             // Calculate where the subitem should be drawn

    7615. 

  7615.             Rectangle r = e.Bounds;

    7616. 

  7616. 

    7617. 

  7617.             // Optimize drawing by only redrawing subitems that touch the area that was damaged

    7618. 

  7618.             //if (!r.IntersectsWith(this.lastUpdateRectangle))

    7619. 

  7619.             //    return;

    7620. 

  7620. 

    7621. 

  7621.             // Get the special renderer for this column. If there isn't one, use the default draw mechanism.

    7622. 

  7622.             OLVColumn column = this.GetColumn(e.ColumnIndex);

    7623. 

  7623.             IRenderer renderer = column.Renderer ?? this.DefaultRenderer;

    7624. 

  7624. 

    7625. 

  7625.             // Get a graphics context for the renderer to use.

    7626. 

  7626.             // But we have more complications. Virtual lists have a nasty habit of drawing column 0

    7627. 

  7627.             // whenever there is any mouse move events over a row, and doing it in an un-double-buffered manner,

    7628. 

  7628.             // which results in nasty flickers! There are also some unbuffered draw when a mouse is first

    7629. 

  7629.             // hovered over column 0 of a normal row. So, to avoid all complications,

    7630. 

  7630.             // we always manually double-buffer the drawing.

    7631. 

  7631.             // Except with Mono, which doesn't seem to handle double buffering at all :-(

    7632. 

  7632.             Graphics g = e.Graphics;

    7633. 

  7633.             BufferedGraphics buffer = null;

    7634. 

  7634.             bool avoidFlickerMode = true; // set this to false to see the problems with flicker

    7635. 

  7635.             if (avoidFlickerMode) {

    7636. 

  7636.                 buffer = BufferedGraphicsManager.Current.Allocate(e.Graphics, r);

    7637. 

  7637.                 g = buffer.Graphics;

    7638. 

  7638.             }

    7639. 

  7639. 

    7640. 

  7640.             g.TextRenderingHint = ObjectListView.TextRenderingHint;

    7641. 

  7641.             g.SmoothingMode = ObjectListView.SmoothingMode;

    7642. 

  7642. 

    7643. 

  7643.             // Finally, give the renderer a chance to draw something

    7644. 

  7644.             e.DrawDefault = !renderer.RenderSubItem(e, g, r, ((OLVListItem)e.Item).RowObject);

    7645. 

  7645. 

    7646. 

  7646.             if (buffer != null) {

    7647. 

  7647.                 if (!e.DrawDefault)

    7648. 

  7648.                     buffer.Render();

    7649. 

  7649.                 buffer.Dispose();

    7650. 

  7650.             }

    7651. 

  7651.         }

    7652. 

  7652. 

    7653. 

  7653.         #endregion

    7654. 

  7654. 

    7655. 

  7655.         #region OnEvent Handling

    7656. 

  7656. 

    7657. 

  7657.         /// <summary>

    7658. 

  7658.         /// We need the click count in the mouse up event, but that is always 1.

    7659. 

  7659.         /// So we have to remember the click count from the preceding mouse down event.

    7660. 

  7660.         /// </summary>

    7661. 

  7661.         /// <param name="e"></param>

    7662. 

  7662.         protected override void OnMouseDown(MouseEventArgs e) {

    7663. 

  7663.             this.lastMouseDownClickCount = e.Clicks;

    7664. 

  7664.             base.OnMouseDown(e);

    7665. 

  7665.         }

    7666. 

  7666.         private int lastMouseDownClickCount;

    7667. 

  7667. 

    7668. 

  7668.         /// <summary>

    7669. 

  7669.         /// When the mouse leaves the control, remove any hot item highlighting

    7670. 

  7670.         /// </summary>

    7671. 

  7671.         /// <param name="e"></param>

    7672. 

  7672.         protected override void OnMouseLeave(EventArgs e) {

    7673. 

  7673.             base.OnMouseLeave(e);

    7674. 

  7674. 

    7675. 

  7675.             if (!this.Created)

    7676. 

  7676.                 return;

    7677. 

  7677. 

    7678. 

  7678.             this.UpdateHotItem(new Point(-1, -1));

    7679. 

  7679.         }

    7680. 

  7680. 

    7681. 

  7681.         // We could change the hot item on the mouse hover event, but it looks wrong.

    7682. 

  7682. 

    7683. 

  7683.         //protected override void OnMouseHover(EventArgs e)

    7684. 

  7684.         //{

    7685. 

  7685.         //    base.OnMouseHover(e);

    7686. 

  7686.         //    this.UpdateHotItem(this.PointToClient(Cursor.Position));

    7687. 

  7687.         //}

    7688. 

  7688. 

    7689. 

  7689.         /// <summary>

    7690. 

  7690.         /// When the mouse moves, we might need to change the hot item.

    7691. 

  7691.         /// </summary>

    7692. 

  7692.         /// <param name="e"></param>

    7693. 

  7693.         protected override void OnMouseMove(MouseEventArgs e) {

    7694. 

  7694.             base.OnMouseMove(e);

    7695. 

  7695. 

    7696. 

  7696.             if (!this.Created)

    7697. 

  7697.                 return;

    7698. 

  7698. 

    7699. 

  7699.             CellOverEventArgs args = new CellOverEventArgs();

    7700. 

  7700.             this.BuildCellEvent(args, e.Location);

    7701. 

  7701.             this.OnCellOver(args);

    7702. 

  7702.             this.MouseMoveHitTest = args.HitTest;

    7703. 

  7703. 

    7704. 

  7704.             if (!args.Handled) {

    7705. 

  7705.                 this.UpdateHotItem(args.HitTest);

    7706. 

  7706.             }

    7707. 

  7707.         }

    7708. 

  7708. 

    7709. 

  7709.         /// <summary>

    7710. 

  7710.         /// Check to see if we need to start editing a cell

    7711. 

  7711.         /// </summary>

    7712. 

  7712.         /// <param name="e"></param>

    7713. 

  7713.         protected override void OnMouseUp(MouseEventArgs e) {

    7714. 

  7714.             base.OnMouseUp(e);

    7715. 

  7715. 

    7716. 

  7716.             if (!this.Created)

    7717. 

  7717.                 return;

    7718. 

  7718. 

    7719. 

  7719.             if (e.Button == MouseButtons.Right) {

    7720. 

  7720.                 this.OnRightMouseUp(e);

    7721. 

  7721.                 return;

    7722. 

  7722.             }

    7723. 

  7723. 

    7724. 

  7724.             // What event should we listen for to start cell editing?

    7725. 

  7725.             // ------------------------------------------------------

    7726. 

  7726.             //

    7727. 

  7727.             // We can't use OnMouseClick, OnMouseDoubleClick, OnClick, or OnDoubleClick

    7728. 

  7728.             // since they are not triggered for clicks on subitems without Full Row Select.

    7729. 

  7729.             //

    7730. 

  7730.             // We could use OnMouseDown, but selecting rows is done in OnMouseUp. This means

    7731. 

  7731.             // that if we start the editing during OnMouseDown, the editor will automatically

    7732. 

  7732.             // lose focus when mouse up happens.

    7733. 

  7733.             //

    7734. 

  7734. 

    7735. 

  7735.             // Tell the world about a cell click. If someone handles it, don't do anything else

    7736. 

  7736.             CellClickEventArgs args = new CellClickEventArgs();

    7737. 

  7737.             this.BuildCellEvent(args, e.Location);

    7738. 

  7738.             args.ClickCount = this.lastMouseDownClickCount;

    7739. 

  7739.             this.OnCellClick(args);

    7740. 

  7740.             if (args.Handled)

    7741. 

  7741.                 return;

    7742. 

  7742. 

    7743. 

  7743.             // Did the user click a hyperlink?

    7744. 

  7744.             if (this.UseHyperlinks &&

    7745. 

  7745.                 args.HitTest.HitTestLocation == HitTestLocation.Text &&

    7746. 

  7746.                 args.SubItem != null &&

    7747. 

  7747.                 !String.IsNullOrEmpty(args.SubItem.Url)) {

    7748. 

  7748.                 // We have to delay the running of this process otherwise we can generate

    7749. 

  7749.                 // a series of MouseUp events (don't ask me why)

    7750. 

  7750.                 this.BeginInvoke((MethodInvoker)delegate { ProcessHyperlinkClicked(args); });

    7751. 

  7751.             }

    7752. 

  7752. 

    7753. 

  7753.             // No one handled it so check to see if we should start editing.

    7754. 

  7754.             // We only start the edit if the user clicked on the image or text.

    7755. 

  7755.             if (this.ShouldStartCellEdit(e) &&

    7756. 

  7756.                 args.HitTest.HitTestLocation != HitTestLocation.Nothing) {

    7757. 

  7757. 

    7758. 

  7758.                 // We don't edit the primary column by single clicks -- only subitems.

    7759. 

  7759.                 if (this.CellEditActivation != CellEditActivateMode.SingleClick || args.ColumnIndex > 0)

    7760. 

  7760.                     this.EditSubItem(args.Item, args.ColumnIndex);

    7761. 

  7761.             }

    7762. 

  7762.         }

    7763. 

  7763. 

    7764. 

  7764.         /// <summary>

    7765. 

  7765.         /// Tell the world that a hyperlink was clicked and if the event isn't handled,

    7766. 

  7766.         /// do the default processing.

    7767. 

  7767.         /// </summary>

    7768. 

  7768.         /// <param name="e"></param>

    7769. 

  7769.         protected virtual void ProcessHyperlinkClicked(CellClickEventArgs e) {

    7770. 

  7770.             HyperlinkClickedEventArgs args = new HyperlinkClickedEventArgs();

    7771. 

  7771.             args.HitTest = e.HitTest;

    7772. 

  7772.             args.ListView = this;

    7773. 

  7773.             args.Location = new Point(-1, -1);

    7774. 

  7774.             args.Item = e.Item;

    7775. 

  7775.             args.SubItem = e.SubItem;

    7776. 

  7776.             args.Model = e.Model;

    7777. 

  7777.             args.ColumnIndex = e.ColumnIndex;

    7778. 

  7778.             args.Column = e.Column;

    7779. 

  7779.             args.RowIndex = e.RowIndex;

    7780. 

  7780.             args.ModifierKeys = Control.ModifierKeys;

    7781. 

  7781.             args.Url = e.SubItem.Url;

    7782. 

  7782.             this.OnHyperlinkClicked(args);

    7783. 

  7783.             if (!args.Handled) {

    7784. 

  7784.                 this.StandardHyperlinkClickedProcessing(args);

    7785. 

  7785.             }

    7786. 

  7786.         }

    7787. 

  7787. 

    7788. 

  7788.         /// <summary>

    7789. 

  7789.         /// Do the default processing for a hyperlink clicked event, which

    7790. 

  7790.         /// is to try and open the url.

    7791. 

  7791.         /// </summary>

    7792. 

  7792.         /// <param name="args"></param>

    7793. 

  7793.         protected virtual void StandardHyperlinkClickedProcessing(HyperlinkClickedEventArgs args) {

    7794. 

  7794.             Cursor originalCursor = this.Cursor;

    7795. 

  7795.             try {

    7796. 

  7796.                 this.Cursor = Cursors.WaitCursor;

    7797. 

  7797.                 System.Diagnostics.Process.Start(args.Url);

    7798. 

  7798.             } catch (Win32Exception) {

    7799. 

  7799.                 System.Media.SystemSounds.Beep.Play();

    7800. 

  7800.                 // ignore it

    7801. 

  7801.             } finally {

    7802. 

  7802.                 this.Cursor = originalCursor;

    7803. 

  7803.             }

    7804. 

  7804.             this.MarkUrlVisited(args.Url);

    7805. 

  7805.             this.RefreshHotItem();

    7806. 

  7806.         }

    7807. 

  7807. 

    7808. 

  7808.         /// <summary>

    7809. 

  7809.         /// The user right clicked on the control

    7810. 

  7810.         /// </summary>

    7811. 

  7811.         /// <param name="e"></param>

    7812. 

  7812.         protected virtual void OnRightMouseUp(MouseEventArgs e) {

    7813. 

  7813.             CellRightClickEventArgs args = new CellRightClickEventArgs();

    7814. 

  7814.             this.BuildCellEvent(args, e.Location);

    7815. 

  7815.             this.OnCellRightClick(args);

    7816. 

  7816.             if (!args.Handled) {

    7817. 

  7817.                 if (args.MenuStrip != null) {

    7818. 

  7818.                     args.MenuStrip.Show(this, args.Location);

    7819. 

  7819.                 }

    7820. 

  7820.             }

    7821. 

  7821.         }

    7822. 

  7822. 

    7823. 

  7823.         private void BuildCellEvent(CellEventArgs args, Point location) {

    7824. 

  7824.             OlvListViewHitTestInfo hitTest = this.OlvHitTest(location.X, location.Y);

    7825. 

  7825.             args.HitTest = hitTest;

    7826. 

  7826.             args.ListView = this;

    7827. 

  7827.             args.Location = location;

    7828. 

  7828.             args.Item = hitTest.Item;

    7829. 

  7829.             args.SubItem = hitTest.SubItem;

    7830. 

  7830.             args.Model = hitTest.RowObject;

    7831. 

  7831.             args.ColumnIndex = hitTest.ColumnIndex;

    7832. 

  7832.             args.Column = hitTest.Column;

    7833. 

  7833.             if (hitTest.Item != null)

    7834. 

  7834.                 args.RowIndex = hitTest.Item.Index;

    7835. 

  7835.             args.ModifierKeys = Control.ModifierKeys;

    7836. 

  7836. 

    7837. 

  7837.             // In non-details view, we want any hit on an item to act as if it was a hit

    7838. 

  7838.             // on column 0 -- which, effectively, it was.

    7839. 

  7839.             if (args.Item != null && args.ListView.View != View.Details) {

    7840. 

  7840.                 args.ColumnIndex = 0;

    7841. 

  7841.                 args.Column = args.ListView.GetColumn(0);

    7842. 

  7842.                 args.SubItem = args.Item.GetSubItem(0);

    7843. 

  7843.             }

    7844. 

  7844.         }

    7845. 

  7845. 

    7846. 

  7846.         /// <summary>

    7847. 

  7847.         /// This method is called every time a row is selected or deselected. This can be

    7848. 

  7848.         /// a pain if the user shift-clicks 100 rows. We override this method so we can

    7849. 

  7849.         /// trigger one event for any number of select/deselects that come from one user action

    7850. 

  7850.         /// </summary>

    7851. 

  7851.         /// <param name="e"></param>

    7852. 

  7852.         protected override void OnSelectedIndexChanged(EventArgs e) {

    7853. 

  7853.             base.OnSelectedIndexChanged(e);

    7854. 

  7854. 

    7855. 

  7855.             // If we haven't already scheduled an event, schedule it to be triggered

    7856. 

  7856.             // By using idle time, we will wait until all select events for the same

    7857. 

  7857.             // user action have finished before triggering the event.

    7858. 

  7858.             if (!this.hasIdleHandler) {

    7859. 

  7859.                 this.hasIdleHandler = true;

    7860. 

  7860.                 Application.Idle += new EventHandler(HandleApplicationIdle);

    7861. 

  7861.             }

    7862. 

  7862.         }

    7863. 

  7863. 

    7864. 

  7864.         /// <summary>

    7865. 

  7865.         /// Called when the handle of the underlying control is created

    7866. 

  7866.         /// </summary>

    7867. 

  7867.         /// <param name="e"></param>

    7868. 

  7868.         protected override void OnHandleCreated(EventArgs e) {

    7869. 

  7869.             base.OnHandleCreated(e);

    7870. 

  7870. 

    7871. 

  7871.             this.Invoke((MethodInvoker)this.OnControlCreated);

    7872. 

  7872.         }

    7873. 

  7873. 

    7874. 

  7874.         /// <summary>

    7875. 

  7875.         /// This method is called after the control has been fully created.

    7876. 

  7876.         /// </summary>

    7877. 

  7877.         protected virtual void OnControlCreated() {

    7878. 

  7878. 

    7879. 

  7879.             // Force the header control to be created when the listview handle is

    7880. 

  7880.             HeaderControl hc = this.HeaderControl;

    7881. 

  7881.             hc.WordWrap = this.HeaderWordWrap;

    7882. 

  7882. 

    7883. 

  7883.             // Make sure any overlays that are set on the hot item style take effect

    7884. 

  7884.             this.HotItemStyle = this.HotItemStyle;

    7885. 

  7885. 

    7886. 

  7886.             // Arrange for any group images to be installed after the control is created

    7887. 

  7887.             int x = NativeMethods.SetGroupImageList(this, this.GroupImageList);

    7888. 

  7888. 

    7889. 

  7889.             this.UseExplorerTheme = this.UseExplorerTheme;

    7890. 

  7890. 

    7891. 

  7891.             this.RememberDisplayIndicies();

    7892. 

  7892.         }

    7893. 

  7893. 

    7894. 

  7894.         #endregion

    7895. 

  7895. 

    7896. 

  7896.         #region Cell editing

    7897. 

  7897. 

    7898. 

  7898.         /// <summary>

    7899. 

  7899.         /// Should we start editing the cell in response to the given mouse button event?

    7900. 

  7900.         /// </summary>

    7901. 

  7901.         /// <param name="e"></param>

    7902. 

  7902.         /// <returns></returns>

    7903. 

  7903.         protected virtual bool ShouldStartCellEdit(MouseEventArgs e) {

    7904. 

  7904.             if (this.IsCellEditing)

    7905. 

  7905.                 return false;

    7906. 

  7906. 

    7907. 

  7907.             if (e.Button != MouseButtons.Left)

    7908. 

  7908.                 return false;

    7909. 

  7909. 

    7910. 

  7910.             if ((Control.ModifierKeys & (Keys.Shift | Keys.Control | Keys.Alt)) != 0)

    7911. 

  7911.                 return false;

    7912. 

  7912. 

    7913. 

  7913.             if (this.lastMouseDownClickCount == 1 && this.CellEditActivation == CellEditActivateMode.SingleClick)

    7914. 

  7914.                 return true;

    7915. 

  7915. 

    7916. 

  7916.             return (this.lastMouseDownClickCount == 2 && this.CellEditActivation == CellEditActivateMode.DoubleClick);

    7917. 

  7917.         }

    7918. 

  7918. 

    7919. 

  7919.         /// <summary>

    7920. 

  7920.         /// Handle a key press on this control. We specifically look for F2 which edits the primary column,

    7921. 

  7921.         /// or a Tab character during an edit operation, which tries to start editing on the next (or previous) cell.

    7922. 

  7922.         /// </summary>

    7923. 

  7923.         /// <param name="keyData"></param>

    7924. 

  7924.         /// <returns></returns>

    7925. 

  7925.         protected override bool ProcessDialogKey(Keys keyData) {

    7926. 

  7926. 

    7927. 

  7927.             if (this.IsCellEditing) 

    7928. 

  7928.                 return this.CellEditKeyEngine.HandleKey(this, keyData);

    7929. 

  7929. 

    7930. 

  7930.             // Treat F2 as a request to edit the primary column

    7931. 

  7931.             if (keyData == Keys.F2) {

    7932. 

  7932.                 this.EditSubItem((OLVListItem)this.FocusedItem, 0);

    7933. 

  7933.                 return base.ProcessDialogKey(keyData);

    7934. 

  7934.             }

    7935. 

  7935. 

    7936. 

  7936.             // Treat Ctrl-C as Copy To Clipboard. 

    7937. 

  7937.             if (this.CopySelectionOnControlC && keyData == (Keys.C | Keys.Control)) {

    7938. 

  7938.                 this.CopySelectionToClipboard();

    7939. 

  7939.                 return true;

    7940. 

  7940.             }

    7941. 

  7941. 

    7942. 

  7942.             // Treat Ctrl-A as Select All.

    7943. 

  7943.             if (this.SelectAllOnControlA && keyData == (Keys.A | Keys.Control)) {

    7944. 

  7944.                 this.SelectAll();

    7945. 

  7945.                 return true;

    7946. 

  7946.             }

    7947. 

  7947. 

    7948. 

  7948.             return base.ProcessDialogKey(keyData);

    7949. 

  7949.         }

    7950. 

  7950.        

    7951. 

  7951.         /// <summary>

    7952. 

  7952.         /// Begin an edit operation on the given cell.

    7953. 

  7953.         /// </summary>

    7954. 

  7954.         /// <remarks>This performs various sanity checks and passes off the real work to StartCellEdit().</remarks>

    7955. 

  7955.         /// <param name="item">The row to be edited</param>

    7956. 

  7956.         /// <param name="subItemIndex">The index of the cell to be edited</param>

    7957. 

  7957.         public virtual void EditSubItem(OLVListItem item, int subItemIndex) {

    7958. 

  7958.             if (item == null)

    7959. 

  7959.                 return;

    7960. 

  7960. 

    7961. 

  7961.             if (subItemIndex < 0 && subItemIndex >= item.SubItems.Count)

    7962. 

  7962.                 return;

    7963. 

  7963. 

    7964. 

  7964.             if (this.CellEditActivation == CellEditActivateMode.None)

    7965. 

  7965.                 return;

    7966. 

  7966. 

    7967. 

  7967.             if (!this.GetColumn(subItemIndex).IsEditable)

    7968. 

  7968.                 return;

    7969. 

  7969. 

    7970. 

  7970.             this.StartCellEdit(item, subItemIndex);

    7971. 

  7971.         }

    7972. 

  7972. 

    7973. 

  7973.         /// <summary>

    7974. 

  7974.         /// Really start an edit operation on a given cell. The parameters are assumed to be sane.

    7975. 

  7975.         /// </summary>

    7976. 

  7976.         /// <param name="item">The row to be edited</param>

    7977. 

  7977.         /// <param name="subItemIndex">The index of the cell to be edited</param>

    7978. 

  7978.         public virtual void StartCellEdit(OLVListItem item, int subItemIndex) {

    7979. 

  7979.             OLVColumn column = this.GetColumn(subItemIndex);

    7980. 

  7980.             Rectangle r = this.CalculateCellEditorBounds(item, subItemIndex);

    7981. 

  7981.             Control c = this.GetCellEditor(item, subItemIndex);

    7982. 

  7982.             c.Bounds = r;

    7983. 

  7983. 

    7984. 

  7984.             // Try to align the control as the column is aligned. Not all controls support this property

    7985. 

  7985.             Munger.PutProperty(c, "TextAlign", column.TextAlign);

    7986. 

  7986. 

    7987. 

  7987.             // Give the control the value from the model

    7988. 

  7988.             this.SetControlValue(c, column.GetValue(item.RowObject), column.GetStringValue(item.RowObject));

    7989. 

  7989. 

    7990. 

  7990.             // Give the outside world the chance to munge with the process

    7991. 

  7991.             this.cellEditEventArgs = new CellEditEventArgs(column, c, r, item, subItemIndex);

    7992. 

  7992.             this.OnCellEditStarting(this.cellEditEventArgs);

    7993. 

  7993.             if (this.cellEditEventArgs.Cancel)

    7994. 

  7994.                 return;

    7995. 

  7995. 

    7996. 

  7996.             // The event handler may have completely changed the control, so we need to remember it

    7997. 

  7997.             this.cellEditor = this.cellEditEventArgs.Control;

    7998. 

  7998. 

    7999. 

  7999.             // If the control isn't the height of the cell, centre it vertically. We don't

    8000. 

  8000.             // need to do this when in Tile view.

    8001. 

  8001.             if (this.View != View.Tile && this.cellEditor.Height != r.Height)

    8002. 

  8002.                 this.cellEditor.Top += (r.Height - this.cellEditor.Height) / 2;

    8003. 

  8003. 

    8004. 

  8004.             this.Invalidate();

    8005. 

  8005.             this.Controls.Add(this.cellEditor);

    8006. 

  8006.             this.ConfigureControl();

    8007. 

  8007.             this.PauseAnimations(true);

    8008. 

  8008.         }

    8009. 

  8009.         private Control cellEditor;

    8010. 

  8010.         internal CellEditEventArgs cellEditEventArgs;

    8011. 

  8011. 

    8012. 

  8012.         /// <summary>

    8013. 

  8013.         /// Calculate the bounds of the edit control for the given item/column

    8014. 

  8014.         /// </summary>

    8015. 

  8015.         /// <param name="item"></param>

    8016. 

  8016.         /// <param name="subItemIndex"></param>

    8017. 

  8017.         /// <returns></returns>

    8018. 

  8018.         public Rectangle CalculateCellEditorBounds(OLVListItem item, int subItemIndex) {

    8019. 

  8019.             Rectangle r;

    8020. 

  8020.             if (this.View == View.Details)

    8021. 

  8021.                 r = item.GetSubItemBounds(subItemIndex);

    8022. 

  8022.             else

    8023. 

  8023.                 r = this.GetItemRect(item.Index, ItemBoundsPortion.Label);

    8024. 

  8024.             if (this.OwnerDraw)

    8025. 

  8025.                 return CalculateCellEditorBoundsOwnerDrawn(item, subItemIndex, r);

    8026. 

  8026.             else

    8027. 

  8027.                 return CalculateCellEditorBoundsStandard(item, subItemIndex, r);

    8028. 

  8028.         }

    8029. 

  8029. 

    8030. 

  8030.         /// <summary>

    8031. 

  8031.         /// Calculate the bounds of the edit control for the given item/column, when the listview

    8032. 

  8032.         /// is being owner drawn.

    8033. 

  8033.         /// </summary>

    8034. 

  8034.         /// <param name="item"></param>

    8035. 

  8035.         /// <param name="subItemIndex"></param>

    8036. 

  8036.         /// <param name="r"></param>

    8037. 

  8037.         /// <returns>A rectangle that is the bounds of the cell editor</returns>

    8038. 

  8038.         protected Rectangle CalculateCellEditorBoundsOwnerDrawn(OLVListItem item, int subItemIndex, Rectangle r) {

    8039. 

  8039.             IRenderer renderer = null;

    8040. 

  8040.             if (this.View == View.Details)

    8041. 

  8041.                 renderer = this.GetColumn(subItemIndex).Renderer ?? this.DefaultRenderer;

    8042. 

  8042.             else

    8043. 

  8043.                 renderer = this.ItemRenderer;

    8044. 

  8044. 

    8045. 

  8045.             if (renderer == null)

    8046. 

  8046.                 return r;

    8047. 

  8047.             else {

    8048. 

  8048.                 using (Graphics g = this.CreateGraphics()) {

    8049. 

  8049.                     return renderer.GetEditRectangle(g, r, item, subItemIndex);

    8050. 

  8050.                 }

    8051. 

  8051.             }

    8052. 

  8052.         }

    8053. 

  8053. 

    8054. 

  8054.         /// <summary>

    8055. 

  8055.         /// Calculate the bounds of the edit control for the given item/column, when the listview

    8056. 

  8056.         /// is not being owner drawn.

    8057. 

  8057.         /// </summary>

    8058. 

  8058.         /// <param name="item"></param>

    8059. 

  8059.         /// <param name="subItemIndex"></param>

    8060. 

  8060.         /// <param name="cellBounds"></param>

    8061. 

  8061.         /// <returns>A rectangle that is the bounds of the cell editor</returns>

    8062. 

  8062.         protected Rectangle CalculateCellEditorBoundsStandard(OLVListItem item, int subItemIndex, Rectangle cellBounds) {

    8063. 

  8063.             if (this.View != View.Details)

    8064. 

  8064.                 return cellBounds;//

    8065. 

  8065. 

    8066. 

  8066.             // Allow for image (if there is one)

    8067. 

  8067.             int offset = 0;

    8068. 

  8068.             object subItemImageSelector = item.ImageSelector;

    8069. 

  8069.             if (subItemIndex > 0)

    8070. 

  8070.                 subItemImageSelector = ((OLVListSubItem)item.SubItems[subItemIndex]).ImageSelector;

    8071. 

  8071.             if (this.GetActualImageIndex(subItemImageSelector) != -1) {

    8072. 

  8072.                 offset += this.SmallImageSize.Width + 2;

    8073. 

  8073.             }

    8074. 

  8074. 

    8075. 

  8075.             // Allow for checkbox

    8076. 

  8076.             if (this.CheckBoxes && this.StateImageList != null && subItemIndex == 0) {

    8077. 

  8077.                 offset += this.StateImageList.ImageSize.Width + 2;

    8078. 

  8078.             }

    8079. 

  8079. 

    8080. 

  8080.             // Allow for indent (first column only)

    8081. 

  8081.             if (subItemIndex == 0 && item.IndentCount > 0) {

    8082. 

  8082.                 offset += (this.SmallImageSize.Width * item.IndentCount);

    8083. 

  8083.             }

    8084. 

  8084. 

    8085. 

  8085.             // Do the adjustment

    8086. 

  8086.             if (offset > 0) {

    8087. 

  8087.                 cellBounds.X += offset;

    8088. 

  8088.                 cellBounds.Width -= offset;

    8089. 

  8089.             }

    8090. 

  8090. 

    8091. 

  8091.             return cellBounds;

    8092. 

  8092.         }

    8093. 

  8093. 

    8094. 

  8094.         /// <summary>

    8095. 

  8095.         /// Try to give the given value to the provided control. Fall back to assigning a string

    8096. 

  8096.         /// if the value assignment fails.

    8097. 

  8097.         /// </summary>

    8098. 

  8098.         /// <param name="control">A control</param>

    8099. 

  8099.         /// <param name="value">The value to be given to the control</param>

    8100. 

  8100.         /// <param name="stringValue">The string to be given if the value doesn't work</param>

    8101. 

  8101.         protected virtual void SetControlValue(Control control, Object value, String stringValue) {

    8102. 

  8102.             // Handle combobox explicitly

    8103. 

  8103.             if (control is ComboBox) {

    8104. 

  8104.                 ComboBox cb = ((ComboBox)control);

    8105. 

  8105.                 if (cb.Created)

    8106. 

  8106.                     cb.SelectedValue = value;

    8107. 

  8107.                 else

    8108. 

  8108.                     this.BeginInvoke(new MethodInvoker(delegate {

    8109. 

  8109.                         cb.SelectedValue = value;

    8110. 

  8110.                     }));

    8111. 

  8111.                 return;

    8112. 

  8112.             }

    8113. 

  8113. 

    8114. 

  8114. 

    8115. 

  8115.             if (Munger.PutProperty(control, "Value", value))

    8116. 

  8116.                 return;

    8117. 

  8117. 

    8118. 

  8118.             // There wasn't a Value property, or we couldn't set it, so set the text instead

    8119. 

  8119.             try {

    8120. 

  8120.                 String valueAsString = value as String;

    8121. 

  8121.                 if (valueAsString == null)

    8122. 

  8122.                     control.Text = stringValue;

    8123. 

  8123.                 else

    8124. 

  8124.                     control.Text = valueAsString;

    8125. 

  8125.             } catch (ArgumentOutOfRangeException) {

    8126. 

  8126.                 // The value couldn't be set via the Text property.

    8127. 

  8127.             }

    8128. 

  8128.         }

    8129. 

  8129. 

    8130. 

  8130.         /// <summary>

    8131. 

  8131.         /// Setup the given control to be a cell editor

    8132. 

  8132.         /// </summary>

    8133. 

  8133.         protected virtual void ConfigureControl() {

    8134. 

  8134.             this.cellEditor.Validating += new CancelEventHandler(CellEditor_Validating);

    8135. 

  8135.             this.cellEditor.Select();

    8136. 

  8136.         }

    8137. 

  8137. 

    8138. 

  8138.         /// <summary>

    8139. 

  8139.         /// Return the value that the given control is showing

    8140. 

  8140.         /// </summary>

    8141. 

  8141.         /// <param name="control"></param>

    8142. 

  8142.         /// <returns></returns>

    8143. 

  8143.         protected virtual Object GetControlValue(Control control) {

    8144. 

  8144.             if (control == null)

    8145. 

  8145.                 return null;

    8146. 

  8146. 

    8147. 

  8147.             if (control is TextBox)

    8148. 

  8148.                 return ((TextBox)control).Text;

    8149. 

  8149. 

    8150. 

  8150.             if (control is ComboBox)

    8151. 

  8151.                 return ((ComboBox)control).SelectedValue;

    8152. 

  8152. 

    8153. 

  8153.             if (control is CheckBox)

    8154. 

  8154.                 return ((CheckBox)control).Checked;

    8155. 

  8155. 

    8156. 

  8156.             try {

    8157. 

  8157.                 return control.GetType().InvokeMember("Value", BindingFlags.GetProperty, null, control, null);

    8158. 

  8158.             } catch (MissingMethodException) { // Microsoft throws this

    8159. 

  8159.                 return control.Text;

    8160. 

  8160.             } catch (MissingFieldException) { // Mono throws this

    8161. 

  8161.                 return control.Text;

    8162. 

  8162.             }

    8163. 

  8163.         }

    8164. 

  8164. 

    8165. 

  8165.         /// <summary>

    8166. 

  8166.         /// Called when the cell editor could be about to lose focus. Time to commit the change

    8167. 

  8167.         /// </summary>

    8168. 

  8168.         /// <param name="sender"></param>

    8169. 

  8169.         /// <param name="e"></param>

    8170. 

  8170.         protected virtual void CellEditor_Validating(object sender, CancelEventArgs e) {

    8171. 

  8171.             this.cellEditEventArgs.Cancel = false;

    8172. 

  8172.             this.cellEditEventArgs.NewValue = this.GetControlValue(this.cellEditor);

    8173. 

  8173.             this.OnCellEditorValidating(this.cellEditEventArgs);

    8174. 

  8174. 

    8175. 

  8175.             if (this.cellEditEventArgs.Cancel) {

    8176. 

  8176.                 this.cellEditEventArgs.Control.Select();

    8177. 

  8177.                 e.Cancel = true;

    8178. 

  8178.             } else

    8179. 

  8179.                 FinishCellEdit();

    8180. 

  8180.         }

    8181. 

  8181. 

    8182. 

  8182.         /// <summary>

    8183. 

  8183.         /// Return the bounds of the given cell

    8184. 

  8184.         /// </summary>

    8185. 

  8185.         /// <param name="item">The row to be edited</param>

    8186. 

  8186.         /// <param name="subItemIndex">The index of the cell to be edited</param>

    8187. 

  8187.         /// <returns>A Rectangle</returns>

    8188. 

  8188.         public virtual Rectangle CalculateCellBounds(OLVListItem item, int subItemIndex) {

    8189. 

  8189.             // We use ItemBoundsPortion.Label rather than ItemBoundsPortion.Item

    8190. 

  8190.             // since Label extends to the right edge of the cell, whereas Item gives just the

    8191. 

  8191.             // current text width.

    8192. 

  8192.             return this.CalculateCellBounds(item, subItemIndex, ItemBoundsPortion.Label);

    8193. 

  8193.         }

    8194. 

  8194. 

    8195. 

  8195.         /// <summary>

    8196. 

  8196.         /// Return the bounds of the given cell only until the edge of the current text

    8197. 

  8197.         /// </summary>

    8198. 

  8198.         /// <param name="item">The row to be edited</param>

    8199. 

  8199.         /// <param name="subItemIndex">The index of the cell to be edited</param>

    8200. 

  8200.         /// <returns>A Rectangle</returns>

    8201. 

  8201.         public virtual Rectangle CalculateCellTextBounds(OLVListItem item, int subItemIndex) {

    8202. 

  8202.             return this.CalculateCellBounds(item, subItemIndex, ItemBoundsPortion.ItemOnly);

    8203. 

  8203.         }

    8204. 

  8204. 

    8205. 

  8205.         private Rectangle CalculateCellBounds(OLVListItem item, int subItemIndex, ItemBoundsPortion portion) {

    8206. 

  8206.             // SubItem.Bounds works for every subitem, except the first.

    8207. 

  8207.             if (subItemIndex > 0)

    8208. 

  8208.                 return item.SubItems[subItemIndex].Bounds;

    8209. 

  8209. 

    8210. 

  8210.             // For non detail views, we just use the requested portion

    8211. 

  8211.             Rectangle r = this.GetItemRect(item.Index, portion);

    8212. 

  8212.             if (r.Y < -10000000 || r.Y > 10000000) {

    8213. 

  8213.                 r.Y = item.Bounds.Y;

    8214. 

  8214.             }

    8215. 

  8215.             if (this.View != View.Details)

    8216. 

  8216.                 return r;

    8217. 

  8217. 

    8218. 

  8218.             // Finding the bounds of cell 0 should not be a difficult task, but it is. Problems:

    8219. 

  8219.             // 1) item.SubItem[0].Bounds is always the full bounds of the entire row, not just cell 0.

    8220. 

  8220.             // 2) if column 0 has been dragged to some other position, the bounds always has a left edge of 0.

    8221. 

  8221. 

    8222. 

  8222.             // We avoid both these problems by using the position of sides the column header to calculate

    8223. 

  8223.             // the sides of the cell

    8224. 

  8224.             Point sides = NativeMethods.GetScrolledColumnSides(this, 0);

    8225. 

  8225.             r.X = sides.X + 4;

    8226. 

  8226.             r.Width = sides.Y - sides.X - 5;

    8227. 

  8227. 

    8228. 

  8228.             return r;

    8229. 

  8229.         }

    8230. 

  8230. 

    8231. 

  8231.         /// <summary>

    8232. 

  8232.         /// Return a control that can be used to edit the value of the given cell.

    8233. 

  8233.         /// </summary>

    8234. 

  8234.         /// <param name="item">The row to be edited</param>

    8235. 

  8235.         /// <param name="subItemIndex">The index of the cell to be edited</param>

    8236. 

  8236.         /// <returns>A Control to edit the given cell</returns>

    8237. 

  8237.         protected virtual Control GetCellEditor(OLVListItem item, int subItemIndex) {

    8238. 

  8238.             OLVColumn column = this.GetColumn(subItemIndex);

    8239. 

  8239.             Object value = column.GetValue(item.RowObject) ?? this.GetFirstNonNullValue(column);

    8240. 

  8240. 

    8241. 

  8241.             // TODO: What do we do if value is still null here?

    8242. 

  8242. 

    8243. 

  8243.             // Ask the registry for an instance of the appropriate editor.

    8244. 

  8244.             Control editor = ObjectListView.EditorRegistry.GetEditor(item.RowObject, column, value);

    8245. 

  8245. 

    8246. 

  8246.             // Use a default editor if the registry can't create one for us.

    8247. 

  8247.             if (editor == null)

    8248. 

  8248.                 editor = this.MakeDefaultCellEditor(column);

    8249. 

  8249. 

    8250. 

  8250.             return editor;

    8251. 

  8251.         }

    8252. 

  8252. 

    8253. 

  8253.         /// <summary>

    8254. 

  8254.         /// Get the first non-null value of the given column.

    8255. 

  8255.         /// At most 1000 rows will be considered.

    8256. 

  8256.         /// </summary>

    8257. 

  8257.         /// <param name="column"></param>

    8258. 

  8258.         /// <returns>The first non-null value, or null if no non-null values were found</returns>

    8259. 

  8259.         internal object GetFirstNonNullValue(OLVColumn column) {

    8260. 

  8260.             for (int i = 0; i < Math.Min(this.GetItemCount(), 1000); i++) {

    8261. 

  8261.                 object value = column.GetValue(this.GetModelObject(i));

    8262. 

  8262.                 if (value != null)

    8263. 

  8263.                     return value;

    8264. 

  8264.             }

    8265. 

  8265.             return null;

    8266. 

  8266.         }

    8267. 

  8267. 

    8268. 

  8268.         /// <summary>

    8269. 

  8269.         /// Return a TextBox that can be used as a default cell editor.

    8270. 

  8270.         /// </summary>

    8271. 

  8271.         /// <param name="column">What column does the cell belong to?</param>

    8272. 

  8272.         /// <returns></returns>

    8273. 

  8273.         protected virtual Control MakeDefaultCellEditor(OLVColumn column) {

    8274. 

  8274.             TextBox tb = new TextBox();

    8275. 

  8275.             if (column.AutoCompleteEditor)

    8276. 

  8276.                 this.ConfigureAutoComplete(tb, column);

    8277. 

  8277.             return tb;

    8278. 

  8278.         }

    8279. 

  8279. 

    8280. 

  8280.         /// <summary>

    8281. 

  8281.         /// Configure the given text box to autocomplete unique values

    8282. 

  8282.         /// from the given column. At most 1000 rows will be considered.

    8283. 

  8283.         /// </summary>

    8284. 

  8284.         /// <param name="tb">The textbox to configure</param>

    8285. 

  8285.         /// <param name="column">The column used to calculate values</param>

    8286. 

  8286.         public void ConfigureAutoComplete(TextBox tb, OLVColumn column) {

    8287. 

  8287.             this.ConfigureAutoComplete(tb, column, 1000);

    8288. 

  8288.         }

    8289. 

  8289. 

    8290. 

  8290. 

    8291. 

  8291.         /// <summary>

    8292. 

  8292.         /// Configure the given text box to autocomplete unique values

    8293. 

  8293.         /// from the given column. At most 1000 rows will be considered.

    8294. 

  8294.         /// </summary>

    8295. 

  8295.         /// <param name="tb">The textbox to configure</param>

    8296. 

  8296.         /// <param name="column">The column used to calculate values</param>

    8297. 

  8297.         /// <param name="maxRows">Consider only this many rows</param>

    8298. 

  8298.         public void ConfigureAutoComplete(TextBox tb, OLVColumn column, int maxRows) {

    8299. 

  8299.             // Don't consider more rows than we actually have

    8300. 

  8300.             maxRows = Math.Min(this.GetItemCount(), maxRows);

    8301. 

  8301. 

    8302. 

  8302.             // Reset any existing autocomplete

    8303. 

  8303.             tb.AutoCompleteCustomSource.Clear();

    8304. 

  8304. 

    8305. 

  8305.             // CONSIDER: Should we use ClusteringStrategy here?

    8306. 

  8306. 

    8307. 

  8307.             // Build a list of unique values, to be used as autocomplete on the editor

    8308. 

  8308.             Dictionary<string, bool> alreadySeen = new Dictionary<string, bool>();

    8309. 

  8309.             List<string> values = new List<string>();

    8310. 

  8310.             for (int i = 0; i < maxRows; i++) {

    8311. 

  8311.                 string valueAsString = column.GetStringValue(this.GetModelObject(i));

    8312. 

  8312.                 if (!String.IsNullOrEmpty(valueAsString) && !alreadySeen.ContainsKey(valueAsString)) {

    8313. 

  8313.                     values.Add(valueAsString);

    8314. 

  8314.                     alreadySeen[valueAsString] = true;

    8315. 

  8315.                 }

    8316. 

  8316.             }

    8317. 

  8317. 

    8318. 

  8318.             tb.AutoCompleteCustomSource.AddRange(values.ToArray());

    8319. 

  8319.             tb.AutoCompleteSource = AutoCompleteSource.CustomSource;

    8320. 

  8320.             tb.AutoCompleteMode = column.AutoCompleteEditorMode;

    8321. 

  8321.         }

    8322. 

  8322. 

    8323. 

  8323.         /// <summary>

    8324. 

  8324.         /// Stop editing a cell and throw away any changes.

    8325. 

  8325.         /// </summary>

    8326. 

  8326.         public virtual void CancelCellEdit() {

    8327. 

  8327.             if (!this.IsCellEditing)

    8328. 

  8328.                 return;

    8329. 

  8329. 

    8330. 

  8330.             // Let the world know that the user has cancelled the edit operation

    8331. 

  8331.             this.cellEditEventArgs.Cancel = true;

    8332. 

  8332.             this.cellEditEventArgs.NewValue = this.GetControlValue(this.cellEditor);

    8333. 

  8333.             this.OnCellEditFinishing(this.cellEditEventArgs);

    8334. 

  8334. 

    8335. 

  8335.             // Now cleanup the editing process

    8336. 

  8336.             this.CleanupCellEdit();

    8337. 

  8337.         }

    8338. 

  8338. 

    8339. 

  8339.         /// <summary>

    8340. 

  8340.         /// If a cell edit is in progress, finish the edit.

    8341. 

  8341.         /// </summary>

    8342. 

  8342.         /// <returns>Returns false if the finishing process was cancelled

    8343. 

  8343.         /// (i.e. the cell editor is still on screen)</returns>

    8344. 

  8344.         /// <remarks>This method does not guarantee that the editing will finish. The validation

    8345. 

  8345.         /// process can cause the finishing to be aborted. Developers should check the return value

    8346. 

  8346.         /// or use IsCellEditing property after calling this method to see if the user is still

    8347. 

  8347.         /// editing a cell.</remarks>

    8348. 

  8348.         public virtual bool PossibleFinishCellEditing() {

    8349. 

  8349.             if (!this.IsCellEditing)

    8350. 

  8350.                 return true;

    8351. 

  8351. 

    8352. 

  8352.             this.cellEditEventArgs.Cancel = false;

    8353. 

  8353.             this.cellEditEventArgs.NewValue = this.GetControlValue(this.cellEditor);

    8354. 

  8354.             this.OnCellEditorValidating(this.cellEditEventArgs);

    8355. 

  8355. 

    8356. 

  8356.             if (this.cellEditEventArgs.Cancel)

    8357. 

  8357.                 return false;

    8358. 

  8358. 

    8359. 

  8359.             this.FinishCellEdit();

    8360. 

  8360. 

    8361. 

  8361.             return true;

    8362. 

  8362.         }

    8363. 

  8363. 

    8364. 

  8364.         /// <summary>

    8365. 

  8365.         /// Finish the cell edit operation, writing changed data back to the model object

    8366. 

  8366.         /// </summary>

    8367. 

  8367.         /// <remarks>This method does not trigger a Validating event, so it always finishes

    8368. 

  8368.         /// the cell edit.</remarks>

    8369. 

  8369.         public virtual void FinishCellEdit() {

    8370. 

  8370.             if (!this.IsCellEditing)

    8371. 

  8371.                 return;

    8372. 

  8372. 

    8373. 

  8373.             this.cellEditEventArgs.Cancel = false;

    8374. 

  8374.             this.cellEditEventArgs.NewValue = this.GetControlValue(this.cellEditor);

    8375. 

  8375.             this.OnCellEditFinishing(this.cellEditEventArgs);

    8376. 

  8376. 

    8377. 

  8377.             // If someone doesn't cancel the editing process, write the value back into the model

    8378. 

  8378.             if (!this.cellEditEventArgs.Cancel) {

    8379. 

  8379.                 this.cellEditEventArgs.Column.PutValue(this.cellEditEventArgs.RowObject, this.cellEditEventArgs.NewValue);

    8380. 

  8380.                 this.RefreshItem(this.cellEditEventArgs.ListViewItem);

    8381. 

  8381.             }

    8382. 

  8382. 

    8383. 

  8383.             this.CleanupCellEdit();

    8384. 

  8384.         }

    8385. 

  8385. 

    8386. 

  8386.         /// <summary>

    8387. 

  8387.         /// Remove all trace of any existing cell edit operation

    8388. 

  8388.         /// </summary>

    8389. 

  8389.         protected virtual void CleanupCellEdit() {

    8390. 

  8390.             if (this.cellEditor == null)

    8391. 

  8391.                 return;

    8392. 

  8392. 

    8393. 

  8393.             this.cellEditor.Validating -= new CancelEventHandler(CellEditor_Validating);

    8394. 

  8394. 

    8395. 

  8395.             Control soonToBeOldCellEditor = this.cellEditor;

    8396. 

  8396.             this.cellEditor = null;

    8397. 

  8397. 

    8398. 

  8398.             // Delay cleaning up the cell editor so that if we are immediately going to 

    8399. 

  8399.             // start a new cell edit (because the user pressed Tab) the new cell editor

    8400. 

  8400.             // has a chance to grab the focus. Without this, the ListView gains focus

    8401. 

  8401.             // momentarily (after the cell editor is remove and before the new one is created)

    8402. 

  8402.             // causing the list's selection to flash momentarily.

    8403. 

  8403.             EventHandler toBeRun = null;

    8404. 

  8404.             toBeRun = delegate(object sender, EventArgs e) {

    8405. 

  8405.                 Application.Idle -= toBeRun;

    8406. 

  8406.                 this.Controls.Remove(soonToBeOldCellEditor);

    8407. 

  8407.                 this.Invalidate();

    8408. 

  8408. 

    8409. 

  8409.                 if (!this.IsCellEditing) {

    8410. 

  8410.                     this.Select();

    8411. 

  8411.                     this.PauseAnimations(false);

    8412. 

  8412.                 }

    8413. 

  8413.             };

    8414. 

  8414. 

    8415. 

  8415.             Application.Idle += toBeRun;

    8416. 

  8416.         }

    8417. 

  8417. 

    8418. 

  8418.         #endregion

    8419. 

  8419. 

    8420. 

  8420.         #region Hot row and cell handling

    8421. 

  8421. 

    8422. 

  8422.         /// <summary>

    8423. 

  8423.         /// Force the hot item to be recalculated

    8424. 

  8424.         /// </summary>

    8425. 

  8425.         public virtual void ClearHotItem() {

    8426. 

  8426.             this.UpdateHotItem(new Point(-1, -1));

    8427. 

  8427.         }

    8428. 

  8428. 

    8429. 

  8429.         /// <summary>

    8430. 

  8430.         /// Force the hot item to be recalculated

    8431. 

  8431.         /// </summary>

    8432. 

  8432.         public virtual void RefreshHotItem() {

    8433. 

  8433.             this.UpdateHotItem(this.PointToClient(Cursor.Position));

    8434. 

  8434.         }

    8435. 

  8435. 

    8436. 

  8436.         /// <summary>

    8437. 

  8437.         /// The mouse has moved to the given pt. See if the hot item needs to be updated

    8438. 

  8438.         /// </summary>

    8439. 

  8439.         /// <param name="pt">Where is the mouse?</param>

    8440. 

  8440.         /// <remarks>This is the main entry point for hot item handling</remarks>

    8441. 

  8441.         protected virtual void UpdateHotItem(Point pt) {

    8442. 

  8442.             this.UpdateHotItem(this.OlvHitTest(pt.X, pt.Y));

    8443. 

  8443.         }

    8444. 

  8444.         /// <summary>

    8445. 

  8445.         /// The mouse has moved to the given pt. See if the hot item needs to be updated

    8446. 

  8446.         /// </summary>

    8447. 

  8447.         /// <param name="hti"></param>

    8448. 

  8448.         /// <remarks>This is the main entry point for hot item handling</remarks>

    8449. 

  8449.         protected virtual void UpdateHotItem(OlvListViewHitTestInfo hti) {

    8450. 

  8450. 

    8451. 

  8451.             if (!this.UseHotItem && !this.UseHyperlinks)

    8452. 

  8452.                 return;

    8453. 

  8453. 

    8454. 

  8454.             int newHotRow = hti.RowIndex;

    8455. 

  8455.             int newHotColumn = hti.ColumnIndex;

    8456. 

  8456.             HitTestLocation newHotCellHitLocation = hti.HitTestLocation;

    8457. 

  8457. 

    8458. 

  8458.             // In non-details view, we treat any hit on a row as if it were a hit

    8459. 

  8459.             // on column 0 -- which (effectively) it is!

    8460. 

  8460.             if (newHotRow >= 0 && this.View != View.Details)

    8461. 

  8461.                 newHotColumn = 0;

    8462. 

  8462. 

    8463. 

  8463.             if (this.HotRowIndex == newHotRow &&

    8464. 

  8464.                 this.HotColumnIndex == newHotColumn &&

    8465. 

  8465.                 this.HotCellHitLocation == newHotCellHitLocation)

    8466. 

  8466.                 return;

    8467. 

  8467. 

    8468. 

  8468.             // Trigger the hotitem changed event

    8469. 

  8469.             HotItemChangedEventArgs args = new HotItemChangedEventArgs();

    8470. 

  8470.             args.HotCellHitLocation = newHotCellHitLocation;

    8471. 

  8471.             args.HotColumnIndex = newHotColumn;

    8472. 

  8472.             args.HotRowIndex = newHotRow;

    8473. 

  8473.             args.OldHotCellHitLocation = this.HotCellHitLocation;

    8474. 

  8474.             args.OldHotColumnIndex = this.HotColumnIndex;

    8475. 

  8475.             args.OldHotRowIndex = this.HotRowIndex;

    8476. 

  8476.             this.OnHotItemChanged(args);

    8477. 

  8477. 

    8478. 

  8478.             // Update the state of the control

    8479. 

  8479.             this.HotRowIndex = newHotRow;

    8480. 

  8480.             this.HotColumnIndex = newHotColumn;

    8481. 

  8481.             this.HotCellHitLocation = newHotCellHitLocation;

    8482. 

  8482. 

    8483. 

  8483.             // If the event handler handled it complete, don't do anything else

    8484. 

  8484.             if (args.Handled)

    8485. 

  8485.                 return;

    8486. 

  8486. 

    8487. 

  8487.             this.BeginUpdate();

    8488. 

  8488.             try {

    8489. 

  8489.                 this.Invalidate();

    8490. 

  8490.                 if (args.OldHotRowIndex != -1)

    8491. 

  8491.                     this.UnapplyHotItem(args.OldHotRowIndex);

    8492. 

  8492. 

    8493. 

  8493.                 if (this.HotRowIndex != -1) {

    8494. 

  8494.                     // Virtual lists apply hot item style when fetching their rows

    8495. 

  8495.                     if (this.VirtualMode)

    8496. 

  8496.                         this.RedrawItems(this.HotRowIndex, this.HotRowIndex, true);

    8497. 

  8497.                     else

    8498. 

  8498.                         this.UpdateHotRow(this.HotRowIndex, this.HotColumnIndex, this.HotCellHitLocation, hti.Item);

    8499. 

  8499.                 }

    8500. 

  8500. 

    8501. 

  8501.                 if (this.UseHotItem && this.HotItemStyle != null && this.HotItemStyle.Overlay != null) {

    8502. 

  8502.                     this.RefreshOverlays();

    8503. 

  8503.                 }

    8504. 

  8504.             } finally {

    8505. 

  8505.                 this.EndUpdate();

    8506. 

  8506.             }

    8507. 

  8507.         }

    8508. 

  8508. 

    8509. 

  8509.         /// <summary>

    8510. 

  8510.         /// Update the given row using the current hot item information

    8511. 

  8511.         /// </summary>

    8512. 

  8512.         /// <param name="olvi"></param>

    8513. 

  8513.         protected virtual void UpdateHotRow(OLVListItem olvi) {

    8514. 

  8514.             this.UpdateHotRow(this.HotRowIndex, this.HotColumnIndex, this.HotCellHitLocation, olvi);

    8515. 

  8515.         }

    8516. 

  8516. 

    8517. 

  8517.         /// <summary>

    8518. 

  8518.         /// Update the given row using the given hot item information

    8519. 

  8519.         /// </summary>

    8520. 

  8520.         /// <param name="rowIndex"></param>

    8521. 

  8521.         /// <param name="columnIndex"></param>

    8522. 

  8522.         /// <param name="hitLocation"></param>

    8523. 

  8523.         /// <param name="olvi"></param>

    8524. 

  8524.         protected virtual void UpdateHotRow(int rowIndex, int columnIndex, HitTestLocation hitLocation, OLVListItem olvi) {

    8525. 

  8525.             if (rowIndex < 0 || columnIndex < 0)

    8526. 

  8526.                 return;

    8527. 

  8527. 

    8528. 

  8528.             if (this.UseHyperlinks) {

    8529. 

  8529.                 OLVColumn column = this.GetColumn(columnIndex);

    8530. 

  8530.                 OLVListSubItem subItem = olvi.GetSubItem(columnIndex);

    8531. 

  8531.                 if (column.Hyperlink && hitLocation == HitTestLocation.Text && !String.IsNullOrEmpty(subItem.Url)) {

    8532. 

  8532.                     this.ApplyCellStyle(olvi, columnIndex, this.HyperlinkStyle.Over);

    8533. 

  8533.                     this.Cursor = this.HyperlinkStyle.OverCursor ?? Cursors.Default;

    8534. 

  8534.                 } else {

    8535. 

  8535.                     this.Cursor = Cursors.Default;

    8536. 

  8536.                 }

    8537. 

  8537.             }

    8538. 

  8538. 

    8539. 

  8539.             if (this.UseHotItem) {

    8540. 

  8540.                 if (!olvi.Selected) {

    8541. 

  8541.                     this.ApplyRowStyle(olvi, this.HotItemStyle);

    8542. 

  8542.                 }

    8543. 

  8543.             }

    8544. 

  8544.         }

    8545. 

  8545. 

    8546. 

  8546.         /// <summary>

    8547. 

  8547.         /// Apply a style to the given row

    8548. 

  8548.         /// </summary>

    8549. 

  8549.         /// <param name="olvi"></param>

    8550. 

  8550.         /// <param name="style"></param>

    8551. 

  8551.         protected virtual void ApplyRowStyle(OLVListItem olvi, IItemStyle style) {

    8552. 

  8552.             if (style == null)

    8553. 

  8553.                 return;

    8554. 

  8554. 

    8555. 

  8555.             if (this.FullRowSelect || this.View != View.Details) {

    8556. 

  8556.                 if (style.Font != null)

    8557. 

  8557.                     olvi.Font = style.Font;

    8558. 

  8558. 

    8559. 

  8559.                 if (style.FontStyle != FontStyle.Regular)

    8560. 

  8560.                     olvi.Font = new Font(olvi.Font ?? this.Font, style.FontStyle);

    8561. 

  8561. 

    8562. 

  8562.                 if (!style.ForeColor.IsEmpty) {

    8563. 

  8563.                     if (olvi.UseItemStyleForSubItems)

    8564. 

  8564.                         olvi.ForeColor = style.ForeColor;

    8565. 

  8565.                     else {

    8566. 

  8566.                         foreach (ListViewItem.ListViewSubItem x in olvi.SubItems) {

    8567. 

  8567.                             x.ForeColor = style.ForeColor;

    8568. 

  8568.                         }

    8569. 

  8569.                     }

    8570. 

  8570.                 }

    8571. 

  8571. 

    8572. 

  8572.                 if (!style.BackColor.IsEmpty) {

    8573. 

  8573.                     if (olvi.UseItemStyleForSubItems)

    8574. 

  8574.                         olvi.BackColor = style.BackColor;

    8575. 

  8575.                     else {

    8576. 

  8576.                         foreach (ListViewItem.ListViewSubItem x in olvi.SubItems) {

    8577. 

  8577.                             x.BackColor = style.BackColor;

    8578. 

  8578.                         }

    8579. 

  8579.                     }

    8580. 

  8580.                 }

    8581. 

  8581.             } else {

    8582. 

  8582.                 olvi.UseItemStyleForSubItems = false;

    8583. 

  8583. 

    8584. 

  8584.                 foreach (ListViewItem.ListViewSubItem x in olvi.SubItems) {

    8585. 

  8585.                     if (style.BackColor.IsEmpty)

    8586. 

  8586.                         x.BackColor = olvi.BackColor;

    8587. 

  8587.                     else

    8588. 

  8588.                         x.BackColor = style.BackColor;

    8589. 

  8589.                 }

    8590. 

  8590. 

    8591. 

  8591.                 this.ApplyCellStyle(olvi, 0, style);

    8592. 

  8592.             }

    8593. 

  8593.         }

    8594. 

  8594. 

    8595. 

  8595.         /// <summary>

    8596. 

  8596.         /// Apply a style to a cell

    8597. 

  8597.         /// </summary>

    8598. 

  8598.         /// <param name="olvi"></param>

    8599. 

  8599.         /// <param name="columnIndex"></param>

    8600. 

  8600.         /// <param name="style"></param>

    8601. 

  8601.         protected virtual void ApplyCellStyle(OLVListItem olvi, int columnIndex, IItemStyle style) {

    8602. 

  8602.             if (style == null)

    8603. 

  8603.                 return;

    8604. 

  8604. 

    8605. 

  8605.             // Don't apply formatting to subitems when not in Details view

    8606. 

  8606.             if (this.View != View.Details && columnIndex > 0)

    8607. 

  8607.                 return;

    8608. 

  8608. 

    8609. 

  8609.             olvi.UseItemStyleForSubItems = false;

    8610. 

  8610. 

    8611. 

  8611.             ListViewItem.ListViewSubItem subItem = olvi.SubItems[columnIndex];

    8612. 

  8612.             if (style.Font != null)

    8613. 

  8613.                 subItem.Font = style.Font;

    8614. 

  8614. 

    8615. 

  8615.             if (style.FontStyle != FontStyle.Regular)

    8616. 

  8616.                 subItem.Font = new Font(subItem.Font ?? olvi.Font ?? this.Font, style.FontStyle);

    8617. 

  8617. 

    8618. 

  8618.             if (!style.ForeColor.IsEmpty)

    8619. 

  8619.                 subItem.ForeColor = style.ForeColor;

    8620. 

  8620. 

    8621. 

  8621.             if (!style.BackColor.IsEmpty)

    8622. 

  8622.                 subItem.BackColor = style.BackColor;

    8623. 

  8623.         }

    8624. 

  8624. 

    8625. 

  8625.         /// <summary>

    8626. 

  8626.         /// Remove hot item styling from the given row

    8627. 

  8627.         /// </summary>

    8628. 

  8628.         /// <param name="index"></param>

    8629. 

  8629.         protected virtual void UnapplyHotItem(int index) {

    8630. 

  8630.             this.Cursor = Cursors.Default;

    8631. 

  8631.             // Virtual lists will apply the appropriate formatting when the row is fetched

    8632. 

  8632.             if (this.VirtualMode) {

    8633. 

  8633.                 if (index < this.VirtualListSize)

    8634. 

  8634.                     this.RedrawItems(index, index, true);

    8635. 

  8635.             } else {

    8636. 

  8636.                 OLVListItem olvi = this.GetItem(index);

    8637. 

  8637.                 if (olvi != null) {

    8638. 

  8638.                     //this.PostProcessOneRow(index, index, olvi);

    8639. 

  8639.                     this.RefreshItem(olvi);

    8640. 

  8640.                 }

    8641. 

  8641.             }

    8642. 

  8642.         }

    8643. 

  8643. 

    8644. 

  8644. 

    8645. 

  8645.         #endregion

    8646. 

  8646. 

    8647. 

  8647.         #region Drag and drop

    8648. 

  8648. 

    8649. 

  8649.         /// <summary>

    8650. 

  8650.         /// 

    8651. 

  8651.         /// </summary>

    8652. 

  8652.         /// <param name="e"></param>

    8653. 

  8653.         protected override void OnItemDrag(ItemDragEventArgs e) {

    8654. 

  8654.             base.OnItemDrag(e);

    8655. 

  8655. 

    8656. 

  8656.             if (this.DragSource == null)

    8657. 

  8657.                 return;

    8658. 

  8658. 

    8659. 

  8659.             Object data = this.DragSource.StartDrag(this, e.Button, (OLVListItem)e.Item);

    8660. 

  8660.             if (data != null) {

    8661. 

  8661.                 DragDropEffects effect = this.DoDragDrop(data, this.DragSource.GetAllowedEffects(data));

    8662. 

  8662.                 this.DragSource.EndDrag(data, effect);

    8663. 

  8663.             }

    8664. 

  8664.         }

    8665. 

  8665. 

    8666. 

  8666.         /// <summary>

    8667. 

  8667.         /// 

    8668. 

  8668.         /// </summary>

    8669. 

  8669.         /// <param name="args"></param>

    8670. 

  8670.         protected override void OnDragEnter(DragEventArgs args) {

    8671. 

  8671.             base.OnDragEnter(args);

    8672. 

  8672. 

    8673. 

  8673.             if (this.DropSink != null)

    8674. 

  8674.                 this.DropSink.Enter(args);

    8675. 

  8675.         }

    8676. 

  8676. 

    8677. 

  8677.         /// <summary>

    8678. 

  8678.         /// 

    8679. 

  8679.         /// </summary>

    8680. 

  8680.         /// <param name="args"></param>

    8681. 

  8681.         protected override void OnDragOver(DragEventArgs args) {

    8682. 

  8682.             base.OnDragOver(args);

    8683. 

  8683. 

    8684. 

  8684.             if (this.DropSink != null)

    8685. 

  8685.                 this.DropSink.Over(args);

    8686. 

  8686.         }

    8687. 

  8687. 

    8688. 

  8688.         /// <summary>

    8689. 

  8689.         /// 

    8690. 

  8690.         /// </summary>

    8691. 

  8691.         /// <param name="args"></param>

    8692. 

  8692.         protected override void OnDragDrop(DragEventArgs args) {

    8693. 

  8693.             base.OnDragDrop(args);

    8694. 

  8694. 

    8695. 

  8695.             if (this.DropSink != null)

    8696. 

  8696.                 this.DropSink.Drop(args);

    8697. 

  8697.         }

    8698. 

  8698. 

    8699. 

  8699.         /// <summary>

    8700. 

  8700.         /// 

    8701. 

  8701.         /// </summary>

    8702. 

  8702.         /// <param name="e"></param>

    8703. 

  8703.         protected override void OnDragLeave(EventArgs e) {

    8704. 

  8704.             base.OnDragLeave(e);

    8705. 

  8705. 

    8706. 

  8706.             if (this.DropSink != null)

    8707. 

  8707.                 this.DropSink.Leave();

    8708. 

  8708.         }

    8709. 

  8709. 

    8710. 

  8710.         /// <summary>

    8711. 

  8711.         /// 

    8712. 

  8712.         /// </summary>

    8713. 

  8713.         /// <param name="args"></param>

    8714. 

  8714.         protected override void OnGiveFeedback(GiveFeedbackEventArgs args) {

    8715. 

  8715.             base.OnGiveFeedback(args);

    8716. 

  8716. 

    8717. 

  8717.             if (this.DropSink != null)

    8718. 

  8718.                 this.DropSink.GiveFeedback(args);

    8719. 

  8719.         }

    8720. 

  8720. 

    8721. 

  8721.         /// <summary>

    8722. 

  8722.         /// 

    8723. 

  8723.         /// </summary>

    8724. 

  8724.         /// <param name="args"></param>

    8725. 

  8725.         protected override void OnQueryContinueDrag(QueryContinueDragEventArgs args) {

    8726. 

  8726.             base.OnQueryContinueDrag(args);

    8727. 

  8727. 

    8728. 

  8728.             if (this.DropSink != null)

    8729. 

  8729.                 this.DropSink.QueryContinue(args);

    8730. 

  8730.         }

    8731. 

  8731. 

    8732. 

  8732.         #endregion

    8733. 

  8733. 

    8734. 

  8734.         #region Decorations and Overlays

    8735. 

  8735. 

    8736. 

  8736.         /// <summary>

    8737. 

  8737.         /// Add the given decoration to those on this list and make it appear

    8738. 

  8738.         /// </summary>

    8739. 

  8739.         /// <param name="decoration">The decoration</param>

    8740. 

  8740.         /// <remarks>

    8741. 

  8741.         /// A decoration scrolls with the listview. An overlay stays fixed in place.

    8742. 

  8742.         /// </remarks>

    8743. 

  8743.         public virtual void AddDecoration(IDecoration decoration) {

    8744. 

  8744.             if (decoration == null)

    8745. 

  8745.                 return;

    8746. 

  8746.             this.Decorations.Add(decoration);

    8747. 

  8747.             this.Invalidate();

    8748. 

  8748.         }

    8749. 

  8749. 

    8750. 

  8750.         /// <summary>

    8751. 

  8751.         /// Add the given overlay to those on this list and make it appear

    8752. 

  8752.         /// </summary>

    8753. 

  8753.         /// <param name="overlay">The overlay</param>

    8754. 

  8754.         public virtual void AddOverlay(IOverlay overlay) {

    8755. 

  8755.             if (overlay == null)

    8756. 

  8756.                 return;

    8757. 

  8757.             this.Overlays.Add(overlay);

    8758. 

  8758.             this.Invalidate();

    8759. 

  8759.         }

    8760. 

  8760. 

    8761. 

  8761.         /// <summary>

    8762. 

  8762.         /// Draw all the decorations

    8763. 

  8763.         /// </summary>

    8764. 

  8764.         /// <param name="g">A Graphics</param>

    8765. 

  8765.         /// <param name="drawnItems">The items that were redrawn and whose decorations should also be redrawn</param>

    8766. 

  8766.         protected virtual void DrawAllDecorations(Graphics g, List<OLVListItem> drawnItems) {

    8767. 

  8767.             g.TextRenderingHint = ObjectListView.TextRenderingHint;

    8768. 

  8768.             g.SmoothingMode = ObjectListView.SmoothingMode;

    8769. 

  8769. 

    8770. 

  8770.             Rectangle contentRectangle = this.ContentRectangle;

    8771. 

  8771. 

    8772. 

  8772.             if (this.HasEmptyListMsg && this.GetItemCount() == 0) {

    8773. 

  8773.                 this.EmptyListMsgOverlay.Draw(this, g, contentRectangle);

    8774. 

  8774.             }

    8775. 

  8775. 

    8776. 

  8776.             // Let the drop sink draw whatever feedback it likes

    8777. 

  8777.             if (this.DropSink != null) {

    8778. 

  8778.                 this.DropSink.DrawFeedback(g, contentRectangle);

    8779. 

  8779.             }

    8780. 

  8780. 

    8781. 

  8781.             // Draw our item and subitem decorations

    8782. 

  8782.             foreach (OLVListItem olvi in drawnItems) {

    8783. 

  8783.                 if (olvi.HasDecoration) {

    8784. 

  8784.                     foreach (IDecoration d in olvi.Decorations) {

    8785. 

  8785.                         d.ListItem = olvi;

    8786. 

  8786.                         d.SubItem = null;

    8787. 

  8787.                         d.Draw(this, g, contentRectangle);

    8788. 

  8788.                     }

    8789. 

  8789.                 }

    8790. 

  8790.                 foreach (OLVListSubItem subItem in olvi.SubItems) {

    8791. 

  8791.                     if (subItem.HasDecoration) {

    8792. 

  8792.                         foreach (IDecoration d in subItem.Decorations) {

    8793. 

  8793.                             d.ListItem = olvi;

    8794. 

  8794.                             d.SubItem = subItem;

    8795. 

  8795.                             d.Draw(this, g, contentRectangle);

    8796. 

  8796.                         }

    8797. 

  8797.                     }

    8798. 

  8798.                 }

    8799. 

  8799.                 if (this.SelectedRowDecoration != null && olvi.Selected) {

    8800. 

  8800.                     this.SelectedRowDecoration.ListItem = olvi;

    8801. 

  8801.                     this.SelectedRowDecoration.SubItem = null;

    8802. 

  8802.                     this.SelectedRowDecoration.Draw(this, g, contentRectangle);

    8803. 

  8803.                 }

    8804. 

  8804.             }

    8805. 

  8805. 

    8806. 

  8806.             // Now draw the specifically registered decorations

    8807. 

  8807.             foreach (IDecoration decoration in this.Decorations) {

    8808. 

  8808.                 decoration.ListItem = null;

    8809. 

  8809.                 decoration.SubItem = null;

    8810. 

  8810.                 decoration.Draw(this, g, contentRectangle);

    8811. 

  8811.             }

    8812. 

  8812. 

    8813. 

  8813.             // Finally, draw any hot item decoration

    8814. 

  8814.             if (this.UseHotItem && this.HotItemStyle != null && this.HotItemStyle.Decoration != null) {

    8815. 

  8815.                 IDecoration hotItemDecoration = this.HotItemStyle.Decoration;

    8816. 

  8816.                 hotItemDecoration.ListItem = this.GetItem(this.HotRowIndex);

    8817. 

  8817.                 if (hotItemDecoration.ListItem == null)

    8818. 

  8818.                     hotItemDecoration.SubItem = null;

    8819. 

  8819.                 else

    8820. 

  8820.                     hotItemDecoration.SubItem = hotItemDecoration.ListItem.GetSubItem(this.HotColumnIndex);

    8821. 

  8821.                 hotItemDecoration.Draw(this, g, contentRectangle);

    8822. 

  8822.             }

    8823. 

  8823. 

    8824. 

  8824.             // If we are in design mode, we don't want to use the glass panels,

    8825. 

  8825.             // so we draw the background overlays here

    8826. 

  8826.             if (this.DesignMode) {

    8827. 

  8827.                 foreach (IOverlay overlay in this.Overlays) {

    8828. 

  8828.                     overlay.Draw(this, g, contentRectangle);

    8829. 

  8829.                 }

    8830. 

  8830.             }

    8831. 

  8831.         }

    8832. 

  8832. 

    8833. 

  8833.         /// <summary>

    8834. 

  8834.         /// Is the given decoration shown on this list

    8835. 

  8835.         /// </summary>

    8836. 

  8836.         /// <param name="decoration">The overlay</param>

    8837. 

  8837.         public virtual bool HasDecoration(IDecoration decoration) {

    8838. 

  8838.             return this.Decorations.Contains(decoration);

    8839. 

  8839.         }

    8840. 

  8840. 

    8841. 

  8841.         /// <summary>

    8842. 

  8842.         /// Is the given overlay shown on this list?

    8843. 

  8843.         /// </summary>

    8844. 

  8844.         /// <param name="overlay">The overlay</param>

    8845. 

  8845.         public virtual bool HasOverlay(IOverlay overlay) {

    8846. 

  8846.             return this.Overlays.Contains(overlay);

    8847. 

  8847.         }

    8848. 

  8848. 

    8849. 

  8849.         /// <summary>

    8850. 

  8850.         /// Hide any overlays.

    8851. 

  8851.         /// </summary>

    8852. 

  8852.         /// <remarks>

    8853. 

  8853.         /// This is only a temporary hiding -- the overlays will be shown

    8854. 

  8854.         /// the next time the ObjectListView redraws.

    8855. 

  8855.         /// </remarks>

    8856. 

  8856.         public virtual void HideOverlays() {

    8857. 

  8857.             foreach (GlassPanelForm glassPanel in this.glassPanels) {

    8858. 

  8858.                 glassPanel.HideGlass();

    8859. 

  8859.             }

    8860. 

  8860.         }

    8861. 

  8861. 

    8862. 

  8862.         /// <summary>

    8863. 

  8863.         /// Create and configure the empty list msg overlay

    8864. 

  8864.         /// </summary>

    8865. 

  8865.         protected virtual void InitializeEmptyListMsgOverlay() {

    8866. 

  8866.             TextOverlay textOverlay = new TextOverlay();

    8867. 

  8867.             textOverlay.Alignment = System.Drawing.ContentAlignment.MiddleCenter;

    8868. 

  8868.             textOverlay.TextColor = SystemColors.ControlDarkDark;

    8869. 

  8869.             textOverlay.BackColor = Color.BlanchedAlmond;

    8870. 

  8870.             textOverlay.BorderColor = SystemColors.ControlDark;

    8871. 

  8871.             textOverlay.BorderWidth = 2.0f;

    8872. 

  8872.             this.EmptyListMsgOverlay = textOverlay;

    8873. 

  8873.         }

    8874. 

  8874. 

    8875. 

  8875.         /// <summary>

    8876. 

  8876.         /// Initialize the standard image and text overlays

    8877. 

  8877.         /// </summary>

    8878. 

  8878.         protected virtual void InitializeStandardOverlays() {

    8879. 

  8879.             this.OverlayImage = new ImageOverlay();

    8880. 

  8880.             this.AddOverlay(this.OverlayImage);

    8881. 

  8881.             this.OverlayText = new TextOverlay();

    8882. 

  8882.             this.AddOverlay(this.OverlayText);

    8883. 

  8883.         }

    8884. 

  8884. 

    8885. 

  8885.         /// <summary>

    8886. 

  8886.         /// Make sure that any overlays are visible.

    8887. 

  8887.         /// </summary>

    8888. 

  8888.         public virtual void ShowOverlays() {

    8889. 

  8889.             // If we shouldn't show overlays, then don't create glass panels

    8890. 

  8890.             if (!this.ShouldShowOverlays())

    8891. 

  8891.                 return;

    8892. 

  8892. 

    8893. 

  8893.             // Make sure that each overlay has its own glass panels

    8894. 

  8894.             if (this.Overlays.Count != this.glassPanels.Count) {

    8895. 

  8895.                 foreach (IOverlay overlay in this.Overlays) {

    8896. 

  8896.                     GlassPanelForm glassPanel = this.FindGlassPanelForOverlay(overlay);

    8897. 

  8897.                     if (glassPanel == null) {

    8898. 

  8898.                         glassPanel = new GlassPanelForm();

    8899. 

  8899.                         glassPanel.Bind(this, overlay);

    8900. 

  8900.                         this.glassPanels.Add(glassPanel);

    8901. 

  8901.                     }

    8902. 

  8902.                 }

    8903. 

  8903.             }

    8904. 

  8904.             foreach (GlassPanelForm glassPanel in this.glassPanels) {

    8905. 

  8905.                 glassPanel.ShowGlass();

    8906. 

  8906.             }

    8907. 

  8907.         }

    8908. 

  8908. 

    8909. 

  8909.         private bool ShouldShowOverlays() {

    8910. 

  8910.             // If we are in design mode, we dont show the overlays

    8911. 

  8911.             if (this.DesignMode)

    8912. 

  8912.                 return false;

    8913. 

  8913. 

    8914. 

  8914.             // If we are explicitly not using overlays, also don't show them

    8915. 

  8915.             if (!this.UseOverlays)

    8916. 

  8916.                 return false;

    8917. 

  8917. 

    8918. 

  8918.             // If there are no overlays, guess...

    8919. 

  8919.             if (!this.HasOverlays)

    8920. 

  8920.                 return false;

    8921. 

  8921. 

    8922. 

  8922.             // If we don't have 32-bit display, alpha blending doesn't work, so again, no overlays

    8923. 

  8923.             // TODO: This should actually figure out which screen(s) the control is on, and make sure

    8924. 

  8924.             // that each one is 32-bit.

    8925. 

  8925.             if (Screen.PrimaryScreen.BitsPerPixel < 32)

    8926. 

  8926.                 return false;

    8927. 

  8927. 

    8928. 

  8928.             // Finally, we can show the overlays

    8929. 

  8929.             return true;

    8930. 

  8930.         }

    8931. 

  8931. 

    8932. 

  8932.         private GlassPanelForm FindGlassPanelForOverlay(IOverlay overlay) {

    8933. 

  8933.             return this.glassPanels.Find(delegate(GlassPanelForm x) { return x.Overlay == overlay; });

    8934. 

  8934.         }

    8935. 

  8935. 

    8936. 

  8936.         /// <summary>

    8937. 

  8937.         /// Refresh the display of the overlays

    8938. 

  8938.         /// </summary>

    8939. 

  8939.         public virtual void RefreshOverlays() {

    8940. 

  8940.             foreach (GlassPanelForm glassPanel in this.glassPanels) {

    8941. 

  8941.                 glassPanel.Invalidate();

    8942. 

  8942.             }

    8943. 

  8943.         }

    8944. 

  8944. 

    8945. 

  8945.         /// <summary>

    8946. 

  8946.         /// Refresh the display of just one overlays

    8947. 

  8947.         /// </summary>

    8948. 

  8948.         public virtual void RefreshOverlay(IOverlay overlay) {

    8949. 

  8949.             GlassPanelForm glassPanel = this.FindGlassPanelForOverlay(overlay);

    8950. 

  8950.             if (glassPanel != null)

    8951. 

  8951.                 glassPanel.Invalidate();

    8952. 

  8952.         }

    8953. 

  8953. 

    8954. 

  8954.         /// <summary>

    8955. 

  8955.         /// Remove the given decoration from this list

    8956. 

  8956.         /// </summary>

    8957. 

  8957.         /// <param name="decoration">The decoration to remove</param>

    8958. 

  8958.         public virtual void RemoveDecoration(IDecoration decoration) {

    8959. 

  8959.             if (decoration == null)

    8960. 

  8960.                 return;

    8961. 

  8961.             this.Decorations.Remove(decoration);

    8962. 

  8962.             this.Invalidate();

    8963. 

  8963.         }

    8964. 

  8964. 

    8965. 

  8965.         /// <summary>

    8966. 

  8966.         /// Remove the given overlay to those on this list

    8967. 

  8967.         /// </summary>

    8968. 

  8968.         /// <param name="overlay">The overlay</param>

    8969. 

  8969.         public virtual void RemoveOverlay(IOverlay overlay) {

    8970. 

  8970.             if (overlay == null)

    8971. 

  8971.                 return;

    8972. 

  8972.             this.Overlays.Remove(overlay);

    8973. 

  8973.             GlassPanelForm glassPanel = this.FindGlassPanelForOverlay(overlay);

    8974. 

  8974.             if (glassPanel != null) {

    8975. 

  8975.                 this.glassPanels.Remove(glassPanel);

    8976. 

  8976.                 glassPanel.Unbind();

    8977. 

  8977.                 glassPanel.Dispose();

    8978. 

  8978.             }

    8979. 

  8979.         }

    8980. 

  8980. 

    8981. 

  8981.         #endregion

    8982. 

  8982. 

    8983. 

  8983.         #region Filtering

    8984. 

  8984. 

    8985. 

  8985.         /// <summary>

    8986. 

  8986.         /// Create a filter that will enact all the filtering currently installed

    8987. 

  8987.         /// on the visible columns.

    8988. 

  8988.         /// </summary>

    8989. 

  8989.         public virtual IModelFilter CreateColumnFilter() {

    8990. 

  8990.             List<IModelFilter> filters = new List<IModelFilter>();

    8991. 

  8991.             foreach (OLVColumn column in this.Columns) {

    8992. 

  8992.                 IModelFilter filter = column.ValueBasedFilter;

    8993. 

  8993.                 if (filter != null)

    8994. 

  8994.                     filters.Add(filter);

    8995. 

  8995.             }

    8996. 

  8996.             return (filters.Count == 0) ? null : new CompositeAllFilter(filters);

    8997. 

  8997.         }

    8998. 

  8998. 

    8999. 

  8999.         /// <summary>

    9000. 

  9000.         /// Do the actual work of filtering

    9001. 

  9001.         /// </summary>

    9002. 

  9002.         /// <param name="objects"></param>

    9003. 

  9003.         /// <param name="aModelFilter"></param>

    9004. 

  9004.         /// <param name="aListFilter"></param>

    9005. 

  9005.         /// <returns></returns>

    9006. 

  9006.         virtual protected IEnumerable FilterObjects(IEnumerable objects, IModelFilter aModelFilter, IListFilter aListFilter) {

    9007. 

  9007.             // Being cautious

    9008. 

  9008.             objects = objects ?? new ArrayList();

    9009. 

  9009. 

    9010. 

  9010.             // Tell the world to filter the objects. If they do so, don't do anything else

    9011. 

  9011.             FilterEventArgs args = new FilterEventArgs(objects);

    9012. 

  9012.             this.OnFilter(args);

    9013. 

  9013.             if (args.FilteredObjects != null)

    9014. 

  9014.                 return args.FilteredObjects;

    9015. 

  9015. 

    9016. 

  9016.             // Apply a filter to the list as a whole

    9017. 

  9017.             if (aListFilter != null)

    9018. 

  9018.                 objects = aListFilter.Filter(objects);

    9019. 

  9019. 

    9020. 

  9020.             // Apply the object filter if there is one

    9021. 

  9021.             if (aModelFilter != null) {

    9022. 

  9022.                 ArrayList filteredObjects = new ArrayList();

    9023. 

  9023.                 foreach (object model in objects) {

    9024. 

  9024.                     if (aModelFilter.Filter(model))

    9025. 

  9025.                         filteredObjects.Add(model);

    9026. 

  9026.                 }

    9027. 

  9027.                 objects = filteredObjects;

    9028. 

  9028.             }

    9029. 

  9029. 

    9030. 

  9030.             return objects;

    9031. 

  9031.         }

    9032. 

  9032. 

    9033. 

  9033.         /// <summary>

    9034. 

  9034.         /// Remove all column filtering.

    9035. 

  9035.         /// </summary>

    9036. 

  9036.         public virtual void ResetColumnFiltering() {

    9037. 

  9037.             foreach (OLVColumn column in this.Columns) {

    9038. 

  9038.                 column.ValuesChosenForFiltering.Clear();

    9039. 

  9039.             }

    9040. 

  9040.             this.UpdateColumnFiltering();

    9041. 

  9041.         }

    9042. 

  9042. 

    9043. 

  9043.         /// <summary>

    9044. 

  9044.         /// Update the filtering of this ObjectListView based on the value filtering

    9045. 

  9045.         /// defined in each column

    9046. 

  9046.         /// </summary>

    9047. 

  9047.         public virtual void UpdateColumnFiltering() {

    9048. 

  9048.             this.ModelFilter = this.CreateColumnFilter();

    9049. 

  9049.         }

    9050. 

  9050. 

    9051. 

  9051.         /// <summary>

    9052. 

  9052.         /// When some setting related to filtering changes, this method is called.

    9053. 

  9053.         /// </summary>

    9054. 

  9054.         protected virtual void UpdateFiltering() {

    9055. 

  9055.             this.BuildList(true);

    9056. 

  9056.         }

    9057. 

  9057. 

    9058. 

  9058.         #endregion

    9059. 

  9059. 

    9060. 

  9060.         #region Implementation variables

    9061. 

  9061. 

    9062. 

  9062.         private Rectangle lastUpdateRectangle; // remember the update rect from the last WM_PAINT message

    9063. 

  9063.         private bool isOwnerOfObjects; // does this ObjectListView own the Objects collection?

    9064. 

  9064.         private bool hasIdleHandler; // has an Idle handler already been installed?

    9065. 

  9065.         private bool hasResizeColumnsHandler; // has an idle handler been installed which will handle column resizing?

    9066. 

  9066.         private bool isInWmPaintEvent; // is a WmPaint event currently being handled?

    9067. 

  9067.         private bool shouldDoCustomDrawing; // should the list do its custom drawing?

    9068. 

  9068.         private bool isMarqueSelecting; // Is a marque selection in progress?

    9069. 

  9069. 

    9070. 

  9070.         private List<GlassPanelForm> glassPanels = new List<GlassPanelForm>(); // The transparent panel that draws overlays

    9071. 

  9071.         Dictionary<string, bool> visitedUrlMap = new Dictionary<string, bool>(); // Which urls have been visited?

    9072. 

  9072. 

    9073. 

  9073.         #endregion

    9074. 

  9074.     }

    9075. 

  9075. }

    9076. 

  9076.