/lib/CListViewControl.ahk

http://github.com/Skiouros/Macro · AutoHotKey · 901 lines · 568 code · 9 blank · 324 comment · 139 complexity · 15f9f07d4f26f3e0f4345a64088563ac MD5 · raw file 

    

  1. /*

    2. 

  2. Class: CListViewControl

    3. 

  3. A ListView control. Additionally to its features present in AHK it can use sorting-independent indexing for synchronizing its fields with an array.

    4. 

  4. 

    5. 

  5. This control extends <CControl>. All basic properties and functions are implemented and documented in this class.

    6. 

  6. */

    7. 

  7. Class CListViewControl Extends CControl

    8. 

  8. {

    9. 

  9. 	__New(Name, ByRef Options, Text, GUINum)

    10. 

  10. 	{

    11. 

  11. 		;~ global CGUI		

    12. 

  12. 		Events := ["Click", "RightClick", "ItemActivated", "MouseLeave", "EditingStart", "FocusReceived", "FocusLost", "ItemSelected", "ItemDeselected", "ItemFocused", "ItemDefocused", "ItemChecked", " ItemUnChecked", "SelectionChanged", "CheckedChanged", "FocusedChanged", "KeyPress", "Marquee", "ScrollingStart", "ScrollingEnd"]

    13. 

  13. 		if(!InStr(Options, "AltSubmit")) ;Automagically add AltSubmit when necessary

    14. 

  14. 		{

    15. 

  15. 			for index, function in Events

    16. 

  16. 			{

    17. 

  17. 				if(IsFunc(CGUI.GUIList[GUINum][Name "_" function]))

    18. 

  18. 				{

    19. 

  19. 					Options .= " AltSubmit"

    20. 

  20. 					break

    21. 

  21. 				}

    22. 

  22. 			}

    23. 

  23. 		}

    24. 

  24. 		base.__New(Name, Options, Text, GUINum)

    25. 

  25. 		this._.Insert("ControlStyles", {ReadOnly : -0x200, Header : -0x4000, NoSortHdr : 0x8000, AlwaysShowSelection : 0x8, Multi : -0x4, Sort : 0x10, SortDescending : 0x20})

    26. 

  26. 		this._.Insert("ControlExStyles", {Checked : 0x4, FullRowSelect : 0x20, Grid : 0x1, AllowHeaderReordering : 0x10, HotTrack : 0x8})

    27. 

  27. 		this._.Insert("Events", ["DoubleClick", "DoubleRightClick", "ColumnClick", "EditingEnd", "Click", "RightClick", "ItemActivate", "EditingStart", "KeyPress", "FocusReceived", "FocusLost", "Marquee", "ScrollingStart", "ScrollingEnd", "ItemSelected", "ItemDeselected", "ItemFocused", "ItemDefocused", "ItemChecked", "ItemUnChecked", "SelectionChanged", "CheckedChanged", "FocusedChanged"])

    28. 

  28. 		this._.Insert("Messages", {0x004E : "Notify"}) ;This control uses WM_NOTIFY with NM_SETFOCUS and NM_KILLFOCUS

    29. 

  29. 		this.Type := "ListView"

    30. 

  30. 	}

    31. 

  31. 	

    32. 

  32. 	PostCreate()

    33. 

  33. 	{

    34. 

  34. 		Base.PostCreate()

    35. 

  35. 		this._.Insert("ImageListManager", new this.CImageListManager(this.GUINum, this.hwnd))

    36. 

  36. 		this._.Insert("Items", new this.CItems(this.GUINum, this.hwnd))

    37. 

  37. 	}

    38. 

  38. 	/*

    39. 

  39. 	Function: ModifyCol

    40. 

  40. 	Modifies a column. See AHK help on LV_ModifyCol for details.

    41. 

  41. 	*/

    42. 

  42. 	ModifyCol(ColumnNumber="", Options="", ColumnTitle="")

    43. 

  43. 	{

    44. 

  44. 		;~ global CGUI

    45. 

  45. 		if(CGUI.GUIList[this.GUINum].IsDestroyed)

    46. 

  46. 			return

    47. 

  47. 		Gui, % this.GUINum ":Default"

    48. 

  48. 		Gui, ListView, % this.ClassNN

    49. 

  49. 		LV_ModifyCol(ColumnNumber, Options, ColumnTitle)

    50. 

  50. 	}

    51. 

  51. 	/*

    52. 

  52. 	Function: InsertCol

    53. 

  53. 	Inserts a column. See AHK help on LV_InsertCol for details.

    54. 

  54. 	*/

    55. 

  55. 	InsertCol(ColumnNumber, Options="", ColumnTitle="")

    56. 

  56. 	{

    57. 

  57. 		;~ global CGUI

    58. 

  58. 		if(CGUI.GUIList[this.GUINum].IsDestroyed)

    59. 

  59. 			return

    60. 

  60. 		Gui, % this.GUINum ":Default"

    61. 

  61. 		Gui, ListView, % this.ClassNN

    62. 

  62. 		LV_InsertCol(ColumnNumber, Options, ColumnTitle)

    63. 

  63. 	}

    64. 

  64. 	/*

    65. 

  65. 	Function: DeleteCol

    66. 

  66. 	Deletes a column. See AHK help on LV_DeleteCol for details.

    67. 

  67. 	*/

    68. 

  68. 	DeleteCol(ColumnNumber)

    69. 

  69. 	{

    70. 

  70. 		;~ global CGUI

    71. 

  71. 		if(CGUI.GUIList[this.GUINum].IsDestroyed)

    72. 

  72. 			return

    73. 

  73. 		Gui, % this.GUINum ":Default"

    74. 

  74. 		Gui, ListView, % this.ClassNN

    75. 

  75. 		LV_DeleteCol(ColumnNumber)

    76. 

  76. 	}

    77. 

  77. 	/*

    78. 

  78. 	Variable: Items

    79. 

  79. 	An array of all ListView rows. See <CListViewControl.CItems>.

    80. 

  80. 	

    81. 

  81. 	Variable: SelectedItem

    82. 

  82. 	Contains the (first) selected row.

    83. 

  83. 	

    84. 

  84. 	Variable: SelectedItems

    85. 

  85. 	Contains all selected rows.

    86. 

  86. 	

    87. 

  87. 	Variable: SelectedIndex

    88. 

  88. 	Contains the index of the (first) selected row.

    89. 

  89. 	

    90. 

  90. 	Variable: SelectedIndices

    91. 

  91. 	Contains all indices of the selected rows.

    92. 

  92. 	

    93. 

  93. 	Variable: CheckedItem

    94. 

  94. 	Contains the (first) checked row.

    95. 

  95. 	

    96. 

  96. 	Variable: CheckedItems

    97. 

  97. 	Contains all checked rows.

    98. 

  98. 	

    99. 

  99. 	Variable: CheckedIndex

    100. 

  100. 	Contains the index of the (first) checked row.

    101. 

  101. 	

    102. 

  102. 	Variable: CheckedIndices

    103. 

  103. 	Contains all indices of the checked rows.

    104. 

  104. 	

    105. 

  105. 	Variable: FocusedItem

    106. 

  106. 	Contains the focused row.

    107. 

  107. 	

    108. 

  108. 	Variable: FocusedIndex

    109. 

  109. 	Contains the index of the focused row.

    110. 

  110. 	

    111. 

  111. 	Variable: IndependentSorting

    112. 

  112. 	This setting is off by default. In this case, indexing the rows behaves like AHK ListViews usually do. 

    113. 

  113. 	If it is enabled however, the row indexing will be independent of the current sorting. 

    114. 

  114. 	That means that the first row can actually be displayed as the second, third,... or last row on the GUI. 

    115. 

  115. 	This feature is very useful if you need to synchronize an array with the data in the ListView 

    116. 

  116. 	because the index of the array can then be directly mapped to the ListView row index. 

    117. 

  117. 	This would not be possible if this option was off and the ListView gets sorted differently.

    118. 

  118. 	*/

    119. 

  119. 	__Get(Name, Params*)

    120. 

  120. 	{

    121. 

  121. 		;~ global CGUI

    122. 

  122. 		if(Name != "GUINum" && !CGUI.GUIList[this.GUINum].IsDestroyed)

    123. 

  123. 		{

    124. 

  124. 			DetectHidden := A_DetectHiddenWindows

    125. 

  125. 			DetectHiddenWindows, On

    126. 

  126. 			if(Name = "Items")

    127. 

  127. 				Value := this._.Items

    128. 

  128. 			else if(Name = "SelectedIndices" || Name = "SelectedItems" || Name = "CheckedIndices" || Name = "CheckedItems")

    129. 

  129. 			{

    130. 

  130. 				Gui, % this.GUINum ":Default"

    131. 

  131. 				Gui, ListView, % this.ClassNN

    132. 

  132. 				Value := []

    133. 

  133. 				Loop % this.Items.Count

    134. 

  134. 					if(LV_GetNext(A_Index - 1, InStr(Name, "Checked") ? "Checked" : "") = A_Index)

    135. 

  135. 					{

    136. 

  136. 						Index := (this._.Items.IndependentSorting ? this.CItems.CRow.GetUnsortedIndex(A_Index, this.hwnd) : A_Index)

    137. 

  137. 						Value.Insert(InStr(Name, "Indices") ? Index : this._.Items[Index]) ;new this.CItems.CRow(this.CItems.GetSortedIndex(A_Index, this.hwnd), this.GUINum, this.Name))

    138. 

  138. 					}

    139. 

  139. 			}

    140. 

  140. 			else if(Name = "SelectedIndex" || Name = "SelectedItem" || Name = "CheckedIndex" || Name = "CheckedItem")

    141. 

  141. 			{

    142. 

  142. 				Gui, % this.GUINum ":Default"

    143. 

  143. 				Gui, ListView, % this.ClassNN

    144. 

  144. 				Loop % this.Items.Count

    145. 

  145. 					if(LV_GetNext(A_Index - 1, InStr(Name, "Checked") ? "Checked" : "") = A_Index)

    146. 

  146. 					{

    147. 

  147. 						Index := (this._.Items.IndependentSorting ? this.CItems.CRow.GetUnsortedIndex(A_Index, this.hwnd) : A_Index)

    148. 

  148. 						Value := InStr(Name, "Index") ? Index : this._.Items[Index] ;new this.CItems.CRow(this.CItems.GetSortedIndex(A_Index, this.hwnd), this.GUINum, this.Name))

    149. 

  149. 						break

    150. 

  150. 					}

    151. 

  151. 			}

    152. 

  152. 			else if(Name = "FocusedItem" || Name = "FocusedIndex")

    153. 

  153. 			{

    154. 

  154. 				Gui, % this.GUINum ":Default"

    155. 

  155. 				Gui, ListView, % this.ClassNN

    156. 

  156. 				Value := LV_GetNext(0, "Focused")

    157. 

  157. 				if(this._.Items.IndependentSorting)

    158. 

  158. 					Value := this.CItems.CRow.GetUnsortedIndex(Value, this.hwnd)

    159. 

  159. 				if(Name = "FocusedItem")

    160. 

  160. 					Value := this._.Items[Value] ;new this.CItems.CRow(Value, this.GUINum, this.Name)

    161. 

  161. 			}

    162. 

  162. 			else if(Name = "IndependentSorting")

    163. 

  163. 				Value := this._.Items.IndependentSorting

    164. 

  164. 			Loop % Params.MaxIndex()

    165. 

  165. 				if(IsObject(Value)) ;Fix unlucky multi parameter __GET

    166. 

  166. 					Value := Value[Params[A_Index]]

    167. 

  167. 			if(!DetectHidden)

    168. 

  168. 				DetectHiddenWindows, Off

    169. 

  169. 			if(Value != "")

    170. 

  170. 				return Value

    171. 

  171. 		}

    172. 

  172. 	}

    173. 

  173. 	__Set(Name, Params*)

    174. 

  174. 	{

    175. 

  175. 		;~ global CGUI

    176. 

  176. 		if(!CGUI.GUIList[this.GUINum].IsDestroyed)

    177. 

  177. 		{

    178. 

  178. 			DetectHidden := A_DetectHiddenWindows

    179. 

  179. 			DetectHiddenWindows, On

    180. 

  180. 			Handled := true

    181. 

  181. 			Value := Params[Params.MaxIndex()]

    182. 

  182. 			Params.Remove(Params.MaxIndex())

    183. 

  183. 			if(Name = "SelectedIndices" || Name = "CheckedIndices")

    184. 

  184. 			{

    185. 

  185. 				Gui, % this.GUINum ":Default"

    186. 

  186. 				Gui, ListView, % this.ClassNN

    187. 

  187. 				Indices := Value

    188. 

  188. 				if(!IsObject(Value))

    189. 

  189. 				{

    190. 

  190. 					Indices := Array()

    191. 

  191. 					Loop, Parse, Value,|

    192. 

  192. 						if A_LoopField is Integer

    193. 

  193. 							Indices.Insert(A_LoopField)

    194. 

  194. 				}

    195. 

  195. 				LV_Modify(0, Name = "SelectedIndices" ? "-Select" : "-Check")

    196. 

  196. 				Loop % Indices.MaxIndex()

    197. 

  197. 					if(Indices[A_Index] > 0)

    198. 

  198. 						LV_Modify(this._.Items.IndependentSorting ? this.CItems.CRow.GetSortedIndex(Indices[A_Index], this.hwnd) : Indices[A_Index], Name = "SelectedIndices" ? "Select" : "Check")

    199. 

  199. 				if(Name = "SelectedIndices")

    200. 

  200. 				{

    201. 

  201. 					if(LV_GetCount("Selected") = 1)

    202. 

  202. 					{

    203. 

  203. 						this.ProcessSubControlState(this._.PreviouslySelectedItem, this.SelectedItem)

    204. 

  204. 						this._.PreviouslySelectedItem := this.SelectedItem

    205. 

  205. 					}

    206. 

  206. 					else

    207. 

  207. 					{

    208. 

  208. 						this.ProcessSubControlState(this._.PreviouslySelectedItem, "")

    209. 

  209. 						this._.PreviouslySelectedItem := ""

    210. 

  210. 					}

    211. 

  211. 				}

    212. 

  212. 			}

    213. 

  213. 			else if(Name = "SelectedIndex" || Name = "CheckedIndex")

    214. 

  214. 			{

    215. 

  215. 				Gui, % this.GUINum ":Default"

    216. 

  216. 				Gui, ListView, % this.ClassNN

    217. 

  217. 				LV_Modify(0, Name = "SelectedIndex" ? "-Select" : "-Check")

    218. 

  218. 				if(Value > 0)

    219. 

  219. 				{

    220. 

  220. 					LV_Modify(this._.Items.IndependentSorting ? this.CItems.CRow.GetSortedIndex(Value, this.hwnd) : Value, Name = "SelectedIndex" ? "Select" : "Check")

    221. 

  221. 					if(Name = "SelectedIndex")

    222. 

  222. 					{

    223. 

  223. 						if(LV_GetCount("Selected") = 1)

    224. 

  224. 						{

    225. 

  225. 							this.ProcessSubControlState(this._.PreviouslySelectedItem, this.SelectedItem)

    226. 

  226. 							this._.PreviouslySelectedItem := this.SelectedItem

    227. 

  227. 						}

    228. 

  228. 						else

    229. 

  229. 						{

    230. 

  230. 							this.ProcessSubControlState(this._.PreviouslySelectedItem, "")

    231. 

  231. 							this._.PreviouslySelectedItem := ""

    232. 

  232. 						}

    233. 

  233. 					}

    234. 

  234. 				}

    235. 

  235. 			}

    236. 

  236. 			else if(Name = "FocusedIndex")

    237. 

  237. 			{

    238. 

  238. 				Gui, % this.GUINum ":Default"

    239. 

  239. 				Gui, ListView, % this.ClassNN

    240. 

  240. 				LV_Modify(this._.Items.IndependentSorting ? this.CItems.CRow.GetSortedIndex(Value, this.hwnd) : Value, "Focused")

    241. 

  241. 			}

    242. 

  242. 			else if(Name = "Items" && IsObject(Value) && IsObject(this._.Items) && Params.MaxIndex() > 0)

    243. 

  243. 			{

    244. 

  244. 				Items := this._.Items

    245. 

  245. 				Items[Params*] := Value

    246. 

  246. 			}

    247. 

  247. 			else if(Name = "IndependentSorting")

    248. 

  248. 				this._.Items.IndependentSorting := Value

    249. 

  249. 			else if(Name = "Items")

    250. 

  250. 				Value := 0

    251. 

  251. 			else

    252. 

  252. 				Handled := false

    253. 

  253. 			if(!DetectHidden)

    254. 

  254. 				DetectHiddenWindows, Off

    255. 

  255. 			if(Handled)

    256. 

  256. 				return Value

    257. 

  257. 		}

    258. 

  258. 	}

    259. 

  259. 	

    260. 

  260. 	/*

    261. 

  261. 	Class: CListViewControl.CItems

    262. 

  262. 	An array of all ListView rows.

    263. 

  263. 	*/

    264. 

  264. 	Class CItems

    265. 

  265. 	{

    266. 

  266. 		__New(GUINum, hwnd)

    267. 

  267. 		{

    268. 

  268. 			this._Insert("_", {})

    269. 

  269. 			this._.GUINum := GUINum

    270. 

  270. 			this._.hwnd := hwnd

    271. 

  271. 		}

    272. 

  272. 		_NewEnum()

    273. 

  273. 		{

    274. 

  274. 			;~ global CEnumerator

    275. 

  275. 			return new CEnumerator(this)

    276. 

  276. 		}

    277. 

  277. 		/*

    278. 

  278. 		Function: MaxIndex

    279. 

  279. 		Returns the number of rows.

    280. 

  280. 		*/

    281. 

  281. 		MaxIndex()

    282. 

  282. 		{

    283. 

  283. 			;~ global CGUI

    284. 

  284. 			GUI := CGUI.GUIList[this._.GUINum]

    285. 

  285. 			if(GUI.IsDestroyed)

    286. 

  286. 				return

    287. 

  287. 			Control := GUI.Controls[this._.hwnd]

    288. 

  288. 			Gui, % this._.GUINum ":Default"

    289. 

  289. 			Gui, ListView, % Control.ClassNN

    290. 

  290. 			return LV_GetCount()

    291. 

  291. 		}

    292. 

  292. 		/*

    293. 

  293. 		Function: Add

    294. 

  294. 		Adds a row.

    295. 

  295. 		

    296. 

  296. 		Parameters:

    297. 

  297. 			Options - Options for the new row. See AHK documentation on LV_Add().

    298. 

  298. 			Fields - Any additional parameters are used as cell text.

    299. 

  299. 		*/

    300. 

  300. 		Add(Options, Fields*)

    301. 

  301. 		{

    302. 

  302. 			;~ global CGUI

    303. 

  303. 			GUI := CGUI.GUIList[this._.GUINum]

    304. 

  304. 			if(GUI.IsDestroyed)

    305. 

  305. 				return

    306. 

  306. 			Control := GUI.Controls[this._.hwnd]

    307. 

  307. 			Gui, % Control.GUINum ":Default"

    308. 

  308. 			Gui, ListView, % Control.ClassNN

    309. 

  309. 			SortedIndex := LV_Add(Options, Fields*)

    310. 

  310. 			UnsortedIndex := LV_GetCount()

    311. 

  311. 			this._.Insert(UnsortedIndex, new this.CRow(SortedIndex, UnsortedIndex, this._.GUINum, Control.hwnd))

    312. 

  312. 			if(InStr(Options, "Select"))

    313. 

  313. 			{

    314. 

  314. 				if(LV_GetCount("Selected") = 1)

    315. 

  315. 				{

    316. 

  316. 					Control.ProcessSubControlState(Control._.PreviouslySelectedItem, Control.SelectedItem)

    317. 

  317. 					Control._.PreviouslySelectedItem := Control.SelectedItem

    318. 

  318. 				}

    319. 

  319. 				else

    320. 

  320. 				{

    321. 

  321. 					Control.ProcessSubControlState(Control._.PreviouslySelectedItem, "")

    322. 

  322. 					Control._.PreviouslySelectedItem := ""

    323. 

  323. 				}

    324. 

  324. 			}

    325. 

  325. 		}

    326. 

  326. 		/*

    327. 

  327. 		Function: Insert

    328. 

  328. 		Inserts a row.

    329. 

  329. 		

    330. 

  330. 		Parameters:

    331. 

  331. 			RowNumber - Index before which the row is inserted.

    332. 

  332. 			Options - Options for the new row. See AHK documentation on LV_Add().

    333. 

  333. 			Fields - Any additional parameters are used as cell text.

    334. 

  334. 		*/

    335. 

  335. 		Insert(RowNumber, Options, Fields*)

    336. 

  336. 		{

    337. 

  337. 			;~ global CGUI

    338. 

  338. 			GUI := CGUI.GUIList[this._.GUINum]

    339. 

  339. 			if(GUI.IsDestroyed)

    340. 

  340. 				return

    341. 

  341. 			Control := GUI.Controls[this._.hwnd]

    342. 

  342. 			Gui, % Control.GUINum ":Default"

    343. 

  343. 			Gui, ListView, % Control.ClassNN

    344. 

  344. 			SortedIndex := this.IndependentSorting ? this.CRow.GetSortedIndex(RowNumber, Control.hwnd) : RowNumber ;If independent sorting is off, the RowNumber parameter of this function is interpreted as sorted index

    345. 

  345. 			if(SortedIndex = -1 || SortedIndex > LV_GetCount())

    346. 

  346. 				SortedIndex := LV_GetCount() + 1

    347. 

  347. 			

    348. 

  348. 			UnsortedIndex := this.CRow.GetUnsortedIndex(SortedIndex, Control.hwnd)

    349. 

  349. 			

    350. 

  350. 			;move all unsorted indices >= the insertion point up by one to make place for the insertion

    351. 

  351. 			Loop % LV_GetCount() - UnsortedIndex + 1

    352. 

  352. 			{

    353. 

  353. 				index := LV_GetCount() - A_Index + 1 ;loop backwards

    354. 

  354. 				sIndex := this.CRow.GetSortedIndex(index, Control.hwnd) - 1

    355. 

  355. 				this.CRow.SetUnsortedIndex(sIndex, index + 1, Control.hwnd)

    356. 

  356. 			}

    357. 

  357. 			

    358. 

  358. 			SortedIndex := LV_Insert(SortedIndex, Options, Fields*)

    359. 

  359. 			this._.Insert(UnsortedIndex, new this.CRow(SortedIndex, UnsortedIndex, this._.GUINum, Control.hwnd))

    360. 

  360. 			if(InStr(Options, "Select"))

    361. 

  361. 			{

    362. 

  362. 				if(LV_GetCount("Selected") = 1)

    363. 

  363. 				{

    364. 

  364. 					Control.ProcessSubControlState(Control._.PreviouslySelectedItem, Control.SelectedItem)

    365. 

  365. 					Control._.PreviouslySelectedItem := Control.SelectedItem

    366. 

  366. 				}

    367. 

  367. 				else

    368. 

  368. 				{

    369. 

  369. 					Control.ProcessSubControlState(Control._.PreviouslySelectedItem, "")

    370. 

  370. 					Control._.PreviouslySelectedItem := ""

    371. 

  371. 				}

    372. 

  372. 			}

    373. 

  373. 		}	

    374. 

  374. 		

    375. 

  375. 		/*

    376. 

  376. 		Function: Modify

    377. 

  377. 		Modifies a row.

    378. 

  378. 		

    379. 

  379. 		Parameters:

    380. 

  380. 			RowNumber - Index of the row which should be modified.

    381. 

  381. 			Options - Options for the modified row. See AHK documentation on LV_Modify().

    382. 

  382. 			Fields - Any additional parameters are used as cell text.

    383. 

  383. 		*/

    384. 

  384. 		Modify(RowNumber, Options, Fields*)

    385. 

  385. 		{

    386. 

  386. 			;~ global CGUI

    387. 

  387. 			GUI := CGUI.GUIList[this._.GUINum]

    388. 

  388. 			if(GUI.IsDestroyed)

    389. 

  389. 				return

    390. 

  390. 			Control := GUI.Controls[this._.hwnd]

    391. 

  391. 			Gui, % Control.GUINum ":Default"

    392. 

  392. 			Gui, ListView, % Control.ClassNN

    393. 

  393. 			SortedIndex := this.IndependentSorting ? this.CRow.GetSortedIndex(RowNumber, Control.hwnd) : RowNumber ;If independent sorting is off, the RowNumber parameter of this function is interpreted as sorted index

    394. 

  394. 			LV_Modify(SortedIndex, Options, Fields*)

    395. 

  395. 			if(InStr(Options, "Select"))

    396. 

  396. 			{

    397. 

  397. 				if(LV_GetCount("Selected") = 1)

    398. 

  398. 				{

    399. 

  399. 					Control.ProcessSubControlState(Control._.PreviouslySelectedItem, Control.SelectedItem)

    400. 

  400. 					Control._.PreviouslySelectedItem := Control.SelectedItem

    401. 

  401. 				}

    402. 

  402. 				else

    403. 

  403. 				{

    404. 

  404. 					Control.ProcessSubControlState(Control._.PreviouslySelectedItem, "")

    405. 

  405. 					Control._.PreviouslySelectedItem := ""

    406. 

  406. 				}

    407. 

  407. 			}

    408. 

  408. 		}

    409. 

  409. 		

    410. 

  410. 		/*

    411. 

  411. 		Function: Clear

    412. 

  412. 		Clears the ListView by deleting all rows.

    413. 

  413. 		*/

    414. 

  414. 		Clear()

    415. 

  415. 		{

    416. 

  416. 			Loop % this.MaxIndex()

    417. 

  417. 				this.Delete(1)

    418. 

  418. 		}

    419. 

  419. 		/*

    420. 

  420. 		Function: Delete

    421. 

  421. 		Deletes a row.

    422. 

  422. 		

    423. 

  423. 		Parameters:

    424. 

  424. 			RowNumber - Index of the row which should be deleted.

    425. 

  425. 		*/

    426. 

  426. 		Delete(RowNumber)

    427. 

  427. 		{

    428. 

  428. 			;~ global CGUI

    429. 

  429. 			GUI := CGUI.GUIList[this._.GUINum]

    430. 

  430. 			if(GUI.IsDestroyed)

    431. 

  431. 				return

    432. 

  432. 			Control := GUI.Controls[this._.hwnd]

    433. 

  433. 			Gui, % Control.GUINum ":Default"

    434. 

  434. 			Gui, ListView, % Control.ClassNN

    435. 

  435. 			WasSelected := Control.Items[RowNumber].Selected

    436. 

  436. 			SortedIndex := this.IndependentSorting ? this.CRow.GetSortedIndex(RowNumber, Control.hwnd) : RowNumber ;If independent sorting is off, the RowNumber parameter of this function is interpreted as sorted index

    437. 

  437. 			UnsortedIndex := this.CRow.GetUnsortedIndex(SortedIndex, Control.hwnd)

    438. 

  438. 			;Decrease the unsorted indices after the deletion index by one

    439. 

  439. 			Loop % LV_GetCount() - UnsortedIndex

    440. 

  440. 				this.CRow.SetUnsortedIndex(this.CRow.GetSortedIndex(UnsortedIndex + A_Index, Control.hwnd), UnsortedIndex + A_Index - 1, Control.hwnd)

    441. 

  441. 			LV_Delete(SortedIndex)

    442. 

  442. 			if(WasSelected)

    443. 

  443. 			{

    444. 

  444. 				if(LV_GetCount("Selected") = 1)

    445. 

  445. 				{

    446. 

  446. 					Control.ProcessSubControlState(Control._.PreviouslySelectedItem, Control.SelectedItem)

    447. 

  447. 					Control._.PreviouslySelectedItem := Control.SelectedItem

    448. 

  448. 				}

    449. 

  449. 				else

    450. 

  450. 				{

    451. 

  451. 					Control.ProcessSubControlState(Control._.PreviouslySelectedItem, "")

    452. 

  452. 					Control._.PreviouslySelectedItem := ""

    453. 

  453. 				}

    454. 

  454. 			}

    455. 

  455. 		}

    456. 

  456. 		/*

    457. 

  457. 		Variable: 1,2,3,4,...

    458. 

  458. 		Rows can be accessed by their index, e.g. this.ListView.Items[1][2] accesses the text of the first row and second column.

    459. 

  459. 		

    460. 

  460. 		Variable: Count

    461. 

  461. 		The number of rows.

    462. 

  462. 		*/

    463. 

  463. 		__Get(Name)

    464. 

  464. 		{

    465. 

  465. 			;~ global CGUI

    466. 

  466. 			if(Name != "_")

    467. 

  467. 			{

    468. 

  468. 				GUI := CGUI.GUIList[this._.GUINum]

    469. 

  469. 				if(GUI.IsDestroyed)

    470. 

  470. 					return

    471. 

  471. 				Control := GUI.Controls[this._.hwnd]

    472. 

  472. 				if Name is Integer

    473. 

  473. 				{

    474. 

  474. 					if(Name > 0 && Name <= this.Count)

    475. 

  475. 						return this._[this.IndependentSorting ? Name : this.CRow.GetUnsortedIndex(Name, Control.hwnd)]

    476. 

  476. 				}

    477. 

  477. 				else if(Name = "Count")

    478. 

  478. 					return this.MaxIndex()

    479. 

  479. 			}

    480. 

  480. 		}

    481. 

  481. 		__Set(Name, Params*)

    482. 

  482. 		{

    483. 

  483. 			;~ global CGUI

    484. 

  484. 			GUI := CGUI.GUIList[this._.GUINum]

    485. 

  485. 			if(GUI.IsDestroyed)

    486. 

  486. 				return

    487. 

  487. 			Value := Params[Params.MaxIndex()]

    488. 

  488. 			Params.Remove(Params.MaxIndex())

    489. 

  489. 			if Name is Integer

    490. 

  490. 			{

    491. 

  491. 				if(!Params.MaxIndex()) ;Setting a row directly is not allowed

    492. 

  492. 					return

    493. 

  493. 				else ;Set a column or other row property

    494. 

  494. 				{			

    495. 

  495. 					Row := this[Name]

    496. 

  496. 					Row[Params*] := Value

    497. 

  497. 					return

    498. 

  498. 				}

    499. 

  499. 			}

    500. 

  500. 		}

    501. 

  501. 		

    502. 

  502. 		/*

    503. 

  503. 		Class: CListViewControl.CItems.CRow

    504. 

  504. 		A single row of a ListView control.

    505. 

  505. 		CRow uses the unsorted row numbers internally, but it can switch to sorted row numbers depending on the setting of the ListView.

    506. 

  506. 		*/

    507. 

  507. 		Class CRow

    508. 

  508. 		{

    509. 

  509. 			__New(SortedIndex, UnsortedIndex, GUINum, hwnd)

    510. 

  510. 			{

    511. 

  511. 				;~ global CGUI

    512. 

  512. 				this.Insert("_", {})				

    513. 

  513. 				this._.RowNumber := UnsortedIndex

    514. 

  514. 				this._.GUINum := GUINum

    515. 

  515. 				this._.hwnd := hwnd

    516. 

  516. 				GUI := CGUI.GUIList[GUINum]

    517. 

  517. 				if(GUI.IsDestroyed)

    518. 

  518. 					return

    519. 

  519. 				Control := GUI.Controls[hwnd]				

    520. 

  520. 				;Store the real unsorted index in the custom property lParam field of the list view item so it can be reidentified later

    521. 

  521. 				this.SetUnsortedIndex(SortedIndex, UnsortedIndex, Control.hwnd)

    522. 

  522. 				this.SetIcon("")

    523. 

  523. 				this._.Insert("Controls", {})

    524. 

  524. 			}

    525. 

  525. 			/*

    526. 

  526. 			Function: AddControl

    527. 

  527. 			Adds a control to this item that will be visible/enabled only when this item is selected. The parameters correspond to the Add() function of CGUI.

    528. 

  528. 			

    529. 

  529. 			Parameters:

    530. 

  530. 				Type - The type of the control.

    531. 

  531. 				Name - The name of the control.

    532. 

  532. 				Options - Options used for creating the control.

    533. 

  533. 				Text - The text of the control.

    534. 

  534. 				UseEnabledState - If true, the control will be enabled/disabled instead of visible/hidden.

    535. 

  535. 			*/

    536. 

  536. 			AddControl(type, Name, Options, Text, UseEnabledState = 0)

    537. 

  537. 			{

    538. 

  538. 				;~ global CGUI

    539. 

  539. 				GUI := CGUI.GUIList[this._.GUINum]

    540. 

  540. 				if(!this.Selected)

    541. 

  541. 					Options .= UseEnabledState ? " Disabled" : " Hidden"

    542. 

  542. 				Control := GUI.AddControl(type, Name, Options, Text, this._.Controls)

    543. 

  543. 				Control._.UseEnabledState := UseEnabledState

    544. 

  544. 				Control.hParentControl := this._.hwnd

    545. 

  545. 				return Control

    546. 

  546. 			}

    547. 

  547. 			/*

    548. 

  548. 			typedef struct {

    549. 

  549. 			  UINT   mask;

    550. 

  550. 			  int    iItem;

    551. 

  551. 			  int    iSubItem;

    552. 

  552. 			  UINT   state;

    553. 

  553. 			  UINT   stateMask;

    554. 

  554. 			  LPTSTR pszText;

    555. 

  555. 			  int    cchTextMax;

    556. 

  556. 			  int    iImage;

    557. 

  557. 			  LPARAM lParam;

    558. 

  558. 			#if (_WIN32_IE >= 0x0300)

    559. 

  559. 			  int    iIndent;

    560. 

  560. 			#endif 

    561. 

  561. 			#if (_WIN32_WINNT >= 0x0501)

    562. 

  562. 			  int    iGroupId;

    563. 

  563. 			  UINT   cColumns;

    564. 

  564. 			  UINT   puColumns;

    565. 

  565. 			#endif 

    566. 

  566. 			#if (_WIN32_WINNT >= 0x0600)

    567. 

  567. 			  int    piColFmt;

    568. 

  568. 			  int    iGroup;

    569. 

  569. 			#endif 

    570. 

  570. 			} LVITEM, *LPLVITEM;

    571. 

  571. 			*/

    572. 

  572. 			SetUnsortedIndex(SortedIndex, lParam, hwnd)

    573. 

  573. 			{

    574. 

  574. 				;~ if(!this.IndependentSorting)

    575. 

  575. 					;~ return

    576. 

  576. 				VarSetCapacity(LVITEM, 13*4 + 2 * A_PtrSize, 0)

    577. 

  577. 				mask := 0x4   ; LVIF_PARAM := 0x4

    578. 

  578. 				NumPut(mask, LVITEM, 0, "UInt") 

    579. 

  579. 				NumPut(SortedIndex - 1, LVITEM, 4, "Int")   ; iItem 

    580. 

  580. 				NumPut(lParam, LVITEM, 7*4 + A_PtrSize, "PTR")

    581. 

  581. 				;~ string := this.hex(LVITEM,  "UINT|INT|INT|UINT|UINT|PTR|INT|INT|PTR|INT|INT|UINT|UINT|INT|INT")

    582. 

  582. 				SendMessage, (A_IsUnicode ? 0x1000 + 76 : 0x1000 + 6), 0, &LVITEM,, % "ahk_id " hwnd ;LVM_SETITEM

    583. 

  583. 				;~ result := errorlevel

    584. 

  584. 				;~ result := DllCall("SendMessage", "PTR", hwnd, "UInt", LVM_SETITEM := (A_IsUnicode ? 0x1000 + 76 : 0x1000 + 6), "PTR", 0, "PTRP", LVITEM, "PTR")

    585. 

  585. 				;~ lParam2 := this.GetUnsortedIndex(RowNumber, hwnd)

    586. 

  586. 				return ErrorLevel

    587. 

  587. 			}

    588. 

  588. 			;Returns the sorted index (by which AHK usually accesses listviews) by searching for a custom index that is independent of sorting

    589. 

  589. 			/*

    590. 

  590. 			typedef struct tagLVFINDINFO {

    591. 

  591. 			  UINT    flags; 4

    592. 

  592. 			  LPCTSTR psz; 4-8

    593. 

  593. 			  LPARAM  lParam; 4- 8

    594. 

  594. 			  POINT   pt; 8

    595. 

  595. 			  UINT    vkDirection; 4

    596. 

  596. 			} LVFINDINFO, *LPFINDINFO;

    597. 

  597. 			*/

    598. 

  598. 			GetSortedIndex(UnsortedIndex, hwnd)

    599. 

  599. 			{

    600. 

  600. 				;~ if(!this.IndependentSorting)

    601. 

  601. 					;~ return UnsortedIndex

    602. 

  602. 				;Create the LVFINDINFO structure

    603. 

  603. 				VarSetCapacity(LVFINDINFO, 4*4 + 2 * A_PtrSize, 0)

    604. 

  604. 				mask := 0x1   ; LVFI_PARAM := 0x1

    605. 

  605. 				NumPut(mask, LVFINDINFO, 0, "UInt") 

    606. 

  606. 				NumPut(UnsortedIndex, LVFINDINFO, 4 + A_PtrSize, "PTR")

    607. 

  607. 				;~ string := hex(LVFINDINFO,  "UINT|INT|INT|UINT|UINT|PTR|INT|INT|PTR|INT|INT|UINT|UINT|INT|INT")

    608. 

  608. 				SendMessage, (A_IsUnicode ? 0x1000 + 83 : 0x1000 + 13), -1, &LVFINDINFO,, % "ahk_id " hwnd ;LVM_FINDITEM

    609. 

  609. 				;~ MsgReply := ErrorLevel > 0x7FFFFFFF ? -(~ErrorLevel) - 1 : ErrorLevel

    610. 

  610. 				;~ result := DllCall("SendMessage", "PTR", hwnd, "UInt", LVM_FINDITEM := (A_IsUnicode ? 0x1000 + 83 : 0x1000 + 13), "PTR", -1, "UIntP", LVITEM, "PTR") + 1

    611. 

  611. 				return ErrorLevel + 1

    612. 

  612. 			}

    613. 

  613. 			GetUnsortedIndex(SortedIndex, hwnd)

    614. 

  614. 			{

    615. 

  615. 				;~ if(!this.IndependentSorting)

    616. 

  616. 					;~ return SortedIndex

    617. 

  617. 				VarSetCapacity(LVITEM, 13*4 + 2 * A_PtrSize, 0)

    618. 

  618. 				mask := 0x4   ; LVIF_PARAM := 0x4

    619. 

  619. 				NumPut(mask, LVITEM, 0, "UInt") 

    620. 

  620. 				NumPut(SortedIndex - 1, LVITEM, 4, "Int")   ; iItem 

    621. 

  621. 				;~ NumPut(lParam, LVITEM, 7*4 + A_PtrSize, "PTR")

    622. 

  622. 				;~ string := this.hex(LVITEM,  "UINT|INT|INT|UINT|UINT|PTR|INT|INT|PTR|INT|INT|UINT|UINT|INT|INT")

    623. 

  623. 				SendMessage, (A_IsUnicode ? 0x1000 + 75 : 0x1000 + 5), 0, &LVITEM,,% "ahk_id " hwnd ;LVM_GETITEM

    624. 

  624. 				;~ result := errorlevel

    625. 

  625. 				;~ result := DllCall("SendMessage", "PTR", hwnd, "UInt", LVM_GETITEM := (A_IsUnicode ? 0x1000 + 75 : 0x1000 + 5), "PTR", 0, "PTRP", LVITEM, "PTR")

    626. 

  626. 				;~ string := this.hex(LVITEM,  "UINT|INT|INT|UINT|UINT|PTR|INT|INT|PTR|INT|INT|UINT|UINT|INT|INT")

    627. 

  627. 				UnsortedIndex := NumGet(LVITEM, 7*4 + A_PtrSize, "PTR")

    628. 

  628. 				return UnsortedIndex

    629. 

  629. 			}

    630. 

  630. 			_NewEnum()

    631. 

  631. 			{

    632. 

  632. 				;~ global CEnumerator

    633. 

  633. 				return new CEnumerator(this)

    634. 

  634. 			}

    635. 

  635. 			/*

    636. 

  636. 			Function: MaxIndex

    637. 

  637. 			Returns the number of columns.

    638. 

  638. 			*/

    639. 

  639. 			MaxIndex()

    640. 

  640. 			{				

    641. 

  641. 				;~ global CGUI

    642. 

  642. 				GUI := CGUI.GUIList[this._.GUINum]

    643. 

  643. 				if(GUI.IsDestroyed)

    644. 

  644. 					return

    645. 

  645. 				Control := GUI.Controls[this._.hwnd]

    646. 

  646. 				Gui, % Control.GUINum ":Default"

    647. 

  647. 				Gui, ListView, % Control.ClassNN

    648. 

  648. 				Return LV_GetCount("Column")

    649. 

  649. 			}

    650. 

  650. 			/*

    651. 

  651. 			Function: SetIcon

    652. 

  652. 			Sets the icon of a ListView row

    653. 

  653. 			

    654. 

  654. 			Parameters:

    655. 

  655. 				Filename - The filename of the file containing the icon.

    656. 

  656. 				IconNumberOrTransparencyColor - The icon number or the transparency color if the used file has no transparency support.

    657. 

  657. 			*/

    658. 

  658. 			SetIcon(Filename, IconNumberOrTransparencyColor = 1)

    659. 

  659. 			{

    660. 

  660. 				;~ global CGUI

    661. 

  661. 				GUI := CGUI.GUIList[this._.GUINum]

    662. 

  662. 				if(GUI.IsDestroyed)

    663. 

  663. 					return

    664. 

  664. 				Control := GUI.Controls[this._.hwnd]

    665. 

  665. 				Control._.ImageListManager.SetIcon(this.GetSortedIndex(this._.RowNumber, Control.hwnd), Filename, IconNumberOrTransparencyColor)

    666. 

  666. 				this._.Icon := Filename

    667. 

  667. 				this._.IconNumber := IconNumberOrTransparencyColor

    668. 

  668. 			}

    669. 

  669. 			/*

    670. 

  670. 			Variable: 1,2,3,4,...

    671. 

  671. 			Columns can be accessed by their index, e.g. this.ListView.Items[1][2] accesses the text of the first row and second column.

    672. 

  672. 			

    673. 

  673. 			Variable: Text

    674. 

  674. 			The text of the first column of this row.

    675. 

  675. 			

    676. 

  676. 			Variable: Count

    677. 

  677. 			The number of columns.

    678. 

  678. 			

    679. 

  679. 			Variable: Checked

    680. 

  680. 			True if the row is checked.

    681. 

  681. 			

    682. 

  682. 			Variable: Selected

    683. 

  683. 			True if the row is selected.

    684. 

  684. 			

    685. 

  685. 			Variable: Focused

    686. 

  686. 			True if the row is foucsed.

    687. 

  687. 			

    688. 

  688. 			Variable: Icon

    689. 

  689. 			The filename of the file containing the icon for the current row.

    690. 

  690. 			

    691. 

  691. 			Variable: IconNumber

    692. 

  692. 			The number of the icon in a multi-icon file.

    693. 

  693. 			*/

    694. 

  694. 			__Get(Name)

    695. 

  695. 			{

    696. 

  696. 				;~ global CGUI				

    697. 

  697. 				GUI := CGUI.GUIList[this._.GUINum]

    698. 

  698. 				if(!GUI.IsDestroyed)

    699. 

  699. 				{

    700. 

  700. 					Control := GUI.Controls[this._.hwnd]

    701. 

  701. 					if Name is Integer

    702. 

  702. 					{

    703. 

  703. 						if(Name > 0 && Name <= this.Count) ;Setting default listview is already done by this.Count __Get

    704. 

  704. 						{

    705. 

  705. 							LV_GetText(value, this.GetSortedIndex(this._.RowNumber, Control.hwnd), Name)

    706. 

  706. 							return value

    707. 

  707. 						}

    708. 

  708. 					}

    709. 

  709. 					else if(Name = "Text")

    710. 

  710. 						return this[1]

    711. 

  711. 					else if(Name = "Count")

    712. 

  712. 					{

    713. 

  713. 						Gui, % Control.GUINum ":Default"

    714. 

  714. 						Gui, ListView, % Control.ClassNN

    715. 

  715. 						Return LV_GetCount("Column")

    716. 

  716. 					}

    717. 

  717. 					else if Name in Checked,Focused,Selected

    718. 

  718. 					{

    719. 

  719. 						Value := {Checked : "Checked", Focused : "Focused", Selected : ""}[Name]

    720. 

  720. 						Gui, % Control.GUINum ":Default"

    721. 

  721. 						Gui, ListView, % Control.ClassNN

    722. 

  722. 						return this.GetUnsortedIndex(LV_GetNext(this.GetSortedIndex(this._.RowNumber, Control.hwnd) - 1, Value), Control.hwnd) = this._.RowNumber

    723. 

  723. 					}

    724. 

  724. 					else if(Name = "Icon" || Name = "IconNumber")

    725. 

  725. 						return this._[Name]

    726. 

  726. 					else if(Name = "Controls")

    727. 

  727. 						return this._.Controls

    728. 

  728. 				}

    729. 

  729. 			}

    730. 

  730. 			__Set(Name, Value)

    731. 

  731. 			{				

    732. 

  732. 				;~ global CGUI

    733. 

  733. 				GUI := CGUI.GUIList[this._.GUINum]

    734. 

  734. 				if(!GUI.IsDestroyed)

    735. 

  735. 				{

    736. 

  736. 					Control := GUI.Controls[this._.hwnd]

    737. 

  737. 					if Name is Integer

    738. 

  738. 					{

    739. 

  739. 						if(Name <= this.Count) ;Setting default listview is already done by this.Count __Get

    740. 

  740. 							LV_Modify(this.GetSortedIndex(this._.RowNumber, Control.hwnd), "Col" Name, Value)

    741. 

  741. 						return Value

    742. 

  742. 					}

    743. 

  743. 					else if(Key := {Checked : "Check", Focused : "Focus", "Selected" : ""}[Name])

    744. 

  744. 					{

    745. 

  745. 						Gui, % Control.GUINum ":Default"

    746. 

  746. 						Gui, ListView, % Control.ClassNN

    747. 

  747. 						LV_Modify(this.GetSortedIndex(this._.RowNumber, Control.hwnd), (Value = 0 ? "-" : "") Key)

    748. 

  748. 						if(Name = "Selected")

    749. 

  749. 						{							

    750. 

  750. 							if(LV_GetCount("Selected") = 1)

    751. 

  751. 							{

    752. 

  752. 								Control.ProcessSubControlState(Control._.PreviouslySelectedItem, Control.SelectedItem)

    753. 

  753. 								Control._.PreviouslySelectedItem := Control.SelectedItem

    754. 

  754. 							}

    755. 

  755. 							else

    756. 

  756. 							{

    757. 

  757. 								Control.ProcessSubControlState(Control._.PreviouslySelectedItem, "")

    758. 

  758. 								Control._.PreviouslySelectedItem := ""

    759. 

  759. 							}

    760. 

  760. 						}

    761. 

  761. 						return Value

    762. 

  762. 					}

    763. 

  763. 					else if(Name = "Icon")

    764. 

  764. 					{

    765. 

  765. 						this.SetIcon(Value, this._.HasKey("IconNumber") ? this._.IconNumber : 1)

    766. 

  766. 						return Value

    767. 

  767. 					}

    768. 

  768. 					else if(Name = "IconNumber")

    769. 

  769. 					{

    770. 

  770. 						this._.IconNumber := Value

    771. 

  771. 						if(this._.Icon)

    772. 

  772. 							this.SetIcon(this._.Icon, Value)

    773. 

  773. 						return Value

    774. 

  774. 					}

    775. 

  775. 				}

    776. 

  776. 			}

    777. 

  777. 		}

    778. 

  778. 	}

    779. 

  779. 	

    780. 

  780. 	/*

    781. 

  781. 	Event: Introduction

    782. 

  782. 	To handle control events you need to create a function with this naming scheme in your window class: ControlName_EventName(params)

    783. 

  783. 	The parameters depend on the event and there may not be params at all in some cases.

    784. 

  784. 	Additionally it is required to create a label with this naming scheme: GUIName_ControlName

    785. 

  785. 	GUIName is the name of the window class that extends CGUI. The label simply needs to call CGUI.HandleEvent(). 

    786. 

  786. 	For better readability labels may be chained since they all execute the same code.

    787. 

  787. 	Instead of using ControlName_EventName() you may also call <CControl.RegisterEvent> on a control instance to register a different event function name.

    788. 

  788. 	

    789. 

  789. 	Event: Click(RowItem)

    790. 

  790. 	Invoked when the user clicked on the control.

    791. 

  791. 	

    792. 

  792. 	Event: DoubleClick(RowItem)

    793. 

  793. 	Invoked when the user double-clicked on the control.

    794. 

  794. 	

    795. 

  795. 	Event: RightClick(RowItem)

    796. 

  796. 	Invoked when the user right-clicked on the control.

    797. 

  797. 	

    798. 

  798. 	Event: DoubleRightClick(RowItem)

    799. 

  799. 	Invoked when the user double-right-clicked on the control.

    800. 

  800. 	

    801. 

  801. 	Event: ColumnClick(ColumnIndex)

    802. 

  802. 	Invoked when the user clicked on a column header.

    803. 

  803. 	

    804. 

  804. 	Event: EditingStart(RowItem)

    805. 

  805. 	Invoked when the user started editing the first cell of a row.

    806. 

  806. 	

    807. 

  807. 	Event: EditingEnd(RowItem)

    808. 

  808. 	Invoked when the user finished editing a cell.

    809. 

  809. 	

    810. 

  810. 	Event: ItemActivate(RowItem)

    811. 

  811. 	Invoked when a row was activated.

    812. 

  812. 	

    813. 

  813. 	Event: KeyPress(KeyCode)

    814. 

  814. 	Invoked when the user pressed a key while the control had focus.

    815. 

  815. 	

    816. 

  816. 	Event: MouseLeave()

    817. 

  817. 	Invoked when the mouse leaves the control boundaries.

    818. 

  818. 	

    819. 

  819. 	Event: FocusReceived()

    820. 

  820. 	Invoked when the control receives the focus.

    821. 

  821. 	

    822. 

  822. 	Event: FocusLost()

    823. 

  823. 	Invoked when the control loses the focus.

    824. 

  824. 	

    825. 

  825. 	Event: Marquee()

    826. 

  826. 	Invoked when the mouse gets moved over the control.

    827. 

  827. 	

    828. 

  828. 	Event: ScrollingStart()

    829. 

  829. 	Invoked when the user starts scrolling the control.

    830. 

  830. 	

    831. 

  831. 	Event: ScrollingEnd()

    832. 

  832. 	Invoked when the user ends scrolling the control.

    833. 

  833. 	

    834. 

  834. 	Event: ItemSelected(RowItem)

    835. 

  835. 	Invoked when the user selects an item.

    836. 

  836. 	

    837. 

  837. 	Event: ItemDeselected(RowItem)

    838. 

  838. 	Invoked when the user deselects an item.

    839. 

  839. 	

    840. 

  840. 	Event: SelectionChanged(RowItem)

    841. 

  841. 	Invoked when the selected item(s) has/have changed.

    842. 

  842. 	

    843. 

  843. 	Event: ItemFocused(RowItem)

    844. 

  844. 	Invoked when a row gets focused.

    845. 

  845. 	

    846. 

  846. 	Event: ItemDefocused(RowItem)

    847. 

  847. 	Invoked when a row loses the focus.

    848. 

  848. 	

    849. 

  849. 	Event: FocusedChanged(RowItem)

    850. 

  850. 	Invoked when the row focus has changed.

    851. 

  851. 	

    852. 

  852. 	Event: ItemChecked(RowItem)

    853. 

  853. 	Invoked when the user checks a row.

    854. 

  854. 	

    855. 

  855. 	Event: ItemUnchecked(RowItem)

    856. 

  856. 	Invoked when the user unchecks a row.	

    857. 

  857. 	

    858. 

  858. 	Event: CheckedChanged(RowItem)

    859. 

  859. 	Invoked when the checked row(s) has/have changed.

    860. 

  860. 	*/

    861. 

  861. 	HandleEvent(Event)

    862. 

  862. 	{

    863. 

  863. 		Row := this._.Items.IndependentSorting ? this.CItems.CRow.GetUnsortedIndex(Event.EventInfo, this.hwnd) : Event.EventInfo

    864. 

  864. 		if(Event.GUIEvent == "E")

    865. 

  865. 			this.CallEvent("EditingStart", Row)

    866. 

  866. 		else if(EventName := {DoubleClick : "DoubleClick", R : "DoubleRightClick", ColClick : "ColumnClick", e : "EditingEnd", Normal : "Click", RightClick : "RightClick",  A : "ItemActivate", K : "KeyPress"}[Event.GUIEvent])

    867. 

  867. 			this.CallEvent(EventName, Row)

    868. 

  868. 		else if(Event.GUIEvent == "F")

    869. 

  869. 			this.CallEvent("FocusReceived")

    870. 

  870. 		else if(Event.GUIEvent == "S")

    871. 

  871. 			this.CallEvent("ScrollingStart")

    872. 

  872. 		else if(EventName :=  {C : "MouseLeave", f : "FocusLost", M : "Marquee", s : "ScrollingEnd"}[Event.GUIEvent])

    873. 

  873. 			this.CallEvent(EventName)

    874. 

  874. 		else if(Event.GUIEvent = "I")

    875. 

  875. 		{

    876. 

  876. 			if(InStr(Event.Errorlevel, "S")) ;Process sub control state

    877. 

  877. 			{

    878. 

  878. 				if(LV_GetCount("Selected") = 1)

    879. 

  879. 					this.ProcessSubControlState(this._.PreviouslySelectedItem, this.SelectedItem)

    880. 

  880. 				else

    881. 

  881. 					this.ProcessSubControlState(this._.PreviouslySelectedItem, "")

    882. 

  882. 			}

    883. 

  883. 			Mapping := { Sa : "ItemSelected", sb : "ItemDeselected", Fa : "ItemFocused", fb : "ItemDefocused", Ca : "ItemChecked", cb : "ItemUnChecked"} ;Case insensitivity strikes back!

    884. 

  884. 			for EventIndex, Function in Mapping

    885. 

  885. 				if(InStr(Event.Errorlevel, SubStr(EventIndex, 1, 1), true))

    886. 

  886. 				{

    887. 

  887. 					this.CallEvent(Function, Row)

    888. 

  888. 					break

    889. 

  889. 				}

    890. 

  890. 			if(EventName :=  {S : "SelectionChanged", C : "CheckedChanged", F : "FocusedChanged"}[Event.Errorlevel])

    891. 

  891. 				this.CallEvent(EventName, Row)

    892. 

  892. 			if(InStr(Event.Errorlevel, "S")) ;Process sub control state

    893. 

  893. 			{

    894. 

  894. 				if(LV_GetCount("Selected") = 1)

    895. 

  895. 					this._.PreviouslySelectedItem := this.SelectedItem

    896. 

  896. 				else

    897. 

  897. 					this._.PreviouslySelectedItem := ""

    898. 

  898. 			}

    899. 

  899. 		}

    900. 

  900. 	}

    901. 

  901. }
    902.