rom/intuition/screendepth.c

   1 /*
   2     Copyright  1995-2010, 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     I am not sure, if it is enough, to just send a SNOTIFY message to one
  68     screen.  I would suggest, the former FirstScreen gets a SDEPTH_TOBACK
  69     message and the new FirstScreen gets a SDEPTH_TOFRONT message.
  70     Currently only the screen supplied with ScreenDepth gets a message.
  71
  72     But those messages need to be sent in front of the actual
  73     screen depth change because of the SNOTIFY_WAIT_REPLY-flag must be
  74     able to block the action. But we only know after int_screendepth(),
  75     if there was a change and which change took place.
  76
  77     So I leave it, as it is. This way SNOTIFY_WAIT_REPLY should work
  78     at least. Is there something written in the AutoDocs, how this has
  79     to be done (each screen gets a message)?
  80
  81     (o1i)
  82
  83     SEE ALSO
  84     ScreenToBack(), ScreenToFront()
  85
  86     INTERNALS
  87
  88 *****************************************************************************/
  89 {
  90     AROS_LIBFUNC_INIT
  91
  92     struct ScreenDepthActionMsg msg;
  93
  94     if (reserved != NULL) return;
  95     SANITY_CHECK(screen)
  96
  97     FireScreenNotifyMessageCode((IPTR) screen, SNOTIFY_SCREENDEPTH, flags, IntuitionBase);
  98
  99     msg.screen = screen;
 100     msg.flags  = flags;
 101     DoASyncAction((APTR)int_screendepth, &msg.msg, sizeof(msg), IntuitionBase);
 102
 103     AROS_LIBFUNC_EXIT
 104
 105 } /* ScreenDepth */
 106
 107 /*****************************************************************************************/
 108
 109 static VOID int_screendepth(struct ScreenDepthActionMsg *msg,
 110                             struct IntuitionBase *IntuitionBase)
 111 {
 112     struct Screen   *screen = msg->screen;
 113     ULONG            flags = msg->flags;
 114     ULONG            ilock = LockIBase(0); /* before access to FirstScreen */
 115     struct Screen   *family = NULL,
 116                     *current = IntuitionBase->FirstScreen,
 117                     *previous = NULL,
 118                     *prefamily = NULL;
 119     struct Window   *win = NULL;
 120
 121     /* Find the screen in the list and check for family */
 122     while ( current && current!=screen )
 123     {
 124         if ( flags & SDEPTH_INFAMILY )
 125         {
 126             /* Check if this is the first child in a family */
 127             if ( !family && (GetPrivScreen(current)->SpecialFlags & SF_IsChild) )
 128             {
 129                 family = current;
 130                 prefamily = previous;
 131             }
 132             /* Check if this screen is a child so next one belongs to current family */
 133             if ( family && !(GetPrivScreen(current)->SpecialFlags & SF_IsChild) )
 134             {
 135                 family = NULL;
 136                 prefamily = NULL;
 137             }
 138         }
 139         previous = current;
 140         current = current->NextScreen;
 141     }
 142
 143     if ( current )
 144     {
 145         if ( ! (flags & SDEPTH_TOBACK) ) /* SDEPTH_TOFRONT is #defined as 0 */
 146         {
 147             BOOL changed = FALSE;
 148             if ( previous ) /* I'm not the very first screen */
 149             {
 150                 changed = TRUE;
 151                 if ( flags & SDEPTH_INFAMILY )
 152                 {
 153                     if ( GetPrivScreen(current)->SpecialFlags & SF_IsChild )
 154                     { /* Move me in the front of my family */
 155                         if ( family ) /* I'm not the first one in my family */
 156                         {
 157                             previous->NextScreen = current->NextScreen;
 158                             current->NextScreen = family;
 159                             if ( prefamily )
 160                             {
 161                                 prefamily->NextScreen = current;
 162                             }
 163                             else
 164                             {
 165                                 IntuitionBase->FirstScreen = current;
 166                             }
 167                         }
 168                     }
 169                     else if ( GetPrivScreen(current)->SpecialFlags & SF_IsParent )
 170                     { /* Move whole family */
 171                         if ( prefamily ) /* We are not the first family */
 172                         {
 173                             prefamily->NextScreen = current->NextScreen;
 174                             current->NextScreen = IntuitionBase->FirstScreen;
 175                             IntuitionBase->FirstScreen = family;
 176                         }
 177                     }
 178                     else
 179                     { /* I have no family */
 180                         previous->NextScreen = current->NextScreen;
 181                         current->NextScreen = IntuitionBase->FirstScreen;
 182                         IntuitionBase->FirstScreen = current;
 183                     }
 184
 185                 } /* SDEPTH_INFAMILY */
 186                 else
 187                 {
 188                     if ( GetPrivScreen(current)->SpecialFlags & (SF_IsChild|SF_IsParent) )
 189                     { /* Move my whole family */
 190                         if ( !family )
 191                         {
 192                             prefamily = previous;
 193                             family = current;
 194                         }
 195                         if ( prefamily )
 196                         { /* We are not the first family */
 197                             while ( !(GetPrivScreen(current)->SpecialFlags & SF_IsParent) )
 198                             {
 199                                 current = current->NextScreen;
 200                             }
 201                             prefamily->NextScreen = current->NextScreen;
 202                             current->NextScreen = IntuitionBase->FirstScreen;
 203                             IntuitionBase->FirstScreen = family;
 204                         }
 205                     }
 206                     else
 207                     { /* I have no family */
 208                         previous->NextScreen = current->NextScreen;
 209                         current->NextScreen = IntuitionBase->FirstScreen;
 210                         IntuitionBase->FirstScreen = current;
 211                     }
 212
 213                 } /* ! SDEPTH_INFAMILY */
 214
 215             } /* if (previous) */
 216
 217             if (!changed)
 218                 goto end;
 219             /* The screen has been made frontmost, activate its monitor */
 220             ActivateMonitor(GetPrivScreen(IntuitionBase->FirstScreen)->MonitorObject, -1, -1, IntuitionBase);
 221             IntuitionBase->ActiveScreen = IntuitionBase->FirstScreen;
 222         } /* if SDEPTH_TO_FRONT */
 223
 224         else if ( flags & SDEPTH_TOBACK )
 225         {
 226             BOOL changed = FALSE;
 227             if ( flags & SDEPTH_INFAMILY )
 228             {
 229                 if ( GetPrivScreen(current)->SpecialFlags & SF_IsChild )
 230                 {
 231                     /* Go to last screen of this family */
 232                     while ( !GetPrivScreen(current->NextScreen)->SpecialFlags & SF_IsParent )
 233                     {
 234                         current = current->NextScreen;
 235                     }
 236                     if ( current != screen ) /* I'm not the last screen of my family */
 237                     {
 238                         if ( previous )
 239                         {
 240                             previous->NextScreen = screen->NextScreen;
 241                         }
 242                         else
 243                         {
 244                             IntuitionBase->FirstScreen = screen->NextScreen;
 245                         }
 246                         screen->NextScreen = current->NextScreen;
 247                         current->NextScreen = screen;
 248                         changed = TRUE;
 249                     }
 250                 }
 251                 else if ( GetPrivScreen(current)->SpecialFlags & SF_IsParent )
 252                 {
 253                     if ( current->NextScreen ) /* I'm not the last screen */
 254                     {
 255                         while ( current->NextScreen )
 256                         {
 257                             current = current->NextScreen;
 258                         }
 259                         if ( prefamily )
 260                         {
 261                             prefamily->NextScreen = screen->NextScreen;
 262                         }
 263                         else
 264                         {
 265                             IntuitionBase->FirstScreen = screen->NextScreen;
 266                         }
 267                         if ( family )
 268                         {
 269                             current->NextScreen = family;
 270                         }
 271                         else
 272                         {
 273                             current->NextScreen = screen;
 274                         }
 275                         screen->NextScreen = NULL;
 276                         changed = TRUE;
 277                     }
 278                 }
 279                 else
 280                 {
 281                     if ( current->NextScreen ) /* I'm not the last screen */
 282                     {
 283                         while ( current->NextScreen )
 284                         {
 285                             current = current->NextScreen;
 286                         }
 287                         if ( previous )
 288                         {
 289                             previous->NextScreen = screen->NextScreen;
 290                         }
 291                         else
 292                         {
 293                             IntuitionBase->FirstScreen = screen->NextScreen;
 294                         }
 295                         current->NextScreen = screen;
 296                         screen->NextScreen = NULL;
 297                         changed = TRUE;
 298                     }
 299                 }
 300
 301             } /* SDEPTH_INFAMILY */
 302             else
 303             {
 304                 struct Screen *last;
 305
 306                 if ( GetPrivScreen(current)->SpecialFlags & (SF_IsChild|SF_IsParent) )
 307                 {
 308                     if ( !family )
 309                     {
 310                         family = current;
 311                         prefamily = previous;
 312                     }
 313                     /* Go to last screen of this family */
 314                     while ( !GetPrivScreen(current)->SpecialFlags & SF_IsParent )
 315                     {
 316                         current = current->NextScreen;
 317                     }
 318                     if ( current->NextScreen ) /* We are not the last family */
 319                     {
 320                         last = current->NextScreen;
 321                         while ( last->NextScreen )
 322                         {
 323                             last = last->NextScreen;
 324                         }
 325                         if ( prefamily )
 326                         {
 327                             prefamily->NextScreen = current->NextScreen;
 328                         }
 329                         else
 330                         {
 331                             IntuitionBase->FirstScreen = current->NextScreen;
 332                         }
 333                         last->NextScreen = family;
 334                         current->NextScreen = NULL;
 335                         changed = TRUE;
 336                     }
 337
 338                 } /* if ( GetPrivScreen(current)->SpecialFlags & (SF_IsChild|SF_IsParent) ) */
 339                 else
 340                 {
 341                     if ( current->NextScreen ) /* I'm not the last screen */
 342                     {
 343                         while ( current->NextScreen )
 344                         {
 345                             current = current->NextScreen;
 346                         }
 347                         if ( previous )
 348                         {
 349                             previous->NextScreen = screen->NextScreen;
 350                         }
 351                         else
 352                         {
 353                             IntuitionBase->FirstScreen = screen->NextScreen;
 354                         }
 355                         current->NextScreen = screen;
 356                         screen->NextScreen = NULL;
 357                         changed = TRUE;
 358                     }
 359
 360                 } /* current not SF_isChild | SF_IsParent */
 361
 362             } /* ! SDEPTH_INFAMILY */
 363             if (!changed)
 364                 goto end;
 365             /* We have just brought the screen to back. We want to stay on the current monitor,
 366                so we activate the frontmost screen on THIS monitor */
 367             IntuitionBase->ActiveScreen = FindFirstScreen(GetPrivIBase(IntuitionBase)->ActiveMonitor, IntuitionBase);
 368         } /* if SDEPTH_TO_BACK */
 369     } /* if (current) */
 370
 371     RethinkDisplay();
 372
 373 #if 0 /* FIXME: backport, disabled */
 374     if (IntuitionBase->FirstScreen && GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_SCREENACTIVATION)
 375     {
 376         struct Window *scanw = 0;
 377
 378         for (scanw = IntuitionBase->FirstScreen->FirstWindow; scanw ; scanw = scanw->NextWindow)
 379         {
 380             if (win)
 381             {
 382                 if ((IW(scanw)->activationtime.tv_secs > IW(win)->activationtime.tv_secs) ||
 383                     ((IW(scanw)->activationtime.tv_secs == IW(win)->activationtime.tv_secs) && (IW(scanw)->activationtime.tv_micro > IW(win)->activationtime.tv_micro)))
 384                 {
 385                     win = scanw;
 386                 }
 387             }
 388
 389             if (!win) win = scanw;
 390         }
 391
 392         if (!win) win = IntuitionBase->FirstScreen->FirstWindow;
 393         if (IntuitionBase->ActiveWindow && IntuitionBase->ActiveWindow->WScreen == IntuitionBase->FirstScreen) win = NULL;
 394     }
 395 #endif
 396
 397     /* now set the default pub screen */
 398     /* if the screen is not a public one we just ignore this */
 399
 400     if (IntuitionBase->FirstScreen && GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_DEFPUBSCREEN)
 401     {
 402         if (GetPrivScreen(IntuitionBase->FirstScreen)->pubScrNode && (IntuitionBase->FirstScreen->Flags & (PUBLICSCREEN | WBENCHSCREEN)))
 403         {
 404             GetPrivIBase(IntuitionBase)->DefaultPubScreen = IntuitionBase->FirstScreen;
 405         }
 406     }
 407 end:
 408     UnlockIBase(ilock);
 409
 410     if (win)
 411     {
 412         ActivateWindow(win);
 413     }
 414 }