?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Moving to main tree, needed by SysExplorer
[AROS.git] / workbench / classes / zune / nlist / nlist_mcc / NList_func.c
blob346327349b205494b77239d870c87170f223cc9b
1 /***************************************************************************
2
3 NList.mcc - New List MUI Custom Class
4 Registered MUI class, Serial Number: 1d51 0x9d510030 to 0x9d5100A0
5 0x9d5100C0 to 0x9d5100FF
6
7 Copyright (C) 1996-2001 by Gilles Masson
8 Copyright (C) 2001-2005 by NList Open Source Team
9
10 This library is free software; you can redistribute it and/or
11 modify it under the terms of the GNU Lesser General Public
12 License as published by the Free Software Foundation; either
13 version 2.1 of the License, or (at your option) any later version.
14
15 This library is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 Lesser General Public License for more details.
19
20 NList classes Support Site: http://www.sf.net/projects/nlist-classes
21
22 $Id$
23
24 ***************************************************************************/
25
26 #include <clib/alib_protos.h>
27 #include <proto/intuition.h>
28
29 #include "private.h"
30
31 #include "NList_func.h"
32
33 // static functions in this file
34 static BOOL NL_List_Jump(struct NLData *data, LONG pos);
35 static BOOL NL_List_GetPos(struct NLData *data, APTR entry, LONG *pos);
36
37 /* Extent the selection between ent1 and ent2.
38 Make the first_change and last_change optimal for redrawing optimiztion */
39 void NL_SegChanged(struct NLData *data,LONG ent1,LONG ent2)
40 {
41 // D(bug("ent1=%ld ent2=%ld\n",ent1,ent2));
42 // D(bug("first_change=%ld last_change=%ld\n",data->first_change,data->last_change));
43 if (ent1 < data->first_change)
44 { if (ent1 >= data->NList_First)
45 { data->first_change = ent1;
46 if (data->last_change < data->first_change)
47 data->last_change = data->first_change;
48 }
49 else if (ent2 >= data->NList_First)
50 { data->first_change = data->NList_First;
51 if (data->last_change < data->first_change)
52 data->last_change = data->first_change;
53 }
54 }
55 if (ent2 > data->last_change)
56 { if (ent2 < data->NList_First+data->NList_Visible)
57 { data->last_change = ent2;
58 if (data->first_change > data->last_change)
59 data->first_change = data->last_change;
60 }
61 else if (ent1 < data->NList_First+data->NList_Visible)
62 { data->last_change = data->NList_First+data->NList_Visible;
63 if (data->first_change > data->last_change)
64 data->first_change = data->last_change;
65 }
66 }
67 // D(bug("NL_SegChanged: first_change=%ld last_change=%ld\n",data->first_change,data->last_change));
68 }
69
70 /* Extent the selection by this entry optimal */
71 void NL_Changed(struct NLData *data,LONG ent)
72 {
73 // D(bug("ent=%ld\n",ent));
74 // D(bug("first_change=%ld last_change=%ld\n",data->first_change,data->last_change));
75 if ((ent < data->first_change) && (ent >= data->NList_First))
76 { data->first_change = ent;
77 if (data->last_change < data->first_change)
78 data->last_change = data->first_change;
79 }
80 if ((ent > data->last_change) && (ent < data->NList_First+data->NList_Visible))
81 { data->last_change = ent;
82 if (data->first_change > data->last_change)
83 data->first_change = data->last_change;
84 }
85 // D(bug("first_change=%ld last_change=%ld\n",data->first_change,data->last_change));
86 }
87
88
89 void NL_UnSelectAll(struct NLData *data,LONG untouch_ent)
90 {
91 LONG ent;
92
93 DONE_NOTIFY(NTF_Select | NTF_LV_Select);
94 ent = 0;
95 while (ent < data->NList_Entries)
96 { if (ent != untouch_ent)
97 { SELECT2_CHGE(ent,TE_Select_None);
98 data->lastselected = MUIV_NList_Active_Off;
99 data->lastactived = MUIV_NList_Active_Off;
100 }
101 ent++;
102 }
103 REDRAW;
104 /* do_notifies(NTF_AllChanges|NTF_MinMax);*/
105 }
106
107
108 void UnSelectCharSel(struct NLData *data,BOOL redraw)
109 {
110 if (data->NList_TypeSelect && !data->UpdatingScrollbars)
111 {
112 if ((data->sel_pt[data->min_sel].ent >= 0) && (data->sel_pt[data->max_sel].ent >= 0))
113 NL_SegChanged(data,data->sel_pt[data->min_sel].ent,data->sel_pt[data->max_sel].ent);
114
115 data->sel_pt[1].ent = -1;
116 data->min_sel = 1;
117 data->max_sel = 1;
118 if (redraw)
119 REDRAW;
120 }
121 }
122
123
124 void SelectFirstPoint(struct NLData *data,WORD x,WORD y)
125 {
126 struct MUI_NList_TestPos_Result res;
127 LONG e1 = data->sel_pt[data->min_sel].ent;
128 LONG e1x = data->sel_pt[data->min_sel].xoffset;
129 LONG e2 = data->sel_pt[data->max_sel].ent;
130 LONG e2x = data->sel_pt[data->max_sel].xoffset;
131 res.char_number = 0;
132 data->last_sel_click_x = x;
133 data->last_sel_click_y = y;
134 NL_List_TestPos(data,x,y,&res);
135 if ((res.column < 0) || (res.column >= data->numcols))
136 return;
137 if ((e1 >= 0) && (e2 >= 0))
138 { if ((e2 > e1) && (e2x == PMIN))
139 NL_SegChanged(data,e1,e2-1);
140 else
141 NL_SegChanged(data,e1,e2);
142 }
143 if ((data->NList_TypeSelect == MUIV_NList_TypeSelect_CLine) && (res.entry >= 0))
144 {
145 data->sel_pt[2].column = 0;
146 data->sel_pt[2].xoffset = PMIN;
147 data->sel_pt[2].colpos = -1;
148 data->sel_pt[2].ent = res.entry;
149 data->sel_pt[3] = data->sel_pt[2];
150 data->sel_pt[3].ent = res.entry+1;
151 data->sel_pt[0] = data->sel_pt[2];
152 data->sel_pt[1] = data->sel_pt[3];
153 data->min_sel = 0;
154 data->max_sel = 1;
155 NL_Changed(data,res.entry);
156 data->minx_change_entry = res.entry;
157 data->minx_change_offset = PMIN;
158 data->maxx_change_entry = res.entry+1;
159 data->maxx_change_offset = PMIN;
160 REDRAW;
161 }
162 /*
163 * else if ((data->NList_TypeSelect == MUIV_NList_TypeSelect_CWord) && (res.entry >= 0))
164 * {
165 * data->sel_pt[0].column = res.column;
166 * data->sel_pt[0].xoffset = res.xoffset;
167 * data->sel_pt[0].colpos = res.char_number;
168 * data->sel_pt[0].ent = res.entry;
169 * data->sel_pt[1] = data->sel_pt[0];
170 * data->min_sel = 0;
171 * data->max_sel = 1;
172 * if (res.char_number == -1)
173 * { if (res.char_xoffset < 0)
174 * { if (res.column == 0)
175 * { data->sel_pt[0].xoffset = PMIN;
176 * data->sel_pt[1].xoffset += data->cols[res.column].c->minx - res.char_xoffset;
177 * data->sel_pt[1].colpos = 0;
178 * }
179 * else
180 * { data->sel_pt[0].xoffset = data->cols[res.column].c->minx;
181 * data->sel_pt[1].xoffset += data->cols[res.column].c->minx - res.char_xoffset;
182 * data->sel_pt[1].colpos = 0;
183 * }
184 * }
185 * else if (res.char_xoffset >= 0)
186 * { if (res.column == data->numcols-1)
187 * { data->sel_pt[0].xoffset += data->cols[res.column].c->minx - res.char_xoffset;
188 * data->sel_pt[0].colpos = -2;
189 * data->sel_pt[1].column = 0;
190 * data->sel_pt[1].xoffset = PMIN;
191 * data->sel_pt[1].colpos = -1;
192 * data->sel_pt[1].ent++;
193 * }
194 * else
195 * { data->sel_pt[0].xoffset += data->cols[res.column].c->minx - res.char_xoffset;
196 * data->sel_pt[0].colpos = -2;
197 * data->sel_pt[1].xoffset = data->cols[res.column].c->maxx;
198 * data->sel_pt[1].colpos = -2;
199 * }
200 * }
201 * }
202 * else
203 * {
204 * data->sel_pt[0].xoffset += data->cols[res.column].c->minx - res.char_xoffset;
205 * data->sel_pt[1].xoffset = data->sel_pt[0].xoffset + data->hinc;
206 * if (res.char_xoffset < 0)
207 * data->sel_pt[0].colpos++;
208 * data->sel_pt[1].colpos = data->sel_pt[0].colpos + 1;
209 * }
210 * data->sel_pt[2] = data->sel_pt[0];
211 * data->sel_pt[3] = data->sel_pt[1];
212 *
213 * NL_Changed(data,res.entry);
214 * data->minx_change_entry = data->sel_pt[0].ent;
215 * data->minx_change_offset = data->sel_pt[0].xoffset;
216 * data->maxx_change_entry = data->sel_pt[1].ent;
217 * data->maxx_change_offset = data->sel_pt[1].xoffset;
218 * REDRAW;
219 * }
220 */
221 else
222 { if (res.char_number == -1)
223 { if (res.char_xoffset < 0)
224 { if (res.column == 0)
225 res.xoffset = PMIN;
226 else
227 res.xoffset = data->cols[res.column].c->minx;
228 }
229 else if (res.char_xoffset >= 0)
230 { if (res.column == data->numcols-1)
231 { res.xoffset = PMAX; /* when on full right, go full left of next line */
232 /*
233 // The last releases had these lines while the one above had been commented out.
234 // The problem with these 4 lines is, that the beginning of then next line will
235 // be copied as well if the line is marked until the very right position, which
236 // is definitely wrong (see bugs #1190788 and #1720456). I hope this fix does
237 // not have any other negative side effects.
238 res.column=0;
239 res.xoffset = PMIN;
240 res.char_xoffset = PMIN;
241 res.entry++;
242 */
243 }
244 else
245 res.xoffset = data->cols[res.column].c->maxx;
246 res.char_number = -2;
247 }
248 }
249 else
250 { res.xoffset += data->cols[res.column].c->minx - res.char_xoffset;
251 if (res.char_xoffset < 0)
252 res.char_number++;
253 }
254 data->sel_pt[0].column = res.column;
255 data->sel_pt[0].xoffset = res.xoffset;
256 data->sel_pt[0].colpos = res.char_number;
257 data->sel_pt[0].ent = res.entry;
258 data->sel_pt[1].ent = -1;
259 data->min_sel = 1;
260 data->max_sel = 1;
261 if ((e1 >= 0) && (e2 >= 0))
262 { data->minx_change_entry = e1;
263 data->minx_change_offset = e1x;
264 data->maxx_change_entry = e2;
265 data->maxx_change_offset = e2x;
266 }
267 REDRAW;
268 }
269 }
270
271
272 void SelectSecondPoint(struct NLData *data,WORD x,WORD y)
273 {
274 struct MUI_NList_TestPos_Result res;
275 LONG e1 = data->sel_pt[1].ent;
276 LONG e1x = data->sel_pt[1].xoffset;
277 LONG e2,e2x,e3,e3x;
278 data->last_sel_click_x = x;
279 data->last_sel_click_y = y;
280 res.char_number = 0;
281 NL_List_TestPos(data,x,y,&res);
282 if ((res.column < 0) || (res.column >= data->numcols))
283 return;
284 if ((data->NList_TypeSelect == MUIV_NList_TypeSelect_CLine) && (res.entry >= 0))
285 { data->sel_pt[1].column = 0;
286 data->sel_pt[1].xoffset = PMIN;
287 data->sel_pt[1].colpos = -1;
288 data->min_sel = 0;
289 data->max_sel = 1;
290 if (res.entry > data->sel_pt[2].ent)
291 { e3 = 2;
292 data->sel_pt[1].ent = res.entry+1;
293 }
294 else if (res.entry < data->sel_pt[2].ent)
295 { e3 = 3;
296 data->sel_pt[1].ent = res.entry;
297 data->min_sel = 1;
298 data->max_sel = 0;
299 }
300 else
301 { e3 = 2;
302 data->sel_pt[1] = data->sel_pt[3];
303 }
304 data->sel_pt[0] = data->sel_pt[e3];
305 e2 = data->sel_pt[1].ent;
306 if (e1 != e2)
307 { if (e1 > e2) { e3 = e1; e1 = e2; e2 = e3; }
308 data->minx_change_entry = e1;
309 data->minx_change_offset = PMIN;
310 data->maxx_change_entry = e2;
311 data->maxx_change_offset = PMIN;
312 if (e2 > e1)
313 e2--;
314 NL_SegChanged(data,e1,e2);
315 REDRAW;
316 }
317 }
318 /*
319 * else if ((data->NList_TypeSelect == MUIV_NList_TypeSelect_CWord) && (res.entry >= 0))
320 * {
321 * LONG e0 = data->sel_pt[0].ent;
322 * LONG e0x = data->sel_pt[0].xoffset;
323 * data->sel_pt[0].column = res.column;
324 * data->sel_pt[0].xoffset = res.xoffset;
325 * data->sel_pt[0].colpos = res.char_number;
326 * data->sel_pt[0].ent = res.entry;
327 * data->sel_pt[1] = data->sel_pt[0];
328 * data->min_sel = 0;
329 * data->max_sel = 1;
330 * if (res.char_number == -1)
331 * { if (res.char_xoffset < 0)
332 * { if (res.column == 0)
333 * { data->sel_pt[0].xoffset = PMIN;
334 * data->sel_pt[1].xoffset += data->cols[res.column].c->minx - res.char_xoffset;
335 * data->sel_pt[1].colpos = 0;
336 * }
337 * else
338 * { data->sel_pt[0].xoffset = data->cols[res.column].c->minx;
339 * data->sel_pt[1].xoffset += data->cols[res.column].c->minx - res.char_xoffset;
340 * data->sel_pt[1].colpos = 0;
341 * }
342 * }
343 * else if (res.char_xoffset >= 0)
344 * { if (res.column == data->numcols-1)
345 * { data->sel_pt[0].xoffset += data->cols[res.column].c->minx - res.char_xoffset;
346 * data->sel_pt[0].colpos = -2;
347 * data->sel_pt[1].column = 0;
348 * data->sel_pt[1].xoffset = PMIN;
349 * data->sel_pt[1].colpos = -1;
350 * data->sel_pt[1].ent++;
351 * }
352 * else
353 * { data->sel_pt[0].xoffset += data->cols[res.column].c->minx - res.char_xoffset;
354 * data->sel_pt[0].colpos = -2;
355 * data->sel_pt[1].xoffset = data->cols[res.column].c->maxx;
356 * data->sel_pt[1].colpos = -2;
357 * }
358 * }
359 * }
360 * else
361 * {
362 * data->sel_pt[0].xoffset += data->cols[res.column].c->minx - res.char_xoffset;
363 * data->sel_pt[1].xoffset = data->sel_pt[0].xoffset + data->hinc;
364 * if (res.char_xoffset < 0)
365 * data->sel_pt[0].colpos++;
366 * data->sel_pt[1].colpos = data->sel_pt[0].colpos + 1;
367 * }
368 *
369 * if ( (data->sel_pt[0].ent > data->sel_pt[2].ent) ||
370 * ( (data->sel_pt[0].ent == data->sel_pt[2].ent) &&
371 * ( (data->sel_pt[0].column > data->sel_pt[2].column) ||
372 * ( (data->sel_pt[0].column == data->sel_pt[2].column) &&
373 * (data->sel_pt[0].xoffset > data->sel_pt[2].xoffset)
374 * )
375 * )
376 * )
377 * )
378 * { data->sel_pt[0] = data->sel_pt[2];
379 * if ((e1 < data->sel_pt[1].ent) || (e1x < data->sel_pt[1].xoffset))
380 * { data->minx_change_entry = e1;
381 * data->minx_change_offset = e1x;
382 * data->maxx_change_entry = data->sel_pt[1].ent;
383 * data->maxx_change_offset = data->sel_pt[1].xoffset;
384 * NL_SegChanged(data,e1,data->sel_pt[1].ent);
385 * }
386 * else
387 * { data->minx_change_entry = data->sel_pt[1].ent;
388 * data->minx_change_offset = data->sel_pt[1].xoffset;
389 * data->maxx_change_entry = e1;
390 * data->maxx_change_offset = e1x;
391 * NL_SegChanged(data,data->sel_pt[1].ent,e1);
392 * }
393 * }
394 * else if ( (data->sel_pt[1].ent < data->sel_pt[3].ent) ||
395 * ( (data->sel_pt[1].ent == data->sel_pt[3].ent) &&
396 * ( (data->sel_pt[1].column < data->sel_pt[3].column) ||
397 * ( (data->sel_pt[1].column == data->sel_pt[3].column) &&
398 * (data->sel_pt[1].xoffset < data->sel_pt[3].xoffset)
399 * )
400 * )
401 * )
402 * )
403 * { data->sel_pt[1] = data->sel_pt[3];
404 * if ((e0 < data->sel_pt[0].ent) || (e0x < data->sel_pt[0].xoffset))
405 * { data->minx_change_entry = e0;
406 * data->minx_change_offset = e0x;
407 * data->maxx_change_entry = data->sel_pt[0].ent;
408 * data->maxx_change_offset = data->sel_pt[0].xoffset;
409 * NL_SegChanged(data,e0,data->sel_pt[0].ent);
410 * }
411 * else
412 * { data->minx_change_entry = data->sel_pt[0].ent;
413 * data->minx_change_offset = data->sel_pt[0].xoffset;
414 * data->maxx_change_entry = e0;
415 * data->maxx_change_offset = e0x;
416 * NL_SegChanged(data,data->sel_pt[0].ent,e0);
417 * }
418 * }
419 * REDRAW;
420 * }
421 */
422 else if (res.entry >= 0)
423 {
424 if (res.char_number == -1)
425 { if (res.char_xoffset < 0)
426 { if (res.column == 0)
427 res.xoffset = PMIN;
428 else
429 res.xoffset = data->cols[res.column].c->minx;
430 }
431 else if (res.char_xoffset >= 0)
432 {
433 if (res.column == data->numcols-1)
434 {
435 res.xoffset = PMAX; /* when on full right, go full left of next line */
436 /*
437 // before this part was active while the assignment above was inactive
438 // see bugs #1190788 and #1720456
439 res.column=0;
440 res.xoffset = PMIN;
441 res.char_xoffset = PMIN;
442 res.entry++;
443 */
444 }
445 else
446 res.xoffset = data->cols[res.column].c->maxx;
447 res.char_number = -2;
448 }
449 }
450 else
451 {
452 res.xoffset += data->cols[res.column].c->minx - res.char_xoffset;
453 if (res.char_xoffset < 0)
454 res.char_number++;
455 }
456 if ((data->sel_pt[1].ent != res.entry) || (data->sel_pt[1].column != res.column) || (data->sel_pt[1].xoffset != res.xoffset))
457 {
458 data->sel_pt[1].column = res.column;
459 data->sel_pt[1].xoffset = res.xoffset;
460 data->sel_pt[1].colpos = res.char_number;
461 data->sel_pt[1].ent = res.entry;
462 data->min_sel = 0;
463 data->max_sel = 1;
464 if ( (data->sel_pt[0].ent > data->sel_pt[1].ent) ||
465 ( (data->sel_pt[0].ent == data->sel_pt[1].ent) &&
466 ( (data->sel_pt[0].column > data->sel_pt[1].column) ||
467 ( (data->sel_pt[0].column == data->sel_pt[1].column) &&
468 (data->sel_pt[0].xoffset > data->sel_pt[1].xoffset)
469 )
470 )
471 )
472 )
473 { data->min_sel = 1;
474 data->max_sel = 0;
475 }
476 else if ((data->sel_pt[0].ent == data->sel_pt[1].ent) &&
477 (data->sel_pt[0].column == data->sel_pt[1].column) &&
478 (data->sel_pt[0].xoffset == data->sel_pt[1].xoffset))
479 { data->min_sel = 1;
480 data->max_sel = 1;
481 data->sel_pt[1].ent = -1;
482 }
483
484 e2 = data->sel_pt[1].ent;
485 e2x = data->sel_pt[1].xoffset;
486 if (e1 < 0)
487 { e1 = data->sel_pt[0].ent;
488 e1x = data->sel_pt[0].xoffset;
489 }
490 else if (e2 < 0)
491 { e2 = data->sel_pt[0].ent;
492 e2x = data->sel_pt[0].xoffset;
493 }
494 if ((e2 < e1) || ((e2 == e1) && (e2x < e1x)))
495 { e3 = e2; e2 = e1; e1 = e3; e3x = e2x; e2x = e1x; e1x = e3x; }
496 if ((e1 >= 0) && (e2 >= 0))
497 { NL_SegChanged(data,e1,e2);
498 data->minx_change_entry = e1;
499 data->minx_change_offset = e1x;
500 data->maxx_change_entry = e2;
501 data->maxx_change_offset = e2x;
502 }
503 REDRAW;
504 }
505 }
506 }
507
508
509 BOOL NL_List_First(struct NLData *data,LONG lf,struct TagItem *tag)
510 {
511 struct TagItem ltag;
512 BOOL scrolled = FALSE;
513
514 ENTER();
515
516 if (!tag)
517 tag = &ltag;
518
519 if((data->NList_Entries > 0) && (lf != data->NList_First))
520 {
521 switch (lf)
522 {
523 case MUIV_NList_First_Top:
524 lf = 0;
525 break;
526
527 case MUIV_NList_First_Bottom:
528 {
529 lf = data->NList_Entries - data->NList_Visible;
530 if (lf < 0)
531 lf = 0;
532 }
533 break;
534
535 case MUIV_NList_First_Up:
536 {
537 lf = data->NList_First - 1;
538 if (lf < 0)
539 lf = 0;
540 }
541 break;
542
543 case MUIV_NList_First_Down:
544 {
545 lf = data->NList_First + 1;
546 if (lf + data->NList_Visible >= data->NList_Entries)
547 lf = data->NList_Entries - data->NList_Visible;
548 if (lf < 0)
549 lf = 0;
550 }
551 break;
552
553 case MUIV_NList_First_PageUp:
554 {
555 lf = data->NList_First - data->NList_Visible + 1;
556 if (lf < 0)
557 lf = 0;
558 }
559 break;
560
561 case MUIV_NList_First_PageDown:
562 {
563 lf = data->NList_First + data->NList_Visible - 1;
564 if (lf + data->NList_Visible >= data->NList_Entries)
565 lf = data->NList_Entries - data->NList_Visible;
566 if (lf < 0)
567 lf = 0;
568 }
569 break;
570
571 case MUIV_NList_First_Up2:
572 {
573 lf = data->NList_First - 2;
574 if (lf < 0)
575 lf = 0;
576 }
577 break;
578
579 case MUIV_NList_First_Down2:
580 {
581 lf = data->NList_First + 2;
582 if (lf + data->NList_Visible >= data->NList_Entries)
583 lf = data->NList_Entries - data->NList_Visible;
584 if (lf < 0)
585 lf = 0;
586 }
587 break;
588
589 case MUIV_NList_First_Up4:
590 {
591 lf = data->NList_First - 4;
592 if (lf < 0)
593 lf = 0;
594 }
595 break;
596
597 case MUIV_NList_First_Down4 :
598 {
599 lf = data->NList_First + 4;
600 if (lf + data->NList_Visible >= data->NList_Entries)
601 lf = data->NList_Entries - data->NList_Visible;
602 if (lf < 0)
603 lf = 0;
604 }
605 break;
606 }
607
608 if ((lf >= 0) && (lf < data->NList_Entries))
609 {
610 if (data->NList_First != lf)
611 {
612 DO_NOTIFY(NTF_First);
613 scrolled = TRUE;
614 }
615
616 data->NList_First = lf;
617 REDRAW;
618 /* do_notifies(NTF_AllChanges|NTF_MinMax);*/
619 tag->ti_Data = lf;
620 }
621 else
622 tag->ti_Tag = TAG_IGNORE;
623 }
624 else
625 tag->ti_Tag = TAG_IGNORE;
626
627 RETURN(scrolled);
628 return scrolled;
629 }
630
631
632 BOOL NL_List_Active(struct NLData *data, LONG la, struct TagItem *tag, LONG newactsel, LONG acceptsame, ULONG flags)
633 {
634 struct TagItem ltag;
635 struct TagItem *tag2 = tag;
636 LONG ent;
637 BOOL changed = FALSE;
638
639 ENTER();
640
641 //D(DBF_STARTUP, "NL_List_Active: 0x%lx la=%ld newactsel=%ld acceptsame=%ld data->pad1=%ld",obj,la,newactsel,acceptsame,data->pad1);
642
643 if (data->NList_TypeSelect || !data->NList_Input)
644 {
645 if (tag2)
646 tag->ti_Data = MUIV_NList_Active_Off;
647
648 if((la == MUIV_NList_Active_Off) || (data->NList_Entries <= 0))
649 {
650 data->pad1 = MUIV_NList_Active_Off;
651
652 RETURN(TRUE);
653 return TRUE;
654 }
655 else if (la < 0)
656 {
657 if(tag2 == NULL)
658 {
659 changed = NL_List_First(data,la,tag);
660
661 RETURN(changed);
662 return changed;
663 }
664 else if (data->NList_Entries > 0)
665 {
666 switch (la)
667 {
668 case MUIV_NList_Active_Top :
669 case MUIV_NList_Active_UntilTop :
670 la = 0;
671 break;
672 case MUIV_NList_Active_Bottom :
673 case MUIV_NList_Active_UntilBottom :
674 la = data->pad1 - 1;
675 break;
676 case MUIV_NList_Active_Up :
677 if (data->NList_Active != MUIV_NList_Active_Off)
678 la = data->pad1 - 1;
679 else
680 la = data->NList_First - 1 + data->NList_Visible;
681 break;
682 case MUIV_NList_Active_Down :
683 if (data->pad1 != MUIV_NList_Active_Off)
684 la = data->pad1 + 1;
685 else
686 la = data->NList_First;
687 break;
688 case MUIV_NList_Active_PageUp :
689 case MUIV_NList_Active_UntilPageUp :
690 if (data->pad1 == data->NList_First)
691 la = data->pad1 + 1 - data->NList_Visible;
692 else
693 la = data->NList_First;
694 break;
695 case MUIV_NList_Active_PageDown :
696 case MUIV_NList_Active_UntilPageDown :
697 if (data->pad1 == data->NList_First - 1 + data->NList_Visible)
698 la = data->pad1 - 1 + data->NList_Visible;
699 else
700 la = data->NList_First - 1 + data->NList_Visible;
701 break;
702 }
703 }
704 }
705
706 if (la < 0)
707 la = 0;
708 else if (la >= data->NList_Entries)
709 la = data->NList_Entries - 1;
710
711 data->pad1 = la;
712
713 // if the SetActive_Jump_Center flag is active we make sure
714 // the new active entry will be centered
715 if(isFlagSet(flags, MUIV_NList_SetActive_Jump_Center))
716 la = MUIV_NList_Jump_Active_Center;
717
718 // make sure the entry is visible
719 if(NL_List_Jump(data, la) == TRUE)
720 {
721 DO_NOTIFY(NTF_First);
722 REDRAW;
723
724 changed = TRUE;
725 }
726
727 RETURN(changed);
728 return changed;
729 }
730
731 if (!tag)
732 tag = &ltag;
733
734 if(data->NList_Entries > 0)
735 {
736 ent = -2;
737
738 switch (la)
739 {
740 case MUIV_NList_Active_Top :
741 la = 0;
742 break;
743 case MUIV_NList_Active_Bottom :
744 la = data->NList_Entries - 1;
745 break;
746 case MUIV_NList_Active_Up :
747 if (data->NList_Active != MUIV_NList_Active_Off)
748 la = data->NList_Active - 1;
749 else
750 la = data->NList_First - 1 + data->NList_Visible;
751 if (la < 0)
752 la = 0;
753 if (la >= data->NList_Entries)
754 la = data->NList_Entries - 1;
755 break;
756 case MUIV_NList_Active_Down :
757 if (data->NList_Active != MUIV_NList_Active_Off)
758 la = data->NList_Active + 1;
759 else
760 la = data->NList_First;
761 if (la >= data->NList_Entries)
762 la = data->NList_Entries - 1;
763 break;
764 case MUIV_NList_Active_PageUp :
765 if (data->NList_Active == data->NList_First)
766 la = data->NList_Active + 1 - data->NList_Visible;
767 else
768 la = data->NList_First;
769 if (la < 0)
770 la = 0;
771 break;
772 case MUIV_NList_Active_PageDown :
773 if (data->NList_Active == data->NList_First - 1 + data->NList_Visible)
774 la = data->NList_Active - 1 + data->NList_Visible;
775 else
776 la = data->NList_First - 1 + data->NList_Visible;
777 if (la >= data->NList_Entries)
778 la = data->NList_Entries - 1;
779 break;
780 case MUIV_NList_Active_UntilPageUp :
781 if (data->NList_Active == data->NList_First)
782 la = data->NList_Active + 1 - data->NList_Visible;
783 else
784 la = data->NList_First;
785 if (la < 0)
786 la = 0;
787 ent = data->NList_Active;
788 break;
789 case MUIV_NList_Active_UntilPageDown :
790 if (data->NList_Active == data->NList_First - 1 + data->NList_Visible)
791 la = data->NList_Active - 1 + data->NList_Visible;
792 else
793 la = data->NList_First - 1 + data->NList_Visible;
794 if (la >= data->NList_Entries)
795 la = data->NList_Entries - 1;
796 ent = data->NList_Active;
797 break;
798 case MUIV_NList_Active_UntilTop :
799 la = 0;
800 ent = data->NList_Active;
801 break;
802 case MUIV_NList_Active_UntilBottom :
803 la = data->NList_Entries - 1;
804 ent = data->NList_Active;
805 break;
806 case MUIV_NList_Active_Off :
807 la = MUIV_NList_Active_Off;
808 break;
809 }
810
811 if ((la != data->NList_Active) || (acceptsame &&
812 !((newactsel == MUIV_NList_Select_On) && (la >= 0) && (la < data->NList_Entries) &&
813 (data->EntriesArray[la]->Select != TE_Select_None))))
814 {
815 if ((la >= 0) && (la < data->NList_Entries))
816 {
817 if ((data->NList_MultiSelect == MUIV_NList_MultiSelect_None) && (la != data->NList_Active))
818 {
819 DO_NOTIFY(NTF_Select | NTF_LV_Select);
820
821 if ((data->NList_Active >= 0) && (data->NList_Active < data->NList_Entries))
822 SELECT2(data->NList_Active,TE_Select_None);
823 }
824
825 if ((data->NList_MultiSelect != MUIV_NList_MultiSelect_None) && (newactsel == MUIV_NList_Select_List))
826 {
827 DO_NOTIFY(NTF_Select | NTF_LV_Select);
828 if((data->NList_Active >= 0) && (data->NList_Active < data->NList_Entries))
829 {
830 if (data->EntriesArray[data->NList_Active]->Select != TE_Select_None)
831 SELECT2(data->NList_Active,TE_Select_None);
832 else
833 SELECT(data->NList_Active,TE_Select_Line);
834
835 data->lastselected = data->NList_Active;
836 data->lastactived = data->NList_Active;
837 }
838 }
839
840 if((ent < -1) || (data->multiselect == MUIV_NList_MultiSelect_None))
841 ent = la;
842
843 if (ent < 0)
844 ent = 0;
845 else if (ent >= data->NList_Entries)
846 ent = data->NList_Entries - 1;
847
848 set_Active(la);
849 changed = TRUE;
850
851 if (ent < la)
852 NL_SegChanged(data,ent,la-1);
853 else if (ent > la)
854 NL_SegChanged(data,la+1,ent);
855
856 do
857 {
858 if (ent < la)
859 ent++;
860 else if (ent > la)
861 ent--;
862 switch (newactsel)
863 { case MUIV_NList_Select_Off :
864 SELECT2(ent,TE_Select_None);
865 data->lastselected = ent;
866 data->lastactived = ent;
867 break;
868 case MUIV_NList_Select_On :
869 SELECT(ent,TE_Select_Line);
870 data->lastselected = ent;
871 data->lastactived = ent;
872 break;
873 case MUIV_NList_Select_Toggle :
874 if (data->EntriesArray[ent]->Select != TE_Select_None)
875 { SELECT2(ent,TE_Select_None);
876 }
877 else
878 { SELECT(ent,TE_Select_Line);
879 }
880 data->lastselected = ent;
881 data->lastactived = ent;
882 break;
883
884 case MUIV_NList_Select_List :
885 if (data->NList_MultiSelect != MUIV_NList_MultiSelect_None)
886 { ent = la;
887 if (data->EntriesArray[ent]->Select != TE_Select_None)
888 { SELECT2(ent,TE_Select_None);
889 }
890 else
891 { SELECT(ent,TE_Select_Line);
892 }
893 data->lastselected = ent;
894 data->lastactived = ent;
895 break;
896 }
897
898 default:
899 if (data->NList_MultiSelect == MUIV_NList_MultiSelect_None)
900 { SELECT(ent,TE_Select_Line);
901 data->lastselected = ent;
902 data->lastactived = ent;
903 }
904 break;
905 }
906 } while (ent != la);
907
908 tag->ti_Data = la;
909 data->do_draw_active = TRUE;
910
911 // if the SetActive_Jump_Center flag is active we make sure
912 // the new active entry will be centered
913 if(isFlagSet(flags, MUIV_NList_SetActive_Jump_Center))
914 la = MUIV_NList_Jump_Active_Center;
915
916 // make sure the entry is visible
917 if(NL_List_Jump(data, la) == TRUE)
918 {
919 DO_NOTIFY(NTF_First);
920 }
921
922 // redraw at all means
923 REDRAW;
924 }
925 else if (la == MUIV_NList_Active_Off)
926 {
927 if ((data->NList_MultiSelect == MUIV_NList_MultiSelect_None) && (la != data->NList_Active))
928 {
929 DO_NOTIFY(NTF_Select | NTF_LV_Select);
930 if ((data->NList_Active >= 0) && (data->NList_Active < data->NList_Entries))
931 SELECT2(data->NList_Active,TE_Select_None);
932 }
933
934 set_Active(MUIV_NList_Active_Off);
935 tag->ti_Data = MUIV_NList_Active_Off;
936 REDRAW;
937
938 changed = TRUE;
939 }
940 else
941 tag->ti_Tag = TAG_IGNORE;
942 }
943 else
944 tag->ti_Tag = TAG_IGNORE;
945 }
946 else
947 {
948 set_Active(MUIV_NList_Active_Off);
949 tag->ti_Data = MUIV_NList_Active_Off;
950 if (la >= 0)
951 tag->ti_Tag = TAG_IGNORE;
952 }
953 /* do_notifies(NTF_AllChanges|NTF_MinMax);*/
954
955 RETURN(changed);
956 return changed;
957 }
958
959
960 BOOL NL_List_Horiz_First(struct NLData *data,LONG hf,struct TagItem *tag)
961 {
962 BOOL scrolled = FALSE;
963
964 ENTER();
965
966 if(data->NList_Horiz_First != hf)
967 {
968 struct TagItem ltag;
969 BOOL tagnul = FALSE;
970
971 if(!tag)
972 {
973 tag = &ltag;
974 tagnul = TRUE;
975 }
976
977 switch (hf)
978 {
979 case MUIV_NList_Horiz_First_Start :
980 hf = 0;
981 break;
982
983 case MUIV_NList_Horiz_First_End :
984 {
985 hf = data->NList_Horiz_Entries - data->NList_Horiz_Visible;
986 if(hf < 0)
987 hf = 0;
988 }
989 break;
990
991 case MUIV_NList_Horiz_First_Left :
992 {
993 hf = data->NList_Horiz_First - _font(data->this)->tf_XSize;
994 if (hf < 0)
995 hf = 0;
996 }
997 break;
998
999 case MUIV_NList_Horiz_First_Right :
1000 {
1001 hf = data->NList_Horiz_First + _font(data->this)->tf_XSize;
1002 if(hf > data->NList_Horiz_Entries - data->NList_Horiz_Visible)
1003 hf = data->NList_Horiz_Entries - data->NList_Horiz_Visible;
1004 }
1005 break;
1006
1007 case MUIV_NList_Horiz_First_PageLeft :
1008 {
1009 hf = data->NList_Horiz_First - data->NList_Horiz_Visible / 2;
1010 if (hf < 0)
1011 hf = 0;
1012 }
1013 break;
1014
1015 case MUIV_NList_Horiz_First_PageRight :
1016 {
1017 hf = data->NList_Horiz_First + data->NList_Horiz_Visible / 2;
1018 if (hf > data->NList_Horiz_Entries - data->NList_Horiz_Visible)
1019 hf = data->NList_Horiz_Entries - data->NList_Horiz_Visible;
1020 }
1021 break;
1022
1023 case MUIV_NList_Horiz_First_Left2 :
1024 {
1025 hf = data->NList_Horiz_First - _font(data->this)->tf_XSize*2;
1026 if (hf < 0)
1027 hf = 0;
1028 }
1029 break;
1030
1031 case MUIV_NList_Horiz_First_Right2 :
1032 {
1033 hf = data->NList_Horiz_First + _font(data->this)->tf_XSize*2;
1034 if (hf > data->NList_Horiz_Entries - data->NList_Horiz_Visible)
1035 hf = data->NList_Horiz_Entries - data->NList_Horiz_Visible;
1036 }
1037 break;
1038
1039 case MUIV_NList_Horiz_First_Left4 :
1040 {
1041 hf = data->NList_Horiz_First - _font(data->this)->tf_XSize*4;
1042 if (hf < 0)
1043 hf = 0;
1044 }
1045 break;
1046
1047 case MUIV_NList_Horiz_First_Right4 :
1048 {
1049 hf = data->NList_Horiz_First + _font(data->this)->tf_XSize*4;
1050 if (hf > data->NList_Horiz_Entries - data->NList_Horiz_Visible)
1051 hf = data->NList_Horiz_Entries - data->NList_Horiz_Visible;
1052 }
1053 break;
1054 }
1055
1056 if(data->NList_Horiz_First != hf)
1057 {
1058 if((hf >= 0) && (hf < data->NList_Horiz_Entries))
1059 {
1060 if(hf > data->NList_Horiz_Entries - data->NList_Horiz_Visible)
1061 hf = data->NList_Horiz_Entries - data->NList_Horiz_Visible;
1062
1063 data->NList_Horiz_First = hf;
1064 REDRAW;
1065
1066 tag->ti_Data = hf;
1067 if (tagnul /*&& data->Notify_HSB*/)
1068 notdoset(data->this,MUIA_NList_Horiz_First,hf);
1069
1070 scrolled = TRUE;
1071 }
1072 else
1073 tag->ti_Tag = TAG_IGNORE;
1074 }
1075 else
1076 tag->ti_Tag = TAG_IGNORE;
1077 }
1078
1079 RETURN(scrolled);
1080 return scrolled;
1081 }
1082
1083
1084 ULONG NL_List_SelectChar(struct NLData *data,LONG pos,LONG seltype,LONG *state)
1085 {
1086 LONG ent,ent2;
1087
1088 if (seltype == MUIV_NList_Select_None)
1089 return (TRUE);
1090
1091 if (data->NList_TypeSelect)
1092 {
1093 if (seltype == MUIV_NList_Select_Ask)
1094 { LONG first = data->sel_pt[data->min_sel].ent;
1095 LONG last = data->sel_pt[data->max_sel].ent;
1096 if ((data->sel_pt[data->max_sel].column == 0) && (data->sel_pt[data->max_sel].xoffset == PMIN))
1097 last--;
1098 if (state)
1099 *state = (LONG) (last - first + 1);
1100 }
1101 else if (seltype == MUIV_NList_Select_Off)
1102 UnSelectCharSel(data,TRUE);
1103 else if ((seltype == MUIV_NList_Select_On) && (data->NList_Entries > 0))
1104 {
1105 UnSelectCharSel(data,FALSE);
1106 if (pos == MUIV_NList_Select_All)
1107 { ent = 0;
1108 ent2 = data->NList_Entries;
1109 }
1110 else
1111 { if (pos == MUIV_NList_Select_Active)
1112 ent = data->NList_Active;
1113 else
1114 ent = pos;
1115 if (ent < 0)
1116 ent = 0;
1117 else if (ent >= data->NList_Entries)
1118 ent = data->NList_Entries - 1;
1119 ent2 = ent + 1;
1120 }
1121 data->sel_pt[0].column = 0;
1122 data->sel_pt[0].xoffset = PMIN;
1123 data->sel_pt[0].colpos = -1;
1124 data->sel_pt[0].ent = ent;
1125 data->sel_pt[1].column = 0;
1126 data->sel_pt[1].xoffset = PMIN;
1127 data->sel_pt[1].colpos = -1;
1128 data->sel_pt[1].ent = ent2;
1129 data->min_sel = 0;
1130 data->max_sel = 1;
1131 NL_SegChanged(data,ent,ent2);
1132 data->minx_change_entry = ent;
1133 data->minx_change_offset = PMIN;
1134 data->maxx_change_entry = ent2;
1135 data->maxx_change_offset = PMIN;
1136 REDRAW;
1137 }
1138 return (TRUE);
1139 }
1140
1141 return(FALSE);
1142 }
1143
1144
1145 ULONG NL_List_Select(struct NLData *data,LONG pos,LONG pos2,LONG seltype,LONG *state)
1146 {
1147 LONG ent,ent2,ent3;
1148 /* DONE_NOTIFY(NTF_Select | NTF_LV_Select);*/
1149 if ((seltype == MUIV_NList_Select_None) || data->NList_TypeSelect || !data->NList_Input)
1150 return (TRUE);
1151 if ((pos == MUIV_NList_Select_All) && data->multiselect && data->NList_Input)
1152 { LONG num = 0;
1153 ent = 0;
1154 switch (seltype)
1155 { case MUIV_NList_Select_Off :
1156 while (ent < data->NList_Entries)
1157 { if ((data->NList_List_Select == MUIV_NList_Select_List) && (ent == data->NList_Active))
1158 { SELECT2_CHGE(ent,TE_Select_Line);
1159 num++;
1160 }
1161 else
1162 { SELECT2_CHGE(ent,TE_Select_None);
1163 }
1164 ent++;
1165 }
1166 if (state)
1167 *state = num;
1168 REDRAW;
1169 break;
1170 case MUIV_NList_Select_On :
1171 while (ent < data->NList_Entries)
1172 { SELECT_CHGE(ent,TE_Select_Line);
1173 num++;
1174 ent++;
1175 }
1176 if (state)
1177 *state = num;
1178 REDRAW;
1179 break;
1180 case MUIV_NList_Select_Toggle :
1181 while (ent < data->NList_Entries)
1182 { if ((data->NList_List_Select == MUIV_NList_Select_List) && (ent == data->NList_Active))
1183 { SELECT2_CHGE(ent,TE_Select_Line);
1184 num++;
1185 }
1186 else if (data->EntriesArray[ent]->Select != TE_Select_None)
1187 { SELECT2_CHGE(ent,TE_Select_None);
1188 }
1189 else
1190 { SELECT_CHGE(ent,TE_Select_Line);
1191 num++;
1192 }
1193 ent++;
1194 }
1195 if (state)
1196 *state = num;
1197 REDRAW;
1198 break;
1199 default : /* MUIV_NList_Select_Ask */
1200 while (ent < data->NList_Entries)
1201 { if (data->EntriesArray[ent]->Select != TE_Select_None)
1202 num++;
1203 ent++;
1204 }
1205 if (state)
1206 *state = num;
1207 break;
1208 }
1209 data->lastselected = MUIV_NList_Active_Off;
1210 /* do_notifies(NTF_AllChanges|NTF_MinMax);*/
1211 return (TRUE);
1212 }
1213 else if ((data->multiselect || (seltype == MUIV_NList_Select_Ask)) && data->NList_Input)
1214 { if (pos == MUIV_NList_Select_Active)
1215 ent = data->NList_Active;
1216 else
1217 ent = pos;
1218 if ((ent < 0) || (ent >= data->NList_Entries))
1219 return (FALSE);
1220
1221 if (seltype != MUIV_NList_Select_Ask)
1222 data->lastselected = ent;
1223 /*
1224 * if ((data->NList_List_Select == MUIV_NList_Select_List) && (ent == data->NList_Active) && (seltype == MUIV_NList_Select_Ask))
1225 * seltype = MUIV_NList_Select_On;
1226 */
1227 ent2 = pos2;
1228 if ((ent2 < 0) || (ent2 >= data->NList_Entries))
1229 ent2 = ent;
1230 if (ent2 < ent)
1231 { ent3 = ent;
1232 ent = ent2 + 1;
1233 ent2 = ent3 + 1;
1234 }
1235 else if (ent2 == ent)
1236 ent2++;
1237 while (ent < ent2)
1238 { switch (seltype)
1239 { case MUIV_NList_Select_Off :
1240 if (state) *state = MUIV_NList_Select_Off;
1241 SELECT2_CHGE(ent,TE_Select_None);
1242 break;
1243 case MUIV_NList_Select_On :
1244 if (state) *state = MUIV_NList_Select_On;
1245 SELECT_CHGE(ent,TE_Select_Line);
1246 break;
1247 case MUIV_NList_Select_Toggle :
1248 if (data->EntriesArray[ent]->Select == TE_Select_None)
1249 { if (state) *state = MUIV_NList_Select_On;
1250 SELECT_CHGE(ent,TE_Select_Line);
1251 }
1252 else
1253 { if (state) *state = MUIV_NList_Select_Off;
1254 SELECT2_CHGE(ent,TE_Select_None);
1255 }
1256 break;
1257 default : /* MUIV_NList_Select_Ask */
1258 if (data->EntriesArray[ent]->Select != TE_Select_None)
1259 { if (state) *state = MUIV_NList_Select_On; }
1260 else
1261 { if (state) *state = MUIV_NList_Select_Off; }
1262 break;
1263 }
1264 ent++;
1265 }
1266 if (ASKED_NOTIFY(NTF_Select | NTF_LV_Select))
1267 { REDRAW;
1268 }
1269 /* do_notifies(NTF_AllChanges|NTF_MinMax);*/
1270 return (TRUE);
1271 }
1272 return (FALSE);
1273 }
1274
1275
1276 ULONG NL_List_TestPos(struct NLData *data,LONG x,LONG y,struct MUI_NList_TestPos_Result *res)
1277 {
1278 if ((x == MUI_MAXMAX) && (y == MUI_MAXMAX))
1279 {
1280 x = data->click_x;
1281 y = data->click_y;
1282 }
1283 else if ((x == MUI_MAXMAX) && (y == 0))
1284 {
1285 x = data->mouse_x;
1286 y = data->mouse_y;
1287 }
1288 if (res)
1289 {
1290 WORD ly = (y - data->vpos);
1291 WORD lyl = ly / data->vinc;
1292 WORD lx = (x - data->hpos);
1293 res->entry = -1;
1294 res->column = -1;
1295 res->flags = 0;
1296 res->xoffset = 0;
1297 res->yoffset = 0;
1298 res->preparse = 0;
1299 if (res->char_number != -2)
1300 res->char_number = -1;
1301 res->char_xoffset = 0;
1302 if ((lx >= 0) && (lx < data->NList_Horiz_Visible) &&
1303 (ly >= 0) && (lyl < data->NList_Visible))
1304 { LONG line = lyl + data->NList_First;
1305 if (!data->NList_Title && (ly < data->vinc/2))
1306 res->flags |= MUI_NLPR_ONTOP;
1307 lx += data->NList_Horiz_First;
1308 if ((line >= 0) && ((line < data->NList_First + data->NList_Visible) || (line < data->NList_Entries)))
1309 { if (data->cols)
1310 { res->column = 1;
1311 while (res->column < data->numcols)
1312 { if (data->cols[res->column].c->minx > lx)
1313 break;
1314 res->column++;
1315 }
1316 res->column--;
1317 if ((res->column == data->numcols-1) && (lx > data->cols[res->column].c->maxx+data->cols[res->column].c->delta))
1318 res->column = -1;
1319 else
1320 {
1321 if ((lx > data->cols[res->column].c->maxx-2) && (res->column < data->numcols-1))
1322 res->flags |= MUI_NLPR_BAR;
1323 else if ((res->column == data->numcols-1) && IS_BAR(res->column,data->cols[res->column].c) &&
1324 (lx > data->cols[res->column].c->maxx-4) && (lx <= data->cols[res->column].c->maxx+data->cols[res->column].c->delta))
1325 res->flags |= MUI_NLPR_BAR;
1326 else if ((res->column > 0) && (res->column == data->numcols-1) &&
1327 (data->NList_Horiz_First + data->NList_Horiz_Visible >= data->NList_Horiz_Entries) &&
1328 (x >= data->mright - 2) && (res->flags & MUI_NLPR_ONTOP))
1329 res->flags |= MUI_NLPR_BAR;
1330 lx -= data->cols[res->column].c->minx;
1331 }
1332 }
1333 else
1334 res->column = -1;
1335 }
1336 if ((res->column >= 0) && (line >= 0) && (line < data->NList_Entries))
1337 { res->entry = line;
1338 res->xoffset = lx;
1339 res->yoffset = ly - ((lyl * data->vinc) + (data->vinc / 2));
1340 if (res->char_number != -2)
1341 FindCharInColumn(data,line,res->column,lx,&res->char_xoffset,&res->char_number);
1342 if (res->char_number < -PREPARSE_OFFSET_ENTRY)
1343 { res->char_number += PREPARSE_OFFSET_COL;
1344 res->preparse = 2;
1345 }
1346 else if (res->char_number < -1)
1347 { res->char_number += PREPARSE_OFFSET_ENTRY;
1348 res->preparse = 1;
1349 }
1350 }
1351 else
1352 { if (line < 0)
1353 res->flags |= MUI_NLPR_ABOVE;
1354 if (line >= data->NList_Entries)
1355 res->flags |= MUI_NLPR_BELOW;
1356 }
1357 }
1358 else if (data->NList_Title && (lx >= 0) && (lx < data->NList_Horiz_Visible) &&
1359 (ly < 0) && (y >= data->vdtitlepos))
1360 { res->flags = MUI_NLPR_ABOVE | MUI_NLPR_TITLE | MUI_NLPR_ONTOP;
1361 lx += data->NList_Horiz_First;
1362 if (data->cols)
1363 { res->column = 1;
1364 while (res->column < data->numcols)
1365 { if (data->cols[res->column].c->minx > lx)
1366 break;
1367 res->column++;
1368 }
1369 res->column--;
1370 if ((res->column == data->numcols-1) && (lx > data->cols[res->column].c->maxx+data->cols[res->column].c->delta))
1371 res->column = -1;
1372 else
1373 {
1374 if ((lx > data->cols[res->column].c->maxx-2) && (res->column < data->numcols-1))
1375 res->flags |= MUI_NLPR_BAR;
1376 else if ((res->column == data->numcols-1) && IS_BAR(res->column,data->cols[res->column].c) &&
1377 (lx > data->cols[res->column].c->maxx-4) && (lx <= data->cols[res->column].c->maxx+data->cols[res->column].c->delta))
1378 res->flags |= MUI_NLPR_BAR;
1379 else if ((res->column > 0) && (res->column == data->numcols-1) &&
1380 (data->NList_Horiz_First + data->NList_Horiz_Visible >= data->NList_Horiz_Entries) &&
1381 (x >= data->mright - 2))
1382 res->flags |= MUI_NLPR_BAR;
1383 lx -= data->cols[res->column].c->minx;
1384 }
1385 }
1386 else
1387 res->column = -1;
1388 res->xoffset = lx;
1389 res->yoffset = y - ((data->vdtitlepos + data->vpos) / 2);
1390 }
1391 else
1392 { if (lx < 0)
1393 res->flags |= MUI_NLPR_LEFT;
1394 else if (lx >= data->NList_Horiz_Visible)
1395 res->flags |= MUI_NLPR_RIGHT;
1396 if (ly < 0)
1397 res->flags |= MUI_NLPR_ABOVE;
1398 else if (lyl >= data->NList_Visible)
1399 res->flags |= MUI_NLPR_BELOW;
1400 }
1401 return (TRUE);
1402 }
1403 return (FALSE);
1404 }
1405
1406
1407 ULONG NL_List_TestPosOld(struct NLData *data,LONG x,LONG y,struct MUI_List_TestPos_Result *res)
1408 {
1409 if (res)
1410 {
1411 WORD ly = (y - data->vpos);
1412 WORD lyl = ly / data->vinc;
1413 WORD lx = (x - data->hpos);
1414 res->entry = -1;
1415 res->column = -1;
1416 res->flags = 0;
1417 res->xoffset = 0;
1418 res->yoffset = 0;
1419 if ((lx >= 0) && (lx < data->NList_Horiz_Visible) &&
1420 (ly >= 0) && (lyl < data->NList_Visible))
1421 { LONG line = lyl + data->NList_First;
1422 if ((line >= 0) && (line < data->NList_Entries))
1423 { res->entry = line;
1424 lx += data->NList_Horiz_First;
1425 if (data->cols)
1426 { res->column = 1;
1427 while (res->column < data->numcols)
1428 { if (data->cols[res->column].c->minx > lx)
1429 break;
1430 res->column++;
1431 }
1432 res->column--;
1433 lx -= data->cols[res->column].c->minx;
1434 }
1435 else
1436 res->column = 0;
1437 res->xoffset = lx;
1438 res->yoffset = ly - ((lyl * data->vinc) + (data->vinc / 2));
1439 }
1440 else
1441 { if (line < 0)
1442 res->flags |= MUI_NLPR_ABOVE;
1443 if (line >= data->NList_Entries)
1444 res->flags |= MUI_NLPR_BELOW;
1445 }
1446 }
1447 else
1448 { if (lx < 0)
1449 res->flags |= MUI_NLPR_LEFT;
1450 else if (lx >= data->NList_Horiz_Visible)
1451 res->flags |= MUI_NLPR_RIGHT;
1452 if (ly < 0)
1453 res->flags |= MUI_NLPR_ABOVE;
1454 else if (lyl >= data->NList_Visible)
1455 res->flags |= MUI_NLPR_BELOW;
1456 }
1457 return (TRUE);
1458 }
1459 return (FALSE);
1460 }
1461
1462
1463 IPTR mNL_List_GetEntry(struct IClass *cl,Object *obj,struct MUIP_NList_GetEntry *msg)
1464 {
1465 struct NLData *data = INST_DATA(cl,obj);
1466 LONG ent = msg->pos;
1467 APTR entry = NULL;
1468
1469 if(ent == MUIV_NList_GetEntry_Active)
1470 ent = data->NList_Active;
1471
1472 if(ent >= 0 && ent < data->NList_Entries && isFlagSet(data->EntriesArray[ent]->Wrap, TE_Wrap_TmpLine))
1473 ent -= data->EntriesArray[ent]->dnum;
1474
1475 if(ent >= 0 && ent < data->NList_Entries)
1476 entry = data->EntriesArray[ent]->Entry;
1477
1478 // return the entry in the message if we got a valid pointer to store it
1479 if(msg->entry != NULL)
1480 *msg->entry = entry;
1481
1482 // return the entry as a normal return value in any case
1483 return (IPTR)entry;
1484 }
1485
1486
1487 IPTR mNL_List_GetEntryInfo(struct IClass *cl,Object *obj,struct MUIP_NList_GetEntryInfo *msg)
1488 {
1489 struct NLData *data = INST_DATA(cl,obj);
1490 LONG line,ent2,ent = msg->res->pos;
1491 /*DoSuperMethodA(cl,obj,(Msg) msg);*/
1492
1493 if (ent == MUIV_NList_GetEntryInfo_Line)
1494 { ent = line = 0;
1495 ent2 = msg->res->line;
1496 while (ent < data->NList_Entries)
1497 { if (!(data->EntriesArray[ent]->Wrap & TE_Wrap_TmpLine))
1498 { if (line == ent2)
1499 break;
1500 line++;
1501 }
1502 ent++;
1503 }
1504 if ((ent >= 0) && (ent < data->NList_Entries))
1505 { msg->res->entry_pos = ent;
1506 msg->res->entry = data->EntriesArray[ent]->Entry;
1507 msg->res->wrapcol = (LONG) data->EntriesArray[ent]->Wrap;
1508 msg->res->charpos = (LONG) data->EntriesArray[ent]->pos;
1509 msg->res->charlen = (LONG) data->EntriesArray[ent]->len;
1510 }
1511 else
1512 { msg->res->line = -1;
1513 msg->res->entry_pos = -1;
1514 msg->res->entry = NULL;
1515 msg->res->wrapcol = (LONG) 0;
1516 msg->res->charpos = (LONG) 0;
1517 msg->res->charlen = (LONG) 0;
1518 }
1519 }
1520 else
1521 { if (ent == MUIV_NList_GetEntry_Active)
1522 ent = data->NList_Active;
1523
1524 if (ent == -3 ) /* Magic number to get the last inserted entry <aphaso> */
1525 {
1526 if ( data->NList_LastInserted == -1 )
1527 ent = (data->NList_Entries - 1);
1528 else
1529 ent = data->NList_LastInserted;
1530 }
1531
1532 ent2 = ent;
1533 if ((ent >= 0) && (ent < data->NList_Entries) && (data->EntriesArray[ent]->Wrap & TE_Wrap_TmpLine))
1534 ent -= data->EntriesArray[ent]->dnum;
1535 if ((ent >= 0) && (ent < data->NList_Entries))
1536 {
1537 if (msg->res->line == -2) /* Magic number to receive the NList entry pointer, not the supplied! <aphaso> */
1538 {
1539 msg->res->entry_pos = ent;
1540 msg->res->entry = data->EntriesArray[ent];
1541 }
1542 else
1543 {
1544 msg->res->entry_pos = ent;
1545 msg->res->entry = data->EntriesArray[ent]->Entry;
1546 msg->res->wrapcol = (LONG) data->EntriesArray[ent2]->Wrap;
1547 msg->res->charpos = (LONG) data->EntriesArray[ent2]->pos;
1548 msg->res->charlen = (LONG) data->EntriesArray[ent2]->len;
1549 ent2 = line = 0;
1550 while (ent2 < ent)
1551 { if (!(data->EntriesArray[ent2]->Wrap & TE_Wrap_TmpLine))
1552 line++;
1553 ent2++;
1554 }
1555 msg->res->line = line;
1556 }
1557 }
1558 else
1559 { msg->res->line = -1;
1560 msg->res->entry_pos = -1;
1561 msg->res->entry = NULL;
1562 msg->res->wrapcol = (LONG) 0;
1563 msg->res->charpos = (LONG) 0;
1564 msg->res->charlen = (LONG) 0;
1565 }
1566 }
1567 return (TRUE);
1568 }
1569
1570 static BOOL NL_List_Jump(struct NLData *data, LONG pos)
1571 {
1572 BOOL result = FALSE;
1573 ENTER();
1574
1575 switch(pos)
1576 {
1577 case MUIV_NList_Jump_Top:
1578 {
1579 pos = 0;
1580 }
1581 break;
1582
1583 case MUIV_NList_Jump_Bottom:
1584 {
1585 pos = data->NList_Entries - 1;
1586 }
1587 break;
1588
1589 case MUIV_NList_Jump_Active:
1590 {
1591 pos = data->NList_Active;
1592 }
1593 break;
1594
1595 case MUIV_NList_Jump_Up:
1596 {
1597 pos = data->NList_First - 1;
1598 }
1599 break;
1600
1601 case MUIV_NList_Jump_Down:
1602 {
1603 pos = data->NList_First + data->NList_Visible;
1604 }
1605 break;
1606
1607 case MUIV_NList_Jump_Active_Center:
1608 {
1609 // center the item in the visible area
1610 LONG first = data->NList_Active - data->NList_Visible/2;
1611
1612 // make sure that the last item is displayed in the last line
1613 while(first + data->NList_Visible > data->NList_Entries)
1614 first--;
1615
1616 if(first < 0)
1617 first = 0;
1618
1619 data->NList_First = first;
1620
1621 result = TRUE;
1622 pos = -1;
1623 }
1624 break;
1625 }
1626
1627 if(pos >= 0 && pos < data->NList_Entries)
1628 {
1629 // old style jump, just make the requested item visible
1630 if(pos < data->NList_First)
1631 {
1632 data->NList_First = pos;
1633
1634 result = TRUE;
1635 }
1636 else if(pos >= data->NList_First + data->NList_Visible)
1637 {
1638 data->NList_First = pos - data->NList_Visible + 1;
1639
1640 // make sure that the last item is displayed in the last line
1641 while(data->NList_First + data->NList_Visible > data->NList_Entries)
1642 data->NList_First--;
1643
1644 if(data->NList_First < 0)
1645 data->NList_First = 0;
1646
1647 result = TRUE;
1648 }
1649 }
1650
1651 RETURN(result);
1652 return result;
1653 }
1654
1655 IPTR mNL_List_Jump(struct IClass *cl, Object *obj, struct MUIP_NList_Jump *msg)
1656 {
1657 struct NLData *data = INST_DATA(cl,obj);
1658
1659 ENTER();
1660
1661 if(NL_List_Jump(data, msg->pos) == TRUE)
1662 {
1663 DO_NOTIFY(NTF_First);
1664 REDRAW;
1665 }
1666
1667 /* do_notifies(NTF_AllChanges|NTF_MinMax);*/
1668
1669 RETURN(TRUE);
1670 return TRUE;
1671 }
1672
1673 IPTR mNL_List_SetActive(struct IClass *cl, Object *obj, struct MUIP_NList_SetActive *msg)
1674 {
1675 BOOL result = FALSE;
1676 struct NLData *data = INST_DATA(cl,obj);
1677 LONG pos = (LONG)(SIPTR)msg->pos;
1678
1679 ENTER();
1680
1681 // check if the user used msg->pos for specifying the entry position (integer)
1682 // or by using the entry address
1683 if(isFlagSet(msg->flags, MUIV_NList_SetActive_Entry))
1684 NL_List_GetPos(data, (APTR)msg->pos, &pos);
1685
1686 result = NL_List_Active(data, pos, NULL, data->NList_List_Select, FALSE, msg->flags);
1687 if(result == TRUE)
1688 {
1689 DO_NOTIFY(NTF_Active | NTF_L_Active);
1690 }
1691
1692 RETURN(result);
1693 return result;
1694 }
1695
1696 IPTR mNL_List_Select(struct IClass *cl,Object *obj,struct MUIP_NList_Select *msg)
1697 {
1698 struct NLData *data = INST_DATA(cl,obj);
1699 /*DoSuperMethodA(cl,obj,(Msg) msg);*/
1700 if (data->NList_TypeSelect)
1701 return (NL_List_SelectChar(data,msg->pos,msg->seltype,msg->state));
1702 else
1703 return (NL_List_Select(data,msg->pos,msg->pos,msg->seltype,msg->state));
1704 return (0);
1705 }
1706
1707
1708 IPTR mNL_List_TestPos(struct IClass *cl,Object *obj,struct MUIP_NList_TestPos *msg)
1709 {
1710 struct NLData *data = INST_DATA(cl,obj);
1711 /*DoSuperMethodA(cl,obj,(Msg) msg);*/
1712 return (NL_List_TestPos(data,msg->x,msg->y,msg->res));
1713 }
1714
1715
1716 IPTR mNL_List_TestPosOld(struct IClass *cl,Object *obj,struct MUIP_List_TestPos *msg)
1717 {
1718 struct NLData *data = INST_DATA(cl,obj);
1719 /*DoSuperMethodA(cl,obj,(Msg) msg);*/
1720 return (NL_List_TestPosOld(data,msg->x,msg->y,msg->res));
1721 }
1722
1723
1724 IPTR mNL_List_Redraw(struct IClass *cl,Object *obj,struct MUIP_NList_Redraw *msg)
1725 {
1726 struct NLData *data = INST_DATA(cl,obj);
1727 long ent;
1728
1729 ENTER();
1730
1731 /*DoSuperMethodA(cl,obj,(Msg) msg);*/
1732 ent = msg->pos;
1733 data->display_ptr = NULL;
1734 data->parse_column = -1;
1735
1736 /*D(bug("%lx|List_Redraw1 pos=%ld Q=%ld D=%ld S=%ld\n",obj,msg->pos,data->NList_Quiet,data->DRAW,data->SETUP));*/
1737
1738 if(data->DRAW > 1)
1739 {
1740 // defer the redraw process
1741 /*D(bug("%lx|List_Redraw no! %ld %ld (push it)\n",obj,msg->pos,data->DRAW));*/
1742 DoMethod(_app(obj), MUIM_Application_PushMethod, obj, 2, msg->MethodID, msg->pos);
1743 }
1744 else
1745 {
1746 if(msg->MethodID == MUIM_List_Redraw && msg->pos == MUIV_NList_Redraw_All)
1747 msg->pos = -6;
1748
1749 switch(msg->pos)
1750 {
1751 case -6:
1752 {
1753 if(data->DRAW)
1754 {
1755 NL_SetColsAdd(data,-2,TRUE);
1756 DoMethod(_app(obj), MUIM_Application_PushMethod, obj, 2, MUIM_NList_Redraw, MUIV_NList_Redraw_All);
1757 }
1758 }
1759 break;
1760
1761 case MUIV_NList_Redraw_All:
1762 {
1763 // redraw all entries
1764 if(data->DRAW)
1765 {
1766 NL_SetColsAdd(data,-2,TRUE);
1767 for(ent = 0; ent < data->NList_Entries; ent++)
1768 data->EntriesArray[ent]->PixLen = -1;
1769 }
1770 data->Title_PixLen = -1;
1771 data->do_draw_title = TRUE;
1772 data->do_parse = TRUE;
1773 data->do_setcols = TRUE;
1774 data->do_updatesb = TRUE;
1775 data->force_wwrap = TRUE;
1776 REDRAW_ALL;
1777 }
1778 break;
1779
1780 case MUIV_NList_Redraw_VisibleCols:
1781 {
1782 // redraw visible columns only
1783 if(data->DRAW)
1784 NL_SetColsAdd(data, -3, TRUE);
1785 }
1786 break;
1787
1788 case MUIV_NList_Redraw_Selected:
1789 {
1790 // redraw selected entries only
1791 if(data->DRAW)
1792 {
1793 BOOL doDraw = FALSE;
1794
1795 if(data->NList_TypeSelect == MUIV_NList_TypeSelect_Line)
1796 {
1797 for(ent=0; ent < data->NList_Entries; ent++)
1798 {
1799 // mark the selected entries as "to be redrawn"
1800 if(data->EntriesArray[ent]->Select != TE_Select_None)
1801 {
1802 NL_SetColsAdd(data, ent, TRUE);
1803 data->EntriesArray[ent]->PixLen = -1;
1804 NL_Changed(data, ent);
1805 doDraw = TRUE;
1806 }
1807 }
1808 }
1809 else
1810 {
1811 NL_SegChanged(data,data->sel_pt[data->min_sel].ent,data->sel_pt[data->max_sel].ent);
1812 doDraw = TRUE;
1813 }
1814
1815 if(doDraw == TRUE)
1816 {
1817 // at least one entry must be redrawn
1818 data->display_ptr = NULL;
1819 data->do_draw = TRUE;
1820 REDRAW;
1821 }
1822 }
1823 }
1824 break;
1825
1826 case MUIV_NList_Redraw_Title:
1827 {
1828 // redraw title only
1829 if(data->DRAW)
1830 {
1831 NL_SetColsAdd(data, -1, TRUE);
1832 data->Title_PixLen = -1;
1833 }
1834 data->do_draw_title = TRUE;
1835 data->do_setcols = TRUE;
1836 REDRAW;
1837 }
1838 break;
1839
1840 case MUIV_NList_Redraw_Active:
1841 {
1842 // redraw the active entry only
1843 ent = data->NList_Active;
1844 }
1845 // fall through to the default redraw
1846
1847 default:
1848 {
1849 // redraw a specific entry
1850 if(ent >= 0 && ent < data->NList_Entries)
1851 {
1852 if(data->DRAW)
1853 {
1854 NL_SetColsAdd(data, ent, TRUE);
1855 data->EntriesArray[ent]->PixLen = -1;
1856 }
1857 NL_Changed(data, ent);
1858 REDRAW;
1859 }
1860 }
1861 break;
1862 }
1863
1864 /*D(bug("%lx|List_Redraw2 pos=%ld Q=%ld D=%ld S=%ld\n",obj,msg->pos,data->NList_Quiet,data->DRAW,data->SETUP));*/
1865 }
1866
1867 RETURN(TRUE);
1868 return TRUE;
1869 }
1870
1871
1872 IPTR mNL_List_RedrawEntry(struct IClass *cl,Object *obj,struct MUIP_NList_RedrawEntry *msg)
1873 {
1874 struct NLData *data = INST_DATA(cl,obj);
1875 LONG ent = 0;
1876 BOOL dodraw = FALSE;
1877 if (!msg->entry)
1878 return (FALSE);
1879 while (ent < data->NList_Entries)
1880 { if (data->EntriesArray[ent]->Entry == msg->entry)
1881 { data->EntriesArray[ent]->PixLen = -1;
1882 NL_Changed(data,ent);
1883 dodraw = TRUE;
1884 }
1885 ent++;
1886 }
1887 if (dodraw)
1888 {
1889 /* sba: This enforces redrawing the entry completly */
1890 data->display_ptr = NULL;
1891
1892 data->do_draw = TRUE;
1893 REDRAW;
1894
1895 return (TRUE);
1896 }
1897 return (FALSE);
1898 }
1899
1900
1901 IPTR mNL_List_NextSelected(struct IClass *cl,Object *obj,struct MUIP_NList_NextSelected *msg)
1902 {
1903 struct NLData *data = INST_DATA(cl,obj);
1904 long ent = *msg->pos;
1905 /*DoSuperMethodA(cl,obj,(Msg) msg);*/
1906 if ((ent == MUIV_NList_NextSelected_Start) || (ent < 0))
1907 ent = 0;
1908 else
1909 ent++;
1910 if (data->NList_TypeSelect)
1911 {
1912 if (ent < data->sel_pt[data->min_sel].ent)
1913 ent = data->sel_pt[data->min_sel].ent;
1914 else if (ent > data->sel_pt[data->max_sel].ent)
1915 ent = MUIV_NList_NextSelected_End;
1916 else if ((ent == data->sel_pt[data->max_sel].ent) &&
1917 (data->sel_pt[data->max_sel].column == 0) &&
1918 (data->sel_pt[data->max_sel].xoffset == PMIN))
1919 ent = MUIV_NList_NextSelected_End;
1920 }
1921 else
1922 { while ((ent < data->NList_Entries) && (data->EntriesArray[ent]->Select == TE_Select_None))
1923 ent++;
1924 if (ent >= data->NList_Entries)
1925 ent = MUIV_NList_NextSelected_End;
1926 }
1927 *msg->pos = ent;
1928 return (TRUE);
1929 }
1930
1931
1932 IPTR mNL_List_PrevSelected(struct IClass *cl,Object *obj,struct MUIP_NList_PrevSelected *msg)
1933 {
1934 struct NLData *data = INST_DATA(cl,obj);
1935 long ent = *msg->pos;
1936 /*DoSuperMethodA(cl,obj,(Msg) msg);*/
1937 if ((ent == MUIV_NList_PrevSelected_Start) || (ent < 0) || (ent >= data->NList_Entries))
1938 ent = data->NList_Entries - 1;
1939 else
1940 ent--;
1941 if (data->NList_TypeSelect)
1942 {
1943 if (ent < data->sel_pt[data->min_sel].ent)
1944 ent = MUIV_NList_PrevSelected_End;
1945 else if ((ent == data->sel_pt[data->max_sel].ent) &&
1946 (data->sel_pt[data->max_sel].column == 0) &&
1947 (data->sel_pt[data->max_sel].xoffset == PMIN))
1948 ent = data->sel_pt[data->max_sel].ent - 1;
1949 else if (ent > data->sel_pt[data->max_sel].ent)
1950 ent = data->sel_pt[data->max_sel].ent;
1951 }
1952 else
1953 { while ((ent > 0) && (data->EntriesArray[ent]->Select == TE_Select_None))
1954 ent--;
1955 if (ent < 0)
1956 ent = MUIV_NList_PrevSelected_End;
1957 }
1958 *msg->pos = ent;
1959 return (TRUE);
1960 }
1961
1962
1963 IPTR mNL_List_GetSelectInfo(struct IClass *cl,Object *obj,struct MUIP_NList_GetSelectInfo *msg)
1964 {
1965 struct NLData *data = INST_DATA(cl,obj);
1966 LONG ent;
1967
1968 msg->res->start = 1;
1969 msg->res->vstart = -1;
1970 msg->res->end = 1;
1971 msg->res->vend = -1;
1972 msg->res->num = -1;
1973 msg->res->vnum = 0;
1974 msg->res->start_column = -1;
1975 msg->res->end_column = -1;
1976 msg->res->start_pos= -1;
1977 msg->res->end_pos = -1;
1978
1979 if(data->NList_TypeSelect == MUIV_NList_TypeSelect_Line)
1980 {
1981 ent = 0;
1982
1983 while(ent < data->NList_Entries)
1984 {
1985 if(data->EntriesArray[ent] != NULL && data->EntriesArray[ent]->Select != TE_Select_None)
1986 {
1987 if(msg->res->start == -1)
1988 msg->res->start = ent;
1989
1990 msg->res->end = ent;
1991 msg->res->vnum++;
1992 }
1993 ent++;
1994 }
1995 msg->res->vstart = msg->res->start;
1996 msg->res->vend = msg->res->end;
1997 }
1998 else
1999 {
2000 msg->res->start_column = data->sel_pt[data->min_sel].column;
2001 msg->res->start_pos = data->sel_pt[data->min_sel].colpos;
2002 msg->res->end_column = data->sel_pt[data->max_sel].column;
2003 msg->res->end_pos = data->sel_pt[data->max_sel].colpos;
2004 msg->res->start = data->sel_pt[data->min_sel].ent;
2005 msg->res->end = data->sel_pt[data->max_sel].ent;
2006 msg->res->vstart = msg->res->start;
2007 msg->res->vend = msg->res->end;
2008
2009 if((msg->res->vstart >= 0) && (msg->res->vend >= msg->res->vstart))
2010 msg->res->vnum = msg->res->vend - msg->res->vstart + 1;
2011 }
2012
2013 if (msg->res->start >= 0 && msg->res->start < data->NList_Entries && data->EntriesArray[msg->res->start] != NULL && data->EntriesArray[msg->res->start]->Wrap)
2014 {
2015 if (data->EntriesArray[msg->res->start]->Wrap & TE_Wrap_TmpLine)
2016 msg->res->start -= data->EntriesArray[msg->res->start]->dnum;
2017 }
2018
2019 if (msg->res->end >= 0 && msg->res->end < data->NList_Entries && data->EntriesArray[msg->res->end] != NULL && data->EntriesArray[msg->res->end]->Wrap)
2020 {
2021 if (data->EntriesArray[msg->res->end]->Wrap & TE_Wrap_TmpLine)
2022 msg->res->end -= data->EntriesArray[msg->res->end]->dnum;
2023 }
2024
2025 return (TRUE);
2026 }
2027
2028
2029 IPTR mNL_List_DoMethod(struct IClass *cl,Object *obj,struct MUIP_NList_DoMethod *msg)
2030 {
2031 struct NLData *data = INST_DATA(cl,obj);
2032 LONG ent = msg->pos;
2033 APTR dest = msg->DestObj;
2034
2035 if((msg->FollowParams >= 1) && (msg->FollowParams < 40) &&
2036 ((msg->pos == MUIV_NList_DoMethod_Active) ||
2037 (msg->pos == MUIV_NList_DoMethod_Selected) ||
2038 (msg->pos == MUIV_NList_DoMethod_All) ||
2039 ((msg->pos >= 0) && (msg->pos < data->NList_Entries))))
2040 {
2041 LONG *table1 = (LONG *)&msg->FollowParams;
2042 struct
2043 {
2044 STACKED ULONG MethodID;
2045 SIPTR params[64]; /* MAXIMUM 40 (see docs) <aphaso> */
2046 } newMsg;
2047
2048 if(msg->FollowParams > 63) /* MAXIMUM 40 (see docs) <aphaso> */
2049 {
2050 msg->FollowParams = 63;
2051 newMsg.params[63] = 0;
2052 }
2053
2054 if((IPTR)msg->DestObj == (IPTR)MUIV_NList_DoMethod_Self)
2055 dest = (APTR) obj;
2056 else if((IPTR)msg->DestObj == (IPTR)MUIV_NList_DoMethod_App)
2057 {
2058 if(data->SETUP)
2059 dest = (APTR) _app(obj);
2060 else
2061 dest = NULL;
2062 }
2063 if(msg->pos == MUIV_NList_DoMethod_Active)
2064 ent = MUIV_NList_DoMethod_Active;
2065 else if(msg->pos == MUIV_NList_DoMethod_Selected)
2066 {
2067 if(data->NList_TypeSelect)
2068 ent = data->sel_pt[data->min_sel].ent;
2069 else
2070 {
2071 ent = 0;
2072 while((ent < data->NList_Entries) && (data->EntriesArray[ent]->Select == TE_Select_None))
2073 ent++;
2074 }
2075 }
2076 else if(msg->pos == MUIV_NList_DoMethod_All)
2077 ent = 0;
2078 while((ent >= 0) && (ent < data->NList_Entries))
2079 {
2080 if((IPTR) msg->DestObj == (IPTR)MUIV_NList_DoMethod_Entry)
2081 dest = data->EntriesArray[ent]->Entry;
2082 if(dest)
2083 {
2084 ULONG num;
2085
2086 newMsg.MethodID = table1[1];
2087
2088 for(num = 1;num < msg->FollowParams;num++)
2089 {
2090 switch(table1[num+1])
2091 {
2092 case MUIV_NList_EntryValue:
2093 newMsg.params[num] = (SIPTR)data->EntriesArray[ent]->Entry;
2094 break;
2095 case MUIV_NList_EntryPosValue:
2096 newMsg.params[num] = (LONG)ent;
2097 break;
2098 case MUIV_NList_SelfValue:
2099 newMsg.params[num] = (SIPTR)obj;
2100 break;
2101 case MUIV_NList_AppValue:
2102 if (data->SETUP)
2103 newMsg.params[num] = (SIPTR)_app(obj);
2104 else
2105 newMsg.params[num] = 0;
2106 break;
2107 default:
2108 newMsg.params[num] = table1[num+1];
2109 break;
2110 }
2111 }
2112
2113 DoMethodA(dest, (Msg)((APTR)&newMsg));
2114 }
2115 ent++;
2116 if(msg->pos == MUIV_NList_DoMethod_Selected)
2117 {
2118 if(data->NList_TypeSelect)
2119 {
2120 if((ent > data->sel_pt[data->max_sel].ent) ||
2121 ((ent == data->sel_pt[data->max_sel].ent) &&
2122 (data->sel_pt[data->max_sel].column == 0) &&
2123 (data->sel_pt[data->max_sel].xoffset == PMIN)))
2124 break;
2125 }
2126 else
2127 {
2128 while((ent < data->NList_Entries) && (data->EntriesArray[ent]->Select == TE_Select_None))
2129 ent++;
2130 }
2131 }
2132 else if(msg->pos != MUIV_NList_DoMethod_All)
2133 break;
2134 }
2135 }
2136 return (TRUE);
2137 }
2138
2139 static BOOL NL_List_GetPos(struct NLData *data, APTR entry, LONG *pos)
2140 {
2141 BOOL result = FALSE;
2142
2143 ENTER();
2144
2145 if(entry == NULL)
2146 {
2147 *pos = MUIV_NList_GetPos_End;
2148 result = FALSE;
2149 }
2150 else if((IPTR)entry == (IPTR)-2)
2151 {
2152 if(data->NList_LastInserted == -1)
2153 *pos = (data->NList_Entries - 1);
2154 else
2155 *pos = data->NList_LastInserted;
2156
2157 result = TRUE;
2158 }
2159 else
2160 {
2161 LONG ent = *pos + 1;
2162
2163 while(ent < data->NList_Entries)
2164 {
2165 if(data->EntriesArray[ent]->Entry == entry)
2166 {
2167 *pos = ent;
2168
2169 result = TRUE;
2170 break;
2171 }
2172 ent++;
2173 }
2174
2175 if(result == FALSE)
2176 {
2177 *pos = MUIV_NList_GetPos_End;
2178 result = TRUE;
2179 }
2180 }
2181
2182 RETURN(result);
2183 return result;
2184 }
2185
2186 IPTR mNL_List_GetPos(struct IClass *cl,Object *obj,struct MUIP_NList_GetPos *msg)
2187 {
2188 struct NLData *data = INST_DATA(cl,obj);
2189 BOOL result;
2190
2191 result = NL_List_GetPos(data, msg->entry, msg->pos);
2192
2193 return result;
2194 }
Mirror of AROS' svn.