Subversion Repositories filter_foundry

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.         This file is part of "Filter Foundry", a filter plugin for Adobe Photoshop
  3.     Copyright (C) 2002-3 Toby Thain, toby@telegraphics.com.au
  4.  
  5.     This program is free software; you can redistribute it and/or modify
  6.     it under the terms of the GNU General Public License as published by  
  7.     the Free Software Foundation; either version 2 of the License, or
  8.     (at your option) any later version.
  9.  
  10.     This program is distributed in the hope that it will be useful,
  11.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.     GNU General Public License for more details.
  14.  
  15.     You should have received a copy of the GNU General Public License  
  16.     along with this program; if not, write to the Free Software
  17.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18. */
  19.  
  20. /* This is PLATFORM INDEPENDENT user interface code - mainly dialog logic */
  21.  
  22. #include "ff.h"
  23.  
  24. #include "node.h"
  25. #include "parser.h"
  26. #include "funcs.h"
  27. #include "y.tab.h"
  28. #include "choosefile.h"
  29.  
  30. #ifdef macintosh
  31.         #define GETSLIDERVALUE GetDlgControlValue
  32.         #define SETSLIDERVALUE SetDlgControlValue
  33. #else
  34.         #include <commctrl.h>
  35.         #define GETSLIDERVALUE(d,i) SendDlgItemMessage(d,i,TBM_GETPOS,0,0)
  36.         #define SETSLIDERVALUE(d,i,v) SendDlgItemMessage(d,i,TBM_SETPOS,TRUE,v)
  37. #endif
  38.  
  39. Boolean doupdates = true;
  40.  
  41. void updateglobals(DIALOGREF dp);
  42. struct node *doexpr(DIALOGREF dp,int i);
  43. void updatedialog(DIALOGREF dp);
  44. void slidertextchanged(DIALOGREF dp,int item);
  45.  
  46. void updatedialog(DIALOGREF dp){
  47.         int i;
  48.  
  49.         doupdates = false;
  50.  
  51.         for( i=0 ; i<8 ; ++i ){
  52.                 SETSLIDERVALUE(dp,FIRSTCTLITEM+i,slider[i]);
  53.                 SetDlgItemInt(dp,FIRSTCTLTEXTITEM+i,slider[i],false);
  54.         }
  55.         for( i=0 ; i<4 ; ++i ){
  56.                 SetDlgItemText(dp,FIRSTEXPRITEM+i,expr[i] ? expr[i] : "oups! expr[i] is nil!");
  57.                 if(i<nplanes)
  58.                         doexpr(dp,FIRSTEXPRITEM+i);
  59.         }
  60.  
  61.         SELECTDLGITEMTEXT(dp,FIRSTEXPRITEM,0,-1);
  62.  
  63.         doupdates = true;
  64. }
  65.  
  66. /* copy dialog settings to global variables (sliders, expressions) */
  67.  
  68. void updateglobals(DIALOGREF dp){
  69.         int i,j;
  70.         char s[MAXEXPR+1];
  71.  
  72.         for( i=0 ; i<8 ; ++i )
  73.                 slider[i] = GETSLIDERVALUE(dp,FIRSTCTLITEM+i);
  74.  
  75.         for( i=0 ; i<4 ; ++i ){
  76.                 /* stash expression strings */
  77.                 if(GetDlgItemText(dp,FIRSTEXPRITEM+i,s,MAXEXPR)){
  78.                         if(expr[i])
  79.                                 free(expr[i]);
  80.                         if(!(expr[i] = my_strdup(s)))
  81.                                 dbg("updateglobals: my_strdup returned zero??");
  82.                 }else
  83.                         dbg("updateglobals: GetDlgItemText returned zero??");
  84.         }
  85. }
  86.  
  87. struct node *doexpr(DIALOGREF dp,int i){
  88.         char s[MAXEXPR+1];
  89.  
  90. //dbg("doexpr");
  91.         GetDlgItemText(dp,i,s,MAXEXPR);
  92.         i -= FIRSTEXPRITEM;
  93.         freetree(tree[i]);
  94.         if(tree[i] = parseexpr(s))
  95.                 HideDialogItem(dp,FIRSTICONITEM+i);
  96.         else{
  97.                 err[i] = errstr;
  98.                 errstart[i] = tokstart;
  99.                 errpos[i] = tokpos;
  100.                 ShowDialogItem(dp,FIRSTICONITEM+i);
  101.         }
  102.         return tree[i];
  103. }
  104.  
  105. /* traverse expression tree, looking for constant references to sliders */
  106.  
  107. int checksl(struct node*p,int flags[]);
  108. int checksl(struct node*p,int flags[]){
  109.         if(p){
  110.                 int s;
  111.                 if( (p->kind==TOK_FN1 && p->v.sym->fn == (pfunc_type)ff_ctl)
  112.                  || (p->kind==TOK_FN3 && p->v.sym->fn == (pfunc_type)ff_val) ){
  113.                         if(p->child[0]->kind == TOK_NUM){
  114.                                 s = p->child[0]->v.value;
  115.                                 if(s>=0 && s<=7)
  116.                                         flags[s] = 1;
  117.                         }else
  118.                                 return true; /* can't determine which slider */
  119.                 }else if( p->kind==TOK_FN2 && p->v.sym->fn == (pfunc_type)ff_map )
  120.                         if(p->child[0]->kind == TOK_NUM){
  121.                                 s = p->child[0]->v.value;
  122.                                 if(s>=0 && s<=3)
  123.                                         flags[s*2] = flags[s*2+1] = 1;
  124.                         }else
  125.                                 return true; /* can't determine which slider */
  126.  
  127.                 return checksl(p->child[0],flags)
  128.                         || checksl(p->child[1],flags)
  129.                         || checksl(p->child[2],flags)
  130.                         || checksl(p->child[3],flags)
  131.                         || checksl(p->child[4],flags); 
  132.         }else return false;
  133. }
  134.  
  135. void checksliders(DIALOGREF dp);
  136. void checksliders(DIALOGREF dp){
  137.         int i,f[8] = {0,0,0,0,0,0,0,0},unknown;
  138.  
  139.         for(i=0;i<nplanes;i++)
  140.                 if(checksl(tree[i],f))
  141.                         break;
  142.  
  143.         unknown = i < nplanes;
  144.         for(i=0;i<8;i++)
  145.                 if(unknown || f[i]){
  146.                         ENABLECONTROL(dp,FIRSTCTLITEM+i);
  147.                         ShowDialogItem(dp,FIRSTCTLTEXTITEM+i);
  148.                 }else{
  149.                         DISABLECONTROL(dp,FIRSTCTLITEM+i);
  150.                         HideDialogItem(dp,FIRSTCTLTEXTITEM+i);
  151.                 }
  152. }
  153.  
  154. void slidermoved(DIALOGREF dp,int i){
  155.         int v = GETSLIDERVALUE(dp,i);
  156.         i -= FIRSTCTLITEM;
  157.         slider[i] = v;
  158.         SetDlgItemInt(dp,i+FIRSTCTLTEXTITEM,v,false);
  159. }
  160.  
  161. void slidertextchanged(DIALOGREF dp,int i){
  162.         int v = GetDlgItemInt(dp,i,NULL,false);
  163.         i -= FIRSTCTLTEXTITEM;
  164.         SETSLIDERVALUE(dp,i+FIRSTCTLITEM,v);
  165.         slider[i] = v;
  166. }
  167.  
  168. void maindlgupdate(DIALOGREF dp){
  169.         int i;
  170.  
  171.         checksliders(dp);
  172.  
  173.         for( i=0 ; i<nplanes && tree[i] ; i++ )
  174.                 ;
  175.  
  176.         if(i==nplanes){
  177.                 updateglobals(dp);
  178.                 if(setup(gpb))
  179.                         recalc_preview(gpb,dp);
  180.  
  181.                 ENABLECONTROL(dp,IDOK);
  182.         }else
  183.                 DISABLECONTROL(dp,IDOK);
  184. }
  185.  
  186. /* one-time initialisation of dialog box */
  187.  
  188. void maindlginit(DIALOGREF dp){
  189.         int i;
  190.        
  191.         /* hide unused expression items */
  192.         for(i=nplanes;i<4;++i){
  193.                 HideDialogItem(dp,FIRSTICONITEM+i);
  194.                 HideDialogItem(dp,FIRSTEXPRITEM+i);
  195.                 HideDialogItem(dp,FIRSTLABELITEM+i);
  196.         }
  197. //      DISABLECONTROL(dp,MAKEITEM);
  198.  
  199.         setup_preview(gpb);
  200.         updatedialog(dp);
  201.         maindlgupdate(dp);
  202. }
  203.  
  204.  
  205. /* process an item hit. return false if the dialog is finished; otherwise return true. */
  206.  
  207. Boolean maindlgitem(DIALOGREF dp,int item){
  208.         int i,j;
  209.         StandardFileReply sfr;
  210.         NavReplyRecord reply;
  211.         static char filefilters[]="Filter Factory settings\0*.TXT;*.AFS\0\0";
  212.  
  213.         switch(item){
  214.         case IDOK:     
  215.                 updateglobals(dp);
  216.         case IDCANCEL:
  217.                 dispose_preview();
  218.                 return false; // end dialog
  219.         case OPENITEM:
  220.                 if(choosefile("\pChoose filter settings",&sfr,&reply,'TEXT',filefilters)
  221.                                 && readfile(&sfr)){
  222.                         updatedialog(dp);
  223.                         maindlgupdate(dp);
  224.                 }
  225.                 break;
  226.         case SAVEITEM:
  227.                 if(putfile("\pSave filter settings","\p",'TEXT',SIG_SIMPLETEXT,&reply,&sfr)){
  228.                         updateglobals(dp);
  229.                         if(savefile(&sfr))
  230.                                 completesave(&reply);
  231.                 }
  232.                 break;
  233.         /*case PREVIEWITEM:
  234.                 trackpreview();
  235.                 break;*/
  236.         case FIRSTCTLITEM:
  237.         case FIRSTCTLITEM+1:
  238.         case FIRSTCTLITEM+2:
  239.         case FIRSTCTLITEM+3:
  240.         case FIRSTCTLITEM+4:
  241.         case FIRSTCTLITEM+5:
  242.         case FIRSTCTLITEM+6:
  243.         case FIRSTCTLITEM+7:
  244.                 slidermoved(dp,item);
  245.                 recalc_preview(gpb,dp);
  246.                 break;
  247.         case FIRSTCTLTEXTITEM:
  248.         case FIRSTCTLTEXTITEM+1:
  249.         case FIRSTCTLTEXTITEM+2:
  250.         case FIRSTCTLTEXTITEM+3:
  251.         case FIRSTCTLTEXTITEM+4:
  252.         case FIRSTCTLTEXTITEM+5:
  253.         case FIRSTCTLTEXTITEM+6:
  254.         case FIRSTCTLTEXTITEM+7:
  255.                 slidertextchanged(dp,item);
  256.                 recalc_preview(gpb,dp);
  257.                 break;
  258.         case FIRSTICONITEM:
  259.         case FIRSTICONITEM+1:
  260.         case FIRSTICONITEM+2:
  261.         case FIRSTICONITEM+3:
  262.                 item -= FIRSTICONITEM;
  263.                 alertuser(err[item],"");
  264.                 SELECTDLGITEMTEXT(dp,FIRSTEXPRITEM+item,errstart[item],errpos[item]);
  265.                 break;
  266.         case FIRSTEXPRITEM:
  267.         case FIRSTEXPRITEM+1:
  268.         case FIRSTEXPRITEM+2:
  269.         case FIRSTEXPRITEM+3:
  270.                 if( (item-FIRSTEXPRITEM)<nplanes ){
  271.                         doexpr(dp,item);
  272.                         maindlgupdate(dp);
  273.                 }
  274.                 break;
  275.         }
  276.  
  277.         return true; // keep going
  278. }
  279.  
  280. Boolean alertuser(char *err,char *more){
  281.         char *s = malloc(strlen(err)+strlen(more)+2),*q;
  282.         Boolean res;
  283.        
  284.         q = cat(s,err);
  285.         if(more){
  286.                 *q++ = '\n';
  287.                 q = cat(q,more);
  288.         }
  289.         *q = 0;
  290.         res = simplealert(s);
  291.         free(s);
  292.         return res;
  293. }
  294.