home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 15 / AACD15.ISO / AACD / Programming / MultiDesktop / scr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-27  |  16.5 KB  |  737 lines
  1. /* Screen-Verwaltung */
  2. #include "multiwindows.h"
  3.  
  4. extern struct ExecBase         *SysBase;
  5. extern struct MultiWindowsBase *MultiWindowsBase;
  6.  
  7. UWORD StdPalette[]={0xaaa,0x000,0xfff,0x68b,0x999,0xbbb,0xba9,0xfba};
  8. UWORD StdPens[]={0,1,1,2,1,3,1,0,2,-1};
  9.  
  10. UWORD GetScreenWidth();
  11. BOOL  InitBackdrop();
  12. void  RemoveBackdrop();
  13.  
  14. /* ---- Screen öffnen */
  15. BOOL CreateScreen(screenID,titleID,w,h,d,modeID,type,flags,addTagList)
  16.  UBYTE           screenID;
  17.  UBYTE          *titleID;
  18.  UWORD           w,h;
  19.  UBYTE           d;
  20.  ULONG           modeID;
  21.  ULONG           type;
  22.  UWORD           flags;
  23.  struct TagItem *addTagList;
  24. {
  25.  LONG                      errorCode;
  26.  struct MultiWindowsUser  *mw;
  27.  struct ScreenEntry       *se;
  28.  struct Screen            *scr;
  29.  
  30.  USER;
  31.  if(screenID>MAXSCREENS)
  32.   { ErrorL(1112,"CreateScreen():\nInvalid ScreenID!");
  33.     return(FALSE); }
  34.  if(mw->ScreenList[screenID]!=NULL)
  35.   { ErrorL(1113,"CreateScreen():\nScreenID already used!");
  36.     return(FALSE); }
  37.  
  38.  se=ALLOC1(sizeof(struct ScreenEntry));
  39.  if(se==NULL)
  40.   {
  41.    NoMemory();
  42.    return(FALSE);
  43.   }
  44.  
  45.  se->TagList[0].ti_Tag=SA_Width;
  46.  se->TagList[0].ti_Data=w;
  47.  se->TagList[1].ti_Tag=SA_Height;
  48.  se->TagList[1].ti_Data=h;
  49.  se->TagList[2].ti_Tag=SA_Depth;
  50.  se->TagList[2].ti_Data=d;
  51.  se->TagList[3].ti_Tag=SA_DisplayID;
  52.  se->TagList[3].ti_Data=modeID;
  53.  se->TagList[4].ti_Tag=SA_ErrorCode;
  54.  se->TagList[4].ti_Data=&errorCode;
  55.  se->TagList[5].ti_Tag=SA_SysFont;
  56.  se->TagList[5].ti_Data=1;
  57.  
  58.  if((d>1)&&(!(flags & CS_NOSTDCOLORS)))
  59.   {
  60.    se->TagList[6].ti_Tag=SA_Pens;
  61.    se->TagList[6].ti_Data=&StdPens;
  62.   }
  63.  else
  64.    se->TagList[6].ti_Tag=TAG_IGNORE;
  65.  
  66.  se->TagList[7].ti_Tag=SA_Overscan;
  67.  if(flags & CS_TEXTOVERSCAN)
  68.    se->TagList[7].ti_Data=OSCAN_TEXT;
  69.  else if(flags & CS_STDOVERSCAN)
  70.    se->TagList[7].ti_Data=OSCAN_STANDARD;
  71.  else if(flags & CS_MAXOVERSCAN)
  72.    se->TagList[7].ti_Data=OSCAN_MAX;
  73.  else if(flags & CS_VIDEOOVERSCAN)
  74.    se->TagList[7].ti_Data=OSCAN_VIDEO;
  75.  else
  76.    se->TagList[7].ti_Tag=TAG_IGNORE;
  77.  if(!flags & CS_NOAUTOSCROLL)
  78.   {
  79.    se->TagList[8].ti_Tag=SA_AutoScroll;
  80.    se->TagList[8].ti_Data=TRUE;
  81.   }
  82.  else
  83.    se->TagList[8].ti_Tag=TAG_IGNORE;
  84.  se->TagList[9].ti_Tag=SA_Title;
  85.  se->TagList[9].ti_Data=FindID(mw->Catalog,titleID);
  86.  se->TagList[10].ti_Tag=SA_Type;
  87.  se->TagList[10].ti_Data=type;
  88.  if(addTagList)
  89.   {
  90.    se->TagList[11].ti_Tag=TAG_MORE;
  91.    se->TagList[11].ti_Data=addTagList;
  92.   }
  93.  else
  94.    se->TagList[11].ti_Tag=TAG_IGNORE;
  95.  
  96.  se->TagList[12].ti_Tag=SA_Left;       /* für Iconify/UnIconify         */
  97.  se->TagList[12].ti_Data=0;            /* ACHTUNG: Tag-Nummer 12 und 13 */
  98.  se->TagList[13].ti_Tag=SA_Top;        /*   bei Änderungen beachten!    */
  99.  se->TagList[13].ti_Data=0;
  100.  
  101.  se->TagList[14].ti_Tag=TAG_DONE;
  102.  se->TagList[14].ti_Data=0;
  103.  
  104.  errorCode=0;
  105.  scr=OpenScreenTagList(NULL,&se->TagList);
  106.  if(scr==NULL)
  107.   {
  108.    switch(errorCode)
  109.     {
  110.      case OSERR_NOMONITOR:
  111.        ErrorL(1114,"CreateScreen():\nWrong monitor for this ModeID!");
  112.       break;
  113.      case OSERR_NOCHIPS:
  114.        ErrorL(1115,"CreateScreen():\nWrong custom chips for this ModeID!");
  115.       break;
  116.      case OSERR_NOCHIPMEM:
  117.        ErrorL(1116,"CreateScreen():\nWrong custom chips for this ModeID!");
  118.       break;
  119.      case OSERR_PUBNOTUNIQUE:
  120.        ErrorL(1117,"CreateScreen():\nPublic screen name not unique!");
  121.       break;
  122.      case OSERR_UNKNOWNMODE:
  123.        ErrorL(1118,"CreateScreen():\nUnknown ModeID!");
  124.       break;
  125.      default:
  126.        ErrorL(0,0);
  127.       break;
  128.     }
  129.    FREE1(se);
  130.    return(FALSE);
  131.   }
  132.  
  133.  se->Screen=scr;
  134.  se->Iconify=FALSE;
  135.  se->RastPort=&scr->RastPort;
  136.  se->ViewPort=&scr->ViewPort;
  137.  se->BitMap=se->RastPort->BitMap;
  138.  se->LayerInfo=&scr->LayerInfo;
  139.  se->ColorMap=se->ViewPort->ColorMap;
  140.  scr->UserData=se;
  141.  
  142.  se->ScreenID=screenID;
  143.  se->ModeID=modeID;
  144.  se->ScreenFlags=flags;
  145.  NewList(&se->WindowList);
  146.  GetDisplayInfoData(NULL,&se->DisplayInfoBuffer,sizeof(struct DisplayInfo),DTAG_DISP,modeID);
  147.  se->DisplayInfo=&se->DisplayInfoBuffer;
  148.  
  149.  if(!(flags & CS_NOSTDCOLORS))
  150.   {
  151.    if(d==2)
  152.      LoadRGB4(se->ViewPort,&StdPalette,4L);
  153.    else if(d>2)
  154.      LoadRGB4(se->ViewPort,&StdPalette,8L);
  155.   }
  156.  if(!(flags & CS_NOBACKDROP))
  157.    InitBackdrop(se);
  158.  
  159.  mw->ScreenList[screenID]=se; 
  160.  return(TRUE);
  161. }
  162.  
  163. /* ---- ScreenEntry für ID ermitteln */
  164. struct ScreenEntry *FindScreenEntry(screenID)
  165.  UBYTE screenID;
  166. {
  167.  struct MultiWindowsUser  *mw;
  168.  struct ScreenEntry       *we;
  169.  
  170.  USER;
  171.  if(screenID>MAXSCREENS)
  172.   { ErrorL(1119,"FindScreenEntry():\nInvalid ScreenID!");
  173.     return(NULL); }
  174.  
  175.  we=mw->ScreenList[screenID];
  176.  if(we==NULL)
  177.   { ErrorL(1120,"FindScreenEntry():\nNo screen with this ScreenID available!");
  178.     return(NULL); }
  179.  return(we);
  180. }
  181.  
  182. /* ---- Prüfen, ob ScreenID gültig ist */
  183. BOOL CheckScreenID(screenID)
  184.  UBYTE screenID;
  185. {
  186.  struct MultiWindowsUser *mw;
  187.  
  188.  USER;
  189.  if(screenID<=MAXSCREENS)
  190.   { if(mw->ScreenList[screenID]!=NULL) return(TRUE); }
  191.  return(FALSE);
  192. }
  193.  
  194. /* ---- Screen schließen */
  195. void DeleteScreen(screenID)
  196.  UBYTE screenID;
  197. {
  198.  struct ScreenEntry      *se;
  199.  struct MultiWindowsUser *mw;
  200.  
  201.  if((CheckScreenID(screenID))==FALSE) return;
  202.  se=FindScreenEntry(screenID);
  203.  if(se!=NULL)
  204.   {
  205.    mw->ScreenList[screenID]=NULL;
  206.    RemoveBackdrop(se);
  207.    if(se->Screen) CloseScreen(se->Screen);
  208.    FREE1(se);
  209.   }
  210. }
  211.  
  212. /* ---- Displaymodes ermitteln */
  213. struct List *ScanDisplayModes()
  214. {
  215.  struct MultiWindowsUser *mw;
  216.  struct VideoInfo        *vi;
  217.  struct NameInfo          ninfo;
  218.  ULONG                    okay;
  219.  ULONG                    modeID;
  220.  
  221.  if(MultiWindowsBase->VideoInfoList.lh_Head!=NULL)
  222.    return(&MultiWindowsBase->VideoInfoList);
  223.  
  224.  NewList(&MultiWindowsBase->VideoInfoList);
  225.  modeID=NextDisplayInfo(INVALID_ID);
  226.  while(modeID!=INVALID_ID)
  227.   {
  228.    okay=ModeNotAvailable(modeID);
  229.    if((okay==0)&&(modeID & MONITOR_ID_MASK))
  230.     {
  231.      okay=GetDisplayInfoData(NULL,&ninfo,sizeof(struct NameInfo),DTAG_NAME,modeID);
  232.      if(okay!=NULL)
  233.       {
  234.        vi=AllocMem(sizeof(struct VideoInfo),MEMF_CLEAR|MEMF_PUBLIC);
  235.        if(vi!=NULL)
  236.         {
  237.          CopyMemQuick(&ninfo,&vi->NameInfoBuffer,sizeof(struct NameInfo));
  238.          vi->ModeID=modeID;
  239.          vi->NameInfo=&vi->NameInfoBuffer;
  240.          vi->DisplayInfo=&vi->DisplayInfoBuffer;
  241.          vi->DimensionInfo=&vi->DimensionInfoBuffer;
  242.          vi->MonitorInfo=&vi->MonitorInfoBuffer;
  243.          vi->Node.ln_Name=&vi->NameInfoBuffer.Name;
  244.          GetDisplayInfoData(NULL,&vi->DisplayInfoBuffer,sizeof(struct DisplayInfo),DTAG_DISP,modeID);
  245.          GetDisplayInfoData(NULL,&vi->DimensionInfoBuffer,sizeof(struct DimensionInfo),DTAG_DIMS,modeID);
  246.          GetDisplayInfoData(NULL,&vi->MonitorInfoBuffer,sizeof(struct MonitorInfo),DTAG_MNTR,modeID);
  247.          AddTail(&MultiWindowsBase->VideoInfoList,vi);
  248.          MultiWindowsBase->VideoInfoCount++;
  249.         }
  250.        else
  251.          NoMemory();
  252.       }
  253.     }
  254.    modeID=NextDisplayInfo(modeID);
  255.   }
  256.  return(&MultiWindowsBase->VideoInfoList);
  257. }
  258.  
  259. /* ---- Screendaten ermitteln */
  260. APTR GetScreenLayerInfo(screenID)
  261.  UBYTE screenID;
  262. {
  263.  struct ScreenEntry *se;
  264.  se=FindScreenEntry(screenID);
  265.  if(se) return(se->LayerInfo);
  266.  return(NULL);
  267. }
  268.  
  269. /* ---- Screendaten ermitteln */
  270. UBYTE *GetScreenTitle(screenID)
  271.  UBYTE screenID;
  272. {
  273.  struct ScreenEntry *se;
  274.  se=FindScreenEntry(screenID);
  275.  if((se)&&(se->Screen)) return(se->Screen->Title);
  276.  return(NULL);
  277. }
  278.  
  279. /* ---- Screendaten ermitteln */
  280. UBYTE *GetScreenDefaultTitle(screenID)
  281.  UBYTE screenID;
  282. {
  283.  struct ScreenEntry *se;
  284.  se=FindScreenEntry(screenID);
  285.  if((se)&&(se->Screen)) return(se->Screen->DefaultTitle);
  286.  return(NULL);
  287. }
  288.  
  289. /* ---- Screendaten ermitteln */
  290. APTR GetScreenRastPort(screenID)
  291.  UBYTE screenID;
  292. {
  293.  struct ScreenEntry *se;
  294.  se=FindScreenEntry(screenID);
  295.  if(se) return(se->RastPort);
  296.  return(NULL);
  297. }
  298.  
  299. /* ---- Screendaten ermitteln */
  300. APTR GetScreenViewPort(screenID)
  301.  UBYTE screenID;
  302. {
  303.  struct ScreenEntry *se;
  304.  se=FindScreenEntry(screenID);
  305.  if(se) return(se->ViewPort);
  306.  return(NULL);
  307. }
  308.  
  309. /* ---- Screendaten ermitteln */
  310. APTR GetScreenBitMap(screenID)
  311.  UBYTE screenID;
  312. {
  313.  struct ScreenEntry *se;
  314.  se=FindScreenEntry(screenID);
  315.  if(se) return(se->BitMap);
  316.  return(NULL);
  317. }
  318.  
  319. /* ---- Screendaten ermitteln */
  320. APTR GetScreenDisplayInfo(screenID)
  321.  UBYTE screenID;
  322. {
  323.  struct ScreenEntry *se;
  324.  se=FindScreenEntry(screenID);
  325.  if(se) return(se->DisplayInfo);
  326.  return(NULL);
  327. }
  328.  
  329. /* ---- Screendaten ermitteln */
  330. APTR GetScreenCMap(screenID)
  331.  UBYTE screenID;
  332. {
  333.  struct ScreenEntry *se;
  334.  se=FindScreenEntry(screenID);
  335.  if(se) return(se->ColorMap);
  336.  return(NULL);
  337. }
  338.  
  339. /* ---- Screendaten ermitteln */
  340. APTR GetScreenCTable(screenID)
  341.  UBYTE screenID;
  342. {
  343.  struct ScreenEntry *se;
  344.  se=FindScreenEntry(screenID);
  345.  if((se)&&(se->ColorMap)) return(se->ColorMap->ColorTable);
  346.  return(NULL);
  347. }
  348.  
  349. /* ---- Screendaten ermitteln */
  350. APTR GetScreenBitplane(screenID,num)
  351.  UBYTE screenID;
  352.  UBYTE num;
  353. {
  354.  struct ScreenEntry *se;
  355.  se=FindScreenEntry(screenID);
  356.  if((se)&&(se->BitMap))
  357.   {
  358.    if(num<se->BitMap->Depth)
  359.      return(se->BitMap->Planes[num]);
  360.   }
  361.  return(NULL);
  362. }
  363.  
  364. /* ---- Screendaten ermitteln */
  365. UWORD GetScreenLeftEdge(screenID)
  366.  UBYTE screenID;
  367. {
  368.  struct ScreenEntry *se;
  369.  se=FindScreenEntry(screenID);
  370.  if((se)&&(se->Screen)) return(se->Screen->LeftEdge);
  371.  return(0);
  372. }
  373.  
  374. /* ---- Screendaten ermitteln */
  375. UWORD GetScreenInnerLeftEdge(screenID)
  376.  UBYTE screenID;
  377. { return(0); }
  378.  
  379. /* ---- Screendaten ermitteln */
  380. UWORD GetScreenInnerWidth(screenID)
  381.  UBYTE screenID;
  382. { return(GetScreenWidth(screenID)); }
  383.  
  384. /* ---- Screendaten ermitteln */
  385. UWORD GetScreenInnerTopEdge(screenID)
  386.  UBYTE screenID;
  387. {
  388.  struct ScreenEntry *se;
  389.  se=FindScreenEntry(screenID);
  390.  if((se)&&(se->Screen)) return(se->Screen->BarHeight+1);
  391.  return(0);
  392. }
  393.  
  394. /* ---- Screendaten ermitteln */
  395. UWORD GetScreenInnerHeight(screenID)
  396.  UBYTE screenID;
  397. {
  398.  struct ScreenEntry *se;
  399.  se=FindScreenEntry(screenID);
  400.  if((se)&&(se->Screen)) return(se->Screen->Height-se->Screen->BarHeight-1);
  401.  return(0);
  402. }
  403.  
  404. /* ---- Screendaten ermitteln */
  405. BOOL GetScreenIconifyStatus(screenID)
  406.  UBYTE screenID;
  407. {
  408.  struct ScreenEntry *se;
  409.  se=FindScreenEntry(screenID);
  410.  if(se) return(se->Iconify);
  411.  return(FALSE);
  412. }
  413.  
  414. /* ---- Screendaten ermitteln */
  415. UWORD GetScreenTopEdge(screenID)
  416.  UBYTE screenID;
  417. {
  418.  struct ScreenEntry *se;
  419.  se=FindScreenEntry(screenID);
  420.  if((se)&&(se->Screen)) return(se->Screen->TopEdge);
  421.  return(0);
  422. }
  423.  
  424. /* ---- Screendaten ermitteln */
  425. UWORD GetScreenWidth(screenID)
  426.  UBYTE screenID;
  427. {
  428.  struct ScreenEntry *se;
  429.  se=FindScreenEntry(screenID);
  430.  if((se)&&(se->Screen)) return(se->Screen->Width);
  431.  return(0);
  432. }
  433.  
  434. /* ---- Screendaten ermitteln */
  435. UWORD GetScreenHeight(screenID)
  436.  UBYTE screenID;
  437. {
  438.  struct ScreenEntry *se;
  439.  se=FindScreenEntry(screenID);
  440.  if((se)&&(se->Screen)) return(se->Screen->Height);
  441.  return(0);
  442. }
  443.  
  444. /* ---- Screendaten ermitteln */
  445. UBYTE GetScreenDepth(screenID)
  446.  UBYTE screenID;
  447. {
  448.  struct ScreenEntry *se;
  449.  se=FindScreenEntry(screenID);
  450.  if((se)&&(se->Screen)) return(se->Screen->Depth);
  451.  return(0);
  452. }
  453.  
  454. /* ---- Screendaten ermitteln */
  455. APTR GetScreenAddress(screenID)
  456.  UBYTE screenID;
  457. {
  458.  struct ScreenEntry *se;
  459.  se=FindScreenEntry(screenID);
  460.  if(se) return(se->Screen);
  461.  return(NULL);
  462. }
  463.  
  464. /* ---- Screendaten ermitteln */
  465. ULONG GetScreenModeID(screenID)
  466.  UBYTE screenID;
  467. {
  468.  struct ScreenEntry *se;
  469.  se=FindScreenEntry(screenID);
  470.  if((se)&&(se->ViewPort)) return(GetVPModeID(se->ViewPort));
  471.  return(0);
  472. }
  473.  
  474. /* ---- Screendaten ermitteln */
  475. UWORD GetScreenViewModes(screenID)
  476.  UBYTE screenID;
  477. {
  478.  struct ScreenEntry *se;
  479.  se=FindScreenEntry(screenID);
  480.  if((se)&&(se->ViewPort)) return(se->ViewPort->Modes);
  481.  return(0);
  482. }
  483.  
  484. /* ---- Screen ikonifizieren */
  485. BOOL IconifyScreen(screenID,flags)
  486.  UBYTE screenID;
  487.  UWORD flags;
  488. {
  489.  struct ScreenEntry      *se;
  490.  struct MultiWindowsUser *mw;
  491.  struct WindowEntry      *we;
  492.  struct Node             *node;
  493.  UWORD                    colors;
  494.  UWORD                   *ctab;
  495.  
  496.  se=FindScreenEntry(screenID);
  497.  if((se!=NULL)&&(se->Iconify==FALSE))
  498.   {
  499.    colors=8;
  500.    ctab=AllocVec(colors*2,MEMF_ANY);
  501.    if(ctab==NULL)
  502.     {
  503.      NoMemory();
  504.      return(FALSE);
  505.     }
  506.    CopyMem(se->ColorMap->ColorTable,ctab,colors*2);
  507.  
  508.    if(flags & IF_APPICON)
  509.     {
  510.      se->AppIcon=CreateAppObject(-1L,AOT_ICON,"AppIcon",OT_SCREENENTRY,se);
  511.      if(se->AppIcon==NULL) {
  512.        FreeVec(ctab);
  513.        return(FALSE); }
  514.  
  515.     }
  516.    if(flags & IF_APPMENU)
  517.     {
  518.      se->AppMenuItem=CreateAppObject(-1L,AOT_MENUITEM,"AppMenuItem",OT_SCREENENTRY,se);
  519.      if(se->AppMenuItem==NULL)
  520.       {
  521.        if(se->AppIcon) DeleteAppObject(se->AppIcon);
  522.        FreeVec(ctab);
  523.        se->AppIcon=NULL;
  524.        return(FALSE);
  525.       }
  526.     }
  527.  
  528.    for(node=se->WindowList.lh_Head;node!=&se->WindowList.lh_Tail;node=node->ln_Succ)
  529.     {
  530.      we=node;
  531.      IconifyWindow(we->WindowID,IF_NONE);
  532.     }
  533.    RemoveBackdrop(se);
  534.  
  535.    se->TagList[12].ti_Data=se->Screen->LeftEdge;
  536.    se->TagList[13].ti_Data=se->Screen->TopEdge;
  537.  
  538.    CloseScreen(se->Screen);
  539.    se->Iconify=TRUE;
  540.  
  541.    se->Screen=NULL;
  542.    se->RastPort=NULL;
  543.    se->ViewPort=NULL;
  544.    se->BitMap=NULL;
  545.    se->LayerInfo=NULL;
  546.    se->ColorMap=NULL;
  547.    se->CTabBackup=ctab;
  548.    return(TRUE);
  549.   }
  550.  return(FALSE);
  551. }
  552.  
  553. /* ---- Screen entikonifizieren */
  554. BOOL UnIconifyScreen(screenID)
  555.  UBYTE screenID;
  556. {
  557.  BOOL                     okay,bool;
  558.  struct ScreenEntry      *se;
  559.  struct Screen           *scr;
  560.  struct MultiWindowsUser *mw;
  561.  struct WindowEntry      *we;
  562.  struct Node             *node;
  563.  
  564.  se=FindScreenEntry(screenID);
  565.  if((se!=NULL)&&(se->Iconify==TRUE))
  566.   {
  567.    scr=OpenScreenTagList(NULL,&se->TagList);
  568.    if(scr==NULL) return(FALSE);
  569.  
  570.    se->Screen=scr;
  571.    se->Iconify=FALSE;
  572.    se->RastPort=&scr->RastPort;
  573.    se->ViewPort=&scr->ViewPort;
  574.    se->BitMap=se->RastPort->BitMap;
  575.    se->LayerInfo=&scr->LayerInfo;
  576.    se->ColorMap=se->ViewPort->ColorMap;
  577.    scr->UserData=se;
  578.  
  579.    LoadRGB4(se->ViewPort,se->CTabBackup,8);
  580.    FreeVec(se->CTabBackup);
  581.    se->CTabBackup=NULL;
  582.  
  583.    InitBackdrop(se);
  584.    if((se->BgWallpaper!=NULL)&&(se->BgWindow!=NULL))
  585.      ShowWallpaperWindow(se->BgWindow,se->BgWallpaper);
  586.  
  587.    okay=TRUE;
  588.    for(node=se->WindowList.lh_Head;node!=&se->WindowList.lh_Tail;node=node->ln_Succ)
  589.     {
  590.      we=node;
  591.      bool=UnIconifyWindow(we->WindowID);
  592.      if(bool==FALSE) okay=FALSE;
  593.     }
  594.  
  595.    if(se->AppIcon) DeleteAppObject(se->AppIcon);
  596.    if(se->AppMenuItem) DeleteAppObject(se->AppMenuItem);
  597.    se->AppIcon=NULL;
  598.    se->AppMenuItem=NULL;
  599.  
  600.    return(okay);
  601.   }
  602.  return(FALSE);
  603. }
  604.  
  605. /* ---- Backdrop erstellen */
  606. BOOL InitBackdrop(se)
  607.  struct ScreenEntry *se;
  608. {
  609.  struct TagItem tags[7];
  610.  
  611.  tags[0].ti_Tag=WA_Width;
  612.  tags[0].ti_Data=se->Screen->Width;
  613.  tags[1].ti_Tag=WA_Height;
  614.  tags[1].ti_Data=se->Screen->Height-se->Screen->BarHeight-1;
  615.  tags[2].ti_Tag=WA_Top;
  616.  tags[2].ti_Data=se->Screen->BarHeight+1;
  617.  tags[3].ti_Tag=WA_CustomScreen;
  618.  tags[3].ti_Data=se->Screen;
  619.  tags[4].ti_Tag=WA_Flags;
  620.  tags[4].ti_Data=BORDERLESS|BACKDROP|RMBTRAP;
  621.  tags[5].ti_Tag=TAG_DONE;
  622.  tags[5].ti_Data=0;
  623.  
  624.  se->BgWindow=OpenWindowTagList(NULL,&tags);
  625.  if(se->BgWindow==NULL)
  626.    ErrorL(1122,"InitBackdrop():\nUnable to open backdrop window!");
  627.  else
  628.    SetWindowTitles(se->BgWindow,-1L,se->Screen->DefaultTitle);
  629. }
  630.  
  631. /* ---- Backdrop entfernen */
  632. void RemoveBackdrop(se)
  633.  struct ScreenEntry *se;
  634. {
  635.  if(se->BgWindow)
  636.   {
  637.    CloseWindow(se->BgWindow);
  638.    se->BgWindow=NULL;
  639.   }
  640. }
  641.  
  642. /* ---- Screen verschieben */
  643. void ScreenMove(screenID,x,y)
  644.  UBYTE screenID;
  645.  WORD  x,y;
  646. {
  647.  struct ScreenEntry *se;
  648.  struct Screen      *scr;
  649.  
  650.  se=FindScreenEntry(screenID);
  651.  if((se!=NULL)&&(se->Screen!=NULL))
  652.   {
  653.    scr=se->Screen;
  654.    MoveScreen(scr,x-scr->LeftEdge,y-scr->TopEdge);
  655.   }
  656. }
  657.  
  658. /* ---- Screen verschieben */
  659. void ScreenMoveDelta(screenID,x,y)
  660.  UBYTE screenID;
  661.  WORD  x,y;
  662. {
  663.  struct ScreenEntry *se;
  664.  struct Screen      *scr;
  665.  
  666.  se=FindScreenEntry(screenID);
  667.  if((se!=NULL)&&(se->Screen!=NULL))
  668.   {
  669.    scr=se->Screen;
  670.    MoveScreen(scr,x,y);
  671.   }
  672. }
  673.  
  674. /* ---- Screen noch Vorne legen */
  675. void ScreenFront(screenID)
  676.  UBYTE screenID;
  677. {
  678.  struct ScreenEntry *se;
  679.  
  680.  if(screenID==SCREENID_WORKBENCH)
  681.    WBenchToFront();
  682.  else
  683.   {
  684.    se=FindScreenEntry(screenID);
  685.    if((se!=NULL)&&(se->Screen!=NULL))
  686.      ScreenToFront(se->Screen);
  687.   }
  688. }
  689.  
  690. /* ---- Screen noch Hinten legen */
  691. void ScreenBack(screenID)
  692.  UBYTE screenID;
  693. {
  694.  struct ScreenEntry *se;
  695.  
  696.  if(screenID==SCREENID_WORKBENCH)
  697.    WBenchToBack();
  698.  else
  699.   {
  700.    se=FindScreenEntry(screenID);
  701.    if((se!=NULL)&&(se->Screen!=NULL))
  702.      ScreenToBack(se->Screen);
  703.   }
  704. }
  705.  
  706. /* ---- Screen-Titel setzen */
  707. void ScreenTitle(screenID,title)
  708.  UBYTE  screenID;
  709.  UBYTE *title;
  710. {
  711.  struct ScreenEntry *se;
  712.  
  713.  se=FindScreenEntry(screenID);
  714.  if((se!=NULL)&&(se->Screen!=NULL))
  715.   {
  716.    se->Screen->Title=title;
  717.    ShowTitle(se->Screen,TRUE);
  718.   }
  719. }
  720.  
  721. /* ---- Screen-Titel setzen */
  722. void ScreenDefaultTitle(screenID,title)
  723.  UBYTE  screenID;
  724.  UBYTE *title;
  725. {
  726.  struct ScreenEntry *se;
  727.  
  728.  se=FindScreenEntry(screenID);
  729.  if((se!=NULL)&&(se->Screen!=NULL))
  730.   {
  731.    if(se->BgWindow) SetWindowTitles(se->BgWindow,-1L,se->Screen->DefaultTitle);
  732.    se->Screen->DefaultTitle=title;
  733.    ShowTitle(se->Screen,TRUE);
  734.   }
  735. }
  736.  
  737.