?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Minor fixes to comments.
[AROS.git] / rom / intuition / openscreen.c
blob20db9bbd7885fbfcc429ae79dcfa50afab6df345
1 /*
2 Copyright © 1995-2011, The AROS Development Team. All rights reserved.
3 Copyright © 2001-2003, The MorphOS Development Team. All Rights Reserved.
4 $Id$
5
6 Open a new screen.
7 */
8
9 #include <aros/config.h>
10 #include <exec/memory.h>
11 #include <utility/tagitem.h>
12 #include <intuition/screens.h>
13 #include <intuition/intuition.h>
14 #include <intuition/imageclass.h>
15 #include <intuition/windecorclass.h>
16 #include <intuition/scrdecorclass.h>
17 #include <intuition/gadgetclass.h>
18 #include <intuition/extensions.h>
19 #include <graphics/modeid.h>
20 #include <graphics/videocontrol.h>
21 #include <graphics/displayinfo.h>
22 #include <prefs/screenmode.h>
23 #include <proto/exec.h>
24 #include <proto/graphics.h>
25 #include <proto/layers.h>
26 #include <proto/utility.h>
27 #include <proto/intuition.h>
28 #include <proto/dos.h>
29 #include <string.h>
30 #include <proto/cybergraphics.h>
31 #include <cybergraphx/cybergraphics.h>
32 #include "intuition_intern.h"
33 #include "intuition_customize.h"
34 #include "intuition_extend.h"
35 #include "inputhandler.h"
36 #include "inputhandler_support.h"
37 #include "inputhandler_actions.h"
38 #include "menus.h"
39 #include "monitorclass_private.h"
40
41 #ifndef DEBUG_OpenScreen
42 #define DEBUG_OpenScreen 0
43 #endif
44 #undef DEBUG
45 #if DEBUG_OpenScreen
46 #define DEBUG 1
47 #endif
48 #include <aros/debug.h>
49
50 struct OpenScreenActionMsg
51 {
52 struct IntuiActionMsg msg;
53 struct IntScreen *Screen;
54 struct NewScreen *NewScreen;
55 struct List *List;
56 };
57
58 static VOID int_openscreen(struct OpenScreenActionMsg *msg,
59 struct IntuitionBase *IntuitionBase);
60
61 #ifdef SKINS
62 extern const ULONG defaultdricolors[DRIPEN_NUMDRIPENS];
63 #endif
64
65 /*****************************************************************************
66
67 NAME */
68
69 AROS_LH1(struct Screen *, OpenScreen,
70
71 /* SYNOPSIS */
72 AROS_LHA(struct NewScreen *, newScreen, A0),
73
74 /* LOCATION */
75 struct IntuitionBase *, IntuitionBase, 33, Intuition)
76
77 /* FUNCTION
78
79 INPUTS
80
81 RESULT
82
83 NOTES
84
85 EXAMPLE
86
87 BUGS
88
89 SEE ALSO
90
91 INTERNALS
92 The function relies on private data being passed in DimensionInfo.reserved[0]
93 by graphics.library/GetDisplayInfoData(). Keep this in sync when modifying
94 the code.
95
96 HISTORY
97 29-10-95 digulla automatically created from
98 intuition_lib.fd and clib/intuition_protos.h
99
100 *****************************************************************************/
101 {
102 AROS_LIBFUNC_INIT
103
104 struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
105 struct LayersBase *LayersBase = GetPrivIBase(IntuitionBase)->LayersBase;
106 struct Library *UtilityBase = GetPrivIBase(IntuitionBase)->UtilityBase;
107 struct NewScreen ns;
108 struct TagItem *tag, *tagList;
109 IPTR vctl = 0;
110 struct IntScreen *screen;
111 int success;
112 struct Hook *layer_info_hook = NULL;
113 struct ColorSpec *colors = NULL;
114 ULONG *errorPtr; /* Store error at user specified location */
115 UWORD *customdripens = NULL;
116 ULONG *colors32 = NULL;
117 WORD sysfont = -1;
118 BOOL ok = TRUE, rp_inited = FALSE, li_inited = FALSE, sharepens = FALSE;
119 #ifdef USEWINDOWLOCK
120 BOOL windowlock = FALSE;
121 #endif
122 struct Rectangle *dclip = NULL;
123 LONG overscan = OSCAN_TEXT;
124 DisplayInfoHandle displayinfo;
125 struct DimensionInfo dimensions;
126 #ifdef __MORPHOS__
127 struct MonitorInfo monitor;
128 #endif
129 ULONG allocbitmapflags = BMF_DISPLAYABLE;
130 //ULONG lock;
131 WORD numcolors = 0;
132 UWORD spritebase;
133 #ifdef SKINS
134 BOOL workbench = FALSE;
135 #endif
136 BOOL draggable = TRUE;
137 struct TagItem modetags[] =
138 {
139 { BIDTAG_Depth , 0UL },
140 { BIDTAG_DesiredWidth , 0UL },
141 { BIDTAG_DesiredHeight , 0UL },
142 { BIDTAG_DIPFMustHave , 0UL },
143 { TAG_DONE }
144 };
145 ULONG modeid = INVALID_ID;
146 struct DisplayInfo dispinfo;
147
148 /* Intuition not up yet? */
149 if (!GetPrivIBase(IntuitionBase)->DefaultPointer)
150 return FALSE;
151
152 ASSERT_VALID_PTR_ROMOK(newScreen);
153
154 #define COPY(x) screen->Screen.x = ns.x
155 #define SetError(x) if (errorPtr != NULL) *errorPtr = x;
156
157 D(bug("OpenScreen (%p = { Left=%d Top=%d Width=%d Height=%d Depth=%d Mode=%04x })\n"
158 , newScreen
159 , newScreen->LeftEdge
160 , newScreen->TopEdge
161 , newScreen->Width
162 , newScreen->Height
163 , newScreen->Depth
164 , newScreen->ViewModes
165 ));
166
167 FireScreenNotifyMessage((IPTR) newScreen, SNOTIFY_BEFORE_OPENSCREEN, IntuitionBase);
168
169 ns = *newScreen;
170
171 if (newScreen->Type & NS_EXTENDED)
172 {
173 tagList = ((struct ExtNewScreen *)newScreen)->Extension;
174 }
175 else
176 {
177 tagList = NULL;
178 }
179
180 DEBUG_OPENSCREEN(dprintf("OpenScreen: Left %d Top %d Width %d Height %d Depth %d Tags 0x%lx\n",
181 ns.LeftEdge, ns.TopEdge, ns.Width, ns.Height, ns.Depth, tagList));
182
183 #ifdef __MORPHOS__
184 if (!LocaleBase) LocaleBase = OpenLibrary("locale.library",0);
185 if (!LocaleBase) return NULL;
186 #endif
187
188 #ifdef USEGETIPREFS //needs INTUITION_THEME_ENCHANCEMENT!
189 if (!GetPrivIBase(IntuitionBase)->IPrefsLoaded && FindPort(SKINMANAGERPORTNAME))
190 {
191 /* let's init prefs before 1st OpenScreen that needs them*/
192 int_SkinAction(SKA_GetIPrefs,0,0,IntuitionBase);
193 }
194 #endif
195
196 screen = AllocMem(sizeof (struct IntScreen), MEMF_ANY | MEMF_CLEAR);
197
198 DEBUG_OPENSCREEN(dprintf("OpenScreen: screen 0x%lx\n", screen));
199
200 /* Do this really early to be able to report errors */
201 errorPtr = (ULONG *)GetTagData(SA_ErrorCode, 0, tagList);
202
203 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_ErrorCode 0x%lx\n",errorPtr));
204
205 if (screen == NULL)
206 {
207 FireScreenNotifyMessage((IPTR) NULL, SNOTIFY_AFTER_OPENSCREEN, IntuitionBase);
208 SetError(OSERR_NOMEM);
209 return NULL;
210 }
211
212 if (tagList)
213 {
214 if (GetTagData(SA_LikeWorkbench, FALSE, tagList))
215 {
216
217 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_LikeWorkbench\n"));
218
219 ns.Width = GetPrivIBase(IntuitionBase)->ScreenModePrefs.smp_Width;
220 ns.Height = GetPrivIBase(IntuitionBase)->ScreenModePrefs.smp_Height;
221 ns.Depth = GetPrivIBase(IntuitionBase)->ScreenModePrefs.smp_Depth;
222 modeid = GetPrivIBase(IntuitionBase)->ScreenModePrefs.smp_DisplayID;
223
224 if (GetPrivIBase(IntuitionBase)->ScreenModePrefs.smp_Control & SMF_AUTOSCROLL)
225 {
226 /* need to mark autoscroll */
227 ns.Type |= AUTOSCROLL;
228 }
229 sysfont = 1;
230 sharepens = TRUE; /* not sure */
231 }
232
233 while((tag = NextTagItem(&tagList)))
234 {
235 DEBUG_OPENSCREEN(dprintf("OpenScreen: Tag 0x%08lx Data 0x%08lx\n",
236 tag->ti_Tag, tag->ti_Data));
237 switch(tag->ti_Tag)
238 {
239 case SA_Left:
240 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Left %ld\n",tag->ti_Data));
241 ns.LeftEdge = tag->ti_Data;
242 break;
243
244 case SA_Top:
245 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Top %ld\n",tag->ti_Data));
246 ns.TopEdge = tag->ti_Data;
247 break;
248
249 case SA_Width:
250 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Width %ld\n",tag->ti_Data));
251 ns.Width = tag->ti_Data;
252 break;
253
254 case SA_Height:
255 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Height %ld\n",tag->ti_Data));
256 ns.Height = tag->ti_Data;
257 break;
258
259 case SA_Depth:
260 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Depth %ld\n",tag->ti_Data));
261 ns.Depth = tag->ti_Data;
262 break;
263
264 case SA_DetailPen:
265 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_DetailPen %ld\n",tag->ti_Data));
266 ns.DetailPen = tag->ti_Data;
267 break;
268
269 case SA_BlockPen:
270 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_BlockPen %ld\n",tag->ti_Data));
271 ns.BlockPen = tag->ti_Data;
272 break;
273
274 case SA_Type:
275 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Type 0x%lx\n",tag->ti_Data));
276 ns.Type &= ~SCREENTYPE;
277 ns.Type |= tag->ti_Data;
278 break;
279
280 case SA_Title:
281 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Title <%s>\n",tag->ti_Data));
282 ns.DefaultTitle = (UBYTE *)tag->ti_Data;
283 break;
284
285 case SA_Font:
286 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Font 0x%lx\n",tag->ti_Data));
287 ns.Font = (struct TextAttr *)tag->ti_Data;
288 break;
289
290 case SA_Colors32:
291 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Colors32 0x%lx\n",tag->ti_Data));
292 colors32 = (ULONG *)tag->ti_Data;
293 break;
294
295 case SA_Colors:
296 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Colors 0x%lx\n",tag->ti_Data));
297 colors = (struct ColorSpec *)tag->ti_Data;
298 break;
299
300 case SA_SysFont:
301 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_SysFont 0x%lx\n",tag->ti_Data));
302 sysfont = (WORD)tag->ti_Data;
303 break;
304
305 case SA_BitMap:
306 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_BitMap 0x%lx\n",tag->ti_Data));
307 if(tag->ti_Data)
308 {
309 ns.Type |= CUSTOMBITMAP;
310 ns.CustomBitMap = (struct BitMap *)tag->ti_Data;
311 }
312 else
313 {
314 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_BitMap==NULL specified, custom bitmap use disabled\n"));
315 }
316 break;
317
318 /* Name of this public screen. */
319 case SA_PubName:
320 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_PubName <%s>\n",tag->ti_Data));
321 if (!tag->ti_Data)
322 {
323 screen->pubScrNode = AllocMem(sizeof(struct PubScreenNode), MEMF_CLEAR);
324 break;
325 }
326 else
327 {
328 struct Screen *old;
329
330 LockPubScreenList();
331
332 if (strcasecmp((char *)tag->ti_Data, "Workbench") == 0)
333 {
334 /* FIXME: This would still not be safe, if a normal app tried to open its own screen with SA_PubName=Workbench */
335 if (GetPrivIBase(IntuitionBase)->WorkBench)
336 {
337 UnlockPubScreenList();
338
339 FireScreenNotifyMessage((IPTR) NULL, SNOTIFY_AFTER_OPENSCREEN, IntuitionBase);
340
341 return NULL;
342 }
343 #ifdef SKINS
344 workbench = TRUE;
345 #endif
346 }
347 else
348 {
349 old = LockPubScreen((STRPTR)tag->ti_Data);
350
351 if (old != NULL)
352 {
353 UnlockPubScreen(NULL, old);
354 SetError(OSERR_PUBNOTUNIQUE);
355 UnlockPubScreenList();
356 FireScreenNotifyMessage((IPTR) NULL, SNOTIFY_AFTER_OPENSCREEN, IntuitionBase);
357
358 return NULL;
359 }
360 }
361
362 UnlockPubScreenList();
363 }
364
365 screen->pubScrNode = AllocMem(sizeof(struct PubScreenNode), MEMF_CLEAR);
366
367 DEBUG_OPENSCREEN(dprintf("OpenScreen: pubScrNode 0x%lx\n",screen->pubScrNode));
368
369 if (screen->pubScrNode == NULL)
370 {
371 SetError(OSERR_NOMEM);
372 FireScreenNotifyMessage((IPTR) NULL, SNOTIFY_AFTER_OPENSCREEN, IntuitionBase);
373
374 return NULL;
375 }
376
377 if ((ns.Type & SCREENTYPE) == CUSTOMSCREEN)
378 {
379 ns.Type &= ~SCREENTYPE;
380 ns.Type |= PUBLICSCREEN;
381 }
382
383 screen->pubScrNode->psn_Node.ln_Name = AllocVec(MAXPUBSCREENNAME + 1,
384 MEMF_ANY);
385
386 if (screen->pubScrNode->psn_Node.ln_Name == NULL)
387 {
388 SetError(OSERR_NOMEM);
389 FreeMem(screen->pubScrNode, sizeof(struct PubScreenNode));
390 FireScreenNotifyMessage((IPTR) NULL, SNOTIFY_AFTER_OPENSCREEN, IntuitionBase);
391
392 return NULL;
393 }
394
395 /* Always open public screens in private mode. */
396 screen->pubScrNode->psn_Flags |= PSNF_PRIVATE;
397 strcpy(screen->pubScrNode->psn_Node.ln_Name, (STRPTR)tag->ti_Data);
398 break;
399
400 /* Signal bit number to use when signalling public screen
401 signal task. */
402 case SA_PubSig:
403 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_PubSig 0x%lx\n",tag->ti_Data));
404 if (screen->pubScrNode == NULL)
405 {
406 FireScreenNotifyMessage((IPTR) NULL, SNOTIFY_AFTER_OPENSCREEN, IntuitionBase);
407
408 return NULL;
409 }
410 /* If no PubTask is set, we set the calling task as default */
411 if (screen->pubScrNode->psn_SigTask == NULL)
412 screen->pubScrNode->psn_SigTask = FindTask(NULL);
413
414 screen->pubScrNode->psn_SigBit = (UBYTE)tag->ti_Data;
415 break;
416
417 /* Task that should be signalled when the public screen loses
418 its last visitor window. */
419 case SA_PubTask:
420 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_PubTask 0x%lx\n",tag->ti_Data));
421 if (screen->pubScrNode == NULL)
422 {
423 FireScreenNotifyMessage((IPTR) NULL, SNOTIFY_AFTER_OPENSCREEN, IntuitionBase);
424 return NULL;
425 }
426 screen->pubScrNode->psn_SigTask = (struct Task *)tag->ti_Data;
427 break;
428
429 case SA_BackFill:
430 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_BackFill Hook 0x%lx\n",tag->ti_Data));
431 layer_info_hook = (struct Hook *)tag->ti_Data;
432 break;
433
434 case SA_Quiet:
435 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Quiet 0x%lx\n",tag->ti_Data));
436 if (tag->ti_Data)
437 {
438 ns.Type |= SCREENQUIET;
439 }
440 else
441 {
442 ns.Type &= ~SCREENQUIET;
443 }
444 break;
445
446 case SA_ShowTitle:
447 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_ShowTitle 0x%lx\n",tag->ti_Data));
448 if (tag->ti_Data)
449 {
450 ns.Type |= SHOWTITLE;
451 }
452 else
453 {
454 ns.Type &= ~SHOWTITLE;
455 }
456 break;
457
458 case SA_Pens:
459 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Pens 0x%lx\n",tag->ti_Data));
460 customdripens = (UWORD *)tag->ti_Data;
461 break;
462
463 case SA_DisplayID:
464 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_DisplayID 0x%lx\n",tag->ti_Data));
465 //if (modeid == INVALID_ID)
466 modeid = tag->ti_Data;
467 break;
468
469 case SA_SharePens:
470 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_SharePens 0x%lx\n",tag->ti_Data));
471 sharepens = tag->ti_Data ? TRUE : FALSE;
472 if (tag->ti_Data)
473 {
474 ns.Type |= PENSHARED;
475 }
476 else
477 {
478 ns.Type &= ~PENSHARED;
479 }
480 break;
481
482 case SA_Interleaved:
483 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Interleaved 0x%lx\n",tag->ti_Data));
484 if (tag->ti_Data)
485 {
486 allocbitmapflags |= BMF_INTERLEAVED;
487 }
488 else
489 {
490 allocbitmapflags &= ~BMF_INTERLEAVED;
491 }
492 break;
493
494 case SA_Behind:
495 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Behind 0x%lx\n",tag->ti_Data));
496 if (tag->ti_Data)
497 {
498 ns.Type |= SCREENBEHIND;
499 }
500 else
501 {
502 ns.Type &= ~SCREENBEHIND;
503 }
504 break;
505
506 case SA_DClip:
507 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_DClip 0x%lx\n",tag->ti_Data));
508 dclip = (struct Rectangle *)tag->ti_Data;
509 break;
510
511 case SA_Overscan:
512 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_OverScan 0x%lx\n",tag->ti_Data));
513 overscan = tag->ti_Data;
514 break;
515
516 case SA_LikeWorkbench:
517 case SA_ErrorCode:
518 /*
519 * handled elsewhere
520 */
521 break;
522
523 case SA_AutoScroll:
524 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_AutoScroll 0x%lx\n",tag->ti_Data));
525 ns.Type |= AUTOSCROLL;
526 break;
527
528 case SA_FullPalette:
529 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_FullPalette 0x%lx\n",tag->ti_Data));
530 break;
531
532 case SA_ColorMapEntries:
533 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_ColorMapEntries 0x%lx\n",tag->ti_Data));
534 numcolors = tag->ti_Data;
535 break;
536
537 case SA_Parent:
538 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Parent 0x%lx\n",tag->ti_Data));
539 break;
540
541 case SA_Draggable:
542 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Draggable 0x%lx\n",tag->ti_Data));
543 draggable = tag->ti_Data;
544 break;
545
546 case SA_Exclusive:
547 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_Exclusive 0x%lx\n",tag->ti_Data));
548 break;
549
550 case SA_VideoControl:
551 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_VideoControl 0x%p\n",tag->ti_Data));
552 vctl = tag->ti_Data;
553 break;
554
555 case SA_FrontChild:
556 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_FrontChild 0x%lx\n",tag->ti_Data));
557 break;
558
559 case SA_BackChild:
560 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_BackChild 0x%lx\n",tag->ti_Data));
561 break;
562
563 case SA_MinimizeISG:
564 DEBUG_OPENSCREEN(dprintf("OpenScreen: SA_MinimizeISG 0x%lx\n",tag->ti_Data));
565 break;
566
567 /* TODO: Missing SA_ Tags */
568 default:
569 DEBUG_OPENSCREEN(dprintf("OpenScreen: unknown tag 0x%lx data 0x%lx\n",
570 tag->ti_Tag,
571 tag->ti_Data));
572 break;
573
574 } /* switch (tag->ti_Tag) */
575
576 } /* while ((tag = NextTagItem (&tagList))) */
577
578 } /* if (tagList) */
579
580 DEBUG_OPENSCREEN(dprintf("OpenScreen: Requested: Left %d Top %d Width %d Height %d Depth %d Tags 0x%lx\n",
581 ns.LeftEdge, ns.TopEdge, ns.Width, ns.Height, ns.Depth, tagList));
582
583 /* First Init the RastPort then get the BitPlanes!! */
584
585 modetags[0].ti_Data = ns.Depth;
586 if (ns.Width != STDSCREENWIDTH)
587 {
588 modetags[1].ti_Data = ns.Width;
589 }
590 else
591 {
592 modetags[1].ti_Tag = TAG_IGNORE;
593 }
594
595 if (ns.Height != STDSCREENHEIGHT)
596 {
597 modetags[2].ti_Data = ns.Height;
598 }
599 else
600 {
601 modetags[2].ti_Tag = TAG_IGNORE;
602 }
603
604 /* if default HIRES_KEY or HIRESLACE_KEY is passed, make sure we find a replacement mode. */
605 if (INVALID_ID != modeid)
606 {
607 if (FindDisplayInfo(modeid) == NULL)
608 {
609 switch(modeid)
610 {
611 case HIRES_KEY:
612 case HIRESLACE_KEY:
613 {
614 modetags[1].ti_Data = ns.Width;
615 modetags[2].ti_Data = ns.Height;
616
617 DEBUG_OPENSCREEN(dprintf("resetting native mode id !!\n");)
618 DEBUG_OPENSCREEN(dprintf("ns.Width %ld ns.Height %ld ns.Depth %ld !!\n",
619 (LONG) ns.Width, (LONG) ns.Height, (LONG) ns.Depth);)
620
621 modeid = INVALID_ID;
622 }
623 break;
624
625 default:
626 break;
627 }
628 #ifdef __mc68000
629 /* Got OpenScreenTags modeid without monitor, select system default.
630 * We really need proper mode promotion support.
631 */
632 if ((modeid & MONITOR_ID_MASK) == 0) {
633 modeid |= (GfxBase->DisplayFlags & PAL) ? PAL_MONITOR_ID : NTSC_MONITOR_ID;
634 }
635 #endif
636 }
637 }
638
639 if (INVALID_ID == modeid)
640 {
641 /* Old-style HAM or EHB request? */
642 if (newScreen->ViewModes & (HAM | EXTRA_HALFBRITE)) {
643 if (newScreen->ViewModes & HAM)
644 modetags[3].ti_Data |= DIPF_IS_HAM;
645 if (newScreen->ViewModes & EXTRA_HALFBRITE)
646 modetags[3].ti_Data |= DIPF_IS_EXTRAHALFBRITE;
647 } else {
648 modetags[3].ti_Tag = TAG_IGNORE;
649 }
650 modeid = BestModeIDA(modetags);
651 if (INVALID_ID == modeid)
652 {
653 DEBUG_OPENSCREEN(dprintf("!!! OpenScreen: Could not find valid modeid !!!\n");)
654
655 SetError(OSERR_UNKNOWNMODE);
656 FireScreenNotifyMessage((IPTR) NULL, SNOTIFY_AFTER_OPENSCREEN, IntuitionBase);
657
658 return NULL;
659 }
660 }
661
662 DEBUG_OPENSCREEN(dprintf("OpenScreen: Corrected ModeID: 0x%08lx\n", modeid));
663
664 InitRastPort(&screen->Screen.RastPort);
665 rp_inited = TRUE;
666 success = FALSE;
667
668 if ((displayinfo = FindDisplayInfo(modeid)) != NULL &&
669 GetDisplayInfoData(displayinfo, (APTR)&dispinfo, sizeof(dispinfo), DTAG_DISP, modeid)) {
670 screen->DInfo.dri.dri_Resolution.X = dispinfo.Resolution.x;
671 screen->DInfo.dri.dri_Resolution.Y = dispinfo.Resolution.y;
672 } else {
673 /* Fake a resolution */
674 screen->DInfo.dri.dri_Resolution.X = 22;
675 screen->DInfo.dri.dri_Resolution.Y = 22;
676 }
677
678 if ((displayinfo = FindDisplayInfo(modeid)) != NULL &&
679 GetDisplayInfoData(displayinfo, (APTR)&dimensions, sizeof(dimensions), DTAG_DIMS, modeid) &&
680 #ifdef __MORPHOS__
681 GetDisplayInfoData(displayinfo, &monitor, sizeof(monitor), DTAG_MNTR, modeid)
682 #else
683 ((screen->MonitorObject = FindMonitor(modeid, IntuitionBase)) != NULL)
684 #endif
685 )
686 {
687 #ifdef __MORPHOS__
688 screen->Monitor = monitor.Mspc;
689 #else
690 /* graphics.library supplies HIDD composition flags here, specially for us */
691 screen->SpecialFlags = dimensions.reserved[0] << 8;
692 #endif
693 success = TRUE;
694
695 if (dclip == NULL)
696 {
697 switch (overscan)
698 {
699 case OSCAN_STANDARD:
700 dclip = &dimensions.StdOScan;
701 break;
702
703 case OSCAN_MAX:
704 dclip = &dimensions.MaxOScan;
705 break;
706
707 case OSCAN_VIDEO:
708 dclip = &dimensions.VideoOScan;
709 break;
710
711 default:
712 dclip = &dimensions.TxtOScan;
713 break;
714 }
715 }
716
717 if (ns.Width == STDSCREENWIDTH)
718 ns.Width = dclip->MaxX - dclip->MinX + 1;
719 else if (ns.Width < dimensions.MinRasterWidth)
720 ns.Width = dimensions.MinRasterWidth;
721 else if (ns.Width > dimensions.MaxRasterWidth)
722 ns.Width = dimensions.MaxRasterWidth;
723
724 if (ns.Height == STDSCREENHEIGHT)
725 ns.Height = dclip->MaxY - dclip->MinY + 1;
726 else if (ns.Height < dimensions.MinRasterHeight)
727 ns.Height = dimensions.MinRasterHeight;
728 else if (ns.Height > dimensions.MaxRasterHeight)
729 ns.Height = dimensions.MaxRasterHeight;
730
731 DEBUG_OPENSCREEN(dprintf("OpenScreen: Corrected: Width %ld Height %ld\n", ns.Width, ns.Height));
732
733 screen->Screen.RastPort.BitMap = NULL;
734 if (ns.Type & CUSTOMBITMAP)
735 {
736 struct BitMap *custombm;
737
738 custombm = ns.CustomBitMap;
739 #ifdef __MORPHOS__
740 if (IsCyberModeID(modeid) && custombm)
741 {
742 int pixfmt = GetCyberIDAttr(CYBRIDATTR_PIXFMT,modeid);
743
744 if(GetCyberMapAttr(custombm,CYBRMATTR_PIXFMT) != pixfmt)
745 {
746 // incompatible formats !
747 custombm = NULL;
748 }
749 }
750 #else
751 if (!(custombm->Flags & BMF_SPECIALFMT) || (modeid != (ULONG)(IPTR)custombm->Planes[7]))
752 custombm = NULL;
753 #endif
754
755 if(custombm != NULL)
756 {
757 screen->Screen.RastPort.BitMap = custombm;
758 ns.Depth = GetBitMapAttr(ns.CustomBitMap,BMA_DEPTH);
759 DEBUG_OPENSCREEN(dprintf("OpenScreen: CustomBitmap Depth %ld\n",
760 ns.Depth));
761 }
762 else
763 {
764 ns.CustomBitMap = NULL;
765 ns.Type &= ~CUSTOMBITMAP;
766 }
767 }
768
769 if(screen->Screen.RastPort.BitMap == NULL)
770 {
771 ULONG Depth = (dimensions.MaxDepth > 8) ? dimensions.MaxDepth : ns.Depth;
772 #ifdef __MORPHOS__
773 ULONG pixfmt;
774
775 switch(Depth)
776 {
777 case 15:
778 pixfmt = PIXFMT_RGB15;
779 break;
780 case 16:
781 pixfmt = PIXFMT_RGB16;
782 break;
783 case 24:
784 pixfmt = PIXFMT_BGR24;
785 break;
786 case 32:
787 pixfmt = PIXFMT_ARGB32;
788 break;
789 default:
790 pixfmt = PIXFMT_LUT8;
791 break;
792 }
793
794 if (IsCyberModeID(modeid))
795 {
796 pixfmt = GetCyberIDAttr(CYBRIDATTR_PIXFMT,modeid);
797 }
798
799
800 allocbitmapflags |= (BMF_SPECIALFMT|BMF_CLEAR);
801
802 screen->Screen.RastPort.BitMap = AllocBitMap(ns.Width,
803 ns.Height,
804 Depth,
805 allocbitmapflags | (pixfmt << 24),
806 NULL);
807 #else
808 struct TagItem bmtags[] = {
809 {BMATags_DisplayID, modeid},
810 {TAG_DONE , 0 }
811 };
812
813 screen->Screen.RastPort.BitMap = AllocBitMap(ns.Width,
814 ns.Height,
815 Depth,
816 allocbitmapflags | BMF_CHECKVALUE,
817 (struct BitMap *)bmtags);
818 #endif
819 screen->AllocatedBitmap = screen->Screen.RastPort.BitMap;
820 }
821
822 DEBUG_OPENSCREEN(dprintf("OpenScreen: BitMap 0x%lx\n",
823 screen->Screen.RastPort.BitMap));
824 }
825 else
826 {
827 DEBUG_OPENSCREEN(dprintf("OpenScreen: no displayinfo\n"));
828 SetError(OSERR_UNKNOWNMODE);
829 }
830
831 /* Init screen's viewport */
832 InitVPort(&screen->Screen.ViewPort);
833
834 /* Allocate a RasInfo struct in which we have a pointer
835 to the struct BitMap, into which the driver can
836 store its stuff. (Eg. pointer to a BitMap HIDD object)
837 */
838 screen->Screen.ViewPort.RasInfo = AllocMem(sizeof(struct RasInfo), MEMF_ANY | MEMF_CLEAR);
839
840 DEBUG_OPENSCREEN(dprintf("OpenScreen: RasInfo 0x%lx\n",
841 screen->Screen.ViewPort.RasInfo));
842
843 if (!success ||
844 (screen->Screen.RastPort.BitMap == NULL) ||
845 (screen->Screen.ViewPort.RasInfo == NULL))
846 {
847 ok = FALSE;
848 }
849 else
850 {
851 D(bug("got allocated stuff\n"));
852
853 /*
854 * Store pointer to bitmap, so we can get hold of it
855 * from withing LoadRGBxx() functions
856 */
857 screen->Screen.ViewPort.RasInfo->BitMap = screen->Screen.RastPort.BitMap;
858 /* Initialize legacy embedded BitMap structure */
859 CopyMem(screen->Screen.RastPort.BitMap, &screen->Screen.BitMap, sizeof(struct BitMap));
860 }
861
862 if (ok)
863 {
864 /* Read depth from the bitmap to avoid AttachPalExtra/ObtainPen getting
865 * confused if cgx decided to allocate a higher depth bitmap than what
866 * was asked.
867 */
868 ns.Depth = GetBitMapAttr(screen->Screen.RastPort.BitMap,BMA_DEPTH);
869 DEBUG_OPENSCREEN(bug("OpenScreen: Real bitmap depth is %u\n", ns.Depth));
870
871 if (!numcolors) {
872 if (ns.Depth < 5)
873 numcolors = 32;
874 else if (ns.Depth > 8)
875 numcolors = 256;
876 else
877 numcolors = 1L << ns.Depth;
878 }
879
880 /* Get a color map structure. Sufficient colors?? */
881
882 DEBUG_OPENSCREEN(dprintf("OpenScreen: Colormap Entries %ld\n",
883 numcolors));
884
885 if ((screen->Screen.ViewPort.ColorMap = GetColorMap(numcolors)) != NULL)
886 {
887 if (0 == AttachPalExtra(screen->Screen.ViewPort.ColorMap,
888 &screen->Screen.ViewPort))
889 {
890 #if 0
891 int i = 0;
892 char *alloclist;
893 UWORD *refcnt;
894
895 refcnt =(UWORD*) screen->Screen.ViewPort.ColorMap->PalExtra->pe_RefCnt;
896 alloclist = (UBYTE *)(refcnt + screen->Screen.ViewPort.ColorMap->Count);
897
898 DEBUG_OPENSCREEN(dprintf("OpenScreen: PalExtra alloclist 0x%lx Count %ld\n",alloclist,screen->Screen.ViewPort.ColorMap->Count));
899
900 while(i < screen->Screen.ViewPort.ColorMap->Count)
901 {
902 // initialize alloc list to -1,0,1,2,3,4
903
904 DEBUG_OPENSCREEN(dprintf("OpenScreen: alloclist[%ld]=%ld\n",
905 i,alloclist[i]));
906 i++;
907 }
908 #endif
909 }
910 else
911 {
912 ok = FALSE;
913 }
914 }
915 else
916 {
917 ok = FALSE;
918 }
919
920 DEBUG_OPENSCREEN(dprintf("OpenScreen: ColorMap 0x%lx\n",
921 screen->Screen.ViewPort.ColorMap));
922 }
923
924 #ifdef __MORPHOS__
925 screen->ModeID = modeid;
926 #endif
927
928 if (ok)
929 {
930 struct ViewPortExtra *vpe = (struct ViewPortExtra *)GfxNew(VIEWPORT_EXTRA_TYPE);
931
932 DEBUG_OPENSCREEN(dprintf("OpenScreen: ViewPortExtra 0x%lx\n", vpe));
933
934 ok = FALSE;
935
936 if (vpe)
937 {
938 struct TagItem tags[6];
939
940 memcpy(&vpe->DisplayClip, dclip,sizeof(struct Rectangle));
941
942 screen->Screen.ViewPort.DxOffset = ns.LeftEdge;
943 screen->Screen.ViewPort.DyOffset = ns.TopEdge;
944 screen->Screen.ViewPort.DWidth = dclip->MaxX - dclip->MinX + 1;//ns.Width; /* or from dclip ? */
945 screen->Screen.ViewPort.DHeight = dclip->MaxY - dclip->MinY + 1;//ns.Height;
946
947 tags[0].ti_Tag = VTAG_ATTACH_CM_SET;
948 tags[0].ti_Data = (IPTR)&screen->Screen.ViewPort;
949 tags[1].ti_Tag = VTAG_VIEWPORTEXTRA_SET;
950 tags[1].ti_Data = (IPTR)vpe;
951 tags[2].ti_Tag = VTAG_NORMAL_DISP_SET;
952 tags[2].ti_Data = (IPTR)displayinfo;
953 tags[3].ti_Tag = VTAG_VPMODEID_SET;
954 tags[3].ti_Data = modeid;
955 tags[4].ti_Tag = VTAG_SPEVEN_BASE_SET;
956 tags[5].ti_Tag = VTAG_NEXTBUF_CM; /* if vctl is 0, this will terminate the list */
957 tags[5].ti_Data = vctl;
958
959 /* Originally we could always use palette entries 16-19 for
960 sprites, even if the screen has less than 32 colors. AROS may
961 run on hardware that does not allow this (e.g. VGA cards).
962 In this case we have to shift down sprite colors. Currently
963 we use 4 colors before last 4 colors. For example on VGA cards
964 with only 16 colors we use colors 9 - 12. Remember that last 4 colors
965 of the screen are always used by Intuition.
966 Remember that the first color of the sprite is always transparent. So actually
967 we use 3, not 4 colors.
968 Yes, sprites may look not as expected on screens with low color depth, but at
969 least they will be seen. It's better than nothing.
970
971 Note that because our base color number doesn't always divide by 16, we use MSB to store
972 the remainder (offset in the color bank). Yes, it's a bit hacky, but i have no better idea
973 at the moment.
974
975 FIXME: this mapping scheme assumes that we always have at least 16 colors.
976 For current display modes supported by AROS it's always true, but in future
977 we may support more display modes (for example monochrome ones), and we
978 should take into account that on screens with less than 11 colors this simply
979 won't work
980
981 TODO: I think we should have SpriteBase attribute for the bitmap which
982 defaults to acceptable value. We should just get its default value here.
983 The same attribute would be set by VideoControl() and MakeVPort() in order
984 to actually apply the value. */
985 #if (AROS_FLAVOUR & AROS_FLAVOUR_BINCOMPAT)
986 spritebase = 16;
987 #else
988 spritebase = (ns.Depth < 5) ? (1 << ns.Depth) - 8 : 16;
989 #endif
990 DEBUG_OPENSCREEN(bug("OpenScreen: spritebase is %u\n", spritebase));
991 tags[4].ti_Data = ((spritebase & 0x0F) << 8 ) | (spritebase >> 4);
992
993 if (VideoControl(screen->Screen.ViewPort.ColorMap, tags) == 0)
994 {
995 DEBUG_OPENSCREEN(dprintf("OpenScreen: VideoControl ok\n"));
996 ok = TRUE;
997 }
998 else
999 {
1000 DEBUG_OPENSCREEN(dprintf("OpenScreen: VideoControl failed\n"));
1001 }
1002 }
1003 }
1004
1005 if (ok)
1006 {
1007 struct Color32 *p;
1008 int k;
1009
1010 DEBUG_OPENSCREEN(dprintf("OpenScreen: Set first 4 colors\n"));
1011 p = GetPrivIBase(IntuitionBase)->Colors;
1012 for (k = 0; k < 4; ++k)
1013 {
1014 DEBUG_OPENSCREEN(dprintf("OpenScreen: Viewport 0x%p Index %ld R 0x%lx G 0x%lx B 0x%lx\n",
1015 &screen->Screen.ViewPort,
1016 k, p[k].red, p[k].green, p[k].blue));
1017 SetRGB32(&screen->Screen.ViewPort, k, p[k].red, p[k].green, p[k].blue);
1018 }
1019
1020 if (ns.Depth >= 3)
1021 {
1022 ULONG lastcol = ((ns.Depth > 8) ? 256 : (1 << ns.Depth)) - 4;
1023
1024 DEBUG_OPENSCREEN(dprintf("OpenScreen: Set last 4 colors (starting from %u)\n", lastcol));
1025 for (k = 0; k < 4; ++k)
1026 {
1027 DEBUG_OPENSCREEN(dprintf("OpenScreen: Viewport 0x%p Index %u R 0x%08X G 0x%08X B 0x%08X\n",
1028 &screen->Screen.ViewPort,
1029 k + lastcol, p[k+4].red, p[k+4].green, p[k+4].blue));
1030
1031 if (k + lastcol < numcolors)
1032 ObtainPen(screen->Screen.ViewPort.ColorMap, k + lastcol,
1033 p[k+4].red, p[k+4].green, p[k+4].blue, 0);
1034 else
1035 /* Can't be allocated, but can still be set. */
1036 SetRGB32(&screen->Screen.ViewPort, k + lastcol,
1037 p[k+4].red, p[k+4].green, p[k+4].blue);
1038 }
1039 }
1040 /* Allocate pens for mouse pointer sprite only on LUT screens. On hi- and
1041 truecolor screens sprite colors come from colormap attached to the sprite
1042 bitmap itself.
1043 See pointerclass::New() for details. */
1044 #ifndef ALWAYS_ALLOCATE_SPRITE_COLORS
1045 if (ns.Depth < 9)
1046 #endif
1047 {
1048 DEBUG_OPENSCREEN(dprintf("OpenScreen: Obtain Mousepointer colors\n"));
1049 /* Allocate pens for the mouse pointer */
1050 for (k = 1; k < 4; ++k)
1051 {
1052 LONG opret = -1;
1053 DEBUG_OPENSCREEN(dprintf("OpenScreen: ViewPort 0x%p Index %d R 0x%08X G 0x%08X B 0x%08X\n",
1054 &screen->Screen.ViewPort,
1055 k + spritebase,
1056 p[k+7].red,
1057 p[k+7].green,
1058 p[k+7].blue));
1059 if (k + spritebase < numcolors)
1060 opret = ObtainPen(screen->Screen.ViewPort.ColorMap, k + spritebase,
1061 p[k+7].red, p[k+7].green, p[k+7].blue, 0);
1062 if (opret < 0) /* ObtainPen() fails if spritebase >= number of screen colors */
1063 SetRGB32(&screen->Screen.ViewPort, k + spritebase,
1064 p[k+7].red, p[k+7].green, p[k+7].blue);
1065 }
1066 }
1067
1068 if (colors) /* if SA_Colors tag exists */
1069 {
1070 DEBUG_OPENSCREEN(dprintf("OpenScreen: set SA_Colors 0x%lx\n",colors));
1071 for(; colors->ColorIndex != (WORD)~0; colors++)
1072 {
1073 DEBUG_OPENSCREEN(dprintf("OpenScreen: SetRGB4 Viewport 0x%p Index %d R 0x%x G 0x%x B 0x%x\n",
1074 &screen->Screen.ViewPort,
1075 colors->ColorIndex,
1076 colors->Red,
1077 colors->Green,
1078 colors->Blue));
1079 SetRGB4(&screen->Screen.ViewPort,
1080 colors->ColorIndex,
1081 colors->Red,
1082 colors->Green,
1083 colors->Blue);
1084 }
1085 }
1086
1087 if (colors32) /* if SA_Colors32 tag exists */
1088 {
1089 DEBUG_OPENSCREEN(dprintf("OpenScreen: LoadRGB32 colors32 0x%lx\n",colors32));
1090 LoadRGB32(&screen->Screen.ViewPort, (const ULONG *)colors32);
1091 }
1092
1093 D(bug("Loaded colors\n"));
1094
1095 MakeVPort(&IntuitionBase->ViewLord, &screen->Screen.ViewPort);
1096 /* Put validated values into screen structure, this is important */
1097 screen->Screen.LeftEdge = screen->Screen.ViewPort.DxOffset;
1098 screen->Screen.TopEdge = screen->Screen.ViewPort.DyOffset;
1099 COPY(Width);
1100 COPY(Height);
1101 COPY(DetailPen);
1102 COPY(BlockPen);
1103 COPY(Font);
1104 COPY(DefaultTitle);
1105
1106 //intui68k filters this
1107 screen->Screen.Flags = (ns.Type & ~NS_EXTENDED);
1108
1109 /* Temporary hack, only used to set size of system gadgets */
1110 if (ns.Width >= 500 || ns.Height >= 300)
1111 screen->Screen.Flags |= SCREENHIRES;
1112
1113 /*
1114 Copy the data from the rastport's bitmap
1115 to the screen's bitmap structure
1116 */
1117 screen->Screen.BitMap = *screen->Screen.RastPort.BitMap;
1118
1119 #ifdef __MORPHOS__
1120 screen->Screen.WBorTop = 2;
1121 screen->Screen.WBorLeft = 4;
1122 screen->Screen.WBorRight = 4;
1123 screen->Screen.WBorBottom = 2;
1124 #else
1125 screen->Screen.WBorTop = 3; /* Amiga default is 2 */
1126 screen->Screen.WBorLeft = 4;
1127 screen->Screen.WBorRight = 4;
1128 screen->Screen.WBorBottom = 2; /* Amiga default is 2 */
1129 #endif
1130
1131 screen->Screen.Title = ns.DefaultTitle;
1132
1133 DEBUG_OPENSCREEN(dprintf("OpenScreen: init layers\n"));
1134 InitLayers(&screen->Screen.LayerInfo);
1135 li_inited = TRUE;
1136
1137 if (NULL != layer_info_hook)
1138 {
1139 DEBUG_OPENSCREEN(dprintf("OpenScreen: instal layerinfohook\n"));
1140 InstallLayerInfoHook(&screen->Screen.LayerInfo, layer_info_hook);
1141 }
1142 D(bug("layers intited screen\n"));
1143
1144 /* Use higher than DRI_VERSION to detect manually created
1145 * DrawInfo structures (for example WB3.1:Prefs/Palette)
1146 */
1147 screen->DInfo.dri.dri_Version = DRI_VERSION_AROS;
1148 screen->DInfo.dri.dri_NumPens = NUMDRIPENS;
1149 screen->DInfo.dri.dri_Pens = screen->Pens;
1150 /* dri_Depth is 8 on hi/true color screens like in AmigaOS with picasso96/cybergraphx */
1151 screen->DInfo.dri.dri_Depth = (ns.Depth <= 8) ? ns.Depth : 8;
1152
1153 if (ns.Depth > 8) screen->DInfo.dri.dri_Flags = DRIF_DIRECTCOLOR;
1154
1155 screen->DInfo.dri_Screen = &screen->Screen;
1156
1157 /* SA_SysFont overrides SA_Font! */
1158
1159 DEBUG_OPENSCREEN(dprintf("OpenScreen: SysFont = %d, ns.Font = %p\n", sysfont, ns.Font));
1160
1161 if (sysfont == 0)
1162 {
1163 /* Is handled below */
1164 DEBUG_OPENSCREEN(dprintf("OpenScreen: skip SysFont for now\n"));
1165 }
1166 else if (sysfont == 1)
1167 {
1168 #if 1
1169 /* Use safe OpenFont here - Piru
1170 */
1171 screen->DInfo.dri.dri_Font = SafeReopenFont(IntuitionBase, &GetPrivIBase(IntuitionBase)->ScreenFont);
1172 #else
1173 #warning: Really hacky way of re-opening ScreenFont
1174
1175 Forbid();
1176 screen->DInfo.dri.dri_Font = GetPrivIBase(IntuitionBase)->ScreenFont;
1177 screen->DInfo.dri.dri_Font->tf_Accessors++;
1178 Permit();
1179 #endif
1180
1181 screen->SpecialFlags |= SF_SysFont;
1182
1183 DEBUG_OPENSCREEN(dprintf("OpenScreen: Set ScreenFont\n"));
1184
1185 }
1186 else if (ns.Font)
1187 {
1188 screen->DInfo.dri.dri_Font = OpenFont(ns.Font);
1189 DEBUG_OPENSCREEN(dprintf("OpenScreen: custom font 0x%lx\n",screen->DInfo.dri.dri_Font));
1190 }
1191
1192 if (!screen->DInfo.dri.dri_Font)
1193 {
1194 /* GfxBase->DefaultFont is *not* always topaz 8. It
1195 can be set with the Font prefs program!! */
1196
1197 #if 1
1198 /* Use safe OpenFont.. - Piru
1199 */
1200 screen->DInfo.dri.dri_Font = SafeReopenFont(IntuitionBase, &GfxBase->DefaultFont);
1201 #else
1202
1203 #warning: Really hacky way of re-opening system default font
1204
1205 Forbid();
1206 screen->DInfo.dri.dri_Font = GfxBase->DefaultFont;
1207 screen->DInfo.dri.dri_Font->tf_Accessors++;
1208 Permit();
1209 #endif
1210 }
1211
1212 if (!screen->DInfo.dri.dri_Font) ok = FALSE;
1213
1214 } /* if (ok) */
1215
1216 if (ok)
1217 {
1218 /* set default values for pens */
1219 DEBUG_OPENSCREEN(dprintf("OpenScreen: Set Default Pens\n"));
1220
1221 CopyMem(ns.Depth == 1 ? GetPrivIBase(IntuitionBase)->DriPens2
1222 : ns.Depth == 4 ? GetPrivIBase(IntuitionBase)->DriPens4
1223 : GetPrivIBase(IntuitionBase)->DriPens8,
1224 screen->Pens,
1225 sizeof(screen->Pens));
1226
1227 if (ns.Depth > 1)
1228 {
1229 DEBUG_OPENSCREEN(dprintf("OpenScreen: Set NewLook\n"));
1230 screen->DInfo.dri.dri_Flags |= DRIF_NEWLOOK;
1231 }
1232
1233
1234 if (customdripens)
1235 {
1236 WORD i;
1237
1238 DEBUG_OPENSCREEN(dprintf("OpenScreen: Set Custom Pens\n"));
1239
1240 screen->Pens[DETAILPEN] = screen->Screen.DetailPen;
1241 screen->Pens[BLOCKPEN] = screen->Screen.BlockPen;
1242
1243 for(i = 0; (i < NUMDRIPENS) && (customdripens[i] != (UWORD)~0); i++)
1244 {
1245 DEBUG_OPENSCREEN(dprintf("OpenScreen: Pen[%ld] %ld\n",i,screen->Pens[i]));
1246 screen->Pens[i] = customdripens[i];
1247 }
1248 }
1249 else
1250 {
1251 /*
1252 * Let`s do some broken software validation of the pens
1253 * so we may not run into a black desktop.
1254 */
1255
1256 DEBUG_OPENSCREEN(dprintf("OpenScreen: Check Default Pens if the make sense\n"));
1257 if (screen->Screen.DetailPen == screen->Screen.BlockPen)
1258 {
1259 DEBUG_OPENSCREEN(dprintf("OpenScreen: DetailPen==BlockPen..correct\n"));
1260 screen->Screen.DetailPen = 0;
1261 screen->Screen.BlockPen = 1;
1262 }
1263 else
1264 if (screen->Screen.BlockPen == 0)
1265 {
1266 DEBUG_OPENSCREEN(dprintf("OpenScreen: BlockPen==0..correct\n"));
1267 screen->Screen.BlockPen = screen->Screen.DetailPen;
1268 screen->Screen.DetailPen = 0;
1269 }
1270
1271 screen->Pens[DETAILPEN] = screen->Screen.DetailPen;
1272 screen->Pens[BLOCKPEN] = screen->Screen.BlockPen;
1273 }
1274
1275 /* Allocate shared/exclusive colors */
1276
1277 {
1278 BYTE color_alloced[256];
1279
1280 WORD i;
1281
1282 for(i = 0; i < 256; i++)
1283 {
1284 color_alloced[i] = FALSE;
1285 }
1286
1287 /* Mouse pointer colors */
1288
1289 color_alloced[17] = TRUE;
1290 color_alloced[18] = TRUE;
1291 color_alloced[19] = TRUE;
1292
1293 /* The Pens in the DrawInfo must be allocated as shared */
1294
1295 DEBUG_OPENSCREEN(dprintf("OpenScreen: ObtainPen DrawInfo Pens as shared\n"));
1296
1297 for(i = 0; i < NUMDRIPENS; i++)
1298 {
1299 int pen = screen->Pens[i];
1300
1301 if (!color_alloced[pen])
1302 {
1303 DEBUG_OPENSCREEN(dprintf("OpenScreen: ObtainPen ColorMap 0x%lx Pen %ld\n",
1304 screen->Screen.ViewPort.ColorMap,
1305 pen));
1306
1307 ObtainPen(screen->Screen.ViewPort.ColorMap,
1308 pen,
1309 0,
1310 0,
1311 0,
1312 PENF_NO_SETCOLOR);
1313 color_alloced[pen] = TRUE;
1314 }
1315 }
1316 DEBUG_OPENSCREEN(dprintf("OpenScreen: done\n"));
1317
1318 /* If SA_SharePens is FALSE then allocate the rest of the colors
1319 in the colormap as exclusive */
1320
1321 if (!sharepens)
1322 {
1323 DEBUG_OPENSCREEN(dprintf("OpenScreen: ObtainPen the remaining Pens as exclusive\n"));
1324
1325 for(i = 0; i < numcolors; i++)
1326 {
1327 if (!color_alloced[i])
1328 {
1329 DEBUG_OPENSCREEN(dprintf("OpenScreen: ObtainPen ColorMap 0x%lx Pen %ld\n",
1330 screen->Screen.ViewPort.ColorMap,
1331 i));
1332 ObtainPen(screen->Screen.ViewPort.ColorMap,
1333 i,
1334 0,
1335 0,
1336 0,
1337 PENF_EXCLUSIVE | PENF_NO_SETCOLOR);
1338 }
1339 }
1340
1341 } /* if (!sharepens) */
1342
1343 }
1344 }
1345
1346 #ifdef SKINS
1347 if (ok)
1348 {
1349 ULONG realdepth;
1350
1351 screen->DInfo.dri_Screen = &screen->Screen; //useful sometimes ;)
1352
1353 realdepth = GetBitMapAttr( screen->Screen.RastPort.BitMap, BMA_DEPTH );
1354 if (realdepth > 8)
1355 {
1356 screen->DInfo.dri_Flags |= DRIF_DIRECTCOLOR;
1357 }
1358 else
1359 {
1360 screen->DInfo.dri_Flags &= ~DRIF_DIRECTCOLOR;
1361 }
1362
1363 if (!(screen->DInfo.dri_Colors = AllocMem(4 * DRIPEN_NUMDRIPENS,MEMF_PUBLIC)))
1364 ok = FALSE;
1365
1366 if (ok)
1367 {
1368 CopyMem(&defaultdricolors,screen->DInfo.dri_Colors,sizeof (defaultdricolors));
1369 memset(((UBYTE *) screen->DInfo.dri_Colors) + sizeof(defaultdricolors), 0, 4 * DRIPEN_NUMDRIPENS - sizeof(defaultdricolors));
1370 }
1371
1372 if (ok)
1373 {
1374 if ((screen->DInfo.dri_Customize = AllocMem(sizeof (struct IntuitionCustomize),MEMF_PUBLIC|MEMF_CLEAR)))
1375 {
1376 struct IntuitionCustomize *ic;
1377 ic = screen->DInfo.dri_Customize;
1378 screen->DInfo.dri_Flags |= DRIF_SKINSSUPPORT;
1379 /* This initializes CustomizePrefs structure */
1380
1381 int_SkinAction(SKA_LoadSkin,(ULONG*)&screen->DInfo,(struct Screen *)screen,IntuitionBase);
1382 }
1383 else
1384 {
1385 ok = FALSE;
1386 }
1387 }
1388 }
1389
1390 if (ok)
1391 {
1392 struct windowclassprefs *wcprefs;
1393
1394 wcprefs = (struct windowclassprefs *)int_GetCustomPrefs(TYPE_WINDOWCLASS,&screen->DInfo,IntuitionBase);
1395 if (wcprefs->flags & WINDOWCLASS_PREFS_1TO1FRAMES)
1396 {
1397 screen->Screen.WBorLeft = screen->Screen.WBorTop;
1398 screen->Screen.WBorRight = screen->Screen.WBorTop;
1399 screen->Screen.WBorBottom = screen->Screen.WBorTop;
1400 }
1401 #ifdef TITLEHACK
1402 screen->Screen.WBorTop += wcprefs->titlebarincrement;
1403 #endif
1404 int_FreeCustomPrefs(TYPE_WINDOWCLASS,&screen->DInfo,IntuitionBase);
1405 }
1406
1407 #endif
1408
1409 if (ok)
1410 {
1411 IPTR userbuffersize;
1412 struct NewDecorator *nd;
1413
1414 nd = ((struct IntIntuitionBase *)(IntuitionBase))->Decorator;
1415
1416 ObtainSemaphore(&((struct IntIntuitionBase *)(IntuitionBase))->ScrDecorSem);
1417
1418 struct DosLibrary *DOSBase = GetPrivIBase(IntuitionBase)->DOSBase;
1419
1420 /* Open dos.library only once, when first needed */
1421 if (!DOSBase)
1422 GetPrivIBase(IntuitionBase)->DOSBase = DOSBase = (struct DosLibrary *)OpenLibrary("dos.library", 36);
1423
1424 if (DOSBase)
1425 {
1426 struct Node *node;
1427
1428 if (!IsListEmpty(&GetPrivIBase(IntuitionBase)->Decorations))
1429 {
1430 node = GetPrivIBase(IntuitionBase)->Decorations.lh_Head;
1431 for (; node->ln_Succ; node = node->ln_Succ)
1432 {
1433 struct NewDecorator *d = (struct NewDecorator *) node;
1434
1435 if ((d->nd_IntPattern != NULL) && (screen->Screen.Title != NULL))
1436 {
1437 if (MatchPattern(d->nd_IntPattern, screen->Screen.Title))
1438 nd = d;
1439 }
1440 }
1441 }
1442 }
1443
1444 if (nd != NULL)
1445 {
1446 screen->ScrDecorObj = NewObjectA(nd->nd_ScreenClass, NULL, nd->nd_ScreenTags);
1447 screen->MenuDecorObj = NewObjectA(nd->nd_MenuClass, NULL, nd->nd_MenuTags);
1448 screen->WinDecorObj = NewObjectA(nd->nd_WindowClass, NULL, nd->nd_WindowTags);
1449 }
1450 else
1451 {
1452 screen->ScrDecorObj = NewObjectA(GetPrivIBase(IntuitionBase)->ScrDecorClass, NULL, GetPrivIBase(IntuitionBase)->ScrDecorTags);
1453 screen->MenuDecorObj = NewObjectA(GetPrivIBase(IntuitionBase)->MenuDecorClass, NULL, GetPrivIBase(IntuitionBase)->MenuDecorTags);
1454 screen->WinDecorObj = NewObjectA(GetPrivIBase(IntuitionBase)->WinDecorClass, NULL, GetPrivIBase(IntuitionBase)->WinDecorTags);
1455 }
1456 screen->Decorator = nd;
1457
1458 if (screen->Decorator) screen->Decorator->nd_cnt++;
1459
1460 ReleaseSemaphore(&((struct IntIntuitionBase *)(IntuitionBase))->ScrDecorSem);
1461
1462 GetAttr(SDA_UserBuffer, screen->ScrDecorObj, &userbuffersize);
1463
1464 if (userbuffersize)
1465 {
1466 screen->DecorUserBufferSize = userbuffersize;
1467 screen->DecorUserBuffer = (IPTR) AllocMem(userbuffersize, MEMF_ANY | MEMF_CLEAR);
1468 if (!screen->DecorUserBuffer) ok = FALSE;
1469 }
1470 }
1471
1472 if (ok)
1473 {
1474 struct TagItem sysi_tags[] =
1475 {
1476 {SYSIA_Which , MENUCHECK },
1477 {SYSIA_DrawInfo , (IPTR)&screen->DInfo },
1478 {SYSIA_UserBuffer, screen->DecorUserBuffer },
1479
1480 {TAG_DONE }
1481 };
1482
1483 screen->DInfo.dri.dri_CheckMark = NewObjectA(NULL, "sysiclass", sysi_tags);
1484 DEBUG_OPENSCREEN(dprintf("OpenScreen: CheckMark 0x%lx\n",
1485 screen->DInfo.dri.dri_CheckMark));
1486
1487 sysi_tags[0].ti_Data = AMIGAKEY;
1488
1489 screen->DInfo.dri.dri_AmigaKey = NewObjectA(NULL, "sysiclass", sysi_tags);
1490 DEBUG_OPENSCREEN(dprintf("OpenScreen: AmigaKey 0x%lx\n",
1491 screen->DInfo.dri.dri_AmigaKey));
1492
1493 sysi_tags[0].ti_Data = SUBMENUIMAGE;
1494
1495 screen->DInfo.dri.dri_SubMenuImage = NewObjectA(NULL, "sysiclass", sysi_tags);
1496 DEBUG_OPENSCREEN(dprintf("OpenScreen: SubMenuImage 0x%lx\n",
1497 screen->DInfo.dri.dri_SubMenuImage));
1498
1499 #ifdef SKINS
1500 sysi_tags[0].ti_Data = SUBMENUIMAGE;
1501 screen->DInfo.dri_Customize->submenu = NewObjectA(NULL, "sysiclass", sysi_tags);
1502 sysi_tags[0].ti_Data = MENUTOGGLEIMAGE;
1503 screen->DInfo.dri_Customize->menutoggle = NewObjectA(NULL, "sysiclass", sysi_tags);
1504 if (!screen->DInfo.dri_Customize->submenu ||
1505 !screen->DInfo.dri_Customize->menutoggle) ok = FALSE;
1506 #endif
1507
1508 if (!screen->DInfo.dri.dri_CheckMark || !screen->DInfo.dri.dri_AmigaKey || !screen->DInfo.dri.dri_SubMenuImage) ok = FALSE;
1509 }
1510
1511
1512
1513 if (ok)
1514 {
1515 SetFont(&screen->Screen.RastPort, screen->DInfo.dri.dri_Font);
1516
1517 AskFont(&screen->Screen.RastPort, (struct TextAttr *) &screen->textattr);
1518
1519 screen->Screen.Font = (struct TextAttr *) &screen->textattr;
1520
1521 DEBUG_OPENSCREEN(dprintf("OpenScreen: Font %s/%d\n",
1522 screen->textattr.tta_Name, screen->textattr.tta_YSize));
1523
1524 screen->Screen.BarVBorder = 1; /* on the Amiga it is (usually?) 1 */
1525 screen->Screen.BarHBorder = 5;
1526 screen->Screen.MenuVBorder = 2; /* on the Amiga it is (usually?) 2 */
1527 screen->Screen.MenuHBorder = 4;
1528
1529 struct sdpInitScreen msg;
1530
1531 msg.MethodID = SDM_INITSCREEN;
1532 msg.sdp_Screen = &screen->Screen;
1533 msg.sdp_TrueColor = screen->DInfo.dri.dri_Flags & DRIF_DIRECTCOLOR;
1534 msg.sdp_FontHeight = screen->DInfo.dri.dri_Font->tf_YSize;
1535 msg.sdp_BarVBorder = screen->Screen.BarVBorder;
1536 msg.sdp_BarHBorder = screen->Screen.BarHBorder;
1537 msg.sdp_MenuVBorder = screen->Screen.MenuVBorder;
1538 msg.spd_MenuHBorder = screen->Screen.MenuHBorder;
1539 msg.sdp_WBorTop = screen->Screen.WBorTop;
1540 msg.sdp_WBorLeft = screen->Screen.WBorLeft;
1541 msg.sdp_WBorRight = screen->Screen.WBorRight;
1542 msg.sdp_WBorBottom = screen->Screen.WBorBottom;
1543
1544 #ifdef TITLEHACK
1545 msg.sdp_TitleHack = screen->Screen.WBorTop-2;
1546 #else
1547 msg.sdp_TitleHack = 0;
1548 #endif
1549
1550 msg.sdp_BarHeight = msg.sdp_FontHeight + msg.sdp_BarVBorder * 2 + msg.sdp_TitleHack;
1551 msg.sdp_UserBuffer = ((struct IntScreen *)screen)->DecorUserBuffer;
1552
1553 if (!DoMethodA(((struct IntScreen *)(screen))->ScrDecorObj, (Msg)&msg)) ok = FALSE;
1554 if (ok)
1555 {
1556 screen->Screen.BarHeight = msg.sdp_BarHeight;
1557 screen->Screen.BarVBorder = msg.sdp_BarVBorder;
1558 screen->Screen.BarHBorder = msg.sdp_BarHBorder;
1559 screen->Screen.MenuVBorder = msg.sdp_MenuVBorder;
1560 screen->Screen.MenuHBorder = msg.spd_MenuHBorder;
1561 screen->Screen.WBorTop = msg.sdp_WBorTop;
1562 screen->Screen.WBorLeft = msg.sdp_WBorLeft;
1563 screen->Screen.WBorRight = msg.sdp_WBorRight;
1564 screen->Screen.WBorBottom = msg.sdp_WBorBottom;
1565 }
1566 }
1567
1568
1569 if (ok)
1570 {
1571 #define SDEPTH_HEIGHT (screen->Screen.BarHeight + 1)
1572 #ifdef IA_Screen
1573 #undef IA_Screen
1574 #endif
1575 #define IA_Screen (IA_Dummy + 0x1f) /* OS v44 includes!*/
1576
1577 struct TagItem sdepth_tags[] =
1578 {
1579 {GA_Image , 0 },
1580 {GA_Top , 0 },
1581 #if SQUARE_WIN_GADGETS
1582 {GA_Width , SDEPTH_HEIGHT },
1583 #endif
1584 {GA_Height , SDEPTH_HEIGHT },
1585 {GA_SysGadget , TRUE },
1586 {GA_SysGType , GTYP_SDEPTH },
1587 {GA_RelVerify , TRUE },
1588 {TAG_DONE }
1589 };
1590
1591 Object *im = 0;
1592
1593 if (!(screen->Screen.Flags & SCREENQUIET))
1594 {
1595 im = CreateStdSysImage(SDEPTHIMAGE, SDEPTH_HEIGHT, &screen->Screen, (APTR) ((struct IntScreen *)screen)->DecorUserBuffer,
1596 (struct DrawInfo *)&screen->DInfo, IntuitionBase);
1597 }
1598
1599 sdepth_tags[0].ti_Data = (IPTR)im;
1600
1601 screen->depthgadget = NewObjectA(NULL, BUTTONGCLASS, sdepth_tags );
1602
1603 DEBUG_OPENSCREEN(dprintf("OpenScreen: DepthGadget 0x%lx\n",
1604 screen->depthgadget));
1605
1606 screen->Screen.FirstGadget = (struct Gadget *)screen->depthgadget;
1607 if (screen->Screen.FirstGadget)
1608 {
1609 struct sdpLayoutScreenGadgets msg;
1610
1611 screen->Screen.FirstGadget->GadgetType |= GTYP_SCRGADGET;
1612
1613 msg.MethodID = SDM_LAYOUT_SCREENGADGETS;
1614 msg.sdp_TrueColor = screen->DInfo.dri.dri_Flags & DRIF_DIRECTCOLOR;
1615 msg.sdp_Layer = screen->Screen.BarLayer;
1616 msg.sdp_Gadgets = screen->Screen.FirstGadget;
1617 msg.sdp_Flags = SDF_LSG_INITIAL | SDF_LSG_MULTIPLE;
1618 msg.sdp_UserBuffer = ((struct IntScreen *)screen)->DecorUserBuffer;
1619
1620 DoMethodA(((struct IntScreen *)(screen))->ScrDecorObj, (Msg)&msg);
1621
1622 #if 0
1623 struct TagItem gadtags[] =
1624 {
1625 {GA_RelRight, 0 },
1626 {TAG_DONE }
1627 };
1628 IPTR width;
1629
1630 GetAttr(GA_Width, screen->depthgadget, &width);
1631
1632 gadtags[0].ti_Data = -width + 1;
1633 SetAttrsA(screen->depthgadget, gadtags);
1634 #endif
1635
1636 }
1637 else
1638 {
1639 if (im) DisposeObject(im);
1640 }
1641
1642
1643 #if DEBUG_OpenScreen
1644 {
1645 int i;
1646
1647 for (i = 0; i <= screen->DInfo.dri.dri_NumPens; i++)
1648 {
1649 dprintf("OpenScreen: dri_Pen[%ld] = %ld\n", i, screen->DInfo.dri.dri_Pens[i]);
1650 }
1651 }
1652 #endif
1653
1654 #ifdef USEWINDOWLOCK
1655 /* let's wait for user to finish window drag/size actions to avoid
1656 deadlocks and not break user's input */
1657 ObtainSemaphore(&GetPrivIBase(IntuitionBase)->WindowLock);
1658 windowlock = TRUE;
1659 #endif
1660
1661 #ifdef SKINS
1662 int_CalcSkinInfo(&screen->Screen,IntuitionBase);
1663 int_InitTitlebarBuffer(screen,IntuitionBase);
1664 #endif
1665
1666 D(bug("Calling SetRast()\n"));
1667
1668 DEBUG_OPENSCREEN(dprintf("OpenScreen: Set background color Pen %ld\n",screen->Pens[BACKGROUNDPEN]));
1669 /* Set screen to background color */
1670 SetRast(&screen->Screen.RastPort, screen->Pens[BACKGROUNDPEN]);
1671
1672 D(bug("SetRast() called\n"));
1673
1674 DEBUG_OPENSCREEN(dprintf("OpenScreen: Creating screen bar\n"));
1675
1676 #ifdef SKINS
1677 if (workbench)
1678 {
1679 if (GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_NOWBTITLEBAR) screen->SpecialFlags |= SF_InvisibleBar;
1680 if (GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_DISAPPEARINGTITLEBAR) screen->SpecialFlags |= SF_AppearingBar;
1681 }
1682 #endif
1683 if (draggable)
1684 screen->SpecialFlags |= SF_Draggable;
1685 DEBUG_OPENSCREEN(bug("OpenScreen: Special flags: 0x%04X\n", screen->SpecialFlags));
1686
1687 //jDc: ALL screens MUST have BarLayer!
1688 CreateScreenBar(&screen->Screen, IntuitionBase);
1689
1690 DEBUG_OPENSCREEN(bug("OpenScreen: ScreenBar = %p\n", screen->Screen.BarLayer));
1691
1692 if (!screen->Screen.BarLayer) ok = FALSE;
1693
1694 /*
1695 ** jDc: better modify the screen list in sync with inputhandler, this for example allows us to scan the list
1696 ** without any locks when we are on input.device context
1697 */
1698 if (ok)
1699 {
1700 struct OpenScreenActionMsg msg;
1701 struct List *list = LockPubScreenList();
1702
1703 msg.Screen = screen;
1704 msg.NewScreen = &ns;
1705 msg.List = list;
1706
1707 DEBUG_OPENSCREEN(dprintf("OpenScreen: Calling DoSyncAction()\n"));
1708
1709 DoSyncAction((APTR)int_openscreen,&msg.msg,IntuitionBase);
1710
1711 DEBUG_OPENSCREEN(dprintf("OpenScreen: DoSyncAction returned\n"));
1712
1713 UnlockPubScreenList();
1714 }
1715
1716 } /* if (ok) */
1717
1718 if (ok)
1719 {
1720 GetAttr(POINTERA_SharedPointer, GetPrivIBase(IntuitionBase)->DefaultPointer, (IPTR *)&screen->Pointer);
1721 ObtainSharedPointer(screen->Pointer, IntuitionBase);
1722 DEBUG_OPENSCREEN(dprintf("OpenScreen: Sprite DefaultPtr 0x%lx\n",&screen->Pointer));
1723 }
1724
1725 #ifdef __MORPHOS__
1726 if (ok)
1727 {
1728 ok = MakeScreen(&screen->Screen) == 0;
1729 DEBUG_OPENSCREEN(dprintf("OpenScreen: MakeScreen %s\n", ok ? "ok" : "failed"));
1730 }
1731 #endif
1732 if (ok)
1733 {
1734 ok = RethinkDisplay() == 0;
1735 DEBUG_OPENSCREEN(dprintf("OpenScreen: RethinkDisplay %s\n", ok ? "ok" : "failed"));
1736 }
1737
1738 #ifdef SKINS
1739 if (ok)
1740 {
1741 FireMenuMessage(MMCODE_STARTCLOCK,NULL,NULL,IntuitionBase);
1742 }
1743 #endif
1744
1745 #ifdef USEWINDOWLOCK
1746 if (windowlock) ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->WindowLock);
1747 #endif
1748
1749 if (!ok)
1750 {
1751 if (li_inited)
1752 {
1753 DEBUG_OPENSCREEN(dprintf("OpenScreen: Get ThinLayerInfo\n"));
1754 ThinLayerInfo(&screen->Screen.LayerInfo);
1755 }
1756
1757 if (screen->Screen.ViewPort.ColorMap)
1758 {
1759 FreeColorMap(screen->Screen.ViewPort.ColorMap);
1760 }
1761
1762 if (screen->Screen.BarLayer)
1763 {
1764 DEBUG_OPENSCREEN(dprintf("OpenScreen: KillScreenBar\n"));
1765 KillScreenBar(&screen->Screen, IntuitionBase);
1766 }
1767
1768 #ifdef SKINS
1769 DisposeObject(screen->DInfo.dri_Customize->submenu);
1770 DisposeObject(screen->DInfo.dri_Customize->menutoggle);
1771 if (screen->DInfo.dri_Customize) FreeMem(screen->DInfo.dri_Customize,sizeof (struct IntuitionCustomize));
1772 if (screen->DInfo.dri_Colors) FreeMem(screen->DInfo.dri_Colors,4 * DRIPEN_NUMDRIPENS);
1773 #endif
1774 if (screen->DInfo.dri.dri_AmigaKey)
1775 {
1776 DEBUG_OPENSCREEN(dprintf("OpenScreen: Dispose AmigaKey Object\n"));
1777 DisposeObject(screen->DInfo.dri.dri_AmigaKey);
1778 }
1779 if (screen->DInfo.dri.dri_CheckMark)
1780 {
1781 DEBUG_OPENSCREEN(dprintf("OpenScreen: Dispose CheckMark Object\n"));
1782 DisposeObject(screen->DInfo.dri.dri_CheckMark);
1783 }
1784
1785 if (screen->DInfo.dri.dri_SubMenuImage)
1786 {
1787 DEBUG_OPENSCREEN(dprintf("OpenScreen: Dispose SubMenuImage Object\n"));
1788 DisposeObject(screen->DInfo.dri.dri_SubMenuImage);
1789 }
1790
1791 if (screen->DInfo.dri.dri_Font)
1792 {
1793 DEBUG_OPENSCREEN(dprintf("OpenScreen: Close Font\n"));
1794 CloseFont(screen->DInfo.dri.dri_Font);
1795 }
1796
1797 if (screen->AllocatedBitmap && !(ns.Type & CUSTOMBITMAP))
1798 {
1799 DEBUG_OPENSCREEN(dprintf("OpenScreen: Free BitMap\n"));
1800 FreeBitMap(screen->AllocatedBitmap);
1801 }
1802
1803 if (screen->Screen.ViewPort.RasInfo)
1804 {
1805 DEBUG_OPENSCREEN(dprintf("OpenScreen: Free RasInfo\n"));
1806 FreeMem(screen->Screen.ViewPort.RasInfo, sizeof (struct RasInfo));
1807 }
1808
1809 if (rp_inited)
1810 {
1811 DEBUG_OPENSCREEN(dprintf("OpenScreen: Trash Rastport\n"));
1812 DeinitRastPort(&screen->Screen.RastPort);
1813 }
1814
1815 if (screen->DecorUserBuffer)
1816 {
1817 FreeMem((void *)screen->DecorUserBuffer, screen->DecorUserBufferSize);
1818 }
1819
1820 if (screen->Decorator) screen->Decorator->nd_cnt--;
1821
1822 DEBUG_OPENSCREEN(dprintf("OpenScreen: Free Screen\n"));
1823 FreeMem (screen, sizeof (struct IntScreen));
1824
1825 screen = 0;
1826
1827 } /* if (!ok) */
1828
1829 DEBUG_OPENSCREEN(dprintf("OpenScreen: return 0x%lx\n", screen));
1830
1831 FireScreenNotifyMessage((IPTR) screen, SNOTIFY_AFTER_OPENSCREEN, IntuitionBase);
1832
1833 ReturnPtr ("OpenScreen", struct Screen *, (struct Screen *)screen);
1834
1835 AROS_LIBFUNC_EXIT
1836
1837 } /* OpenScreen */
1838
1839 static VOID int_openscreen(struct OpenScreenActionMsg *msg,
1840 struct IntuitionBase *IntuitionBase)
1841 {
1842 ULONG lock;
1843 struct IntScreen *screen = msg->Screen;
1844 struct NewScreen *ns = msg->NewScreen;
1845 struct List *list = msg->List;
1846 struct Screen *oldFirstScreen;
1847
1848 DEBUG_OPENSCREEN(dprintf("OpenScreen: Checking for pubScrNode (0x%lx)\n",screen->pubScrNode));
1849
1850 /* If this is a public screen, we link it into the intuition global
1851 public screen list */
1852 if (screen->pubScrNode != NULL)
1853 {
1854 /* Set the pointer to ourselves */
1855 GetPrivScreen(screen)->pubScrNode->psn_Screen = &screen->Screen;
1856
1857 DEBUG_OPENSCREEN(dprintf("OpenScreen: Add Screen to PubList\n"));
1858 AddTail(list, (struct Node *)GetPrivScreen(screen)->pubScrNode);
1859 }
1860
1861 lock = LockIBase(0);
1862
1863 oldFirstScreen = IntuitionBase->FirstScreen;
1864
1865 if (ns->Type & SCREENBEHIND)
1866 {
1867 struct Screen **ptr = &IntuitionBase->FirstScreen;
1868
1869 DEBUG_OPENSCREEN(dprintf("OpenScreen: Sort Behind\n"));
1870 if (!*ptr)
1871 IntuitionBase->ActiveScreen = &screen->Screen;
1872 while (*ptr)
1873 ptr = &(*ptr)->NextScreen;
1874 *ptr = &screen->Screen;
1875 }
1876 else
1877 {
1878 screen->Screen.NextScreen = IntuitionBase->FirstScreen;
1879 IntuitionBase->FirstScreen =
1880 IntuitionBase->ActiveScreen = &screen->Screen;
1881 DEBUG_OPENSCREEN(dprintf("OpenScreen: Set as ActiveScreen\n"));
1882 }
1883
1884 /* If it's the first screen being opened, activate its monitor */
1885 if (!oldFirstScreen)
1886 ActivateMonitor(screen->MonitorObject, -1, -1, IntuitionBase);
1887
1888 /* set the default pub screen */
1889 if (GetPrivIBase(IntuitionBase)->IControlPrefs.ic_Flags & ICF_DEFPUBSCREEN)
1890 {
1891 if ((IntuitionBase->FirstScreen == &screen->Screen) && screen->pubScrNode && (screen->Screen.Flags & (PUBLICSCREEN | WBENCHSCREEN)))
1892 {
1893 GetPrivIBase(IntuitionBase)->DefaultPubScreen = &screen->Screen;
1894 }
1895 }
1896
1897 UnlockIBase(lock);
1898
1899 D(bug("set active screen\n"));
1900
1901 AddResourceToList(screen, RESOURCE_SCREEN, IntuitionBase);
1902
1903 }
Mirror of AROS' svn.