Subversion Repositories filter_foundry

Rev

Rev 442 | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1. /*
  2.     This file is part of "Filter Foundry", a filter plugin for Adobe Photoshop
  3.     Copyright (C) 2003-2009 Toby Thain, toby@telegraphics.net
  4.     Copyright (C) 2018-2021 Daniel Marschall, ViaThinkSoft
  5.  
  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
  8.     the Free Software Foundation; either version 2 of the License, or
  9.     (at your option) any later version.
  10.  
  11.     This program is distributed in the hope that it will be useful,
  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.     GNU General Public License for more details.
  15.  
  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
  18.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19. */
  20.  
  21. #ifndef SCRIPTING_H_
  22. #define SCRIPTING_H_
  23.  
  24. /* Portions Copyright 1993 - 1999 Adobe Systems Incorporated */
  25. /* All Rights Reserved.                                      */
  26.  
  27. //#include <stddef.h>                     // Standard definitions.
  28. //#include <Types.h>                    // Standard types.
  29.  
  30. //#include "PITypes.h"                    // Photoshop types.
  31. //#include "PIGeneral.h"                  // Photoshop general routines.
  32. //#include "PIActions.h"                  // Photoshop scripting.
  33. //#include "PIAbout.h"                    // AboutRecord structure.
  34. //#include "PIFormat.h"                   // AboutRecord structure.
  35. //#include "PIDefines.h"                // Plug-in definitions.
  36. //#include "FileUtilities.h"            // Simple file utilities.
  37.  
  38. Boolean HostDescriptorAvailable (PIDescriptorParameters *procs,
  39.                                  Boolean *outNewerVersion);
  40.  
  41. OSErr HostCloseReader (PIDescriptorParameters *procs,
  42.                        HandleProcs *hProcs,
  43.                        PIReadDescriptor *token);
  44.  
  45. OSErr HostCloseWriter(PIDescriptorParameters *procs,
  46.                       HandleProcs *hProcs,
  47.                       PIWriteDescriptor *token);
  48.  
  49. OSErr put_cstring(PIWriteDescriptor token, DescriptorKeyID key, char *s);
  50.  
  51. char *get_cstring(PIReadDescriptor token);
  52.  
  53. enum ScriptingShowDialog {
  54.         SCR_NO_SCRIPT,
  55.         SCR_SHOW_DIALOG,
  56.         SCR_HIDE_DIALOG
  57. };
  58.  
  59. enum ScriptingShowDialog ReadScriptParamsOnRead(void);
  60.  
  61. OSErr WriteScriptParamsOnRead(void);
  62.  
  63. OSType getAeteKey(char c, PARM_T *parm);
  64.  
  65. //-------------------------------------------------------------------------------
  66. //      PIDescriptorParameters -- Macro definitions
  67. //-------------------------------------------------------------------------------
  68.  
  69. #define NULLID          0 // for ID routines needing null terminator
  70.  
  71. #define DescParams      gpb->descriptorParameters
  72.  
  73. #define Reader          DescParams->readDescriptorProcs
  74.  
  75. #define Writer          DescParams->writeDescriptorProcs
  76.  
  77. #define PlayInfo        DescParams->playInfo
  78.  
  79. #define RecordInfo      DescParams->recordInfo
  80.  
  81. #define PlayDialog() \
  82.         HostPlayDialog (DescParams)
  83.  
  84. #define DescriptorAvailable(outNewerVersion) \
  85.         HostDescriptorAvailable(DescParams, outNewerVersion)
  86.  
  87. #define WarnDescriptorAvailable() \
  88.         WarnHostDescriptorAvailable(DescParams, hDllInstance)
  89.  
  90. #define OpenReadDesc(desc, array) \
  91.         Reader->openReadDescriptorProc(desc, array)
  92.  
  93. #define OpenReader(array) \
  94.         OpenReadDesc(DescParams->descriptor, array)
  95.  
  96. #define CloseReadDesc(token) \
  97.         Reader->closeReadDescriptorProc(token)
  98.  
  99. #define CloseReader(token) \
  100.         HostCloseReader(DescParams, gpb->handleProcs, token)
  101.  
  102. #define OpenWriter() \
  103.         Writer->openWriteDescriptorProc()
  104.  
  105. #define CloseWriteDesc(token, handle) \
  106.         Writer->closeWriteDescriptorProc(token, handle)
  107.  
  108. #define CloseWriter(token) \
  109.         HostCloseWriter(DescParams, gpb->handleProcs, token)
  110.  
  111. // These Macros simplify access to all the basic Get and Put routines:
  112.  
  113. #define PIGetKey(token, key, type, flags) \
  114.         Reader->getKeyProc(token, key, type, flags)
  115.  
  116. #define PIGetEnum(token, value) \
  117.         Reader->getEnumeratedProc(token, value)
  118.  
  119. #define PIPutEnum(token, key, type, value) \
  120.         Writer->putEnumeratedProc(token, key, type, value)
  121.  
  122. #define PIGetInt(token, value) \
  123.         Reader->getIntegerProc(token, value)
  124.  
  125. #define PIGetPinInt(token, min, max, value) \
  126.         Reader->getPinnedIntegerProc(token, min, max, value)
  127.  
  128. #define PIPutInt(token, key, value) \
  129.         Writer->putIntegerProc(token, key, value)
  130.  
  131. #define PIGetFloat(token, value) \
  132.         Reader->getFloatProc(token, value)
  133.  
  134. #define PIGetPinFloat(token, min, max, value) \
  135.         Reader->getPinnedFloatProc(token, min, max, value)
  136.  
  137. #define PIPutFloat(token, key, value) \
  138.         Writer->putFloatProc(token, key, value)
  139.  
  140. #define PIGetUnitFloat(token, unit, value) \
  141.         Reader->getUnitFloatProc(token, unit, value)
  142.  
  143. #define PIGetPinUnitFloat(token, min, max, unit, value) \
  144.         Reader->getPinnedUnitFloatProc(token, min, max, unit, value)
  145.  
  146. #define PIPutUnitFloat(token, key, unit, value) \
  147.         Writer->putUnitFloatProc(token, key, unit, value)
  148.  
  149. #define PIGetBool(token, value) \
  150.         Reader->getBooleanProc(token, value)
  151.  
  152. #define PIPutBool(token, key, value) \
  153.         Writer->putBooleanProc(token, key, value)
  154.  
  155. #define PIGetText(token, value) \
  156.         Reader->getTextProc(token, value)
  157.  
  158. #define PIPutText(token, key, value) \
  159.         Writer->putTextProc(token, key, value)
  160.  
  161. #define PIGetAlias(token, value) \
  162.         Reader->getAliasProc(token, value)
  163.  
  164. #define PIPutAlias(token, key, value) \
  165.         Writer->putAliasProc(token, key, value)
  166.  
  167. #define PIGetEnum(token, value) \
  168.         Reader->getEnumeratedProc(token, value)
  169.  
  170. #define PIPutEnum(token, key, type, value) \
  171.         Writer->putEnumeratedProc(token, key, type, value)
  172.  
  173. #define PIGetClass(token, value) \
  174.         Reader->getClassProc(token, value)
  175.  
  176. #define PIPutClass(token, key, value) \
  177.         Writer->putClassProc(token, key, value)
  178.  
  179. #define PIGetRef(token, value) \
  180.         Reader->getSimpleReferenceProc(token,value)
  181.  
  182. #define PIPutRef(token, key, value) \
  183.         Writer->putSimpleReferenceProc(token, key, value)
  184.  
  185. #define PIGetObj(token, type, value) \
  186.         Reader->getObjectProc(token, type, value)
  187.  
  188. #define PIPutObj(token, key, type, value) \
  189.         HostPutObj(DescParams, gpb->handleProcs, token, key, type, value)
  190.  
  191. #define PIPutObjProc(token, key, type, value) \
  192.         Writer->putObjectProc(token, key, type, value)
  193.  
  194. #define PIGetCount(token, value) \
  195.         Reader->getCountProc(token, value)
  196.  
  197. #define PIPutCount(token, key, value) \
  198.         Writer->putCountProc(token, key, value)
  199.  
  200. #define PIGetStr(token, value) \
  201.         Reader->getStringProc(token, value)
  202.  
  203. #define PIPutStr(token, key, value) \
  204.         Writer->putStringProc(token, key, value)
  205.  
  206. #endif
  207.