arch/.unmaintained/hidd/activescreen.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <proto/exec.h>
   7 #include <proto/intuition.h>
   8 #include <proto/arossupport.h>
   9 #include <proto/alib.h>
  10
  11 #include <exec/memory.h>
  12 #include <exec/tasks.h>
  13 #include <exec/ports.h>
  14
  15 #include <dos/dos.h>
  16
  17 #include "macros.h"
  18
  19 // #include <oop/oop.h>
  20
  21 /* Hack: prevent hidd/graphics.h from beeing included */
  22 // #include "graphics_internal.h"
  23
  24
  25 VOID activescreen_taskentry();
  26
  27 struct activescreen_msg {
  28     struct Message message;
  29     OOP_Object *bmobj;
  30 };
  31
  32
  33 static struct Task *activescreen_task = NULL;
  34 static struct Task *parent_task = NULL;
  35 static struct MsgPort *activescreen_msgport = NULL;
  36
  37 static ULONG oksig      = SIGBREAKF_CTRL_E;
  38 static ULONG failsig    = SIGBREAKF_CTRL_D;
  39 static ULONG killsig    = SIGBREAKF_CTRL_C;
  40
  41 static struct ExecBase *sysbase = NULL;
  42
  43
  44 static BOOL send_activescreen_msg( Object *bmobj, struct ExecBase *SysBase)
  45 {
  46     /* Allocate a new message */
  47     struct activescreen_msg *msg;
  48
  49     msg = AllocMem(sizeof (*msg), MEMF_PUBLIC | MEMF_CLEAR);
  50     if (NULL == msg)
  51         return FALSE;
  52
  53     msg->bmobj = bmobj;
  54     PutMsg(activescreen_msgport, (struct Message *)msg);
  55
  56     return TRUE;
  57 }
  58
  59
  60 VOID activatebm_callback(APTR data, OOP_Object *bmobj, BOOL activated)
  61 {
  62
  63     struct GfxBase *GfxBase;
  64
  65     GfxBase = (struct GfxBase *)data;
  66
  67     if (!activated)
  68         return;
  69
  70     /* We must send it to some task that can handle this.
  71        We should NOT use LockIBase() inside here, since we might
  72        have locked layers also. So we instead send it to some othe task
  73     */
  74
  75     if (!send_activescreen_msg(bmobj, SysBase)) {
  76         kprintf("!!! activatebm_callback: Could not send activatescreen message !!!!\n");
  77     }
  78
  79     return;
  80
  81 }
  82
  83 BOOL init_activescreen_stuff(struct GfxBase *GfxBase)
  84 {
  85
  86     BOOL ok = FALSE;
  87     sysbase = SysBase;
  88
  89 kprintf("init_activescreen_stuff\n");
  90
  91     parent_task = FindTask(NULL);
  92
  93     /* Create the task */
  94     activescreen_task = CreateTask("Active screen updating task"
  95         , 40
  96         , activescreen_taskentry
  97         , 4096
  98     );
  99
 100     if (NULL != activescreen_task) {
 101         ULONG sigs;
 102
 103         kprintf("Task created\n");
 104
 105         sigs = Wait(oksig | failsig);
 106         kprintf("Got sig: %d\n", sigs);
 107         if (sigs & oksig) {
 108              ok = TRUE;
 109         }
 110     }
 111
 112     return ok;
 113
 114 }
 115
 116 VOID cleanup_activescreen_stuff(struct GfxBase *GfxBase)
 117 {
 118     /* Kill the task. Note that this
 119        may cause race condition problems
 120        if some task continues to send messages to the task
 121      */
 122     Signal(activescreen_task, killsig);
 123
 124 }
 125
 126 #undef SysBase
 127 #define SysBase sysbase
 128
 129 VOID activescreen_taskentry()
 130 {
 131     /* Create the msg port */
 132     struct IntuitionBase *IntuitionBase = NULL;
 133     BOOL ok = FALSE;
 134
 135     activescreen_msgport = CreateMsgPort();
 136     if (NULL != activescreen_msgport) {
 137         IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 0);
 138         if (NULL != IntuitionBase) {
 139              ok = TRUE;
 140         } else {
 141             kprintf("activescreen_task: Could not open intuition\n");
 142         }
 143     } else {
 144         kprintf("activescreen_task: Could not create msgport\n");
 145     }
 146
 147     if (!ok) {
 148         /* Signal failure to the creating task */
 149         Signal(parent_task, failsig);
 150
 151     } else {
 152         ULONG portsig;
 153         BOOL done = FALSE;
 154
 155         Signal(parent_task, oksig);
 156
 157         portsig = 1L << activescreen_msgport->mp_SigBit;
 158
 159         /* Go into endeless loop handling the messages */
 160         while (!done) {
 161
 162             struct activescreen_msg *msg;
 163
 164             ULONG sigs;
 165
 166             if ((msg = (struct activescreen_msg *)GetMsg(activescreen_msgport))) {
 167                 struct Screen *scr;
 168
 169                 /* Handle the message. Go through the screen list
 170                    and find the screen that uses the supplied HIDD bitmap
 171                    object
 172                 */
 173                 LockIBase(0UL);
 174
 175                 for (scr = IntuitionBase->FirstScreen; NULL != scr; scr = scr->NextScreen) {
 176
 177                     /* Get the hidd object */
 178                     if (msg->bmobj == HIDD_BM_OBJ(scr->RastPort.BitMap)) {
 179
 180                         kprintf("Active screen found: %s\n", scr->Title);
 181
 182                         IntuitionBase->ActiveScreen = scr;
 183
 184                     }
 185                 }
 186
 187                 UnlockIBase(0UL);
 188
 189                 /* We do not reply the message, but instead free it here. */
 190                 FreeMem(msg, sizeof (*msg));
 191
 192             } else {
 193                 sigs = Wait(portsig | killsig);
 194             }
 195             if (sigs & killsig) {
 196                 /* Get outstanding messages */
 197                 while ((msg = (struct activescreen_msg *)GetMsg(activescreen_msgport)))
 198                         FreeMem(msg, sizeof (*msg));
 199                 done = TRUE;
 200             }
 201
 202         } /* while */
 203
 204     } /* if (ok) */
 205
 206     if (NULL != IntuitionBase)
 207         CloseLibrary((struct Library *)IntuitionBase);
 208
 209     if (NULL != activescreen_msgport)
 210         DeleteMsgPort(activescreen_msgport);
 211
 212 }
 213