compiler/arossupport/rt_intuition.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Basic functions for ressource tracking
   6     Lang: english
   7 */
   8
   9 #include "rt.h"
  10 #if 0
  11 #define ENABLE_RT 0     /* no RT inside this file */
  12 #define RT_INTERNAL 1
  13 #include <aros/rt.h>
  14
  15 #include <exec/lists.h>
  16 #include <aros/system.h>
  17 #include <exec/tasks.h>
  18 #include <exec/ports.h>
  19 #include <exec/memory.h>
  20 #include <exec/execbase.h>
  21 #include <stdarg.h>
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include <proto/alib.h>
  25 #include "etask.h"
  26 #endif
  27 #include <proto/exec.h>
  28 #include <proto/arossupport.h>
  29 #include <proto/intuition.h>
  30
  31 typedef struct
  32 {
  33     RTNode          Node;
  34     struct Screen * Screen;
  35 }
  36 ScreenResource;
  37
  38 typedef struct
  39 {
  40     RTNode          Node;
  41     struct Window * Window;
  42 }
  43 WindowResource;
  44
  45 static IPTR RT_OpenScreen (RTData * rtd, ScreenResource * rt, va_list args, BOOL * success);
  46 static IPTR RT_CloseScreen (RTData * rtd, ScreenResource * rt);
  47 static IPTR RT_ShowErrorScreen (RTData * rtd, int, ScreenResource *, IPTR, int, const char * file, ULONG line, va_list);
  48 static IPTR RT_CheckScreen (RTData * rtd, int desc, const char * file, ULONG line, ULONG op, va_list args);
  49
  50 static IPTR RT_OpenWindow (RTData * rtd, WindowResource * rt, va_list args, BOOL * success);
  51 static IPTR RT_CloseWindow (RTData * rtd, WindowResource * rt);
  52 static IPTR RT_ShowErrorWindow (RTData * rtd, int, WindowResource *, IPTR, int, const char * file, ULONG line, va_list);
  53 static IPTR RT_CheckWindow (RTData * rtd, int desc, const char * file, ULONG line, ULONG op, va_list args);
  54
  55 static const RTDesc RT_IntuitionResources[] =
  56 {
  57     { /* RTT_SCREEN */
  58         sizeof (ScreenResource),
  59         (RT_AllocFunc) RT_OpenScreen,
  60         (RT_FreeFunc)  RT_CloseScreen,
  61         RT_Search,
  62         (RT_ShowError) RT_ShowErrorScreen,
  63         (RT_CheckFunc) RT_CheckScreen,
  64     },
  65     { /* RTT_WINDOW */
  66         sizeof (WindowResource),
  67         (RT_AllocFunc) RT_OpenWindow,
  68         (RT_FreeFunc)  RT_CloseWindow,
  69         RT_Search,
  70         (RT_ShowError) RT_ShowErrorWindow,
  71         (RT_CheckFunc) RT_CheckWindow,
  72     },
  73 };
  74
  75 void RT_InitIntuition (void)
  76 {
  77     RT_Resources[RTT_SCREEN] = &RT_IntuitionResources[0];
  78     RT_Resources[RTT_WINDOW] = &RT_IntuitionResources[1];
  79 }
  80
  81 void RT_ExitIntuition (void)
  82 {
  83 }
  84
  85 /**************************************
  86             RT Screens
  87 **************************************/
  88
  89 static IPTR RT_OpenScreen (RTData * rtd, ScreenResource * rt, va_list args, BOOL * success)
  90 {
  91     struct NewScreen * ns;
  92     struct TagItem   * tags = NULL;
  93     int op;
  94
  95     op = va_arg (args, int);
  96     ns = va_arg (args, struct NewScreen *);
  97
  98     switch (op)
  99     {
 100     case RTTO_OpenScreenTags:
 101         tags = (struct TagItem *)args;
 102         break;
 103
 104     case RTTO_OpenScreenTagList:
 105         tags = va_arg (args, struct TagItem *);
 106         break;
 107
 108     }
 109
 110     if (!CheckPtr (ns, NULL_PTR))
 111     {
 112         kprintf ("OpenScreen(): Illegal NewScreen pointer\n"
 113                 "    NewScreen=%p at %s:%d\n"
 114             , ns
 115             , rt->Node.File, rt->Node.Line
 116         );
 117         return 0ul;
 118     }
 119     else if (!CheckPtr (tags, NULL_PTR))
 120     {
 121         kprintf ("OpenScreenTagList(): Illegal TagItem pointer\n"
 122                 "    tagList=%p at %s:%d\n"
 123             , tags
 124             , rt->Node.File, rt->Node.Line
 125         );
 126         return 0ul;
 127     }
 128
 129     rt->Screen = OpenScreenTagList (ns, tags);
 130
 131     if (rt->Screen)
 132         *success = TRUE;
 133
 134     return (IPTR)(rt->Screen);
 135 } /* RT_OpenScreen */
 136
 137 static IPTR RT_CloseScreen (RTData * rtd, ScreenResource * rt)
 138 {
 139     if (rt->Screen->FirstWindow)
 140     {
 141         struct Window  * win;
 142         WindowResource * rtwin;
 143         APTR prtwin = &rtwin;
 144
 145         kprintf ("CloseScreen(): There are still windows open on this screen\n"
 146                 "    Screen=%p opened at %s:%d\n"
 147                 , rt->Screen
 148                 , rt->Node.File, rt->Node.Line
 149         );
 150
 151         while ((win = rt->Screen->FirstWindow))
 152         {
 153             if (RT_Search (rtd, RTT_WINDOW, (RTNode **)prtwin, NULL) == RT_SEARCH_FOUND)
 154             {
 155                 RT_FreeResource (rtd, RTT_WINDOW, (RTNode *)rtwin);
 156             }
 157             else
 158             {
 159                 kprintf ("  Window=%p not tracked by the RT system\n"
 160                     , win
 161                 );
 162                 CloseWindow (win);
 163             }
 164         }
 165     } /* Check for windows */
 166
 167     /* Close the screen */
 168     CloseScreen (rt->Screen);
 169
 170     return TRUE;
 171 } /* RT_CloseScreen */
 172
 173 static IPTR RT_ShowErrorScreen (RTData * rtd, int rtt, ScreenResource * rt,
 174         IPTR ret, int mode, const char * file, ULONG line, va_list args)
 175 {
 176     if (mode != RT_EXIT)
 177     {
 178         const char    * modestr = (mode == RT_FREE) ? "Close" : "Check";
 179         struct Screen * scr;
 180
 181         scr = va_arg (args, struct Screen *);
 182
 183         switch (ret)
 184         {
 185         case RT_SEARCH_FOUND:
 186             if (rt->Node.Flags & RTNF_DONT_FREE)
 187             {
 188                 kprintf ("RT%s: Try to free read-only resource: Screen\n"
 189                         "    %s at %s:%d\n"
 190                         "    Added at %s:%d\n"
 191                         "    Screen=%p\n"
 192                     , modestr
 193                     , modestr
 194                     , file, line
 195                     , rt->Node.File, rt->Node.Line
 196                     , rt->Screen
 197                 );
 198             }
 199             break;
 200
 201         case RT_SEARCH_NOT_FOUND:
 202             kprintf ("RT%s: Screen not found\n"
 203                     "    %s at %s:%d\n"
 204                     "    Screen=%p\n"
 205                 , modestr
 206                 , modestr
 207                 , file, line
 208                 , scr
 209             );
 210             break;
 211
 212         } /* switch */
 213     }
 214     else
 215     {
 216         kprintf ("RTExit: Screen was not closed\n"
 217                 "    Opened at %s:%d\n"
 218                 "    Screen=%p\n"
 219             , rt->Node.File, rt->Node.Line
 220             , rt->Screen
 221         );
 222     }
 223
 224     return ret;
 225 } /* RT_ShowErrorScreen */
 226
 227 static IPTR RT_CheckScreen (RTData * rtd, int rtt,
 228                         const char * file, ULONG line,
 229                         ULONG op, va_list args)
 230 {
 231     ScreenResource * rt;
 232     APTR prt = &rt;
 233
 234     if (RT_Search (rtd, rtt, (RTNode **)prt, args) != RT_SEARCH_FOUND)
 235         rt = NULL;
 236
 237     switch (op)
 238     {
 239     case RTTO_ScreenToFront:
 240         {
 241             struct Screen * scr = va_arg (args, struct Screen *);
 242
 243             if (!rt)
 244             {
 245                 kprintf ("ScreenToFont(): Illegal window pointer\n"
 246                         "    Screen=%p at %s:%d\n"
 247                     , scr
 248                     , file, line
 249                 );
 250
 251                 return -1;
 252             }
 253
 254             ScreenToFront (scr);
 255
 256             return 0;
 257         }
 258
 259     case RTTO_ScreenToBack:
 260         {
 261             struct Screen * scr = va_arg (args, struct Screen *);
 262
 263             if (!rt)
 264             {
 265                 kprintf ("ScreenToBack(): Illegal window pointer\n"
 266                         "    Screen=%p at %s:%d\n"
 267                     , scr
 268                     , file, line
 269                 );
 270
 271                 return -1;
 272             }
 273
 274             ScreenToBack (scr);
 275
 276             return 0;
 277         }
 278
 279     }
 280
 281     return 0L;
 282 } /* RT_CheckScreen */
 283
 284
 285 /**************************************
 286             RT Windows
 287 **************************************/
 288
 289 static IPTR RT_OpenWindow (RTData * rtd, WindowResource * rt, va_list args, BOOL * success)
 290 {
 291     struct NewWindow * nw;
 292     struct TagItem   * tags = NULL;
 293     int op;
 294
 295     op = va_arg (args, int);
 296     nw = va_arg (args, struct NewWindow *);
 297
 298     switch (op)
 299     {
 300     case RTTO_OpenWindowTags:
 301         tags = (struct TagItem *)args;
 302         break;
 303
 304     case RTTO_OpenWindowTagList:
 305         tags = va_arg (args, struct TagItem *);
 306         break;
 307
 308     }
 309
 310     if (!CheckPtr (nw, NULL_PTR))
 311     {
 312         kprintf ("OpenWindow(): Illegal NewWindow pointer\n"
 313                 "    NewWindow=%p at %s:%d\n"
 314             , nw
 315             , rt->Node.File, rt->Node.Line
 316         );
 317         return 0ul;
 318     }
 319     else if (!CheckPtr (tags, NULL_PTR))
 320     {
 321         kprintf ("OpenWindowTagList(): Illegal TagList pointer\n"
 322                 "    tagList=%p at %s:%d\n"
 323             , nw
 324             , rt->Node.File, rt->Node.Line
 325         );
 326         return 0ul;
 327     }
 328
 329     rt->Window = OpenWindowTagList (nw, tags);
 330
 331     if (rt->Window->UserPort)
 332         RT_IntTrack (RTT_PORT, __FILE__, __LINE__, rt->Window->UserPort);
 333
 334     if (rt->Window)
 335         *success = TRUE;
 336
 337     return (IPTR)(rt->Window);
 338 } /* RT_OpenWindow */
 339
 340 static IPTR RT_CloseWindow (RTData * rtd, WindowResource * rt)
 341 {
 342     CloseWindow (rt->Window);
 343
 344     return TRUE;
 345 } /* RT_CloseWindow */
 346
 347 static IPTR RT_ShowErrorWindow (RTData * rtd, int rtt, WindowResource * rt,
 348         IPTR ret, int mode, const char * file, ULONG line, va_list args)
 349 {
 350     if (mode != RT_EXIT)
 351     {
 352         const char    * modestr = (mode == RT_FREE) ? "Close" : "Check";
 353         struct Window * win;
 354
 355         win = va_arg (args, struct Window *);
 356
 357         switch (ret)
 358         {
 359         case RT_SEARCH_FOUND:
 360             if (rt->Node.Flags & RTNF_DONT_FREE)
 361             {
 362                 kprintf ("RT%s: Try to free read-only resource: Window\n"
 363                         "    %s at %s:%d\n"
 364                         "    Added at %s:%d\n"
 365                         "    Window=%p\n"
 366                     , modestr
 367                     , modestr
 368                     , file, line
 369                     , rt->Node.File, rt->Node.Line
 370                     , rt->Window
 371                 );
 372             }
 373             break;
 374
 375         case RT_SEARCH_NOT_FOUND:
 376             kprintf ("RT%s: Window not found\n"
 377                     "    %s at %s:%d\n"
 378                     "    Window=%p\n"
 379                 , modestr
 380                 , modestr
 381                 , file, line
 382                 , win
 383             );
 384             break;
 385
 386         } /* switch */
 387     }
 388     else
 389     {
 390         kprintf ("RTExit: Window was not closed\n"
 391                 "    Opened at %s:%d\n"
 392                 "    Window=%p\n"
 393             , rt->Node.File, rt->Node.Line
 394             , rt->Window
 395         );
 396     }
 397
 398     return ret;
 399 } /* RT_ShowErrorWindow */
 400
 401 static IPTR RT_CheckWindow (RTData * rtd, int rtt,
 402                         const char * file, ULONG line,
 403                         ULONG op, va_list args)
 404 {
 405     WindowResource * rt;
 406     APTR prt = &rt;
 407
 408     if (RT_Search (rtd, rtt, (RTNode **)prt, args) != RT_SEARCH_FOUND)
 409         rt = NULL;
 410
 411     switch (op)
 412     {
 413     case RTTO_WindowToFront:
 414         {
 415             struct Window * win = va_arg (args, struct Window *);
 416
 417             if (!rt)
 418             {
 419                 kprintf ("WindowToFont(): Illegal window pointer\n"
 420                         "    Window=%p at %s:%d\n"
 421                     , win
 422                     , file, line
 423                 );
 424
 425                 return -1;
 426             }
 427
 428             WindowToFront (win);
 429
 430             return 0;
 431         }
 432
 433     case RTTO_WindowToBack:
 434         {
 435             struct Window * win = va_arg (args, struct Window *);
 436
 437             if (!rt)
 438             {
 439                 kprintf ("WindowToBack(): Illegal window pointer\n"
 440                         "    Window=%p at %s:%d\n"
 441                     , win
 442                     , file, line
 443                 );
 444
 445                 return -1;
 446             }
 447
 448             WindowToBack (win);
 449
 450             return 0;
 451         }
 452
 453     } /* switch (op) */
 454
 455     return 0L;
 456 } /* RT_CheckWindow */
 457