rom/intuition/displaybeep.c

   1 /*
   2     Copyright © 1995-2003, 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     AROS_LIBBASE_EXT_DECL(struct IntuitionBase *,IntuitionBase)
  60
  61 #if USE_NEWDISPLAYBEEP
  62
  63     BOOL AllScreens = FALSE;
  64     ULONG lock;
  65
  66     //dprintf("INT_DisplayBeep: entry, screen 0x%lx\n", (ULONG) screen);
  67
  68 #ifdef USEWINDOWLOCK
  69     ObtainSemaphore(&GetPrivIBase(IntuitionBase)->WindowLock);
  70 #else
  71     return; //RenderScreenBar NOT safe without this
  72 #endif
  73     //jDc: screenlist will NOT be modified while we hold WINDOWLOCK!
  74     //lock = LockIBase(0);
  75
  76     /* Start Beep */
  77     if (screen == (struct Screen *) -1 || screen == NULL)
  78     {
  79         screen = IntuitionBase->FirstScreen;
  80         AllScreens = TRUE;
  81     }
  82
  83     while (screen)
  84     {
  85         //dprintf("INT_DisplayBeep: screen 0x%lx\n", (ULONG) screen);
  86
  87         if (screen->Flags & BEEPING)
  88         {
  89             GetPrivScreen(screen)->BeepingCounter = BEEPTICKS;
  90         }
  91         else
  92         {
  93             screen->Flags |= BEEPING;
  94
  95             RenderScreenBar(screen, FALSE, IntuitionBase);
  96             //dprintf("INT_DisplayBeep: RenderScreenBar done for screen 0x%lx\n", (ULONG) screen);
  97
  98             GetPrivIBase(IntuitionBase)->BeepingScreens++;
  99             GetPrivScreen(screen)->BeepingCounter = BEEPTICKS;
 100         }
 101
 102         screen =  AllScreens ? screen->NextScreen : NULL;
 103     }
 104
 105     //UnlockIBase(lock);
 106
 107 #ifdef USEWINDOWLOCK
 108     ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->WindowLock);
 109 #endif
 110     //dprintf("INT_DisplayBeep: done\n");
 111
 112 #else /* USE_NEWDISPLAYBEEP */
 113
 114     struct MsgPort      *TimerMsgPort;
 115     struct timerequest  *BeepTimerIO;
 116     BOOL                 VisualBeep = TRUE;
 117     BOOL                 AllScreens = FALSE;
 118     LONG                 NumBeeped = 0;
 119
 120     TimerMsgPort = CreateMsgPort();
 121     if (!TimerMsgPort)
 122     {
 123         return;
 124     }
 125
 126     BeepTimerIO = (struct timerequest *) CreateIORequest (TimerMsgPort, sizeof (struct timerequest));
 127     if (!BeepTimerIO)
 128     {
 129         DeleteMsgPort(TimerMsgPort);
 130         return;
 131     }
 132
 133     if (OpenDevice ("timer.device", UNIT_VBLANK, (struct IORequest *) BeepTimerIO, 0) != 0)
 134     {
 135         DeleteIORequest((struct IORequest *) BeepTimerIO);
 136         DeleteMsgPort(TimerMsgPort);
 137         return;
 138     }
 139
 140     BeepTimerIO->tr_node.io_Command = TR_ADDREQUEST;
 141     BeepTimerIO->tr_time.tv_secs    = 0;
 142     BeepTimerIO->tr_time.tv_micro   = 200000; // 250000
 143
 144
 145     /* Start Beep */
 146     if (VisualBeep)
 147     {
 148         if (screen == (struct Screen *) -1 || screen == NULL)
 149         {
 150             //LockIBase();
 151             screen = IntuitionBase->FirstScreen;
 152             //UnlockIBase();
 153             AllScreens = TRUE;
 154         }
 155
 156         do
 157         {
 158             Forbid();
 159             if (!(screen->Flags & BEEPING))
 160             {
 161                 screen->Flags |= BEEPING;
 162                 Permit();
 163
 164                 if (GetBitMapAttr(screen->RastPort.BitMap, BMA_DEPTH) <= 8)
 165                     // visual beep on CLUT-screen
 166                 {
 167                     /*
 168                     struct DrawInfo *DInfo = NULL;
 169                     UWORD BGPen;
 170                     ULONG color[3];
 171
 172                     DInfo = GetScreenDrawInfo (screen);
 173                     BGPen = DInfo->dri_Pens[BACKGROUNDPEN];
 174                     */
 175
 176                     GetRGB32 (screen->ViewPort.ColorMap, 0, 1, GetPrivScreen(screen)->DisplayBeepColor0);
 177                     screen->SaveColor0 = GetRGB4 (screen->ViewPort.ColorMap, 0);
 178
 179                     SetRGB32 (&screen->ViewPort, 0,
 180                               beepcolor(GetPrivScreen(screen)->DisplayBeepColor0[0]),
 181                               beepcolor(GetPrivScreen(screen)->DisplayBeepColor0[1]),
 182                               beepcolor(GetPrivScreen(screen)->DisplayBeepColor0[2])
 183                              );
 184
 185                     // FreeScreenDrawInfo (screen, DInfo);
 186                 }
 187
 188                 else
 189                     // visual beep on hi- and truecolor screens
 190                 {
 191                     // struct Window *BeepWindow;
 192                     struct TagItem window_tags[] =
 193                     {
 194                         {WA_Left        , 0                                     },
 195                         {WA_Top         , 0                                     },
 196                         {WA_Width       , -1                                    },
 197                         {WA_Height      , -1                                    },
 198                         {WA_Flags       , WFLG_SIMPLE_REFRESH | WFLG_BORDERLESS },
 199                         {WA_CustomScreen, (IPTR) screen                         },
 200                       //{WA_Priority    , 50                                    },  // Place in front of all other windows!
 201                         {TAG_DONE                                               }
 202                     };
 203
 204                     GetPrivScreen(screen)->DisplayBeepWindow = (struct Window *) OpenWindowTagList (NULL, window_tags);
 205                     screen->Flags |= BEEPING;
 206                 }
 207                 NumBeeped++;
 208
 209                 //LockIBase();
 210                 if (AllScreens) screen = screen->NextScreen;
 211                 //UnlockIBase();
 212             }
 213             else
 214                 Permit();
 215
 216         }
 217         while (AllScreens && screen);
 218     }
 219
 220     if (NumBeeped)
 221     {
 222         /* Wait */
 223         DoIO ((struct IORequest *) BeepTimerIO);
 224     }
 225
 226     /* Stop Beep */
 227     if (VisualBeep)
 228     {
 229         if (AllScreens)
 230         {
 231             //LockIBase();
 232             screen = IntuitionBase->FirstScreen;
 233             //UnlockIBase();
 234         }
 235
 236
 237         do
 238         {
 239             Forbid();
 240             if (screen->Flags & BEEPING)
 241             {
 242                 Permit();
 243
 244                 if (GetBitMapAttr(screen->RastPort.BitMap, BMA_DEPTH) <= 8)
 245                     // visual beep on CLUT-screen
 246                 {
 247                     // SetRGB4 (&screen->ViewPort, 0, screen->SaveColor0 & 0x000F, (screen->SaveColor0 & 0x00F0) >> 4, (screen->SaveColor0 & 0x0F00) >> 8);
 248                     SetRGB32 (&screen->ViewPort, 0,
 249                               GetPrivScreen(screen)->DisplayBeepColor0[0],
 250                               GetPrivScreen(screen)->DisplayBeepColor0[1],
 251                               GetPrivScreen(screen)->DisplayBeepColor0[2]
 252                              );
 253                 }
 254                 else
 255                     // visual beep on hi- and truecolor screens
 256                 {
 257                     if (GetPrivScreen(screen)->DisplayBeepWindow)
 258                     {
 259                         CloseWindow (GetPrivScreen(screen)->DisplayBeepWindow);
 260                         GetPrivScreen(screen)->DisplayBeepWindow = NULL;
 261                     }
 262                 }
 263
 264                 screen->Flags &= (UWORD) ~BEEPING;
 265             }
 266             else
 267                 Permit();
 268
 269             //LockIBase();
 270             if (AllScreens) screen = screen->NextScreen;
 271             //UnlockIBase();
 272
 273         }
 274         while (AllScreens && screen);
 275     }
 276
 277     CloseDevice((struct IORequest *) BeepTimerIO);
 278     DeleteIORequest((struct IORequest *) BeepTimerIO);
 279     DeleteMsgPort(TimerMsgPort);
 280
 281     #warning TODO: Make this "multitasking proof"!
 282     #warning TODO: Produce beep according to prefs
 283     #warning TODO: Check if BEEPING flag is handled correctly
 284     #warning TODO: Make BeepWindow 50% transparent! :-)
 285     #warning TODO: Use TimerIO (IntuitionBase->TimerIO) instead of self-made BeepTimerIO?
 286
 287 #endif /* USE_NEWDISPLAYBEEP */
 288
 289     AROS_LIBFUNC_EXIT
 290 } /* DisplayBeep */