trunk/Src/wptListView.cpp

/* wptListView.cpp - Dynamic list view control
 *      Copyright (C) 2000-2007, 2009 Timo Schulz
 *      Copyright (C) 2004 Andreas Jobs
 *
 * This file is part of WinPT.
 *
 * WinPT is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License 
 * as published by the Free Software Foundation; either version 2 
 * of the License, or (at your option) any later version.
 *  
 * WinPT is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdio.h>
#include <windows.h>
#include <commctrl.h>

#include "wptCommonCtl.h"
#include "wptW32API.h"
#include "wptVersion.h"
#include "wptErrors.h"
#include "wptTypes.h"
#include "wptGPG.h"
#include "wptKeylist.h"
#include "wptUTF8.h"
#include "resource.h"


void
listview_new (listview_ctrl_t *ctx, HWND ctrl)
{
    struct listview_ctrl_s *c;

    c = new struct listview_ctrl_s;
    if (!c)
        BUG (NULL);
    memset (c, 0, sizeof *c);
    c->ctrl = ctrl? ctrl : NULL;
    c->hil = NULL;
    *ctx = c;
}


void
listview_release (listview_ctrl_t ctx)
{
    if (!ctx)
        return;

    ctx->cols = 0;
    ctx->ctrl = NULL;
    ctx->items = 0;
    if (ctx->hil)
        ImageList_Destroy (ctx->hil);
    delete ctx;
}


int
listview_set_column_width (listview_ctrl_t ctx, int col, int width)
{
    LVCOLUMN lvc;

    memset (&lvc, 0, sizeof (lvc));
    lvc.mask = LVCF_WIDTH;
    lvc.cx = width;
    ListView_SetColumn (ctx->ctrl, col, &lvc);
    return 0;
}


int
listview_add_column (listview_ctrl_t ctx, listview_column_t col)
{       
    int rc = 0;
    LV_COLUMN lvc;

    memset (&lvc, 0, sizeof lvc);
    lvc.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
    lvc.pszText = col->fieldname;
    lvc.cx = col->width;
    lvc.fmt = LVCFMT_LEFT;
    lvc.iSubItem = col->pos;
    if (ListView_InsertColumn (ctx->ctrl, col->pos, &lvc) == -1)
        rc = 1;
    ctx->cols++;
    return rc;
}


int 
listview_add_item_pos (listview_ctrl_t ctx, int pos)
{
    int rc = 0;
    LV_ITEM lvi;

    memset (&lvi, 0, sizeof lvi);
    lvi.iItem = pos;
    if (ListView_InsertItem (ctx->ctrl, &lvi) != pos)
        rc = -1;
    ctx->items++;
    return rc;
}


int
listview_add_item (listview_ctrl_t ctx, const char *text)
{
    int rc = 0;
    LV_ITEM lvi;

    memset (&lvi, 0, sizeof lvi);
    lvi.mask = LVIF_TEXT;
    lvi.pszText = (char *)text;
    rc = ListView_InsertItem (ctx->ctrl, &lvi);
    if( rc == -1 )
        rc = 1; 
    ctx->items++;
    return rc;
}


int
listview_add_item_image (listview_ctrl_t ctx, const char *text, int image)
{
    int rc = 0;
    LV_ITEM lvi;

    memset( &lvi, 0, sizeof lvi );
    lvi.mask = LVIF_TEXT | LVIF_IMAGE;
    lvi.pszText = (char *)text;
    lvi.iImage = image;
    rc = ListView_InsertItem (ctx->ctrl, &lvi);
    if (rc == -1)
        rc = 1; 
    ctx->items++;
    return rc;
}


int
listview_add_item2 (listview_ctrl_t ctx, const char *text, void *magic)
{
    int rc = 0;
    LVITEM lvi;

    memset (&lvi, 0, sizeof (lvi));
    lvi.mask = LVIF_TEXT | LVIF_PARAM;
    lvi.pszText = (char *)text;
    lvi.lParam = (LPARAM)magic;
    rc = ListView_InsertItem (ctx->ctrl, &lvi);
    if (rc == -1)
        rc = 1; 
    ctx->items++;
    return rc;
}


void*
listview_get_item2 (listview_ctrl_t ctx, int pos)
{
    LVITEM lvi;

    memset (&lvi, 0, sizeof lvi);
    lvi.mask = LVIF_PARAM;
    lvi.iItem = pos;
    ListView_GetItem (ctx->ctrl, &lvi);
    return (void*)lvi.lParam;
}


int
listview_set_item2 (listview_ctrl_t ctx, int pos, void *magic)
{
    LVITEM lvi;

    memset (&lvi, 0, sizeof (lvi));
    lvi.mask = LVIF_PARAM;
    lvi.iItem = pos;
    lvi.lParam = (LPARAM)magic;
    if (ListView_SetItem (ctx->ctrl, &lvi) == -1)
        return 1;
    return 0;
}


void
listview_add_sub_item (listview_ctrl_t ctx, int pos, int col, const char *text)
{
    ListView_SetItemText (ctx->ctrl, pos, col, (char*)text);
}


int
listview_count_items (listview_ctrl_t ctx, int curr_sel)
{       
    int n;

    n = curr_sel? ListView_GetSelectedCount( ctx->ctrl ) :    
                  ListView_GetItemCount( ctx->ctrl );
    return n;
}


int
listview_del_column (listview_ctrl_t ctx, int pos)
{
    ctx->cols--;
    return ListView_DeleteColumn (ctx->ctrl, pos)? 0 : 1;
}


/* Delete a single item from @ctx at position @pos. */
int
listview_del_item (listview_ctrl_t ctx, int pos)
{
    int rc = 0;

    if (ListView_DeleteItem (ctx->ctrl, pos) == -1)
        rc = 1;
    return rc;
}


/* Delete all selected items in @ctx. */
int
listview_del_sel_items (listview_ctrl_t ctx)
{       
    int i, n;

    n = listview_count_items (ctx, 0);
    for (i = n;  i > -1; i--) {
        if (listview_get_item_state (ctx, i))
            listview_del_item (ctx, i);
    }
    return 0;
}


int
listview_del_all_items (listview_ctrl_t ctx)
{       
    int rc = 0;

    if (ListView_DeleteAllItems (ctx->ctrl) == FALSE)
        rc = 1;
    return rc;
}


/* Return the index of the selected item.
   Support both selections and checkboxes. */
int
listview_get_selected_item (listview_ctrl_t lv)
{
    int pos, i;
    
    pos = listview_get_curr_pos (lv);
    if (pos != -1)
        return pos;
    for (i=0; i < listview_count_items (lv, 0); i++) {
        if (listview_get_item_state (lv, i))
            return i;
    }
    return -1;
}


/* Return if the given element is selected or if the ext
   style is used, if the checkbox is activated. */
int
listview_get_item_state (listview_ctrl_t ctx, int pos)
{
    int ret;
    if (ctx->ext_chkbox)
        ret = ListView_GetCheckState (ctx->ctrl, pos);
    else
        ret = ListView_GetItemState (ctx->ctrl, pos, LVIS_SELECTED);
    return ret;
}


int
listview_sort_items (listview_ctrl_t ctx, int sortby, listview_cmp sort_cb)
{
    ListView_SortItems (ctx->ctrl, sort_cb, sortby);
    return 0;
}


int
listview_get_curr_pos (listview_ctrl_t ctx)
{       
    return ListView_GetNextItem( ctx->ctrl, -1, LVNI_SELECTED );
}


int
listview_get_item_text (listview_ctrl_t ctx, int pos, int col, char *text,
                        int maxbytes)
{
    if (pos == -1) {
        pos = listview_get_curr_pos (ctx);
        if (pos == -1)
            return -1;
    }
    ListView_GetItemText (ctx->ctrl, pos, col, text, maxbytes);
    return 0;
}


/* Use extended style with checkboxes for each item. */
void
listview_set_chkbox_style (listview_ctrl_t ctx)
{
    DWORD flag = LVS_EX_CHECKBOXES;
    DWORD style;
    style = ListView_GetExtendedListViewStyle (ctx->ctrl)|flag;    
    ListView_SetExtendedListViewStyle (ctx->ctrl, style);
    ctx->ext_chkbox = 1;
}


/* Use extended style to select the entire row. */
void
listview_set_ext_style (listview_ctrl_t ctx)
{
    DWORD flag = LVS_EX_FULLROWSELECT;
    DWORD style;
    style = ListView_GetExtendedListViewStyle (ctx->ctrl)|flag;
    ListView_SetExtendedListViewStyle (ctx->ctrl, style);
}


void
listview_set_grid_style (listview_ctrl_t ctx)
{
    DWORD flag = LVS_EX_GRIDLINES;
    DWORD style;
    style = ListView_GetExtendedListViewStyle (ctx->ctrl)|flag;
    ListView_SetExtendedListViewStyle (ctx->ctrl, style);
}

int
listview_set_column_order (listview_ctrl_t ctx, int *array)
{       
    return ListView_SetColumnOrderArray (ctx->ctrl, ctx->cols, array);
}


void
listview_select_all (listview_ctrl_t ctx)
{       
    ListView_SetItemState (ctx->ctrl, -1, LVIS_SELECTED, LVIS_SELECTED);
}


void
listview_deselect_all (listview_ctrl_t ctx)
{
    ListView_SetItemState (ctx->ctrl, -1, ~LVNI_SELECTED, LVNI_SELECTED);
}


void
listview_select_one (listview_ctrl_t ctx, int pos)
{
    ListView_SetItemState (ctx->ctrl, pos, LVIS_SELECTED|LVIS_FOCUSED, 
                                            LVIS_FOCUSED|LVIS_SELECTED);
}


void
listview_scroll (listview_ctrl_t ctx, int oldpos, int newpos)
{    
    const int size=14;
    
    if (oldpos == -1)
        oldpos = 0;
    ListView_Scroll (ctx->ctrl, 0, (newpos-oldpos)*size);
}


static int 
listview_find_substr (listview_ctrl_t ctx, const char *str)
{
    char buf[256];
    int i, n, fnd = 0;

    /* We assume the first column contains text. */
    n = listview_count_items (ctx, 0);
    for (i = 0; i < n; i++) {
        listview_get_item_text (ctx, i, 0, buf, DIM (buf)-1);
        if (stristr (buf, str)) {
            fnd = 1;
            break;
        }
    }
    if (!fnd)
        i = -1; /* not found */
    return i;
}


int
listview_find (listview_ctrl_t ctx, const char *str, int substr)
{
    LVFINDINFO inf;
    int pos;

    /* XXX: allow to make a substring search. */
    memset (&inf, 0, sizeof (inf));
    inf.flags = LVFI_STRING|LVFI_PARTIAL;
    inf.psz = str;
    pos = ListView_FindItem (ctx->ctrl, -1, &inf);
    if (pos == -1 && substr)
        pos = listview_find_substr (ctx, str);
    return pos;
}


void
listview_setview (listview_ctrl_t ctx, DWORD view)
{
    DWORD style = GetWindowLong (ctx->ctrl, GWL_STYLE);
    if ((style & LVS_TYPEMASK) != view)
        SetWindowLong (ctx->ctrl, GWL_STYLE, (style & ~LVS_TYPEMASK) | view);
}


void
listview_set_image_list (listview_ctrl_t ctx, int cx, int cy, 
                         HICON *ico, DWORD nicons)
{
    HIMAGELIST hil;

    if (cx <= 0 || cy <= 0)
        cx = cy = 16; /* default size. */

    hil = ImageList_Create (cx, cy, ILC_COLOR8|ILC_MASK, nicons, 1);
    ImageList_SetBkColor (hil, CLR_NONE);
    for (DWORD i=0; i < nicons; i++)
        ImageList_AddIcon (hil, ico[i]);    
    (void)ListView_SetImageList (ctx->ctrl, hil, LVSIL_SMALL);    
}
1	werner	36	/* wptListView.cpp - Dynamic list view control
2	twoaday	328	* Copyright (C) 2000-2007, 2009 Timo Schulz
3	werner	36	* Copyright (C) 2004 Andreas Jobs
4			*
5			* This file is part of WinPT.
6			*
7			* WinPT is free software; you can redistribute it and/or
8			* modify it under the terms of the GNU General Public License
9			* as published by the Free Software Foundation; either version 2
10			* of the License, or (at your option) any later version.
11			*
12			* WinPT is distributed in the hope that it will be useful,
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15			* General Public License for more details.
16			*/
17			#ifdef HAVE_CONFIG_H
18			#include <config.h>
19			#endif
20
21			#include <stdio.h>
22			#include <windows.h>
23			#include <commctrl.h>
24
25			#include "wptCommonCtl.h"
26			#include "wptW32API.h"
27			#include "wptVersion.h"
28			#include "wptErrors.h"
29			#include "wptTypes.h"
30			#include "wptGPG.h"
31			#include "wptKeylist.h"
32	twoaday	204	#include "wptUTF8.h"
33	werner	47	#include "resource.h"
34	werner	36
35
36	twoaday	208	void
37			listview_new (listview_ctrl_t *ctx, HWND ctrl)
38	werner	36	{
39			struct listview_ctrl_s *c;
40
41			c = new struct listview_ctrl_s;
42	twoaday	133	if (!c)
43			BUG (NULL);
44	twoaday	273	memset (c, 0, sizeof *c);
45	twoaday	208	c->ctrl = ctrl? ctrl : NULL;
46	twoaday	133	c->hil = NULL;
47	werner	36	*ctx = c;
48	twoaday	174	}
49	werner	36
50
51			void
52	twoaday	133	listview_release (listview_ctrl_t ctx)
53	werner	36	{
54	twoaday	133	if (!ctx)
55			return;
56
57			ctx->cols = 0;
58			ctx->ctrl = NULL;
59			ctx->items = 0;
60			if (ctx->hil)
61			ImageList_Destroy (ctx->hil);
62			delete ctx;
63	twoaday	193	}
64	werner	36
65
66			int
67	twoaday	193	listview_set_column_width (listview_ctrl_t ctx, int col, int width)
68			{
69			LVCOLUMN lvc;
70
71			memset (&lvc, 0, sizeof (lvc));
72			lvc.mask = LVCF_WIDTH;
73			lvc.cx = width;
74			ListView_SetColumn (ctx->ctrl, col, &lvc);
75			return 0;
76			}
77
78
79			int
80	werner	36	listview_add_column (listview_ctrl_t ctx, listview_column_t col)
81			{
82			int rc = 0;
83			LV_COLUMN lvc;
84
85	twoaday	273	memset (&lvc, 0, sizeof lvc);
86	werner	36	lvc.mask = LVCF_TEXT \| LVCF_WIDTH \| LVCF_SUBITEM;
87			lvc.pszText = col->fieldname;
88			lvc.cx = col->width;
89			lvc.fmt = LVCFMT_LEFT;
90			lvc.iSubItem = col->pos;
91	twoaday	273	if (ListView_InsertColumn (ctx->ctrl, col->pos, &lvc) == -1)
92	werner	36	rc = 1;
93			ctx->cols++;
94			return rc;
95	twoaday	200	}
96	werner	36
97
98			int
99			listview_add_item_pos (listview_ctrl_t ctx, int pos)
100			{
101			int rc = 0;
102			LV_ITEM lvi;
103
104			memset (&lvi, 0, sizeof lvi);
105			lvi.iItem = pos;
106	twoaday	133	if (ListView_InsertItem (ctx->ctrl, &lvi) != pos)
107			rc = -1;
108	werner	36	ctx->items++;
109			return rc;
110			}
111
112
113			int
114	twoaday	241	listview_add_item (listview_ctrl_t ctx, const char *text)
115	werner	36	{
116			int rc = 0;
117			LV_ITEM lvi;
118
119	twoaday	241	memset (&lvi, 0, sizeof lvi);
120	werner	36	lvi.mask = LVIF_TEXT;
121			lvi.pszText = (char *)text;
122	twoaday	241	rc = ListView_InsertItem (ctx->ctrl, &lvi);
123	werner	36	if( rc == -1 )
124			rc = 1;
125			ctx->items++;
126			return rc;
127	twoaday	200	}
128	werner	36
129
130			int
131	twoaday	133	listview_add_item_image (listview_ctrl_t ctx, const char *text, int image)
132			{
133			int rc = 0;
134			LV_ITEM lvi;
135
136			memset( &lvi, 0, sizeof lvi );
137			lvi.mask = LVIF_TEXT \| LVIF_IMAGE;
138			lvi.pszText = (char *)text;
139			lvi.iImage = image;
140			rc = ListView_InsertItem (ctx->ctrl, &lvi);
141			if (rc == -1)
142			rc = 1;
143			ctx->items++;
144			return rc;
145			}
146
147
148			int
149	werner	36	listview_add_item2 (listview_ctrl_t ctx, const char text, void magic)
150			{
151			int rc = 0;
152	twoaday	139	LVITEM lvi;
153	werner	36
154	twoaday	139	memset (&lvi, 0, sizeof (lvi));
155	werner	36	lvi.mask = LVIF_TEXT \| LVIF_PARAM;
156			lvi.pszText = (char *)text;
157			lvi.lParam = (LPARAM)magic;
158	twoaday	139	rc = ListView_InsertItem (ctx->ctrl, &lvi);
159			if (rc == -1)
160	werner	36	rc = 1;
161			ctx->items++;
162			return rc;
163	twoaday	200	}
164	werner	36
165
166			void*
167			listview_get_item2 (listview_ctrl_t ctx, int pos)
168			{
169			LVITEM lvi;
170
171			memset (&lvi, 0, sizeof lvi);
172			lvi.mask = LVIF_PARAM;
173			lvi.iItem = pos;
174			ListView_GetItem (ctx->ctrl, &lvi);
175			return (void*)lvi.lParam;
176			}
177
178	twoaday	241
179	werner	36	int
180			listview_set_item2 (listview_ctrl_t ctx, int pos, void *magic)
181			{
182			LVITEM lvi;
183
184			memset (&lvi, 0, sizeof (lvi));
185			lvi.mask = LVIF_PARAM;
186			lvi.iItem = pos;
187			lvi.lParam = (LPARAM)magic;
188			if (ListView_SetItem (ctx->ctrl, &lvi) == -1)
189			return 1;
190			return 0;
191			}
192
193
194			void
195	twoaday	204	listview_add_sub_item (listview_ctrl_t ctx, int pos, int col, const char *text)
196			{
197	twoaday	205	ListView_SetItemText (ctx->ctrl, pos, col, (char*)text);
198	twoaday	200	}
199	werner	36
200
201			int
202	twoaday	328	listview_count_items (listview_ctrl_t ctx, int curr_sel)
203	werner	36	{
204			int n;
205
206			n = curr_sel? ListView_GetSelectedCount( ctx->ctrl ) :
207			ListView_GetItemCount( ctx->ctrl );
208			return n;
209	twoaday	200	}
210	werner	36
211
212			int
213	twoaday	129	listview_del_column (listview_ctrl_t ctx, int pos)
214			{
215			ctx->cols--;
216			return ListView_DeleteColumn (ctx->ctrl, pos)? 0 : 1;
217			}
218
219
220	twoaday	150	/* Delete a single item from @ctx at position @pos. */
221	twoaday	129	int
222	twoaday	150	listview_del_item (listview_ctrl_t ctx, int pos)
223	werner	36	{
224			int rc = 0;
225
226	twoaday	150	if (ListView_DeleteItem (ctx->ctrl, pos) == -1)
227	werner	36	rc = 1;
228			return rc;
229	twoaday	150	}
230	werner	36
231
232	twoaday	150	/* Delete all selected items in @ctx. */
233	werner	36	int
234	twoaday	150	listview_del_sel_items (listview_ctrl_t ctx)
235	werner	36	{
236			int i, n;
237
238			n = listview_count_items (ctx, 0);
239	twoaday	150	for (i = n; i > -1; i--) {
240			if (listview_get_item_state (ctx, i))
241			listview_del_item (ctx, i);
242	werner	36	}
243			return 0;
244	twoaday	150	}
245	werner	36
246
247			int
248	twoaday	150	listview_del_all_items (listview_ctrl_t ctx)
249	werner	36	{
250			int rc = 0;
251
252	twoaday	150	if (ListView_DeleteAllItems (ctx->ctrl) == FALSE)
253	werner	36	rc = 1;
254			return rc;
255	twoaday	150	}
256	werner	36
257
258	twoaday	193	/* Return the index of the selected item.
259			Support both selections and checkboxes. */
260			int
261			listview_get_selected_item (listview_ctrl_t lv)
262			{
263			int pos, i;
264
265			pos = listview_get_curr_pos (lv);
266			if (pos != -1)
267			return pos;
268			for (i=0; i < listview_count_items (lv, 0); i++) {
269			if (listview_get_item_state (lv, i))
270			return i;
271			}
272			return -1;
273			}
274
275
276	twoaday	174	/* Return if the given element is selected or if the ext
277			style is used, if the checkbox is activated. */
278	werner	36	int
279	twoaday	174	listview_get_item_state (listview_ctrl_t ctx, int pos)
280			{
281			int ret;
282			if (ctx->ext_chkbox)
283			ret = ListView_GetCheckState (ctx->ctrl, pos);
284			else
285			ret = ListView_GetItemState (ctx->ctrl, pos, LVIS_SELECTED);
286			return ret;
287			}
288	werner	36
289
290			int
291	twoaday	236	listview_sort_items (listview_ctrl_t ctx, int sortby, listview_cmp sort_cb)
292	twoaday	273	{
293	werner	36	ListView_SortItems (ctx->ctrl, sort_cb, sortby);
294			return 0;
295	twoaday	200	}
296	werner	36
297
298			int
299	twoaday	273	listview_get_curr_pos (listview_ctrl_t ctx)
300	werner	36	{
301			return ListView_GetNextItem( ctx->ctrl, -1, LVNI_SELECTED );
302	twoaday	200	}
303	werner	36
304
305			int
306			listview_get_item_text (listview_ctrl_t ctx, int pos, int col, char *text,
307			int maxbytes)
308			{
309			if (pos == -1) {
310			pos = listview_get_curr_pos (ctx);
311			if (pos == -1)
312			return -1;
313			}
314			ListView_GetItemText (ctx->ctrl, pos, col, text, maxbytes);
315			return 0;
316	twoaday	200	}
317	werner	36
318
319	twoaday	174	/* Use extended style with checkboxes for each item. */
320	werner	36	void
321	twoaday	174	listview_set_chkbox_style (listview_ctrl_t ctx)
322			{
323	twoaday	328	DWORD flag = LVS_EX_CHECKBOXES;
324			DWORD style;
325			style = ListView_GetExtendedListViewStyle (ctx->ctrl)\|flag;
326			ListView_SetExtendedListViewStyle (ctx->ctrl, style);
327	twoaday	174	ctx->ext_chkbox = 1;
328			}
329
330
331			/* Use extended style to select the entire row. */
332			void
333			listview_set_ext_style (listview_ctrl_t ctx)
334	twoaday	328	{
335			DWORD flag = LVS_EX_FULLROWSELECT;
336			DWORD style;
337			style = ListView_GetExtendedListViewStyle (ctx->ctrl)\|flag;
338			ListView_SetExtendedListViewStyle (ctx->ctrl, style);
339	twoaday	174	}
340	werner	36
341
342	twoaday	328	void
343			listview_set_grid_style (listview_ctrl_t ctx)
344			{
345			DWORD flag = LVS_EX_GRIDLINES;
346			DWORD style;
347			style = ListView_GetExtendedListViewStyle (ctx->ctrl)\|flag;
348			ListView_SetExtendedListViewStyle (ctx->ctrl, style);
349			}
350
351	werner	36	int
352	twoaday	328	listview_set_column_order (listview_ctrl_t ctx, int *array)
353	werner	36	{
354	twoaday	328	return ListView_SetColumnOrderArray (ctx->ctrl, ctx->cols, array);
355	twoaday	200	}
356	werner	36
357
358			void
359			listview_select_all (listview_ctrl_t ctx)
360			{
361	twoaday	328	ListView_SetItemState (ctx->ctrl, -1, LVIS_SELECTED, LVIS_SELECTED);
362	twoaday	200	}
363	werner	36
364
365			void
366	twoaday	77	listview_deselect_all (listview_ctrl_t ctx)
367			{
368			ListView_SetItemState (ctx->ctrl, -1, ~LVNI_SELECTED, LVNI_SELECTED);
369			}
370
371
372			void
373	werner	36	listview_select_one (listview_ctrl_t ctx, int pos)
374			{
375	twoaday	241	ListView_SetItemState (ctx->ctrl, pos, LVIS_SELECTED\|LVIS_FOCUSED,
376			LVIS_FOCUSED\|LVIS_SELECTED);
377	werner	36	}
378
379
380			void
381			listview_scroll (listview_ctrl_t ctx, int oldpos, int newpos)
382			{
383			const int size=14;
384
385			if (oldpos == -1)
386			oldpos = 0;
387			ListView_Scroll (ctx->ctrl, 0, (newpos-oldpos)*size);
388			}
389
390
391	twoaday	241	static int
392			listview_find_substr (listview_ctrl_t ctx, const char *str)
393			{
394			char buf[256];
395			int i, n, fnd = 0;
396
397			/* We assume the first column contains text. */
398			n = listview_count_items (ctx, 0);
399			for (i = 0; i < n; i++) {
400	twoaday	304	listview_get_item_text (ctx, i, 0, buf, DIM (buf)-1);
401	twoaday	241	if (stristr (buf, str)) {
402			fnd = 1;
403			break;
404			}
405			}
406			if (!fnd)
407			i = -1; /* not found */
408			return i;
409			}
410
411
412	werner	36	int
413	twoaday	241	listview_find (listview_ctrl_t ctx, const char *str, int substr)
414	werner	36	{
415			LVFINDINFO inf;
416			int pos;
417
418	twoaday	207	/* XXX: allow to make a substring search. */
419	werner	36	memset (&inf, 0, sizeof (inf));
420			inf.flags = LVFI_STRING\|LVFI_PARTIAL;
421			inf.psz = str;
422			pos = ListView_FindItem (ctx->ctrl, -1, &inf);
423	twoaday	241	if (pos == -1 && substr)
424			pos = listview_find_substr (ctx, str);
425	werner	36	return pos;
426			}
427
428	twoaday	129
429			void
430			listview_setview (listview_ctrl_t ctx, DWORD view)
431			{
432			DWORD style = GetWindowLong (ctx->ctrl, GWL_STYLE);
433			if ((style & LVS_TYPEMASK) != view)
434			SetWindowLong (ctx->ctrl, GWL_STYLE, (style & ~LVS_TYPEMASK) \| view);
435			}
436	twoaday	133
437
438			void
439	twoaday	181	listview_set_image_list (listview_ctrl_t ctx, int cx, int cy,
440			HICON *ico, DWORD nicons)
441	twoaday	133	{
442			HIMAGELIST hil;
443
444	twoaday	273	if (cx <= 0 \|\| cy <= 0)
445			cx = cy = 16; /* default size. */
446	twoaday	181
447			hil = ImageList_Create (cx, cy, ILC_COLOR8\|ILC_MASK, nicons, 1);
448	twoaday	144	ImageList_SetBkColor (hil, CLR_NONE);
449	twoaday	328	for (DWORD i=0; i < nicons; i++)
450	twoaday	144	ImageList_AddIcon (hil, ico[i]);
451	twoaday	328	(void)ListView_SetImageList (ctx->ctrl, hil, LVSIL_SMALL);
452	twoaday	133	}