?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Prefs/ScreenMode: change the way depth is selected
[AROS.git] / workbench / tools / commodities / DepthMenu.c
blob898f8abf690a34f32c478493ca016fa8d91f43b8
1 /*
2 Copyright © 2007, The AROS Development Team. All rights reserved.
3 $Id$
4
5 DepthMenu commodity -- shows list of window/screens in popupmenu.
6 */
7
8 /******************************************************************************
9
10 NAME
11
12 DepthMenu
13
14 SYNOPSIS
15
16 CX_PRIORITY/N/K
17
18 LOCATION
19
20 SYS:Tools/Commodities
21
22 FUNCTION
23
24 Shows popup menu with list of screens and windows after user clicks on
25 depth gadget of screen or window.
26
27 INPUTS
28
29 CX_PRIORITY -- The priority of the commodity
30
31 RESULT
32
33 NOTES
34
35 EXAMPLE
36
37 BUGS
38
39 SEE ALSO
40
41 INTERNALS
42
43 ******************************************************************************/
44
45 #include <aros/symbolsets.h>
46 #include <intuition/intuition.h>
47 #include <intuition/intuitionbase.h>
48 #include <libraries/commodities.h>
49 #include <libraries/locale.h>
50 #include <proto/exec.h>
51 #include <proto/dos.h>
52 #include <proto/intuition.h>
53 #include <proto/graphics.h>
54 #include <proto/layers.h>
55 #include <proto/commodities.h>
56 #include <proto/input.h>
57 #include <proto/alib.h>
58 #include <proto/locale.h>
59
60 #include <stdio.h>
61 #include <string.h>
62
63 #define DEBUG 0
64 #include <aros/debug.h>
65
66 #define CATCOMP_ARRAY
67 #include "strings.h"
68
69 #define CATALOG_NAME "System/Tools/Commodities.catalog"
70 #define CATALOG_VERSION 3
71
72
73 /***************************************************************************/
74
75 UBYTE version[] = "$VER: DepthMenu 0.3 (30.05.2007)";
76
77 #define ARG_TEMPLATE "CX_PRIORITY=PRI/N/K"
78
79 #define ARG_PRI 0
80 #define NUM_ARGS 1
81
82 #define DM_WINDOW 1
83 #define DM_SCREEN 2
84
85 #define DM_MAXENTRY 15
86 #define DM_MAXSTRLEN 30
87
88 #define DM_BORDERWIDTH 4
89
90 #define SYSGADTYPE(gad) ((gad)->GadgetType & GTYP_SYSTYPEMASK)
91
92 struct Device *InputBase = NULL;
93 struct Catalog *catalog;
94 struct IOStdReq *inputIO;
95
96
97 /* The Depth broker */
98 static struct NewBroker nb =
99 {
100 NB_VERSION,
101 NULL,
102 NULL,
103 NULL,
104 NBU_NOTIFY | NBU_UNIQUE,
105 0,
106 0,
107 NULL,
108 0
109 };
110
111
112 typedef struct _DMState
113 {
114 CxObj *cs_broker;
115 struct MsgPort *cs_msgPort;
116 } DMState;
117
118
119 typedef struct _DMData
120 {
121 struct Window *popupwindow;
122 WORD entries;
123 WORD mode;
124 void *address[DM_MAXENTRY]; // struct Window * or struct Screen *
125 char title[DM_MAXENTRY][DM_MAXSTRLEN];
126 ULONG ibaselock;
127 BOOL locked;
128 WORD selected; // -1 means no entry selected
129 struct DrawInfo *drawinfo;
130 UBYTE bgpen;
131 UBYTE txtpen;
132 UBYTE highpen;
133 UBYTE shinepen;
134 UBYTE shadowpen;
135 } DMData;
136
137 static DMData dmdata;
138
139 /************************************************************************************/
140
141 static void freeResources(DMState *cs);
142 static BOOL initiate(int argc, char **argv, DMState *cs);
143 static void depthMenu(CxMsg *msg, CxObj *co);
144 static void handleMenuUp(CxMsg *cxm);
145 static void handleMenuDown(CxMsg *cxm);
146 static void handleMouseMove(CxMsg *cxm);
147 static void showPopup(WORD mode, struct Screen *screen, WORD xpos, WORD ypos);
148 static void lockIBaseSave(void);
149 static void unlockIBaseSave(void);
150 static CONST_STRPTR _(ULONG id);
151 static BOOL Locale_Initialize(VOID);
152 static VOID Locale_Deinitialize(VOID);
153 static void showSimpleMessage(CONST_STRPTR msgString);
154 static void drawEntry(LONG entry, BOOL selstate);
155 static BOOL depthGadHit(struct Window *window, WORD mousex, WORD mousey);
156
157 /************************************************************************************/
158
159 static CONST_STRPTR _(ULONG id)
160 {
161 if (LocaleBase != NULL && catalog != NULL)
162 {
163 return GetCatalogStr(catalog, id, CatCompArray[id].cca_Str);
164 }
165 else
166 {
167 return CatCompArray[id].cca_Str;
168 }
169 }
170
171 /************************************************************************************/
172
173 static BOOL Locale_Initialize(VOID)
174 {
175 if (LocaleBase != NULL)
176 {
177 catalog = OpenCatalog
178 (
179 NULL, CATALOG_NAME, OC_Version, CATALOG_VERSION, TAG_DONE
180 );
181 }
182 else
183 {
184 catalog = NULL;
185 }
186
187 return TRUE;
188 }
189
190 /************************************************************************************/
191
192 static VOID Locale_Deinitialize(VOID)
193 {
194 if(LocaleBase != NULL && catalog != NULL) CloseCatalog(catalog);
195 }
196
197 /************************************************************************************/
198
199 static void showSimpleMessage(CONST_STRPTR msgString)
200 {
201 struct EasyStruct easyStruct;
202
203 easyStruct.es_StructSize = sizeof(easyStruct);
204 easyStruct.es_Flags = 0;
205 easyStruct.es_Title = _(MSG_DEPTHMENU_CXNAME);
206 easyStruct.es_TextFormat = msgString;
207 easyStruct.es_GadgetFormat = _(MSG_OK);
208
209 if (IntuitionBase != NULL && !Cli() )
210 {
211 EasyRequestArgs(NULL, &easyStruct, NULL, NULL);
212 }
213 else
214 {
215 PutStr(msgString);
216 }
217 }
218
219 /************************************************************************************/
220
221 static BOOL initiate(int argc, char **argv, DMState *cs)
222 {
223 CxObj *customObj;
224
225 memset(cs, 0, sizeof(DMState));
226
227 if (Cli() != NULL)
228 {
229 struct RDArgs *rda;
230 IPTR args[] = { (IPTR) NULL, (IPTR) NULL, FALSE };
231
232 rda = ReadArgs(ARG_TEMPLATE, args, NULL);
233 if (rda != NULL)
234 {
235 if (args[ARG_PRI] != (IPTR) NULL)
236 {
237 nb.nb_Pri = *(LONG *)args[ARG_PRI];
238 }
239 }
240 FreeArgs(rda);
241 }
242 else
243 {
244 UBYTE **array = ArgArrayInit(argc, (UBYTE **)argv);
245 nb.nb_Pri = ArgInt(array, "CX_PRIORITY", 0);
246 ArgArrayDone();
247 }
248
249 nb.nb_Name = _(MSG_DEPTHMENU_CXNAME);
250 nb.nb_Title = _(MSG_DEPTHMENU_CXTITLE);
251 nb.nb_Descr = _(MSG_DEPTHMENU_CXDESCR);
252
253 cs->cs_msgPort = CreateMsgPort();
254 if (cs->cs_msgPort == NULL)
255 {
256 showSimpleMessage(_(MSG_CANT_CREATE_MSGPORT));
257 return FALSE;
258 }
259
260 nb.nb_Port = cs->cs_msgPort;
261 cs->cs_broker = CxBroker(&nb, 0);
262 if (cs->cs_broker == NULL)
263 {
264 return FALSE;
265 }
266
267 customObj = CxCustom(depthMenu, 0);
268 if (customObj == NULL)
269 {
270 showSimpleMessage(_(MSG_CANT_CREATE_MSGPORT));
271 return FALSE;
272 }
273
274 AttachCxObj(cs->cs_broker, customObj);
275 ActivateCxObj(cs->cs_broker, TRUE);
276
277 inputIO = (struct IOStdReq *)CreateIORequest(cs->cs_msgPort,
278 sizeof(struct IOStdReq));
279
280 if (inputIO == NULL)
281 {
282 showSimpleMessage(_(MSG_CANT_ALLOCATE_MEM));
283 return FALSE;
284 }
285
286 if ((OpenDevice("input.device", 0, (struct IORequest *)inputIO, 0)) != 0)
287 {
288 showSimpleMessage(_(MSG_CANT_OPEN_INPUTDEVICE));
289 return FALSE;
290 }
291
292 InputBase = (struct Device *)inputIO->io_Device;
293
294 return TRUE;
295 }
296
297 /************************************************************************************/
298
299 static void freeResources(DMState *cs)
300 {
301 struct Message *cxm;
302
303 if (cs->cs_broker != NULL)
304 {
305 DeleteCxObjAll(cs->cs_broker);
306 }
307
308 if (cs->cs_msgPort != NULL)
309 {
310 while ((cxm = GetMsg(cs->cs_msgPort)))
311 {
312 ReplyMsg(cxm);
313 }
314 DeleteMsgPort(cs->cs_msgPort);
315 }
316
317 if (inputIO != NULL)
318 {
319 CloseDevice((struct IORequest *)inputIO);
320 DeleteIORequest((struct IORequest *)inputIO);
321 }
322 }
323
324 /************************************************************************************/
325
326 static void depthMenu(CxMsg *cxm, CxObj *co)
327 {
328 struct InputEvent *ie = (struct InputEvent *)CxMsgData(cxm);
329 if (ie->ie_Class == IECLASS_RAWMOUSE)
330 {
331 switch (ie->ie_Code)
332 {
333 case MENUDOWN:
334 handleMenuDown(cxm);
335 break;
336 case MENUUP:
337 handleMenuUp(cxm);
338 break;
339 case IECODE_NOBUTTON:
340 handleMouseMove(cxm);
341 break;
342 }
343 }
344 }
345
346 /************************************************************************************/
347
348 static void handleMenuDown(CxMsg *cxm)
349 {
350 struct Screen *screen;
351 struct Layer *layer;
352 struct Window *window;
353
354 dmdata.selected = -1;
355 lockIBaseSave();
356 screen = IntuitionBase->FirstScreen; // frontmost screen
357 LockLayerInfo(&screen->LayerInfo);
358 layer = WhichLayer(&screen->LayerInfo, screen->MouseX, screen->MouseY);
359 UnlockLayerInfo(&screen->LayerInfo);
360
361 if (layer)
362 {
363 if (layer == screen->BarLayer) // Title bar of screen
364 {
365 D(bug("DepthMenu: BarLayer\n"));
366 if (
367 screen->Title
368 && (screen->MouseX > screen->Width - 25) // FIXME real width/pos. of depth gadget
369 && (screen->MouseX < screen->Width)
370 && (screen->MouseY > 0)
371 && (screen->MouseY < screen->BarHeight)
372 )
373 {
374 showPopup(DM_SCREEN, screen, screen->MouseX, screen->MouseY);
375 DisposeCxMsg(cxm);
376 }
377 }
378 else
379 {
380 D(bug("DepthMenu: other Layer\n"));
381 window = layer->Window;
382 if (
383 window
384 && depthGadHit(window, screen->MouseX, screen->MouseY)
385 )
386 {
387 showPopup(DM_WINDOW, screen, screen->MouseX, screen->MouseY);
388 DisposeCxMsg(cxm);
389 }
390 }
391 }
392 unlockIBaseSave();
393 }
394
395 /************************************************************************************/
396
397 static void handleMenuUp(CxMsg *cxm)
398 {
399 if (dmdata.popupwindow)
400 {
401 struct Screen *screen = dmdata.popupwindow->WScreen;
402 {
403 LONG entry = dmdata.selected;
404
405 FreeScreenDrawInfo(screen, dmdata.drawinfo);
406 dmdata.drawinfo = NULL;
407
408 CloseWindow(dmdata.popupwindow);
409 dmdata.popupwindow = NULL;
410
411 D(bug("DepthMenu: selected entry %d\n", entry));
412 if (entry != -1)
413 {
414 if (dmdata.mode == DM_WINDOW)
415 {
416 // does selected window still exist?
417 lockIBaseSave();
418 struct Window *checkwin = screen->FirstWindow;
419 while (checkwin)
420 {
421 if (checkwin == dmdata.address[entry])
422 {
423 unlockIBaseSave();
424 WindowToFront(dmdata.address[entry]);
425 ActivateWindow(dmdata.address[entry]);
426 break;
427 }
428 checkwin = checkwin->NextWindow;
429 }
430 }
431 else
432 {
433 // does selected screen still exist?
434 lockIBaseSave();
435 struct Screen *checkscreen = IntuitionBase->FirstScreen;
436 while (checkscreen)
437 {
438 if (checkscreen == dmdata.address[entry])
439 {
440 unlockIBaseSave();
441 ScreenToFront(dmdata.address[entry]);
442 break;
443 }
444 checkscreen = checkscreen->NextScreen;
445 }
446 }
447 }
448 }
449 // when we release mouse outside window it's still open
450 if (dmdata.popupwindow)
451 {
452 FreeScreenDrawInfo(screen, dmdata.drawinfo);
453 dmdata.drawinfo = NULL;
454 CloseWindow(dmdata.popupwindow);
455 dmdata.popupwindow = NULL;
456 }
457 }
458 unlockIBaseSave();
459 }
460
461 /************************************************************************************/
462
463 static void handleMouseMove(CxMsg *cxm)
464 {
465 if ( ! dmdata.popupwindow) return;
466
467 struct Screen *screen = dmdata.popupwindow->WScreen;
468 LONG entry = -1;
469
470 // are we within popupwindow?
471 if (
472 (screen->MouseX > dmdata.popupwindow->LeftEdge)
473 && (screen->MouseX < dmdata.popupwindow->LeftEdge + dmdata.popupwindow->Width)
474 && (screen->MouseY > dmdata.popupwindow->TopEdge)
475 && (screen->MouseY < dmdata.popupwindow->TopEdge + dmdata.popupwindow->Height)
476 )
477 {
478 entry = (screen->MouseY - dmdata.popupwindow->TopEdge - DM_BORDERWIDTH)
479 / dmdata.popupwindow->RPort->TxHeight;
480 if ((entry < 0) || (entry >= dmdata.entries)) entry = -1;
481 }
482 if (entry != dmdata.selected)
483 {
484 // undraw old entry
485 if (dmdata.selected != -1)
486 {
487 drawEntry(dmdata.selected, FALSE);
488 }
489
490 // draw selected
491 if (entry != -1)
492 {
493 drawEntry(entry, TRUE);
494 }
495 dmdata.selected = entry;
496 }
497 }
498
499 /************************************************************************************/
500
501 static void showPopup(WORD mode, struct Screen *screen, WORD xpos, WORD ypos)
502 {
503 lockIBaseSave();
504
505 // screen for popupmenu, check if it's a public screen
506 struct Screen *popupscreen = screen;
507 if ((popupscreen->Flags & (PUBLICSCREEN | WBENCHSCREEN)) == 0)
508 {
509 bug("DepthMenu: Frontmost screen isn't a public screen\n");
510 return;
511 }
512
513 if ( ! popupscreen->RastPort.Font)
514 {
515 bug("DepthMenu: Frontmost screen doesn't have Font\n");
516 return;
517 }
518
519 if (mode == DM_WINDOW)
520 {
521 D(bug("DepthMenu: window\n"));
522 struct Window *window = screen->FirstWindow;
523 dmdata.entries = 0;
524 while (window && (dmdata.entries < DM_MAXENTRY))
525 {
526 if (window->Title && (window->WScreen == screen))
527 {
528 dmdata.mode = DM_WINDOW;
529 dmdata.address[dmdata.entries] = window;
530 strncpy(dmdata.title[dmdata.entries], window->Title, DM_MAXSTRLEN);
531 dmdata.title[dmdata.entries][DM_MAXSTRLEN - 1] = 0;
532 dmdata.entries++;
533 }
534 window = window->NextWindow;
535 }
536 }
537 else
538 {
539 D(bug("DepthMenu: Screen\n"));
540 dmdata.entries = 0;
541 screen = screen->NextScreen; // Don't add frontmost screen, start with second screen
542 while (screen && (dmdata.entries < DM_MAXENTRY))
543 {
544 if (screen->Title)
545 {
546 dmdata.mode = DM_SCREEN;
547 dmdata.address[dmdata.entries] = screen;
548 strncpy(dmdata.title[dmdata.entries], screen->Title, DM_MAXSTRLEN);
549 dmdata.title[dmdata.entries][DM_MAXSTRLEN - 1] = 0;
550 dmdata.entries++;
551 }
552 screen = screen->NextScreen;
553 }
554 }
555
556 if (dmdata.entries > 0)
557 {
558 // calculate max. text length
559 LONG maxtextwidth = 0;
560 LONG textwidth;
561 int i;
562 for (i=0 ; i < dmdata.entries ; i++)
563 {
564 textwidth = TextLength(&popupscreen->RastPort, dmdata.title[i], strlen(dmdata.title[i]));
565 if (textwidth > maxtextwidth) maxtextwidth = textwidth;
566 }
567
568 LONG width = maxtextwidth + 2 * DM_BORDERWIDTH;
569 LONG height = dmdata.entries * popupscreen->RastPort.TxHeight + 2 * DM_BORDERWIDTH;
570 LONG left = xpos - width / 2;
571 LONG top = ypos - height / 2;
572 if (left < 0) left = 0;
573 if (left + width > popupscreen->Width) left = popupscreen->Width - width;
574 if (top < 0) top = 0;
575 if (top + height > popupscreen->Height) top = popupscreen->Height - height;
576
577 unlockIBaseSave();
578
579 dmdata.popupwindow = OpenWindowTags
580 (
581 NULL,
582 WA_Left, left,
583 WA_Top, top,
584 WA_InnerWidth, width,
585 WA_InnerHeight, height,
586 WA_Borderless, TRUE,
587 WA_Activate, TRUE,
588 WA_SmartRefresh, TRUE,
589 WA_PubScreen, popupscreen,
590 TAG_DONE
591 );
592 if (dmdata.popupwindow)
593 {
594 struct RastPort *rp = dmdata.popupwindow->RPort;
595 SetFont(rp, popupscreen->RastPort.Font); // use the screen's font for the menu
596 // so we can calculate the window size with the screen font
597 SetDrMd(rp, JAM1); // for text rendering
598
599 dmdata.drawinfo = GetScreenDrawInfo(popupscreen);
600 if (dmdata.drawinfo)
601 {
602 dmdata.bgpen = dmdata.drawinfo->dri_Pens[BACKGROUNDPEN];
603 dmdata.txtpen = dmdata.drawinfo->dri_Pens[TEXTPEN];
604 dmdata.highpen = dmdata.drawinfo->dri_Pens[FILLPEN];
605 dmdata.shinepen =dmdata.drawinfo->dri_Pens[SHINEPEN];
606 dmdata.shadowpen = dmdata.drawinfo->dri_Pens[SHADOWPEN];
607 }
608 else
609 {
610 bug("DepthMenu: GetScreenDrawInfo failed\n");
611 dmdata.bgpen = 0;
612 dmdata.txtpen = 1;
613 dmdata.highpen = 3;
614 dmdata.shinepen = 1;
615 dmdata.shadowpen = 1;
616 }
617
618 SetAPen(rp, dmdata.shinepen);
619 Move(rp, width-1, 0);
620 Draw(rp, 0, 0);
621 Draw(rp, 0, height-1);
622 SetAPen(rp, dmdata.shadowpen);
623 Draw(rp, width-1, height-1);
624 Draw(rp, width-1, 0);
625
626 int i;
627 for(i=0; i<dmdata.entries; i++)
628 {
629 drawEntry(i, FALSE);
630 }
631 }
632 else
633 {
634 bug("DepthMenu: Can't open popup window\n");
635 }
636 }
637 }
638
639 /************************************************************************************/
640
641 static void drawEntry(LONG entry, BOOL selstate)
642 {
643 struct RastPort *rp = dmdata.popupwindow->RPort;
644
645 if (selstate)
646 {
647 SetAPen(rp, dmdata.highpen);
648 }
649 else
650 {
651 SetAPen(rp, dmdata.bgpen);
652 }
653 RectFill(rp, DM_BORDERWIDTH, entry * rp->TxHeight + DM_BORDERWIDTH,
654 dmdata.popupwindow->Width - DM_BORDERWIDTH , (entry+1) * rp->TxHeight + DM_BORDERWIDTH);
655
656 SetAPen(rp, dmdata.txtpen);
657 Move(rp, DM_BORDERWIDTH, entry * rp->TxHeight + rp->TxBaseline + DM_BORDERWIDTH);
658 Text(rp, dmdata.title[entry], strlen(dmdata.title[entry]));
659 }
660
661 /************************************************************************************/
662
663 static BOOL depthGadHit(struct Window *window, WORD mousex, WORD mousey)
664 {
665 struct Gadget *gad;
666
667 for(gad = window->FirstGadget; gad; gad = gad->NextGadget)
668 {
669 if ( ! (gad->Flags & GFLG_DISABLED))
670 {
671 WORD x = window->LeftEdge + gad->LeftEdge;
672 WORD y = window->TopEdge + gad->TopEdge;
673 WORD w = gad->Width;
674 WORD h = gad->Height;
675
676 if (gad->Flags & GFLG_RELRIGHT) x += window->Width - 1;
677 if (gad->Flags & GFLG_RELBOTTOM) y += window->Height - 1;
678 if (gad->Flags & GFLG_RELWIDTH) w += window->Width;
679 if (gad->Flags & GFLG_RELHEIGHT) h += window->Height;
680
681 if (
682 (mousex >= x) &&
683 (mousey >= y) &&
684 (mousex < x + w) &&
685 (mousey < y + h)
686 )
687 {
688 if (SYSGADTYPE(gad) == GTYP_WDEPTH)
689 {
690 /* found depth */
691 return TRUE;
692 }
693 }
694 }
695 }
696 return FALSE;
697 }
698
699 /************************************************************************************/
700
701 static void lockIBaseSave(void)
702 {
703 if ( ! dmdata.locked)
704 {
705 dmdata.ibaselock = LockIBase(0);
706 dmdata.locked = TRUE;
707 }
708 }
709
710 /************************************************************************************/
711
712 static void unlockIBaseSave(void)
713 {
714 if (dmdata.locked)
715 {
716 UnlockIBase(dmdata.ibaselock);
717 dmdata.locked = FALSE;
718 }
719 }
720
721 /************************************************************************************/
722
723 static void handleCx(DMState *cs)
724 {
725 CxMsg *msg;
726 BOOL quit = FALSE;
727 LONG signals;
728
729 while (!quit)
730 {
731 signals = Wait((1 << nb.nb_Port->mp_SigBit) | SIGBREAKF_CTRL_C);
732
733 if (signals & (1 << nb.nb_Port->mp_SigBit))
734 {
735 while ((msg = (CxMsg *)GetMsg(cs->cs_msgPort)))
736 {
737 switch (CxMsgType(msg))
738 {
739 case CXM_COMMAND:
740 switch (CxMsgID(msg))
741 {
742 case CXCMD_DISABLE:
743 ActivateCxObj(cs->cs_broker, FALSE);
744 break;
745
746 case CXCMD_ENABLE:
747 ActivateCxObj(cs->cs_broker, TRUE);
748 break;
749
750 case CXCMD_UNIQUE:
751 /* Running the program twice is the same as shutting
752 down the existing program... */
753 /* Fall through */
754
755 case CXCMD_KILL:
756 quit = TRUE;
757 break;
758
759 } /* switch (CxMsgID(msg)) */
760 break;
761 } /* switch (CxMsgType(msg))*/
762
763 ReplyMsg((struct Message *)msg);
764
765 } /* while ((msg = (CxMsg *)GetMsg(cs->cs_msgPort))) */
766 }
767
768 if (signals & SIGBREAKF_CTRL_C)
769 {
770 quit = TRUE;
771 }
772
773 } /* while(!quit) */
774 }
775
776 /************************************************************************************/
777
778 int main(int argc, char **argv)
779 {
780 DMState cState;
781 int error = RETURN_OK;
782
783 if (initiate(argc, argv, &cState))
784 {
785 handleCx(&cState);
786 }
787 else
788 {
789 error = RETURN_FAIL;
790 }
791
792 freeResources(&cState);
793
794 return error;
795 }
796
797 /************************************************************************************/
798
799 ADD2INIT(Locale_Initialize, 90);
800 ADD2EXIT(Locale_Deinitialize, 90);
801
Mirror of AROS' svn.