?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Enable VFP unit as early as possible. This has to be so since e.g. gcc9 uses vfp...
[AROS.git] / rom / intuition / openscreen.c
blob04c22fe8150c796b12e16e2ebb0847fd1666abc0
1 /*
2 Copyright © 1995-2018, The AROS Development Team. All rights reserved.
3 Copyright © 2001-2013, The MorphOS Development Team. All Rights Reserved.
4 $Id$
5
6 Open a new screen.
7 */
8
9 /*
10 * Things added by AROS, which needs to be kept when merging with newer MorphOS releases:
11 *
12 * 1. Explicit library bases
13 * 2. FireScreenNotifyMessage() calls
14 * 3. AddResourceToList() call
15 * 4. Decoration calls (see intuition_customize.h)
16 * 5. Hardcoded initial color table is not used and removed.
17 * AmigaOS-compatible palette is used instead.
18 * 6. Other placed marked by 'AROS:' in comments.
19 * 7. Check #ifdef's. Some of them were rearranged or completely deleted.
20 * We reuse MorphOS skin code where appropriate.
21 */
22
23 #include <aros/config.h>
24 #include <exec/memory.h>
25 #include <utility/tagitem.h>
26 #include <intuition/screens.h>
27 #include <intuition/intuition.h>
28 #include <intuition/imageclass.h>
29 #include <intuition/gadgetclass.h>
30 #include <intuition/monitorclass.h>
31 #include <graphics/modeid.h>
32 #include <graphics/videocontrol.h>
33 #include <graphics/displayinfo.h>
34 #include <graphics/rpattr.h>
35 #include <prefs/screenmode.h>
36 #include <proto/input.h>
37 #include <proto/dos.h>
38 #include <proto/exec.h>
39 #include <proto/graphics.h>
40 #include <proto/layers.h>
41 #include <proto/utility.h>
42 #include <proto/intuition.h>
43 #ifdef __MORPHOS__
44 #include <proto/cybergraphics.h>
45 #include <cybergraphx/cybergraphics.h>
46 #else
47 #include <hidd/gfx.h>
48 #endif
49 #include "intuition_intern.h"
50 #include "intuition_customize.h"
51 #include "intuition_extend.h"
52 #include "inputhandler.h"
53 #include "inputhandler_support.h"
54 #include "inputhandler_actions.h"
55 #include "menus.h"
56 #include "monitorclass_intern.h"
57 #include "monitorclass_private.h"
58
59 // disabled as it causes compatibility issues
60 //#define USE8BITHACK
61
62 #ifndef DEBUG_OpenScreen
63 #define DEBUG_OpenScreen 0
64 #endif
65 #undef DEBUG
66 #if DEBUG_OpenScreen
67 #define DEBUG 1
68 #endif
69 #include <aros/debug.h>
70
71 struct OpenScreenActionMsg
72 {
73 struct IntuiActionMsg msg;
74 struct IntScreen *Screen;
75 struct NewScreen *NewScreen;
76 struct List *List;
77 BOOL Success;
78 };
79
80 VOID int_openscreen(struct OpenScreenActionMsg *msg,struct IntuitionBase *IntuitionBase);
81
82 #ifdef SKINS
83 extern const ULONG defaultdricolors[DRIPEN_NUMDRIPENS];
84 #endif
85
86 #if DEBUG
87 #undef THIS_FILE
88 static const char THIS_FILE[] = __FILE__;
89 #endif
90
91 /*****************************************************************************
92
93 NAME */
94 AROS_LH1(struct Screen *, OpenScreen,
95
96 /* SYNOPSIS */
97 AROS_LHA(struct NewScreen *, newScreen, A0),
98
99 /* LOCATION */
100 struct IntuitionBase *, IntuitionBase, 33, Intuition)
101
102 /* FUNCTION
103
104 INPUTS
105
106 RESULT
107
108 NOTES
109
110 EXAMPLE
111
112 BUGS
113
114 SEE ALSO
115
116 INTERNALS
117 The function relies on private data being passed in
118 DimensionInfo.reserved[0] by graphics.library/GetDisplayInfoData().
119 Keep this in sync when modifying the code.
120
121 *****************************************************************************/
122 {
123 AROS_LIBFUNC_INIT
124
125 struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
126 struct LayersBase *LayersBase = GetPrivIBase(IntuitionBase)->LayersBase;
127 struct Library *UtilityBase = GetPrivIBase(IntuitionBase)->UtilityBase;
128 struct NewScreen ns;
129 struct TagItem *tag, *tagList;
130 struct IntScreen *screen;
131 int success;
132 struct Hook *layer_info_hook = NULL;
133 struct ColorSpec *colors = NULL;
134 ULONG *errorPtr; /* Store error at user specified location */
135 UWORD *customdripens = NULL;
136 ULONG *colors32 = NULL;
137 WORD sysfont = -1;
138 BOOL ok = TRUE, rp_inited = FALSE, li_inited = FALSE, sharepens = FALSE;
139 #ifdef USEWINDOWLOCK
140 BOOL windowlock = FALSE;
141 BOOL dowindowlock = TRUE;
142 #endif
143 struct Rectangle *dclip = NULL;
144 LONG overscan = OSCAN_TEXT;
145 DisplayInfoHandle displayinfo = NULL;
146 struct DisplayInfo dispinfo;
147 struct DimensionInfo dimensions;
148 #ifdef __MORPHOS__
149 struct MonitorInfo monitor;
150 #endif
151 ULONG allocbitmapflags = BMF_DISPLAYABLE;
152 char *skinname = 0;
153 #ifdef SKINS
154 ULONG vesafallback = 0;
155 ULONG *modecontrol = 0;
156 BOOL compositing = FALSE;
157 #endif
158 IPTR vctl = 0;
159 char *monitorname = 0;
160 BOOL exactname = FALSE;
161 BOOL showpointer = TRUE;
162 BOOL gammacontrol = FALSE;
163 UBYTE *gammared = NULL, *gammablue = NULL, *gammagreen = NULL;
164 BOOL support3d = FALSE;
165 BOOL adaptsize = FALSE;
166 ULONG displaywidth = 0;
167 ULONG displayheight = 0;
168 //ULONG lock;
169 WORD numcolors = 0;
170 UWORD spritebase;
171 BOOL workbench = FALSE;
172 ULONG requesteddepth = 1;
173 BOOL draggable = TRUE;
174 ULONG compflags = COMPF_ABOVE; // Default to AmigaOS like behaviour.
175 struct Hook *compalphahook = NULL;
176
177 struct TagItem modetags[] =
178 {
179 { BIDTAG_Depth , 0UL },
180 { BIDTAG_DesiredWidth , 0UL },
181 { BIDTAG_DesiredHeight, 0UL },
182 { BIDTAG_NominalWidth , 0UL },
183 { BIDTAG_NominalHeight, 0UL },
184 { BIDTAG_DIPFMustHave , 0UL },
185 { TAG_DONE }
186 };
187
188 ULONG modeid = INVALID_ID;
189
190 ASSERT_VALID_PTR_ROMOK(newScreen);
191
192
193 #define COPY(x) screen->Screen.x = ns.x
194 #define SetError(x) if (errorPtr != NULL) *errorPtr = x;
195
196 D(bug("OpenScreen (%p = { Left=%d Top=%d Width=%d Height=%d Depth=%d })\n"
197 , newScreen
198 , newScreen->LeftEdge
199 , newScreen->TopEdge
200 , newScreen->Width
201 , newScreen->Height
202 , newScreen->Depth
203 ));
204
205 FireScreenNotifyMessage((IPTR) newScreen, SNOTIFY_BEFORE_OPENSCREEN, IntuitionBase);
206 ns = *newScreen;
207
208 if (newScreen->Type & NS_EXTENDED)
209 {
210 tagList = ((struct ExtNewScreen *)newScreen)->Extension;
211 } else {
212 tagList = NULL;
213 }
214
215 DEBUG_OPENSCREEN(dprintf("OpenScreen: Left %d Top %d Width %d Height %d Depth %d Tags 0x%lx\n",
216 ns.LeftEdge, ns.TopEdge, ns.Width, ns.Height, ns.Depth, tagList));
217
218 #ifdef __MORPHOS__
219 if (!CyberGfxBase)
220 {
221 struct Library *lib = ComplainOpenLibrary(COMPLAIN_CYBERGFX,FALSE,IntuitionBase);
222 Forbid();
223 if (!CyberGfxBase)
224 {
225 CyberGfxBase = lib;
226 Permit();
227 }
228 else
229 {
230 Permit();
231 CloseLibrary(lib);
232 }
233 }
234 if (!CyberGfxBase)
235 {
236 FireScreenNotifyMessage(0, SNOTIFY_AFTER_OPENSCREEN, IntuitionBase);
237 return NULL;
238 }
239
240 if (!LocaleBase)
241 {
242 struct Library *lib = ComplainOpenLibrary(COMPLAIN_LOCALE,FALSE,IntuitionBase);
243 Forbid();
244 if (!LocaleBase)
245 {
246 LocaleBase = lib;
247 Permit();
248 OpenintuitionCatalog(IntuitionBase);
249 }
250 else
251 {
252 Permit();
253 CloseLibrary(lib);
254 }
255 }
256
257 if (!CGXSystemBase)
258 {
259 struct Library *lib = ComplainOpenLibrary(COMPLAIN_CGXSYSTEM,FALSE,IntuitionBase);
260 Forbid();
261 if (!CGXSystemBase)
262 {
263 CGXSystemBase = lib;
264 Permit();
265 }
266 else
267 {
268 Permit();
269 CloseLibrary(lib);
270 }
271 }
272 #endif
273
274 screen = NewObjectA(IBase->screenclass,0,0);
275
276 DEBUG_OPENSCREEN(dprintf("OpenScreen: screen 0x%lx\n", screen));
277
278 /* Do this really early to be able to report errors */
279 errorPtr = (ULONG *)GetTagData((Tag)SA_ErrorCode, (IPTR)NULL, (struct TagItem *)tagList);
280
281 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_ErrorCode 0x%lx\n",errorPtr));
282
283 if (screen == NULL)
284 {
285 SetError(OSERR_NOMEM);
286 ok = FALSE;
287 }
288
289 if (ok && tagList)
290 {
291 char *pubname = NULL;
292
293 modeid = GetTagData(SA_DisplayID,INVALID_ID, tagList);
294 #ifndef __AROS__
295 /*
296 * AROS: MorphOS private tag temporarily disabled. Used by OpenWorkbench().
297 * Information from MorphOS intuition.notes file:
298 *
299 * Added SA_OpenWorkbench to fix the OpenScreen handling for this special case, fixes
300 * the problem with autoscroll promoting to a bigger res than the one selected in prefs
301 *
302 * CHECKME: May be we also need this ?
303 */
304 workbench = GetTagData(SA_OpenWorkbench,FALSE,tagList);
305
306 if (workbench)
307 {
308 compositing = TRUE;
309 }
310 #endif
311
312 DEBUG_OPENSCREEN(dprintf("OpenScreen: modeid from taglist: %lx\n",modeid));
313
314 if (GetTagData(SA_LikeWorkbench, FALSE, tagList))
315 {
316 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_LikeWorkbench\n"));
317
318 #ifndef SKINS
319 /*
320 * AROS: Use oldstyle ScreenModePrefs structure.
321 * CHECKME: Can we merge better ?
322 */
323 if (!GetPrivIBase(IntuitionBase)->ScreenModePrefs)
324 SetDisplayDefaults(IntuitionBase);
325
326 ns.Width = GetPrivIBase(IntuitionBase)->ScreenModePrefs->smp_Width;
327 ns.Height = GetPrivIBase(IntuitionBase)->ScreenModePrefs->smp_Height;
328 ns.Depth = GetPrivIBase(IntuitionBase)->ScreenModePrefs->smp_Depth;
329 modeid = GetPrivIBase(IntuitionBase)->ScreenModePrefs->smp_DisplayID;
330
331 if (GetPrivIBase(IntuitionBase)->ScreenModePrefs->smp_Control & SMF_AUTOSCROLL)
332 {
333 /* need to mark autoscroll */
334 ns.Type |= AUTOSCROLL;
335 }
336 #else
337 ns.Width = IBase->AmbientScreenMode.DisplayWidth;
338 ns.Height = IBase->AmbientScreenMode.DisplayHeight;
339 ns.Depth = IBase->AmbientScreenMode.DisplayDepth;
340 if (IBase->AmbientScreenMode.AutoScroll) ns.Type |= AUTOSCROLL;
341 displaywidth = IBase->AmbientScreenMode.ModeWidth;
342 displayheight = IBase->AmbientScreenMode.ModeHeight;
343
344 /* jDc: do NOT copy modeid of wb as that will not allow overloading depth param properly */
345
346 /* unless it's OpenWorkbench! */
347
348 if (workbench)
349 {
350 modeid = INVALID_ID; // we'll use the stored ID only in the worst case!
351 compositing = IBase->AmbientScreenMode.Compositing;
352 }
353
354 /* let's try to limit the new screen to the same monitor ambient would use */
355 /* but only if modeid is a weak one */
356 if ((modeid == INVALID_ID) || (ModeNotAvailable(modeid)) || !FindDisplayInfo(modeid))
357 {
358 if (IBase->AmbientScreenMode.ModeMonitor[0])
359 {
360 monitorname = IBase->AmbientScreenMode.ModeMonitor;
361 }
362 else
363 {
364 struct IMonitorNode *node = FindMonitorNode(IBase->AmbientScreenMode.ModeID,IntuitionBase);
365
366 if (node)
367 {
368 monitorname = node->MonitorName;
369 }
370 }
371 }
372 #endif
373
374 sysfont = 1;
375 sharepens = TRUE; /* not sure */
376 }
377
378 if ((pubname = (char*)GetTagData(SA_PubName, 0, tagList)))
379 {
380 /* Name of this public screen. */
381 struct PubScreenNode *oldpsn;
382 struct List *list;
383
384 list = LockPubScreenList();
385
386 if ((strcmp(pubname, "Workbench") == 0) || workbench)
387 {
388 if (IBase->WorkBench)
389 {
390 ok = FALSE;
391 }
392
393 workbench = TRUE;
394 }
395 else
396 {
397 /* jDc: LockPubScreen is not safe here as it does not lock
398 screens in private state so we could end up with two
399 screens with the same name */
400 oldpsn = (struct PubScreenNode *)FindName(list,(UBYTE*)pubname);
401
402 if (oldpsn)
403 {
404 SetError(OSERR_PUBNOTUNIQUE);
405 ok = FALSE;
406 }
407 }
408
409 UnlockPubScreenList();
410
411 if (ok)
412 {
413 screen->pubScrNode = AllocMem(sizeof(struct PubScreenNode), MEMF_CLEAR);
414
415 DEBUG_OPENSCREEN(dprintf("OpenScreen: pubScrNode 0x%lx\n",screen->pubScrNode));
416
417 if (screen->pubScrNode == NULL)
418 {
419 SetError(OSERR_NOMEM);
420 ok = FALSE;
421 }
422
423 if (ok && (screen->pubScrNode->psn_Node.ln_Name = AllocVec(MAXPUBSCREENNAME + 1,MEMF_ANY)))
424 {
425 UBYTE sigbit;
426
427 if ((ns.Type & SCREENTYPE) == CUSTOMSCREEN)
428 {
429 ns.Type &= ~SCREENTYPE;
430 ns.Type |= PUBLICSCREEN;
431 }
432
433 /* Always open public screens in private mode. */
434 screen->pubScrNode->psn_Flags |= PSNF_PRIVATE;
435 strcpy(screen->pubScrNode->psn_Node.ln_Name, pubname);
436
437 /* Task that should be signalled when the public screen loses
438 its last visitor window. */
439
440 screen->pubScrNode->psn_SigTask = (struct Task *)GetTagData(SA_PubTask, 0, tagList);
441
442 /* Signal bit number to use when signalling public screen
443 signal task. */
444
445 sigbit = GetTagData(SA_PubSig,(ULONG)-1,tagList);
446
447 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_PubSig 0x%lx\n",sigbit));
448
449 if (sigbit != (UBYTE)-1)
450 {
451 if (!screen->pubScrNode->psn_SigTask) screen->pubScrNode->psn_SigTask = FindTask(NULL);
452 screen->pubScrNode->psn_SigBit = sigbit;
453 }
454 else
455 {
456 /* do not signal with -1 ! */
457 screen->pubScrNode->psn_SigTask = NULL;
458 }
459 }
460 else
461 {
462 SetError(OSERR_NOMEM);
463 FreeMem(screen->pubScrNode, sizeof(struct PubScreenNode));
464 screen->pubScrNode = NULL;
465 ok = FALSE;
466 }
467 }
468
469 }
470
471 #ifdef SKINS
472 if (modeid != INVALID_ID)
473 {
474 /* modes can be on other monitors */
475 monitorname = NULL;
476 }
477 #endif
478
479 while((tag = NextTagItem ((struct TagItem **)&tagList)))
480 {
481 #if 1
482 DEBUG_OPENSCREEN(dprintf("OpenScreen: Tag 0x%08lx Data 0x%08lx\n",
483 tag->ti_Tag, tag->ti_Data));
484 #endif
485 switch(tag->ti_Tag)
486 {
487 case SA_CompositingFlags:
488 compflags = tag->ti_Data;
489 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_CompositingFlags 0x%p\n", compflags));
490 break;
491 case SA_AlphaPreCompositingHook:
492 compalphahook = (struct Hook *)tag->ti_Data;
493 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_AlphaPreCompositingHook 0x%p\n", compalphahook));
494 break;
495 case SA_Left:
496 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Left %ld\n",tag->ti_Data));
497 ns.LeftEdge = tag->ti_Data;
498 break;
499 case SA_Top:
500 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Top %ld\n",tag->ti_Data));
501 ns.TopEdge = tag->ti_Data;
502 break;
503 case SA_Width:
504 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Width %ld\n",tag->ti_Data));
505 if ((tag->ti_Data != ~0) && (tag->ti_Data > 32767))
506 {
507 ok = FALSE;
508 }
509 ns.Width = tag->ti_Data;
510 break;
511 case SA_Height:
512 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Height %ld\n",tag->ti_Data));
513 if ((tag->ti_Data != ~0) && (tag->ti_Data > 32767))
514 {
515 ok = FALSE;
516 }
517 ns.Height = tag->ti_Data;
518 break;
519 case SA_Depth:
520 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Depth %ld\n",tag->ti_Data));
521 ns.Depth = tag->ti_Data;
522 break;
523 case SA_DetailPen:
524 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_DetailPen %ld\n",tag->ti_Data));
525 ns.DetailPen = tag->ti_Data;
526 break;
527 case SA_BlockPen:
528 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_BlockPen %ld\n",tag->ti_Data));
529 ns.BlockPen = tag->ti_Data;
530 break;
531 case SA_Type:
532 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Type 0x%lx\n",tag->ti_Data));
533 ns.Type &= ~SCREENTYPE;
534 ns.Type |= tag->ti_Data;
535 break;
536
537 case SA_Title:
538 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Title <%s>\n",tag->ti_Data));
539 ns.DefaultTitle = (UBYTE *)tag->ti_Data;
540 break;
541
542 case SA_Font:
543 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Font 0x%lx\n",tag->ti_Data));
544 ns.Font = (struct TextAttr *)tag->ti_Data;
545 break;
546
547 case SA_Colors32:
548 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Colors32 0x%lx\n",tag->ti_Data));
549 colors32 = (ULONG *)tag->ti_Data;
550 break;
551
552 case SA_Colors:
553 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Colors 0x%lx\n",tag->ti_Data));
554 colors = (struct ColorSpec *)tag->ti_Data;
555 break;
556
557 case SA_SysFont:
558 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_SysFont 0x%lx\n",tag->ti_Data));
559 sysfont = (WORD)tag->ti_Data;
560 break;
561
562 case SA_BitMap:
563 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_BitMap 0x%lx\n",tag->ti_Data));
564 if(tag->ti_Data)
565 {
566 ns.Type |= CUSTOMBITMAP;
567 ns.CustomBitMap = (struct BitMap *)tag->ti_Data;
568 }
569 else
570 {
571 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_BitMap==NULL specified, custom BitMap use disabled\n"));
572 }
573 break;
574
575 case SA_BackFill:
576 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_BackFill Hook 0x%lx\n",tag->ti_Data));
577 layer_info_hook = (struct Hook *)tag->ti_Data;
578 break;
579
580 case SA_Quiet:
581 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Quiet 0x%lx\n",tag->ti_Data));
582 if (tag->ti_Data)
583 {
584 ns.Type |= SCREENQUIET;
585 }
586 else
587 {
588 ns.Type &= ~SCREENQUIET;
589 }
590 break;
591
592 case SA_ShowTitle:
593 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_ShowTitle 0x%lx\n",tag->ti_Data));
594 if (tag->ti_Data)
595 {
596 ns.Type |= SHOWTITLE;
597 }
598 else
599 {
600 ns.Type &= ~SHOWTITLE;
601 }
602 break;
603
604 case SA_Pens:
605 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Pens 0x%lx\n",tag->ti_Data));
606 customdripens = (UWORD *)tag->ti_Data;
607 break;
608
609 case SA_SharePens:
610 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_SharePens 0x%lx\n",tag->ti_Data));
611 sharepens = tag->ti_Data ? TRUE : FALSE;
612 if (tag->ti_Data)
613 {
614 ns.Type |= PENSHARED;
615 } else {
616 ns.Type &= ~PENSHARED;
617 }
618 break;
619
620 case SA_Interleaved:
621 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Interleaved 0x%lx\n",tag->ti_Data));
622 if (tag->ti_Data)
623 {
624 allocbitmapflags |= BMF_INTERLEAVED;
625 }
626 else
627 {
628 allocbitmapflags &= ~BMF_INTERLEAVED;
629 }
630 break;
631
632 case SA_Behind:
633 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Behind 0x%lx\n",tag->ti_Data));
634 if (tag->ti_Data)
635 {
636 ns.Type |= SCREENBEHIND;
637 }
638 else
639 {
640 ns.Type &= ~SCREENBEHIND;
641 }
642 break;
643
644 case SA_DClip:
645 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_DClip 0x%lx\n",tag->ti_Data));
646 dclip = (struct Rectangle *)tag->ti_Data;
647 break;
648
649 case SA_Overscan:
650 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_OverScan 0x%lx\n",tag->ti_Data));
651 overscan = tag->ti_Data;
652 break;
653
654 case SA_DisplayID:
655 case SA_LikeWorkbench:
656 case SA_ErrorCode:
657 case SA_PubName:
658 case SA_PubSig:
659 case SA_PubTask:
660 /*
661 * handled elsewhere
662 */
663 break;
664
665 case SA_AutoScroll:
666 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_AutoScroll 0x%lx\n",tag->ti_Data));
667 if (tag->ti_Data)
668 {
669 ns.Type |= AUTOSCROLL;
670 }
671 else
672 {
673 ns.Type &= ~AUTOSCROLL;
674 }
675 break;
676
677 case SA_FullPalette:
678 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_FullPalette 0x%lx\n",tag->ti_Data));
679 break;
680 case SA_ColorMapEntries:
681 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_ColorMapEntries 0x%lx\n",tag->ti_Data));
682 numcolors = tag->ti_Data; /* AROS: Added support for this tag */
683 break;
684 case SA_Parent:
685 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Parent 0x%lx\n",tag->ti_Data));
686 break;
687 case SA_Draggable:
688 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Draggable 0x%lx\n",tag->ti_Data));
689 draggable = tag->ti_Data; /* AROS: Added support for this tag */
690 break;
691 case SA_Exclusive:
692 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Exclusive 0x%lx\n",tag->ti_Data));
693 break;
694 case SA_VideoControl:
695 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_VideoControl 0x%lx\n",tag->ti_Data));
696 vctl = tag->ti_Data; /* AROS: Added support for this tag */
697 break;
698 case SA_FrontChild:
699 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_FrontChild 0x%lx\n",tag->ti_Data));
700 break;
701 case SA_BackChild:
702 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_BackChild 0x%lx\n",tag->ti_Data));
703 break;
704 case SA_MinimizeISG:
705 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_MinimizeISG 0x%lx\n",tag->ti_Data));
706 break;
707
708 case SA_MonitorName:
709 monitorname = (char*)tag->ti_Data;
710 break;
711 #ifndef __AROS__ /* AROS: Disable MorphOS-specific extensions and private stuff */
712 case SA_SkinName: /* TODO: Complete support for named skins and enable this tag. Value needed. */
713 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_SkinName (%s)\n",(char *)tag->ti_Data));
714 skinname = (char *)tag->ti_Data;
715 break;
716
717 case SA_VesaFallback:
718 vesafallback = tag->ti_Data;
719 break;
720
721 case SA_ModeEditControl:
722 modecontrol = (ULONG*)tag->ti_Data;
723 break;
724
725 case SA_WindowLock: /* TODO: We also can support this private tag. In which situations we don't need locking ? */
726 dowindowlock = tag->ti_Data ? TRUE : FALSE;
727 break;
728
729 case SA_CompositingLayers:
730 compositing = tag->ti_Data ? TRUE : FALSE;
731 break;
732 #endif
733 case SA_ShowPointer:
734 showpointer = tag->ti_Data ? TRUE : FALSE;
735 break;
736
737 case SA_GammaControl:
738 gammacontrol = tag->ti_Data ? TRUE : FALSE;
739 break;
740
741 case SA_GammaRed:
742 gammared = (UBYTE*)tag->ti_Data;
743 break;
744
745 case SA_GammaBlue:
746 gammablue = (UBYTE*)tag->ti_Data;
747 break;
748
749 case SA_GammaGreen:
750 gammagreen = (UBYTE*)tag->ti_Data;
751 break;
752
753 case SA_3DSupport:
754 support3d = tag->ti_Data ? TRUE : FALSE;
755 break;
756
757 case SA_AdaptSize:
758 adaptsize = tag->ti_Data ? TRUE : FALSE;
759 break;
760
761 case SA_DisplayWidth:
762 displaywidth = (ULONG)tag->ti_Data;
763 break;
764
765 case SA_DisplayHeight:
766 displayheight = (ULONG)tag->ti_Data;
767 break;
768
769 case SA_ExactMatchMonitorName:
770 exactname = tag->ti_Data ? TRUE : FALSE;
771 break;
772
773 /* TODO: Missing SA_ Tags */
774 default:
775 DEBUG_OPENSCREEN(dprintf("OpenScreen: unknown tag 0x%lx data 0x%lx\n",
776 tag->ti_Tag,
777 tag->ti_Data));
778 break;
779
780 } /* switch (tag->ti_Tag) */
781
782 } /* while ((tag = NextTagItem (&tagList))) */
783
784 } /* if (tagList) */
785
786 DEBUG_OPENSCREEN(dprintf("OpenScreen: Left %d Top %d Width %d Height %d Depth %d Tags 0x%lx\n",
787 ns.LeftEdge, ns.TopEdge, ns.Width, ns.Height, ns.Depth, tagList));
788
789 requesteddepth = ns.Depth;
790
791 /* Fail if bogus size is requested - Piru/jDc */
792 if ((ns.Width < -1) || (ns.Height < -1))
793 {
794 DEBUG_OPENSCREEN(dprintf("!!! OpenScreen(): Width and/or Height negative !!!\n");)
795 ok = FALSE;
796 }
797
798 /* First Init the RastPort then get the BitPlanes!! */
799
800 #ifdef __MORPHOS__
801 #include "workaround.openscreen.c"
802 #endif
803 /* AROS: Use 3D support code */
804 if (support3d)
805 {
806 struct IMonitorNode *node = NULL;
807 ULONG depth = (ULONG)-1;
808
809 #ifndef __AROS__
810 /*AROS: We don't need these flags because we keep ModeID together with the BitMap */
811 screen->Support3D = TRUE;
812 allocbitmapflags |= BMF_3DTARGET;
813 #endif
814 /* check for SA_DisplayID or SA_MonitorName, this can also return other monitor
815 within the same class of monitors (ex radeon7k instead of 9k) */
816 if (monitorname || (modeid != INVALID_ID))
817 {
818 DEBUG_OPENSCREEN(dprintf("OpenScreen: 3d hunt modeid 0x%lx monname %s\n",modeid,monitorname ? monitorname : "none"));
819 node = FindBestMonitorNode(NULL,monitorname,modeid,IntuitionBase);
820 if (node) depth = FindBest3dDepth(ns.Depth,node,IntuitionBase);
821 }
822
823 /* no suitable depth? find a monitor with best 3d capabilities */
824 if ((depth == (ULONG)-1) && !exactname)
825 {
826 DEBUG_OPENSCREEN(dprintf("OpenScreen: found no suitable depth. monnode 0x%lx\n",node));
827 node = FindBest3dMonitor(NULL,IntuitionBase);
828 if (node) depth = FindBest3dDepth(ns.Depth,node,IntuitionBase);
829 }
830
831 /* found a usable depth? find a modeid with that depth within the monitor we found */
832 if (depth != (ULONG)-1)
833 {
834 DEBUG_OPENSCREEN(dprintf("OpenScreen: found suitable depth %d. monnode 0x%lx\n",depth,node));
835 ns.Depth = depth;
836
837 modeid = FindBestModeID(node->MonitorName,ns.Depth,(displaywidth) ? displaywidth : ns.Width,(displayheight) ? displayheight : ns.Height,IntuitionBase);
838
839 if (modeid == INVALID_ID)
840 {
841 DEBUG_OPENSCREEN(dprintf("OpenScreen: no 3d available, fail (1)!\n"));
842 ok = FALSE;
843 }
844 } else {
845 /* whoops, no 3d support at all, fail! */
846 DEBUG_OPENSCREEN(dprintf("OpenScreen: no 3d available, fail! (2)\n"));
847 ok = FALSE;
848 }
849
850 }
851 else if (monitorname)
852 {
853 ULONG newmodeid = INVALID_ID;
854 newmodeid = FindBestModeID(monitorname,ns.Depth,(displaywidth) ? displaywidth : ns.Width,(displayheight) ? displayheight : ns.Height,IntuitionBase);
855 if (newmodeid != INVALID_ID) modeid = newmodeid;
856 /* monitor not available and exactmatch requested ? */
857 if (exactname)
858 {
859 if (newmodeid == INVALID_ID)
860 {
861 dprintf("uhuh, no modeid!\n");
862 ok = FALSE;
863 }
864 else
865 {
866 // make sure this is the same monitor!
867 struct IMonitorNode *node = FindMonitorNode(newmodeid,IntuitionBase);
868 if (!node || strcmp(node->MonitorName,monitorname)) ok = FALSE;
869 }
870 }
871 DEBUG_OPENSCREEN(dprintf("OpenScreen: monname %s modeid %lx\n",monitorname,modeid));
872 }
873
874 #ifdef __MORPHOS__
875 /* Note: CGX patched ModeNotAvailable() alone doesn't return reliable results due to some fallback code for old apps. - Piru */
876 if ((modeid == INVALID_ID) || ModeNotAvailable(modeid) || !FindDisplayInfo(modeid))
877 {
878 struct TagItem bestmodetags[] =
879 {
880 {CYBRBIDTG_Depth,0},
881 {CYBRBIDTG_NominalWidth,0},
882 {CYBRBIDTG_NominalHeight,0},
883 {TAG_DONE}
884 };
885
886 if((modeid & 0xF00F0000) == 0x40020000)
887 {
888 modeid &= 0x40020000;
889 }
890
891 bestmodetags[0].ti_Data = (ns.Depth < 8) ? 8 : ns.Depth; /* jDc: helps finding a correct mode ;)*/
892 bestmodetags[1].ti_Data = (displaywidth) ? displaywidth : ns.Width;
893 bestmodetags[2].ti_Data = (displayheight) ? displayheight : ns.Height;
894
895 DEBUG_OPENSCREEN(dprintf("ns.Width %ld ns.Height %ld ns.Depth %ld !!\n",
896 (LONG) ns.Width, (LONG) ns.Height, (LONG) ns.Depth);)
897
898 modeid = BestCModeIDTagList(bestmodetags);
899
900 DEBUG_OPENSCREEN(dprintf("BestCModeIDTagList returned %ld\n",modeid);)
901 }
902 #endif
903
904 #ifdef SKINS
905 if ((workbench) && (IBase->EmergencyBoot.monitorname))
906 {
907 struct IMonitorNode *node;
908 ULONG depthid;
909 ULONG newmodeid;
910
911 node = FindBestMonitorNode(GetMonitorClass(IBase->EmergencyBoot.monitorname,IntuitionBase),IBase->EmergencyBoot.monitorname,INVALID_ID,IntuitionBase);
912
913 newmodeid = FakeWorkbenchMode(node,(ULONG*)&depthid,IBase->EmergencyBoot.baseresolution,IntuitionBase);
914
915 DEBUG_OPENSCREEN(dprintf("OpenScreen: Emergency Boot! %lx\n",modeid));
916
917 if (newmodeid != INVALID_ID)
918 {
919 modeid = newmodeid;
920 ns.Width = IBase->EmergencyBoot.baseresolution;
921
922 switch (ns.Width)
923 {
924 case 800:
925 ns.Height = 600;
926 break;
927
928 case 1024:
929 ns.Height = 768;
930 break;
931
932 default:
933 ns.Width = 640;
934 ns.Height = 480;
935 }
936
937 screen->VESAMode = ns.Width;
938 screen->VESAModeDepthID = depthid;
939 }
940 }
941
942 if (workbench && (((struct IIHData *)IBase->InputHandler->is_Data)->ActQualifier & IEQUALIFIER_CONTROL))
943 {
944 vesafallback = 1024;
945 }
946
947 if (vesafallback)
948 {
949 struct IMonitorNode *node = NULL;
950 ULONG depthid;
951 ULONG newmodeid;
952
953 if (monitorname) node = FindBestMonitorNode(GetMonitorClass(monitorname,IntuitionBase),monitorname,INVALID_ID,IntuitionBase);
954
955 newmodeid = FakeWorkbenchMode(node,(ULONG*)&depthid,vesafallback,IntuitionBase);
956
957 DEBUG_OPENSCREEN(dprintf("OpenScreen: vesa fallback %lx\n",modeid));
958
959 if (newmodeid != INVALID_ID)
960 {
961 modeid = newmodeid;
962 ns.Width = vesafallback;
963
964 switch (ns.Width)
965 {
966 case 800:
967 ns.Height = 600;
968 break;
969
970 case 1024:
971 ns.Height = 768;
972 break;
973
974 default:
975 ns.Width = 640;
976 ns.Height = 480;
977 }
978
979 screen->VESAMode = ns.Width;
980 screen->VESAModeDepthID = depthid;
981 }
982 }
983
984 if (modecontrol)
985 {
986 struct IMonitorNode *inode = FindMonitorNode(modeid,IntuitionBase);
987 modeid = FakeScreenMode(inode,ns.Depth,IntuitionBase);
988
989 DEBUG_OPENSCREEN(dprintf("OpenScreen: fake modeid %lx\n",modeid));
990
991 if (modeid != INVALID_ID)
992 {
993 switch (ns.Depth)
994 {
995 case 24: screen->VESAModeDepthID = ID_MD24; break;
996 case 16: screen->VESAModeDepthID = ID_MD16; break;
997 case 15: screen->VESAModeDepthID = ID_MD15; break;
998 default: screen->VESAModeDepthID = ID_MD08; break;
999 }
1000
1001 screen->ModeControl = modecontrol;
1002
1003 } else {
1004 DEBUG_OPENSCREEN(dprintf("OpenScreen: failed to init testmode!\n"));
1005 ok = FALSE;
1006 }
1007 }
1008
1009 #endif
1010
1011 /*
1012 * AROS: Got OpenScreenTags modeid without monitor, promote to chipset default
1013 * (if present).
1014 * We really need proper mode promotion support.
1015 */
1016 if ((modeid & MONITOR_ID_MASK) == 0)
1017 {
1018 if (GfxBase->DisplayFlags & PAL)
1019 modeid |= PAL_MONITOR_ID;
1020 else if (GfxBase->DisplayFlags & NTSC)
1021 modeid |= NTSC_MONITOR_ID;
1022 }
1023
1024 if (INVALID_ID == modeid)
1025 {
1026 #ifndef __AROS__
1027 WORD bestwidth,bestheight;
1028 #endif
1029 modetags[0].ti_Data = ns.Depth;
1030 modetags[1].ti_Data = ns.Width;
1031 modetags[2].ti_Data = ns.Height;
1032 modetags[3].ti_Data = ns.Width;
1033 modetags[4].ti_Data = ns.Height;
1034
1035 #ifdef __AROS__
1036 /*
1037 * AROS: We don't have FindBestWidthAndHeight().
1038 * TODO: Can we merge better here ?
1039 */
1040 if (ns.Width == STDSCREENWIDTH || ns.Width == 0 || adaptsize) {modetags[1].ti_Tag = TAG_IGNORE; modetags[3].ti_Tag = TAG_IGNORE;}
1041 if (ns.Height == STDSCREENWIDTH || ns.Height == 0 || adaptsize) {modetags[2].ti_Tag = TAG_IGNORE; modetags[4].ti_Tag = TAG_IGNORE;}
1042 #else
1043 FindBestWidthAndHeight(&bestwidth,&bestheight,ns.Depth,IntuitionBase);
1044
1045 if (ns.Width == STDSCREENWIDTH || ns.Width == 0 || adaptsize) {modetags[1].ti_Data = bestwidth; modetags[3].ti_Data = bestwidth;}
1046 if (ns.Height == STDSCREENWIDTH || ns.Height == 0 || adaptsize) {modetags[2].ti_Data = bestheight;modetags[4].ti_Data = bestheight;}
1047
1048 DEBUG_OPENSCREEN(dprintf("Attempt BestModeIDA(). Calculated best width %d height %d. Request: %d/%d.\n",bestwidth,bestheight,modetags[1].ti_Data,modetags[2].ti_Data));
1049 #endif
1050 /* AROS: Support old-style HAM or EHB request */
1051 if (newScreen->ViewModes & (HAM | EXTRA_HALFBRITE))
1052 {
1053 if (newScreen->ViewModes & HAM) modetags[5].ti_Data |= DIPF_IS_HAM;
1054 if (newScreen->ViewModes & EXTRA_HALFBRITE) modetags[5].ti_Data |= DIPF_IS_EXTRAHALFBRITE;
1055 }
1056 else
1057 {
1058 modetags[5].ti_Tag = TAG_IGNORE;
1059 }
1060
1061 modeid = BestModeIDA(modetags);
1062
1063 #ifdef SKINS
1064 if (modeid == INVALID_ID && workbench)
1065 {
1066 ULONG depthid;
1067 ULONG newmodeid = FakeWorkbenchMode(NULL,(ULONG*)&depthid,640,IntuitionBase);
1068 /* create an ID */
1069
1070 DEBUG_OPENSCREEN(dprintf("OpenScreen: Vesa Fallback!\n"));
1071
1072 if (newmodeid != INVALID_ID)
1073 {
1074 modeid = newmodeid;
1075 ns.Width = 640;
1076 ns.Height = 480;
1077
1078 screen->VESAMode = 640;
1079 screen->VESAModeDepthID = depthid;
1080 }
1081 }
1082 #endif
1083
1084 if (INVALID_ID == modeid)
1085 {
1086 // wtf? no monitors??
1087 D(bug("!!! OpenScreen(): Could not find any valid modeids. No graphics card? !!!\n"));
1088 SetError(OSERR_UNKNOWNMODE); /* AROS: Added error core setting, fixed MorphOS bug */
1089 ok = FALSE;
1090 }
1091 }
1092
1093 DEBUG_OPENSCREEN(dprintf("OpenScreen: ModeID 0x%08lx\n", modeid));
1094
1095 InitRastPort(&screen->Screen.RastPort);
1096 rp_inited = TRUE;
1097 success = FALSE;
1098
1099 if (ok && (displayinfo = FindDisplayInfo(modeid)) != NULL &&
1100 GetDisplayInfoData(displayinfo, (APTR)&dimensions, sizeof(dimensions), DTAG_DIMS, modeid)
1101 #ifdef __AROS__ /* AROS: We don't need MonitorSpec, however we get DisplayInfo early to get the compositors bm hooks. */
1102 && GetDisplayInfoData(displayinfo, (APTR)&dispinfo, sizeof(dispinfo), DTAG_DISP, modeid)
1103 #else
1104 && GetDisplayInfoData(displayinfo, (APTR)&monitor, sizeof(monitor), DTAG_MNTR, modeid)
1105 #endif
1106 )
1107 {
1108 success = TRUE;
1109 #ifdef __AROS__ /* AROS: Get HIDD composition flags */
1110 screen->SpecialFlags = ((compflags & (dimensions.reserved[0] >> 16)) | (dimensions.reserved[0] & 0xFFFF)) << 8;
1111 screen->preAlphaCompHook = compalphahook;
1112
1113 if (draggable) screen->SpecialFlags |= SF_Draggable;
1114 #else
1115 screen->Monitor = monitor.Mspc;
1116 #endif
1117 if (dclip == NULL)
1118 {
1119 switch (overscan)
1120 {
1121 case OSCAN_STANDARD:
1122 dclip = &dimensions.StdOScan;
1123 break;
1124
1125 case OSCAN_MAX:
1126 dclip = &dimensions.MaxOScan;
1127 break;
1128
1129 case OSCAN_VIDEO:
1130 dclip = &dimensions.VideoOScan;
1131 break;
1132
1133 default:
1134 dclip = &dimensions.TxtOScan;
1135 break;
1136 }
1137 }
1138
1139 if (ns.Width == STDSCREENWIDTH || ns.Width == 0 || adaptsize)
1140 ns.Width = dclip->MaxX - dclip->MinX + 1;
1141 /* AROS: Added raster size limit support */
1142 else if (ns.Width < dimensions.MinRasterWidth)
1143 ns.Width = dimensions.MinRasterWidth;
1144 else if (ns.Width > dimensions.MaxRasterWidth)
1145 ns.Width = dimensions.MaxRasterWidth;
1146
1147 if (ns.Height == STDSCREENHEIGHT || ns.Height == 0 || adaptsize)
1148 ns.Height = dclip->MaxY - dclip->MinY + 1;
1149 /* AROS: Added raster size limit support */
1150 else if (ns.Height < dimensions.MinRasterHeight)
1151 ns.Height = dimensions.MinRasterHeight;
1152 else if (ns.Height > dimensions.MaxRasterHeight)
1153 ns.Height = dimensions.MaxRasterHeight;
1154
1155 #ifndef __AROS__
1156 DEBUG_OPENSCREEN(dprintf("OpenScreen: Monitor 0x%lx Width %ld Height %ld\n",
1157 screen->Monitor, ns.Width, ns.Height));
1158 #endif
1159
1160 if (ns.Type & CUSTOMBITMAP)
1161 {
1162 struct BitMap *custombm;
1163 custombm = ns.CustomBitMap;
1164 #ifdef __AROS__ /* AROS: We don't have CGX in kickstart */
1165 /* FIXME: m68k Compositor needs to report that it can composit planar bitmaps */
1166 BOOL (*__IsCompositable) (struct BitMap *, DisplayInfoHandle, struct GfxBase *) = (APTR)dispinfo.reserved[0];
1167 BOOL (*__MakeDisplayable) (struct BitMap *, DisplayInfoHandle, struct GfxBase *) = (APTR)dispinfo.reserved[1];
1168
1169 if (dispinfo.reserved[0])
1170 {
1171 if (__IsCompositable(custombm, displayinfo, GfxBase))
1172 {
1173 DEBUG_OPENSCREEN(dprintf("OpenScreen: Marking CustomBitMap 0x%lx as compositable\n", custombm));
1174 __MakeDisplayable(custombm, displayinfo, GfxBase);
1175 }
1176 else
1177 {
1178 custombm = NULL;
1179 }
1180 }
1181 else if ((!IS_HIDD_BM(custombm)) || (modeid != HIDD_BM_HIDDMODE(custombm)))
1182 {
1183 custombm = NULL;
1184 }
1185 #else
1186 if (IsCyberModeID(modeid) && custombm)
1187 {
1188 int pixfmt = GetCyberIDAttr(CYBRIDATTR_PIXFMT,modeid);
1189
1190 if(GetCyberMapAttr(custombm,CYBRMATTR_PIXFMT) != pixfmt)
1191 {
1192 // incompatible formats !
1193 custombm = NULL;
1194 }
1195 }
1196 #endif
1197 if(custombm != NULL)
1198 {
1199 screen->Screen.RastPort.BitMap = custombm;
1200 ns.Depth = GetBitMapAttr(ns.CustomBitMap,BMA_DEPTH);
1201 DEBUG_OPENSCREEN(dprintf("OpenScreen: CustomBitMap Depth %ld\n",
1202 ns.Depth));
1203 } else {
1204 ns.CustomBitMap = NULL;
1205 ns.Type &= ~CUSTOMBITMAP;
1206 }
1207 } else {
1208 screen->Screen.RastPort.BitMap = NULL;
1209 }
1210
1211 if ((screen->IMonitorNode = FindMonitorNode(modeid,IntuitionBase)))
1212 {
1213 DEBUG_OPENSCREEN(dprintf("OpenScreen: MonitorNode 0x%lx\n",
1214 screen->IMonitorNode));
1215 } else {
1216 DEBUG_OPENSCREEN(dprintf("OpenScreen: No MonitorNode\n"));
1217 ok = FALSE;
1218 }
1219
1220 if(ok && (screen->Screen.RastPort.BitMap == NULL))
1221 {
1222 #ifdef __AROS__ /* AROS: BitMap needs ModeID */
1223 ULONG Depth = (dimensions.MaxDepth > 8) ? dimensions.MaxDepth : ns.Depth;
1224 struct TagItem bmtags[] =
1225 {
1226 {BMATags_DisplayID, modeid},
1227 {TAG_DONE , 0 }
1228 };
1229
1230 screen->Screen.RastPort.BitMap = AllocBitMap(ns.Width, ns.Height, Depth,
1231 allocbitmapflags | BMF_CHECKVALUE,
1232 (struct BitMap *)bmtags);
1233 #else
1234 struct BitMap *root = NULL;
1235 ULONG pixfmt;
1236 ULONG Depth;
1237 int retrycnt=1;
1238 ULONG stdwidth = dimensions.Nominal.MaxX - dimensions.Nominal.MinX + 1;
1239 ULONG stdheight = dimensions.Nominal.MaxY - dimensions.Nominal.MinY + 1;
1240
1241 #ifdef USE8BITHACK
1242 Depth = (dimensions.MaxDepth > 8) ? dimensions.MaxDepth : 8;
1243 #else
1244 Depth = (dimensions.MaxDepth > 8) ? dimensions.MaxDepth : ns.Depth;
1245 #endif
1246
1247 switch(Depth)
1248 {
1249 case 15:
1250 pixfmt = PIXFMT_RGB15;
1251 break;
1252 case 16:
1253 pixfmt = PIXFMT_RGB16;
1254 break;
1255 case 24:
1256 pixfmt = PIXFMT_BGR24;
1257 break;
1258 case 32:
1259 pixfmt = PIXFMT_ARGB32;
1260 break;
1261 default:
1262 pixfmt = PIXFMT_LUT8;
1263 break;
1264 }
1265
1266 if (IsCyberModeID(modeid))
1267 {
1268 pixfmt = GetCyberIDAttr(CYBRIDATTR_PIXFMT,modeid);
1269 }
1270
1271 DoMethod((Object*)screen->IMonitorNode,MM_GetRootBitMap,pixfmt,(ULONG)&root);
1272
1273 DEBUG_OPENSCREEN(dprintf("OpenScreen: root BitMap 0x%lx\n",root));
1274
1275 do
1276 {
1277 allocbitmapflags &= (BMF_DISPLAYABLE | BMF_INTERLEAVED | BMF_3DTARGET);
1278
1279 if(root == NULL)
1280 {
1281 allocbitmapflags |= (BMF_SPECIALFMT|/*BMF_CLEAR|*/BMF_DISPLAYABLE|BMF_MINPLANES);
1282 allocbitmapflags |= SHIFT_PIXFMT(pixfmt);
1283 }
1284 else
1285 {
1286 allocbitmapflags |= (/*BMF_CLEAR|*/BMF_DISPLAYABLE|BMF_MINPLANES);
1287 }
1288
1289 if((screen->Screen.RastPort.BitMap = AllocBitMap((ns.Width > stdwidth) ? ns.Width : stdwidth,
1290 (ns.Height > stdheight) ? ns.Height : stdheight,
1291 Depth,
1292 allocbitmapflags,
1293 root)) == NULL)
1294 {
1295 root = NULL;
1296 }
1297 }
1298 while((screen->Screen.RastPort.BitMap == NULL) && (retrycnt--));
1299 #endif
1300 screen->AllocatedBitMap = screen->Screen.RastPort.BitMap;
1301
1302 DEBUG_OPENSCREEN(dprintf("OpenScreen: allocated BitMap 0x%lx\n",screen->AllocatedBitMap));
1303
1304 if (screen->Screen.RastPort.BitMap)
1305 {
1306 UpdateScreenBitMap(&screen->Screen, IntuitionBase);
1307 #ifndef __AROS__
1308 /*
1309 * AROS: This seems to be not needed
1310 * TODO: Check if this is really true, test case needed
1311 */
1312 if (Depth > 8)
1313 {
1314 if (stdwidth > ns.Width)
1315 {
1316 struct RastPort rport;
1317
1318 InitRastPort(&rport);
1319 rport.BitMap = screen->AllocatedBitMap;
1320 SetRPAttrs(&rport,RPTAG_PenMode,FALSE,RPTAG_FgColor,0x0,TAG_DONE);
1321
1322 RectFill(&rport,ns.Width,0,stdwidth - 1,ns.Height - 1);
1323 }
1324
1325 if (stdheight > ns.Height)
1326 {
1327 struct RastPort rport;
1328
1329 InitRastPort(&rport);
1330 rport.BitMap = screen->AllocatedBitMap;
1331 SetRPAttrs(&rport,RPTAG_PenMode,FALSE,RPTAG_FgColor,0x0,TAG_DONE);
1332
1333 RectFill(&rport,0,ns.Height,ns.Width - 1,stdheight - 1);
1334 }
1335 }
1336 #endif
1337 }
1338 }
1339
1340 DEBUG_OPENSCREEN(dprintf("OpenScreen: BitMap 0x%lx\n",
1341 screen->Screen.RastPort.BitMap));
1342 }
1343 else
1344 {
1345 DEBUG_OPENSCREEN(dprintf("OpenScreen: no displayinfo\n"));
1346 SetError(OSERR_UNKNOWNMODE); /* AROS: Added error code setting, fixed MorphOS bug */
1347 }
1348
1349 D(bug("got BitMap\n"));
1350
1351 /* Init screen's viewport */
1352 InitVPort(&screen->Screen.ViewPort);
1353
1354 /* Allocate a RasInfo struct in which we have a pointer
1355 to the struct BitMap, into which the driver can
1356 store its stuff. (Eg. pointer to a BitMap HIDD object)
1357 */
1358 screen->Screen.ViewPort.RasInfo = AllocMem(sizeof(struct RasInfo), MEMF_ANY | MEMF_CLEAR);
1359
1360 DEBUG_OPENSCREEN(dprintf("OpenScreen: RasInfo 0x%lx\n",
1361 screen->Screen.ViewPort.RasInfo));
1362
1363 if (!success ||
1364 (screen->Screen.RastPort.BitMap == NULL) ||
1365 (screen->Screen.ViewPort.RasInfo == NULL))
1366 {
1367 ok = FALSE;
1368 } else {
1369 /* Store pointer to BitMap, so we can get hold of it
1370 from withing LoadRGBxx() functions
1371 */
1372 D(bug("got allocated stuff\n"));
1373 screen->Screen.ViewPort.RasInfo->BitMap = screen->Screen.RastPort.BitMap;
1374 }
1375
1376 if (ok)
1377 {
1378 /* Read depth from the BitMap to avoid AttachPalExtra/ObtainPen getting
1379 * confused if cgx decided to allocate a higher depth BitMap than what
1380 * was asked.
1381 */
1382 ns.Depth = GetBitMapAttr(screen->Screen.RastPort.BitMap,BMA_DEPTH);
1383
1384 if (!numcolors) /* AROS: Added support for SA_ColorMapEntries */
1385 {
1386 #ifdef USE8BITHACK
1387 numcolors = 256;
1388 #else
1389 numcolors = (ns.Depth <= 8) ? (1L << ns.Depth) : 256;
1390 #endif
1391 }
1392
1393 /* Get a color map structure. Sufficient colors?? */
1394
1395 DEBUG_OPENSCREEN(dprintf("OpenScreen: Colormap Entries %ld\n",
1396 numcolors));
1397 if ((screen->Screen.ViewPort.ColorMap = GetColorMap(numcolors < 32 ? 32 : numcolors)) != NULL)
1398 {
1399 if (0 == AttachPalExtra(screen->Screen.ViewPort.ColorMap,
1400 &screen->Screen.ViewPort))
1401 {
1402 #if 0
1403 int i=0;
1404 char *alloclist;
1405 UWORD *refcnt;
1406
1407 refcnt =(UWORD*) screen->Screen.ViewPort.ColorMap->PalExtra->pe_RefCnt;
1408 alloclist = (UBYTE *)(refcnt + screen->Screen.ViewPort.ColorMap->Count);
1409
1410 DEBUG_OPENSCREEN(dprintf("OpenScreen: PalExtra alloclist 0x%lx Count %ld\n",alloclist,screen->Screen.ViewPort.ColorMap->Count));
1411
1412 while(i < screen->Screen.ViewPort.ColorMap->Count)
1413 {
1414 // initialize alloc list to -1,0,1,2,3,4
1415
1416 DEBUG_OPENSCREEN(dprintf("OpenScreen: alloclist[%ld]=%ld\n",
1417 i,alloclist[i]));
1418 i++;
1419 }
1420 #endif
1421 }
1422 else
1423 {
1424 ok = FALSE;
1425 }
1426 }
1427 else
1428 {
1429 ok = FALSE;
1430 }
1431
1432 DEBUG_OPENSCREEN(dprintf("OpenScreen: ColorMap 0x%lx\n",
1433 screen->Screen.ViewPort.ColorMap));
1434 }
1435
1436 #ifdef __MORPHOS__
1437
1438 {
1439 ULONG pixfmt = -1;
1440 APTR handle = LockBitMapTags(screen->Screen.RastPort.BitMap,
1441 LBMI_PIXFMT,(ULONG)&pixfmt,TAG_DONE);
1442
1443 if (handle)
1444 {
1445 UnLockBitMap(handle);
1446 screen->PixelFormat = pixfmt;
1447 }
1448 else
1449 {
1450 screen->PixelFormat = -1;
1451 }
1452 }
1453 #endif
1454 screen->GammaControl.UseGammaControl = gammacontrol;
1455 screen->GammaControl.GammaTableR = gammared;
1456 screen->GammaControl.GammaTableG = gammagreen;
1457 screen->GammaControl.GammaTableB = gammablue;
1458 #ifndef __AROS__
1459 /*
1460 * AROS: This fragment seems to delay-load default gamma table for the monitor.
1461 * TODO: May be use this approach ?
1462 */
1463 if (screen->IMonitorNode && !screen->IMonitorNode->GammaLoaded)
1464 {
1465 int_SkinAction(SKA_LoadGamma,(ULONG *)screen->IMonitorNode,NULL,IntuitionBase);
1466 screen->IMonitorNode->GammaLoaded = TRUE;
1467 }
1468
1469 // no hotkey by default
1470 screen->RecallHotkey.ia_Key = 0xFF;
1471 #endif
1472 screen->ModeID = modeid;
1473
1474 if (ok)
1475 {
1476 struct ViewPortExtra *vpe = (struct ViewPortExtra *)GfxNew(VIEWPORT_EXTRA_TYPE);
1477
1478 DEBUG_OPENSCREEN(dprintf("OpenScreen: ViewPortExtra 0x%lx\n", vpe));
1479
1480 ok = FALSE;
1481
1482 if (vpe)
1483 {
1484 struct TagItem tags[6];
1485
1486 memcpy(&vpe->DisplayClip, dclip,sizeof(struct Rectangle));
1487 #ifdef __AROS__
1488 /*
1489 * AROS: Set ViewPort offset and get size from dclip.
1490 * CHECKME: MorphOS source code always sets ViewPort's DWidth and DHeight to
1491 * nominal size, while ViewPortExtra's DisplayClip is still set to OverScan
1492 * rectangle. Whose approach is correct ?
1493 */
1494 screen->Screen.ViewPort.DxOffset = ns.LeftEdge;
1495 screen->Screen.ViewPort.DyOffset = ns.TopEdge;
1496 screen->Screen.ViewPort.DWidth = dclip->MaxX - dclip->MinX + 1;
1497 screen->Screen.ViewPort.DHeight = dclip->MaxY - dclip->MinY + 1;
1498 #else
1499 /* using vpe data for vesamode/modecontrol is not a good idea since the mode
1500 is changed on the fly and the actual data might not be what we'll use */
1501
1502 if (screen->VESAMode)
1503 {
1504 screen->Screen.ViewPort.DWidth = screen->VESAMode;
1505
1506 switch (screen->VESAMode)
1507 {
1508 case 800:
1509 screen->Screen.ViewPort.DHeight = 600;
1510 break;
1511
1512 case 1024:
1513 screen->Screen.ViewPort.DHeight = 768;
1514 break;
1515
1516 default:
1517 screen->Screen.ViewPort.DWidth = 640;
1518 screen->Screen.ViewPort.DHeight = 480;
1519 }
1520
1521 screen->VESAMode = ns.Width;
1522 } else if (screen->ModeControl) {
1523 screen->Screen.ViewPort.DWidth = ns.Width;
1524 screen->Screen.ViewPort.DHeight = ns.Height;
1525 } else {
1526 ULONG stdwidth = dimensions.Nominal.MaxX - dimensions.Nominal.MinX + 1;
1527 ULONG stdheight = dimensions.Nominal.MaxY - dimensions.Nominal.MinY + 1;
1528
1529 screen->Screen.ViewPort.DWidth = min(ns.Width,stdwidth);
1530 screen->Screen.ViewPort.DHeight = min(ns.Height,stdheight);
1531 }
1532 #endif
1533 tags[0].ti_Tag = VTAG_ATTACH_CM_SET;
1534 tags[0].ti_Data = (IPTR)&screen->Screen.ViewPort;
1535 tags[1].ti_Tag = VTAG_VIEWPORTEXTRA_SET;
1536 tags[1].ti_Data = (IPTR)vpe;
1537 tags[2].ti_Tag = VTAG_NORMAL_DISP_SET;
1538 tags[2].ti_Data = (IPTR)displayinfo;
1539 tags[3].ti_Tag = VTAG_VPMODEID_SET;
1540 tags[3].ti_Data = modeid;
1541 tags[4].ti_Tag = VTAG_SPEVEN_BASE_SET; /* AROS: Added sprite base and user-supplied tags */
1542 tags[5].ti_Tag = VTAG_NEXTBUF_CM; /* if vctl is 0, this will terminate the list */
1543 tags[5].ti_Data = vctl;
1544
1545 /*
1546 * Originally we could always use palette entries 16-19 for
1547 * sprites, even if the screen has less than 32 colors. AROS may
1548 * run on hardware that does not allow this (e.g. VGA cards).
1549 * In this case we have to shift down sprite colors. Currently
1550 * we use 4 colors before last 4 colors. For example on VGA cards
1551 * with only 16 colors we use colors 9 - 12. Remember that last 4 colors
1552 * of the screen are always used by Intuition.
1553 * Remember that the first color of the sprite is always transparent. So actually
1554 * we use 3, not 4 colors.
1555 * Yes, sprites may look not as expected on screens with low color depth, but at
1556 * least they will be seen. It's better than nothing.
1557 *
1558 * Note that because our base color number doesn't always divide by 16, we use MSB to store
1559 * the remainder (offset in the color bank). Yes, it's a bit hacky, but i have no better idea
1560 * at the moment.
1561 *
1562 * FIXME: this mapping scheme assumes that we always have at least 16 colors.
1563 * For current display modes supported by AROS it's always true, but in future
1564 * we may support more display modes (for example monochrome ones), and we
1565 * should take into account that on screens with less than 11 colors this simply
1566 * won't work
1567 *
1568 * TODO: I think we should have SpriteBase attribute for the BitMap which
1569 * defaults to acceptable value. We should just get its default value here.
1570 * The same attribute would be set by VideoControl() and MakeVPort() in order
1571 * to actually apply the value.
1572 */
1573 #if (AROS_FLAVOUR & AROS_FLAVOUR_BINCOMPAT)
1574 spritebase = 16;
1575 #else
1576 spritebase = (ns.Depth < 5) ? (1 << ns.Depth) - 8 : 16;
1577 #endif
1578 DEBUG_OPENSCREEN(bug("OpenScreen: spritebase is %u\n", spritebase));
1579 tags[4].ti_Data = ((spritebase & 0x0F) << 8 ) | (spritebase >> 4);
1580
1581 if (VideoControl(screen->Screen.ViewPort.ColorMap, tags) == 0)
1582 {
1583 DEBUG_OPENSCREEN(dprintf("OpenScreen: VideoControl ok\n"));
1584 ok = TRUE;
1585 }
1586 else
1587 {
1588 DEBUG_OPENSCREEN(dprintf("OpenScreen: VideoControl failed\n"));
1589 }
1590 }
1591 }
1592
1593 if (ok)
1594 {
1595 struct Color32 *p;
1596 int k;
1597 UWORD *q;
1598
1599 DEBUG_OPENSCREEN(dprintf("OpenScreen: Set first 4 colors\n"));
1600
1601 p = IBase->Colors;
1602 for (k = 0; k < 4 && k < numcolors; ++k)
1603 {
1604 DEBUG_OPENSCREEN(dprintf("OpenScreen: SetRGB32 Viewport 0x%lx Index %ld R 0x%lx G 0x%lx B 0x%lx\n",
1605 screen->Screen.ViewPort,
1606 k, p[k].red, p[k].green, p[k].blue));
1607 SetRGB32(&screen->Screen.ViewPort, k, p[k].red, p[k].green, p[k].blue);
1608 }
1609
1610 if (ns.Depth >= 3)
1611 {
1612 /*
1613 * AROS: Use screen depth instead of 'numcolors' in order to calculate
1614 * numbers of last 4 colors of the screen.
1615 * This is necessary because we can have 8- or 16- color screen whose
1616 * ColorMap will still have 32 colors for AmigaOS(tm) compatibility
1617 * reasons.
1618 */
1619 ULONG lastcol = ((ns.Depth > 8) ? 256 : (1 << ns.Depth)) - 4;
1620
1621 DEBUG_OPENSCREEN(dprintf("OpenScreen: Set last 4 colors\n"));
1622
1623 for (k = 0; k < 4; ++k)
1624 {
1625 DEBUG_OPENSCREEN(dprintf("OpenScreen: SetRGB32 Viewport 0x%lx Index %ld R 0x%lx G 0x%lx B 0x%lx\n",
1626 screen->Screen.ViewPort,
1627 k + lastcol, p[k+4].red, p[k+4].green, p[k+4].blue));
1628
1629 if (k + lastcol < numcolors)
1630 {
1631 ObtainPen(screen->Screen.ViewPort.ColorMap,
1632 k + lastcol,
1633 p[k+4].red,
1634 p[k+4].green,
1635 p[k+4].blue,
1636 PEN_EXCLUSIVE);
1637 }
1638 else
1639 {
1640 SetRGB32(&screen->Screen.ViewPort, k + lastcol, p[k+4].red, p[k+4].green, p[k+4].blue);
1641 }
1642 }
1643 }
1644
1645 /*
1646 * AROS: AmigaOS(tm) 3.1-compatible mouse colors handling
1647 * 1. Allocate pens for the mouse pointer only on LUT screens.
1648 * On hi- and truecolor screens sprite colors come from colormap attached
1649 * to the sprite BitMap itself. See pointerclass::New() for details.
1650 * 2. Use 32-bit pointer colors instead of KS1.3 ActivePreferences->color17
1651 */
1652 if (ns.Depth < 9)
1653 {
1654 DEBUG_OPENSCREEN(dprintf("OpenScreen: Obtain Mousepointer colors\n"));
1655
1656 for (k = 1; k < 4; ++k, ++q)
1657 {
1658 DEBUG_OPENSCREEN(dprintf("OpenScreen: ColorMap 0x%P Pen %d R 0x%08X G 0x08X B 0x%08X\n",
1659 screen->Screen.ViewPort.ColorMap,
1660 k + spritebase,
1661 p[k+7].red, p[k+7].green, p[k+7].blue));
1662 if (k + spritebase < numcolors)
1663 {
1664 ObtainPen(screen->Screen.ViewPort.ColorMap,
1665 k + spritebase,
1666 p[k+7].red, p[k+7].green, p[k+7].blue,
1667 PEN_EXCLUSIVE);
1668 }
1669 else
1670 {
1671 /* Can't be allocated, but can still be set. */
1672 SetRGB32(&screen->Screen.ViewPort,
1673 k + spritebase,
1674 p[k+7].red, p[k+7].green, p[k+7].blue);
1675 }
1676 }
1677 }
1678
1679 if (colors) /* if SA_Colors tag exists */
1680 {
1681 DEBUG_OPENSCREEN(dprintf("OpenScreen: set SA_Colors 0x%lx\n",colors));
1682 for(; colors->ColorIndex != (WORD)~0; colors++)
1683 {
1684 DEBUG_OPENSCREEN(dprintf("OpenScreen: SetRGB4 Viewport 0x%lx Index %ld R 0x%lx G 0x%lx B 0x%lx\n",
1685 screen->Screen.ViewPort,
1686 colors,
1687 colors->Red,
1688 colors->Green,
1689 colors->Blue));
1690 SetRGB4(&screen->Screen.ViewPort,
1691 colors->ColorIndex,
1692 colors->Red,
1693 colors->Green,
1694 colors->Blue);
1695 }
1696 }
1697
1698 if (colors32) /* if SA_Colors32 tag exists */
1699 {
1700 DEBUG_OPENSCREEN(dprintf("OpenScreen: LoadRGB32 colors32 0x%lx\n",colors32));
1701 LoadRGB32(&screen->Screen.ViewPort, (const ULONG *)colors32);
1702 }
1703
1704 D(bug("Loaded colors\n"));
1705
1706 COPY(LeftEdge);
1707 COPY(TopEdge);
1708 COPY(Width);
1709 COPY(Height);
1710 COPY(DetailPen);
1711 COPY(BlockPen);
1712 COPY(Font);
1713 COPY(DefaultTitle);
1714
1715 //intui68k filters this
1716 screen->Screen.Flags = (ns.Type & ~NS_EXTENDED);
1717
1718 /* Temporary hack */
1719 if (ns.Width >= 500 || ns.Height >= 300)
1720 screen->Screen.Flags |= SCREENHIRES;
1721
1722 /*
1723 Copy the data from the rastport's BitMap
1724 to the screen's BitMap structure
1725 */
1726 UpdateScreenBitMap(&screen->Screen, IntuitionBase);
1727
1728 #ifdef __MORPHOS__
1729 screen->Screen.WBorTop = 2;
1730 screen->Screen.WBorLeft = 4;
1731 screen->Screen.WBorRight = 4;
1732 screen->Screen.WBorBottom = 2;
1733 #else
1734 screen->Screen.WBorTop = 6; /* Amiga default is 2 */
1735 screen->Screen.WBorLeft = 4;
1736 screen->Screen.WBorRight = 4;
1737 screen->Screen.WBorBottom = 4; /* Amiga default is 2 */
1738 #endif
1739
1740 screen->Screen.Title = ns.DefaultTitle;
1741
1742 DEBUG_OPENSCREEN(dprintf("OpenScreen: init layers\n"));
1743 #ifdef __AROS__ /* AROS: We have no compositing layers */
1744 InitLayers(&screen->Screen.LayerInfo);
1745 #else
1746 if (((struct Library *)LayersBase)->lib_Version >= 52 && compositing &&
1747 screen->IMonitorNode->Compositing)
1748 {
1749 struct TagItem layerinfotags[] =
1750 {
1751 {SA_Width,screen->Screen.Width},
1752 {SA_Height,screen->Screen.Height},
1753 {SA_PixelFormat,screen->PixelFormat},
1754 {MA_MemorySize,screen->IMonitorNode->BoardMemory},
1755 {LT_IgnoreMemoryChecks, IBase->LayerSettings.IgnoreMemoryChecks},
1756 {SA_CompositingLayers, TRUE},
1757 {TAG_DONE}
1758 };
1759 ULONG iscompositing = FALSE;
1760
1761 // make SA_CompositingLayers return TRUE (layers will ask)
1762 screen->Compositing = TRUE;
1763 InitScreenLayerInfo(&screen->Screen,layerinfotags);
1764
1765 // validate if we're compositing
1766 LayersControlTags(&screen->Screen.LayerInfo,
1767 LT_GetCompositing,(ULONG)&iscompositing,
1768
1769 // also set current layers settings
1770 LT_AllowDoubleBuffered, IBase->LayerSettings.AllowDoubleBuffered,
1771 LT_AllowTripleBuffered, IBase->LayerSettings.AllowTripleBuffered,
1772 LT_IgnoreMemoryChecks, IBase->LayerSettings.IgnoreMemoryChecks,
1773 LT_LoadBalancing, IBase->LayerSettings.LoadBalancing,
1774
1775 TAG_DONE);
1776
1777 screen->Compositing = iscompositing ? TRUE : FALSE;
1778 }
1779 else
1780 {
1781 struct TagItem layerinfotags[] =
1782 {
1783 {SA_CompositingLayers, FALSE},
1784 {TAG_DONE}
1785 };
1786 screen->Compositing = FALSE;
1787 InitScreenLayerInfo(&screen->Screen,layerinfotags);
1788 }
1789 #endif
1790 li_inited = TRUE;
1791
1792 if (NULL != layer_info_hook)
1793 {
1794 DEBUG_OPENSCREEN(dprintf("OpenScreen: install layerinfohook\n"));
1795 InstallLayerInfoHook(&screen->Screen.LayerInfo, layer_info_hook);
1796 }
1797 D(bug("layers inited screen\n"));
1798
1799 /* AROS: We have already obtained resolution data from DisplayInfo */
1800 #ifdef __AROS__
1801 screen->DInfo.dri_Version = DRI_VERSION;
1802 #else
1803 GetDisplayInfoData(NULL, (APTR)&dispinfo, sizeof(dispinfo), DTAG_DISP, modeid);
1804 screen->DInfo.dri_Version = MOS_DRI_VERSION;
1805 #endif
1806 screen->DInfo.dri_NumPens = NUMDRIPENS;
1807 screen->DInfo.dri_Pens = screen->Pens;
1808 /* dri_Depth is 8 on hi/true color screens like in AmigaOS with picasso96/cybergraphx */
1809 screen->DInfo.dri_Depth = (ns.Depth <= 8) ? ns.Depth : 8;
1810 /* AROS: Get resolution from DisplayInfo */
1811 screen->DInfo.dri_Resolution.X = dispinfo.Resolution.x;
1812 screen->DInfo.dri_Resolution.Y = dispinfo.Resolution.y;
1813 screen->DInfo.dri_Flags = 0;
1814
1815
1816 /* SA_SysFont overrides SA_Font! */
1817
1818 DEBUG_OPENSCREEN(dprintf("OpenScreen: SysFont = %d, ns.Font = %p\n", sysfont, ns.Font));
1819
1820 if (sysfont == 0)
1821 {
1822 /* Is handled below */
1823 DEBUG_OPENSCREEN(dprintf("OpenScreen: skip SysFont for now\n"));
1824 } else if (sysfont == 1) {
1825
1826 screen->DInfo.dri_Font = SafeReopenFont(IntuitionBase, &IBase->ScreenFont);
1827
1828 if (screen->DInfo.dri_Font)
1829 {
1830 screen->SysFont = TRUE;
1831 }
1832 DEBUG_OPENSCREEN(dprintf("OpenScreen: Set ScreenFont\n"));
1833
1834 } else if (ns.Font) {
1835 screen->DInfo.dri_Font = OpenFont(ns.Font);
1836 DEBUG_OPENSCREEN(dprintf("OpenScreen: custom font 0x%lx\n",screen->DInfo.dri_Font));
1837 }
1838
1839 if (!screen->DInfo.dri_Font)
1840 {
1841 /* GfxBase->DefaultFont is *not* always topaz 8. It
1842 can be set with the Font prefs program!! */
1843
1844 screen->DInfo.dri_Font = SafeReopenFont(IntuitionBase, &GfxBase->DefaultFont);
1845 }
1846
1847 if (!screen->DInfo.dri_Font) ok = FALSE;
1848
1849 } /* if (ok) */
1850
1851 if (ok)
1852 {
1853 ULONG *dripens = NULL;
1854
1855 switch (ns.Depth)
1856 {
1857 case 1:
1858 dripens = (ULONG*)&IBase->DriPens2;
1859 break;
1860
1861 case 2:
1862 dripens = (ULONG*)&IBase->DriPens4;
1863 break;
1864
1865 default:
1866 if (colors || colors32)
1867 {
1868 /* jDc: apps are used to use non-std colors for pen # >=4
1869 dripens4 will be a good fallback for this */
1870 dripens = (ULONG*)&IBase->DriPens4;
1871 } else {
1872 dripens = (ULONG*)&IBase->DriPens8;
1873 }
1874 break;
1875 }
1876
1877 /* set default values for pens */
1878 DEBUG_OPENSCREEN(dprintf("OpenScreen: Set Default Pens\n"));
1879 CopyMem(dripens,screen->Pens,sizeof(screen->Pens));
1880
1881 if (ns.Depth > 1)
1882 {
1883 DEBUG_OPENSCREEN(dprintf("OpenScreen: Set NewLook\n"));
1884 screen->DInfo.dri_Flags |= DRIF_NEWLOOK;
1885 }
1886
1887 if (customdripens)
1888 {
1889 WORD i;
1890
1891 DEBUG_OPENSCREEN(dprintf("OpenScreen: Set Custom Pens\n"));
1892 screen->Pens[DETAILPEN] = screen->Screen.DetailPen;
1893 screen->Pens[BLOCKPEN] = screen->Screen.BlockPen;
1894
1895 for(i = 0; (i < NUMDRIPENS) && (customdripens[i] != (UWORD)~0) && (screen->Pens[i] != (UWORD)~0); i++)
1896 {
1897 DEBUG_OPENSCREEN(dprintf("OpenScreen: Pen[%ld] %ld --> %ld\n",i,screen->Pens[i],customdripens[i]));
1898 screen->Pens[i] = customdripens[i];
1899 }
1900 }
1901
1902 /*
1903 * Let's do some broken software validation of the pens
1904 * so we may not run into a black desktop.
1905 */
1906
1907 DEBUG_OPENSCREEN(dprintf("OpenScreen: Check Default Pens if the make sense\n"));
1908 if (screen->Screen.DetailPen == screen->Screen.BlockPen)
1909 {
1910 DEBUG_OPENSCREEN(dprintf("OpenScreen: DetailPen==BlockPen..correct\n"));
1911 screen->Screen.DetailPen = 0;
1912 screen->Screen.BlockPen = 1;
1913 } else if (screen->Screen.BlockPen == 0)
1914 {
1915 DEBUG_OPENSCREEN(dprintf("OpenScreen: BlockPen==0..correct\n"));
1916 screen->Screen.BlockPen = screen->Screen.DetailPen;
1917 screen->Screen.DetailPen = 0;
1918 }
1919
1920 screen->Pens[DETAILPEN] = screen->Screen.DetailPen;
1921 screen->Pens[BLOCKPEN] = screen->Screen.BlockPen;
1922
1923 /* Allocate shared/exclusive colors */
1924
1925 {
1926 BYTE color_alloced[256];
1927 UWORD mask;
1928 WORD i;
1929
1930 /*for(i = 0; i < 256; i++)
1931 {
1932 color_alloced[i] = FALSE;
1933 }*/
1934 memclr(&color_alloced,256);
1935
1936 /* Mouse pointer colors */
1937
1938 color_alloced[17] = TRUE;
1939 color_alloced[18] = TRUE;
1940 color_alloced[19] = TRUE;
1941
1942 /* Clamp the pen numbers. This makes sure that values such as -4 or -3
1943 won't result in random memory trashing, but rather index colours from
1944 the end of the shareable palette. - Piru */
1945 mask = screen->Screen.ViewPort.ColorMap->PalExtra->pe_SharableColors & 0xff;
1946
1947 /* The Pens in the DrawInfo must be allocated as shared */
1948
1949 DEBUG_OPENSCREEN(dprintf("OpenScreen: ObtainPen DrawInfo Pens as shared\n"));
1950 for(i = 0; (i < NUMDRIPENS) && (screen->Pens[i] != (UWORD)~0); i++)
1951 {
1952 int pen = screen->Pens[i] & mask;
1953 if (!color_alloced[pen])
1954 {
1955 DEBUG_OPENSCREEN(dprintf("OpenScreen: ObtainPen ColorMap 0x%lx Pen %ld\n",
1956 screen->Screen.ViewPort.ColorMap,
1957 pen));
1958
1959 ObtainPen(screen->Screen.ViewPort.ColorMap,
1960 pen,
1961 0,
1962 0,
1963 0,
1964 PENF_NO_SETCOLOR);
1965 color_alloced[pen] = TRUE;
1966 }
1967 }
1968 DEBUG_OPENSCREEN(dprintf("OpenScreen: done\n"));
1969
1970 /* If SA_SharePens is FALSE then allocate the rest of the colors
1971 in the colormap as exclusive */
1972
1973 if (!sharepens)
1974 {
1975 ULONG shnumcolors = (requesteddepth <= 8) ? (1L << requesteddepth) : 256;
1976
1977 /* jDc: hack, colors above requested screen depth are not locked! */
1978
1979 DEBUG_OPENSCREEN(dprintf("OpenScreen: ObtainPen the remaining Pens as exclusive\n"));
1980 for(i = 0; i < shnumcolors; i++)
1981 {
1982 if (!color_alloced[i])
1983 {
1984 DEBUG_OPENSCREEN(dprintf("OpenScreen: ObtainPen ColorMap 0x%lx Pen %ld\n",
1985 screen->Screen.ViewPort.ColorMap,
1986 i));
1987 ObtainPen(screen->Screen.ViewPort.ColorMap,
1988 i,
1989 0,
1990 0,
1991 0,
1992 PENF_EXCLUSIVE | PENF_NO_SETCOLOR);
1993 }
1994 }
1995
1996 } /* if (!sharepens) */
1997
1998 }
1999 }
2000
2001 if (ok)
2002 {
2003 screen->DInfo.dri_Screen = &screen->Screen; //useful sometimes ;)
2004
2005 screen->realdepth = GetBitMapAttr( screen->Screen.RastPort.BitMap, BMA_DEPTH );
2006
2007 if (screen->realdepth > 8)
2008 {
2009 screen->DInfo.dri_Flags |= DRIF_DIRECTCOLOR;
2010 } else {
2011 screen->DInfo.dri_Flags &= ~DRIF_DIRECTCOLOR;
2012 }
2013
2014 #ifdef SKINS
2015 if (!(screen->DInfo.dri_Colors = AllocMem(4 * DRIPEN_NUMDRIPENS,MEMF_PUBLIC)))
2016 ok = FALSE;
2017
2018 if (ok)
2019 {
2020 CopyMem(&defaultdricolors,screen->DInfo.dri_Colors,sizeof (defaultdricolors));
2021 memset(((UBYTE *) screen->DInfo.dri_Colors) + sizeof(defaultdricolors), 0, 4 * DRIPEN_NUMDRIPENS - sizeof(defaultdricolors));
2022 }
2023 #endif
2024
2025 if (ok)
2026 {
2027 DEBUG_OPENSCREEN(dprintf("OpenScreen: allocating dri_Customize\n"));
2028
2029 if ((screen->DInfo.dri_Customize = AllocMem(sizeof (struct IntuitionCustomize),MEMF_PUBLIC|MEMF_CLEAR)))
2030 {
2031 #ifdef SKINS
2032 struct IntuitionCustomize *ic;
2033 ic = screen->DInfo.dri_Customize;
2034 screen->DInfo.dri_Flags |= DRIF_SKINSSUPPORT;
2035
2036 /* This initializes CustomizePrefs structure */
2037
2038 if (skinname) strcpy(ic->skinname,skinname);
2039
2040 InitSemaphore(&ic->InitLock);
2041
2042 DEBUG_OPENSCREEN(dprintf("OpenScreen: load skin %s for screen %lx\n",ic->skinname,screen));
2043 int_SkinAction(SKA_LoadSkin,(ULONG*)&screen->DInfo,(struct Screen *)screen,IntuitionBase);
2044 #else
2045 /* AROS: Use less error-prone skinname handling */
2046 ok = int_LoadDecorator(skinname, screen, IntuitionBase);
2047 #endif
2048 }
2049 else
2050 {
2051 ok = FALSE;
2052 }
2053 }
2054 }
2055
2056 #ifdef SKINS
2057 if (ok)
2058 {
2059 struct windowclassprefs *wcprefs;
2060 wcprefs = (struct windowclassprefs *)int_GetCustomPrefs(TYPE_WINDOWCLASS,&screen->DInfo,IntuitionBase);
2061 if (wcprefs->flags & WINDOWCLASS_PREFS_1TO1FRAMES)
2062 {
2063 screen->Screen.WBorLeft = screen->Screen.WBorTop;
2064 screen->Screen.WBorRight = screen->Screen.WBorTop;
2065 screen->Screen.WBorBottom = screen->Screen.WBorTop;
2066 }
2067 screen->Screen.WBorTop += wcprefs->titlebarincrement;
2068 int_FreeCustomPrefs(TYPE_WINDOWCLASS,&screen->DInfo,IntuitionBase);
2069 }
2070
2071 #endif
2072
2073 if (ok)
2074 {
2075 struct TagItem sysi_tags[] =
2076 {
2077 {SYSIA_Which, MENUCHECK },
2078 {SYSIA_DrawInfo, (IPTR)&screen->DInfo },
2079 {TAG_DONE }
2080 };
2081
2082 screen->DInfo.dri_CheckMark = NewObjectA(NULL, "sysiclass", sysi_tags);
2083 DEBUG_OPENSCREEN(dprintf("OpenScreen: CheckMark 0x%lx\n",
2084 screen->DInfo.dri_CheckMark));
2085
2086 sysi_tags[0].ti_Data = AMIGAKEY;
2087
2088 screen->DInfo.dri_AmigaKey = NewObjectA(NULL, "sysiclass", sysi_tags);
2089 DEBUG_OPENSCREEN(dprintf("OpenScreen: AmigaKey 0x%lx\n",
2090 screen->DInfo.dri_AmigaKey));
2091
2092 /* AROS: We also use submenu image */
2093 sysi_tags[0].ti_Data = SUBMENUIMAGE;
2094 screen->DInfo.dri_Customize->submenu = NewObjectA(NULL, "sysiclass", sysi_tags);
2095 if (!screen->DInfo.dri_Customize->submenu) ok =FALSE;
2096 #ifdef SKINS
2097 sysi_tags[0].ti_Data = MENUTOGGLEIMAGE;
2098 screen->DInfo.dri_Customize->menutoggle = NewObjectA(NULL, "sysiclass", sysi_tags);
2099 if (!screen->DInfo.dri_Customize->menutoggle) ok = FALSE;
2100 #endif
2101
2102 if (!screen->DInfo.dri_CheckMark || !screen->DInfo.dri_AmigaKey) ok = FALSE;
2103 }
2104
2105 if (ok)
2106 {
2107 SetFont(&screen->Screen.RastPort, screen->DInfo.dri_Font);
2108
2109 AskFont(&screen->Screen.RastPort, (struct TextAttr *) &screen->textattr);
2110
2111 screen->Screen.Font = (struct TextAttr *) &screen->textattr;
2112
2113 DEBUG_OPENSCREEN(dprintf("OpenScreen: Font %s/%d\n",
2114 screen->textattr.tta_Name, screen->textattr.tta_YSize));
2115
2116 screen->Screen.BarVBorder = 1;
2117 screen->Screen.BarHBorder = 5;
2118 screen->Screen.MenuVBorder = 2;
2119 screen->Screen.MenuHBorder = 4;
2120
2121 screen->Screen.BarHeight = screen->DInfo.dri_Font->tf_YSize + screen->Screen.WBorTop-2 +
2122 screen->Screen.BarVBorder * 2; /* real layer will be 1 pixel higher! */
2123
2124 /*
2125 * AROS: Get size information from decorator.
2126 * This has to be done before we create gadgets because here we may adjust BarHeight.
2127 */
2128 ok = int_InitDecorator(&screen->Screen);
2129 if (ok)
2130 {
2131 #define SDEPTH_HEIGHT (screen->Screen.BarHeight + 1)
2132 #ifdef IA_Screen
2133 #undef IA_Screen
2134 #endif
2135 #define IA_Screen (IA_Dummy + 0x1f) /* OS v44 includes!*/
2136
2137 struct TagItem sdepth_tags[] =
2138 {
2139 {GA_Image, 0 },
2140 {GA_Top, 0 },
2141 {GA_Height, SDEPTH_HEIGHT},
2142 {GA_SysGadget, TRUE },
2143 {GA_SysGType, GTYP_SDEPTH },
2144 {GA_RelVerify, TRUE },
2145 {TAG_DONE, 0UL }
2146 };
2147
2148 struct TagItem image_tags[] =
2149 {
2150 {IA_Left , 0 },
2151 //{IA_Width , SDEPTH_WIDTH + 1 },
2152 {IA_Height , SDEPTH_HEIGHT },
2153 {SYSIA_Which , SDEPTHIMAGE },
2154 {SYSIA_DrawInfo , (IPTR)&screen->DInfo},
2155 {SYSIA_Size , screen->Screen.Flags & SCREENHIRES ?
2156 SYSISIZE_MEDRES : SYSISIZE_LOWRES},
2157 {TAG_DONE }
2158 };
2159
2160 struct Object *im = 0;
2161
2162 if (!(screen->Screen.Flags & SCREENQUIET))
2163 {
2164 im = NewObjectA(NULL, SYSICLASS, image_tags);
2165 }
2166
2167 sdepth_tags[0].ti_Data = (IPTR)im;
2168
2169 screen->depthgadget = NewObjectA(IBase->windowsysiclass, NULL, sdepth_tags );
2170
2171 DEBUG_OPENSCREEN(dprintf("OpenScreen: DepthGadget 0x%lx\n",
2172 screen->depthgadget));
2173
2174 screen->Screen.FirstGadget = (struct Gadget *)screen->depthgadget;
2175 if (screen->Screen.FirstGadget)
2176 {
2177 struct TagItem gadtags[] =
2178 {
2179 {GA_RelRight, 0},
2180 {TAG_DONE }
2181 };
2182 IPTR width; /* AROS: Changed from int to IPTR, 64-bit fix */
2183
2184 GetAttr(GA_Width, screen->depthgadget, &width);
2185
2186 gadtags[0].ti_Data = -width + 1;
2187 SetAttrsA(screen->depthgadget, gadtags);
2188 screen->Screen.FirstGadget->GadgetType |= GTYP_SCRGADGET;
2189 } else {
2190 if (im) DisposeObject(im);
2191 }
2192
2193 #if DEBUG
2194 {
2195 int i;
2196 for (i=0;i<=screen->DInfo.dri_NumPens;i++)
2197 {
2198 DEBUG_OPENSCREEN(dprintf("OpenScreen: dri_Pen[%ld] = %ld\n",i,screen->DInfo.dri_Pens[i]));
2199 }
2200 }
2201 #endif
2202
2203 #ifdef USEWINDOWLOCK
2204 /* let's wait for user to finish window drag/size actions to avoid
2205 deadlocks and not break user's input */
2206 if (dowindowlock && (!(FindTask(NULL) == ((struct IIHData *)IBase->InputHandler->is_Data)->InputDeviceTask)))
2207 {
2208 LOCKWINDOW;
2209 windowlock = TRUE;
2210 screen->WindowLock = TRUE;
2211 }
2212 #endif
2213
2214 int_CalcSkinInfo(&screen->Screen,IntuitionBase);
2215 #ifdef SKINS
2216 int_InitTitlebarBuffer(&screen->Screen,IntuitionBase);
2217 #endif
2218 D(bug("calling SetRast()\n"));
2219
2220 DEBUG_OPENSCREEN(dprintf("OpenScreen: Set background color Pen %ld\n",screen->Pens[BACKGROUNDPEN]));
2221 /* Set screen to background color */
2222 SetRast(&screen->Screen.RastPort, screen->Pens[BACKGROUNDPEN]);
2223
2224 D(bug("SetRast() called\n"));
2225
2226 DEBUG_OPENSCREEN(dprintf("OpenScreen: Creating screen bar\n"));
2227
2228 #ifdef SKINS
2229 if (workbench)
2230 {
2231 #if 1
2232 if (IBase->IControlPrefs.ic_Flags & (ICF_DISAPPEARINGTITLEBAR | ICF_NOWBTITLEBAR)) screen->SpecialFlags |= SF_AppearingBar;
2233 #else
2234 if (IBase->IControlPrefs.ic_Flags & ICF_NOWBTITLEBAR) screen->SpecialFlags |= SF_InvisibleBar;
2235 if (IBase->IControlPrefs.ic_Flags & ICF_DISAPPEARINGTITLEBAR) screen->SpecialFlags |= SF_AppearingBar;
2236 #endif
2237 }
2238 #endif
2239
2240 //jDc: ALL screens MUST have BarLayer!
2241 CreateScreenBar(&screen->Screen, IntuitionBase);
2242
2243 if (!screen->Screen.BarLayer) ok = FALSE;
2244 }
2245
2246 if (ok)
2247 {
2248 if ((ns.Type & SCREENTYPE) == CUSTOMSCREEN)
2249 {
2250 screen->ShowPointer = showpointer;
2251 } else {
2252 screen->ShowPointer = TRUE;
2253 }
2254 #ifdef SKINS
2255 GetAttr(POINTERA_SharedPointer, screen->IMonitorNode->Pointers[POINTERTYPE_INVISIBLE], (IPTR *)&screen->Pointer);
2256 #else
2257 GetAttr(POINTERA_SharedPointer, IBase->DefaultPointer, (IPTR *)&screen->Pointer);
2258 #endif
2259 ObtainSharedPointer(screen->Pointer, IntuitionBase);
2260 DEBUG_OPENSCREEN(dprintf("OpenScreen: Sprite DefaultPtr 0x%lx\n",&screen->Pointer));
2261 }
2262
2263 /*
2264 ** jDc: better modify the screen list in sync with inputhandler, this for example allows us to scan the list
2265 ** without any locks when we are on input.device context
2266 */
2267 if (ok)
2268 {
2269 struct PubScreenNode *ps = NULL;
2270 struct List *list = LockPubScreenList();
2271
2272 /* Additional dupe check, just to be sure */
2273 if (!workbench && screen->pubScrNode && (ps = (struct PubScreenNode *)FindName(list,screen->pubScrNode->psn_Node.ln_Name)))
2274 {
2275 ok = FALSE;
2276 }
2277
2278 if (ok)
2279 {
2280 struct OpenScreenActionMsg msg;
2281
2282 msg.Screen = screen;
2283 msg.NewScreen = &ns;
2284 msg.List = list;
2285
2286 DoSyncAction((APTR)int_openscreen,&msg.msg,IntuitionBase);
2287
2288 ok = msg.Success;
2289 }
2290
2291 UnlockPubScreenList();
2292 }
2293
2294 } /* if (ok) */
2295
2296 #ifdef USEWINDOWLOCK
2297 if (windowlock) UNLOCKWINDOW;
2298 #endif
2299
2300 if (!ok)
2301 {
2302 if (li_inited)
2303 {
2304 DEBUG_OPENSCREEN(dprintf("OpenScreen: Get ThinLayerInfo\n"));
2305 ThinLayerInfo(&screen->Screen.LayerInfo);
2306 }
2307
2308 if (screen->Screen.ViewPort.ColorMap)
2309 {
2310 #ifdef __MORPHOS__
2311 struct TagItem tags[2];
2312
2313 tags[0].ti_Tag = VTAG_ATTACH_CM_GET;
2314 tags[0].ti_Data = 0;
2315 tags[1].ti_Tag = VTAG_END_CM;
2316
2317 if (VideoControl(screen->Screen.ViewPort.ColorMap, tags) == 0 &&
2318 tags[0].ti_Data)
2319 {
2320 GfxFree((APTR)tags[0].ti_Data);
2321 }
2322 #endif
2323
2324 FreeColorMap(screen->Screen.ViewPort.ColorMap);
2325 }
2326
2327 if (screen->Screen.BarLayer)
2328 {
2329 DEBUG_OPENSCREEN(dprintf("OpenScreen: KillScreenBar\n"));
2330 KillScreenBar(&screen->Screen, IntuitionBase);
2331 }
2332
2333 if (screen->DInfo.dri_Customize)
2334 {
2335 /* AROS: submenu image handling moved out of #ifdef */
2336 DisposeObject(screen->DInfo.dri_Customize->submenu);
2337 #ifdef SKINS
2338 DisposeObject(screen->DInfo.dri_Customize->menutoggle);
2339 #endif
2340 FreeMem(screen->DInfo.dri_Customize,sizeof (struct IntuitionCustomize));
2341 }
2342 #ifdef SKINS
2343 if (screen->DInfo.dri_Colors) FreeMem(screen->DInfo.dri_Colors,4 * DRIPEN_NUMDRIPENS);
2344 #endif
2345 if (screen->DInfo.dri_AmigaKey)
2346 {
2347 DEBUG_OPENSCREEN(dprintf("OpenScreen: Dispose AmigaKey Object\n"));
2348 DisposeObject(screen->DInfo.dri_AmigaKey);
2349 }
2350 if (screen->DInfo.dri_CheckMark)
2351 {
2352 DEBUG_OPENSCREEN(dprintf("OpenScreen: Dispose CheckMark Object\n"));
2353 DisposeObject(screen->DInfo.dri_CheckMark);
2354 }
2355
2356 if (screen->DInfo.dri_Font)
2357 {
2358 DEBUG_OPENSCREEN(dprintf("OpenScreen: Close Font\n"));
2359 CloseFont(screen->DInfo.dri_Font);
2360 }
2361
2362 if (screen->AllocatedBitMap && !(ns.Type & CUSTOMBITMAP))
2363 {
2364 DEBUG_OPENSCREEN(dprintf("OpenScreen: Free BitMap\n"));
2365 FreeBitMap(screen->AllocatedBitMap);
2366 }
2367
2368 if (screen->Screen.ViewPort.RasInfo)
2369 {
2370 DEBUG_OPENSCREEN(dprintf("OpenScreen: Free RasInfo\n"));
2371 FreeMem(screen->Screen.ViewPort.RasInfo, sizeof (struct RasInfo));
2372 }
2373
2374 if (rp_inited)
2375 {
2376 DEBUG_OPENSCREEN(dprintf("OpenScreen: Trash Rastport\n"));
2377 DeinitRastPort(&screen->Screen.RastPort);
2378 }
2379
2380 DEBUG_OPENSCREEN(dprintf("OpenScreen: Free Screen\n"));
2381 DisposeObject((APTR)screen);
2382 screen = 0;
2383
2384 } /* if (!ok) */
2385
2386 DEBUG_OPENSCREEN(dprintf("OpenScreen: return 0x%lx\n", screen));
2387
2388 FireScreenNotifyMessage((IPTR) screen, SNOTIFY_AFTER_OPENSCREEN, IntuitionBase);
2389
2390 ReturnPtr ("OpenScreen", struct Screen *, (struct Screen *)screen);
2391
2392 AROS_LIBFUNC_EXIT
2393
2394 } /* OpenScreen */
2395
2396 VOID int_openscreen(struct OpenScreenActionMsg *msg,
2397 struct IntuitionBase *IntuitionBase)
2398 {
2399 struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
2400 struct IntScreen *screen = msg->Screen;
2401 struct NewScreen *ns = msg->NewScreen;
2402 struct List *list = msg->List;
2403 struct Screen *oldFirstScreen;
2404 struct RethinkDisplayActionMsg rmsg;
2405 ULONG lock = 0;
2406
2407 DEBUG_OPENSCREEN(dprintf("OpenScreen: Checking for pubScrNode (0x%lx)\n",screen->pubScrNode));
2408
2409 /* If this is a public screen, we link it into the intuition global
2410 public screen list */
2411 if (screen->pubScrNode != NULL)
2412 {
2413 /* Set the pointer to ourselves */
2414 IS(screen)->pubScrNode->psn_Screen = &screen->Screen;
2415
2416 DEBUG_OPENSCREEN(dprintf("OpenScreen: Add Screen to PubList\n"));
2417 AddTail(list, (struct Node *)IS(screen)->pubScrNode);
2418 }
2419
2420 if (!ILOCKCHECK(((struct IntuiActionMsg *)msg))) lock = LockIBase((IPTR)NULL);
2421
2422 oldFirstScreen = IntuitionBase->FirstScreen;
2423 if (ns->Type & SCREENBEHIND)
2424 {
2425 struct Screen **ptr = &IntuitionBase->FirstScreen;
2426
2427 DEBUG_OPENSCREEN(dprintf("OpenScreen: Sort Behind\n"));
2428 if (!*ptr)
2429 IntuitionBase->ActiveScreen = &screen->Screen;
2430 while (*ptr)
2431 ptr = &(*ptr)->NextScreen;
2432 *ptr = &screen->Screen;
2433 }
2434 else
2435 {
2436 screen->Screen.NextScreen = IntuitionBase->FirstScreen;
2437 IntuitionBase->FirstScreen =
2438 IntuitionBase->ActiveScreen = &screen->Screen;
2439 DEBUG_OPENSCREEN(dprintf("OpenScreen: Set as ActiveScreen\n"));
2440 }
2441
2442 /* AROS: If it's the first screen being opened, activate its monitor */
2443 if (!oldFirstScreen)
2444 ActivateMonitor(screen->IMonitorNode, -1, -1, IntuitionBase);
2445
2446 /* set the default pub screen */
2447 if (IBase->IControlPrefs.ic_Flags & ICF_DEFPUBSCREEN)
2448 {
2449 if ((IntuitionBase->FirstScreen == &screen->Screen) && screen->pubScrNode && (screen->Screen.Flags & (PUBLICSCREEN | WBENCHSCREEN)))
2450 {
2451 IBase->DefaultPubScreen = &screen->Screen;
2452 }
2453 }
2454
2455 msg->Success = MakeVPort(&IntuitionBase->ViewLord, &screen->Screen.ViewPort) ? FALSE : TRUE;
2456
2457 if (msg->Success)
2458 {
2459 /* AROS: Put offsets validated by MakeVPort() back into screen structure */
2460 screen->Screen.LeftEdge = screen->Screen.ViewPort.DxOffset;
2461 screen->Screen.TopEdge = screen->Screen.ViewPort.DyOffset;
2462
2463 rmsg.lock = FALSE;
2464 int_RethinkDisplay(&rmsg,IntuitionBase);
2465 }
2466
2467 #ifdef SKINS
2468 if (!(ns->Type & SCREENBEHIND))
2469 {
2470 // workaround: do not send the event for SCREENBEHIND cause it'd reset the DPMS counter
2471 QueryBlankerEvent(BLANKEREVENT_SCREENDEPTH,(ULONG)screen->IMonitorNode,IntuitionBase);
2472 }
2473 #endif
2474
2475 if (!ILOCKCHECK(((struct IntuiActionMsg *)msg))) UnlockIBase(lock);
2476
2477 D(bug("set active screen\n"));
2478
2479 AddResourceToList(screen, RESOURCE_SCREEN, IntuitionBase);
2480 }
2481
2482
Mirror of AROS' svn.