WebSVN – filter_foundry – Diff – /trunk/ui_build.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
*/
 
/* This is PLATFORM INDEPENDENT user interface code - mainly dialog logic */
 
#include "ff.h"
#include "compat_string.h"
 
int ctls[8],maps[4];
int checksliders_result;
 
/* one-time initialisation of dialog box */
 
void builddlginit(DIALOGREF dp){
        int i;
        char s[0x100];
 
        if(gdata->parmloaded){
                SETCTLTEXT(dp,CATEGORYITEM, gdata->parm.szCategory);
                SETCTLTEXT(dp,TITLEITEM,    gdata->parm.szTitle);
                SETCTLTEXT(dp,COPYRIGHTITEM,gdata->parm.szCopyright);
                SETCTLTEXT(dp,AUTHORITEM,   gdata->parm.szAuthor);
                for(i=0;i<4;++i){
                        SETCTLTEXT(dp,FIRSTMAPNAMEITEM+i,gdata->parm.szMap[i]);
                }
                for(i=0;i<8;++i){
                        SETCTLTEXT(dp,FIRSTCTLNAMEITEM+i,gdata->parm.szCtl[i]);
                }
        }else{
                /* strictly speaking this is not needed on the Mac,
                   we can set initial values statically in the rez description */
                SETCTLTEXT(dp,CATEGORYITEM, "Filter Foundry");
                SETCTLTEXT(dp,TITLEITEM,    "Untitled");
                SETCTLTEXT(dp,COPYRIGHTITEM,""); //"Filter Foundry Copyright (C) 2003-2009 Toby Thain, 2018-" RELEASE_YEAR " Daniel Marschall"
                SETCTLTEXT(dp,AUTHORITEM,   "Anonymous");
                strcpy(s,"Map X");
                for(i = 0; i < 4; ++i){
                        s[4] = (char)('0' + i);
                        SETCTLTEXT(dp,FIRSTMAPNAMEITEM+i,s);
                }
                strcpy(s,"ctl(X)");
                for(i = 0; i < 8; ++i){
                        s[4] = (char)('0' + i);
                        SETCTLTEXT(dp,FIRSTCTLNAMEITEM+i,s);
                }
        }
 
        checksliders_result = checksliders(4,ctls,maps);
        for(i = 4; i--;){
                DISABLEDLGITEM(dp,FIRSTMAPCHECKITEM+i);
                if(maps[i] || (checksliders_result & CHECKSLIDERS_MAP_AMBIGUOUS))
                        CHECKDLGBUTTON(dp,FIRSTMAPCHECKITEM+i,true);
                else
                        HideDialogItem(dp,FIRSTMAPNAMEITEM+i);
        }
        for(i = 8; i--;){
                DISABLEDLGITEM(dp,FIRSTCTLCHECKITEM+i);
                if((ctls[i] || (checksliders_result & CHECKSLIDERS_CTL_AMBIGUOUS)) &&
                   // When map() is activated, we don't need ctl labels,
                   // since the standalone filter will only show map labels
                   !maps[i/2] &&
                   (!(checksliders_result & CHECKSLIDERS_MAP_AMBIGUOUS))
                   )
                        CHECKDLGBUTTON(dp,FIRSTCTLCHECKITEM+i,true);
                else
                        HideDialogItem(dp,FIRSTCTLNAMEITEM+i);
        }
 
        CHECKDLGBUTTON(dp, PROTECTITEM, 0); // TODO: should we remember the last setting?
 
        SELECTDLGITEMTEXT(dp,TITLEITEM,0,-1);
}
 
Boolean containsUnicodeInput(DIALOGREF dp, int item) {
        enum { MAXFIELD = 0x100 };
        char sa[MAXFIELD + 1];
        wchar_t sw[MAXFIELD + 1];
        size_t i;
 
        GetDlgItemTextA(dp, item, sa, MAXFIELD);
        GetDlgItemTextW(dp, item, sw, MAXFIELD);
        for (i = 0; i < strlen(sa); i++) {
                if (((wchar_t)sa[i] != sw[i]) && (sa[i] == '?')) {
                        return true;
                }
        }
 
        return false;
}
 
Boolean containsExtCharset(DIALOGREF dp, int item) {
        enum { MAXFIELD = 0x100 };
        char s[MAXFIELD + 1];
        size_t i;
 
        GetDlgItemTextA(dp, item, s, MAXFIELD);
        for (i = 0; i < strlen(s); i++) {
                if ((unsigned char)s[i] > (unsigned char)0x7F) {
                        return true;
                }
        }
 
        return false;
}
 
/* process an item hit. return false if the dialog is finished; otherwise return true. */
 
Boolean builddlgitem(DIALOGREF dp,int item){
        enum{MAXFIELD=0x100};
        char s[MAXFIELD+1];
        int i,needui;
        TCHAR fname[MAX_PATH + 1];
        StandardFileReply sfr;
        NavReplyRecord reply;
        #ifdef UNICODE
        Boolean unicode;
        #endif
        Boolean extCharset;
 
        switch(item){
#ifdef MAC_ENV
        case ok:
#else
        case IDOK:
#endif
                // Do a few checks first
                GetDlgItemTextA(dp, CATEGORYITEM, s, MAXFIELD);
                if (strlen(s) == 0) {
                        simplealert_id(MSG_CATEGORY_EMPTY_ERR_ID);
                        return true; // don't continue (i.e. don't call EndDialog). Let the user correct the input
                }
                GetDlgItemTextA(dp, TITLEITEM, s, MAXFIELD);
                if (strlen(s) == 0) {
                        simplealert_id(MSG_TITLE_EMPTY_ERR_ID);
                        return true; // don't continue (i.e. don't call EndDialog). Let the user correct the input
                }
 
                // The PiPL and PARM structure does only define single byte charsets
                #ifdef UNICODE
                unicode =
                        containsUnicodeInput(dp, CATEGORYITEM) ||
                        containsUnicodeInput(dp, TITLEITEM) ||
                        containsUnicodeInput(dp, COPYRIGHTITEM) ||
                        containsUnicodeInput(dp, AUTHORITEM);
                #endif
                extCharset =
                        containsExtCharset(dp, CATEGORYITEM) ||
                        containsExtCharset(dp, TITLEITEM) ||
                        containsExtCharset(dp, COPYRIGHTITEM) ||
                        containsExtCharset(dp, AUTHORITEM);
 
                // The AETE structure does only define single byte charsets
                for (i = 0; i < 8; ++i) {
                        if (ctls[i] || (checksliders_result & CHECKSLIDERS_CTL_AMBIGUOUS)) {
                                #ifdef UNICODE
                                unicode |= containsUnicodeInput(dp, FIRSTCTLNAMEITEM + i);
                                #endif
                                extCharset |= containsExtCharset(dp, FIRSTCTLNAMEITEM + i);
                        }
                }
                for (i = 0; i < 4; ++i) {
                        if (maps[i] || (checksliders_result & CHECKSLIDERS_MAP_AMBIGUOUS)) {
                                #ifdef UNICODE
                                unicode |= containsUnicodeInput(dp, FIRSTMAPNAMEITEM + i);
                                #endif
                                extCharset |= containsExtCharset(dp, FIRSTMAPNAMEITEM + i);
                        }
                }
 
                #ifdef UNICODE
                if (unicode) {
                        // "unicode" means that there are characters that will be converted to "?" when converting wchar_t* => char*
                        // Note that this is might be not true if your the characters are mapped in your current default Ansi Charset (e.g. German Umlauts on a German computer)
                        simplewarning_id(MSG_UNICODE_DATA_WARNING_ID);
                }
                else
                #endif
                if (extCharset) {
                        simplewarning_id(MSG_EXTCHARSET_DATA_WARNING_ID);
                }
 
                // Now begin
                memset(&gdata->parm,0,sizeof(PARM_T));
                GetDlgItemTextA(dp,CATEGORYITEM,gdata->parm.szCategory,MAXFIELD-4/*ProtectFlag*/);
                GetDlgItemTextA(dp,TITLEITEM,gdata->parm.szTitle,MAXFIELD);
                GetDlgItemTextA(dp,COPYRIGHTITEM,gdata->parm.szCopyright,MAXFIELD);
                GetDlgItemTextA(dp,AUTHORITEM,gdata->parm.szAuthor,MAXFIELD);
                gdata->parm.cbSize = PARM_SIZE;
                gdata->parm.standalone = 1;  //0=original FF, 1=standalone filter
                needui = 0;
                // Sliders
                for(i = 0; i < 8; ++i){
                        gdata->parm.val[i] = slider[i];
                        gdata->parm.ctl_used[i] = ctls[i] || (checksliders_result & CHECKSLIDERS_CTL_AMBIGUOUS);
                        needui |= gdata->parm.ctl_used[i];
                        GetDlgItemTextA(dp,FIRSTCTLNAMEITEM+i, gdata->parm.szCtl[i],MAXFIELD);
                }
                // Maps
                for (i = 0; i < 4; ++i) {
                        gdata->parm.map_used[i] = maps[i] || (checksliders_result & CHECKSLIDERS_MAP_AMBIGUOUS);
                        needui |= gdata->parm.map_used[i];
                        GetDlgItemTextA(dp, FIRSTMAPNAMEITEM + i, gdata->parm.szMap[i], MAXFIELD);
                }
                // Expressions
                for (i = 0; i < 4; ++i) {
                        if (strlen(expr[i]) >= sizeof(gdata->parm.szFormula[i])) {
                                if (i == 0) {
                                        simplealert_id(MSG_FORMULA_R_1023_TRUNCATED_ID);
                                }
                                else if (i == 1) {
                                        simplealert_id(MSG_FORMULA_G_1023_TRUNCATED_ID);
                                }
                                else if (i == 2) {
                                        simplealert_id(MSG_FORMULA_B_1023_TRUNCATED_ID);
                                }
                                else if (i == 3) {
                                        simplealert_id(MSG_FORMULA_A_1023_TRUNCATED_ID);
                                }
                                expr[i][sizeof(gdata->parm.szFormula[i]) - 1] = '\0';
                        }
                        strcpy(gdata->parm.szFormula[i], expr[i]);
                }
                gdata->parm.popDialog = needui; //true if need to pop a parameter dialog
                gdata->parm.unknown1 = gdata->parm.unknown2 = gdata->parm.unknown3 = 0;
                gdata->parm.iProtected = ISDLGBUTTONCHECKED(dp,PROTECTITEM); // == 1 means protected
                gdata->obfusc = (Boolean)ISDLGBUTTONCHECKED(dp,PROTECTITEM);
 
                GetDlgItemText(dp, TITLEITEM, fname, MAXFIELD);
 
                {
                        TCHAR* tmp1;
                        TCHAR* filters, *title;
                        Boolean makeDlgRet;
 
                        title = (TCHAR*)malloc(1024);
                        if (title == NULL) return false;
 
                        filters = (TCHAR*)malloc(4096);
                        if (filters == NULL) return false;
                        memset(filters, 0, 4096);
                        tmp1 = filters;
 
                        FF_GetMsg(title, MSG_MAKE_FILTER_SETTINGS_TITLE_ID);
 
                        strcpy_advance_id(&tmp1, MSG_MAKE_8BF_ID);
                        strcpy_advance(&tmp1, (TCHAR*)TEXT(" (*.8bf)")); tmp1++;
                        strcpy_advance(&tmp1, (TCHAR*)TEXT("*.8bf")); tmp1++;
 
                        strcpy_advance_id(&tmp1, MSG_ALL_FILES_ID);
                        strcpy_advance(&tmp1, (TCHAR*)TEXT(" (*.*)")); tmp1++;
                        strcpy_advance(&tmp1, (TCHAR*)TEXT("*.*")); tmp1++;
 
                        #ifdef MACMACHO
                        strcat(fname, ".plugin");
                        #endif
 
                        makeDlgRet = putfile(
#ifdef MAC_ENV
                                "\pMake standalone filter", // "\p" means "Pascal string" // TODO (Not important yet): TRANSLATE
                                myc2pstr(_strdup(fname)), // TODO: memory leak?
                                PS_FILTER_FILETYPE, kPhotoshopSignature, &reply, &sfr,
                                "8bf", &filters[0], 1
#else
                                title,
                                fname,
                                PS_FILTER_FILETYPE, kPhotoshopSignature, &reply, &sfr,
                                TEXT("8bf"),
                                &filters[0], 1
                                , (HWND)dp
#endif
                        );
                       
                        free(filters);
                        free(title);
 
                        if (makeDlgRet) {
                                make_standalone(&sfr);
                        }
                        else {
                                return true; // keep going. Let the user correct their input
                        }
                }
 
                return false; // end dialog
#ifdef MAC_ENV
        case cancel:
#else
        case IDCANCEL:
#endif
                return false; // end dialog
        case PROTECTITEM:
                CHECKDLGBUTTON(dp, item, ISDLGBUTTONCHECKED(dp,item) ^ 1);
                break;
        }
 
        return true; // keep going
}
 

Rev 511	Rev 512
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	/* This is PLATFORM INDEPENDENT user interface code - mainly dialog logic */	21	/* This is PLATFORM INDEPENDENT user interface code - mainly dialog logic */
22		22
23	#include "ff.h"	23	#include "ff.h"
24	#include "compat_string.h"	24	#include "compat_string.h"
25		25
26	int ctls[8],maps[4];	26	int ctls[8],maps[4];
27	int checksliders_result;	27	int checksliders_result;
28		28
29	/* one-time initialisation of dialog box */	29	/* one-time initialisation of dialog box */
30		30
31	void builddlginit(DIALOGREF dp){	31	void builddlginit(DIALOGREF dp){
32	int i;	32	int i;
33	char s[0x100];	33	char s[0x100];
34		34
35	if(gdata->parmloaded){	35	if(gdata->parmloaded){
36	SETCTLTEXT(dp,CATEGORYITEM, gdata->parm.szCategory);	36	SETCTLTEXT(dp,CATEGORYITEM, gdata->parm.szCategory);
37	SETCTLTEXT(dp,TITLEITEM, gdata->parm.szTitle);	37	SETCTLTEXT(dp,TITLEITEM, gdata->parm.szTitle);
38	SETCTLTEXT(dp,COPYRIGHTITEM,gdata->parm.szCopyright);	38	SETCTLTEXT(dp,COPYRIGHTITEM,gdata->parm.szCopyright);
39	SETCTLTEXT(dp,AUTHORITEM, gdata->parm.szAuthor);	39	SETCTLTEXT(dp,AUTHORITEM, gdata->parm.szAuthor);
40	for(i=0;i<4;++i){	40	for(i=0;i<4;++i){
41	SETCTLTEXT(dp,FIRSTMAPNAMEITEM+i,gdata->parm.szMap[i]);	41	SETCTLTEXT(dp,FIRSTMAPNAMEITEM+i,gdata->parm.szMap[i]);
42	}	42	}
43	for(i=0;i<8;++i){	43	for(i=0;i<8;++i){
44	SETCTLTEXT(dp,FIRSTCTLNAMEITEM+i,gdata->parm.szCtl[i]);	44	SETCTLTEXT(dp,FIRSTCTLNAMEITEM+i,gdata->parm.szCtl[i]);
45	}	45	}
46	}else{	46	}else{
47	/* strictly speaking this is not needed on the Mac,	47	/* strictly speaking this is not needed on the Mac,
48	we can set initial values statically in the rez description */	48	we can set initial values statically in the rez description */
49	SETCTLTEXT(dp,CATEGORYITEM, "Filter Foundry");	49	SETCTLTEXT(dp,CATEGORYITEM, "Filter Foundry");
50	SETCTLTEXT(dp,TITLEITEM, "Untitled");	50	SETCTLTEXT(dp,TITLEITEM, "Untitled");
51	SETCTLTEXT(dp,COPYRIGHTITEM,""); //"Filter Foundry Copyright (C) 2003-2009 Toby Thain, 2018-" RELEASE_YEAR " Daniel Marschall"	51	SETCTLTEXT(dp,COPYRIGHTITEM,""); //"Filter Foundry Copyright (C) 2003-2009 Toby Thain, 2018-" RELEASE_YEAR " Daniel Marschall"
52	SETCTLTEXT(dp,AUTHORITEM, "Anonymous");	52	SETCTLTEXT(dp,AUTHORITEM, "Anonymous");
53	strcpy(s,"Map X");	53	strcpy(s,"Map X");
54	for(i = 0; i < 4; ++i){	54	for(i = 0; i < 4; ++i){
55	s[4] = (char)('0' + i);	55	s[4] = (char)('0' + i);
56	SETCTLTEXT(dp,FIRSTMAPNAMEITEM+i,s);	56	SETCTLTEXT(dp,FIRSTMAPNAMEITEM+i,s);
57	}	57	}
58	strcpy(s,"ctl(X)");	58	strcpy(s,"ctl(X)");
59	for(i = 0; i < 8; ++i){	59	for(i = 0; i < 8; ++i){
60	s[4] = (char)('0' + i);	60	s[4] = (char)('0' + i);
61	SETCTLTEXT(dp,FIRSTCTLNAMEITEM+i,s);	61	SETCTLTEXT(dp,FIRSTCTLNAMEITEM+i,s);
62	}	62	}
63	}	63	}
64		64
65	checksliders_result = checksliders(4,ctls,maps);	65	checksliders_result = checksliders(4,ctls,maps);
66	for(i = 4; i--;){	66	for(i = 4; i--;){
67	DISABLEDLGITEM(dp,FIRSTMAPCHECKITEM+i);	67	DISABLEDLGITEM(dp,FIRSTMAPCHECKITEM+i);
68	if(maps[i] \|\| (checksliders_result & CHECKSLIDERS_MAP_AMBIGUOUS))	68	if(maps[i] \|\| (checksliders_result & CHECKSLIDERS_MAP_AMBIGUOUS))
69	CHECKDLGBUTTON(dp,FIRSTMAPCHECKITEM+i,true);	69	CHECKDLGBUTTON(dp,FIRSTMAPCHECKITEM+i,true);
70	else	70	else
71	HideDialogItem(dp,FIRSTMAPNAMEITEM+i);	71	HideDialogItem(dp,FIRSTMAPNAMEITEM+i);
72	}	72	}
73	for(i = 8; i--;){	73	for(i = 8; i--;){
74	DISABLEDLGITEM(dp,FIRSTCTLCHECKITEM+i);	74	DISABLEDLGITEM(dp,FIRSTCTLCHECKITEM+i);
75	if((ctls[i] \|\| (checksliders_result & CHECKSLIDERS_CTL_AMBIGUOUS)) &&	75	if((ctls[i] \|\| (checksliders_result & CHECKSLIDERS_CTL_AMBIGUOUS)) &&
76	// When map() is activated, we don't need ctl labels,	76	// When map() is activated, we don't need ctl labels,
77	// since the standalone filter will only show map labels	77	// since the standalone filter will only show map labels
78	!maps[i/2] &&	78	!maps[i/2] &&
79	(!(checksliders_result & CHECKSLIDERS_MAP_AMBIGUOUS))	79	(!(checksliders_result & CHECKSLIDERS_MAP_AMBIGUOUS))
80	)	80	)
81	CHECKDLGBUTTON(dp,FIRSTCTLCHECKITEM+i,true);	81	CHECKDLGBUTTON(dp,FIRSTCTLCHECKITEM+i,true);
82	else	82	else
83	HideDialogItem(dp,FIRSTCTLNAMEITEM+i);	83	HideDialogItem(dp,FIRSTCTLNAMEITEM+i);
84	}	84	}
85		85
86	CHECKDLGBUTTON(dp, PROTECTITEM, 0); // TODO: should we remember the last setting?	86	CHECKDLGBUTTON(dp, PROTECTITEM, 0); // TODO: should we remember the last setting?
87		87
88	SELECTDLGITEMTEXT(dp,TITLEITEM,0,-1);	88	SELECTDLGITEMTEXT(dp,TITLEITEM,0,-1);
89	}	89	}
90		90
91	Boolean containsUnicodeInput(DIALOGREF dp, int item) {	91	Boolean containsUnicodeInput(DIALOGREF dp, int item) {
92	enum { MAXFIELD = 0x100 };	92	enum { MAXFIELD = 0x100 };
93	char s[MAXFIELD + 1];	93	char sa[MAXFIELD + 1];
94	wchar_t sw[MAXFIELD + 1];	94	wchar_t sw[MAXFIELD + 1];
95	size_t i;	95	size_t i;
96		96
97	GetDlgItemTextA(dp, item, s, MAXFIELD);	97	GetDlgItemTextA(dp, item, sa, MAXFIELD);
98	GetDlgItemTextW(dp, item, sw, MAXFIELD);	98	GetDlgItemTextW(dp, item, sw, MAXFIELD);
99	for (i = 0; i < strlen(s); i++) {	99	for (i = 0; i < strlen(sa); i++) {
100	if (((wchar_t)s[i] != sw[i]) && (s[i] == '?')) {	100	if (((wchar_t)sa[i] != sw[i]) && (sa[i] == '?')) {
101	return true;	101	return true;
102	}	102	}
103	}	103	}
104		104
105	return false;	105	return false;
106	}	106	}
107		107
108	Boolean containsExtCharset(DIALOGREF dp, int item) {	108	Boolean containsExtCharset(DIALOGREF dp, int item) {
109	enum { MAXFIELD = 0x100 };	109	enum { MAXFIELD = 0x100 };
110	char s[MAXFIELD + 1];	110	char s[MAXFIELD + 1];
111	size_t i;	111	size_t i;
112		112
113	GetDlgItemTextA(dp, item, s, MAXFIELD);	113	GetDlgItemTextA(dp, item, s, MAXFIELD);
114	for (i = 0; i < strlen(s); i++) {	114	for (i = 0; i < strlen(s); i++) {
115	if ((unsigned char)s[i] > (unsigned char)0x7F) {	115	if ((unsigned char)s[i] > (unsigned char)0x7F) {
116	return true;	116	return true;
117	}	117	}
118	}	118	}
119		119
120	return false;	120	return false;
121	}	121	}
122		122
123	/* process an item hit. return false if the dialog is finished; otherwise return true. */	123	/* process an item hit. return false if the dialog is finished; otherwise return true. */
124		124
125	Boolean builddlgitem(DIALOGREF dp,int item){	125	Boolean builddlgitem(DIALOGREF dp,int item){
126	enum{MAXFIELD=0x100};	126	enum{MAXFIELD=0x100};
127	char s[MAXFIELD+1];	127	char s[MAXFIELD+1];
128	int i,needui;	128	int i,needui;
129	TCHAR fname[MAX_PATH + 1];	129	TCHAR fname[MAX_PATH + 1];
130	StandardFileReply sfr;	130	StandardFileReply sfr;
131	NavReplyRecord reply;	131	NavReplyRecord reply;
132	#ifdef UNICODE	132	#ifdef UNICODE
133	Boolean unicode;	133	Boolean unicode;
134	#endif	134	#endif
135	Boolean extCharset;	135	Boolean extCharset;
136		136
137	switch(item){	137	switch(item){
138	#ifdef MAC_ENV	138	#ifdef MAC_ENV
139	case ok:	139	case ok:
140	#else	140	#else
141	case IDOK:	141	case IDOK:
142	#endif	142	#endif
143	// Do a few checks first	143	// Do a few checks first
144	GetDlgItemTextA(dp, CATEGORYITEM, s, MAXFIELD);	144	GetDlgItemTextA(dp, CATEGORYITEM, s, MAXFIELD);
145	if (strlen(s) == 0) {	145	if (strlen(s) == 0) {
146	simplealert_id(MSG_CATEGORY_EMPTY_ERR_ID);	146	simplealert_id(MSG_CATEGORY_EMPTY_ERR_ID);
147	return true; // don't continue (i.e. don't call EndDialog). Let the user correct the input	147	return true; // don't continue (i.e. don't call EndDialog). Let the user correct the input
148	}	148	}
149	GetDlgItemTextA(dp, TITLEITEM, s, MAXFIELD);	149	GetDlgItemTextA(dp, TITLEITEM, s, MAXFIELD);
150	if (strlen(s) == 0) {	150	if (strlen(s) == 0) {
151	simplealert_id(MSG_TITLE_EMPTY_ERR_ID);	151	simplealert_id(MSG_TITLE_EMPTY_ERR_ID);
152	return true; // don't continue (i.e. don't call EndDialog). Let the user correct the input	152	return true; // don't continue (i.e. don't call EndDialog). Let the user correct the input
153	}	153	}
154		154
155	// The PiPL and PARM structure does only define single byte charsets	155	// The PiPL and PARM structure does only define single byte charsets
156	#ifdef UNICODE	156	#ifdef UNICODE
157	unicode =	157	unicode =
158	containsUnicodeInput(dp, CATEGORYITEM) \|\|	158	containsUnicodeInput(dp, CATEGORYITEM) \|\|
159	containsUnicodeInput(dp, TITLEITEM) \|\|	159	containsUnicodeInput(dp, TITLEITEM) \|\|
160	containsUnicodeInput(dp, COPYRIGHTITEM) \|\|	160	containsUnicodeInput(dp, COPYRIGHTITEM) \|\|
161	containsUnicodeInput(dp, AUTHORITEM);	161	containsUnicodeInput(dp, AUTHORITEM);
162	#endif	162	#endif
163	extCharset =	163	extCharset =
164	containsExtCharset(dp, CATEGORYITEM) \|\|	164	containsExtCharset(dp, CATEGORYITEM) \|\|
165	containsExtCharset(dp, TITLEITEM) \|\|	165	containsExtCharset(dp, TITLEITEM) \|\|
166	containsExtCharset(dp, COPYRIGHTITEM) \|\|	166	containsExtCharset(dp, COPYRIGHTITEM) \|\|
167	containsExtCharset(dp, AUTHORITEM);	167	containsExtCharset(dp, AUTHORITEM);
168		168
169	// The AETE structure does only define single byte charsets	169	// The AETE structure does only define single byte charsets
170	for (i = 0; i < 8; ++i) {	170	for (i = 0; i < 8; ++i) {
171	if (ctls[i] \|\| (checksliders_result & CHECKSLIDERS_CTL_AMBIGUOUS)) {	171	if (ctls[i] \|\| (checksliders_result & CHECKSLIDERS_CTL_AMBIGUOUS)) {
172	#ifdef UNICODE	172	#ifdef UNICODE
173	unicode \|= containsUnicodeInput(dp, FIRSTCTLNAMEITEM + i);	173	unicode \|= containsUnicodeInput(dp, FIRSTCTLNAMEITEM + i);
174	#endif	174	#endif
175	extCharset \|= containsExtCharset(dp, FIRSTCTLNAMEITEM + i);	175	extCharset \|= containsExtCharset(dp, FIRSTCTLNAMEITEM + i);
176	}	176	}
177	}	177	}
178	for (i = 0; i < 4; ++i) {	178	for (i = 0; i < 4; ++i) {
179	if (maps[i] \|\| (checksliders_result & CHECKSLIDERS_MAP_AMBIGUOUS)) {	179	if (maps[i] \|\| (checksliders_result & CHECKSLIDERS_MAP_AMBIGUOUS)) {
180	#ifdef UNICODE	180	#ifdef UNICODE
181	unicode \|= containsUnicodeInput(dp, FIRSTMAPNAMEITEM + i);	181	unicode \|= containsUnicodeInput(dp, FIRSTMAPNAMEITEM + i);
182	#endif	182	#endif
183	extCharset \|= containsExtCharset(dp, FIRSTMAPNAMEITEM + i);	183	extCharset \|= containsExtCharset(dp, FIRSTMAPNAMEITEM + i);
184	}	184	}
185	}	185	}
186		186
187	#ifdef UNICODE	187	#ifdef UNICODE
188	if (unicode) {	188	if (unicode) {
189	// TODO: In this message, we recommend that the user chooses character of his own charset.	189	// "unicode" means that there are characters that will be converted to "?" when converting wchar_t* => char*
190	// BUT: The user should actually only choose A-Z, otherwise stuff might be displayed wrong on foreign computers?!	190	// Note that this is might be not true if your the characters are mapped in your current default Ansi Charset (e.g. German Umlauts on a German computer)
191	simplewarning_id(MSG_UNICODE_DATA_WARNING_ID);	191	simplewarning_id(MSG_UNICODE_DATA_WARNING_ID);
192	}	192	}
193	else	193	else
194	#endif	194	#endif
195	if (extCharset) {	195	if (extCharset) {
196	simplewarning_id(MSG_EXTCHARSET_DATA_WARNING_ID);	196	simplewarning_id(MSG_EXTCHARSET_DATA_WARNING_ID);
197	}	197	}
198		198
199	// Now begin	199	// Now begin
200	memset(&gdata->parm,0,sizeof(PARM_T));	200	memset(&gdata->parm,0,sizeof(PARM_T));
201	GetDlgItemTextA(dp,CATEGORYITEM,gdata->parm.szCategory,MAXFIELD-4/ProtectFlag/);	201	GetDlgItemTextA(dp,CATEGORYITEM,gdata->parm.szCategory,MAXFIELD-4/ProtectFlag/);
202	GetDlgItemTextA(dp,TITLEITEM,gdata->parm.szTitle,MAXFIELD);	202	GetDlgItemTextA(dp,TITLEITEM,gdata->parm.szTitle,MAXFIELD);
203	GetDlgItemTextA(dp,COPYRIGHTITEM,gdata->parm.szCopyright,MAXFIELD);	203	GetDlgItemTextA(dp,COPYRIGHTITEM,gdata->parm.szCopyright,MAXFIELD);
204	GetDlgItemTextA(dp,AUTHORITEM,gdata->parm.szAuthor,MAXFIELD);	204	GetDlgItemTextA(dp,AUTHORITEM,gdata->parm.szAuthor,MAXFIELD);
205	gdata->parm.cbSize = PARM_SIZE;	205	gdata->parm.cbSize = PARM_SIZE;
206	gdata->parm.standalone = 1; //0=original FF, 1=standalone filter	206	gdata->parm.standalone = 1; //0=original FF, 1=standalone filter
207	needui = 0;	207	needui = 0;
208	// Sliders	208	// Sliders
209	for(i = 0; i < 8; ++i){	209	for(i = 0; i < 8; ++i){
210	gdata->parm.val[i] = slider[i];	210	gdata->parm.val[i] = slider[i];
211	gdata->parm.ctl_used[i] = ctls[i] \|\| (checksliders_result & CHECKSLIDERS_CTL_AMBIGUOUS);	211	gdata->parm.ctl_used[i] = ctls[i] \|\| (checksliders_result & CHECKSLIDERS_CTL_AMBIGUOUS);
212	needui \|= gdata->parm.ctl_used[i];	212	needui \|= gdata->parm.ctl_used[i];
213	GetDlgItemTextA(dp,FIRSTCTLNAMEITEM+i, gdata->parm.szCtl[i],MAXFIELD);	213	GetDlgItemTextA(dp,FIRSTCTLNAMEITEM+i, gdata->parm.szCtl[i],MAXFIELD);
214	}	214	}
215	// Maps	215	// Maps
216	for (i = 0; i < 4; ++i) {	216	for (i = 0; i < 4; ++i) {
217	gdata->parm.map_used[i] = maps[i] \|\| (checksliders_result & CHECKSLIDERS_MAP_AMBIGUOUS);	217	gdata->parm.map_used[i] = maps[i] \|\| (checksliders_result & CHECKSLIDERS_MAP_AMBIGUOUS);
218	needui \|= gdata->parm.map_used[i];	218	needui \|= gdata->parm.map_used[i];
219	GetDlgItemTextA(dp, FIRSTMAPNAMEITEM + i, gdata->parm.szMap[i], MAXFIELD);	219	GetDlgItemTextA(dp, FIRSTMAPNAMEITEM + i, gdata->parm.szMap[i], MAXFIELD);
220	}	220	}
221	// Expressions	221	// Expressions
222	for (i = 0; i < 4; ++i) {	222	for (i = 0; i < 4; ++i) {
223	if (strlen(expr[i]) >= sizeof(gdata->parm.szFormula[i])) {	223	if (strlen(expr[i]) >= sizeof(gdata->parm.szFormula[i])) {
224	if (i == 0) {	224	if (i == 0) {
225	simplealert_id(MSG_FORMULA_R_1023_TRUNCATED_ID);	225	simplealert_id(MSG_FORMULA_R_1023_TRUNCATED_ID);
226	}	226	}
227	else if (i == 1) {	227	else if (i == 1) {
228	simplealert_id(MSG_FORMULA_G_1023_TRUNCATED_ID);	228	simplealert_id(MSG_FORMULA_G_1023_TRUNCATED_ID);
229	}	229	}
230	else if (i == 2) {	230	else if (i == 2) {
231	simplealert_id(MSG_FORMULA_B_1023_TRUNCATED_ID);	231	simplealert_id(MSG_FORMULA_B_1023_TRUNCATED_ID);
232	}	232	}
233	else if (i == 3) {	233	else if (i == 3) {
234	simplealert_id(MSG_FORMULA_A_1023_TRUNCATED_ID);	234	simplealert_id(MSG_FORMULA_A_1023_TRUNCATED_ID);
235	}	235	}
236	expr[i][sizeof(gdata->parm.szFormula[i]) - 1] = '\0';	236	expr[i][sizeof(gdata->parm.szFormula[i]) - 1] = '\0';
237	}	237	}
238	strcpy(gdata->parm.szFormula[i], expr[i]);	238	strcpy(gdata->parm.szFormula[i], expr[i]);
239	}	239	}
240	gdata->parm.popDialog = needui; //true if need to pop a parameter dialog	240	gdata->parm.popDialog = needui; //true if need to pop a parameter dialog
241	gdata->parm.unknown1 = gdata->parm.unknown2 = gdata->parm.unknown3 = 0;	241	gdata->parm.unknown1 = gdata->parm.unknown2 = gdata->parm.unknown3 = 0;
242	gdata->parm.iProtected = ISDLGBUTTONCHECKED(dp,PROTECTITEM); // == 1 means protected	242	gdata->parm.iProtected = ISDLGBUTTONCHECKED(dp,PROTECTITEM); // == 1 means protected
243	gdata->obfusc = (Boolean)ISDLGBUTTONCHECKED(dp,PROTECTITEM);	243	gdata->obfusc = (Boolean)ISDLGBUTTONCHECKED(dp,PROTECTITEM);
244		244
245	GetDlgItemText(dp, TITLEITEM, fname, MAXFIELD);	245	GetDlgItemText(dp, TITLEITEM, fname, MAXFIELD);
246		246
247	{	247	{
248	TCHAR* tmp1;	248	TCHAR* tmp1;
249	TCHAR* filters, *title;	249	TCHAR* filters, *title;
250	Boolean makeDlgRet;	250	Boolean makeDlgRet;
251		251
252	title = (TCHAR*)malloc(1024);	252	title = (TCHAR*)malloc(1024);
253	if (title == NULL) return false;	253	if (title == NULL) return false;
254		254
255	filters = (TCHAR*)malloc(4096);	255	filters = (TCHAR*)malloc(4096);
256	if (filters == NULL) return false;	256	if (filters == NULL) return false;
257	memset(filters, 0, 4096);	257	memset(filters, 0, 4096);
258	tmp1 = filters;	258	tmp1 = filters;
259		259
260	FF_GetMsg(title, MSG_MAKE_FILTER_SETTINGS_TITLE_ID);	260	FF_GetMsg(title, MSG_MAKE_FILTER_SETTINGS_TITLE_ID);
261		261
262	strcpy_advance_id(&tmp1, MSG_MAKE_8BF_ID);	262	strcpy_advance_id(&tmp1, MSG_MAKE_8BF_ID);
263	strcpy_advance(&tmp1, (TCHAR)TEXT(" (.8bf)")); tmp1++;	263	strcpy_advance(&tmp1, (TCHAR)TEXT(" (.8bf)")); tmp1++;
264	strcpy_advance(&tmp1, (TCHAR)TEXT(".8bf")); tmp1++;	264	strcpy_advance(&tmp1, (TCHAR)TEXT(".8bf")); tmp1++;
265		265
266	strcpy_advance_id(&tmp1, MSG_ALL_FILES_ID);	266	strcpy_advance_id(&tmp1, MSG_ALL_FILES_ID);
267	strcpy_advance(&tmp1, (TCHAR)TEXT(" (.*)")); tmp1++;	267	strcpy_advance(&tmp1, (TCHAR)TEXT(" (.*)")); tmp1++;
268	strcpy_advance(&tmp1, (TCHAR)TEXT(".*")); tmp1++;	268	strcpy_advance(&tmp1, (TCHAR)TEXT(".*")); tmp1++;
269		269
270	#ifdef MACMACHO	270	#ifdef MACMACHO
271	strcat(fname, ".plugin");	271	strcat(fname, ".plugin");
272	#endif	272	#endif
273		273
274	makeDlgRet = putfile(	274	makeDlgRet = putfile(
275	#ifdef MAC_ENV	275	#ifdef MAC_ENV
276	"\pMake standalone filter", // "\p" means "Pascal string" // TODO (Not important yet): TRANSLATE	276	"\pMake standalone filter", // "\p" means "Pascal string" // TODO (Not important yet): TRANSLATE
277	myc2pstr(_strdup(fname)), // TODO: memory leak?	277	myc2pstr(_strdup(fname)), // TODO: memory leak?
278	PS_FILTER_FILETYPE, kPhotoshopSignature, &reply, &sfr,	278	PS_FILTER_FILETYPE, kPhotoshopSignature, &reply, &sfr,
279	"8bf", &filters[0], 1	279	"8bf", &filters[0], 1
280	#else	280	#else
281	title,	281	title,
282	fname,	282	fname,
283	PS_FILTER_FILETYPE, kPhotoshopSignature, &reply, &sfr,	283	PS_FILTER_FILETYPE, kPhotoshopSignature, &reply, &sfr,
284	TEXT("8bf"),	284	TEXT("8bf"),
285	&filters[0], 1	285	&filters[0], 1
286	, (HWND)dp	286	, (HWND)dp
287	#endif	287	#endif
288	);	288	);
289		289
290	free(filters);	290	free(filters);
291	free(title);	291	free(title);
292		292
293	if (makeDlgRet) {	293	if (makeDlgRet) {
294	make_standalone(&sfr);	294	make_standalone(&sfr);
295	}	295	}
296	else {	296	else {
297	return true; // keep going. Let the user correct their input	297	return true; // keep going. Let the user correct their input
298	}	298	}
299	}	299	}
300		300
301	return false; // end dialog	301	return false; // end dialog
302	#ifdef MAC_ENV	302	#ifdef MAC_ENV
303	case cancel:	303	case cancel:
304	#else	304	#else
305	case IDCANCEL:	305	case IDCANCEL:
306	#endif	306	#endif
307	return false; // end dialog	307	return false; // end dialog
308	case PROTECTITEM:	308	case PROTECTITEM:
309	CHECKDLGBUTTON(dp, item, ISDLGBUTTONCHECKED(dp,item) ^ 1);	309	CHECKDLGBUTTON(dp, item, ISDLGBUTTONCHECKED(dp,item) ^ 1);
310	break;	310	break;
311	}	311	}
312		312
313	return true; // keep going	313	return true; // keep going
314	}	314	}
315		315

Subversion Repositories filter_foundry

filter_foundry/trunk/ui_build.c – Rev 511 → 512