rom/intuition/screendepth.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     Change order of screens.
   7 */
   8
   9 #include <proto/graphics.h>
  10
  11 #include "intuition_intern.h"
  12 #include "inputhandler.h"
  13 #include "inputhandler_actions.h"
  14
  15 struct ScreenDepthActionMsg
  16 {
  17     struct IntuiActionMsg    msg;
  18     struct Screen           *screen;
  19     ULONG                    flags;
  20 };
  21
  22 static VOID int_screendepth(struct ScreenDepthActionMsg *msg,
  23                             struct IntuitionBase *IntuitionBase);
  24
  25 /*****************************************************************************
  26
  27     NAME */
  28 #include <proto/intuition.h>
  29
  30     AROS_LH3(void, ScreenDepth,
  31
  32 /*  SYNOPSIS */
  33          AROS_LHA(struct Screen *, screen, A0),
  34          AROS_LHA(ULONG          , flags, D0),
  35          AROS_LHA(APTR           , reserved, A1),
  36
  37 /*  LOCATION */
  38          struct IntuitionBase *, IntuitionBase, 131, Intuition)
  39
  40 /*  FUNCTION
  41     Move the specified screen to the front or back, based on passed flag.
  42     If the screen is in a group, the screen will change its position in
  43     the group only. If the screen is the parent of a group, the whole
  44     group will be moved.
  45
  46     INPUTS
  47     screen - Move this screen.
  48     flags - SDEPTH_TOFRONT or SDEPTH_TOBACK for bringing the screen to
  49         front or back.
  50         If the screen is a child of another screen you may specify
  51         SDEPTH_INFAMILY to move the screen within the family. If
  52         not specified the whole family will move.
  53     reserved - For future use. MUST be NULL by now.
  54
  55     RESULT
  56     None.
  57
  58     NOTES
  59     Only the owner of the screen should use SDEPTH_INFAMILY.
  60     Intentionally commodities should not change the internal arrangement
  61     of screen families.
  62
  63     EXAMPLE
  64
  65     BUGS
  66
  67     SEE ALSO
  68     ScreenToBack(), ScreenToFront()
  69
  70     INTERNALS
  71
  72 *****************************************************************************/
  73 {
  74     AROS_LIBFUNC_INIT
  75
  76     struct ScreenDepthActionMsg msg;
  77
  78     FireScreenNotifyMessageCode((IPTR) screen, flags, SNOTIFY_SCREENDEPTH, IntuitionBase);
  79
  80     if (reserved != NULL) return;
  81     SANITY_CHECK(screen)
  82
  83     msg.screen = screen;
  84     msg.flags  = flags;
  85     DoASyncAction((APTR)int_screendepth, &msg.msg, sizeof(msg), IntuitionBase);
  86
  87     AROS_LIBFUNC_EXIT
  88
  89 } /* ScreenDepth */
  90
  91 /*****************************************************************************************/
  92
  93 static VOID int_screendepth(struct ScreenDepthActionMsg *msg,
  94                             struct IntuitionBase *IntuitionBase)
  95 {
  96     struct Screen   *screen = msg->screen;
  97     ULONG            flags = msg->flags;
  98     ULONG            ilock = LockIBase(0); /* before access to FirstScreen */
  99     struct Screen   *family = NULL,
 100                     *current = IntuitionBase->FirstScreen,
 101 #ifndef __MORPHOS__
 102                     *oldfront = current,
 103 #endif
 104                     *previous = NULL,
 105                     *prefamily = NULL;
 106     struct Window   *win;
 107
 108     /* Find the screen in the list and check for family */
 109     while ( current && current!=screen )
 110     {
 111         if ( flags & SDEPTH_INFAMILY )
 112         {
 113             /* Check if this is the first child in a family */
 114             if ( !family && (GetPrivScreen(current)->SpecialFlags & SF_IsChild) )
 115             {
 116                 family = current;
 117                 prefamily = previous;
 118             }
 119             /* Check if this screen is a child so next one belongs to current family */
 120             if ( family && !(GetPrivScreen(current)->SpecialFlags & SF_IsChild) )
 121             {
 122                 family = NULL;
 123                 prefamily = NULL;
 124             }
 125         }
 126         previous = current;
 127         current = current->NextScreen;
 128     }
 129
 130     if ( current )
 131     {
 132         if ( ! (flags & SDEPTH_TOBACK) ) /* SDEPTH_TOFRONT is #defined as 0 */
 133         {
 134             if ( previous ) /* I'm not the very first screen */
 135             {
 136                 if ( flags & SDEPTH_INFAMILY )
 137                 {
 138                     if ( GetPrivScreen(current)->SpecialFlags & SF_IsChild )
 139                     { /* Move me in the front of my family */
 140                         if ( family ) /* I'm not the first one in my family */
 141                         {
 142                             previous->NextScreen = current->NextScreen;
 143                             current->NextScreen = family;
 144                             if ( prefamily )
 145                             {
 146                                 prefamily->NextScreen = current;
 147                             }
 148                             else
 149                             {
 150                                 IntuitionBase->FirstScreen = current;
 151                             }
 152                         }
 153                     }
 154                     else if ( GetPrivScreen(current)->SpecialFlags & SF_IsParent )
 155                     { /* Move whole family */
 156                         if ( prefamily ) /* We are not the first family */
 157                         {
 158                             prefamily->NextScreen = current->NextScreen;
 159                             current->NextScreen = IntuitionBase->FirstScreen;
 160                             IntuitionBase->FirstScreen = family;
 161                         }
 162                     }
 163                     else
 164                     { /* I have no family */
 165                         previous->NextScreen = current->NextScreen;
 166                         current->NextScreen = IntuitionBase->FirstScreen;
 167                         IntuitionBase->FirstScreen = current;
 168                     }
 169
 170                 } /* SDEPTH_INFAMILY */
 171                 else
 172                 {
 173                     if ( GetPrivScreen(current)->SpecialFlags & (SF_IsChild|SF_IsParent) )
 174                     { /* Move my whole family */
 175                         if ( !family )
 176                         {
 177                             prefamily = previous;
 178                             family = current;
 179                         }
 180                         if ( prefamily )
 181                         { /* We are not the first family */
 182                             while ( !(GetPrivScreen(current)->SpecialFlags & SF_IsParent) )
 183                             {
 184                                 current = current->NextScreen;
 185                             }
 186                             prefamily->NextScreen = current->NextScreen;
 187                             current->NextScreen = IntuitionBase->FirstScreen;
 188                             IntuitionBase->FirstScreen = family;
 189                         }
 190                     }
 191                     else
 192                     { /* I have no family */
 193                         previous->NextScreen = current->NextScreen;
 194                         current->NextScreen = IntuitionBase->FirstScreen;
 195                         IntuitionBase->FirstScreen = current;
 196                     }
 197
 198                 } /* ! SDEPTH_INFAMILY */
 199
 200             } /* if (previous) */
 201
 202         } /* if SDEPTH_TO_FRONT */
 203
 204         else if ( flags & SDEPTH_TOBACK )
 205         {
 206             if ( flags & SDEPTH_INFAMILY )
 207             {
 208                 if ( GetPrivScreen(current)->SpecialFlags & SF_IsChild )
 209                 {
 210                     /* Go to last screen of this family */
 211                     while ( !GetPrivScreen(current->NextScreen)->SpecialFlags & SF_IsParent )
 212                     {
 213                         current = current->NextScreen;
 214                     }
 215                     if ( current != screen ) /* I'm not the last screen of my family */
 216                     {
 217                         if ( previous )
 218                         {
 219                             previous->NextScreen = screen->NextScreen;
 220                         }
 221                         else
 222                         {
 223                             IntuitionBase->FirstScreen = screen->NextScreen;
 224                         }
 225                         screen->NextScreen = current->NextScreen;
 226                         current->NextScreen = screen;
 227                     }
 228                 }
 229                 else if ( GetPrivScreen(current)->SpecialFlags & SF_IsParent )
 230                 {
 231                     if ( current->NextScreen ) /* I'm not the last screen */
 232                     {
 233                         while ( current->NextScreen )
 234                         {
 235                             current = current->NextScreen;
 236                         }
 237                         if ( prefamily )
 238                         {
 239                             prefamily->NextScreen = screen->NextScreen;
 240                         }
 241                         else
 242                         {
 243                             IntuitionBase->FirstScreen = screen->NextScreen;
 244                         }
 245                         if ( family )
 246                         {
 247                             current->NextScreen = family;
 248                         }
 249                         else
 250                         {
 251                             current->NextScreen = screen;
 252                         }
 253                         screen->NextScreen = NULL;
 254                     }
 255                 }
 256                 else
 257                 {
 258                     if ( current->NextScreen ) /* I'm not the last screen */
 259                     {
 260                         while ( current->NextScreen )
 261                         {
 262                             current = current->NextScreen;
 263                         }
 264                         if ( previous )
 265                         {
 266                             previous->NextScreen = screen->NextScreen;
 267                         }
 268                         else
 269                         {
 270                             IntuitionBase->FirstScreen = screen->NextScreen;
 271                         }
 272                         current->NextScreen = screen;
 273                         screen->NextScreen = NULL;
 274                     }
 275                 }
 276
 277             } /* SDEPTH_INFAMILY */
 278             else
 279             {
 280                 struct Screen *last;
 281
 282                 if ( GetPrivScreen(current)->SpecialFlags & (SF_IsChild|SF_IsParent) )
 283                 {
 284                     if ( !family )
 285                     {
 286                         family = current;
 287                         prefamily = previous;
 288                     }
 289                     /* Go to last screen of this family */
 290                     while ( !GetPrivScreen(current)->SpecialFlags & SF_IsParent )
 291                     {
 292                         current = current->NextScreen;
 293                     }
 294                     if ( current->NextScreen ) /* We are not the last family */
 295                     {
 296                         last = current->NextScreen;
 297                         while ( last->NextScreen )
 298                         {
 299                             last = last->NextScreen;
 300                         }
 301                         if ( prefamily )
 302                         {
 303                             prefamily->NextScreen = current->NextScreen;
 304                         }
 305                         else
 306                         {
 307                             IntuitionBase->FirstScreen = current->NextScreen;
 308                         }
 309                         last->NextScreen = family;
 310                         current->NextScreen = NULL;
 311                     }
 312
 313                 } /* if ( GetPrivScreen(current)->SpecialFlags & (SF_IsChild|SF_IsParent) ) */
 314                 else
 315                 {
 316                     if ( current->NextScreen ) /* I'm not the last screen */
 317                     {
 318                         while ( current->NextScreen )
 319                         {
 320                             current = current->NextScreen;
 321                         }
 322                         if ( previous )
 323                         {
 324                             previous->NextScreen = screen->NextScreen;
 325                         }
 326                         else
 327                         {
 328                             IntuitionBase->FirstScreen = screen->NextScreen;
 329                         }
 330                         current->NextScreen = screen;
 331                         screen->NextScreen = NULL;
 332                     }
 333
 334                 } /* current not SF_isChild | SF_IsParent */
 335
 336             } /* ! SDEPTH_INFAMILY */
 337
 338         } /* if SDEPTH_TO_BACK */
 339
 340     } /* if (current) */
 341
 342 #ifdef __MORPHOS__
 343     IntuitionBase->ActiveScreen = IntuitionBase->FirstScreen;
 344     RethinkDisplay();
 345 #else
 346     if (IntuitionBase->FirstScreen != oldfront)
 347     {
 348         SetFrontBitMap(IntuitionBase->FirstScreen->RastPort.BitMap, TRUE);
 349         IntuitionBase->ActiveScreen = IntuitionBase->FirstScreen;
 350     }
 351 #endif
 352
 353     win = NULL;
 354 #if 0 /* FIXME: backport, disabled */
 355     if (IntuitionBase->FirstScreen && GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_SCREENACTIVATION)
 356     {
 357         struct Window *scanw = 0;
 358
 359         for (scanw = IntuitionBase->FirstScreen->FirstWindow; scanw ; scanw = scanw->NextWindow)
 360         {
 361             if (win)
 362             {
 363                 if ((IW(scanw)->activationtime.tv_secs > IW(win)->activationtime.tv_secs) ||
 364                     ((IW(scanw)->activationtime.tv_secs == IW(win)->activationtime.tv_secs) && (IW(scanw)->activationtime.tv_micro > IW(win)->activationtime.tv_micro)))
 365                 {
 366                     win = scanw;
 367                 }
 368             }
 369
 370             if (!win) win = scanw;
 371         }
 372
 373         if (!win) win = IntuitionBase->FirstScreen->FirstWindow;
 374         if (IntuitionBase->ActiveWindow && IntuitionBase->ActiveWindow->WScreen == IntuitionBase->FirstScreen) win = NULL;
 375     }
 376 #endif
 377
 378     /* now set the default pub screen */
 379     /* if the screen is not a public one we just ignore this */
 380
 381     if (IntuitionBase->FirstScreen && GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_DEFPUBSCREEN)
 382     {
 383         if (GetPrivScreen(IntuitionBase->FirstScreen)->pubScrNode && (IntuitionBase->FirstScreen->Flags & (PUBLICSCREEN | WBENCHSCREEN)))
 384         {
 385             GetPrivIBase(IntuitionBase)->DefaultPubScreen = IntuitionBase->FirstScreen;
 386         }
 387     }
 388
 389     UnlockIBase(ilock);
 390
 391     if (win)
 392     {
 393         ActivateWindow(win);
 394     }
 395 }