rom/intuition/screendepth.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     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     AROS_LIBBASE_EXT_DECL(struct IntuitionBase *,IntuitionBase)
  76
  77     struct ScreenDepthActionMsg msg;
  78
  79     FireScreenNotifyMessageCode((IPTR) screen, flags, SNOTIFY_SCREENDEPTH, IntuitionBase);
  80
  81     if (reserved != NULL) return;
  82     SANITY_CHECK(screen)
  83
  84     msg.screen = screen;
  85     msg.flags  = flags;
  86     DoASyncAction((APTR)int_screendepth, &msg.msg, sizeof(msg), IntuitionBase);
  87
  88     AROS_LIBFUNC_EXIT
  89
  90 } /* ScreenDepth */
  91
  92 /*****************************************************************************************/
  93
  94 static VOID int_screendepth(struct ScreenDepthActionMsg *msg,
  95                             struct IntuitionBase *IntuitionBase)
  96 {
  97     struct Screen   *screen = msg->screen;
  98     ULONG            flags = msg->flags;
  99     ULONG            ilock = LockIBase(0); /* before access to FirstScreen */
 100     struct Screen   *family = NULL,
 101                     *current = IntuitionBase->FirstScreen,
 102 #ifndef __MORPHOS__
 103                     *oldfront = current,
 104 #endif
 105                     *previous = NULL,
 106                     *prefamily = NULL;
 107     struct Window   *win;
 108
 109     /* Find the screen in the list and check for family */
 110     while ( current && current!=screen )
 111     {
 112         if ( flags & SDEPTH_INFAMILY )
 113         {
 114             /* Check if this is the first child in a family */
 115             if ( !family && (GetPrivScreen(current)->SpecialFlags & SF_IsChild) )
 116             {
 117                 family = current;
 118                 prefamily = previous;
 119             }
 120             /* Check if this screen is a child so next one belongs to current family */
 121             if ( family && !(GetPrivScreen(current)->SpecialFlags & SF_IsChild) )
 122             {
 123                 family = NULL;
 124                 prefamily = NULL;
 125             }
 126         }
 127         previous = current;
 128         current = current->NextScreen;
 129     }
 130
 131     if ( current )
 132     {
 133         if ( ! (flags & SDEPTH_TOBACK) ) /* SDEPTH_TOFRONT is #defined as 0 */
 134         {
 135             if ( previous ) /* I'm not the very first screen */
 136             {
 137                 if ( flags & SDEPTH_INFAMILY )
 138                 {
 139                     if ( GetPrivScreen(current)->SpecialFlags & SF_IsChild )
 140                     { /* Move me in the front of my family */
 141                         if ( family ) /* I'm not the first one in my family */
 142                         {
 143                             previous->NextScreen = current->NextScreen;
 144                             current->NextScreen = family;
 145                             if ( prefamily )
 146                             {
 147                                 prefamily->NextScreen = current;
 148                             }
 149                             else
 150                             {
 151                                 IntuitionBase->FirstScreen = current;
 152                             }
 153                         }
 154                     }
 155                     else if ( GetPrivScreen(current)->SpecialFlags & SF_IsParent )
 156                     { /* Move whole family */
 157                         if ( prefamily ) /* We are not the first family */
 158                         {
 159                             prefamily->NextScreen = current->NextScreen;
 160                             current->NextScreen = IntuitionBase->FirstScreen;
 161                             IntuitionBase->FirstScreen = family;
 162                         }
 163                     }
 164                     else
 165                     { /* I have no family */
 166                         previous->NextScreen = current->NextScreen;
 167                         current->NextScreen = IntuitionBase->FirstScreen;
 168                         IntuitionBase->FirstScreen = current;
 169                     }
 170
 171                 } /* SDEPTH_INFAMILY */
 172                 else
 173                 {
 174                     if ( GetPrivScreen(current)->SpecialFlags & (SF_IsChild|SF_IsParent) )
 175                     { /* Move my whole family */
 176                         if ( !family )
 177                         {
 178                             prefamily = previous;
 179                             family = current;
 180                         }
 181                         if ( prefamily )
 182                         { /* We are not the first family */
 183                             while ( !(GetPrivScreen(current)->SpecialFlags & SF_IsParent) )
 184                             {
 185                                 current = current->NextScreen;
 186                             }
 187                             prefamily->NextScreen = current->NextScreen;
 188                             current->NextScreen = IntuitionBase->FirstScreen;
 189                             IntuitionBase->FirstScreen = family;
 190                         }
 191                     }
 192                     else
 193                     { /* I have no family */
 194                         previous->NextScreen = current->NextScreen;
 195                         current->NextScreen = IntuitionBase->FirstScreen;
 196                         IntuitionBase->FirstScreen = current;
 197                     }
 198
 199                 } /* ! SDEPTH_INFAMILY */
 200
 201             } /* if (previous) */
 202
 203         } /* if SDEPTH_TO_FRONT */
 204
 205         else if ( flags & SDEPTH_TOBACK )
 206         {
 207             if ( flags & SDEPTH_INFAMILY )
 208             {
 209                 if ( GetPrivScreen(current)->SpecialFlags & SF_IsChild )
 210                 {
 211                     /* Go to last screen of this family */
 212                     while ( !GetPrivScreen(current->NextScreen)->SpecialFlags & SF_IsParent )
 213                     {
 214                         current = current->NextScreen;
 215                     }
 216                     if ( current != screen ) /* I'm not the last screen of my family */
 217                     {
 218                         if ( previous )
 219                         {
 220                             previous->NextScreen = screen->NextScreen;
 221                         }
 222                         else
 223                         {
 224                             IntuitionBase->FirstScreen = screen->NextScreen;
 225                         }
 226                         screen->NextScreen = current->NextScreen;
 227                         current->NextScreen = screen;
 228                     }
 229                 }
 230                 else if ( GetPrivScreen(current)->SpecialFlags & SF_IsParent )
 231                 {
 232                     if ( current->NextScreen ) /* I'm not the last screen */
 233                     {
 234                         while ( current->NextScreen )
 235                         {
 236                             current = current->NextScreen;
 237                         }
 238                         if ( prefamily )
 239                         {
 240                             prefamily->NextScreen = screen->NextScreen;
 241                         }
 242                         else
 243                         {
 244                             IntuitionBase->FirstScreen = screen->NextScreen;
 245                         }
 246                         if ( family )
 247                         {
 248                             current->NextScreen = family;
 249                         }
 250                         else
 251                         {
 252                             current->NextScreen = screen;
 253                         }
 254                         screen->NextScreen = NULL;
 255                     }
 256                 }
 257                 else
 258                 {
 259                     if ( current->NextScreen ) /* I'm not the last screen */
 260                     {
 261                         while ( current->NextScreen )
 262                         {
 263                             current = current->NextScreen;
 264                         }
 265                         if ( previous )
 266                         {
 267                             previous->NextScreen = screen->NextScreen;
 268                         }
 269                         else
 270                         {
 271                             IntuitionBase->FirstScreen = screen->NextScreen;
 272                         }
 273                         current->NextScreen = screen;
 274                         screen->NextScreen = NULL;
 275                     }
 276                 }
 277
 278             } /* SDEPTH_INFAMILY */
 279             else
 280             {
 281                 struct Screen *last;
 282
 283                 if ( GetPrivScreen(current)->SpecialFlags & (SF_IsChild|SF_IsParent) )
 284                 {
 285                     if ( !family )
 286                     {
 287                         family = current;
 288                         prefamily = previous;
 289                     }
 290                     /* Go to last screen of this family */
 291                     while ( !GetPrivScreen(current)->SpecialFlags & SF_IsParent )
 292                     {
 293                         current = current->NextScreen;
 294                     }
 295                     if ( current->NextScreen ) /* We are not the last family */
 296                     {
 297                         last = current->NextScreen;
 298                         while ( last->NextScreen )
 299                         {
 300                             last = last->NextScreen;
 301                         }
 302                         if ( prefamily )
 303                         {
 304                             prefamily->NextScreen = current->NextScreen;
 305                         }
 306                         else
 307                         {
 308                             IntuitionBase->FirstScreen = current->NextScreen;
 309                         }
 310                         last->NextScreen = family;
 311                         current->NextScreen = NULL;
 312                     }
 313
 314                 } /* if ( GetPrivScreen(current)->SpecialFlags & (SF_IsChild|SF_IsParent) ) */
 315                 else
 316                 {
 317                     if ( current->NextScreen ) /* I'm not the last screen */
 318                     {
 319                         while ( current->NextScreen )
 320                         {
 321                             current = current->NextScreen;
 322                         }
 323                         if ( previous )
 324                         {
 325                             previous->NextScreen = screen->NextScreen;
 326                         }
 327                         else
 328                         {
 329                             IntuitionBase->FirstScreen = screen->NextScreen;
 330                         }
 331                         current->NextScreen = screen;
 332                         screen->NextScreen = NULL;
 333                     }
 334
 335                 } /* current not SF_isChild | SF_IsParent */
 336
 337             } /* ! SDEPTH_INFAMILY */
 338
 339         } /* if SDEPTH_TO_BACK */
 340
 341     } /* if (current) */
 342
 343 #ifdef __MORPHOS__
 344     IntuitionBase->ActiveScreen = IntuitionBase->FirstScreen;
 345     RethinkDisplay();
 346 #else
 347     if (IntuitionBase->FirstScreen != oldfront)
 348     {
 349         SetFrontBitMap(IntuitionBase->FirstScreen->RastPort.BitMap, TRUE);
 350         IntuitionBase->ActiveScreen = IntuitionBase->FirstScreen;
 351     }
 352 #endif
 353
 354     win = NULL;
 355 #if 0 /* FIXME: backport, disabled */
 356     if (IntuitionBase->FirstScreen && GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_SCREENACTIVATION)
 357     {
 358         struct Window *scanw = 0;
 359
 360         for (scanw = IntuitionBase->FirstScreen->FirstWindow; scanw ; scanw = scanw->NextWindow)
 361         {
 362             if (win)
 363             {
 364                 if ((IW(scanw)->activationtime.tv_secs > IW(win)->activationtime.tv_secs) ||
 365                     ((IW(scanw)->activationtime.tv_secs == IW(win)->activationtime.tv_secs) && (IW(scanw)->activationtime.tv_micro > IW(win)->activationtime.tv_micro)))
 366                 {
 367                     win = scanw;
 368                 }
 369             }
 370
 371             if (!win) win = scanw;
 372         }
 373
 374         if (!win) win = IntuitionBase->FirstScreen->FirstWindow;
 375         if (IntuitionBase->ActiveWindow && IntuitionBase->ActiveWindow->WScreen == IntuitionBase->FirstScreen) win = NULL;
 376     }
 377 #endif
 378
 379     /* now set the default pub screen */
 380     /* if the screen is not a public one we just ignore this */
 381
 382     if (IntuitionBase->FirstScreen && GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_DEFPUBSCREEN)
 383     {
 384         if (GetPrivScreen(IntuitionBase->FirstScreen)->pubScrNode && (IntuitionBase->FirstScreen->Flags & (PUBLICSCREEN | WBENCHSCREEN)))
 385         {
 386             GetPrivIBase(IntuitionBase)->DefaultPubScreen = IntuitionBase->FirstScreen;
 387         }
 388     }
 389
 390     UnlockIBase(ilock);
 391
 392     if (win)
 393     {
 394         ActivateWindow(win);
 395     }
 396 }