WebSVN – filter_foundry – Diff – /trunk/save.c


/*
    This file is part of "Filter Foundry", a filter plugin for Adobe Photoshop
    Copyright (C) 2003-2009 Toby Thain, toby@telegraphics.com.au
    Copyright (C) 2018-2022 Daniel Marschall, ViaThinkSoft
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
 
#include "ff.h"
 
#include "file_compat.h"
#include "sprintf_tiny.h"
 
enum{ CHOPLINES = 63 };
 
OSErr putstr(Handle h,char *s);
 
OSErr putstr(Handle h,char *s){
        Ptr p;
        OSErr e;
        size_t size, n;
 
        if (!h) return nilHandleErr;
 
        size = PIGETHANDLESIZE(h);
        n = strlen(s);
 
        if(!(e = PISETHANDLESIZE(h,(int32)(size+n)))){
                p = PILOCKHANDLE(h,false);
                memcpy(p+size,s,n);
                PIUNLOCKHANDLE(h);
        }
        return e;
}
 
OSErr saveparams_afs_pff(Handle h){
        char outbuf[CHOPLINES * 2 + 2] = "";
        char *q, * p, * r, * start;
        size_t n, chunk, j;
        int i;
        OSErr e;
        size_t est;
        static char afs_sig[] = "%RGB-1.0\r";
 
        if (!h) return nilHandleErr;
 
        est = strlen(expr[0]) + strlen(expr[1]) + strlen(expr[2]) + strlen(expr[3]);
        // do not be tempted to combine into one expression: 'est' is referenced below
        est += strlen(afs_sig) + est/CHOPLINES + 4 + 8*6 + 64 /*slop*/ ;
 
        PIUNLOCKHANDLE(h); // should not be necessary
        if( !(e = PISETHANDLESIZE(h,(int32)(est))) && (p = start = PILOCKHANDLE(h,false)) ){
                // build one long string in AFS format
                p = cat(p,afs_sig); // first the header signature
 
                /* then slider values, one per line */
                for( i=0 ; i<8 ; ++i )
                        p += sprintf(p, "%d\r", slider[i]);
 
                /* expressions, broken into lines no longer than CHOPLINES characters */
                for( i=0 ; i<4 ; ++i ){
                        if ((r = expr[i])) {
                                chunk = 0; // to avoid that compiler complains
                                for (n = strlen(r); n; n -= chunk) {
                                        chunk = n > (int)CHOPLINES ? (int)CHOPLINES : n;
                                        for (j = chunk, q = outbuf; j--; )
                                                if (*r == CR) {
                                                        *q++ = '\\';
                                                        *q++ = 'r';
                                                        ++r;
                                                }
                                                else if (*r == LF) {
 
                                                        // This can only happen with Windows or Linux.
                                                        // Native Linux is not supported, and Windows always combines LF with CR. So we can ignore LF.
                                                        ++r;
                                                }
                                                else
                                                        *q++ = *r++;
                                        *q++ = CR;
                                        *q = 0;
                                        p = cat(p, outbuf);
                                }
                        }
                        else
                                p = cat(p,(char*)("(null expr)\r")); // this shouldn't happen
                        *p++ = CR;
                }
 
//              *p = 0; dbg(start);
 
                PIUNLOCKHANDLE(h);
                e = PISETHANDLESIZE(h,(int32)(p - start)); // could ignore this error, maybe
        }
 
        return e;
}
 
OSErr saveparams_picotxt(Handle h, Boolean useparm) {
        extern int ctls[], maps[];
 
        char * p, *start;
        int i;
        OSErr e;
        size_t est;
 
        if (!h) return nilHandleErr;
 
        est = strlen(expr[0]) + strlen(expr[1]) + strlen(expr[2]) + strlen(expr[3]);
        // do not be tempted to combine into one expression: 'est' is referenced below
        est += 16000;
 
        PIUNLOCKHANDLE(h); // should not be necessary
        if (!(e = PISETHANDLESIZE(h, (int32)(est))) && (p = start = PILOCKHANDLE(h, false))) {
                checksliders(4, ctls, maps);
 
                // Metadata
                p += sprintf(p, "Category: %s\r\n", useparm ? gdata->parm.szCategory : "...");
                p += sprintf(p, "Title: %s\r\n", useparm ? gdata->parm.szTitle : "...");
                p += sprintf(p, "Copyright: %s\r\n", useparm ? gdata->parm.szCopyright : "...");
                p += sprintf(p, "Author: %s\r\n", useparm ? gdata->parm.szAuthor : "...");
                p += sprintf(p, "Filename: %s\r\n", useparm ? "Untitled.8bf" : "Untitled.8bf"); // TODO: get .txt filename and change .txt to .8bf
                p += sprintf(p, "\r\n");
                p += sprintf(p, "R: %s\r\n", useparm ? gdata->parm.szFormula[0] : expr[0]);
                p += sprintf(p, "\r\n");
                p += sprintf(p, "G: %s\r\n", useparm ? gdata->parm.szFormula[1] : expr[1]);
                p += sprintf(p, "\r\n");
                p += sprintf(p, "B: %s\r\n", useparm ? gdata->parm.szFormula[2] : expr[2]);
                p += sprintf(p, "\r\n");
                p += sprintf(p, "A: %s\r\n", useparm ? gdata->parm.szFormula[3] : expr[3]);
                p += sprintf(p, "\r\n");
                if (useparm) {
                        for (i = 0; i < 8; i++) {
                                if (gdata->parm.ctl_used[i]) {
                                        p += sprintf(p, "ctl[%d]: %s\r\n", i, gdata->parm.szCtl[i]);
                                }
                        }
                        for (i = 0; i < 4; i++) {
                                if (gdata->parm.map_used[i]) {
                                        p += sprintf(p, "map[%d]: %s\r\n", i, gdata->parm.szMap[i]);
                                }
                        }
                        p += sprintf(p, "\r\n");
                        for (i = 0; i < 8; i++) {
                                if (gdata->parm.ctl_used[i]) {
                                        p += sprintf(p, "val[%d]: %d\r\n", i, gdata->parm.val[i]);
                                }
                        }
                        /*
                        p += sprintf(p, "\r\n");
                        for (i = 0; i < 8; i++) {
                                if (gdata->parm.ctl_used[i]) {
                                        p += sprintf(p, "def[%d]: %d\r\n", i, gdata->parm.val[i]);
                                }
                        }
                        */
                }
                else {
                        for (i = 0; i < 8; i++) {
                                if (ctls[i]) {
                                        p += sprintf(p, "ctl[%d]: %s\r\n", i, "...");
                                }
                        }
                        for (i = 0; i < 4; i++) {
                                if (maps[i]) {
                                        p += sprintf(p, "map[%d]: %s\r\n", i, "...");
                                }
                        }
                        p += sprintf(p, "\r\n");
                        for (i = 0; i < 8; i++) {
                                if (ctls[i]) {
                                        p += sprintf(p, "val[%d]: %d\r\n", i, slider[i]);
                                }
                        }
                        /*
                        p += sprintf(p, "\r\n");
                        for (i = 0; i < 8; i++) {
                                if (ctls[i]) {
                                        p += sprintf(p, "def[%d]: %s\r\n", i, "...");
                                }
                        }
                        */
                }
 
                PIUNLOCKHANDLE(h);
                e = PISETHANDLESIZE(h, (int32)(p - start)); // could ignore this error, maybe
        }
 
        return e;
}
 
OSErr savehandleintofile(Handle h,FILEREF r){
        Ptr p;
        FILECOUNT n;
        OSErr e;
 
        if (!h) return nilHandleErr;
        p = PILOCKHANDLE(h,false);
        n = (FILECOUNT)PIGETHANDLESIZE(h);
        e = FSWrite(r,&n,p);
        PIUNLOCKHANDLE(h);
        return e;
}
 
Boolean savefile_afs_pff_picotxt(StandardFileReply *sfr){
        FILEREF r;
        Handle h;
        Boolean res = false;
        TCHAR* reasonstr = NULL;
 
        FSpDelete(&sfr->sfFile);
        if(FSpCreate(&sfr->sfFile,SIG_SIMPLETEXT,TEXT_FILETYPE,sfr->sfScript) == noErr)
                if(FSpOpenDF(&sfr->sfFile,fsWrPerm,&r) == noErr){
 
                        if (fileHasExtension(sfr, TEXT(".txt"))) {
                                // PluginCommander .txt
                                if ((h = PINEWHANDLE(1))) { // don't set initial size to 0, since some hosts (e.g. GIMP/PSPI) are incompatible with that.
                                        res = !(saveparams_picotxt(h,false) || savehandleintofile(h, r));
                                        PIDISPOSEHANDLE(h);
                                }
                        }
 
                        if ((fileHasExtension(sfr, TEXT(".afs"))) || (fileHasExtension(sfr, TEXT(".pff")))) {
                                if (fileHasExtension(sfr, TEXT(".pff"))) {
                                        // If it is a Premiere settings file, we need to swap the channels red and blue
                                        // We just swap the pointers!
                                        char* tmp;
                                        tmp = expr[0];
                                        expr[0] = expr[2];
                                        expr[2] = tmp;
                                }
 
                                if ((h = PINEWHANDLE(1))) { // don't set initial size to 0, since some hosts (e.g. GIMP/PSPI) are incompatible with that.
                                        res = !(saveparams_afs_pff(h) || savehandleintofile(h, r));
                                        PIDISPOSEHANDLE(h);
                                }
 
                                if (fileHasExtension(sfr, TEXT(".pff"))) {
                                        // Swap back so that the other program stuff will work normally again
                                        char* tmp;
                                        tmp = expr[0];
                                        expr[0] = expr[2];
                                        expr[2] = tmp;
                                }
                        }
 
                        FSClose(r);
                }else reasonstr = FF_GetMsg_Cpy(MSG_CANNOT_OPEN_FILE_ID);
        else reasonstr = FF_GetMsg_Cpy(MSG_CANNOT_CREATE_FILE_ID);
 
        if (!res) {
                alertuser_id(MSG_CANNOT_SAVE_SETTINGS_ID, reasonstr);
        }
 
        if (reasonstr) FF_GetMsg_Free(reasonstr);
 
        return res;
}
 

Rev 503	Rev 505
1	/*	1	/*
2	This file is part of "Filter Foundry", a filter plugin for Adobe Photoshop	2	This file is part of "Filter Foundry", a filter plugin for Adobe Photoshop
3	Copyright (C) 2003-2009 Toby Thain, toby@telegraphics.com.au	3	Copyright (C) 2003-2009 Toby Thain, toby@telegraphics.com.au
4	Copyright (C) 2018-2022 Daniel Marschall, ViaThinkSoft	4	Copyright (C) 2018-2022 Daniel Marschall, ViaThinkSoft
5		5
6	This program is free software; you can redistribute it and/or modify	6	This program is free software; you can redistribute it and/or modify
7	it under the terms of the GNU General Public License as published by	7	it under the terms of the GNU General Public License as published by
8	the Free Software Foundation; either version 2 of the License, or	8	the Free Software Foundation; either version 2 of the License, or
9	(at your option) any later version.	9	(at your option) any later version.
10		10
11	This program is distributed in the hope that it will be useful,	11	This program is distributed in the hope that it will be useful,
12	but WITHOUT ANY WARRANTY; without even the implied warranty of	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	GNU General Public License for more details.	14	GNU General Public License for more details.
15		15
16	You should have received a copy of the GNU General Public License	16	You should have received a copy of the GNU General Public License
17	along with this program; if not, write to the Free Software	17	along with this program; if not, write to the Free Software
18	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	18	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19	*/	19	*/
20		20
21	#include "ff.h"	21	#include "ff.h"
22		22
23	#include "file_compat.h"	23	#include "file_compat.h"
24	#include "sprintf_tiny.h"	24	#include "sprintf_tiny.h"
25		25
26	enum{ CHOPLINES = 63 };	26	enum{ CHOPLINES = 63 };
27		27
28	OSErr putstr(Handle h,char *s);	28	OSErr putstr(Handle h,char *s);
29		29
30	OSErr putstr(Handle h,char *s){	30	OSErr putstr(Handle h,char *s){
31	Ptr p;	31	Ptr p;
32	OSErr e;	32	OSErr e;
33	size_t size, n;	33	size_t size, n;
34		34
35	if (!h) return nilHandleErr;	35	if (!h) return nilHandleErr;
36		36
37	size = PIGETHANDLESIZE(h);	37	size = PIGETHANDLESIZE(h);
38	n = strlen(s);	38	n = strlen(s);
39		39
40	if(!(e = PISETHANDLESIZE(h,(int32)(size+n)))){	40	if(!(e = PISETHANDLESIZE(h,(int32)(size+n)))){
41	p = PILOCKHANDLE(h,false);	41	p = PILOCKHANDLE(h,false);
42	memcpy(p+size,s,n);	42	memcpy(p+size,s,n);
43	PIUNLOCKHANDLE(h);	43	PIUNLOCKHANDLE(h);
44	}	44	}
45	return e;	45	return e;
46	}	46	}
47		47
48	OSErr saveparams_afs_pff(Handle h){	48	OSErr saveparams_afs_pff(Handle h){
49	char outbuf[CHOPLINES2+2],q,p,r,*start;	49	char outbuf[CHOPLINES * 2 + 2] = "";
-		50	char q, p, * r, * start;
50	size_t n, chunk, j;	51	size_t n, chunk, j;
51	int i;	52	int i;
52	OSErr e;	53	OSErr e;
53	size_t est;	54	size_t est;
54	static char afs_sig[] = "%RGB-1.0\r";	55	static char afs_sig[] = "%RGB-1.0\r";
55		56
56	if (!h) return nilHandleErr;	57	if (!h) return nilHandleErr;
57		58
58	est = strlen(expr[0]) + strlen(expr[1]) + strlen(expr[2]) + strlen(expr[3]);	59	est = strlen(expr[0]) + strlen(expr[1]) + strlen(expr[2]) + strlen(expr[3]);
59	// do not be tempted to combine into one expression: 'est' is referenced below	60	// do not be tempted to combine into one expression: 'est' is referenced below
60	est += strlen(afs_sig) + est/CHOPLINES + 4 + 86 + 64 /slop*/ ;	61	est += strlen(afs_sig) + est/CHOPLINES + 4 + 86 + 64 /slop*/ ;
61		62
62	PIUNLOCKHANDLE(h); // should not be necessary	63	PIUNLOCKHANDLE(h); // should not be necessary
63	if( !(e = PISETHANDLESIZE(h,(int32)(est))) && (p = start = PILOCKHANDLE(h,false)) ){	64	if( !(e = PISETHANDLESIZE(h,(int32)(est))) && (p = start = PILOCKHANDLE(h,false)) ){
64	// build one long string in AFS format	65	// build one long string in AFS format
65	p = cat(p,afs_sig); // first the header signature	66	p = cat(p,afs_sig); // first the header signature
66		67
67	/* then slider values, one per line */	68	/* then slider values, one per line */
68	for( i=0 ; i<8 ; ++i )	69	for( i=0 ; i<8 ; ++i )
69	p += sprintf(p, "%d\r", slider[i]);	70	p += sprintf(p, "%d\r", slider[i]);
70		71
71	/* expressions, broken into lines no longer than CHOPLINES characters */	72	/* expressions, broken into lines no longer than CHOPLINES characters */
72	for( i=0 ; i<4 ; ++i ){	73	for( i=0 ; i<4 ; ++i ){
73	if( (r = expr[i]) )	74	if ((r = expr[i])) {
-		75	chunk = 0; // to avoid that compiler complains
74	for( n = strlen(r) ; n ; n -= chunk ){	76	for (n = strlen(r); n; n -= chunk) {
75	chunk = n> (int)CHOPLINES ? (int)CHOPLINES : n;	77	chunk = n > (int)CHOPLINES ? (int)CHOPLINES : n;
76	for( j = chunk,q = outbuf ; j-- ; )	78	for (j = chunk, q = outbuf; j--; )
77	if(*r == CR){	79	if (*r == CR) {
78	*q++ = '\\';	80	*q++ = '\\';
79	*q++ = 'r';	81	*q++ = 'r';
80	++r;	82	++r;
-		83	}
81	}else if (*r == LF) {	84	else if (*r == LF) {
82		85
83	// This can only happen with Windows or Linux.	86	// This can only happen with Windows or Linux.
84	// Native Linux is not supported, and Windows always combines LF with CR. So we can ignore LF.	87	// Native Linux is not supported, and Windows always combines LF with CR. So we can ignore LF.
85	++r;	88	++r;
-		89	}
86	}else	90	else
87	q++ = r++;	91	q++ = r++;
88	*q++ = CR;	92	*q++ = CR;
89	*q = 0;	93	*q = 0;
90	p = cat(p,outbuf);	94	p = cat(p, outbuf);
91	}	95	}
-		96	}
92	else	97	else
93	p = cat(p,(char*)("(null expr)\r")); // this shouldn't happen	98	p = cat(p,(char*)("(null expr)\r")); // this shouldn't happen
94	*p++ = CR;	99	*p++ = CR;
95	}	100	}
96		101
97	// *p = 0; dbg(start);	102	// *p = 0; dbg(start);
98		103
99	PIUNLOCKHANDLE(h);	104	PIUNLOCKHANDLE(h);
100	e = PISETHANDLESIZE(h,(int32)(p - start)); // could ignore this error, maybe	105	e = PISETHANDLESIZE(h,(int32)(p - start)); // could ignore this error, maybe
101	}	106	}
102		107
103	return e;	108	return e;
104	}	109	}
105		110
106	OSErr saveparams_picotxt(Handle h, Boolean useparm) {	111	OSErr saveparams_picotxt(Handle h, Boolean useparm) {
107	extern int ctls[], maps[];	112	extern int ctls[], maps[];
108		113
109	char * p, *start;	114	char * p, *start;
110	int i;	115	int i;
111	OSErr e;	116	OSErr e;
112	size_t est;	117	size_t est;
113		118
114	if (!h) return nilHandleErr;	119	if (!h) return nilHandleErr;
115		120
116	est = strlen(expr[0]) + strlen(expr[1]) + strlen(expr[2]) + strlen(expr[3]);	121	est = strlen(expr[0]) + strlen(expr[1]) + strlen(expr[2]) + strlen(expr[3]);
117	// do not be tempted to combine into one expression: 'est' is referenced below	122	// do not be tempted to combine into one expression: 'est' is referenced below
118	est += 16000;	123	est += 16000;
119		124
120	PIUNLOCKHANDLE(h); // should not be necessary	125	PIUNLOCKHANDLE(h); // should not be necessary
121	if (!(e = PISETHANDLESIZE(h, (int32)(est))) && (p = start = PILOCKHANDLE(h, false))) {	126	if (!(e = PISETHANDLESIZE(h, (int32)(est))) && (p = start = PILOCKHANDLE(h, false))) {
122	checksliders(4, ctls, maps);	127	checksliders(4, ctls, maps);
123		128
124	// Metadata	129	// Metadata
125	p += sprintf(p, "Category: %s\r\n", useparm ? gdata->parm.szCategory : "...");	130	p += sprintf(p, "Category: %s\r\n", useparm ? gdata->parm.szCategory : "...");
126	p += sprintf(p, "Title: %s\r\n", useparm ? gdata->parm.szTitle : "...");	131	p += sprintf(p, "Title: %s\r\n", useparm ? gdata->parm.szTitle : "...");
127	p += sprintf(p, "Copyright: %s\r\n", useparm ? gdata->parm.szCopyright : "...");	132	p += sprintf(p, "Copyright: %s\r\n", useparm ? gdata->parm.szCopyright : "...");
128	p += sprintf(p, "Author: %s\r\n", useparm ? gdata->parm.szAuthor : "...");	133	p += sprintf(p, "Author: %s\r\n", useparm ? gdata->parm.szAuthor : "...");
129	p += sprintf(p, "Filename: %s\r\n", useparm ? "Untitled.8bf" : "Untitled.8bf"); // TODO: get .txt filename and change .txt to .8bf	134	p += sprintf(p, "Filename: %s\r\n", useparm ? "Untitled.8bf" : "Untitled.8bf"); // TODO: get .txt filename and change .txt to .8bf
130	p += sprintf(p, "\r\n");	135	p += sprintf(p, "\r\n");
131	p += sprintf(p, "R: %s\r\n", useparm ? gdata->parm.szFormula[0] : expr[0]);	136	p += sprintf(p, "R: %s\r\n", useparm ? gdata->parm.szFormula[0] : expr[0]);
132	p += sprintf(p, "\r\n");	137	p += sprintf(p, "\r\n");
133	p += sprintf(p, "G: %s\r\n", useparm ? gdata->parm.szFormula[1] : expr[1]);	138	p += sprintf(p, "G: %s\r\n", useparm ? gdata->parm.szFormula[1] : expr[1]);
134	p += sprintf(p, "\r\n");	139	p += sprintf(p, "\r\n");
135	p += sprintf(p, "B: %s\r\n", useparm ? gdata->parm.szFormula[2] : expr[2]);	140	p += sprintf(p, "B: %s\r\n", useparm ? gdata->parm.szFormula[2] : expr[2]);
136	p += sprintf(p, "\r\n");	141	p += sprintf(p, "\r\n");
137	p += sprintf(p, "A: %s\r\n", useparm ? gdata->parm.szFormula[3] : expr[3]);	142	p += sprintf(p, "A: %s\r\n", useparm ? gdata->parm.szFormula[3] : expr[3]);
138	p += sprintf(p, "\r\n");	143	p += sprintf(p, "\r\n");
139	if (useparm) {	144	if (useparm) {
140	for (i = 0; i < 8; i++) {	145	for (i = 0; i < 8; i++) {
141	if (gdata->parm.ctl_used[i]) {	146	if (gdata->parm.ctl_used[i]) {
142	p += sprintf(p, "ctl[%d]: %s\r\n", i, gdata->parm.szCtl[i]);	147	p += sprintf(p, "ctl[%d]: %s\r\n", i, gdata->parm.szCtl[i]);
143	}	148	}
144	}	149	}
145	for (i = 0; i < 4; i++) {	150	for (i = 0; i < 4; i++) {
146	if (gdata->parm.map_used[i]) {	151	if (gdata->parm.map_used[i]) {
147	p += sprintf(p, "map[%d]: %s\r\n", i, gdata->parm.szMap[i]);	152	p += sprintf(p, "map[%d]: %s\r\n", i, gdata->parm.szMap[i]);
148	}	153	}
149	}	154	}
150	p += sprintf(p, "\r\n");	155	p += sprintf(p, "\r\n");
151	for (i = 0; i < 8; i++) {	156	for (i = 0; i < 8; i++) {
152	if (gdata->parm.ctl_used[i]) {	157	if (gdata->parm.ctl_used[i]) {
153	p += sprintf(p, "val[%d]: %d\r\n", i, gdata->parm.val[i]);	158	p += sprintf(p, "val[%d]: %d\r\n", i, gdata->parm.val[i]);
154	}	159	}
155	}	160	}
156	/*	161	/*
157	p += sprintf(p, "\r\n");	162	p += sprintf(p, "\r\n");
158	for (i = 0; i < 8; i++) {	163	for (i = 0; i < 8; i++) {
159	if (gdata->parm.ctl_used[i]) {	164	if (gdata->parm.ctl_used[i]) {
160	p += sprintf(p, "def[%d]: %d\r\n", i, gdata->parm.val[i]);	165	p += sprintf(p, "def[%d]: %d\r\n", i, gdata->parm.val[i]);
161	}	166	}
162	}	167	}
163	*/	168	*/
164	}	169	}
165	else {	170	else {
166	for (i = 0; i < 8; i++) {	171	for (i = 0; i < 8; i++) {
167	if (ctls[i]) {	172	if (ctls[i]) {
168	p += sprintf(p, "ctl[%d]: %s\r\n", i, "...");	173	p += sprintf(p, "ctl[%d]: %s\r\n", i, "...");
169	}	174	}
170	}	175	}
171	for (i = 0; i < 4; i++) {	176	for (i = 0; i < 4; i++) {
172	if (maps[i]) {	177	if (maps[i]) {
173	p += sprintf(p, "map[%d]: %s\r\n", i, "...");	178	p += sprintf(p, "map[%d]: %s\r\n", i, "...");
174	}	179	}
175	}	180	}
176	p += sprintf(p, "\r\n");	181	p += sprintf(p, "\r\n");
177	for (i = 0; i < 8; i++) {	182	for (i = 0; i < 8; i++) {
178	if (ctls[i]) {	183	if (ctls[i]) {
179	p += sprintf(p, "val[%d]: %d\r\n", i, slider[i]);	184	p += sprintf(p, "val[%d]: %d\r\n", i, slider[i]);
180	}	185	}
181	}	186	}
182	/*	187	/*
183	p += sprintf(p, "\r\n");	188	p += sprintf(p, "\r\n");
184	for (i = 0; i < 8; i++) {	189	for (i = 0; i < 8; i++) {
185	if (ctls[i]) {	190	if (ctls[i]) {
186	p += sprintf(p, "def[%d]: %s\r\n", i, "...");	191	p += sprintf(p, "def[%d]: %s\r\n", i, "...");
187	}	192	}
188	}	193	}
189	*/	194	*/
190	}	195	}
191		196
192	PIUNLOCKHANDLE(h);	197	PIUNLOCKHANDLE(h);
193	e = PISETHANDLESIZE(h, (int32)(p - start)); // could ignore this error, maybe	198	e = PISETHANDLESIZE(h, (int32)(p - start)); // could ignore this error, maybe
194	}	199	}
195		200
196	return e;	201	return e;
197	}	202	}
198		203
199	OSErr savehandleintofile(Handle h,FILEREF r){	204	OSErr savehandleintofile(Handle h,FILEREF r){
200	Ptr p;	205	Ptr p;
201	long n;	206	FILECOUNT n;
202	OSErr e;	207	OSErr e;
203		208
204	if (!h) return nilHandleErr;	209	if (!h) return nilHandleErr;
205	p = PILOCKHANDLE(h,false);	210	p = PILOCKHANDLE(h,false);
206	n = PIGETHANDLESIZE(h);	211	n = (FILECOUNT)PIGETHANDLESIZE(h);
207	e = FSWrite(r,&n,p);	212	e = FSWrite(r,&n,p);
208	PIUNLOCKHANDLE(h);	213	PIUNLOCKHANDLE(h);
209	return e;	214	return e;
210	}	215	}
211		216
212	Boolean savefile_afs_pff_picotxt(StandardFileReply *sfr){	217	Boolean savefile_afs_pff_picotxt(StandardFileReply *sfr){
213	FILEREF r;	218	FILEREF r;
214	Handle h;	219	Handle h;
215	Boolean res = false;	220	Boolean res = false;
216	TCHAR* reasonstr = NULL;	221	TCHAR* reasonstr = NULL;
217		222
218	FSpDelete(&sfr->sfFile);	223	FSpDelete(&sfr->sfFile);
219	if(FSpCreate(&sfr->sfFile,SIG_SIMPLETEXT,TEXT_FILETYPE,sfr->sfScript) == noErr)	224	if(FSpCreate(&sfr->sfFile,SIG_SIMPLETEXT,TEXT_FILETYPE,sfr->sfScript) == noErr)
220	if(FSpOpenDF(&sfr->sfFile,fsWrPerm,&r) == noErr){	225	if(FSpOpenDF(&sfr->sfFile,fsWrPerm,&r) == noErr){
221		226
222	if (fileHasExtension(sfr, TEXT(".txt"))) {	227	if (fileHasExtension(sfr, TEXT(".txt"))) {
223	// PluginCommander .txt	228	// PluginCommander .txt
224	if ((h = PINEWHANDLE(1))) { // don't set initial size to 0, since some hosts (e.g. GIMP/PSPI) are incompatible with that.	229	if ((h = PINEWHANDLE(1))) { // don't set initial size to 0, since some hosts (e.g. GIMP/PSPI) are incompatible with that.
225	res = !(saveparams_picotxt(h,false) \|\| savehandleintofile(h, r));	230	res = !(saveparams_picotxt(h,false) \|\| savehandleintofile(h, r));
226	PIDISPOSEHANDLE(h);	231	PIDISPOSEHANDLE(h);
227	}	232	}
228	}	233	}
229		234
230	if ((fileHasExtension(sfr, TEXT(".afs"))) \|\| (fileHasExtension(sfr, TEXT(".pff")))) {	235	if ((fileHasExtension(sfr, TEXT(".afs"))) \|\| (fileHasExtension(sfr, TEXT(".pff")))) {
231	if (fileHasExtension(sfr, TEXT(".pff"))) {	236	if (fileHasExtension(sfr, TEXT(".pff"))) {
232	// If it is a Premiere settings file, we need to swap the channels red and blue	237	// If it is a Premiere settings file, we need to swap the channels red and blue
233	// We just swap the pointers!	238	// We just swap the pointers!
234	char* tmp;	239	char* tmp;
235	tmp = expr[0];	240	tmp = expr[0];
236	expr[0] = expr[2];	241	expr[0] = expr[2];
237	expr[2] = tmp;	242	expr[2] = tmp;
238	}	243	}
239		244
240	if ((h = PINEWHANDLE(1))) { // don't set initial size to 0, since some hosts (e.g. GIMP/PSPI) are incompatible with that.	245	if ((h = PINEWHANDLE(1))) { // don't set initial size to 0, since some hosts (e.g. GIMP/PSPI) are incompatible with that.
241	res = !(saveparams_afs_pff(h) \|\| savehandleintofile(h, r));	246	res = !(saveparams_afs_pff(h) \|\| savehandleintofile(h, r));
242	PIDISPOSEHANDLE(h);	247	PIDISPOSEHANDLE(h);
243	}	248	}
244		249
245	if (fileHasExtension(sfr, TEXT(".pff"))) {	250	if (fileHasExtension(sfr, TEXT(".pff"))) {
246	// Swap back so that the other program stuff will work normally again	251	// Swap back so that the other program stuff will work normally again
247	char* tmp;	252	char* tmp;
248	tmp = expr[0];	253	tmp = expr[0];
249	expr[0] = expr[2];	254	expr[0] = expr[2];
250	expr[2] = tmp;	255	expr[2] = tmp;
251	}	256	}
252	}	257	}
253		258
254	FSClose(r);	259	FSClose(r);
255	}else reasonstr = FF_GetMsg_Cpy(MSG_CANNOT_OPEN_FILE_ID);	260	}else reasonstr = FF_GetMsg_Cpy(MSG_CANNOT_OPEN_FILE_ID);
256	else reasonstr = FF_GetMsg_Cpy(MSG_CANNOT_CREATE_FILE_ID);	261	else reasonstr = FF_GetMsg_Cpy(MSG_CANNOT_CREATE_FILE_ID);
257		262
258	if (!res) {	263	if (!res) {
259	alertuser_id(MSG_CANNOT_SAVE_SETTINGS_ID, reasonstr);	264	alertuser_id(MSG_CANNOT_SAVE_SETTINGS_ID, reasonstr);
260	}	265	}
261		266
262	if (reasonstr) FF_GetMsg_Free(reasonstr);	267	if (reasonstr) FF_GetMsg_Free(reasonstr);
263		268
264	return res;	269	return res;
265	}	270	}
266		271

Subversion Repositories filter_foundry

filter_foundry/trunk/save.c – Rev 503 → 505