rom/workbench/openworkbenchobjecta.c

   1 /*
   2     Copyright © 1995-2004, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Open a drawer or launch a program.
   6 */
   7 #define DEBUG 1
   8 #include <aros/debug.h>
   9
  10 #include <exec/types.h>
  11 #include <exec/ports.h>
  12 #include <utility/tagitem.h>
  13 #include <intuition/intuition.h>
  14 #include <workbench/workbench.h>
  15 #include <proto/utility.h>
  16 #include <proto/dos.h>
  17
  18 #include <string.h>
  19
  20 #include "workbench_intern.h"
  21 #include "support.h"
  22 #include "support_messages.h"
  23 #include "handler.h"
  24 #include "handler_support.h"
  25
  26 /*** Prototypes *************************************************************/
  27 BOOL   __CLI_LaunchProgram(CONST_STRPTR command, struct TagItem *tags, struct WorkbenchBase *WorkbenchBase);
  28 STRPTR __CLI_BuildCommandLine(CONST_STRPTR command, struct TagItem *tags, struct WorkbenchBase *WorkbenchBase);
  29 BOOL   __WB_LaunchProgram(BPTR lock, CONST_STRPTR name, struct TagItem *tags, struct WorkbenchBase *WorkbenchBase);
  30 BOOL   __WB_BuildArguments(struct WBStartup *startup, BPTR lock, CONST_STRPTR name, struct TagItem *tags, struct WorkbenchBase *WorkbenchBase);
  31
  32 /*** Macros *****************************************************************/
  33 #define CLI_LaunchProgram(name, tags) (__CLI_LaunchProgram((name), (tags), WorkbenchBase))
  34 #define CLI_BuildCommandLine(name, tags) (__CLI_BuildCommandLine((name), (tags), WorkbenchBase))
  35 #define WB_LaunchProgram(lock, name, tags) (__WB_LaunchProgram((lock), (name), (tags), WorkbenchBase))
  36 #define WB_BuildArguments(startup, lock, name, tags) (__WB_BuildArguments((startup), (lock), (name), (tags), WorkbenchBase))
  37
  38 /*****************************************************************************
  39
  40     NAME */
  41
  42         #include <proto/workbench.h>
  43
  44         AROS_LH2(BOOL, OpenWorkbenchObjectA,
  45
  46 /*  SYNOPSIS */
  47         AROS_LHA(STRPTR,           name, A0),
  48         AROS_LHA(struct TagItem *, tags, A1),
  49
  50 /*  LOCATION */
  51         struct WorkbenchBase *, WorkbenchBase, 16, Workbench)
  52
  53 /*  FUNCTION
  54
  55     INPUTS
  56
  57     RESULT
  58
  59     NOTES
  60
  61     EXAMPLE
  62
  63     BUGS
  64
  65     SEE ALSO
  66
  67     INTERNALS
  68
  69 ******************************************************************************/
  70 {
  71     AROS_LIBFUNC_INIT
  72     AROS_LIBBASE_EXT_DECL(struct WorkbenchBase *, WorkbenchBase)
  73
  74     BOOL                  success       = FALSE;
  75     LONG                  isDefaultIcon = 42;
  76
  77     struct DiskObject    *icon          = GetIconTags
  78     (
  79         name,
  80         ICONGETA_FailIfUnavailable,        FALSE,
  81         ICONGETA_IsDefaultIcon,     (IPTR) &isDefaultIcon,
  82         TAG_DONE
  83     );
  84
  85     ASSERT_VALID_PTR(name);
  86     ASSERT_VALID_PTR_OR_NULL(tags);
  87
  88     D(bug("OpenWorkbenchObject: name = %s\n", name));
  89     D(bug("OpenWorkbenchObject: isDefaultIcon = %ld\n", isDefaultIcon));
  90
  91     if (icon != NULL)
  92     {
  93         switch (icon->do_Type)
  94         {
  95             case WBDISK:
  96             case WBDRAWER:
  97             case WBGARBAGE:
  98                 /*
  99                     Since it's a directory or volume, tell the Workbench
 100                     Application to open the corresponding drawer.
 101                 */
 102
 103                 D(bug("OpenWorkbenchObject: it's a DISK, DRAWER or GARGABE\n"));
 104
 105                 {
 106                     struct WBCommandMessage *wbcm     = NULL;
 107                     struct WBHandlerMessage *wbhm     = NULL;
 108                     CONST_STRPTR             namecopy = NULL;
 109
 110                     if
 111                     (
 112                            (wbcm     = CreateWBCM(WBCM_TYPE_RELAY)) != NULL
 113                         && (wbhm     = CreateWBHM(WBHM_TYPE_OPEN))  != NULL
 114                         && (namecopy = StrDup(name))                != NULL
 115
 116                     )
 117                     {
 118                         wbhm->wbhm_Data.Open.Name     = namecopy;
 119                         wbcm->wbcm_Data.Relay.Message = wbhm;
 120
 121                         PutMsg(&(WorkbenchBase->wb_HandlerPort), (struct Message *) wbcm);
 122                     }
 123                     else
 124                     {
 125                         FreeVec((STRPTR)namecopy);
 126                         DestroyWBHM(wbhm);
 127                         DestroyWBCM(wbcm);
 128                     }
 129                 }
 130
 131                 break;
 132
 133             case WBTOOL:
 134                 /*
 135                     It's an executable. Before I launch it, I must check
 136                     whether it is a Workbench program or a CLI program.
 137                 */
 138
 139                 D(bug("OpenWorkbenchObject: it's a TOOL\n"));
 140
 141                 if
 142                 (
 143                        !isDefaultIcon
 144                     && FindToolType(icon->do_ToolTypes, "CLI") == NULL
 145                 )
 146                 {
 147                     /* It's a Workbench program */
 148                     BPTR lock = Lock(name, ACCESS_READ);
 149
 150                     D(bug("OpenWorkbenchObject: it's a WB program\n"));
 151
 152                     if (lock != NULL)
 153                     {
 154                         BPTR parent = ParentDir(lock);
 155
 156                         if (parent != NULL)
 157                         {
 158                             success = WB_LaunchProgram
 159                             (
 160                                 parent, FilePart(name), tags
 161                             );
 162
 163                             if (!success)
 164                             {
 165                                 /*
 166                                     Fallback to launching it as a CLI program.
 167                                     Most likely it will also fail, but we
 168                                     might get lucky.
 169                                 */
 170                                 success = CLI_LaunchProgram(name, tags);
 171                             }
 172
 173                             UnLock(parent);
 174                         }
 175
 176                         UnLock(lock);
 177                     }
 178                 }
 179                 else
 180                 {
 181                     /* It's a CLI program */
 182
 183                     D(bug("OpenWorkbenchObject: it's a CLI program\n"));
 184
 185                     success = CLI_LaunchProgram(name, tags);
 186                 }
 187                 break;
 188
 189             case WBPROJECT:
 190                 /* It's a project; try to launch it via it's default tool. */
 191
 192                 D(bug("OpenWorkbenchObject: it's a PROJECT\n"));
 193                 D(bug("OpenWorkbenchObject: default tool: %s\n", icon->do_DefaultTool));
 194
 195                 if
 196                 (
 197                        icon->do_DefaultTool != NULL
 198                     && strlen(icon->do_DefaultTool) > 0
 199                 )
 200                 {
 201                     BPTR lock = Lock(name, ACCESS_READ);
 202
 203
 204                     if (lock != NULL)
 205                     {
 206                         BPTR parent = ParentDir(lock);
 207
 208                         if (parent != NULL)
 209                         {
 210                             success = OpenWorkbenchObject
 211                             (
 212                                 icon->do_DefaultTool,
 213                                 WBOPENA_ArgLock, (IPTR) parent,
 214                                 WBOPENA_ArgName, (IPTR) FilePart(name),
 215                                 TAG_DONE
 216                             );
 217
 218                             UnLock(parent);
 219                         }
 220
 221                         UnLock(lock);
 222                     }
 223                 }
 224
 225                 if (!success)
 226                 {
 227                     // FIXME: open execute command?
 228                 }
 229                 break;
 230         }
 231
 232         FreeDiskObject(icon);
 233     }
 234     else
 235     {
 236         /*
 237             Getting (a possibly default) icon for the path failed, and
 238             therefore there is no such file. We need to search the default
 239             search path for an executable of that name and launch it. This
 240             only makes sense if the name is *not* an (absolute or relative)
 241             path: that is, it must not contain any ':' or '/'.
 242         */
 243
 244         if (strpbrk(name, "/:") == NULL)
 245         {
 246             struct CommandLineInterface *cli = Cli();
 247             if (cli != NULL)
 248             {
 249                 BPTR *paths;          /* Path list */
 250                 BOOL  running = TRUE;
 251
 252                 /* Iterate over all paths in the path list */
 253                 for
 254                 (
 255                     paths = (BPTR *) BADDR(cli->cli_CommandDir);
 256                     running == TRUE && paths != NULL;
 257                     paths = (BPTR *) BADDR(paths[0]) /* next path */
 258                 )
 259                 {
 260                     BPTR cd   = CurrentDir(paths[1]);
 261                     BPTR lock = Lock(name, SHARED_LOCK);
 262
 263                     if (lock != NULL)
 264                     {
 265                         success = OpenWorkbenchObjectA(name, tags);
 266                         running = FALSE;
 267
 268                         UnLock(lock);
 269                     }
 270
 271                     CurrentDir(cd);
 272                 }
 273             }
 274         }
 275     }
 276
 277     D(bug("OpenWorkbenchObject: success = %d\n", success));
 278
 279     return success;
 280
 281     AROS_LIBFUNC_EXIT
 282 } /* OpenWorkbenchObjectA() */
 283
 284 STRPTR __CLI_BuildCommandLine
 285 (
 286     CONST_STRPTR command, struct TagItem *tags,
 287     struct WorkbenchBase *WorkbenchBase
 288 )
 289 {
 290     struct TagItem *tstate   = tags;
 291     struct TagItem *tag      = NULL;
 292     BPTR            lastLock = NULL;
 293     STRPTR          buffer   = NULL;
 294     ULONG           length   = strlen(command) + 3 /* NULL + 2 '"' */;
 295
 296     /*-- Calculate length of resulting string ------------------------------*/
 297     while ((tag = NextTagItem(&tstate)) != NULL)
 298     {
 299         switch (tag->ti_Tag)
 300         {
 301             case WBOPENA_ArgLock:
 302                 lastLock = (BPTR) tag->ti_Data;
 303                 break;
 304
 305             case WBOPENA_ArgName:
 306                 if (lastLock != NULL)
 307                 {
 308                     BPTR cd   = CurrentDir(lastLock);
 309                     BPTR lock = Lock((STRPTR) tag->ti_Data, ACCESS_READ);
 310                     if (lock != NULL)
 311                     {
 312                         STRPTR path = AllocateNameFromLock(lock);
 313                         if (path != NULL)
 314                         {
 315                             length += 3 /* space + 2 '"' */ + strlen(path);
 316                             FreeVec(path);
 317                         }
 318
 319                         UnLock(lock);
 320                     }
 321
 322                     CurrentDir(cd);
 323                 }
 324                 break;
 325         }
 326     }
 327
 328     /*-- Allocate space for command line string ----------------------------*/
 329     buffer = AllocVec(length, MEMF_ANY);
 330
 331     if (buffer != NULL)
 332     {
 333         buffer[0] = '\0';
 334
 335         /*-- Build command line --------------------------------------------*/
 336         strcat(buffer, "\"");
 337         strcat(buffer, command);
 338         strcat(buffer, "\"");
 339
 340         tstate = tags; lastLock = NULL;
 341         while ((tag = NextTagItem(&tstate)) != NULL )
 342         {
 343             switch (tag->ti_Tag)
 344             {
 345                 case WBOPENA_ArgLock:
 346                     lastLock = (BPTR) tag->ti_Data;
 347                     break;
 348
 349                 case WBOPENA_ArgName:
 350                     if (lastLock != NULL)
 351                     {
 352                         BPTR cd   = CurrentDir(lastLock);
 353                         BPTR lock = Lock((STRPTR) tag->ti_Data, ACCESS_READ);
 354                         if (lock != NULL)
 355                         {
 356                             STRPTR path = AllocateNameFromLock(lock);
 357                             if (path != NULL)
 358                             {
 359                                 strcat(buffer, " \"");
 360                                 strcat(buffer, path);
 361                                 strcat(buffer, "\"");
 362                                 FreeVec(path);
 363                             }
 364
 365                             UnLock(lock);
 366                         }
 367
 368                         CurrentDir(cd);
 369                     }
 370                     break;
 371             }
 372         }
 373     }
 374     else
 375     {
 376         SetIoErr(ERROR_NO_FREE_STORE);
 377     }
 378
 379     return buffer;
 380 }
 381
 382 BOOL __CLI_LaunchProgram
 383 (
 384     CONST_STRPTR command, struct TagItem *tags,
 385     struct WorkbenchBase *WorkbenchBase
 386 )
 387 {
 388     BPTR   input       = NULL;
 389     STRPTR commandline = NULL;
 390
 391     input = Open("CON:////Output Window/CLOSE/AUTO/WAIT", MODE_OLDFILE);
 392     if (input == NULL) goto error;
 393
 394     commandline = CLI_BuildCommandLine(command, tags);
 395     if (commandline == NULL) goto error;
 396
 397     if
 398     (
 399         /*
 400             Launch the program. Note that there is no advantage of doing this
 401             in the handler, since we need to wait for the return value anyway
 402             (and thus we cannot cut down the blocking time by returning before
 403             the program is loaded from disk).
 404         */
 405
 406         SystemTags
 407         (
 408             commandline,
 409             SYS_Asynch,          TRUE,
 410             SYS_Input,    (IPTR) input,
 411             SYS_Output,   (IPTR) NULL,
 412             SYS_Error,    (IPTR) NULL,
 413             NP_StackSize,        WorkbenchBase->wb_DefaultStackSize,
 414             TAG_DONE
 415         ) == -1
 416     )
 417     {
 418         goto error;
 419     }
 420     FreeVec(commandline);
 421
 422     return TRUE;
 423
 424 error:
 425     if (input != NULL) Close(input);
 426     if (commandline != NULL) FreeVec(commandline);
 427
 428     return FALSE;
 429 }
 430
 431 BOOL __WB_BuildArguments
 432 (
 433     struct WBStartup *startup, BPTR lock, CONST_STRPTR name, struct TagItem *tags,
 434     struct WorkbenchBase *WorkbenchBase
 435 )
 436 {
 437     struct TagItem *tstate   = tags,
 438                    *tag      = NULL;
 439     BPTR            lastLock = NULL;
 440     struct WBArg   *args     = NULL;
 441
 442     /*-- Calculate the number of arguments ---------------------------------*/
 443     startup->sm_NumArgs = 1;
 444     while ((tag = NextTagItem(&tstate)) != NULL)
 445     {
 446         switch (tag->ti_Tag)
 447         {
 448             case WBOPENA_ArgLock:
 449                 lastLock = (BPTR) tag->ti_Data;
 450                 break;
 451
 452             case WBOPENA_ArgName:
 453                 /*
 454                     Filter out args where both lock AND name are NULL, since
 455                     they are completely worthless to the application.
 456                 */
 457                 if (lastLock != NULL || (STRPTR) tag->ti_Data != NULL)
 458                 {
 459                     startup->sm_NumArgs++;
 460                 }
 461                 break;
 462         }
 463     }
 464
 465     /*-- Allocate memory for the arguments ---------------------------------*/
 466     args = AllocMem(sizeof(struct WBArg) * startup->sm_NumArgs, MEMF_ANY | MEMF_CLEAR);
 467     if (args != NULL)
 468     {
 469         LONG i = 0;
 470
 471         startup->sm_ArgList = args;
 472
 473         /*-- Build the argument list ---------------------------------------*/
 474         if
 475         (
 476                (args[i].wa_Lock = DupLock(lock)) == NULL
 477             || (args[i].wa_Name = StrDup(name))  == NULL
 478         )
 479         {
 480             goto error;
 481         }
 482         i++;
 483
 484         tstate = tags; lastLock = NULL;
 485         while ((tag = NextTagItem(&tstate)) != NULL)
 486         {
 487             switch (tag->ti_Tag)
 488             {
 489                 case WBOPENA_ArgLock:
 490                     lastLock = (BPTR) tag->ti_Data;
 491                     break;
 492
 493                 case WBOPENA_ArgName:
 494                     /*
 495                         Filter out args where both lock AND name are NULL,
 496                         since they are completely worthless to the application.
 497                     */
 498                     if (lastLock != NULL || (STRPTR) tag->ti_Data != NULL)
 499                     {
 500                         STRPTR name = (STRPTR) tag->ti_Data;
 501
 502                         /* Duplicate the lock */
 503                         if (lastLock != NULL)
 504                         {
 505                             args[i].wa_Lock = DupLock(lastLock);
 506
 507                             if (args[i].wa_Lock == NULL)
 508                             {
 509                                 D(bug("workbench.library: WB_BuildArguments: Failed to duplicate lock!\n"));
 510                                 goto error;
 511                                 break;
 512                             }
 513                         }
 514                         else
 515                         {
 516                             args[i].wa_Lock = NULL;
 517                         }
 518
 519                         /* Duplicate the name */
 520                         if (name != NULL)
 521                         {
 522                             args[i].wa_Name = StrDup(name);
 523
 524                             if (args[i].wa_Name == NULL)
 525                             {
 526                                 D(bug("workbench.library: WB_BuildArguments: Failed to duplicate string!\n"));
 527                                 goto error;
 528                                 break;
 529                             }
 530                         }
 531                         else
 532                         {
 533                             args[i].wa_Name = NULL;
 534                         }
 535
 536                         i++;
 537                     }
 538                     break;
 539             }
 540         }
 541
 542         return TRUE;
 543     }
 544     else
 545     {
 546         D(bug("workbench.library: WB_BuildArguments: Failed to allocate memory for argument array\n"));
 547     }
 548
 549 error:
 550     D(bug("workbench.library: WB_BuildArguments: Freeing resources after error...\n"));
 551     /* Free allocated resources */
 552     if (args != NULL)
 553     {
 554         int i;
 555
 556         for (i = 0; i < startup->sm_NumArgs; i++)
 557         {
 558             if (args[i].wa_Lock != NULL) UnLock(args[i].wa_Lock);
 559             if (args[i].wa_Name != NULL) FreeVec(args[i].wa_Name);
 560         }
 561
 562         FreeMem(args, sizeof(struct WBArg) * startup->sm_NumArgs);
 563     }
 564
 565     startup->sm_NumArgs = 0;
 566     startup->sm_ArgList = NULL;
 567
 568     return FALSE;
 569 }
 570
 571 BOOL __WB_LaunchProgram
 572 (
 573     BPTR lock, CONST_STRPTR name, struct TagItem *tags,
 574     struct WorkbenchBase *WorkbenchBase
 575 )
 576 {
 577     struct WBStartup        *startup = NULL;
 578     struct WBCommandMessage *message = NULL;
 579
 580     /*-- Allocate memory for messages --------------------------------------*/
 581     startup = CreateWBS();
 582     if (startup == NULL)
 583     {
 584         D(bug("workbench.library: WB_LaunchProgram: Failed to allocate memory for startup message\n"));
 585         SetIoErr(ERROR_NO_FREE_STORE);
 586         goto error;
 587     }
 588
 589     message = CreateWBCM(WBCM_TYPE_LAUNCH);
 590     if (message == NULL)
 591     {
 592         D(bug("workbench.library: WB_LaunchProgram: Failed to allocate memory for launch message\n"));
 593         SetIoErr(ERROR_NO_FREE_STORE);
 594         goto error;
 595     }
 596
 597     /*-- Build the arguments array -----------------------------------------*/
 598     if (!WB_BuildArguments(startup, lock, name, tags))
 599     {
 600         D(bug("workbench.library: WB_LaunchProgram: Failed to build arguments\n"));
 601         goto error;
 602     }
 603
 604     /*-- Send message to handler -------------------------------------------*/
 605     /* NOTE: The handler will deallocate all resources of this message! */
 606     message->wbcm_Data.Launch.Startup = startup;
 607
 608     PutMsg(&(WorkbenchBase->wb_HandlerPort), (struct Message *) message);
 609
 610     D(bug("workbench.library: WB_LaunchProgram: Success\n"));
 611
 612     return TRUE;
 613
 614 error:
 615     if (startup != NULL) DestroyWBS(startup);
 616     if (message != NULL) DestroyWBCM(message);
 617
 618     D(bug("workbench.library: WB_LaunchProgram: Failure\n"));
 619
 620     return FALSE;
 621 }