1 /*

     2     SDL - Simple DirectMedia Layer

     3     Copyright (C) 1997-2004 Sam Lantinga

     4 

     5     This library is free software; you can redistribute it and/or

     6     modify it under the terms of the GNU Library General Public

     7     License as published by the Free Software Foundation; either

     8     version 2 of the License, or (at your option) any later version.

     9 

    10     This library is distributed in the hope that it will be useful,

    11     but WITHOUT ANY WARRANTY; without even the implied warranty of

    12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    13     Library General Public License for more details.

    14 

    15     You should have received a copy of the GNU Library General Public

    16     License along with this library; if not, write to the Free

    17     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    18 

    19     Sam Lantinga

    20     slouken@libsdl.org

    21 */

    22 #include "SDL_config.h"

    23 

    24 /*

    25     This file added by Alan Buckley (alan_baa@hotmail.com) to support RISC OS 

    26 	26 March 2003

    27 

    28 	File includes routines for:

    29 	  Setting up as a WIMP Task

    30 	  Reading information about the current desktop

    31 	  Storing information before a switch to full screen

    32 	  Restoring desktop after switching to full screen

    33 */

    34 

    35 #include "kernel.h"

    36 #include "swis.h"

    37 

    38 #include "SDL_stdinc.h"

    39 #include "SDL_riscostask.h"

    40 

    41 #if !SDL_THREADS_DISABLED

    42 #include <pthread.h>

    43 pthread_t main_thread;

    44 #endif

    45 

    46 /* RISC OS variables */

    47 

    48 static int task_handle = 0;

    49 static int wimp_version = 0;

    50 

    51 /* RISC OS variables to help compatability with certain programs */

    52 int riscos_backbuffer = 0; /* Create a back buffer in system memory for full screen mode */

    53 int riscos_closeaction = 1; /* Close icon action */

    54 

    55 static int stored_mode = -1; /* -1 when in desktop, mode number or pointer when full screen */

    56 

    57 extern int mouseInWindow; /* Mouse is in WIMP window */

    58 

    59 /* Local function */

    60 

    61 static int RISCOS_GetTaskName(char *task_name, size_t maxlen);

    62 

    63 /* Uncomment next line to copy mode changes/restores to stderr */

    64 /* #define DUMP_MODE */

    65 #ifdef DUMP_MODE

    66 #include "stdio.h"

    67 static void dump_mode()

    68 {

    69     fprintf(stderr, "mode %d\n", stored_mode);

    70     if (stored_mode < -1 || stored_mode >= 256)

    71     {

    72         int blockSize = 0;

    73 		int *storeBlock = (int *)stored_mode;

    74 

    75         while(blockSize < 5 || storeBlock[blockSize] != -1)

    76         {

    77            fprintf(stderr, "   %d\n", storeBlock[blockSize++]);

    78         }

    79     }

    80 }

    81 #endif

    82 

    83 /******************************************************************

    84 

    85  Initialise as RISC OS Wimp task

    86 

    87 *******************************************************************/

    88 

    89 int RISCOS_InitTask()

    90 {

    91    char task_name[32];

    92    _kernel_swi_regs regs;

    93    int messages[4];

    94 

    95    if (RISCOS_GetTaskName(task_name, SDL_arraysize(task_name)) == 0) return 0;

    96 

    97    messages[0] = 9;       /* Palette changed */

    98    messages[1] = 0x400c1; /* Mode changed */

    99    messages[2] = 8;       /* Pre quit */

   100    messages[2] = 0;

   101    

   102 	regs.r[0] = (unsigned int)360; /* Minimum version 3.6 */

   103 	regs.r[1] = (unsigned int)0x4b534154;

   104 	regs.r[2] = (unsigned int)task_name;

   105 	regs.r[3] = (unsigned int)messages;

   106 

   107    if (_kernel_swi(Wimp_Initialise, &regs, &regs) == 0)

   108    {

   109 	   wimp_version = regs.r[0];

   110 	   task_handle = regs.r[1];

   111 	   return 1;

   112    }

   113 

   114 #if !SDL_THREADS_DISABLED

   115    main_thread = pthread_self();

   116 #endif

   117 

   118    return 0;

   119 }

   120 

   121 /*********************************************************************

   122 

   123   Close down application on exit.

   124 

   125 **********************************************************************/

   126 

   127 void RISCOS_ExitTask()

   128 {

   129 	_kernel_swi_regs regs;

   130 

   131     if (stored_mode == -1)

   132     {

   133        /* Ensure cursor is put back to standard pointer shape if

   134           we have been running in a window */

   135        _kernel_osbyte(106,1,0);

   136     }

   137 

   138 	/* Ensure we end up back in the wimp */

   139 	RISCOS_RestoreWimpMode();

   140 

   141 	/* Neatly exit the task */

   142    	regs.r[0] = task_handle;

   143    	regs.r[1] = (unsigned int)0x4b534154;

   144    	_kernel_swi(Wimp_CloseDown, &regs, &regs);

   145 	task_handle = 0;

   146 }

   147 

   148 /**************************************************************************

   149 

   150   Get the name of the task for the desktop.

   151 

   152   Param:   task_name - name of task 32 characters.

   153 

   154   Returns: 1 is successful, otherwise 0

   155 

   156   Notes:   Works by getting using OS_GetEnv to get the command line

   157 		   used to run the program and then parsing a name from it

   158 		   as follows.

   159 

   160 		   1. Use name after final period if not !RunImage

   161 		   2. If name is !RunImage then process item before the period

   162 		      in front of !RunImage.

   163 		   3. If directory name use that

   164 		   4. if in form <XXX$Dir> use the XXX.

   165 

   166 		   Finally once this value has been retrieved use it unless

   167 		   there is a variable set up in the form SDL$<name>$TaskName

   168 		   in which case the value of this variable will be used.

   169 

   170 		   Now also gets other RISC OS configuration varibles

   171                 SDL$<name>$BackBuffer - set to 1 to use a system memory backbuffer in fullscreen mode

   172 						    so updates wait until a call to SDL_UpdateRects. (default 0)

   173 						    This is required for programmes where they have assumed this is

   174 						    always the case which is contrary to the documentation.

   175                SDL$<name>$CloseAction

   176                     0 Don't show close icon

   177                     1 Show close icon

   178 

   179 ***************************************************************************/

   180 

   181 int RISCOS_GetTaskName(char *task_name, size_t maxlen)

   182 {

   183 	_kernel_swi_regs regs;

   184 

   185    task_name[0] = 0;

   186 

   187    /* Figure out a sensible task name */

   188    if (_kernel_swi(OS_GetEnv, &regs, &regs) == 0)

   189    {

   190 	   char *command_line = (char *)regs.r[0];

   191 	   size_t len = SDL_strlen(command_line)+1;

   192 	   char *buffer = SDL_stack_alloc(char, len);

   193 	   char *env_var;

   194 	   char *p;

   195 

   196 	   SDL_strlcpy(buffer, command_line, len);

   197 	   p = SDL_strchr(buffer, ' ');

   198 	   if (p) *p = 0;

   199 	   p = SDL_strrchr(buffer, '.');

   200 	   if (p == 0) p = buffer;

   201 	   if (stricmp(p+1,"!RunImage") == 0)

   202 	   {

   203 		   *p = 0;

   204 	   	   p = SDL_strrchr(buffer, '.');

   205 		   if (p == 0) p = buffer;

   206 	   }

   207 	   if (*p == '.') p++;

   208 	   if (*p == '!') p++; /* Skip "!" at beginning of application directories */

   209 

   210        if (*p == '<')

   211        {

   212           // Probably in the form <appname$Dir>

   213           char *q = SDL_strchr(p, '$');

   214           if (q == 0) q = SDL_strchr(p,'>'); /* Use variable name if not */

   215           if (q) *q = 0;

   216           p++; /* Move over the < */

   217        }

   218 

   219 	   if (*p)

   220 	   {

   221 		   /* Read variables that effect the RISC OS SDL engine for this task */

   222 		   len = SDL_strlen(p) + 18; /* 18 is larger than the biggest variable name */

   223 		   env_var = SDL_stack_alloc(char, len);

   224 		   if (env_var)

   225 		   {

   226 			   char *env_val;

   227 

   228 			   /* See if a variable of form SDL$<dirname>$TaskName exists */

   229 

   230 			   SDL_strlcpy(env_var, "SDL$", len);

   231 			   SDL_strlcat(env_var, p, len);

   232 			   SDL_strlcat(env_var, "$TaskName", len);

   233 

   234 			   env_val = SDL_getenv(env_var);

   235 			   if (env_val) SDL_strlcpy(task_name, env_val, maxlen);

   236 

   237 			   SDL_strlcpy(env_var, "SDL$", len);

   238 			   SDL_strlcat(env_var, p, len);

   239 			   SDL_strlcat(env_var, "$BackBuffer", len);

   240 

   241 			   env_val = SDL_getenv(env_var);

   242 			   if (env_val) riscos_backbuffer = atoi(env_val);

   243 

   244 			   SDL_strlcpy(env_var, "SDL$", len);

   245 			   SDL_strlcat(env_var, p, len);

   246 			   SDL_strlcat(env_var, "$CloseAction", len);

   247 

   248 			   env_val = SDL_getenv(env_var);

   249 			   if (env_val && SDL_strcmp(env_val,"0") == 0) riscos_closeaction = 0;

   250 

   251 			   SDL_stack_free(env_var);

   252 		   }

   253 		   

   254 		   if (!*task_name) SDL_strlcpy(task_name, p, maxlen);

   255 	   }

   256 

   257 	   SDL_stack_free(buffer);

   258    }

   259 

   260    if (task_name[0] == 0) SDL_strlcpy(task_name, "SDL Task", maxlen);

   261 

   262    return 1;

   263 }

   264 

   265 /*****************************************************************

   266 

   267   Store the current desktop screen mode if we are in the desktop.

   268 

   269 ******************************************************************/

   270 

   271 void RISCOS_StoreWimpMode()

   272 {

   273      _kernel_swi_regs regs;

   274 

   275 	/* Don't store if in full screen mode */

   276 	if (stored_mode != -1) return;

   277 

   278     regs.r[0] = 1;

   279     _kernel_swi(OS_ScreenMode, &regs, &regs);

   280     if (regs.r[1] >= 0 && regs.r[1] < 256) stored_mode = regs.r[1];

   281     else

   282     {

   283         int blockSize = 0;

   284         int *retBlock = (int *)regs.r[1];

   285 		int *storeBlock;

   286         int j;

   287 

   288         while(blockSize < 5 || retBlock[blockSize] != -1) blockSize++;

   289         blockSize++;

   290         storeBlock = (int *)SDL_malloc(blockSize * sizeof(int));

   291         retBlock = (int *)regs.r[1];

   292         for ( j = 0; j < blockSize; j++)

   293            storeBlock[j] = retBlock[j];

   294 

   295 		stored_mode = (int)storeBlock;

   296      }

   297 #if DUMP_MODE

   298     fprintf(stderr, "Stored "); dump_mode();

   299 #endif

   300 }

   301 

   302 /*****************************************************************

   303 

   304   Restore desktop screen mode if we are in full screen mode.

   305 

   306 *****************************************************************/

   307 

   308 void RISCOS_RestoreWimpMode()

   309 {

   310     _kernel_swi_regs regs;

   311 

   312 	/* Only need to restore if we are in full screen mode */

   313 	if (stored_mode == -1) return;

   314 

   315 #if DUMP_MODE

   316    fprintf(stderr, "Restored"); dump_mode();

   317 #endif

   318 

   319     regs.r[0] = stored_mode;

   320     _kernel_swi(Wimp_SetMode, &regs, &regs);

   321     if (stored_mode < 0 || stored_mode > 256)

   322     {

   323        SDL_free((int *)stored_mode);

   324     }

   325     stored_mode = -1;

   326 

   327     /* Flush keyboard buffer to dump the keystrokes we've already polled */

   328     regs.r[0] = 21;

   329     regs.r[1] = 0; /* Keyboard buffer number */

   330     _kernel_swi(OS_Byte, &regs, &regs);

   331 

   332     mouseInWindow = 0;

   333 

   334 }

   335 

   336 /*********************************************************************

   337 

   338   Get version of Wimp running when task was initialised.

   339 

   340 *********************************************************************/

   341 

   342 int RISCOS_GetWimpVersion()

   343 {

   344 	return wimp_version;

   345 }

   346 

   347 int RISCOS_GetTaskHandle()

   348 {

   349 	return task_handle;

   350 }