rom/intuition/displaybeep.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     Copyright © 2001-2003, The MorphOS Development Team. All Rights Reserved.
   4     $Id$
   5 */
   6
   7 #include <proto/graphics.h>
   8 #include "intuition_intern.h"
   9
  10 #define BEEPTICKS       3   /* in 1/10th sec units */
  11
  12 static inline ULONG beepcolor(ULONG x)
  13 {
  14     return x < 0x88888888 ? 0xCCCCCCCC : 0x55555555;
  15 }
  16
  17
  18 /*****************************************************************************
  19
  20     NAME */
  21 #include <proto/intuition.h>
  22
  23 AROS_LH1(void, DisplayBeep,
  24
  25          /*  SYNOPSIS */
  26          AROS_LHA(struct Screen *, screen, A0),
  27
  28          /*  LOCATION */
  29          struct IntuitionBase *, IntuitionBase, 16, Intuition)
  30
  31 /*  FUNCTION
  32     The Amiga has no internal speaker, so it flashes the background
  33     color of the specified screen as a signal. If the argument is
  34     NULL all screens will be flashed.
  35
  36     INPUTS
  37     screen - The Screen that will be flashed.
  38         If NULL all screens will flash.
  39
  40     RESULT
  41
  42     NOTES
  43
  44     EXAMPLE
  45
  46     BUGS
  47
  48     SEE ALSO
  49
  50     INTERNALS
  51     Hardware with a speaker should make an audible beep, too.
  52     Maybe even leave out the flashing on those architectures.
  53
  54     HISTORY
  55
  56 *****************************************************************************/
  57 {
  58     AROS_LIBFUNC_INIT
  59
  60 #if USE_NEWDISPLAYBEEP
  61
  62     BOOL AllScreens = FALSE;
  63     ULONG lock;
  64
  65     //dprintf("INT_DisplayBeep: entry, screen 0x%lx\n", (ULONG) screen);
  66
  67 #ifdef USEWINDOWLOCK
  68     ObtainSemaphore(&GetPrivIBase(IntuitionBase)->WindowLock);
  69 #else
  70     return; //RenderScreenBar NOT safe without this
  71 #endif
  72     //jDc: screenlist will NOT be modified while we hold WINDOWLOCK!
  73     //lock = LockIBase(0);
  74
  75     /* Start Beep */
  76     if (screen == (struct Screen *) -1 || screen == NULL)
  77     {
  78         screen = IntuitionBase->FirstScreen;
  79         AllScreens = TRUE;
  80     }
  81
  82     while (screen)
  83     {
  84         //dprintf("INT_DisplayBeep: screen 0x%lx\n", (ULONG) screen);
  85
  86         if (screen->Flags & BEEPING)
  87         {
  88             GetPrivScreen(screen)->BeepingCounter = BEEPTICKS;
  89         }
  90         else
  91         {
  92             screen->Flags |= BEEPING;
  93
  94             RenderScreenBar(screen, FALSE, IntuitionBase);
  95             //dprintf("INT_DisplayBeep: RenderScreenBar done for screen 0x%lx\n", (ULONG) screen);
  96
  97             GetPrivIBase(IntuitionBase)->BeepingScreens++;
  98             GetPrivScreen(screen)->BeepingCounter = BEEPTICKS;
  99         }
 100
 101         screen =  AllScreens ? screen->NextScreen : NULL;
 102     }
 103
 104     //UnlockIBase(lock);
 105
 106 #ifdef USEWINDOWLOCK
 107     ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->WindowLock);
 108 #endif
 109     //dprintf("INT_DisplayBeep: done\n");
 110
 111 #else /* USE_NEWDISPLAYBEEP */
 112
 113     struct MsgPort      *TimerMsgPort;
 114     struct timerequest  *BeepTimerIO;
 115     BOOL                 VisualBeep = TRUE;
 116     BOOL                 AllScreens = FALSE;
 117     LONG                 NumBeeped = 0;
 118
 119     TimerMsgPort = CreateMsgPort();
 120     if (!TimerMsgPort)
 121     {
 122         return;
 123     }
 124
 125     BeepTimerIO = (struct timerequest *) CreateIORequest (TimerMsgPort, sizeof (struct timerequest));
 126     if (!BeepTimerIO)
 127     {
 128         DeleteMsgPort(TimerMsgPort);
 129         return;
 130     }
 131
 132     if (OpenDevice ("timer.device", UNIT_VBLANK, (struct IORequest *) BeepTimerIO, 0) != 0)
 133     {
 134         DeleteIORequest((struct IORequest *) BeepTimerIO);
 135         DeleteMsgPort(TimerMsgPort);
 136         return;
 137     }
 138
 139     BeepTimerIO->tr_node.io_Command = TR_ADDREQUEST;
 140     BeepTimerIO->tr_time.tv_secs    = 0;
 141     BeepTimerIO->tr_time.tv_micro   = 200000; // 250000
 142
 143
 144     /* Start Beep */
 145     if (VisualBeep)
 146     {
 147         if (screen == (struct Screen *) -1 || screen == NULL)
 148         {
 149             //LockIBase();
 150             screen = IntuitionBase->FirstScreen;
 151             //UnlockIBase();
 152             AllScreens = TRUE;
 153         }
 154
 155         do
 156         {
 157             Forbid();
 158             if (!(screen->Flags & BEEPING))
 159             {
 160                 screen->Flags |= BEEPING;
 161                 Permit();
 162
 163                 if (GetBitMapAttr(screen->RastPort.BitMap, BMA_DEPTH) <= 8)
 164                     // visual beep on CLUT-screen
 165                 {
 166                     /*
 167                     struct DrawInfo *DInfo = NULL;
 168                     UWORD BGPen;
 169                     ULONG color[3];
 170
 171                     DInfo = GetScreenDrawInfo (screen);
 172                     BGPen = DInfo->dri_Pens[BACKGROUNDPEN];
 173                     */
 174
 175                     GetRGB32 (screen->ViewPort.ColorMap, 0, 1, GetPrivScreen(screen)->DisplayBeepColor0);
 176                     screen->SaveColor0 = GetRGB4 (screen->ViewPort.ColorMap, 0);
 177
 178                     SetRGB32 (&screen->ViewPort, 0,
 179                               beepcolor(GetPrivScreen(screen)->DisplayBeepColor0[0]),
 180                               beepcolor(GetPrivScreen(screen)->DisplayBeepColor0[1]),
 181                               beepcolor(GetPrivScreen(screen)->DisplayBeepColor0[2])
 182                              );
 183
 184                     // FreeScreenDrawInfo (screen, DInfo);
 185                 }
 186
 187                 else
 188                     // visual beep on hi- and truecolor screens
 189                 {
 190                     // struct Window *BeepWindow;
 191                     struct TagItem window_tags[] =
 192                     {
 193                         {WA_Left        , 0                                     },
 194                         {WA_Top         , 0                                     },
 195                         {WA_Width       , -1                                    },
 196                         {WA_Height      , -1                                    },
 197                         {WA_Flags       , WFLG_SIMPLE_REFRESH | WFLG_BORDERLESS },
 198                         {WA_CustomScreen, (IPTR) screen                         },
 199                       //{WA_Priority    , 50                                    },  // Place in front of all other windows!
 200                         {TAG_DONE                                               }
 201                     };
 202
 203                     GetPrivScreen(screen)->DisplayBeepWindow = (struct Window *) OpenWindowTagList (NULL, window_tags);
 204                     screen->Flags |= BEEPING;
 205                 }
 206                 NumBeeped++;
 207
 208                 //LockIBase();
 209                 if (AllScreens) screen = screen->NextScreen;
 210                 //UnlockIBase();
 211             }
 212             else
 213                 Permit();
 214
 215         }
 216         while (AllScreens && screen);
 217     }
 218
 219     if (NumBeeped)
 220     {
 221         /* Wait */
 222         DoIO ((struct IORequest *) BeepTimerIO);
 223     }
 224
 225     /* Stop Beep */
 226     if (VisualBeep)
 227     {
 228         if (AllScreens)
 229         {
 230             //LockIBase();
 231             screen = IntuitionBase->FirstScreen;
 232             //UnlockIBase();
 233         }
 234
 235
 236         do
 237         {
 238             Forbid();
 239             if (screen->Flags & BEEPING)
 240             {
 241                 Permit();
 242
 243                 if (GetBitMapAttr(screen->RastPort.BitMap, BMA_DEPTH) <= 8)
 244                     // visual beep on CLUT-screen
 245                 {
 246                     // SetRGB4 (&screen->ViewPort, 0, screen->SaveColor0 & 0x000F, (screen->SaveColor0 & 0x00F0) >> 4, (screen->SaveColor0 & 0x0F00) >> 8);
 247                     SetRGB32 (&screen->ViewPort, 0,
 248                               GetPrivScreen(screen)->DisplayBeepColor0[0],
 249                               GetPrivScreen(screen)->DisplayBeepColor0[1],
 250                               GetPrivScreen(screen)->DisplayBeepColor0[2]
 251                              );
 252                 }
 253                 else
 254                     // visual beep on hi- and truecolor screens
 255                 {
 256                     if (GetPrivScreen(screen)->DisplayBeepWindow)
 257                     {
 258                         CloseWindow (GetPrivScreen(screen)->DisplayBeepWindow);
 259                         GetPrivScreen(screen)->DisplayBeepWindow = NULL;
 260                     }
 261                 }
 262
 263                 screen->Flags &= (UWORD) ~BEEPING;
 264             }
 265             else
 266                 Permit();
 267
 268             //LockIBase();
 269             if (AllScreens) screen = screen->NextScreen;
 270             //UnlockIBase();
 271
 272         }
 273         while (AllScreens && screen);
 274     }
 275
 276     CloseDevice((struct IORequest *) BeepTimerIO);
 277     DeleteIORequest((struct IORequest *) BeepTimerIO);
 278     DeleteMsgPort(TimerMsgPort);
 279
 280     #warning TODO: Make this "multitasking proof"!
 281     #warning TODO: Produce beep according to prefs
 282     #warning TODO: Check if BEEPING flag is handled correctly
 283     #warning TODO: Make BeepWindow 50% transparent! :-)
 284     #warning TODO: Use TimerIO (IntuitionBase->TimerIO) instead of self-made BeepTimerIO?
 285
 286 #endif /* USE_NEWDISPLAYBEEP */
 287
 288     AROS_LIBFUNC_EXIT
 289 } /* DisplayBeep */