BOOL WriteIcon(char *name) {
struct DiskObject *dobj;
char *olddeftool;
char **oldtooltypes;
BOOL success = FALSE;
/* Use the already present icon */
dobj=GetDiskObject(name);
if( dobj != NULL ) {
oldtooltypes = dobj->do_ToolTypes;
olddeftool = dobj->do_DefaultTool;
dobj->do_ToolTypes = toolTypes;
dobj->do_DefaultTool = deftoolname;
success = PutDiskObject(name,dobj);
/* we must restore the original pointers before freeing */
dobj->do_ToolTypes = oldtooltypes;
dobj->do_DefaultTool = olddeftool;
FreeDiskObject(dobj);
}
/* Try the user's default prefs icon */
if((! success) && (dobj=GetDiskObject("ENV:Sys/def_Pref"))) {
oldtooltypes = dobj->do_ToolTypes;
olddeftool = dobj->do_DefaultTool;
dobj->do_ToolTypes = toolTypes;
dobj->do_DefaultTool = deftoolname;
success = PutDiskObject(name,dobj);
/* we must restore the original pointers before freeing */
dobj->do_ToolTypes = oldtooltypes;
dobj->do_DefaultTool = olddeftool;
FreeDiskObject(dobj);
}
/* Else, put our default icon */
if(! success) {
success = PutDiskObject(name,&projIcon);
}
return success;
}
STRPTR GetDefInterfaceName(int argc, char **argv)
{
struct DiskObject *dobj;
struct WBStartup *wbs;
struct WBArg *wbarg;
STRPTR icname;
STRPTR iname;
if (argc == 0)
{
wbs = (struct WBStartup *)argv;
wbarg = wbs->sm_ArgList;
icname = wbarg[0].wa_Name;
CurrentDir(wbarg[0].wa_Lock);
}
else
icname = argv[0];
if( !(dobj = GetDiskObject(icname)) )
{
CurrentDir(NULL);
return(NULL);
}
iname = FindToolType(dobj->do_ToolTypes, "INTERFACE");
FreeDiskObject(dobj);
CurrentDir(NULL);
return(iname);
}
void amiga_icon_free(struct DiskObject *dobj)
{
struct bitmap *bm = dobj->do_Gadget.UserData;
FreeDiskObject(dobj);
if(bm) FreeVec(bm->icondata);
}
__autoexit void amiga_exit (void)
{
int i;
for (i = 0; i < HISTORY_LINES; i++)
{
if (*(History + i))
FreeVec (*(History + i));
*(History + i) = 0;
}
if (GameReq)
FreeAslRequest (GameReq);
if (SaveReq)
FreeAslRequest (SaveReq);
if (ScriptReq)
FreeAslRequest (ScriptReq);
if (Menus)
FreeMenus (Menus);
if (Visual)
FreeVisualInfo (Visual);
if (ThisProcess)
ThisProcess->pr_WindowPtr = OldWindowPtr;
if (Window)
CloseWindow (Window);
if (Screen)
CloseScreen (Screen);
if (Font)
CloseFont (Font);
if (DefaultPubScreen)
UnlockPubScreen (0, DefaultPubScreen);
if (Icon)
FreeDiskObject (Icon);
}
VOID
CreateIcon( STRPTR fname )
{
struct DiskObject *dob;
struct Gadget *gad;
if( ( dob = GetDiskObjectNew( NULL ) ) )
{
gad = &dob->do_Gadget;
gad->Width = 54;
gad->Height = 22;
gad->Flags = GFLG_GADGIMAGE | GFLG_GADGBACKFILL;
gad->GadgetType = GTYP_BOOLGADGET;
gad->GadgetRender = ( APTR ) &IconImage;
gad->UserData = ( APTR ) WB_DISKREVISION;
dob->do_Magic = WB_DISKMAGIC;
dob->do_Version = WB_DISKVERSION;
dob->do_Type = WBPROJECT;
dob->do_DefaultTool = "ReqTools";
dob->do_ToolTypes = ToolTypes;
dob->do_CurrentX = dob->do_CurrentY = NO_ICON_POSITION;
PutDiskObject( fname, dob );
FreeDiskObject( dob );
}
}
void load_do(const char *filename, struct IconPixmaps *ip)
{
struct DiskObject *dobj;
#ifdef AMIGAOS
char fn[256];
strncpy(fn, prefs.icondir, sizeof(fn)-1);
fn[sizeof(fn)-1]='\0';
AddPart(fn,filename,sizeof(fn));
#else
int rl=strlen(filename)+strlen(prefs.icondir)+2;
#ifdef HAVE_ALLOCA
char *fn=alloca(rl);
#else
char fn[1024];
#endif
sprintf(fn, "%s/%s", prefs.icondir, filename);
#endif
fn[strlen(fn)-5]=0;
if((dobj=GetDiskObject(fn))) {
ip->pm=image_to_pixmap_scr(scr, (struct Image *)dobj->do_Gadget.GadgetRender,
dobj->do_Gadget.Width, dobj->do_Gadget.Height, &ip->cs);
ip->pm2=image_to_pixmap_scr(scr, (struct Image *)dobj->do_Gadget.SelectRender,
dobj->do_Gadget.Width, dobj->do_Gadget.Height, &ip->cs2);
FreeDiskObject(dobj);
} else ip->pm=ip->pm2=None;
}
nserror
gui_window_save_link(struct gui_window *g, nsurl *url, const char *title)
{
char fname[1024];
STRPTR openurlstring,linkname;
struct DiskObject *dobj = NULL;
linkname = ASPrintf("Link_to_%s",FilePart(nsurl_access(url)));
if(AslRequestTags(savereq,
ASLFR_Window, g->shared->win,
ASLFR_SleepWindow, TRUE,
ASLFR_TitleText,messages_get("NetSurf"),
ASLFR_Screen,scrn,
ASLFR_InitialFile,linkname,
TAG_DONE))
{
strlcpy(fname, savereq->fr_Drawer, 1024);
AddPart(fname,savereq->fr_File,1024);
ami_set_pointer(g->shared, GUI_POINTER_WAIT, false);
if(ami_download_check_overwrite(fname, g->shared->win, 0))
{
BPTR fh;
if((fh = FOpen(fname,MODE_NEWFILE,0)))
{
/* \todo Should be URLOpen on OS4.1 */
openurlstring = ASPrintf("openurl \"%s\"\n",nsurl_access(url));
FWrite(fh,openurlstring,1,strlen(openurlstring));
FClose(fh);
FreeVec(openurlstring);
SetComment(fname, nsurl_access(url));
dobj = GetIconTags(NULL,ICONGETA_GetDefaultName,"url",
ICONGETA_GetDefaultType,WBPROJECT,
TAG_DONE);
dobj->do_DefaultTool = "IconX";
PutIconTags(fname,dobj,
ICONPUTA_NotifyWorkbench,TRUE,
TAG_DONE);
FreeDiskObject(dobj);
}
FreeVec(linkname);
}
ami_reset_pointer(g->shared);
}
return NSERROR_OK;
}
VOID
FreeExit( LONG rc )
{
if( Menus )
{
if( WindowPtr )
{
ClearMenuStrip( WindowPtr );
}
FreeMenus( Menus );
}
CloseGUI();
if( Screen )
{
FreeScreenDrawInfo( Screen, DrawInfo );
UnlockPubScreen (NULL, Screen );
}
if( GadToolsBase )
{
FreeVisualInfo( VisualInfo );
}
if( FileReq )
{
rtFreeRequest( FileReq );
}
if( DiskObject )
{
FreeDiskObject( DiskObject );
}
FreeArgs( RDArgs );
FreeLocale();
CloseLib( GadToolsBase );
CloseLib( IconBase );
CloseLib( IntuitionBase );
CloseLib( ReqToolsBase );
CloseLib( UtilityBase );
CloseLibrary( ( struct Library * ) GfxBase );
__exit( rc );
}
static IPTR mDispose(struct IClass *cl, Object *obj, Msg msg)
{
struct data *data = INST_DATA(cl,obj);
struct DiskObject *icon = data->icon;
IPTR res;
/*
** Because of users hate an app that saves on disc
** at any exit, we check if you must save something
*/
if (DoMethod(data->win,MUIM_App_CheckSave))
{
DoSuperMethod(cl,obj,MUIM_Application_Save,(IPTR)MUIV_Application_Save_ENV);
DoSuperMethod(cl,obj,MUIM_Application_Save,(IPTR)MUIV_Application_Save_ENVARC);
}
res = DoSuperMethodA(cl,obj,msg);
if (icon) FreeDiskObject(icon);
return res;
}
int main(int argc, char **argv)
{
STRPTR newToolTypes[] =
{
"AROS=RULES",
"Tooltypes are actually free-form text",
"Ain't that neat?",
NULL
};
struct DiskObject *icon = GetIconTags
(
"writetooltypes", ICONGETA_FailIfUnavailable, FALSE, TAG_DONE
);
if (icon != NULL)
{
STRPTR *oldToolTypes = icon->do_ToolTypes;
icon->do_ToolTypes = newToolTypes;
if (!PutIconTags("writetooltypes", icon, TAG_DONE))
{
printf("ERROR: Failed to write icon.\n");
}
icon->do_ToolTypes = oldToolTypes;
FreeDiskObject(icon);
}
else
{
printf("ERROR: Failed to open icon for file\n");
return 20;
}
return 0;
}
BOOL NATDECLFUNC_2(GUI_Close, a0, struct ClientGUIParams *, params, a6, struct DnetcLibrary *, LibBase)
{
DECLARG_2(a0, struct ClientGUIParams *, params, a6, struct DnetcLibrary *, LibBase)
(void)params;
ObtainSemaphore(&LibBase->SemaphoreGUI);
if (FindTask(NULL) == LibBase->OwnerTask)
{
MUI_DisposeObject(LibBase->App);
if (LibBase->dobj)
FreeDiskObject(LibBase->dobj);
LibBase->OwnerTask = NULL;
LibBase->App = NULL;
LibBase->dobj = NULL;
}
ReleaseSemaphore(&LibBase->SemaphoreGUI);
return TRUE;
}
static struct DiskObject *int_load_do(char *filename)
{
FILE *f;
struct DiskObject *diskobj;
char buf[78], *p=buf;
int error=0;
if((f=fopen(filename, "r"))) {
if(1==fread(buf, 78, 1, f) &&
(diskobj=calloc(1, sizeof(struct DiskObject)))) {
diskobj->do_Magic=getu16(&p); diskobj->do_Version=getu16(&p);
if(diskobj->do_Magic!=WB_DISKMAGIC) {
free(diskobj);
return NULL;
}
diskobj->do_Gadget.NextGadget=(struct Gadget *)getu32(&p);
diskobj->do_Gadget.LeftEdge=get16(&p);
diskobj->do_Gadget.TopEdge=get16(&p);
diskobj->do_Gadget.Width=get16(&p); diskobj->do_Gadget.Height=get16(&p);
diskobj->do_Gadget.Flags=getu16(&p);
diskobj->do_Gadget.Activation=getu16(&p);
diskobj->do_Gadget.GadgetType=getu16(&p);
diskobj->do_Gadget.GadgetRender=(APTR)getu32(&p);
diskobj->do_Gadget.SelectRender=(APTR)getu32(&p);
diskobj->do_Gadget.GadgetText=(struct IntuiText *)getu32(&p);
diskobj->do_Gadget.MutualExclude=get32(&p);
diskobj->do_Gadget.SpecialInfo=(APTR)getu32(&p);
diskobj->do_Gadget.GadgetID=getu16(&p);
diskobj->do_Gadget.UserData=(APTR)getu32(&p);
diskobj->do_Type=*p; p+=2;
diskobj->do_DefaultTool=(char *)getu32(&p);
diskobj->do_ToolTypes=(char **)getu32(&p);
diskobj->do_CurrentX=get32(&p);
diskobj->do_CurrentY=get32(&p);
diskobj->do_DrawerData=(struct DrawerData *)getu32(&p);
diskobj->do_ToolWindow=(char *)getu32(&p);
diskobj->do_StackSize=get32(&p);
if(diskobj->do_DrawerData) {
struct DrawerData *dd;
if(1==fread(buf, 56, 1, f) &&
(diskobj->do_DrawerData=dd=calloc(1, sizeof(struct DrawerData)))) {
p=buf;
dd->dd_NewWindow.LeftEdge=get16(&p);
dd->dd_NewWindow.TopEdge=get16(&p);
dd->dd_NewWindow.Width=get16(&p);
dd->dd_NewWindow.Height=get16(&p);
dd->dd_NewWindow.DetailPen=*p++;
dd->dd_NewWindow.BlockPen=*p++;
dd->dd_NewWindow.IDCMPFlags=getu32(&p);
dd->dd_NewWindow.Flags=getu32(&p);
dd->dd_NewWindow.FirstGadget=(struct Gadget *)getu32(&p);
dd->dd_NewWindow.CheckMark=(struct Image *)getu32(&p);
dd->dd_NewWindow.Title=(UBYTE *)getu32(&p);
dd->dd_NewWindow.Screen=(struct Screen *)getu32(&p);
dd->dd_NewWindow.BitMap=(struct BitMap *)getu32(&p);
dd->dd_NewWindow.MinWidth=get16(&p);
dd->dd_NewWindow.MinHeight=get16(&p);
dd->dd_NewWindow.MaxWidth=getu16(&p);
dd->dd_NewWindow.MaxHeight=getu16(&p);
dd->dd_NewWindow.Type=getu16(&p);
dd->dd_CurrentX=get32(&p);
dd->dd_CurrentY=get32(&p);
} else error++;
}
if(!(diskobj->do_Gadget.GadgetRender=loadimage(f)))
error++;
if(diskobj->do_Gadget.Flags&2)
if(!(diskobj->do_Gadget.SelectRender=loadimage(f)))
error++;
else ;
else if(diskobj->do_Gadget.Flags&1)
if(!(diskobj->do_Gadget.SelectRender=
backfillimage((struct Image *)diskobj->do_Gadget.GadgetRender)))
error++;
else ;
else diskobj->do_Gadget.SelectRender=NULL;
if(diskobj->do_DefaultTool)
if(!(diskobj->do_DefaultTool=loadstring(f)))
error++;
if(diskobj->do_ToolTypes)
if(!(diskobj->do_ToolTypes=loadtooltypes(f)))
error++;
if(diskobj->do_ToolWindow)
if(!(diskobj->do_ToolWindow=loadstring(f)))
error++;
if(diskobj->do_DrawerData && diskobj->do_Version) {
char buf[6], *p=buf;
if(1==fread(buf, 6, 1, f)) {
diskobj->do_DrawerData->dd_Flags=getu32(&p);
diskobj->do_DrawerData->dd_ViewModes=getu16(&p);
}
}
if(diskobj->do_Version) {
/* Check for GlowIcon */
char buf[8], *p = buf, *glowicon;
LONG len;
if(1==fread(buf, 4, 1, f) && !strncmp(buf, "FORM", 4) &&
1==fread(buf, 8, 1, f) && !strncmp(buf+4, "ICON", 4) &&
(len = get32(&p))>4 && (glowicon = malloc(len))!=NULL) {
if(1==fread(glowicon, len-4, 1, f))
decode_glowicon(diskobj, glowicon, len-4);
free(glowicon);
}
}
if(!error) {
fclose(f);
return diskobj;
}
FreeDiskObject(diskobj);
}
fclose(f);
}
return NULL;
}
int main(int argc, char **argv)
{
LONG rc = RETURN_FAIL;
STRPTR filename,
commandLine = NULL,
ixWindow = DEFWINDOW;
LONG ixWait = 0,
ixStack = DEFSTACK;
BOOL ixUShell = DEFUSHELL;
BPTR oldlock = (BPTR)-1,
dirlock = (BPTR)-1,
window = NULL;
struct DiskObject *dobj = NULL;
D(bug("IconX argc %d\n", argc));
if (argc != 0)
{
displayMsg(ERROR_REQUIRED_ARG_MISSING);
goto exit;
}
struct WBStartup *startup = (struct WBStartup *) argv;
if (startup->sm_NumArgs < 2)
{
displayMsg(ERROR_REQUIRED_ARG_MISSING);
goto exit;
}
D(bug("[IconX] startup->sm_NumArgs: %d\n", startup->sm_NumArgs));
dirlock = startup->sm_ArgList[1].wa_Lock;
filename = startup->sm_ArgList[1].wa_Name;
oldlock = CurrentDir(dirlock);
/* query diskobject for tooltypes */
dobj = GetDiskObject(filename);
if (dobj == NULL)
{
struct EasyStruct es = {sizeof(struct EasyStruct), 0,
"Error", "IconX\nGetDiskObject failed for:\n%s", "OK"};
EasyRequest(0, &es, 0, filename);
goto exit;
}
if (dobj->do_Type == WBPROJECT)
{
const STRPTR *toolarray = (const STRPTR *)dobj->do_ToolTypes;
STRPTR s;
if ((s = FindToolType(toolarray, "WINDOW")))
{
ixWindow = s;
}
if ((s = FindToolType(toolarray, "STACK")))
{
ixStack = atol(s);
}
if ((s = FindToolType(toolarray, "USERSHELL")))
{
if (MatchToolValue(s, "NO"))
{
ixUShell = FALSE;
}
}
if ((s = FindToolType(toolarray, "WAIT")))
{
ixWait += atol(s) * 50;
}
if ((s = FindToolType(toolarray, "DELAY")))
{
ixWait += atol(s);
}
}
else
{
displayMsg(ERROR_OBJECT_WRONG_TYPE);
goto exit;
}
if (ixWait <= 0)
ixWait = DEFWAIT;
if (ixStack <= 4096)
ixStack = DEFSTACK;
D(bug("wait %d stack %d usershell %d window %s\n", ixWait, ixStack, ixUShell, ixWindow));
D(bug("Building command line\n"));
commandLine = BuildCommandLine(startup);
if (commandLine == NULL)
{
displayMsg(IoErr());
goto exit;
}
D(bug("[IconX] commandLine: '%s'\n", commandLine));
window = Open(ixWindow, MODE_OLDFILE);
if (window == NULL)
{
/* try to open default window */
window = Open(DEFWINDOW, MODE_OLDFILE);
}
if (window)
{
D(bug("[IconX] window ok\n"));
struct TagItem tags[] =
{
{ SYS_Asynch, FALSE },
{ SYS_Background, TRUE },
{ SYS_Input, (IPTR)window },
{ SYS_Output, (IPTR)NULL },
{ SYS_Error, (IPTR)NULL },
{ SYS_UserShell, ixUShell },
{ NP_StackSize, ixStack },
{ TAG_DONE, 0 }
};
rc = SystemTagList(commandLine, tags);
if (rc == -1)
{
displayMsg(IoErr());
rc = RETURN_FAIL;
}
}
else
{
displayMsg(IoErr());
goto exit;
}
Delay(ixWait);
rc = RETURN_OK;
exit:
Close(window);
FreeDiskObject(dobj);
if (oldlock != (BPTR)-1)
CurrentDir(oldlock);
return rc;
}
VOID ArgArrayDone(VOID)
{
if(CXLIB_argarray) FreeVec(CXLIB_argarray);
if (disko) FreeDiskObject(disko);
}
void file_open_with(struct Window *window,char *name,ULONG flags)
{
char *buffer;
short len,wb=0,ok=0;
struct DiskObject *icon;
// Allocate buffer
if (!(buffer=AllocVec(1400,MEMF_CLEAR)))
return;
// App already selected?
if (flags&(1<<30))
{
short num;
struct Node *node;
// Get application number in list
num=flags&~(1<<30);
// Lock the list
lock_listlock(&GUI->open_with_list,0);
// Find the node
for (node=GUI->open_with_list.list.lh_Head;
node->ln_Succ;
node=node->ln_Succ)
{
// Matched?
if (num--==0) break;
}
// Valid node?
if (node->ln_Succ)
{
// Get the application name
strcpy(buffer+1,node->ln_Name);
ok=1;
}
// Unlock the list
unlock_listlock(&GUI->open_with_list);
}
// Need to ask?
if (!ok)
{
// Build title
lsprintf(buffer+1024,GetString(&locale,MSG_SELECT_APP),FilePart(name));
// Ask for file
if (!(request_file(
window,
buffer+1024,
buffer+1,
0,
0,0)) || !*(buffer+1))
{
FreeVec(buffer);
return;
}
// Add App to OpenWith list
add_open_with(buffer+1);
}
// See if app has an icon
if (icon=GetDiskObject(buffer+1))
{
// Is it a tool?
if (icon->do_Type==WBTOOL)
{
// Launch as Workbench App
wb=1;
}
// Free icon
FreeDiskObject(icon);
}
// Fill in quotes
buffer[0]='\"';
buffer[(len=strlen(buffer))]='\"';
// Add filename in quotes
buffer[len+1]=' ';
buffer[len+2]='\"';
strcpy(buffer+len+3,name);
buffer[(len=strlen(buffer))]='\"';
buffer[len+1]=0;
// Launch the function
file_launch(buffer,wb,"ram:");
// Free buffer
FreeVec(buffer);
}
const char *fetch_filetype(const char *unix_path)
{
static char mimetype[50];
STRPTR ttype = NULL;
struct DiskObject *dobj = NULL;
BPTR lock = 0;
struct DataTypeHeader *dth = NULL;
struct DataType *dtn;
BOOL found = FALSE;
/* First try getting a tooltype "MIMETYPE" and use that as the MIME type. Will fail over
to default icons if the file doesn't have a real icon. */
if(dobj = GetIconTags(unix_path,ICONGETA_FailIfUnavailable,FALSE,
TAG_DONE))
{
ttype = FindToolType(dobj->do_ToolTypes, "MIMETYPE");
if(ttype)
{
strcpy(mimetype,ttype);
found = TRUE;
}
FreeDiskObject(dobj);
}
/* If that didn't work, have a go at guessing it using datatypes.library. This isn't
accurate - the base names differ from those used by MIME and it relies on the
user having a datatype installed which can handle the file. */
if(!found)
{
if (lock = Lock (unix_path, ACCESS_READ))
{
if (dtn = ObtainDataTypeA (DTST_FILE, (APTR)lock, NULL))
{
dth = dtn->dtn_Header;
switch(dth->dth_GroupID)
{
case GID_SYSTEM:
sprintf(mimetype,"application/%s",dth->dth_BaseName);
break;
case GID_TEXT:
case GID_DOCUMENT:
if(strcmp("ascii",dth->dth_BaseName)==0)
{
sprintf(mimetype,"text/plain",dth->dth_BaseName);
}
else if(strcmp("simplehtml",dth->dth_BaseName)==0)
{
sprintf(mimetype,"text/html",dth->dth_BaseName);
}
else
{
sprintf(mimetype,"text/%s",dth->dth_BaseName);
}
break;
case GID_SOUND:
case GID_INSTRUMENT:
case GID_MUSIC:
sprintf(mimetype,"audio/%s",dth->dth_BaseName);
break;
case GID_PICTURE:
sprintf(mimetype,"image/%s",dth->dth_BaseName);
break;
case GID_ANIMATION:
case GID_MOVIE:
sprintf(mimetype,"video/%s",dth->dth_BaseName);
break;
}
found = TRUE;
ReleaseDataType(dtn);
}
UnLock(lock);
}
}
if(!found) strcpy(mimetype,"text/html"); /* If all else fails */
//printf("%s: %s\n",unix_path,mimetype);
return mimetype;
}
/* This code was grapped from IconImage/wbarg.c/IconFromWBArg()
* Commodore-Amiga Example code
*/
static struct DiskObject *smart_get_icon(struct SmartArgs *args, struct WBStartup *wb_startup)
{
struct DiskObject *dob = NULL;
struct WBArg *wbarg = wb_startup->sm_ArgList;
ULONG num = wb_startup->sm_NumArgs;
UBYTE work_name[MAXIMUM_FILENAME_LENGTH];
BPTR old_lock, new_lock;
/* Copy the WBArg contents */
strncpy(work_name, wbarg->wa_Name, MAXIMUM_FILENAME_LENGTH);
new_lock = DupLock(wbarg->wa_Lock);
if (new_lock != NULL)
{
D(bug("work_name : \"%s\"\n", work_name));
/* go to the directory where the icon resides */
old_lock = CurrentDir(new_lock);
dob = GetDiskObjectNew(work_name);
/* test, if the first icon is a project icon and if so, get its icon */
if (wb_startup->sm_NumArgs > 1)
{
BPTR new_lock2;
if ((new_lock2 = DupLock(wbarg[1].wa_Lock)))
{
struct DiskObject *prj;
CurrentDir(new_lock2);
UnLock(new_lock);
new_lock = new_lock2;
strncpy(work_name, wbarg[1].wa_Name, MAXIMUM_FILENAME_LENGTH);
D(bug("work_name2 : \"%s\"\n", work_name));
if ((prj = GetDiskObjectNew(work_name)))
{
if (prj->do_Type == WBPROJECT)
{
BPTR test;
/* if this is only an icon skip it */
if (!(test = Lock(work_name, SHARED_LOCK)))
{
wbarg++;
num--;
}
else
UnLock(test);
if (dob)
FreeDiskObject(dob);
dob = prj;
}
}
}
}
if (dob)
{
D(bug("dobj window : %s\n", dob->do_ToolWindow));
}
/* go back to where we used to be */
CurrentDir(old_lock);
/* release the duplicated lock */
UnLock(new_lock);
args->sa_WBArg = wbarg + 1;
args->sa_NumArgs = num;
}
D(bug("return (dob)\n"));
return (dob);
}
bool amiga_icon_convert(struct content *c)
{
amiga_icon_content *icon_c = (amiga_icon_content *)c;
union content_msg_data msg_data;
struct DiskObject *dobj;
ULONG *imagebuf;
unsigned char *imagebufptr = NULL;
ULONG size;
int width = 0, height = 0;
long format = 0;
int err = 0;
uint8 r, g, b, a;
ULONG offset;
const char *url;
char *filename;
char *p;
ULONG trans, pals1;
struct ColorRegister *pal1;
url = nsurl_access(content_get_url(c));
filename = url_to_path(url);
/* This loader will only work on local files, so fail if not a local path */
if(filename == NULL)
{
msg_data.error = messages_get("NoMemory");
content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
return false;
}
p = strstr(filename, ".info");
*p = '\0';
dobj = GetIconTagList(filename, NULL);
if(dobj == NULL)
{
msg_data.error = messages_get("NoMemory");
content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
return false;
}
err = IconControl(dobj,
ICONCTRLA_GetImageDataFormat,&format,
ICONCTRLA_GetWidth,&width,
ICONCTRLA_GetHeight,&height,
TAG_DONE);
/* Check icon is direct mapped (truecolour) or palette-mapped colour.
We need additional code to handle planar icons */
if((format != IDFMT_DIRECTMAPPED) && (format==IDFMT_PALETTEMAPPED)) {
if(dobj) FreeDiskObject(dobj);
return false;
}
icon_c->bitmap = bitmap_create(width, height, BITMAP_NEW);
if (!icon_c->bitmap) {
msg_data.error = messages_get("NoMemory");
content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
if(dobj) FreeDiskObject(dobj);
return false;
}
imagebuf = (ULONG *) bitmap_get_buffer(icon_c->bitmap);
if (!imagebuf) {
msg_data.error = messages_get("NoMemory");
content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
if(dobj) FreeDiskObject(dobj);
return false;
}
err = IconControl(dobj,
ICONCTRLA_GetImageData1, &imagebufptr,
TAG_DONE);
if(format==IDFMT_PALETTEMAPPED)
{
IconControl(dobj, ICONCTRLA_GetTransparentColor1, &trans,
ICONCTRLA_GetPalette1, &pal1,
ICONCTRLA_GetPaletteSize1, &pals1,
TAG_DONE);
imagebufptr = (unsigned char *) amiga_icon_convertcolouricon32((UBYTE *)imagebufptr,
width, height, trans, pals1, pal1, 0xff);
}
/* Decoded data is ARGB, so ensure correct byte order */
size = width * height * 4;
for (offset = 0; offset < size; offset += 4) {
b = imagebufptr[offset+3];
g = imagebufptr[offset+2];
r = imagebufptr[offset+1];
a = imagebufptr[offset];
*imagebuf = r << 24 | g << 16 | b << 8 | a;
imagebuf++;
}
c->width = width;
c->height = height;
bitmap_modified(icon_c->bitmap);
content_set_ready(c);
content_set_done(c);
content_set_status(c, "");
if(dobj) FreeDiskObject(dobj);
if(format==IDFMT_PALETTEMAPPED)
FreeVec(imagebufptr);
return true;
}
int main(int argc, char **argv) {
struct RDArgs *rdargs = NULL;
int i;
char pubscreen[32];
if(argc) {
rdargs=ReadArgs( TEMPLATE , (LONG *) &args, NULL);
SaveIcons = FALSE;
}
else {
struct WBStartup *WBenchMsg = (struct WBStartup *)argv;
struct WBArg *wbarg;
BPTR olddir;
struct DiskObject *dobj;
STRPTR* toolarray;
UBYTE *s;
SaveIcons = TRUE;
for(i=0, wbarg=WBenchMsg->sm_ArgList;
i < WBenchMsg->sm_NumArgs;
i++, wbarg++) {
olddir = (BPTR) -1;
if((wbarg->wa_Lock)&&(*wbarg->wa_Name))
olddir = CurrentDir(wbarg->wa_Lock);
if((*wbarg->wa_Name) && (dobj=GetDiskObject(wbarg->wa_Name))) {
toolarray = dobj->do_ToolTypes;
s = FindToolType(toolarray,"CREATEICONS");
if( s != NULL ) {
if( MatchToolValue(s,"NO") ||
MatchToolValue(s,"FALSE")) {
SaveIcons = FALSE;
}
}
s = (char *) FindToolType(toolarray,"PUBSCREEN");
if( s != NULL ) {
strncpy(pubscreen, s, sizeof pubscreen);
args.pubscreen = pubscreen;
}
s = (char *) FindToolType(toolarray,"ACTION");
if( s != NULL ) {
if(MatchToolValue(s,"EDIT")) {
args.edit = TRUE;
}
else if(MatchToolValue(s,"USE")) {
args.use = TRUE;
}
else if(MatchToolValue(s,"SAVE")) {
args.save = TRUE;
}
}
FreeDiskObject(dobj);
}
if((i>0)&&(*wbarg->wa_Name)) {
args.from = wbarg->wa_Name;
}
if(olddir != (BPTR) -1) {
CurrentDir(olddir); /* CD back where we were */
}
}
}
if(args.from == NULL) {
args.from = ENVFILE;
}
if(args.edit) {
args.use = FALSE;
args.save = FALSE;
}
if((SetSignal(0L,SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) == 0) {
if(Initialize()) {
NewSettings(args.from);
if((!args.use && !args.save) || args.edit) {
if(BuildGUI(args.pubscreen)) {
EventLoop();
}
CloseGUI();
}
if(args.use || args.save) {
SaveSettings(ENVFILE, UnitList);
}
if(args.save) {
SaveSettings(ENVARCFILE, UnitList);
}
}
}
if(rdargs) {
FreeArgs(rdargs);
}
FreeVec(Units);
FreeVec(Modes);
FreeVec(Outputs);
FreeVec(Inputs);
FreeList(ModeList);
FreeList(UnitList);
CleanUp();
return 0;
}
/*>ProcessToolTypes(void)
----------------------
Alters defaults based on icon tool types. Handles the following
tooltypes:
Size=<x> <y> Output dimensions
Offset=<x> <y> Output offset
HPGLMargin=<x> <y> HPGL paper margins
Title=<Font> <Size> Title font and size
XTitle=<Font> <Size> X-axis title font and size
YTitle=<Font> <Size> Y-axis title font and size
XLabel=<Font> <Size> X-axis label font and size
YLabel=<Font> <Size> Y-axis label font and size
Key=<Font> <Size> Key font and size
Extralabel=<Font> <Size> Extra label font and size
Hatching=ON|OFF Use hatching or shading
HatchControl=<thick> <space> Thickness and spacing of hatching
Pen0=<R> <G> <B> Pen colours
Pen1=<R> <G> <B>
Pen2=<R> <G> <B>
Pen3=<R> <G> <B>
DIR=<directory> Default directory
NOSHANGHAI Stops editor SHANGHAI under V2.0
AXISBOUNDS EPSF bounding box set to size given by paper
01.07.92 Original
02.07.92 Added pen colours. Also rebuilds windows if colours have been
set.
06.07.92 Added default directory.
04.08.92 Added NOSHANGHAI
15.09.92 Added AXISBOUNDS
*/
ProcessToolTypes(void)
{
struct DiskObject *DiskObj = NULL;
char *valptr,
string[80];
double value,
value2;
int ival1,
ival2,
ival3,
redowindows = FALSE;
if((DiskObj = (struct DiskObject *)
GetDiskObject(WBenchMsg->sm_ArgList->wa_Name)) != NULL)
{
/* Tooltype: Size=<x> <y> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"Size")) != NULL)
if(sscanf(valptr,"%lf %lf",&value,&value2) == 2)
{
output.xsize = value;
output.ysize = value2;
}
/* Tooltype: Offset=<x> <y> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"Offset")) != NULL)
if(sscanf(valptr,"%lf %lf",&value,&value2) == 2)
{
output.xoffset = value;
output.yoffset = value2;
}
/* Tooltype: HPGLMargin=<x> <y> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"HPGLMargin")) != NULL)
if(sscanf(valptr,"%lf %lf",&value,&value2) == 2)
{
output.xmargin = value;
output.ymargin = value2;
}
/* Tooltype: Title=<font> <size> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"Title")) != NULL)
if(sscanf(valptr,"%s %lf",string,&value) == 2)
{
strcpy(GTitle.PSFont,string);
GTitle.PSSize = value;
}
/* Tooltype: XAxTitle=<font> <size> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"XTitle")) != NULL)
if(sscanf(valptr,"%s %lf",string,&value) == 2)
{
strcpy(XTitle.PSFont,string);
XTitle.PSSize = value;
}
/* Tooltype: YAxTitle=<font> <size> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"YTitle")) != NULL)
if(sscanf(valptr,"%s %lf",string,&value) == 2)
{
strcpy(YTitle.PSFont,string);
YTitle.PSSize = value;
}
/* Tooltype: XLabel=<font> <size> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"XLabel")) != NULL)
if(sscanf(valptr,"%s %lf",string,&value) == 2)
{
strcpy(XLabel.PSFont,string);
XLabel.PSSize = value;
}
/* Tooltype: YLabel=<font> <size> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"YLabel")) != NULL)
if(sscanf(valptr,"%s %lf",string,&value) == 2)
{
strcpy(YLabel.PSFont,string);
YLabel.PSSize = value;
}
/* Tooltype: Key=<font> <size> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"Key")) != NULL)
if(sscanf(valptr,"%s %lf",string,&value) == 2)
{
strcpy(Defaults.KeyPSFont,string);
Defaults.KeyPSSize = value;
}
/* Tooltype: ExtraLabel=<font> <size> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"ExtraLabel")) != NULL)
if(sscanf(valptr,"%s %lf",string,&value) == 2)
{
strcpy(Defaults.LabelPSFont,string);
Defaults.LabelPSSize = value;
}
/* Tooltype: Hatching=ON|OFF */
if(MatchToolValue(FindToolType(DiskObj->do_ToolTypes,"Hatching"),"ON"))
output.hatching = TRUE;
if(MatchToolValue(FindToolType(DiskObj->do_ToolTypes,"Hatching"),"OFF"))
output.hatching = FALSE;
/* Tooltype: HatchControl=<thickness> <spacing> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"HatchControl")) != NULL)
if(sscanf(valptr,"%lf %lf",&value,&value2) == 2)
{
output.hatchthick = value;
output.hatchspace = value2;
}
/* Tooltype: Pen0=<R> <G> <B> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"Pen0")) != NULL)
if(sscanf(valptr,"%d %d %d",&ival1,&ival2,&ival3) == 3)
{
ival1 = RANGECHECK(ival1,0,15);
ival2 = RANGECHECK(ival2,0,15);
ival3 = RANGECHECK(ival3,0,15);
SetRGB4(&MyScreen->ViewPort,0,(UBYTE)ival1,(UBYTE)ival2,(UBYTE)ival3);
redowindows = TRUE;
}
/* Tooltype: Pen1=<R> <G> <B> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"Pen1")) != NULL)
if(sscanf(valptr,"%d %d %d",&ival1,&ival2,&ival3) == 3)
{
ival1 = RANGECHECK(ival1,0,15);
ival2 = RANGECHECK(ival2,0,15);
ival3 = RANGECHECK(ival3,0,15);
SetRGB4(&MyScreen->ViewPort,1,(UBYTE)ival1,(UBYTE)ival2,(UBYTE)ival3);
redowindows = TRUE;
}
/* Tooltype: Pen2=<R> <G> <B> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"Pen2")) != NULL)
if(sscanf(valptr,"%d %d %d",&ival1,&ival2,&ival3) == 3)
{
ival1 = RANGECHECK(ival1,0,15);
ival2 = RANGECHECK(ival2,0,15);
ival3 = RANGECHECK(ival3,0,15);
SetRGB4(&MyScreen->ViewPort,2,(UBYTE)ival1,(UBYTE)ival2,(UBYTE)ival3);
redowindows = TRUE;
}
/* Tooltype: Pen3=<R> <G> <B> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"Pen3")) != NULL)
if(sscanf(valptr,"%d %d %d",&ival1,&ival2,&ival3) == 3)
{
ival1 = RANGECHECK(ival1,0,15);
ival2 = RANGECHECK(ival2,0,15);
ival3 = RANGECHECK(ival3,0,15);
SetRGB4(&MyScreen->ViewPort,3,(UBYTE)ival1,(UBYTE)ival2,(UBYTE)ival3);
redowindows = TRUE;
}
/* Tooltype: DIR=<directory> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"DIR")) != NULL)
strcpy(Defaults.directory,valptr);
/* Tooltype: NOSHANGHAI */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"NOSHANGHAI")) != NULL)
display.shanghai = FALSE;
/* Tooltype: AXISBOUNDS */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"AXISBOUNDS")) != NULL)
output.fixbounds = FALSE;
FreeDiskObject(DiskObj);
/*
// if(redowindows)
// {
// FreeAllGadgets();
// BuildAllWindows();
// }
*/
}
return(0);
}
void amiga_icon_superimpose_favicon(char *path, struct hlcache_handle *icon, char *type)
{
struct DiskObject *dobj = NULL;
struct BitMap *bm = NULL;
ULONG *icondata1, *icondata2;
ULONG width, height;
long format = 0;
int err = 0;
ULONG trans1, pals1;
ULONG trans2, pals2;
struct ColorRegister *pal1;
struct ColorRegister *pal2;
if(icon == NULL) return;
if(!type)
{
dobj = GetIconTags(NULL,
ICONGETA_GetDefaultType, WBDRAWER,
TAG_DONE);
}
else
{
dobj = GetIconTags(NULL, ICONGETA_GetDefaultName, type,
ICONGETA_GetDefaultType, WBPROJECT,
TAG_DONE);
}
if(dobj == NULL) return;
err = IconControl(dobj,
ICONCTRLA_GetImageDataFormat,&format,
ICONCTRLA_GetImageData1,&icondata1,
ICONCTRLA_GetImageData2,&icondata2,
ICONCTRLA_GetWidth,&width,
ICONCTRLA_GetHeight,&height,
TAG_DONE);
/* If we have a palette-mapped icon, convert it to a 32-bit one */
if(format == IDFMT_PALETTEMAPPED)
{
IconControl(dobj, ICONCTRLA_GetTransparentColor1, &trans1,
ICONCTRLA_GetPalette1, &pal1,
ICONCTRLA_GetPaletteSize1, &pals1,
ICONCTRLA_GetTransparentColor2, &trans2,
ICONCTRLA_GetPalette2, &pal2,
ICONCTRLA_GetPaletteSize2, &pals2,
TAG_DONE);
icondata1 = amiga_icon_convertcolouricon32((UBYTE *)icondata1,
width, height, trans1, pals1, pal1, 0xff);
icondata2 = amiga_icon_convertcolouricon32((UBYTE *)icondata2,
width, height, trans2, pals2, pal2, 0xff);
err = IconControl(dobj,
ICONCTRLA_SetImageDataFormat, IDFMT_DIRECTMAPPED,
ICONCTRLA_SetImageData1, icondata1,
ICONCTRLA_SetImageData2, icondata2,
TAG_DONE);
}
if((format == IDFMT_DIRECTMAPPED) || (format == IDFMT_PALETTEMAPPED))
amiga_icon_superimpose_favicon_internal(icon, dobj);
PutIconTags(path, dobj,
ICONPUTA_NotifyWorkbench, TRUE, TAG_DONE);
FreeDiskObject(dobj);
if(format == IDFMT_PALETTEMAPPED)
{
/* Free the 32-bit data we created */
FreeVec(icondata1);
FreeVec(icondata2);
}
}
