?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
grub2: bring back build of aros-side grub2 tools
[AROS.git] / workbench / classes / zune / nlist / nlist_mcc / NList_mcc5.c
blobe5c060bce39e48de3db5f47ccb9ff0f03fdc2a34
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-2014 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 <graphics/gfxmacros.h>
27 #undef GetOutlinePen
28
29 #include <dos/dosextens.h>
30
31 #include <libraries/gadtools.h>
32 #include <clib/alib_protos.h>
33 #include <proto/muimaster.h>
34 #include <proto/graphics.h>
35 #include <proto/layers.h>
36 #include <proto/intuition.h>
37
38 #include "private.h"
39
40 #include "NList_func.h"
41 #include "NListview_mcc.h"
42
43 /*#define DO_CLIPBLIT TRUE*/
44
45 static struct NewMenu MenuData[] =
46 {
47 { NM_TITLE, (STRPTR)"Column", 0 ,0 ,0 ,(APTR) MUIV_NList_ContextMenu_Never },
48 { NM_ITEM, (STRPTR)"Default Width: this", 0 ,0 ,0 ,(APTR) MUIV_NList_Menu_DefWidth_This },
49 { NM_ITEM, (STRPTR)"Default Width: all", 0 ,0 ,0 ,(APTR) MUIV_NList_Menu_DefWidth_All },
50 { NM_ITEM, (STRPTR)"Default Order: this", 0 ,0 ,0 ,(APTR) MUIV_NList_Menu_DefOrder_This },
51 { NM_ITEM, (STRPTR)"Default Order: all", 0 ,0 ,0 ,(APTR) MUIV_NList_Menu_DefOrder_All },
52
53 { NM_END,NULL,0,0,0,(APTR)0 },
54 };
55
56
57 void NL_SetCols(struct NLData *data)
58 {
59 if (data->do_setcols)
60 {
61 if (data->cols)
62 {
63 LONG column;
64 LONG weight,weight_all,weight_num,width,width_all,colx,minwidth,maxwidth,mincolwidth,maxcolwidth;
65 BOOL do_colwidthmax = FALSE;
66
67 weight_num = 0;
68 weight_all = 0;
69 width_all = data->mwidth;
70 column = 0;
71 while (column < data->numcols)
72 {
73 if (data->cols[column].c->userwidth >= 0)
74 width_all -= data->cols[column].c->userwidth;
75 else if (data->cols[column].c->width_type == CI_PIX)
76 width_all -= data->cols[column].c->width;
77 else if (data->cols[column].c->width_type == CI_COL)
78 width_all -= data->cols[column].c->width * data->hinc +1;
79 else if (data->cols[column].c->width == -1)
80 { if (!do_colwidthmax)
81 { if (data->cols[column].c->colwidthbiggestptr == -2)
82 {
83 NL_SetColsAdd(data,-2,TRUE);
84 do_colwidthmax = TRUE;
85 }
86 else
87 { data->cols[column].c->colwidthmax = data->cols[column].c->colwidthbiggest;
88 }
89 }
90 width_all -= data->cols[column].c->colwidthmax;
91 }
92 else
93 { weight_all += data->cols[column].c->width;
94 weight_num++;
95 }
96 if (column < data->numcols-1)
97 width_all -= data->cols[column].c->delta;
98 column++;
99 }
100 if (weight_all <= (column*5))
101 weight_all = (column*5)+1;
102 colx = 0;
103 column = 0;
104 while (column < data->numcols)
105 { weight = (LONG) data->cols[column].c->width;
106 if (data->cols[column].c->userwidth >= 0)
107 width = data->cols[column].c->userwidth;
108 else if (data->cols[column].c->width_type == CI_PIX)
109 width = weight;
110 else if (data->cols[column].c->width_type == CI_COL)
111 width = weight * data->hinc;
112 else if (weight == -1)
113 width = data->cols[column].c->colwidthmax;
114 else
115 {
116 width = (weight * width_all) / weight_all;
117 minwidth = (LONG) data->cols[column].c->minwidth;
118 if (minwidth == -1)
119 { if (!do_colwidthmax && (data->cols[column].c->colwidthbiggestptr == -2))
120 {
121 NL_SetColsAdd(data,-2,TRUE);
122 do_colwidthmax = TRUE;
123 }
124 minwidth = data->cols[column].c->colwidthmax;
125 }
126 else
127 minwidth = (minwidth * ((LONG) data->mwidth)) / 100L;
128 maxwidth = (LONG) data->cols[column].c->maxwidth;
129 maxwidth = (maxwidth * ((LONG) data->mwidth)) / 100L;
130
131 mincolwidth = (LONG) data->cols[column].c->mincolwidth;
132 mincolwidth = mincolwidth * ((LONG) data->hinc) + 1;
133 maxcolwidth = (LONG) data->cols[column].c->maxcolwidth;
134 maxcolwidth = maxcolwidth * ((LONG) data->hinc) + 1;
135
136 if (mincolwidth > minwidth)
137 minwidth = mincolwidth;
138 if (data->cols[column].c->minpixwidth > minwidth)
139 minwidth = data->cols[column].c->minpixwidth;
140
141 if (maxcolwidth < maxwidth)
142 maxwidth = maxcolwidth;
143 if (data->cols[column].c->maxpixwidth < maxwidth)
144 maxwidth = data->cols[column].c->maxpixwidth;
145
146 if ((maxwidth > 10) && (width > maxwidth))
147 width = maxwidth;
148
149 if (width < minwidth)
150 width = minwidth;
151
152 if (width < 6)
153 width = 6;
154
155 width_all -= width;
156 weight_all -= data->cols[column].c->width;
157 if (weight_all < 10)
158 weight_all = 10;
159 }
160 if (data->cols[column].c->dx != (WORD) width)
161 { data->do_wwrap = data->force_wwrap = data->do_draw_all = TRUE;
162 data->cols[column].c->dx = (WORD) width;
163 if (data->NList_TypeSelect)
164 UnSelectCharSel(data,FALSE);
165 }
166 if (data->cols[column].c->minx != (WORD) colx)
167 { data->do_wwrap = data->force_wwrap = data->do_draw_all = TRUE;
168 data->cols[column].c->minx = (WORD) colx;
169 if (data->NList_TypeSelect)
170 UnSelectCharSel(data,FALSE);
171 }
172 colx += width;
173 if (data->cols[column].c->maxx != (WORD) colx)
174 { if (column < data->numcols-1)
175 { data->do_wwrap = data->force_wwrap = data->do_draw_all = TRUE;
176 }
177 data->cols[column].c->maxx = (WORD) colx;
178 }
179 if (column < data->numcols-1)
180 colx += data->cols[column].c->delta;
181 else if (data->cols[column].c->userwidth >= 0)
182 { LONG ent = 0;
183 while (data->EntriesArray && (ent < data->NList_Entries))
184 { data->EntriesArray[ent]->PixLen = -1;
185 ent++;
186 }
187 }
188 if (!IS_BAR(column,data->cols[column].c))
189 data->cols[column].c->maxx = MUI_MAXMAX;
190 column++;
191 }
192 }
193 data->do_setcols = FALSE;
194 }
195 }
196
197
198
199 LONG NL_DoNotifies(struct NLData *data,LONG which)
200 {
201 if (data->NList_Quiet || data->NList_Disabled)
202 return (TRUE);
203
204 /* notify ButtonClick */
205 if(NEED_NOTIFY(NTF_ButtonClick) & which)
206 {
207 DONE_NOTIFY(NTF_ButtonClick);
208 notdoset(data->this,MUIA_NList_ButtonClick,data->NList_ButtonClick);
209 }
210
211 /* notify TitleClick */
212 if(NEED_NOTIFY(NTF_TitleClick) & which)
213 {
214 DONE_NOTIFY(NTF_TitleClick);
215 notdoset(data->this,MUIA_NList_TitleClick,data->TitleClick);
216 }
217
218 /* notify TitleClick2 */
219 if(NEED_NOTIFY(NTF_TitleClick2) & which)
220 {
221 DONE_NOTIFY(NTF_TitleClick2);
222 notdoset(data->this,MUIA_NList_TitleClick2,data->TitleClick2);
223 }
224
225 /* notify EntryClick */
226 if(NEED_NOTIFY(NTF_EntryClick) & which)
227 {
228 DONE_NOTIFY(NTF_EntryClick);
229 notdoset(data->this,MUIA_NList_EntryClick,data->click_line);
230 }
231
232 /* notify Doubleclick */
233 if(NEED_NOTIFY(NTF_Doubleclick) & which)
234 {
235 DONE_NOTIFY(NTF_Doubleclick);
236 notdoset(data->this,MUIA_NList_DoubleClick,data->click_line);
237 }
238
239 if(NEED_NOTIFY(NTF_LV_Doubleclick) & which)
240 {
241 DONE_NOTIFY(NTF_LV_Doubleclick);
242 if(data->listviewobj != NULL)
243 DoMethod(data->listviewobj, MUIM_Set, MUIA_Listview_DoubleClick, (LONG)TRUE);
244 else
245 set(data->this,MUIA_Listview_DoubleClick,(LONG) TRUE);
246 }
247
248 /* notify Multiclick */
249 if(NEED_NOTIFY(NTF_Multiclick) & which)
250 {
251 DONE_NOTIFY(NTF_Multiclick);
252 notdoset(data->this,MUIA_NList_MultiClick,data->multiclick + 1);
253 }
254
255 /* notify Multiclick */
256 if(NEED_NOTIFY(NTF_MulticlickAlone) & which)
257 {
258 DONE_NOTIFY(NTF_MulticlickAlone);
259 if (data->multiclickalone > 0)
260 data->multiclickalone = -data->multiclickalone;
261 notdoset(data->this,MUIA_NList_MultiClickAlone,-data->multiclickalone);
262 }
263
264 /* notify_Active */
265 if(NEED_NOTIFY(NTF_Active) & which)
266 {
267 DONE_NOTIFY(NTF_Active);
268 NOTIFY_START(NTF_Active);
269 notdoset(data->this,MUIA_NList_Active,data->NList_Active);
270 NOTIFY_END(NTF_Active);
271 }
272 if(NEED_NOTIFY(NTF_L_Active) & which)
273 {
274 DONE_NOTIFY(NTF_L_Active);
275 NOTIFY_START(NTF_L_Active);
276 notdoset(data->this,MUIA_List_Active,data->NList_Active);
277 NOTIFY_END(NTF_L_Active);
278 }
279
280 /* notify_Select */
281 if(NEED_NOTIFY(NTF_Select) & which)
282 {
283 DONE_NOTIFY(NTF_Select);
284 set(data->this,MUIA_NList_SelectChange,(LONG) TRUE);
285 }
286
287 if(NEED_NOTIFY(NTF_LV_Select) & which)
288 {
289 DONE_NOTIFY(NTF_LV_Select);
290 if(data->listviewobj != NULL)
291 DoMethod(data->listviewobj, MUIM_Set, MUIA_Listview_SelectChange, (LONG)TRUE);
292 else
293 set(data->this,MUIA_Listview_SelectChange,(LONG) TRUE);
294 }
295
296 /* notify first */
297 if(NEED_NOTIFY(NTF_First) & which)
298 {
299 DONE_NOTIFY(NTF_First);
300 notdoset(data->this,MUIA_NList_First,data->NList_First);
301 }
302
303 /* notify entries */
304 if(NEED_NOTIFY(NTF_Entries) & which)
305 {
306 DONE_NOTIFY(NTF_Entries);
307 notdoset(data->this,MUIA_NList_Entries,data->NList_Entries);
308 notdoset(data->this,MUIA_List_Entries,data->NList_Entries);
309 }
310
311 /* notify LineHeight */
312 if(NEED_NOTIFY(NTF_LineHeight) & which)
313 {
314 DONE_NOTIFY(NTF_LineHeight);
315 notdoset(data->this,MUIA_NList_LineHeight,data->vinc);
316 }
317
318 /* notify NTF_DragSortInsert */
319 if(NEED_NOTIFY(NTF_DragSortInsert) & which)
320 {
321 DONE_NOTIFY(NTF_Insert|NTF_DragSortInsert);
322 notdoset(data->this,MUIA_NList_DragSortInsert,data->vinc);
323 }
324
325 /* notify Insert */
326 if(NEED_NOTIFY(NTF_Insert) & which)
327 {
328 DONE_NOTIFY(NTF_Insert);
329 notdoset(data->this,MUIA_NList_InsertPosition,data->vinc);
330 }
331
332 /* notify minmax */
333 if(!data->do_wwrap && !data->force_wwrap &&
334 (ASKED_NOTIFY(NTF_MinMax) & which))
335 {
336 DONE_NOTIFY(NTF_MinMax);
337 ForceMinMax;
338 }
339
340 /* notify columns */
341 if(NEED_NOTIFY(NTF_Columns) & which)
342 {
343 DONE_NOTIFY(NTF_Columns);
344 notdoset(data->this,MUIA_NList_Columns,(IPTR) NL_Columns(data,NULL));
345 }
346
347 return (TRUE);
348 }
349
350
351 void NL_UpdateScrollersValues(struct NLData *data)
352 {
353 Object *obj = data->this;
354
355 if((data->NList_Quiet > 0 || data->NList_Disabled) && !data->do_draw_all)
356 return;
357
358 if(WANTED_NOTIFY(NTF_VSB))
359 {
360 LONG entries = data->NList_Prop_First + data->NList_Prop_Visible;
361
362 if(entries < data->NList_Prop_Entries)
363 entries = data->NList_Prop_Entries;
364
365 if(entries != data->old_prop_entries ||
366 data->NList_Prop_Visible != data->old_prop_visible ||
367 data->NList_Prop_First != data->old_prop_first ||
368 data->vinc != data->old_prop_delta)
369 {
370 SetAttrs(obj,
371 (entries != data->old_prop_entries) ? MUIA_NList_Prop_Entries : TAG_IGNORE, entries,
372 (data->NList_Prop_Visible != data->old_prop_visible) ? MUIA_NList_Prop_Visible : TAG_IGNORE, data->NList_Prop_Visible,
373 (data->NList_Prop_First != data->old_prop_first) ? MUIA_NList_Prop_First : TAG_IGNORE, data->NList_Prop_First,
374 (data->vinc != data->old_prop_delta) ? MUIA_NList_VertDeltaFactor : TAG_IGNORE, data->vinc,
375 TAG_DONE);
376 }
377 }
378 if(WANTED_NOTIFY(NTF_HSB))
379 {
380 if(data->NList_Horiz_Entries != data->old_horiz_entries ||
381 data->NList_Horiz_Visible != data->old_horiz_visible ||
382 data->hinc != data->old_horiz_delta)
383 {
384 SetAttrs(obj,
385 (data->NList_Horiz_Entries != data->old_horiz_entries) ? MUIA_NList_Horiz_Entries : TAG_IGNORE, data->NList_Horiz_Entries,
386 (data->NList_Horiz_Visible != data->old_horiz_visible) ? MUIA_NList_Horiz_Visible : TAG_IGNORE, data->NList_Horiz_Visible,
387 (data->hinc != data->old_horiz_delta) ? MUIA_NList_HorizDeltaFactor : TAG_IGNORE, data->hinc,
388 TAG_DONE);
389 }
390
391 if(data->NList_Horiz_First != data->old_horiz_first)
392 notdoset(obj, MUIA_NList_Horiz_First, data->NList_Horiz_First);
393 }
394 }
395
396
397 ULONG NL_UpdateScrollers(struct NLData *data,BOOL force)
398 {
399 if (!data->SHOW || !data->DRAW)
400 return (FALSE);
401
402 if (data->UpdatingScrollbars)
403 {
404 BOOL lastact = (data->NList_Active == (data->NList_First + data->NList_Visible - 1));
405
406 NL_SetObjInfos(data,TRUE);
407 data->NList_Prop_Visible = data->lvisible * data->vinc;
408 data->NList_Horiz_Visible = data->mright - data->mleft;
409 data->NList_Prop_Entries = data->NList_Entries * data->vinc;
410 if (lastact && (data->NList_Active == (data->NList_First + data->NList_Visible)))
411 data->NList_First++;
412 NL_SetCols(data);
413 NL_DoWrapAll(data,FALSE,FALSE);
414 NL_UpdateScrollersValues(data);
415 return (FALSE);
416 }
417
418 if (data->do_draw_all || data->do_parse || data->do_images || data->do_setcols || data->do_updatesb || data->format_chge)
419 force = TRUE;
420 if (data->ScrollBarsTime <= 0)
421 { data->do_updatesb = TRUE;
422 data->ScrollBarsTime = SCROLLBARSTIME;
423 }
424
425 if (!data->do_draw_all && !data->do_updatesb && !force && (data->NList_Quiet || data->NList_Disabled))
426 {
427 data->ScrollBarsTime = SCROLLBARSTIME;
428 return (FALSE);
429 }
430
431 NL_SetObjInfos(data,TRUE);
432 if (data->do_images)
433 {
434 GetImages(data);
435 GetNImage_Sizes(data);
436 }
437 if (data->do_parse)
438 {
439 AllParseColumns(data);
440 GetNImage_Sizes(data);
441 }
442
443 NL_SetCols(data);
444 NL_DoWrapAll(data,FALSE,FALSE);
445
446 if (data->do_draw_all || force)
447 {
448 LONG ent,ent2,hmax,linelen,hfirst;
449
450 data->NList_Prop_Visible = data->lvisible * data->vinc;
451 data->NList_Horiz_Visible = data->mright - data->mleft;
452 data->NList_Prop_Entries = data->NList_Entries * data->vinc;
453 hmax = 0;
454 hfirst = data->NList_Horiz_First & ~1;
455 ent = data->NList_First;
456 ent2 = data->NList_First + data->NList_Visible;
457 if (ent2 > data->NList_Entries)
458 ent2 = data->NList_Entries;
459 while (data->EntriesArray && (ent < ent2))
460 {
461 linelen = data->EntriesArray[ent]->PixLen;
462 if (((linelen < 1) || data->do_draw_all) && (data->numcols > 0) && !DontDoColumn(data,ent,data->numcols-1))
463 {
464 data->display_ptr = NULL;
465 data->parse_column = -1;
466 if (data->cols[data->numcols-1].c->userwidth > 0)
467 linelen = data->cols[data->numcols-1].c->userwidth + data->cols[data->numcols-1].c->minx - 1;
468 else
469 {
470 NL_GetDisplayArray(data,ent);
471 ParseColumn(data,data->numcols-1,0);
472 WidthColumn(data,data->numcols-1,0);
473 linelen = data->cols[data->numcols-1].c->colwidth + data->cols[data->numcols-1].c->minx + data->cols[data->numcols-1].c->xoffset;
474 if (IS_ALIGN_CENTER(data->cols[data->numcols-1].c->style) && (data->cols[data->numcols-1].c->dx > data->cols[data->numcols-1].c->colwidth))
475 linelen = data->cols[data->numcols-1].c->minx + data->cols[data->numcols-1].c->dx - 1;
476 data->display_ptr = NULL;
477 data->parse_column = -1;
478 }
479 data->EntriesArray[ent]->PixLen = linelen;
480 }
481 if (linelen > hmax)
482 hmax = linelen;
483 ent++;
484 }
485 if (data->NList_Title)
486 {
487 if ((data->Title_PixLen < 0) || data->do_draw_all)
488 {
489 data->do_draw_title = TRUE;
490 data->display_ptr = NULL;
491 data->parse_column = -1;
492 if (data->cols[data->numcols-1].c->userwidth > 0)
493 data->Title_PixLen = data->cols[data->numcols-1].c->userwidth + data->cols[data->numcols-1].c->minx - 1;
494 else
495 {
496 NL_GetDisplayArray(data,-1);
497 ParseColumn(data,data->numcols-1,0);
498 WidthColumn(data,data->numcols-1,0);
499 data->Title_PixLen = data->cols[data->numcols-1].c->colwidth + data->cols[data->numcols-1].c->minx + data->cols[data->numcols-1].c->xoffset;
500 if (IS_ALIGN_CENTER(data->cols[data->numcols-1].c->style) && (data->cols[data->numcols-1].c->dx > data->cols[data->numcols-1].c->colwidth))
501 data->Title_PixLen = data->cols[data->numcols-1].minx + data->cols[data->numcols-1].dx - 1;
502 data->display_ptr = NULL;
503 data->parse_column = -1;
504 }
505 }
506 if (data->Title_PixLen > hmax)
507 hmax = data->Title_PixLen;
508 }
509 if (hfirst + data->hvisible > hmax)
510 hmax = hfirst + data->hvisible;
511 data->NList_Horiz_Entries = hmax;
512 NL_UpdateScrollersValues(data);
513 }
514
515 data->ScrollBarsTime = SCROLLBARSTIME;
516 if (data->do_updatesb && (data->NList_Quiet <= 0) && !data->NList_Disabled && WANTED_NOTIFY(NTF_SB))
517 {
518 data->do_updatesb = FALSE;
519 data->ScrollBars = (data->ScrollBarsOld & ~MUIV_NListview_HSB_On) | MUIV_NListview_HSB_Off;
520
521 if (data->ScrollBarsPos != data->NList_First)
522 data->ScrollBars = MUIV_NListview_HSB_Off | MUIV_NListview_VSB_Off;
523
524 if ((data->NList_Prop_Entries > data->NList_Prop_Visible) || (data->NList_First > 0))
525 data->ScrollBars |= MUIV_NListview_VSB_On;
526
527 if (data->NList_Horiz_Entries > data->NList_Horiz_Visible)
528 data->ScrollBars |= MUIV_NListview_HSB_On;
529 else
530 {
531 LONG ent = data->NList_First + data->NList_Visible;
532
533 if ((ent < data->NList_Entries) && data->EntriesArray &&
534 ((data->ScrollBarsOld & MUIV_NListview_HSB_On) == MUIV_NListview_HSB_On))
535 {
536 LONG hsb,lastent,hsbheight,vsbwidth=0;
537
538 // check if we got a HSB_Height attribute
539 if(data->scrollersobj && GetAttr(MUIA_NListview_HSB_Height, data->scrollersobj, (IPTR *)&hsbheight) != FALSE)
540 {
541 hsbheight += data->vdt + data->vdb;
542 lastent = ent + (hsbheight / data->vinc) + 1;
543 }
544 else
545 lastent = ent+1;
546
547 if(data->scrollersobj)
548 vsbwidth = xget(data->scrollersobj, MUIA_NListview_VSB_Width);
549
550 hsb = 0;
551 while ((ent < lastent) && (ent < data->NList_Entries))
552 {
553 if (((data->EntriesArray[ent]->PixLen < 1) || data->do_draw_all) && (data->numcols > 0) && !DontDoColumn(data,ent,data->numcols-1))
554 {
555 data->display_ptr = NULL;
556 data->parse_column = -1;
557 if (data->cols[data->numcols-1].c->userwidth > 0)
558 data->EntriesArray[ent]->PixLen = data->cols[data->numcols-1].c->userwidth + data->cols[data->numcols-1].c->minx - 1;
559 else
560 {
561 NL_GetDisplayArray(data,ent);
562 ParseColumn(data,data->numcols-1,0);
563 WidthColumn(data,data->numcols-1,0);
564 data->EntriesArray[ent]->PixLen = data->cols[data->numcols-1].c->colwidth + data->cols[data->numcols-1].c->minx + data->cols[data->numcols-1].c->xoffset;
565 if (IS_ALIGN_CENTER(data->cols[data->numcols-1].c->style) && (data->cols[data->numcols-1].c->dx > data->cols[data->numcols-1].c->colwidth))
566 data->EntriesArray[ent]->PixLen = data->cols[data->numcols-1].c->minx + data->cols[data->numcols-1].c->dx - 1;
567 data->display_ptr = NULL;
568 data->parse_column = -1;
569 }
570 }
571
572 if (data->EntriesArray[ent]->PixLen + vsbwidth > data->NList_Horiz_Visible)
573 { hsb |= MUIV_NListview_HSB_On;
574 break;
575 }
576 ent++;
577 }
578 data->ScrollBars |= hsb;
579 }
580 }
581
582 if (force || (data->ScrollBars != data->ScrollBarsOld))
583 {
584 data->ScrollBarsOld = data->ScrollBars;
585 data->ScrollBarsPos = data->NList_First;
586
587 data->UpdatingScrollbars = TRUE;
588 data->UpdateScrollersRedrawn = FALSE;
589 set(data->this,MUIA_NListview_Horiz_ScrollBar,data->ScrollBars);
590 data->UpdatingScrollbars = FALSE;
591
592 NL_UpdateScrollersValues(data);
593
594 if ((data->ScrollBars & MUIV_NListview_VSB_On) != MUIV_NListview_VSB_On)
595 data->ScrollBarsPos = -2;
596
597 return (data->UpdateScrollersRedrawn);
598 }
599 }
600 data->do_updatesb = FALSE;
601 return (FALSE);
602 }
603
604
605 static LONG DoRefresh(struct NLData *data)
606 {
607 if (data->SHOW && data->DRAW)
608 {
609 Object *obj = data->this;
610
611 if (data->DRAW > 1)
612 {
613 data->pushtrigger = 1;
614 DoMethod(_app(obj),MUIM_Application_PushMethod,obj,1,MUIM_NList_Trigger);
615 return (FALSE);
616 }
617 if (!(muiRenderInfo(obj)->mri_Flags & MUIMRI_REFRESHMODE) && !data->refreshing &&
618 (data->rp->Layer->Flags & LAYERREFRESH))
619 /*&& ((_window(obj)->Flags & WFLG_REFRESHBITS) == WFLG_SIMPLE_REFRESH) )*/
620 {
621 SetBackGround(data->NList_ListBackGround);
622 if (MUI_BeginRefresh(muiRenderInfo(obj),0))
623 {
624 Object *o = (Object *)xget(_win(obj),MUIA_Window_RootObject);
625
626 if(o)
627 {
628 data->refreshing = TRUE;
629 /*
630 * if (data->do_draw_all && data->do_draw)
631 * data->refreshing = 2;
632 */
633 MUI_Redraw(o,MADF_DRAWOBJECT); /* MADF_DRAWALL */
634 data->refreshing = FALSE;
635 MUI_EndRefresh(muiRenderInfo(obj),0);
636 }
637 }
638 }
639 if ((data->pushtrigger == 2) ||
640 (!(data->rp->Layer->Flags & LAYERREFRESH) &&
641 !(muiRenderInfo(obj)->mri_Flags & MUIMRI_REFRESHMODE) && !data->refreshing))
642 {
643 return (TRUE);
644 }
645 else if (!data->pushtrigger)
646 {
647 data->pushtrigger = 1;
648 DoMethod(_app(obj),MUIM_Application_PushMethod,obj,1,MUIM_NList_Trigger);
649 }
650 }
651 return (FALSE);
652 }
653
654 /*
655 * if (!(data->rp->Layer->Flags & LAYERREFRESH) || (data->pushtrigger == 2))
656 * {
657 * }
658 * else if (!data->pushtrigger)
659 * { data->pushtrigger = 1;
660 * DoMethod(_app(obj),MUIM_Application_PushMethod,obj,1,MUIM_NList_Trigger);
661 * }
662 */
663
664
665 void NL_DrawQuietBG(struct NLData *data,LONG dowhat,LONG bg)
666 {
667 if (data->do_draw_all)
668 {
669 if ((dowhat == 0) || (dowhat == 4))
670 dowhat = 2;
671 else if (dowhat == 3)
672 dowhat = 1;
673 }
674
675 switch (dowhat)
676 {
677 case 0 : /* REDRAW_IF */
678
679 if (!data->NList_Quiet && !data->NList_Disabled && data->SHOW && data->DRAW)
680 {
681 if (DoRefresh(data))
682 {
683 if (data->do_draw_all)
684 {
685 ULONG mad_Flags = muiAreaData(data->this)->mad_Flags;
686
687 data->nodraw++;
688 OCLASS(data->this) = data->ncl;
689 nnset(data->this,MUIA_Background,(IPTR)"0:128");
690 OCLASS(data->this) = data->ocl;
691 data->nodraw--;
692 muiAreaData(data->this)->mad_Flags = mad_Flags;
693 data->actbackground = -1;
694 MUI_Redraw(data->this,MADF_DRAWUPDATE);
695 }
696 else if (data->do_draw)
697 MUI_Redraw(data->this,MADF_DRAWUPDATE);
698 }
699 }
700 break;
701
702 case 1 : /* REDRAW_ALL_FORCE */
703
704 data->do_draw = data->do_draw_all = TRUE;
705 if (data->SHOW && data->DRAW)
706 {
707 if (DoRefresh(data))
708 {
709 ULONG mad_Flags = muiAreaData(data->this)->mad_Flags;
710
711 data->nodraw++;
712 OCLASS(data->this) = data->ncl;
713 nnset(data->this,MUIA_Background,(IPTR)"0:128");
714 OCLASS(data->this) = data->ocl;
715 data->nodraw--;
716 muiAreaData(data->this)->mad_Flags = mad_Flags;
717 data->actbackground = -1;
718 MUI_Redraw(data->this,MADF_DRAWALL);
719 }
720 }
721 break;
722
723 case 2 : /* REDRAW_ALL */
724
725 data->do_draw = data->do_draw_all = TRUE;
726 if (!data->NList_Quiet && !data->NList_Disabled && data->SHOW && data->DRAW)
727 {
728 if (DoRefresh(data))
729 {
730 ULONG mad_Flags = muiAreaData(data->this)->mad_Flags;
731
732 data->nodraw++;
733 OCLASS(data->this) = data->ncl;
734 nnset(data->this,MUIA_Background,(IPTR)"0:128");
735 OCLASS(data->this) = data->ocl;
736 data->nodraw--;
737 muiAreaData(data->this)->mad_Flags = mad_Flags;
738 data->actbackground = -1;
739 MUI_Redraw(data->this,MADF_DRAWOBJECT);
740 }
741 }
742 break;
743
744 case 3 : /* REDRAW_FORCE */
745
746 data->do_draw = TRUE;
747 if (data->SHOW && data->DRAW)
748 {
749 if (DoRefresh(data))
750 {
751 if (data->do_draw_all)
752 {
753 ULONG mad_Flags = muiAreaData(data->this)->mad_Flags;
754
755 data->nodraw++;
756 OCLASS(data->this) = data->ncl;
757 nnset(data->this,MUIA_Background,(IPTR)"0:128");
758 OCLASS(data->this) = data->ocl;
759 data->nodraw--;
760 muiAreaData(data->this)->mad_Flags = mad_Flags;
761 data->actbackground = -1;
762 MUI_Redraw(data->this,MADF_DRAWUPDATE);
763 }
764 else
765 MUI_Redraw(data->this,MADF_DRAWUPDATE);
766 }
767 }
768 break;
769
770 case 4 : /* REDRAW */
771
772 data->do_draw = TRUE;
773 if (!data->NList_Quiet && !data->NList_Disabled && data->SHOW && data->DRAW)
774 {
775 if (DoRefresh(data))
776 {
777 if (data->do_draw_all)
778 {
779 ULONG mad_Flags = muiAreaData(data->this)->mad_Flags;
780
781 data->nodraw++;
782 OCLASS(data->this) = data->ncl;
783 nnset(data->this,MUIA_Background,(IPTR)"0:128");
784 OCLASS(data->this) = data->ocl;
785 data->nodraw--;
786 muiAreaData(data->this)->mad_Flags = mad_Flags;
787 data->actbackground = -1;
788 MUI_Redraw(data->this,MADF_DRAWUPDATE);
789 }
790 else
791 MUI_Redraw(data->this,MADF_DRAWUPDATE);
792 }
793 }
794 break;
795
796 case 5 : /* ENDQUIET */
797
798 data->NList_Quiet = 0;
799 if (data->SHOW)
800 {
801 if (DoRefresh(data))
802 {
803 if (data->do_draw_all)
804 {
805 ULONG mad_Flags = muiAreaData(data->this)->mad_Flags;
806
807 data->nodraw++;
808 OCLASS(data->this) = data->ncl;
809 nnset(data->this,MUIA_Background,(IPTR)"0:128");
810 OCLASS(data->this) = data->ocl;
811 data->nodraw--;
812 muiAreaData(data->this)->mad_Flags = mad_Flags;
813 data->actbackground = -1;
814 /*MUI_Redraw(data->this,MADF_DRAWOBJECT);*/
815 MUI_Redraw(data->this,MADF_DRAWOBJECT);
816 }
817 else if (data->do_draw)
818 MUI_Redraw(data->this,MADF_DRAWUPDATE);
819 }
820 /* do_notifies(NTF_All);*/
821 }
822 break;
823
824 case 6 : /* LESSQUIET */
825
826 if (data->NList_Quiet > 0)
827 data->NList_Quiet--;
828 if (!data->NList_Quiet && !data->NList_Disabled && data->SHOW)
829 {
830 if (DoRefresh(data))
831 {
832 if (data->do_draw_all)
833 {
834 ULONG mad_Flags = muiAreaData(data->this)->mad_Flags;
835
836 data->nodraw++;
837 OCLASS(data->this) = data->ncl;
838 nnset(data->this,MUIA_Background,(IPTR)"0:128");
839 OCLASS(data->this) = data->ocl;
840 data->nodraw--;
841 muiAreaData(data->this)->mad_Flags = mad_Flags;
842 data->actbackground = -1;
843 /*MUI_Redraw(data->this,MADF_DRAWOBJECT);*/
844 MUI_Redraw(data->this,MADF_DRAWUPDATE);
845 }
846 else if (data->do_draw)
847 MUI_Redraw(data->this,MADF_DRAWUPDATE);
848 }
849 /* do_notifies(NTF_All);*/
850 }
851 break;
852
853 case 7 : /* SetBackGround */
854
855 {
856 ULONG mad_Flags = muiAreaData(data->this)->mad_Flags;
857
858 data->actbackground = bg;
859 data->nodraw++;
860 OCLASS(data->this) = data->ncl;
861 nnset(data->this,MUIA_Background,bg);
862 OCLASS(data->this) = data->ocl;
863 data->nodraw--;
864 muiAreaData(data->this)->mad_Flags = mad_Flags;
865 }
866
867 break;
868
869 case 8 : /* Make_Active_Visible */
870
871 if ((data->NList_AutoVisible) && (data->NList_Active >= 0) && (data->NList_Active < data->NList_Entries))
872 {
873 if (data->NList_Active < data->NList_First)
874 {
875 data->NList_First = data->NList_Active;
876 DO_NOTIFY(NTF_First);
877 }
878 else if (data->NList_Active >= data->NList_First + data->NList_Visible)
879 {
880 data->NList_First = data->NList_Active - data->NList_Visible + 1;
881 if (data->NList_First < 0)
882 data->NList_First = 0;
883 DO_NOTIFY(NTF_First);
884 }
885 }
886 break;
887
888 case 9 : /* ForceMinMax */
889
890 DONE_NOTIFY(NTF_MinMax);
891 if (!WANTED_NOTIFY(NTF_MinMax) && data->SHOW && data->DRAW && data->NL_Group && data->VirtGroup && data->NList_AdjustHeight)
892 {
893 ULONG mad_Flags = muiAreaData(data->this)->mad_Flags;
894
895 WANT_NOTIFY(NTF_MinMax|NTF_MinMaxNoDraw);
896 if (DoMethod(data->VirtGroup,MUIM_Group_InitChange))
897 {
898 DoMethod(data->VirtGroup,MUIM_Group_ExitChange);
899 muiAreaData(data->this)->mad_Flags = mad_Flags;
900 NL_UpdateScrollersValues(data);
901 }
902 }
903 NOWANT_NOTIFY(NTF_MinMax|NTF_MinMaxNoDraw);
904 DONE_NOTIFY(NTF_MinMax);
905 break;
906
907 }
908 }
909
910
911 #define SELECTABLE(ent) \
912 ((!data->NList_MultiTestHook) ||\
913 (MyCallHookPkt(data->this,FALSE,data->NList_MultiTestHook,data->this,data->EntriesArray[ent]->Entry)))
914
915
916 void NL_Select(struct NLData *data,LONG dowhat,LONG ent,BYTE sel)
917 {
918 /* D(bug("%lx dowhat=%ld ent=%ld sel=%ld\n",obj,dowhat,ent,sel));*/
919 switch (dowhat)
920 {
921 case 0 : /* SELECT(ent,sel) */
922 if (!data->NList_TypeSelect && SELECTABLE(ent))
923 { if (data->EntriesArray[ent]->Select != sel)
924 { data->EntriesArray[ent]->Select = sel;
925 DO_NOTIFY(NTF_Select | NTF_LV_Select);
926
927 DoMethod( data->this, MUIM_NList_SelectChange, ent, MUIV_NList_Select_On, 0 );
928 }
929 }
930 break;
931
932 case 1 : /* SELECT2(ent,sel) */
933 if (!data->NList_TypeSelect && (data->EntriesArray[ent]->Select != sel))
934 { data->EntriesArray[ent]->Select = sel;
935 DO_NOTIFY(NTF_Select | NTF_LV_Select);
936
937 DoMethod( data->this, MUIM_NList_SelectChange, ent, MUIV_NList_Select_Off, 0 );
938 }
939 break;
940
941 case 2 : /* SELECT_CHGE(ent,sel) */
942 if (!data->NList_TypeSelect && SELECTABLE(ent))
943 { if (data->EntriesArray[ent]->Select != sel)
944 { data->EntriesArray[ent]->Select = sel;
945 NL_Changed(data,ent);
946 DO_NOTIFY(NTF_Select | NTF_LV_Select);
947
948 DoMethod( data->this, MUIM_NList_SelectChange, ent, MUIV_NList_Select_On, MUIV_NList_SelectChange_Flag_Multi );
949 }
950 }
951 break;
952
953 case 3 : /* SELECT2_CHGE(ent,sel) */
954 if (!data->NList_TypeSelect && (data->EntriesArray[ent]->Select != sel))
955 { data->EntriesArray[ent]->Select = sel;
956 NL_Changed(data,ent);
957 DO_NOTIFY(NTF_Select | NTF_LV_Select);
958
959 DoMethod( data->this, MUIM_NList_SelectChange, ent, MUIV_NList_Select_Off, MUIV_NList_SelectChange_Flag_Multi );
960 }
961 break;
962
963 case 4 : /* set_Active(ent) */
964 { if (data->NList_Active != (ent))
965 {
966 data->NList_Active = (ent);
967 DO_NOTIFY(NTF_Active | NTF_L_Active);
968
969 DoMethod( data->this, MUIM_NList_SelectChange, ent, MUIV_NList_Select_Active, 0 );
970 }
971 }
972 break;
973
974 }
975 }
976
977
978
979
980
981 /*
982 * if ((w->Flags & WFLG_REFRESHBITS) == WFLG_SIMPLE_REFRESH)
983 * {
984 * struct Layer *lay, *l = w->WLayer;
985 * WORD mleft,mright,mtop,mbottom;
986 * mleft = w->LeftEdge + data->mleft;
987 * mright = w->LeftEdge + data->mright;
988 * mtop = w->TopEdge + data->mtop;
989 * mbottom = w->TopEdge + data->mbottom;
990 * lay = w->WLayer->front;
991 * while (lay)
992 * { if ((lay->bounds.MaxX > mleft) &&
993 * (lay->bounds.MinX < mright) &&
994 * (lay->bounds.MaxY > mtop) &&
995 * (lay->bounds.MinY < mbottom))
996 * { data->do_draw_all = TRUE;
997 * data->NList_First_Incr = 0;
998 * break;
999 * }
1000 * lay = lay->front;
1001 * }
1002 * }
1003 */
1004
1005 #define LayerCovered(l) ((!(l)->ClipRect) || ((l)->ClipRect->bounds.MaxX != (l)->bounds.MaxX) ||\
1006 ((l)->ClipRect->bounds.MinX != (l)->bounds.MinX) ||\
1007 ((l)->ClipRect->bounds.MaxY != (l)->bounds.MaxY) ||\
1008 ((l)->ClipRect->bounds.MinY != (l)->bounds.MinY))
1009
1010 #define LayerDamaged(l) ((l)->DamageList && (l)->DamageList->RegionRectangle)
1011
1012 #define ABS(x) (((x) >= 0) ? (x) : -(x))
1013
1014 void ScrollVert(struct NLData *data,WORD dy,LONG LPVisible)
1015 {
1016 WORD y1 = data->vpos;
1017 WORD y2 = data->vpos + LPVisible - 1;
1018
1019 if (data->vwidth <= 0)
1020 return;
1021 if (y1 < data->vtop) y1 = data->vtop;
1022 if (y2 > data->vbottom) y2 = data->vbottom;
1023 if ((y2 - y1) <= ABS(dy))
1024 return;
1025
1026 #ifndef DO_CLIPBLIT
1027 if (LIBVER(GfxBase) >= 39)
1028 {
1029 struct Hook *oldbackfilhook;
1030
1031 oldbackfilhook = InstallLayerHook(data->rp->Layer, LAYERS_NOBACKFILL);
1032 ScrollRasterBF(data->rp,0,dy,data->vleft,y1,data->vright,y2);
1033 InstallLayerHook(data->rp->Layer, oldbackfilhook);
1034 }
1035 else
1036 #endif
1037 {
1038 struct Window *w = _window(data->this);
1039 struct Layer *l = w->WLayer;
1040
1041 if (dy > 0)
1042 ClipBlit(data->rp,data->vleft,y1+dy,data->rp,data->vleft,y1,data->vwidth,y2-y1+1-dy,0xC0);
1043 else
1044 ClipBlit(data->rp,data->vleft,y1,data->rp,data->vleft,y1-dy,data->vwidth,y2-y1+1+dy,0xC0);
1045 if (((w->Flags & WFLG_REFRESHBITS) == WFLG_SIMPLE_REFRESH) &&
1046 (LayerCovered(l) || LayerDamaged(l)))
1047 {
1048 UBYTE oldmask = data->rp->Mask;
1049
1050 SetWrMsk(data->rp,0);
1051 ScrollRaster(data->rp,0,dy,data->vleft,y1,data->vright,y2);
1052 SetWrMsk(data->rp,oldmask);
1053 }
1054 }
1055 }
1056
1057
1058 void ScrollHoriz(struct NLData *data,WORD dx,LONG LPVisible)
1059 {
1060 WORD y1 = data->vpos;
1061 WORD y2 = data->vpos + LPVisible - 1;
1062
1063 if (data->vwidth <= ABS(dx))
1064 return;
1065 if (data->NList_Title)
1066 y1 = data->vdtitlepos;
1067 if (y1 < data->vtop) y1 = data->vtop;
1068 if (y2 > data->vbottom) y2 = data->vbottom;
1069 if (y1 > y2)
1070 return;
1071
1072 #ifndef DO_CLIPBLIT
1073 if (LIBVER(GfxBase) >= 39)
1074 {
1075 struct Hook *oldbackfilhook;
1076
1077 oldbackfilhook = InstallLayerHook(data->rp->Layer, LAYERS_NOBACKFILL);
1078 ScrollRasterBF(data->rp,dx,0,data->vleft,y1,data->vright,y2);
1079 InstallLayerHook(data->rp->Layer, oldbackfilhook);
1080 }
1081 else
1082 #endif
1083 {
1084 struct Window *w = _window(data->this);
1085 struct Layer *l = w->WLayer;
1086
1087 if (dx > 0)
1088 ClipBlit(data->rp,data->vleft+dx,y1,data->rp,data->vleft,y1,data->vwidth-dx,y2-y1+1,0xC0);
1089 else
1090 ClipBlit(data->rp,data->vleft,y1,data->rp,data->vleft-dx,y1,data->vwidth+dx,y2-y1+1,0xC0);
1091 if (((w->Flags & WFLG_REFRESHBITS) == WFLG_SIMPLE_REFRESH) &&
1092 (LayerCovered(l) || LayerDamaged(l)))
1093 {
1094 UBYTE oldmask = data->rp->Mask;
1095
1096 SetWrMsk(data->rp,0);
1097 ScrollRaster(data->rp,dx,0,data->vleft,y1,data->vright,y2);
1098 SetWrMsk(data->rp,oldmask);
1099 }
1100 }
1101 }
1102
1103
1104 LONG NL_ColToColumn(struct NLData *data,LONG col)
1105 {
1106 LONG column;
1107
1108 if ((col >= 0) && (col < DISPLAY_ARRAY_MAX))
1109 {
1110 for (column = 0; column < data->numcols; column++)
1111 {
1112 if (data->cols[column].c->col == col)
1113 return (column);
1114 }
1115 }
1116 return (-1);
1117 }
1118
1119
1120 LONG NL_ColumnToCol(struct NLData *data,LONG column)
1121 {
1122 if ((column >= 0) && (column < data->numcols))
1123 return ((LONG) data->cols[column].c->col);
1124 return (-1);
1125 }
1126
1127
1128 LONG NL_SetCol(struct NLData *data,LONG column,LONG col)
1129 { LONG column2d = -1;
1130 if ((column == MUIV_NList_SetColumnCol_Default) && (col == MUIV_NList_SetColumnCol_Default))
1131 { for (column = 0; column < data->numcols; column++)
1132 { if (data->cols[column].c != &data->cols[column])
1133 data->do_setcols = TRUE;
1134 data->cols[column].c = &data->cols[column];
1135 }
1136 if (data->do_setcols)
1137 { DO_NOTIFY(NTF_Columns);
1138 REDRAW_FORCE;
1139 }
1140 return (0);
1141 }
1142 else if ((col == MUIV_NList_SetColumnCol_Default) &&
1143 (column >= 0) && (column < data->numcols))
1144 { for (column2d = 0; column2d < data->numcols; column2d++)
1145 { if (data->cols[column].c == &data->cols[column2d])
1146 { column = column2d;
1147 break;
1148 }
1149 }
1150 }
1151 else if ((col >= 0) && (col < DISPLAY_ARRAY_MAX))
1152 { for (column2d = 0; column2d < data->numcols; column2d++)
1153 { if (data->cols[column2d].col == col)
1154 { if (column == MUIV_NList_SetColumnCol_Default)
1155 column = column2d;
1156 break;
1157 }
1158 }
1159 }
1160
1161 if ((column >= 0) && (column < data->numcols) &&
1162 (column2d >= 0) && (column2d < data->numcols) &&
1163 (data->cols[column].c != &data->cols[column2d]))
1164 { LONG column2;
1165 for (column2 = 0; column2 < data->numcols; column2++)
1166 { if (data->cols[column2].c == &data->cols[column2d])
1167 break;
1168 }
1169 if ((column2 >= 0) && (column2 < data->numcols))
1170 { data->cols[column2].c = data->cols[column].c;
1171 data->cols[column].c = &data->cols[column2d];
1172 /*
1173 * data->do_draw_all = data->do_draw_title = data->do_draw = TRUE;
1174 * data->do_parse = data->do_setcols = data->do_updatesb = data->do_wwrap = TRUE;
1175 * do_draw = TRUE;
1176 */
1177 data->do_setcols = TRUE;
1178 DO_NOTIFY(NTF_Columns);
1179 REDRAW_FORCE;
1180 }
1181 }
1182 return (0);
1183 }
1184
1185
1186 LONG NL_ColWidth(struct NLData *data,LONG col,LONG width)
1187 {
1188 LONG column = NL_ColToColumn(data,col);
1189 WORD userwidth = (WORD) width;
1190
1191 if (userwidth < 4) /* < 4 is considered as MUIV_NList_ColWidth_Default */
1192 userwidth = -1;
1193 if (userwidth > 2000)
1194 userwidth = 2000;
1195 if (width == MUIV_NList_ColWidth_Get)
1196 {
1197 if ((column >= 0) && (column < data->numcols))
1198 return ((LONG) data->cols[column].c->userwidth);
1199 }
1200 else if (col == MUIV_NList_ColWidth_All)
1201 {
1202 for (column = 0;column < data->numcols;column++)
1203 {
1204 if (data->cols[column].c->userwidth != userwidth)
1205 {
1206 if (userwidth < 0)
1207 data->cols[column].c->colwidthbiggestptr = -2;
1208 data->cols[column].c->userwidth = userwidth;
1209 data->do_setcols = TRUE;
1210 }
1211 }
1212 if (data->do_setcols)
1213 {
1214 REDRAW_FORCE;
1215 }
1216 }
1217 else if ((column >= 0) && (column < data->numcols) && (data->cols[column].c->userwidth != userwidth))
1218 {
1219 if (userwidth < 0)
1220 data->cols[column].c->colwidthbiggestptr = -2;
1221 data->cols[column].c->userwidth = userwidth;
1222 data->do_setcols = TRUE;
1223 REDRAW_FORCE;
1224 return (userwidth);
1225 }
1226 return (0);
1227 }
1228
1229
1230 BYTE *NL_Columns(struct NLData *data,BYTE *columns)
1231 { LONG column;
1232 if (columns)
1233 { column = 0;
1234 while ((column < data->numcols) && (columns[column] != -1))
1235 {
1236 NL_SetCol(data,column,columns[column]);
1237 column++;
1238 }
1239 }
1240 for (column = 0; column < data->numcols; column++)
1241 { data->column[column] = data->cols[column].c->col;
1242 }
1243 data->column[column] = -1;
1244 return (data->column);
1245 }
1246
1247
1248 IPTR mNL_ColToColumn(struct IClass *cl,Object *obj,struct MUIP_NList_ColToColumn *msg)
1249 {
1250 struct NLData *data = INST_DATA(cl,obj);
1251 return ((IPTR) NL_ColToColumn(data,msg->col));
1252 }
1253
1254
1255 IPTR mNL_ColumnToCol(struct IClass *cl,Object *obj,struct MUIP_NList_ColumnToCol *msg)
1256 {
1257 struct NLData *data = INST_DATA(cl,obj);
1258 return ((IPTR) NL_ColumnToCol(data,msg->column));
1259 }
1260
1261
1262 IPTR mNL_SetColumnCol(struct IClass *cl,Object *obj,struct MUIP_NList_SetColumnCol *msg)
1263 {
1264 struct NLData *data = INST_DATA(cl,obj);
1265 LONG retval;
1266 retval = NL_SetCol(data,msg->column,msg->col);
1267 DONE_NOTIFY(NTF_Columns);
1268 return ((IPTR) retval);
1269 }
1270
1271
1272 IPTR mNL_List_ColWidth(struct IClass *cl,Object *obj,struct MUIP_NList_ColWidth *msg)
1273 {
1274 struct NLData *data = INST_DATA(cl,obj);
1275 return ((IPTR) NL_ColWidth(data,msg->col,msg->width));
1276 }
1277
1278
1279
1280 IPTR mNL_ContextMenuBuild(struct IClass *cl,Object *obj,struct MUIP_ContextMenuBuild *msg)
1281 {
1282 struct NLData *data = INST_DATA(cl,obj);
1283 Object *MenuObj = NULL;
1284 LONG column;
1285 LONG mo = 0;
1286 BOOL do_it = FALSE;
1287 BOOL order_it = FALSE;
1288
1289 if (data->NList_Disabled)
1290 return (0);
1291
1292 if((mo = xget(obj, MUIA_ContextMenu)))
1293 {
1294 if ((mo & 0x9d510030) != 0x9d510030)
1295 {
1296 if (data->MenuObj)
1297 { MUI_DisposeObject(data->MenuObj);
1298 data->MenuObj = NULL;
1299 }
1300 return(DoSuperMethodA(cl,obj,(Msg) msg));
1301 }
1302 else if (mo == (LONG)MUIV_NList_ContextMenu_Never)
1303 {
1304 data->ContextMenuOn = FALSE;
1305 data->NList_ContextMenu = MUIV_NList_ContextMenu_Never;
1306 nnset(obj,MUIA_ContextMenu,NULL);
1307 }
1308 for (column = 0;column < data->numcols;column++)
1309 {
1310 if (data->cols[column].c->userwidth >= 0)
1311 do_it = TRUE;
1312 if (data->cols[column].c != &data->cols[column])
1313 order_it = TRUE;
1314 }
1315
1316 /* sba: Contextmenu problem: Disabled */
1317 /* if (data->numcols > 1) */
1318 if (data->numcols > 0)
1319 { Object *mithis = NULL;
1320 struct MUI_NList_TestPos_Result res;
1321 LONG flags,ontop;
1322
1323 data->click_x = msg->mx;
1324 data->click_y = msg->my;
1325 res.char_number = -2;
1326 NL_List_TestPos(data,MUI_MAXMAX,0,&res);
1327 column = (LONG) res.column;
1328 flags = (LONG) res.flags;
1329 if (res.flags & MUI_NLPR_TITLE)
1330 ontop = TRUE;
1331 else
1332 ontop = FALSE;
1333
1334 MenuObj = (Object *) DoMethod(obj,MUIM_NList_ContextMenuBuild,msg->mx,msg->my,res.entry,column,flags,ontop);
1335
1336 if ((IPTR)MenuObj == (IPTR)-1)
1337 return (0);
1338
1339 if (!MenuObj)
1340 { if (!data->MenuObj)
1341 data->MenuObj = MUI_MakeObject(MUIO_MenustripNM,MenuData,0);
1342 MenuObj = data->MenuObj;
1343 }
1344
1345 if (MenuObj && (mithis = (Object *) DoMethod(MenuObj,MUIM_FindUData,MUIV_NList_Menu_DefWidth_This)))
1346 {
1347 if ((res.column >= 0) && (res.column < data->numcols) &&
1348 !(res.flags & MUI_NLPR_BAR) && (data->cols[res.column].c->userwidth > 0))
1349 { nnset(mithis,MUIA_Menuitem_Enabled,TRUE);
1350 }
1351 else
1352 { nnset(mithis,MUIA_Menuitem_Enabled,FALSE);
1353 }
1354 }
1355 if (MenuObj && (mithis = (Object *) DoMethod(MenuObj,MUIM_FindUData,MUIV_NList_Menu_DefWidth_All)))
1356 { if (do_it)
1357 { nnset(mithis,MUIA_Menuitem_Enabled,TRUE);
1358 }
1359 else
1360 { nnset(mithis,MUIA_Menuitem_Enabled,FALSE);
1361 }
1362 }
1363 if (MenuObj && (mithis = (Object *) DoMethod(MenuObj,MUIM_FindUData,MUIV_NList_Menu_DefOrder_This)))
1364 {
1365 if ((res.column >= 0) && (res.column < data->numcols) &&
1366 !(res.flags & MUI_NLPR_BAR) && (data->cols[res.column].c != &data->cols[res.column]))
1367 { nnset(mithis,MUIA_Menuitem_Enabled,TRUE);
1368 }
1369 else
1370 { nnset(mithis,MUIA_Menuitem_Enabled,FALSE);
1371 }
1372 }
1373 if (MenuObj && (mithis = (Object *) DoMethod(MenuObj,MUIM_FindUData,MUIV_NList_Menu_DefOrder_All)))
1374 { if (order_it)
1375 { nnset(mithis,MUIA_Menuitem_Enabled,TRUE);
1376 }
1377 else
1378 { nnset(mithis,MUIA_Menuitem_Enabled,FALSE);
1379 }
1380 }
1381 return ((IPTR) MenuObj);
1382 }
1383 }
1384
1385 return (0);
1386 }
1387
1388
1389
1390 IPTR mNL_ContextMenuChoice(struct IClass *cl,Object *obj,struct MUIP_ContextMenuChoice *msg)
1391 {
1392 struct NLData *data = INST_DATA(cl,obj);
1393
1394 if (data->NList_Disabled)
1395 return (0);
1396
1397 if (msg->item)
1398 {
1399 if (muiUserData(msg->item) == MUIV_NList_Menu_DefWidth_This)
1400 {
1401 struct MUI_NList_TestPos_Result res;
1402
1403 res.char_number = -2;
1404 NL_List_TestPos(data,MUI_MAXMAX,0,&res);
1405 if ((res.column >= 0) && (res.column < data->numcols) && !(res.flags & MUI_NLPR_BAR))
1406 NL_ColWidth(data,NL_ColumnToCol(data,res.column),MUIV_NList_ColWidth_Default);
1407 }
1408 else if (muiUserData(msg->item) == MUIV_NList_Menu_DefWidth_All)
1409 NL_ColWidth(data,MUIV_NList_ColWidth_All,MUIV_NList_ColWidth_Default);
1410 else if (muiUserData(msg->item) == MUIV_NList_Menu_DefOrder_This)
1411 {
1412 struct MUI_NList_TestPos_Result res;
1413
1414 res.char_number = -2;
1415 NL_List_TestPos(data,MUI_MAXMAX,0,&res);
1416 if ((res.column >= 0) && (res.column < data->numcols) && !(res.flags & MUI_NLPR_BAR))
1417 NL_SetCol(data,res.column,MUIV_NList_SetColumnCol_Default);
1418 }
1419 else if (muiUserData(msg->item) == MUIV_NList_Menu_DefOrder_All)
1420 NL_SetCol(data,MUIV_NList_SetColumnCol_Default,MUIV_NList_SetColumnCol_Default);
1421 else
1422 return(DoSuperMethodA(cl,obj,(Msg) msg));
1423 }
1424
1425 return (0);
1426 }
Mirror of AROS' svn.