workbench/libs/muimaster/classes/popasl.c

   1 /*
   2     Copyright © 2002-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define MUIMASTER_YES_INLINE_STDARG
   7
   8 #include <string.h>
   9 #include <stdio.h>
  10
  11 #include <graphics/gfx.h>
  12 #include <graphics/view.h>
  13 #include <dos/dostags.h>
  14 #include <libraries/asl.h>
  15 #include <clib/alib_protos.h>
  16 #include <proto/exec.h>
  17 #include <proto/graphics.h>
  18 #include <proto/utility.h>
  19 #include <proto/intuition.h>
  20 #include <proto/asl.h>
  21 #include <proto/dos.h>
  22 #include <proto/muimaster.h>
  23
  24 #include "mui.h"
  25 #include "muimaster_intern.h"
  26 #include "support.h"
  27 #include "support_classes.h"
  28 #include "popasl_private.h"
  29
  30 extern struct Library *MUIMasterBase;
  31
  32 struct Asl_Startup
  33 {
  34     struct Message msg;
  35     APTR asl_req;
  36     struct TagItem *tags;
  37     Object *app;          /* the application */
  38     Object *pop;
  39     STRPTR buf;           /* asl_entry must FreeVec() this before exiting!!! */
  40 };
  41
  42 SAVEDS static LONG Asl_Entry(void)
  43 {
  44     struct Process *proc;
  45     struct Asl_Startup *msg;
  46
  47     APTR asl_req;
  48     struct TagItem *tags;
  49     Object *app;
  50     Object *pop;
  51     STRPTR buf;
  52
  53     proc = (struct Process *)FindTask(NULL);
  54     WaitPort(&proc->pr_MsgPort);        /* Wait for the startup message */
  55     msg = (struct Asl_Startup *)GetMsg(&proc->pr_MsgPort);
  56
  57     asl_req = msg->asl_req;
  58     tags = msg->tags;
  59     app = msg->app;
  60     pop = msg->pop;
  61     buf = msg->buf;
  62
  63     ReplyMsg(&msg->msg);
  64
  65     if (AslRequest(asl_req, tags))
  66         DoMethod(app, MUIM_Application_PushMethod, (IPTR) pop, 2,
  67             MUIM_Popstring_Close, TRUE);
  68     else
  69         DoMethod(app, MUIM_Application_PushMethod, (IPTR) pop, 2,
  70             MUIM_Popstring_Close, FALSE);
  71
  72     if (buf != NULL)
  73         FreeVec(buf);
  74
  75     return 0;
  76 }
  77
  78 static ULONG Popasl_Open_Function(struct Hook *hook, Object *obj,
  79     void **msg)
  80 {
  81     char *buf = NULL;
  82     struct Popasl_DATA *data = (struct Popasl_DATA *)hook->h_Data;
  83     struct Asl_Startup *startup;
  84     Object *string = (Object *) msg[0];
  85     struct MsgPort *msg_port;
  86
  87     if (data->asl_proc)
  88         return 0;
  89
  90     data->tag_list[0].ti_Tag = ASLFR_Screen;
  91     data->tag_list[0].ti_Data = (IPTR) _screen(obj);
  92     data->tag_list[1].ti_Tag = ASLFR_PrivateIDCMP;
  93     data->tag_list[1].ti_Data = 1;
  94     data->tag_list[2].ti_Tag = ASLFR_InitialLeftEdge;
  95     data->tag_list[2].ti_Data = _left(obj);
  96     data->tag_list[3].ti_Tag = ASLFR_InitialTopEdge;
  97     data->tag_list[3].ti_Data = _top(obj);
  98     data->tag_list[4].ti_Tag = ASLFR_InitialWidth;
  99     data->tag_list[4].ti_Data = _width(obj);
 100     data->tag_list[5].ti_Tag = TAG_DONE;
 101     data->tag_list[5].ti_Data = 0;
 102
 103     if (data->start_hook)
 104     {
 105         if (!(CallHookPkt(data->start_hook, obj, data->tag_list)))
 106             return 0;
 107     }
 108     else
 109     {
 110         if (data->type == ASL_FileRequest)
 111         {
 112             char *str = NULL;
 113             char *path_end;
 114
 115             get(string, MUIA_String_Contents, &str);
 116
 117             path_end = PathPart(str);
 118             buf = (char *)AllocVec(path_end - str + 10, MEMF_PUBLIC);
 119             if (!buf)
 120                 return 0;
 121
 122             strncpy(buf, str, path_end - str);
 123             buf[path_end - str] = 0;
 124
 125             data->tag_list[5].ti_Tag = ASLFR_InitialFile;
 126             data->tag_list[5].ti_Data = (IPTR) FilePart(str);
 127             data->tag_list[6].ti_Tag = ASLFR_InitialDrawer;
 128             data->tag_list[6].ti_Data = (IPTR) buf;
 129             data->tag_list[7].ti_Tag = TAG_DONE;
 130             data->tag_list[7].ti_Data = 0;
 131         }
 132
 133         if (data->type == ASL_FontRequest)
 134         {
 135             char *str = NULL;
 136             char *name_end;
 137             LONG size;
 138
 139             get(string, MUIA_String_Contents, &str);
 140
 141             if (str)
 142             {
 143                 name_end = PathPart(str);
 144                 buf = (char *)AllocVec(name_end - str + 10, MEMF_PUBLIC);
 145                 if (!buf)
 146                     return 0;
 147
 148                 strncpy(buf, str, name_end - str);
 149                 strcpy(buf + (name_end - str), ".font");
 150                 StrToLong(FilePart(str), &size);
 151
 152                 data->tag_list[5].ti_Tag = ASLFO_InitialName;
 153                 data->tag_list[5].ti_Data = (IPTR) buf;
 154                 data->tag_list[6].ti_Tag = ASLFO_InitialSize;
 155                 data->tag_list[6].ti_Data = size;
 156                 data->tag_list[7].ti_Tag = TAG_DONE;
 157                 data->tag_list[7].ti_Data = 0;
 158             }
 159         }
 160     }
 161
 162     if (!(msg_port = CreateMsgPort()))
 163         return 0;
 164     if (!(startup =
 165             (struct Asl_Startup *)AllocVec(sizeof(struct Asl_Startup),
 166                 MEMF_PUBLIC)))
 167     {
 168         DeleteMsgPort(msg_port);
 169         return 0;
 170     }
 171
 172     {
 173         const struct TagItem processTags[2] = {
 174             {NP_Entry, (IPTR) Asl_Entry},
 175             {TAG_DONE, 0}
 176         };
 177
 178         if (!(data->asl_proc = CreateNewProc(processTags)))
 179         {
 180             FreeVec(startup);
 181             DeleteMsgPort(msg_port);
 182             return 0;
 183         }
 184     }
 185
 186     startup->msg.mn_ReplyPort = msg_port;
 187     startup->msg.mn_Length = sizeof(struct Asl_Startup);
 188     startup->tags = data->tag_list;
 189     startup->app = _app(obj);
 190     startup->asl_req = data->asl_req;
 191     startup->pop = obj;
 192     startup->buf = buf;
 193     PutMsg(&data->asl_proc->pr_MsgPort, &startup->msg);
 194     WaitPort(msg_port);
 195
 196     FreeVec(startup);
 197     DeleteMsgPort(msg_port);
 198
 199     return 1;
 200 }
 201
 202
 203 static ULONG Popasl_Close_Function(struct Hook *hook, Object *obj,
 204     void **msg)
 205 {
 206     struct Popasl_DATA *data = (struct Popasl_DATA *)hook->h_Data;
 207     Object *string = (Object *) msg[0];
 208     IPTR suc = (IPTR) msg[1];
 209
 210     if (suc)
 211     {
 212         if (data->stop_hook)
 213         {
 214             CallHookPkt(data->stop_hook, obj, data->asl_req);
 215         }
 216         else
 217         {
 218             char *buf = NULL;
 219
 220             if (data->type == ASL_FileRequest)
 221             {
 222                 struct FileRequester *file_req =
 223                     (struct FileRequester *)data->asl_req;
 224                 char *file =
 225                     (char *)file_req->fr_File ? (char *)file_req->
 226                     fr_File : (char *)"";
 227                 char *drawer =
 228                     (char *)file_req->fr_Drawer ? (char *)file_req->
 229                     fr_Drawer : (char *)"";
 230                 int len = strlen(file) + strlen(drawer) + 10;
 231
 232                 buf = (char *)AllocVec(len, MEMF_CLEAR);
 233                 if (buf)
 234                 {
 235                     strcpy(buf, drawer);
 236                     AddPart(buf, file, len);
 237                 }
 238             }
 239             else if (data->type == ASL_FontRequest)
 240             {
 241                 struct FontRequester *font_req =
 242                     (struct FontRequester *)data->asl_req;
 243                 char *name = font_req->fo_Attr.ta_Name;
 244
 245                 if (name)
 246                 {
 247                     LONG size = font_req->fo_Attr.ta_YSize;
 248                     int len = strlen(name) + 20;
 249
 250                     buf = AllocVec(len, MEMF_CLEAR);
 251                     if (buf)
 252                     {
 253                         char num_buf[20];
 254                         char *font_ext;
 255
 256                         strcpy(buf, name);
 257
 258                         /* Remove the .font extension */
 259                         if ((font_ext = strstr(buf, ".font")))
 260                             *font_ext = 0;
 261
 262                         snprintf(num_buf, 20, "%ld", (long)size);
 263                         AddPart(buf, num_buf, len);
 264                     }
 265                 }
 266             }
 267
 268             if (buf)
 269             {
 270                 IPTR contents = 0;
 271
 272                 set(string, MUIA_String_Contents, (IPTR) buf);
 273                 get(string, MUIA_String_Contents, &contents);
 274
 275                 /* trigger string notification */
 276                 set(string, MUIA_String_Acknowledge, contents);
 277
 278                 FreeVec(buf);
 279             }
 280         }
 281     }
 282
 283     data->asl_proc = NULL;
 284     nfset(obj, MUIA_Popasl_Active, FALSE);
 285
 286     return 0;
 287 }
 288
 289 IPTR Popasl__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
 290 {
 291     struct Popasl_DATA *data;
 292     struct TagItem *tags;
 293     struct TagItem *tag;
 294     ULONG asl_type =
 295         GetTagData(MUIA_Popasl_Type, ASL_FileRequest, msg->ops_AttrList);
 296     APTR asl_req;
 297
 298     if (!(asl_req = AllocAslRequest(asl_type, msg->ops_AttrList)))
 299         return 0;
 300
 301     obj = (Object *) DoSuperNewTags(cl, obj, NULL,
 302         MUIA_Popstring_Toggle, FALSE, TAG_MORE, (IPTR) msg->ops_AttrList);
 303     if (!obj)
 304         return FALSE;
 305
 306     data = INST_DATA(cl, obj);
 307
 308     /* parse initial taglist */
 309
 310     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 311     {
 312         switch (tag->ti_Tag)
 313         {
 314         case MUIA_Popasl_StartHook:
 315             data->start_hook = (struct Hook *)tag->ti_Data;
 316             break;
 317
 318         case MUIA_Popasl_StopHook:
 319             data->stop_hook = (struct Hook *)tag->ti_Data;
 320             break;
 321         }
 322     }
 323
 324     data->open_hook.h_Entry = HookEntry;
 325     data->open_hook.h_SubEntry = (HOOKFUNC) Popasl_Open_Function;
 326     data->open_hook.h_Data = data;
 327     data->close_hook.h_Entry = HookEntry;
 328     data->close_hook.h_SubEntry = (HOOKFUNC) Popasl_Close_Function;
 329     data->close_hook.h_Data = data;
 330     data->asl_req = asl_req;
 331     data->type = asl_type;
 332
 333     SetAttrs(obj,
 334         MUIA_Popstring_OpenHook, (IPTR) & data->open_hook,
 335         MUIA_Popstring_CloseHook, (IPTR) & data->close_hook,
 336         MUIA_Popstring_Toggle, FALSE, TAG_DONE);
 337
 338     return (IPTR) obj;
 339 }
 340
 341 IPTR Popasl__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 342 {
 343     struct Popasl_DATA *data = INST_DATA(cl, obj);
 344     if (data->asl_req)
 345         FreeAslRequest(data->asl_req);
 346     return DoSuperMethodA(cl, obj, (Msg) msg);
 347 }
 348
 349 #define STORE *(msg->opg_Storage)
 350 IPTR Popasl__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 351 {
 352     struct Popasl_DATA *data = INST_DATA(cl, obj);
 353
 354     switch (msg->opg_AttrID)
 355     {
 356     case MUIA_Popasl_Active:
 357         STORE = ! !data->asl_proc;
 358         return 1;
 359     }
 360     return DoSuperMethodA(cl, obj, (Msg) msg);
 361 }
 362 #undef STORE
 363
 364 IPTR Popasl__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
 365 {
 366     struct Popasl_DATA *data = INST_DATA(cl, obj);
 367     struct TagItem *tags = msg->ops_AttrList;
 368     struct TagItem *tag;
 369
 370     while ((tag = NextTagItem(&tags)) != NULL)
 371     {
 372         switch (tag->ti_Tag)
 373         {
 374         case MUIA_Popasl_StartHook:
 375             data->start_hook = (struct Hook *)tag->ti_Data;
 376             break;
 377         case MUIA_Popasl_StopHook:
 378             data->stop_hook = (struct Hook *)tag->ti_Data;
 379             break;
 380         }
 381     }
 382
 383     return DoSuperMethodA(cl, obj, (Msg) msg);
 384 }
 385
 386 IPTR Popasl__MUIM_Cleanup(struct IClass *cl, Object *obj,
 387     struct MUIP_Cleanup *msg)
 388 {
 389     struct Popasl_DATA *data = INST_DATA(cl, obj);
 390     if (data->asl_proc)
 391         AbortAslRequest(data->asl_req);
 392     return DoSuperMethodA(cl, obj, (Msg) msg);
 393 }
 394
 395 #if ZUNE_BUILTIN_POPASL
 396 BOOPSI_DISPATCHER(IPTR, Popasl_Dispatcher, cl, obj, msg)
 397 {
 398     switch (msg->MethodID)
 399     {
 400     case OM_NEW:
 401         return Popasl__OM_NEW(cl, obj, (struct opSet *)msg);
 402     case OM_DISPOSE:
 403         return Popasl__OM_DISPOSE(cl, obj, msg);
 404     case OM_GET:
 405         return Popasl__OM_GET(cl, obj, (struct opGet *)msg);
 406     case OM_SET:
 407         return Popasl__OM_SET(cl, obj, (struct opSet *)msg);
 408     case MUIM_Cleanup:
 409         return Popasl__MUIM_Cleanup(cl, obj, (struct MUIP_Cleanup *)msg);
 410     default:
 411         return DoSuperMethodA(cl, obj, msg);
 412     }
 413 }
 414 BOOPSI_DISPATCHER_END
 415
 416 const struct __MUIBuiltinClass _MUI_Popasl_desc =
 417 {
 418     MUIC_Popasl,
 419     MUIC_Popstring,
 420     sizeof(struct Popasl_DATA),
 421     (void *) Popasl_Dispatcher
 422 };
 423 #endif /* ZUNE_BUILTIN_POPASL */