?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Build fix for x86_64.
[AROS.git] / workbench / tools / BoingIconBar / iconbar.c
blob9ada93894761ce71c38663d8bba5a09be7e92839
1 //////////////////////////////////////////////////////////////
2 // //
3 // AROS PORT by LuKeJerry (at) gmail.com //
4 // Based on the program version with standard window //
5 // + BackFill //
6 // //
7 // -- last update: 26-04-2012 //
8 // - Fixed the notification //
9 // - Use D(bug()) macros //
10 // -------------------------------------------------------- //
11 // //
12 // -- translated to ENG from 26-09-2011 //
13 // -- converted TABs to 4-Spaces //
14 // //
15 // - FIXME: //
16 // //
17 // . When there are more icons than the screen width //
18 // can handle, exceeding icons should appear in the //
19 // next submenu. Seems that icon space is allocated, //
20 // but icon is not appearing //
21 // Look in: Read_Prefs( and SetWindowParameters( //
22 // //
23 // TO DO: //
24 // //
25 // - Even in static mode, put BiB window //
26 // active when mouse cursor goes to very //
27 // bottom of screen //
28 // //
29 // - Add possibility to show icon labels //
30 // - Add support for screennotify //
31 // - Add support for d&d to add an icon to a dock //
32 // - Add commodities CX support //
33 // //
34 //////////////////////////////////////////////////////////////
35
36 #define DEBUG 0
37 #include <aros/debug.h>
38
39 #include <stdio.h>
40 #include <string.h>
41 #include <stdlib.h>
42 #include <proto/workbench.h>
43 #include <proto/icon.h>
44 #include <proto/exec.h>
45 #include <proto/intuition.h>
46 #include <proto/graphics.h>
47 #include <proto/gadtools.h>
48 #include <proto/dos.h>
49 #include <proto/datatypes.h>
50 #include <exec/types.h>
51 #include <exec/libraries.h>
52 #include <workbench/icon.h>
53 #include <workbench/startup.h>
54 #include <intuition/intuition.h>
55 #include <intuition/imageclass.h>
56 #include <datatypes/datatypes.h>
57 #include <datatypes/pictureclass.h>
58 #include <devices/rawkeycodes.h>
59 #include <dos/dos.h>
60
61 #define SUM_ICON 200
62 #define ICON_ACTIVE (1<<7)
63 #define SELECTED_ICON (1<<6)
64
65 #define TEMPLATE "SPACE/N/K,STATIC/N/K,AUTOREMAP/S,BACKGROUND/S"
66 #define ARG_SPACE 0
67 #define ARG_STATIC 1
68 #define ARG_AUTOREMAP 2
69 #define ARG_BACKGROUND 3
70
71 #define BIB_PREFS "ENV:Iconbar.prefs"
72
73 /*****************************************************************************/
74
75 BOOL BiB_Exit = FALSE,
76 Icon_Remap = FALSE,
77 Bar_Background = FALSE,
78 PositionMenuOK = FALSE,
79 Image = FALSE, // <--- FIXME: "Image" seems not used at all
80 Window_Active = FALSE,
81 Window_Open = FALSE,
82 MenuWindow_Open = FALSE,
83 FirstOpening = TRUE;
84
85 int Static = 0,
86 Spacing = 5,
87 CurrentLevel = 0,
88 lbm = 0,
89 rbm = 0;
90
91 int WindowHeight,
92 WindowWidth,
93 ScreenHeight,
94 ScreenWidth,
95 IconWidth,
96 ImageWidth,
97 ImageHeight, // <--- FIXME: ...also: ImageWidth, ImageHeight not used at all
98 Position,
99 OldPosition,
100 IconCounter,
101 LevelCounter,
102 MouseIcon,
103 Lenght,
104 BeginningWindow,
105 EndingWindow,
106 Window_Max_X,
107 Window_Max_Y;
108
109 char version[] = "$VER: BoingIconBar 1.02 (26.04.2012) ©2012 Robert 'Phibrizzo' Krajcarz";
110
111 char Background_name[256], // <-- FIXME: Background_name not used at all,
112 BufferList[20], // but might be interesting to implement
113 MovingTable[8] = {0, 4, 7, 9, 10, 9, 7, 4};
114
115 ULONG WindowMask = 0,
116 MenuMask = 0,
117 WindowSignal;
118
119 IPTR args[] = {(IPTR)&Spacing, (IPTR)&Static, 0, 0};
120
121 /*****************************************************************************/
122
123 struct DiskObject *Icon[SUM_ICON];
124
125 struct Window *Window_struct, *MenuWindow_struct; // FIXME: really ugly _struct names...
126 struct Screen *Screen_struct;
127
128 struct BitMap *BMP_Buffer, *BMP_DoubleBuffer;
129 struct RastPort RP_Buffer, RP_DoubleBuffer;
130
131 // struct of icons
132
133 struct Icon_Struct
134 {
135 int Icon_Height; // icon height
136 int Icon_Width; // icon width
137 int Icon_PositionX; // X position on main window
138 int Icon_PositionY; // Y position on main window
139 int Icon_Status; // status of icon: normal or selected
140 BOOL Icon_OK; // everything OK with icon
141 char Icon_Path[255]; // name to path of icon
142 } Icons_Struct[SUM_ICON];
143
144 // struct of submenu
145
146 struct Level_Struct
147 {
148 char Level_Name[20]; // name submenu - level name
149 int Beginning; // first icon on menu
150 int WindowPos_X; // X position main window
151 int WindowPos_Y; // Y position main window
152 } Levels_Struct[11];
153
154 struct TextAttr Topaz8 = {"topaz.font",8,0,FPF_ROMFONT};
155
156 struct IntuiText Names = {1,0,JAM1,0,0,&Topaz8,BufferList,NULL};
157
158 // background pictures
159
160 Object *picture[3];
161 struct BitMap *bm[3];
162
163 struct Struct_BackgroundData
164 {
165 int Width; // width
166 int Height; // height
167 } BackgroundData[3];
168
169
170 /*****************************************************************************/
171 // functions
172 int ReadPrefs(void); // load prefs
173 void LoadBackground(void); //load background pictures
174 void SetWindowParameters(void); // check window sizes
175 void Decode_IDCMP(struct IntuiMessage *KomIDCMP); // decode IDCMP main signals
176 void Change_State(int Reset); // change icon state
177 void Insert_Icon(int Tryb, int IconNumber); // draw icon
178 void Blink_Icon(int IconNumber); // blink the icon
179 BOOL OpenMainWindow(void); // open main window
180 void CloseMainWindow(void); // close main window
181 void CheckMousePosition(void); // check mouse position
182 void Show_Selected_Level(void); // change the submenu
183 void OpenMenuWindow(void); // open menu window
184 void CloseMenuWindow(void); // close menu window
185 void Decode_IDCMP2(struct IntuiMessage *KomIDCMP); // decode IDCMP menu signals
186 void Launch_Program(char *Program); // start the chosed program
187 void Settings(void); // open the prefs program
188 void Reload_BiB(void); // reload the BiB
189
190
191 /*****************************************************************************/
192
193 int main(int argc, char *argv[])
194 {
195 int x, outt = FALSE;
196
197 struct IntuiMessage *KomIDCMP, KopiaIDCMP;
198 struct RDArgs *rda = NULL;
199 struct DiskObject *dob = NULL;
200 struct NotifyRequest *nr;
201 struct MsgPort *BIBport;
202 BOOL notification = FALSE;
203 BPTR out = BNULL;
204 int result = RETURN_OK;
205
206 // Read arguments
207 if (argc)
208 {
209 // Started from Shell
210 if (!(rda = ReadArgs(TEMPLATE, args, NULL)))
211 {
212 PrintFault(IoErr(), argv[0]);
213 return RETURN_FAIL;
214 }
215
216 if (args[ARG_AUTOREMAP]) Icon_Remap = TRUE;
217
218 if (args[ARG_BACKGROUND]) Bar_Background = TRUE;
219
220 out = Output();
221 } else {
222 // Started from WB: Read ToolTypes
223 struct WBStartup *wbs=(struct WBStartup*)argv;
224 struct WBArg *wba=&wbs->sm_ArgList[wbs->sm_NumArgs-1];
225 BPTR oldcd;
226
227 if (!(*wba->wa_Name))
228 {
229 return RETURN_FAIL;
230 }
231
232 oldcd=CurrentDir(wba->wa_Lock);
233 if ((dob=GetDiskObjectNew(wba->wa_Name)))
234 {
235 char *str;
236
237 if ((str=FindToolType(dob->do_ToolTypes, "SPACE")))
238 *(ULONG*)args[ARG_SPACE]=(ULONG)atoi(str);
239
240 if ((str=FindToolType(dob->do_ToolTypes, "STATIC")))
241 *(ULONG*)args[ARG_STATIC]=(ULONG)atoi(str);
242
243 if ((str=FindToolType(dob->do_ToolTypes, "AUTOREMAP")))
244 Icon_Remap = TRUE;
245 if ((str=FindToolType(dob->do_ToolTypes, "BACKGROUND")))
246 Bar_Background = TRUE;
247 }
248
249 CurrentDir(oldcd);
250 outt = TRUE;
251 }
252
253 if (out || outt)
254 {
255 Spacing = *(LONG*)args[ARG_SPACE];
256 Static = *(LONG*)args[ARG_STATIC];
257 }
258
259
260 D(bug("[IconBar] Specified options: SPACE=%d, STATIC=%d, AUTOREMAP=%d\n", Spacing, Static, Icon_Remap));
261
262 // Read the prefs file, fail if it doesn't exist
263 if(ReadPrefs())
264 {
265 // Set notification of prefs change
266 if ((BIBport = CreateMsgPort()))
267 {
268 if ((nr = AllocMem(sizeof(struct NotifyRequest), MEMF_CLEAR)))
269 {
270 nr->nr_Name = BIB_PREFS;
271
272 D(bug("[IconBar] prefs filename: %s\n",nr->nr_Name));
273
274 nr->nr_Flags = NRF_SEND_MESSAGE;
275 nr->nr_stuff.nr_Signal.nr_Task = FindTask(NULL);
276 nr->nr_stuff.nr_Msg.nr_Port = BIBport;
277
278 if (StartNotify(nr) != DOSFALSE)
279 {
280 notification = TRUE;
281 D(bug("[IconBar] Notification started\n"));
282 }
283 }
284 }
285 if (Bar_Background)
286 LoadBackground();
287
288 if(Static)
289 {
290 Delay(Static * 50);
291 OpenMainWindow();
292 FirstOpening = FALSE;
293 }
294
295 // ---- main loop
296
297 while (BiB_Exit==FALSE)
298 {
299 if(notification)
300 {
301 if (GetMsg(BIBport) != NULL)
302 {
303 D(bug("[IconBar] Prefs modified!\n"));
304 Reload_BiB();
305 }
306 }
307
308 if(Window_Open || MenuWindow_Open)
309 {
310 WindowSignal = Wait(WindowMask | MenuMask);
311
312 if(WindowSignal & WindowMask)
313 {
314 while((KomIDCMP = GT_GetIMsg(Window_struct->UserPort)))
315 {
316 CopyMem(KomIDCMP, &KopiaIDCMP, sizeof(struct IntuiMessage));
317 GT_ReplyIMsg(KomIDCMP);
318 Decode_IDCMP(&KopiaIDCMP);
319 }
320
321 if(!(Static) && Window_Active == FALSE) CloseMainWindow();
322 }
323
324 if(WindowSignal & MenuMask)
325 {
326 while((KomIDCMP = GT_GetIMsg(MenuWindow_struct->UserPort)))
327 {
328 CopyMem(KomIDCMP, &KopiaIDCMP, sizeof(struct IntuiMessage));
329 GT_ReplyIMsg(KomIDCMP);
330 Decode_IDCMP2(&KopiaIDCMP);
331 }
332
333 if(MenuWindow_Open == FALSE) CloseMenuWindow();
334 }
335 } else {
336 Delay(50);
337 CheckMousePosition();
338 }
339 } // ---- end of main loop
340
341 // ---- close all
342 CloseMainWindow();
343
344 for(x=0; x<SUM_ICON; x++)
345 {
346 if(Icon[x] != NULL)
347 {
348 FreeDiskObject(Icon[x]);
349 }
350 }
351
352 if(BMP_Buffer) FreeBitMap(BMP_Buffer);
353 if(BMP_DoubleBuffer) FreeBitMap(BMP_DoubleBuffer);
354
355 for(x=0; x<3; x++)
356 {
357 if(picture[x]) DisposeDTObject(picture[x]);
358 }
359
360 // Close notification of prefs change
361 if(notification)
362 EndNotify(nr);
363 if(nr)
364 FreeMem(nr, sizeof(struct NotifyRequest));
365 if(BIBport)
366 DeleteMsgPort(BIBport);
367
368 } else {
369 D(bug("[IconBar] No prefs found!\n"));
370 result = RETURN_FAIL;
371 }
372 D(bug("[IconBar] Quitting...\n"));
373
374 if (rda) FreeArgs(rda);
375 if (dob) FreeDiskObject(dob);
376 return(result);
377 }
378
379 /*****************************************************************************/
380
381 int ReadPrefs(void)
382 {
383 BPTR Prefs;
384 int x, TextLenght, NumChars;
385
386 Icons_Struct[0].Icon_OK = FALSE;
387 IconCounter = 0;
388 LevelCounter = 0;
389 Lenght = 0;
390
391 if((Prefs = Open(BIB_PREFS, MODE_OLDFILE)))
392 {
393 FGets(Prefs, Icons_Struct[0].Icon_Path, 255);
394
395 if(strncmp(Icons_Struct[0].Icon_Path, "BOING_PREFS", 11) != 0)
396 {
397 Close(Prefs);
398 //FIXME: A better error handling might be added
399 D(bug("[IconBar] Prefs error\n"));
400 return(0);
401 }
402
403 if((Screen_struct = LockPubScreen(NULL)) != NULL)
404 {
405 while (FGets(Prefs, Icons_Struct[IconCounter].Icon_Path, 255))
406 {
407 NumChars = strlen(Icons_Struct[IconCounter].Icon_Path);
408 Icons_Struct[IconCounter].Icon_Path[NumChars-1] = '\0';
409
410 if (Icons_Struct[IconCounter].Icon_Path[0] == ';')
411 {
412 D(bug("[IconBar] Found a submenu! Name lenght = %d, last char = %d\n",
413 NumChars, Icons_Struct[IconCounter].Icon_Path[NumChars-1]));
414
415 if (NumChars > 20) NumChars = 20;
416 Icons_Struct[IconCounter].Icon_Path[19] = '\0';
417
418 for (x=1; x<NumChars; x++)
419 {
420 Levels_Struct[LevelCounter].Level_Name[x-1] = Icons_Struct[IconCounter].Icon_Path[x];
421 }
422
423 D(bug("[IconBar] x after \'for\' = %d\n", x));
424
425 strcpy(BufferList, Levels_Struct[LevelCounter].Level_Name);
426
427 D(bug("[IconBar] Level name: %s\n", Levels_Struct[LevelCounter].Level_Name));
428
429 TextLenght = IntuiTextLength(&Names);
430
431 if (TextLenght > Lenght) Lenght = TextLenght;
432
433 D(bug("[IconBar] IntuiTextLenght = %d\n", TextLenght));
434
435 D(bug("[IconBar] Submenu %d - %s, beginning %d\n",
436 LevelCounter, Levels_Struct[LevelCounter].Level_Name, Levels_Struct[LevelCounter].Beginning));
437
438 Levels_Struct[LevelCounter].Beginning = IconCounter;
439 LevelCounter++;
440 } else {
441 D(bug("[IconBar] Loading icon #%d - name: %s\n", IconCounter, Icons_Struct[IconCounter].Icon_Path));
442
443 if ((Icon[IconCounter] = GetIconTags(Icons_Struct[IconCounter].Icon_Path,
444 ICONGETA_RemapIcon, FALSE,
445 TAG_DONE)))
446 {
447 IconControl(Icon[IconCounter],
448 ICONCTRLA_GetWidth, &Icons_Struct[IconCounter].Icon_Width,
449 ICONCTRLA_GetHeight, &Icons_Struct[IconCounter].Icon_Height,
450 ICONCTRLA_SetNewIconsSupport, TRUE,
451 TAG_END);
452
453 if (Icons_Struct[IconCounter].Icon_Width == 0)
454 {
455 Icons_Struct[IconCounter].Icon_Width = Icon[IconCounter]->do_Gadget.Width;
456 }
457
458 if (Icons_Struct[IconCounter].Icon_Height == 0)
459 {
460 Icons_Struct[IconCounter].Icon_Height = Icon[IconCounter]->do_Gadget.Height;
461 }
462
463 LayoutIcon(Icon[IconCounter], Screen_struct, NULL);
464
465 D(bug("[IconBar] Dimension icon #%d: Widht=%d Height=%d\n",
466 IconCounter, Icons_Struct[IconCounter].Icon_Width, Icons_Struct[IconCounter].Icon_Height));
467
468 D(bug("[IconBar] Icon %d loaded\n", IconCounter));
469
470 Icons_Struct[IconCounter].Icon_OK = TRUE;
471 IconCounter++;
472
473 if (IconCounter == SUM_ICON) break;
474 } else {
475 //FIXME: A better error handling might be added
476 D(bug("[IconBar] Not found icon %s.\n", Icons_Struct[IconCounter].Icon_Path));
477 }
478 }
479 }
480 Close(Prefs);
481
482 ScreenWidth = Screen_struct->Width;
483 ScreenHeight = Screen_struct->Height;
484
485 UnlockPubScreen(NULL, Screen_struct);
486
487 Levels_Struct[LevelCounter].Beginning = IconCounter;
488
489 D(bug("[IconBar] Screen size: Width=%d, Height=%d\n", ScreenWidth, ScreenHeight));
490
491 SetWindowParameters();
492
493 IconCounter = Levels_Struct[1].Beginning;
494 WindowWidth = Levels_Struct[0].WindowPos_X;
495 WindowHeight = Levels_Struct[0].WindowPos_Y;
496
497 BeginningWindow = (ScreenWidth>>1) - (WindowWidth>>1);
498 EndingWindow = (ScreenWidth>>1) + (WindowWidth>>1);
499
500 CurrentLevel = 0;
501
502 sprintf(Levels_Struct[LevelCounter].Level_Name, "Settings");
503 sprintf(Names.IText, "%s", Levels_Struct[LevelCounter].Level_Name);
504
505 TextLenght = IntuiTextLength(&Names);
506
507 if (TextLenght > Lenght) Lenght = TextLenght;
508
509 LevelCounter++;
510
511 Lenght = Lenght + 10;
512 } else {
513 //FIXME: A better error handling might be added
514 D(bug("[IconBar] Error reading screen parameters\n"));
515 }
516 }
517
518 return Icons_Struct[0].Icon_OK;
519 }
520
521 /*****************************************************************************/
522
523 void LoadBackground(void)
524 {
525 int x;
526
527 STRPTR name[3] =
528 {
529 "SYS:System/Images/bibgfx/left" ,
530 "SYS:System/Images/bibgfx/middle",
531 "SYS:System/Images/bibgfx/right"
532 };
533
534 for (x=0; x<3; x++)
535 {
536 picture[x] = NewDTObject (name[x],
537 DTA_GroupID, GID_PICTURE,
538 PDTA_Remap, TRUE,
539 PDTA_DestMode, PMODE_V43,
540 OBP_Precision, PRECISION_IMAGE,
541 PDTA_Screen, (ULONG)Screen_struct,
542 TAG_END);
543
544 if (picture[x])
545 {
546 D(bug("[IconBar] Loading image n. %d - name: %s\n",x,name[x]));
547
548 DoDTMethod(picture[x], NULL, NULL, DTM_PROCLAYOUT, NULL, DTSIF_NEWSIZE);
549
550 GetDTAttrs
551 ( picture[x],
552 PDTA_DestBitMap, (LONG)&bm[x],
553 DTA_NominalHoriz, (LONG)&BackgroundData[x].Width,
554 DTA_NominalVert, (LONG)&BackgroundData[x].Height,
555 TAG_END
556 );
557 }
558 }
559 }
560
561 /*****************************************************************************/
562
563 void SetWindowParameters(void)
564 {
565
566 int x, y;
567
568 Window_Max_X = 0;
569 Window_Max_Y = 0;
570
571 Icons_Struct[0].Icon_PositionX = 0;
572
573 for (y=0; y<(LevelCounter); y++)
574 {
575 WindowHeight = 0;
576 WindowWidth = 0;
577
578 IconCounter = Levels_Struct[y+1].Beginning;
579
580 for (x=Levels_Struct[y].Beginning; x<IconCounter; x++)
581 {
582 if (Icons_Struct[x].Icon_OK)
583 {
584 if (Icons_Struct[x].Icon_Height > WindowHeight)
585 {
586 WindowHeight = Icons_Struct[x].Icon_Height;
587 }
588
589 if (Icons_Struct[x].Icon_Width > IconWidth)
590 {
591 IconWidth = Icons_Struct[x].Icon_Width;
592 }
593
594 if ((WindowWidth + Icons_Struct[x].Icon_Width + 35) > ScreenWidth)
595 {
596 D(bug("[IconBar] Exceeding the size of the screen, can't display all icons!\n"));
597
598 IconCounter = x;
599 Levels_Struct[y+1].Beginning = x;
600 break;
601 }
602
603 WindowWidth = WindowWidth + Icons_Struct[x].Icon_Width + Spacing;
604
605 Icons_Struct[x].Icon_PositionY = 10;
606
607 if ((x+1) != IconCounter)
608 {
609 Icons_Struct[x+1].Icon_PositionX = WindowWidth;
610 }
611 }
612 else break;
613 }
614
615 for (x=Levels_Struct[y].Beginning; x<IconCounter; x++)
616 {
617 if (Icons_Struct[x].Icon_OK)
618 {
619 Icons_Struct[x].Icon_PositionX = Icons_Struct[x].Icon_PositionX + 15;
620 Icons_Struct[x].Icon_PositionY = (WindowHeight>>1) - (Icons_Struct[x].Icon_Height>>1) + 15;
621 }
622 }
623
624 Levels_Struct[y].WindowPos_X = WindowWidth + 30;
625 Levels_Struct[y].WindowPos_Y = WindowHeight + 20;
626
627 if (Levels_Struct[y].WindowPos_X > ScreenWidth)
628 Levels_Struct[y].WindowPos_X = WindowWidth;
629
630 if (Window_Max_X < Levels_Struct[y].WindowPos_X)
631 Window_Max_X = Levels_Struct[y].WindowPos_X;
632
633 if (Window_Max_Y < Levels_Struct[y].WindowPos_Y)
634 Window_Max_Y = Levels_Struct[y].WindowPos_Y;
635
636 D(bug("[IconBar] Window size %d: S=%d, W=%d\n", y, Levels_Struct[y].WindowPos_X, Levels_Struct[y].WindowPos_Y));
637 }
638
639 D(bug("[IconBar] Maximum window size: S=%d, W=%d\n", Window_Max_X, Window_Max_Y));
640 D(bug("[IconBar] Icon width: %d\n", IconWidth));
641
642 if((Screen_struct=LockPubScreen(NULL)) != NULL)
643 {
644 BMP_Buffer = AllocBitMap
645 (
646 Window_Max_X,
647 Window_Max_Y,
648 GetBitMapAttr(Screen_struct->RastPort.BitMap, BMA_DEPTH),
649 BMF_MINPLANES | BMF_CLEAR,
650 Screen_struct->RastPort.BitMap
651 );
652
653 InitRastPort(&RP_Buffer);
654 RP_Buffer.BitMap = BMP_Buffer;
655 RP_Buffer.Layer = NULL;
656
657 BMP_DoubleBuffer = AllocBitMap
658 (
659 IconWidth + 8,
660 Window_Max_Y,
661 GetBitMapAttr(Screen_struct->RastPort.BitMap, BMA_DEPTH),
662 BMF_MINPLANES | BMF_CLEAR,
663 Screen_struct->RastPort.BitMap
664 );
665
666 InitRastPort(&RP_DoubleBuffer);
667 RP_DoubleBuffer.BitMap = BMP_DoubleBuffer;
668 RP_DoubleBuffer.Layer = NULL;
669
670 UnlockPubScreen(NULL,Screen_struct);
671 }
672 }
673
674 /*****************************************************************************/
675
676 void Decode_IDCMP(struct IntuiMessage *KomIDCMP)
677 {
678 int x;
679
680 // LJ: Temporary disabled mouse cases in function Decode_IDCMP
681
682 switch (KomIDCMP->Class)
683 {
684 case IDCMP_CLOSEWINDOW:
685 BiB_Exit = TRUE;
686 break;
687
688 case IDCMP_MOUSEMOVE:
689 for(MouseIcon=Levels_Struct[CurrentLevel].Beginning; MouseIcon<IconCounter; MouseIcon++)
690 {
691 if(Icons_Struct[MouseIcon].Icon_OK)
692 {
693 // too noisy: D(bug("[IconBar] Mouse position in the window X=%d, Y=%d\n",
694 // KomIDCMP->MouseX, KomIDCMP->MouseY));
695
696 if((ScreenHeight - Screen_struct->MouseY) > WindowHeight)
697 {
698 Window_Active = FALSE;
699 }
700
701 if(KomIDCMP->MouseX > Icons_Struct[MouseIcon].Icon_PositionX &&
702 KomIDCMP->MouseX < Icons_Struct[MouseIcon].Icon_PositionX + Icons_Struct[MouseIcon].Icon_Width &&
703 KomIDCMP->MouseY > 0 &&
704 KomIDCMP->MouseY < WindowHeight - 5)
705 {
706 if((Icons_Struct[MouseIcon].Icon_Status & ICON_ACTIVE) != ICON_ACTIVE)
707 {
708 for(x=Levels_Struct[CurrentLevel].Beginning; x<IconCounter; x++)
709 {
710 Icons_Struct[x].Icon_Status = Icons_Struct[x].Icon_Status & 0x07;
711 }
712
713 Icons_Struct[MouseIcon].Icon_Status = ICON_ACTIVE | (SELECTED_ICON * lbm);
714 D(bug("[IconBar] Pointer on icon #%d\n", MouseIcon));
715 }
716 break;
717 }
718 Icons_Struct[MouseIcon].Icon_Status = Icons_Struct[MouseIcon].Icon_Status & 0x07;
719 }
720 }
721 break;
722
723 case IDCMP_MOUSEBUTTONS:
724 switch (KomIDCMP->Code)
725 {
726 case SELECTDOWN:
727 Icons_Struct[MouseIcon].Icon_Status = Icons_Struct[MouseIcon].Icon_Status | SELECTED_ICON;
728 lbm = 1;
729
730 D(bug("[IconBar] Icon #%d\n", MouseIcon));
731 break;
732
733 case SELECTUP:
734 lbm = 0;
735
736 if((Icons_Struct[MouseIcon].Icon_Status & (SELECTED_ICON | ICON_ACTIVE)) == (SELECTED_ICON | ICON_ACTIVE))
737 {
738 Blink_Icon(MouseIcon);
739
740 D(bug("[IconBar] Launching program function with param: %s\n",
741 Icons_Struct[MouseIcon].Icon_Path));
742 Launch_Program(Icons_Struct[MouseIcon].Icon_Path);
743
744 D(bug("[IconBar] Icon #%d confirmed\n", MouseIcon));
745 }
746
747 Icons_Struct[MouseIcon].Icon_Status = Icons_Struct[MouseIcon].Icon_Status & 0xBF; //10001111b
748
749 break;
750
751 case MENUDOWN:
752 rbm = 1;
753 OpenMenuWindow();
754 break;
755 }
756
757 case IDCMP_RAWKEY:
758 switch(KomIDCMP->Code)
759 {
760 case RAWKEY_ESCAPE:
761 if((KomIDCMP->Qualifier) & IEQUALIFIER_LSHIFT)
762 {
763 BiB_Exit = TRUE;
764 }
765 break;
766
767 case RAWKEY_F1:
768 for(x=0; x<SUM_ICON; x++)
769 {
770 if(Icon[x] != NULL)
771 {
772 LayoutIcon(Icon[x],
773 Screen_struct,
774 NULL);
775 }
776 }
777
778 for(x=Levels_Struct[CurrentLevel].Beginning; x<IconCounter; x++)
779 {
780 if(Icon[x] != NULL)
781 {
782 DrawIconState(Window_struct->RPort,
783 Icon[x],
784 NULL,
785 Icons_Struct[x].Icon_PositionX,
786 Icons_Struct[x].Icon_PositionY,
787 IDS_NORMAL,
788 ICONDRAWA_Frameless, TRUE,
789 ICONDRAWA_EraseBackground, FALSE,
790 TAG_DONE);
791 }
792 }
793 break;
794
795 case RAWKEY_F2:
796 case RAWKEY_NM_WHEEL_DOWN:
797 CurrentLevel++;
798 if(CurrentLevel == (LevelCounter -1 )) CurrentLevel = 0;
799 Show_Selected_Level();
800 break;
801
802 case RAWKEY_F3:
803 case RAWKEY_NM_WHEEL_UP:
804 CurrentLevel--;
805 if(CurrentLevel < 0) CurrentLevel = LevelCounter - 2;
806 Show_Selected_Level();
807 break;
808
809 case RAWKEY_F4:
810 Settings();
811 break;
812 }
813 break;
814
815 case IDCMP_INACTIVEWINDOW:
816 if(rbm == 0) Window_Active = FALSE;
817 lbm = 0;
818
819 if(Static)
820 {
821 for(x=Levels_Struct[CurrentLevel].Beginning; x<IconCounter; x++)
822 {
823 if(Icons_Struct[x].Icon_Status != 0)
824 {
825 Icons_Struct[x].Icon_Status = 0;
826 Insert_Icon(IDS_NORMAL, x);
827 }
828 }
829 }
830
831 break;
832
833 case IDCMP_INTUITICKS:
834 Change_State(0);
835 break;
836 }
837
838 }
839
840 void Change_State(int Reset)
841 {
842 int x;
843
844 for(x=Levels_Struct[CurrentLevel].Beginning; x<IconCounter; x++)
845 {
846 if(Icons_Struct[x].Icon_OK)
847 {
848 if(Icons_Struct[x].Icon_Status != 0)
849 {
850 if(Reset == 0)
851 {
852 if((Icons_Struct[x].Icon_Status & ICON_ACTIVE) == 0 && Icons_Struct[x].Icon_Status < 4)
853 {
854 // 11000111b
855 Icons_Struct[x].Icon_Status = (Icons_Struct[x].Icon_Status - 1) & 0xC7;
856 }
857 else
858 {
859 Icons_Struct[x].Icon_Status = (Icons_Struct[x].Icon_Status + 1) & 0xC7;
860 }
861 }
862 else
863 {
864 Icons_Struct[x].Icon_Status = 0;
865 }
866
867 Insert_Icon((Icons_Struct[x].Icon_Status & SELECTED_ICON) ? IDS_SELECTED : IDS_NORMAL, x);
868 }
869 }
870 }
871 }
872
873 void Insert_Icon(int Tryb, int IconNumber)
874 {
875 BltBitMapRastPort(BMP_Buffer,
876 Icons_Struct[IconNumber].Icon_PositionX,
877 0,
878 &RP_DoubleBuffer, //Window_struct->RPort,
879 0, //Icons_Struct[IconNumber].Icon_PositionX,
880 0,
881 Icons_Struct[IconNumber].Icon_Width + 1,
882 WindowHeight,
883 0xC0);
884
885 DrawIconState(&RP_DoubleBuffer, //Window_struct->RPort,
886 Icon[IconNumber],
887 NULL,
888 0, //Icons_Struct[IconNumber].Icon_PositionX,
889 Icons_Struct[IconNumber].Icon_PositionY - MovingTable[(Icons_Struct[IconNumber].Icon_Status & 0x07)],
890 Tryb,
891 ICONDRAWA_Frameless, TRUE,
892 ICONDRAWA_EraseBackground, FALSE,
893 TAG_DONE);
894
895 BltBitMapRastPort(BMP_DoubleBuffer,
896 0,
897 0,
898 Window_struct->RPort,
899 Icons_Struct[IconNumber].Icon_PositionX,
900 0,
901 Icons_Struct[IconNumber].Icon_Width + 1,
902 WindowHeight,
903 0xC0);
904 }
905
906 void Blink_Icon(int IconNumber)
907 {
908 int x, Tryb=IDS_SELECTED;
909
910 for(x=0; x<8; x++)
911 {
912 Insert_Icon(Tryb, IconNumber);
913 Delay(3);
914
915 if(Tryb == IDS_NORMAL) Tryb = IDS_SELECTED;
916 else Tryb = IDS_NORMAL;
917 }
918 }
919
920 BOOL OpenMainWindow(void)
921 {
922 int x, y, a;
923
924 if((Screen_struct=LockPubScreen(NULL)) != NULL)
925 {
926 BltBitMapRastPort(Screen_struct->RastPort.BitMap,
927 (ScreenWidth>>1) - (WindowWidth>>1),
928 ScreenHeight - WindowHeight,
929 &RP_Buffer,
930 0, 0,
931 Window_Max_X,
932 Window_Max_Y,
933 0xC0);
934
935 UnlockPubScreen(NULL,Screen_struct);
936 }
937
938 if(picture[0] && picture[1] && picture[2])
939 {
940 y = WindowWidth - BackgroundData[0].Width - BackgroundData[2].Width;
941 a = y / BackgroundData[1].Width;
942
943 BltBitMapRastPort(bm[0],
944 0,
945 0,
946 &RP_Buffer,
947 0,
948 WindowHeight - BackgroundData[0].Height,
949 BackgroundData[0].Width,
950 BackgroundData[0].Height,
951 0xC0);
952
953 for(x=0; x<a; x++)
954 {
955 BltBitMapRastPort(bm[1],
956 0,
957 0,
958 &RP_Buffer,
959 BackgroundData[0].Width + x * BackgroundData[1].Width,
960 WindowHeight - BackgroundData[1].Height,
961 BackgroundData[1].Width,
962 BackgroundData[1].Height,
963 0xC0);
964 }
965
966 BltBitMapRastPort(bm[1],
967 0,
968 0,
969 &RP_Buffer,
970 BackgroundData[0].Width + x * BackgroundData[1].Width,
971 WindowHeight - BackgroundData[1].Height,
972 y - BackgroundData[1].Width * a,
973 BackgroundData[1].Height,
974 0xC0);
975
976 BltBitMapRastPort(bm[2],
977 0,
978 0,
979 &RP_Buffer,
980 WindowWidth - BackgroundData[2].Width,
981 WindowHeight - BackgroundData[2].Height,
982 BackgroundData[2].Width,
983 BackgroundData[2].Height,
984 0xC0);
985 } else if(picture[1]) {
986 for(x=0; x<WindowWidth; x=x+BackgroundData[1].Width)
987 {
988 BltBitMapRastPort(bm[1],
989 0,
990 0,
991 &RP_Buffer,
992 x,
993 WindowHeight - BackgroundData[1].Height,
994 BackgroundData[1].Width,
995 BackgroundData[1].Height,
996 0xC0);
997 }
998 }
999
1000 if(Icon_Remap == TRUE)
1001 {
1002 D(bug("[IconBar] Iconremap is true!\n"));
1003
1004 for(x=Levels_Struct[CurrentLevel].Beginning; x<IconCounter; x++)
1005 {
1006 if(Icon[x]!=NULL)
1007 {
1008 // D(bug("[Iconbar] Icon#%d-%s was not NULL, so LayoutIcon Adapt a palette-mapped icon to display\n", x, Icons_Struct[x].Icon_Path);
1009 LayoutIcon(Icon[x], Screen_struct, NULL);
1010 }
1011 }
1012 }
1013
1014 D(bug("[IconBar] Opening window: S=%d, W=%d\n", WindowWidth, WindowHeight));
1015
1016 if((Window_struct = OpenWindowTags(NULL,
1017 WA_Left, BeginningWindow,
1018 WA_Top, ScreenHeight - WindowHeight,
1019 WA_InnerWidth, WindowWidth,
1020 WA_InnerHeight, WindowHeight,
1021 WA_ReportMouse, TRUE,
1022 WA_MouseQueue, 3,
1023 WA_Borderless, TRUE,
1024 WA_SizeGadget, FALSE,
1025 WA_Activate, ((FirstOpening && Static) ? FALSE : TRUE),
1026 WA_PubScreenName, NULL,
1027 WA_BackFill, LAYERS_NOBACKFILL,
1028 WA_Flags, WFLG_NOCAREREFRESH|
1029 WFLG_SMART_REFRESH|
1030 WFLG_RMBTRAP,
1031 WA_IDCMP, IDCMP_NEWSIZE|
1032 IDCMP_RAWKEY|
1033 IDCMP_INACTIVEWINDOW|
1034 IDCMP_MOUSEMOVE|
1035 IDCMP_INTUITICKS|
1036 IDCMP_MOUSEBUTTONS,
1037 TAG_END)))
1038 {
1039 D(bug("[IconBar] Window opened\n"));
1040
1041 WindowMask = 1 << Window_struct->UserPort->mp_SigBit;
1042
1043 BltBitMapRastPort(BMP_Buffer,
1044 0, 0,
1045 Window_struct->RPort,
1046 0, 0,
1047 WindowWidth,
1048 WindowHeight,
1049 0xC0);
1050
1051 for(x=Levels_Struct[CurrentLevel].Beginning; x<IconCounter; x++)
1052 {
1053 if(Icon[x] != NULL)
1054 {
1055 DrawIconState(Window_struct->RPort,
1056 Icon[x],
1057 NULL,
1058 Icons_Struct[x].Icon_PositionX,
1059 Icons_Struct[x].Icon_PositionY,
1060 IDS_NORMAL,
1061 ICONDRAWA_Frameless, TRUE,
1062 ICONDRAWA_EraseBackground, FALSE,
1063 TAG_DONE);
1064 }
1065 }
1066 } else {
1067 D(bug("[IconBar] Can't open main toolbar window\n"));
1068 return FALSE;
1069 }
1070
1071 Window_Open = TRUE;
1072 Window_Active = TRUE;
1073
1074 return TRUE;
1075 }
1076
1077 void CloseMainWindow(void)
1078 {
1079 D(bug("[IconBar] ClosingMainWindow...\n"));
1080
1081 int x;
1082
1083 if(Window_struct) CloseWindow(Window_struct);
1084
1085 for(x=Levels_Struct[CurrentLevel].Beginning; x<IconCounter; x++)
1086 {
1087 Icons_Struct[x].Icon_Status = 0;
1088 }
1089
1090 Window_Open = FALSE;
1091 WindowMask = 0;
1092 }
1093
1094 void CheckMousePosition(void)
1095 {
1096 // noisy: D(bug("[IconBar] Mouse current position: Y=%d\n", Screen_struct->MouseY));
1097
1098 if((Screen_struct->MouseY == ScreenHeight - 1) &&
1099 Window_Open == FALSE &&
1100 Screen_struct->MouseX > BeginningWindow &&
1101 Screen_struct->MouseX < EndingWindow)
1102 {
1103 D(bug("[IconBar] Opening the window\n"));
1104 if(OpenMainWindow() == FALSE)
1105 {
1106 BiB_Exit = TRUE;
1107 }
1108 }
1109
1110 // LJ: trying to make window active when going to very bottom of the screen
1111 // even in static mode - but it doesn't work because this code is checked
1112 // only in static=0 mode
1113
1114 else if ((Screen_struct->MouseY == ScreenHeight - 1) &&
1115 Window_Open == TRUE &&
1116 Screen_struct->MouseX > BeginningWindow &&
1117 Screen_struct->MouseX < EndingWindow)
1118 {
1119 D(bug("[IconBar] You're at the very bottom! I should make this window active!\n"));
1120 Window_Active = TRUE;
1121 }
1122 }
1123
1124 void Show_Selected_Level(void)
1125 {
1126 CloseMainWindow();
1127
1128 IconCounter = Levels_Struct[CurrentLevel+1].Beginning;
1129 WindowWidth = Levels_Struct[CurrentLevel].WindowPos_X;
1130 WindowHeight = Levels_Struct[CurrentLevel].WindowPos_Y;
1131 BeginningWindow = (ScreenWidth>>1) - (WindowWidth>>1);
1132 EndingWindow = (ScreenWidth>>1) + (WindowWidth>>1);
1133
1134 //LJ: delay needed for AROS, otherwise garbage from old icons remains
1135 Delay(10); //10 ms seems to be enough
1136
1137 if(OpenMainWindow() == FALSE)
1138 {
1139 BiB_Exit = TRUE;
1140 }
1141 }
1142
1143 void OpenMenuWindow(void)
1144 {
1145 int x;
1146
1147 if((MenuWindow_struct = OpenWindowTags(NULL,
1148 WA_Left, Screen_struct->MouseX,
1149 WA_Top, Screen_struct->MouseY,
1150 WA_InnerWidth, Lenght + 1,
1151 WA_InnerHeight, LevelCounter << 4,
1152 WA_AutoAdjust, TRUE,
1153 WA_ReportMouse, TRUE,
1154 WA_Borderless, TRUE,
1155 WA_IDCMP,IDCMP_MOUSEBUTTONS|
1156 IDCMP_MOUSEMOVE|
1157 IDCMP_INACTIVEWINDOW,
1158 WA_Flags,WFLG_ACTIVATE|
1159 WFLG_RMBTRAP|
1160 WFLG_SMART_REFRESH,
1161 TAG_END)))
1162 {
1163 MenuMask = 1 << MenuWindow_struct->UserPort->mp_SigBit;
1164
1165 SetAPen(MenuWindow_struct->RPort, 1);
1166 Move(MenuWindow_struct->RPort, Lenght, 0);
1167 Draw(MenuWindow_struct->RPort, Lenght, LevelCounter << 4);
1168 Draw(MenuWindow_struct->RPort, 0, LevelCounter << 4);
1169 SetAPen(MenuWindow_struct->RPort, 2);
1170 Draw(MenuWindow_struct->RPort, 0, 0);
1171 Draw(MenuWindow_struct->RPort, Lenght, 0);
1172
1173 SetAPen(MenuWindow_struct->RPort, 1);
1174 Move(MenuWindow_struct->RPort, 0, (LevelCounter - 1) << 4);
1175 Draw(MenuWindow_struct->RPort, Lenght - 1, (LevelCounter - 1) << 4);
1176
1177 SetAPen(MenuWindow_struct->RPort, 2);
1178 Move(MenuWindow_struct->RPort, 0, ((LevelCounter - 1) << 4) + 1);
1179 Draw(MenuWindow_struct->RPort, Lenght - 1, ((LevelCounter - 1) << 4) + 1);
1180
1181 for(x=0; x<LevelCounter; x++)
1182 {
1183 if(x == CurrentLevel) Names.FrontPen = 2;
1184 else Names.FrontPen = 1;
1185
1186 strcpy(BufferList, Levels_Struct[x].Level_Name);
1187
1188 PrintIText(MenuWindow_struct->RPort, &Names, 5, (x << 4) + 5);
1189
1190 D(bug("[IconBar] Level %d: %s\n", x, Levels_Struct[x].Level_Name));
1191 }
1192 MenuWindow_Open = TRUE;
1193 }
1194 else D(bug("[IconBar] Can't open menu\n"));
1195 }
1196
1197 void CloseMenuWindow(void)
1198 {
1199 CloseWindow(MenuWindow_struct);
1200 MenuMask = 0;
1201
1202 if(PositionMenuOK == TRUE)
1203 {
1204 if(Position == (LevelCounter - 1))
1205 {
1206 Settings();
1207 } else {
1208 CurrentLevel = Position;
1209 Show_Selected_Level();
1210 }
1211 }
1212 }
1213
1214 void Decode_IDCMP2(struct IntuiMessage *KomIDCMP)
1215 {
1216 int x, kolA, kolB, dluG, x4;
1217
1218 dluG = Lenght - 2;
1219
1220 switch(KomIDCMP->Class)
1221 {
1222 case IDCMP_MOUSEMOVE:
1223 if(MenuWindow_struct->MouseX > 0 &&
1224 MenuWindow_struct->MouseX < Lenght &&
1225 MenuWindow_struct->MouseY >0)
1226 {
1227 Position = MenuWindow_struct->MouseY >> 4;
1228 }
1229 else
1230 {
1231 Position = 100;
1232 }
1233
1234 if(Position != OldPosition)
1235 {
1236 for(x=0; x<LevelCounter; x++)
1237 {
1238 x4 = (x << 4) + 2;
1239
1240 if(x == Position)
1241 {
1242 kolA = 2;
1243 kolB = 1;
1244 }
1245 else
1246 {
1247 kolA = 0;
1248 kolB = 0;
1249 }
1250
1251 SetAPen(MenuWindow_struct->RPort, kolA);
1252 Move(MenuWindow_struct->RPort, dluG, x4);
1253 Draw(MenuWindow_struct->RPort, dluG, x4 + 13);
1254 Draw(MenuWindow_struct->RPort, 2, x4 + 13);
1255 SetAPen(MenuWindow_struct->RPort, kolB);
1256 Draw(MenuWindow_struct->RPort, 2, x4);
1257 Draw(MenuWindow_struct->RPort, dluG, x4);
1258 }
1259
1260 if(Position != CurrentLevel && Position != 100)
1261 PositionMenuOK = TRUE;
1262 else PositionMenuOK = FALSE;
1263
1264 OldPosition = Position;
1265
1266 D(bug("[IconBar] Menu %d, level %d\n", Position, CurrentLevel));
1267 }
1268 break;
1269
1270 case IDCMP_MOUSEBUTTONS: //LJ: Adding IDCMP_ seems to do the trick...
1271 switch (KomIDCMP->Code)
1272 {
1273 case MENUUP:
1274 MenuWindow_Open = FALSE;
1275 rbm = 0;
1276 break;
1277 }
1278 break;
1279
1280 case IDCMP_INACTIVEWINDOW:
1281 MenuWindow_Open = FALSE;
1282 break;
1283 }
1284 }
1285
1286 void Launch_Program(char *Program)
1287 {
1288 BPTR oldlock;
1289
1290 // Get current directory lock
1291 oldlock = CurrentDir(NULL);
1292
1293 D(bug("[IconBar] Launch_Program %s\n", Program));
1294 OpenWorkbenchObject(Program, TAG_DONE);
1295
1296 // Go back to old directory
1297 CurrentDir(oldlock);
1298 }
1299
1300 void Settings(void)
1301 {
1302 if (!OpenWorkbenchObject("PROGDIR:BIBPrefs", TAG_DONE))
1303 OpenWorkbenchObject("SYS:Prefs/BIBPrefs", TAG_DONE);
1304 }
1305
1306 void Reload_BiB(void)
1307 {
1308 D(bug("[IconBar] Reloading BiB...\n"));
1309
1310 int x;
1311
1312 if (Window_Open == TRUE)
1313 {
1314 D(bug("[IconBar] The Main window is open.. so let's close it...\n"));
1315 CloseMainWindow();
1316 }
1317
1318 for(x=0; x<SUM_ICON; x++)
1319 {
1320 if(Icon[x] != NULL)
1321 {
1322 FreeDiskObject(Icon[x]);
1323 }
1324 Icons_Struct[x].Icon_Height = 0;
1325 Icons_Struct[x].Icon_Width = 0;
1326 Icons_Struct[x].Icon_PositionX = 0;
1327 Icons_Struct[x].Icon_PositionY = 0;
1328 }
1329
1330 if(BMP_Buffer) FreeBitMap(BMP_Buffer);
1331
1332 if(BMP_DoubleBuffer) FreeBitMap(BMP_DoubleBuffer);
1333
1334 if(ReadPrefs() == FALSE)
1335 {
1336 D(bug("[IconBar] Prefs error\n"));
1337 return;
1338 }
1339
1340 if(Static)
1341 {
1342 Delay(Static * 50);
1343 OpenMainWindow();
1344 FirstOpening = FALSE;
1345 }
1346 }
Mirror of AROS' svn.