FileMaker version 12 or higher.
When 360Plugins are intialized for the first time, they will automatically download all required support files
Drag the plugin from the MAC or WIN folder into your FileMaker extensions, and restart FileMaker.
If the plugin does not load correctly, please send an email to support@360works.com
Install plug-ins for use with WebDirect by dragging the appropriate plugin to FileMaker Server/Web Publishing/publishing-engine/cwpc/Plugins
You do not need to do this step unless you plan on using the plugin with Instant Web Publishing with FileMaker Server Advanced.
For installing into the Web Publishing Engine with FileMaker Server or FileMaker Server Advanced, drag the plugin from the MAC or WIN(.fmx) folder into the FileMaker Server/Web Publishing/publishing-engine/wpc/Plugins folder. If there is no Plugins folder inside the wpc folder, then create it manually. Restart FileMaker Web Publishing, and now the plugins should be ready to go.
The easiest way to test whether the plugin is working is to call the version function of the plugin, and display that on an IWP layout. If it shows "?", then the plugin is not working. If it shows a number, then the plugin has been installed successfully.
If you are using FileMaker Server 12.0v1, you can follow the same procedure as detailed above for custom web publishing. However, in FileMaker Server 12.0v2 and later, custom web publishing now runs as a 64-bit application and requires the 64-bit version of the plugin
For Mac, the single plug-in file in the MAC directory contains both 32-bit and 64-bit versions. For Windows, look for the plug-in that has the extension .fmx64 and use it in exclusively in custom web publishing.
To install 64-bit plug-ins, install either the .fmx64 or the .fmplugin to the following directory:
FileMaker Server / Web Publishing / publishing-engine / cwpc / Plugins
If it does not exist, create the Plugin folder manually. Restart FileMaker Web Publishing, and then you can then test a script that contains a plug-in and see if it returns the correct values.
You do not need to do this step unless you plan on using the plugin with scheduled script triggering.
360Works has created an AutoUpdate helper database which makes setting up AutoUpdate much easier. This file includes pre-configured plugin files which you can place on your server, and an AutoUpdate script for each of our plugins which you can paste into your own solution.
You can get the AutoUpdate360Works file here Follow the instructions included in the file to either host your own Auto Update server or pull the files from ours.
Plugins will run in demo mode until they are registered. While running in Demo mode, the product will run for 2 hours every time you launch FileMaker / FileMaker Server / FileMaker Web Publishing Engine. The 2 hour time limit will reset every time you relaunch FileMaker. There is no expiration date when Demo mode stops working. There are no feature differences between the Demo version and the licensed version.
Once you have purchased the plugin, you can register it with the license key. Once a valid license key is entered, the product will run for as long as FileMaker is running. After FileMaker starts up with the plugin installed, open FileMaker preferences, click on the Plug-ins tab, select the plugin from the list, and click the Configure button. Enter your license key and company name in this dialog. You will only need to do this once on a given machine. Alternately, you can use the registration function to register the plugin during a startup script.
Note: If you are running the plugin with FileMaker Server / FileMaker Web Publishing Engine, you must use the registration function to register the plugin, since there is no preferences dialog on FileMaker Server to enter the license key and company name. You will need to call the register function at the beginning of any script that is going to call plugin functions. This will ensure that you do not get demo mode errors.
We love to hear your suggestions for improving our products! If you are experiencing problems with this plugin, or have a feature request, or are happy with it, we'd appreciate hearing about it. Send us a message on our website, or email us!
When calling plugin functions as script steps, you will handle errors in the same manner you would any other FileMaker script step. Please see the FileMaker documentation for how to handle errors appropriately. Generally, if there is an error, our plugins will return an error code of 1552 when Get(LastError) is called. However, some plugin functions will return different error codes. If a function can return an error code other than a 1552, it will be documented with the description of the function below. In addition to the error code, you can also get the description of the error by calling Get(LastExternalErrorDetail). Please note that if you are using FileMaker 19.6 or later then this function has been renamed to Get(LastErrorDetail)
You can also call our functions in a calculation dialog. In this case, error handling is done differently. If you decide to call plugin functions in a calculation dialog and you want to capture errors, see this page page for instruction on how to do so
Note: FileMaker 18 requires plugins to be signed in order to work correctly. This directly impacts custom plugins made with ScriptMaster. For more information see here: ScriptMaster Documentation
ScriptMaster is a free, general-purpose, modular plugin. It includes modules for file manipulation (reading, writing, copying, deleting, zipping/unzipping, and moving files on the hard drive); downloading URLs and submitting forms online; XML Web Services; shell scripting; and many others including screen capture, encryption, SQL access and clipboard access. Modules for ScriptMaster are written in a programming language called Groovy, which is very similar to Java. Because they are so similar, we often use the terms Java and Groovy interchangeably in this documentation, although it is more technically accurate to refer to it as Groovy. You do not need to be a Java programmer to use ScriptMaster, but if you are, you can write your own modules or enhance the ones that come with it.
ScriptMaster modules work just like FileMaker custom functions: You pass in some inputs and get back an output. They appear in your FileMaker function list, just like custom functions.
In other ways, however, they improve on what you can do with custom functions. Custom functions only allow you to do things you can already do with features built into FileMaker, but ScriptMaster modules can access all of the power in the Java language and class libraries. It's also easier to share ScriptMaster modules across all of your FileMaker files than sharing custom functions, because custom functions must be duplicated into every FileMaker file, while ScriptMaster modules are available to every file running in FileMaker.
To get started with ScriptMaster, install the ScriptMaster plugin by copying it into your FileMaker extensions directory (complete installation instructions can be found below). Then open the ScriptMaster.fmp12 file that comes with it. At the top, click on 'ScriptMaster Modules' which will show you a list of all of the modules that come with ScriptMaster listed in order by Category. To try one out, click on it in the list view. 'Screen Capture' under the 'Containers' Category is a good one to start with. This module will take a picture of some section of your screen and store it into a container field in FileMaker. You supply parameters for left, top, width, and height, which tells the module which section of your screen to capture. This is a good module to start with because the Java code is very short and easy to understand, and it also demonstrates how to work with data in container fields. Click the 'Run Script' button with the green arrow to run the module, which will run the module based on the values set for the input variables. After you run this, you should see a screen shot in the result area at the bottom of the screen (click on 'Enlarge' to see the full screen shot). Experiment with changing the inputs (left, top, width, and height) to see the result, and try out some of the other modules that come with ScriptMaster.
The 'Run Script' button is a very easy way to try out modules in the development file, but it's not how you would use it within your own FileMaker solution. For that, we'll talk about registering this module as a function, which makes the module appear in your list of available FileMaker functions. Because it compiles the code, it will also run much faster as a registered function than by using the 'Run Script' button. To register a module, simply click the 'Register Function' button at the bottom of any module's screen. This compiles the code for the module, adds it to the list of available FileMaker functions, and takes you to a screen showing that the module has been registered successfully. You can see your registered ScriptMaster functions anywhere you'd get a calculation dialog in FileMaker (such as a calculation field or a 'set variable' script step) by pulling down to the 'External functions' grouping. The registered function will appear under the 'ScriptMaster' section, and can be called just like any other built-in FileMaker function.
Now that you've registered the function, you're almost ready to start using it in your solution. The only problem is that functions only remain registered while FileMaker is running - if you were to quit FileMaker and start it back up, the module you just registered would no longer appear in the FileMaker functions list. We'll discuss three options for registering ScriptMaster modules every time you open your solution file.
The first option requires ScriptMaster Advanced Edition. This is available for purchase for $95 per developer per year from http://www.360works.com/scriptmaster, and is included in the 360Works Portfolio License Bundle. See the licensing section for more details. With the Advanced Edition, click the 'plugin generation' button from the registration screen or the top of any other screen. This will create a new plugin that you can name whatever you want and distribute to your customers along with your FileMaker solutions royalty-free. This plugin is completely self-contained, and does not require either the ScriptMaster plugin or the ScriptMaster.fmp12 FileMaker file.
The second option is to simply check the 'register on startup' box from the registration screen (the layout that you are taken to after clicking the 'register' button). All modules with this option enabled are registered every time you open the ScriptMaster.fmp12 file, so you can just include the ScriptMaster.fmp12 file with your solution, open it in your startup script, and then immediately close it (it doesn't need to stay open after the functions have been registered). Here's an example of what you would put in your startup script:
Open File ["ScriptMaster"] Close File ["ScriptMaster"]
The third option is the most complex, but it does not require ScriptMaster Advanced Edition, and it does not require you to include the ScriptMaster.fmp12 file with your solution. In the module registration screen, click the button that says 'Copy to clipboard', which puts all of the registration code onto your clipboard. Now go to the startup script in your FileMaker solution, add a 'set variable' script step (you can name the variable anything you like), and paste in the registration code as the formula to calculate. Now the function will be registered every time that your startup script runs. Here's what that script step would look like:
Set Variable [$result; Value:RegisterGroovy( "GetURLasText( url )"; "new URL(url).getText();" )]
It is a good idea to check for errors after registering the function, in case there is any problem compiling the Java code. See the section below on error reporting, or watch the Youtube movie in this documentation to see an example of this complete setup. Here is an example that does the same thing as the previous one, but checks for errors and displays them to the user in case the function cannot be compiled:
If [RegisterGroovy( "GetURLasText( url )"; "new URL(url).getText();" ) = "ERROR"] Show Custom Dialog ["Could not register ScriptMaster function"; SMLastError] End If
The ScriptMaster plugin is completely free. You may
distribute it with your own solution. It would be great if you mention 360Works or ScriptMaster in your documentation
/ about screen, but there is no requirement that you do this. This plugin may be deployed with the Web Publishing
Engine, for scripts that will be called from Instant Web Publishing or Custom Web Publishing. It may also be deployed
on FileMaker Server for use with scripts that are scheduled to run on the server. See the installation section below
for more information on how to do this. There is also a ScriptMaster Advanced Edition available. This is
available for purchase for $95 per developer per year from http://www.360works.com/scriptmaster.
If you own a 360Works Portfolio License, that
includes ScriptMaster Advanced for one developer. Purchasing the advanced edition gives you all the same features as
the free version, plus three new capabilities: Plugins created with
ScriptMaster Advanced cannot be distributed by themselves, for free or commercially. They can only be distributed
with a FileMaker Solution that utilizes the plugin. The FileMaker Solution cannot be just a wrapper or demo of the
plugin functionality, it must be a full-fledged solution in its own right that uses the plugin for additional
functionality. Plugins created with ScriptMaster Advanced can utilize the SQL and Clipboard features. Once
generated, they will never expire. However, the ScriptMaster Advanced plugin itself will not be able to generate new
plugins after one year until the license key is renewed for an annual cost of $95 per developer. We've created a video showing how to use ScriptMaster. This is a quick (8:15 minute) jump-start showing
you how to create a plugin with ScriptMaster Advanced and use it to screen scrape images from a web site. ScriptMaster 4 has added a new feature to load ScriptMaster modules from a network URL. You
can use the SMLoadJar function to register all ScriptMaster modules found in the jar file. The jar file can
also contain 3rd party classes referenced by the ScriptMaster modules in that jar file. Todd Geist has published his
set of commonly used ScriptMaster modules at this URL: If you would like to publish your own favorite ScriptMaster modules for others to share, please read the
SMLoadJar function description for instructions on this. Your
ScriptMaster functions can reference compiled Java libraries (stored in the .jar format) by using the SMLoadJar function. Pass in a container field containing a .jar file, or a URL pointing to a .jar file, and any
scripts you execute will have access to the classes in that .jar. This means you can access libraries like iText (a
powerful PDF manipulation library) or qtjava (QuickTime for Java) from within FileMaker. You could also easily write
your own java code, package it as a .jar, and distribute it with your FileMaker solution! And since the .jar is
stored in FileMaker, deploying new versions of the java code to the FileMaker clients is as easy as updating a single
container field. Keep in mind that if you are copying and pasting the function registration into your
startup script, and that module requires any jar libraries, you will need to add those jar files to container fields
in your solution and use SMLoadJar to load them before registering the function. This is not an issue if using the
'register on startup' option with the ScriptMaster.fp7 development file, since that file includes all of the jar
files needed for the modules that come with ScriptMaster. After a ScriptMaster function executes, you can
access any of the named variables which were set during execution using the SMGetVariable function. This can
be very useful for returning multiple output values, similar to setting global variables in a FileMaker script. If you get the word 'ERROR' as the result of a ScriptMaster function, be sure to read
the section below on Error reporting for how to get more information on that. Phone and e-mail support for
ScriptMaster are available at our standard hourly rate of $165. There is also a free ScriptMaster discussion forum
where you can get help from the growing community of ScriptMaster users. If you create your own module
that you think would be useful to others, post it on the fmforums discussion group! If it seems like it will have
broad appeal, we'll include it with the next release of ScriptMaster (preference will be given to modules that do not
require 3rd party libraries). In addition to the many existing modules
that come free with ScriptMaster, 360Works is available to create custom modules suited to your specific needs. Send
us an email ( plugins@360works.com ) or give us a call at 770-234-9293 and let us know what you're looking for, and
we'll get you an estimate at no charge. The other choice is to do it yourself! We want to start off by
stressing that you can skip the rest of this section if you're not interested in learning Groovy or Java.
ScriptMaster comes with tons of useful modules that you can use without having to learn a new programming language.
However, if the built in modules have stirred your curiosity, you'll be able to take your FileMaker solutions to a
whole new level with the power of Groovy and Java. Because Groovy is cross-platform, modules you create will run on
both Windows and Mac OS X. To create your own module, just create a new record from the menu. Give it a
title and start coding! You can learn about Groovy at http://groovy.codehaus.org/Beginners+Tutorial (you can skip all
of the steps about setting up your Java and Groovy environment; that's all taken care of by ScriptMaster).
Here are a few tips about using ScriptMaster with FileMaker: In the 'Screen Capture' module, one thing
you'll notice is that the Integer.valueOf() calls at the beginning. This is because all ScriptMaster functions are
transmitted as text. The Integer.valueOf(someText) translates this into a numeric value. Java is much stricter about
data types than FileMaker, so this can take some getting used to for FileMaker programmers. In addition
to setting variables prior to script execution, you can access the FileMaker calculation engine directly from within
your Groovy script. This is accomplished using the reserved A script evaluated in ScriptMaster always returns the value of
the last line, or the value which is implicitly returned by the script. This can be any type of Java object.
ScriptMaster does its best to convert this to a FileMaker object. The following conversions occur: Licensing and pricing
Tutorial
video
Loading modules
from the Internet
http://www.360works.com/static/ScriptMaster/core/plugin.jarAdvanced techniques
Getting help
Writing your own modules
fmpro
object. Every Groovy script which is
executed will have an fmpro
variable set to an instance of an FMPro
object, which has these
important methods:
fmcalculation
parameter can be any valid FileMaker calculation
string.paramString
as a parameter. Note: fileName
is
required.<<table::field>>
. If an error
occurs during evaluation, the field is left as is.
Strings
and Readers
are returned as Filemaker TEXT
fields, with newline
characters (\n
) converted to carriage returns (\r
). If you are returning a very large
block of text, you should return a Reader, which streams in chunks so that it will not run out of memory.Number
s and numeric primitives are returned as FileMaker NUMBER
fieldsBoolean
values are returned as a 0 or 1File
objects are converted to embedded
containersArray
s and Collection
s are converted to return-separated listsURL
s are converted to embedded containersColor
s are converted to a string
like RGB(204,102,255)
RenderedImage
, BufferedImage
are converted to
container images. If the image has transparency, it is converted to a PNG
image. Otherwise it is
converted to a JPEG
.FMType
objects are returned as-is.String
and returned as Text.
Call SMLastError to get a detailed description of the compilation error.
Call SMLastStackTrace to get a detailed description of any exception which occurs during script execution.
groovyScript
- a block of groovy/java code You must pass in a signature for the function being registered. This is
the full signature of the function, including any parameters. For example:
Set Variable[$result = RegisterGroovy ( "logMessage ( text )" ; "System.out.println(text)" )
The ScriptMaster.fp7 file included in the ScriptMaster download will take care of registering your ScriptMaster scripts as dynamic plugin functions at startup.
Calling RegisterGroovy twice with the same function name will overwrite the previously registered function. The function is uniquely identified by its name (case sensitive). You can change the arguments of a function without changing its unique id.
You can pass in additional parameters to this function in a key=value format. Currently, the only supported additional parameter is 'isGui'. By default, all ScriptMaster functions are treated as GUI functions, which means that they may potentially access the drawing functions of the operating system. However, there is significant overhead in running a GUI function. If you are positive that a ScriptMaster module does not access the GUI, you can pass in a parameter of 'isGui=false' to run it as a non-GUI function. Be aware that this can cause FileMaker to hang if you do access GUI functions from the ScriptMaster module, so do not set this parameter unless you are confident that it is correct.
The signature of your method determines what parameters are accepted by your function. Param names containingnoLog
will never be logged, which
is useful if you are encrypting passwords or other sensitive data.
signature
- the full signature of the plugin function, as it appears in the FileMaker list of functions.script
- the actual script.pluginName
- The name of the new plugin. For example, 'My Plugin'quadChar
- 4 alphanumeric characters that uniquely identify your plugin. Use your best guess to come
up with a quadChar that is unlikely to be the same as something else, ie. 'mHz7'. Users
will never see this quadChar.pluginPrefix
- A piece of text that will appear before before standard functions. For example, if your
plugin prefix is 'ABC', then you will have plugin functions 'ABCVersion', 'ABCLastError',
and 'ABCRegister' instead of 'SMVersion', 'SMLastError', and 'SMRegister'.helpText
- The text that should appear in the plugin preferences dialog when somebody selects your
plugin, for example 'This plugin has many useful networking functions'versionString
- This should be a decimal value that appears after the help text in the plugin preferences,
for example '1.02'folderToWriteTo
- The folder where the plugins should be written to. A MAC and/or WIN subfolder will be
created, depending on the crossPlatform setting.crossPlatform
- Pass in a 0 to only create a plugin for the current platform (ie. a Windows plugin if you
are running on Windows, and a Mac plugin if you are running on Mac OS X). If you pass in a
1, you will be prompted for the location of the plugin for the other platform, and then
both a Mac and Windows plugin will be created.is64Bit
- Optional parameter. Pass in a 0 to create a 32-bit plugin or a 1 to spawn a file chooser
dialog used to select the 64-bit SM plugin needed to create a 64-bit plugin. Only applies
when building plugins on Windows.variableName
- the name of the variable whose value is being gotten.
A jar file can also contain ScriptMaster modules, which will be registered when this function is used. Since jar files can be loaded from the network (see below), this allows you to use ScriptMaster functions in your solution without needing to explicitly register any functions at all in your solution.
Here is a list of the publicly available ScriptMaster modules (currently only one, more will be added):
To create a jar file that can be loaded with this function, use the SMCreatePlugin feature to create a Mac plugin with the functions that you want. Then upload the plugin file to http://www.360works.com/upload/. We will create a signed jar file and send it back to you, usually within 24 hours. Once you receive that jar file, you can then register the functions in that jar file using this SMLoadJar function.
To add your own ScriptMaster functions to the list of publicly available modules, please contact 360Works.
There are three methods of loading the driver .jar file: from a URL, from a container field, or from a file on the hard drive.
externalJar
parameter.
The URL should be of the form http://example.org/path/to/my.jar
or
file:///path/to/my.jar
. You can embed any java .jar file into a container field in your FileMaker solution, and load the .jar from there.
You can pass in an OS-specific path, like C:\Documents and Settings\Joe\My.jar or /Users/Joe/My.jar to load the jar from your hard drive.
licenseKey
- The license key returned by the SMCreatePlugin functionregisteredTo
- The name of your company, as you entered onto the web form when you ordered ScriptMaster
Advanced.emailAddress
- The user's email address to allow for support contactproblemDescription
- A description of the current issueSet Variable[$errCap; Value: SMSetErrorCapture(True)]
errorCapture
- set to true to suppress the default popups.Note that the value will always be converted to a String. If you need to use this as some other object type (date, etc) you are responsible for converting it within your script.
All variables are cleared after every call to an Evaluate function. Setting a variable also clears the named variables from the previous script execution. If a script dealing with memory-intensive objects has been completed, it's a good idea to set a dummy variable to free up this memory.
variableName
- the name of the variable being setvalue
- the value of the variable being set