{{template "links.html"}}
This tool generates the standard Cardholder Verification Value (CVV) variants.


Ternary networks in SteadyCellPhenotype
Ternary models can represent biomolecular networks in a simple and intuitive manner by viewing the network in terms of a collection of logical rules. One can think of these models as an extension of Boolean models if simple logic is employed, but ternary models can also utilize more complicated rules and expressions. Each species in ternary network is represented by three states: 0, 1, and 2. Various assignments have been suggested for the states. For example, one possibility is to view 0 as false/inactive, 2 as true/active, and 1 as unknown, meaning that 1 can be either true/active or false/inactive. Another possibility is to think of these numbers as concentration levels of various proteins: low (0), normal (1) and high (2). Regardless of the labeling, the interactions in the network can be translated into functions over the finite field on three elements and then used to perform simulations, computations of the attractors, and visualizations of these attractors and trajectories.
An example of a biological network (or a graph) is depicted in Figure 1 below. This network is part of our previously published much larger network (see doi:10.1371/journal.pcbi.1005352 ). We have selected the iron homeostasis pathway to demonstrate the ideas and the terminology of this section. The underlying graph of this network is also a directed graph in the sense that each species is connected by an arc (edge) that has a direction, e.g., there is an arrow from TfR1 (transferrin receptor 1) to LIP (labile iron pool). In addition, in this network the graph is a signed graph, that is, each connection from one species to the next is either positive (activation - a blue arc with an arrow head) or negative (inhibition - an orange arc with a hammer head). We would like to note, that edges joining species do not have to be signed, but in most applications, majority of connections will be positive or negative.
Local activation functions
The next step in model building is to define a local activation function for each node in the network. The value of each local activation function depends on its input nodes (species) and their current state. This can be accomplished in multiple ways (i) using an analog to the Boolean formalism, (ii) tables and (iii) functions over finite field on three elements. These are not the only possibilities. Here we describe the first possibility and just mention the second (our future editions will include generation of functions from tables directly). As for the third option and others, our browser based interface SteadyCellPhenotype is capable of reading any input function over a finite field on three elements, thus allowing the user to explore any type of ternary network.
A local activation function for a node \(v\) is often denoted in literature by \(f_v\). If the node \(v\) has multiple input nodes \( w_1, w_2, \dots, w_k \), then this function is written as \( f_v(w_1, w_2, \dots, w_k)\). Using this notation and Figure 1 activation function, for example, for LIP is then \(f_{LIP}(TfR1, Fpn, Ft)\). To make notations simpler, SteadyCellPhenotype allows the user to replace the bulky notation \(f_{LIP}(TfR1, Fpn, Ft)\) by simply typing \(LIP.\)
Now suppose, that a node in the network only has one input (e.g., IRP1 and IRP2 in Figure 1) and it is clear from the biological evidence if the regulation is positive or negative. In this case, one can use simple relations as depicted by the tables below.
| \(X\) | \(f_Y(X)\) |
|---|---|
| 0 | 0 |
| 1 | 1 |
| 2 | 2 |
| \(X\) | \(f_Y(X)\) |
|---|---|
| 0 | 2 |
| 1 | 1 |
| 2 | 0 |
Local activation functions depicting these tables are then:
Since \(-1 \bmod 3 = 2\), then the equation for inhibition can also be written as \(f_Y(X) = 2+2X\). Note that the table for inhibition just reverses the values and so can be considered as an analog of the Boolean NOT gate. The user may then write the local activation function for inhibition in several ways, including algebraic forms as well as using the included not function.
When a node has two inputs (e.g., TfR1, Fpn and Ft in Figure 1) then the local activation functions may also be defined using the max or min operators (see Tables below).
| \(X\) | \(Y\) | \(f_Z(X,Y)\) |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 0 | 2 | 2 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
| 1 | 2 | 2 |
| 2 | 0 | 2 |
| 2 | 1 | 2 |
| 2 | 2 | 2 |
| \(X\) | \(Y\) | \(f_Z(X,Y)\) |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 0 | 2 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
| 1 | 2 | 1 |
| 2 | 0 | 0 |
| 2 | 1 | 1 |
| 2 | 2 | 2 |
Note that SteadyCellPhenotype's max and min operators support exactly two arguments. One can also combine operators, using the not operator inside the max and min. For example, if X activates node Z but Y inhibits node Z then a possible update rule could be \(f_Z(X,Y)=\min(X,\mathrm{not}(Y)))\).
If nontraditional activation, inhibition, or any other modulations are required, then the user may enter any combination of algebraic or max/min/not expressions and SteadyCellPhenotype will evaluate the corresponding function modulo 3.
For nodes with more than two inputs, any composition of the max, min, and not operators are possible. The not operator will always take a single expression as input and the max and min operators take two comma delimited arguments. Similar to the cases above, other expressions can be used as well among input nodes. Internally, max and min operators are recoded as polynomials of degree four when necessary for algebraic computations:
Note: Unlike variable names, the names of the max, min and not operators are case insensitive and either lower case, all caps, or a combination of cases can be used to enter these functions.
Example: iron homeostasis pathway
Using the graph in Figure 1 and rules as described in doi:10.1371/journal.pcbi.1005352 we can write local activation functions for this portion of the network. Note that IRP1 has an adjusted rule (see discussion on pages 16-17 of the article mentioned above). Syntax and the actual entry within an application (Figure 2) are shown below. Note, the user also has an option to upload the file in text (.txt) format.
Continuity
In Boolean networks there is a single scale of change for each node. However, in ternary networks there are two possible scales: a jump \(\pm1\) or \(\pm 2\). This means that a node can have a "discontinuous" change, for example from low (0) to high (2), in a single time step. If the user wishes to ensure that all or some nodes change by at most one unit then one can select an option Continuous for the variables (see Figure 3). Internally, continuity is applied to each update rule as follows:
- the local activation function \(f_X\) is computed for the variable \(X\) and compared to the current state of the variable,
- if the current state of \(X\) is the same as \(f_X\) or differs from \(f_X\) by one unit only, then the value assigned to the variable is \(f_X\), and
- if the current state of \(X\) and \(f_X\) differs by \(\pm2\), then the value of \(X\) at the next time step moves by 1 in the direction of \(f_X\).
State Space: attractors
In the current version of SteadyCellPhenotype, all nodes in the network are on a synchronous update schedule, where all values are updated simultaneously. This implies that trajectories are deterministic and each state of the network will belong to the basin of attraction of only one attractor: a fixed point or cyclic attractor.
Fixed Points can be computed using two different options.
- Selecting the radio-button Find all fixed points (see Figure 3). In this case SteadyCellPhenotype will compute all fixed points analytically using Macaulay2, which can be downloaded at their site . Note that the option to find all fixed points will only work after the user installs Macaulay2. If the model has no fixed points then a Message with the text Macaulay could not find any fixed points will be displayed.
- Another option to find some of the fixed points is by selecting the radio-button Sample fixed points and cycles. Here the user can select from the dropdown list the number of random initial states from which the trajectory will be computed.
When the radio-button Sample fixed points and cycles is selected, the length of each trajectory leading to an attractor for each random start is recorded. A histogram, summarizing a distribution of the path lengths, is displayed below each attractor (see Figure 4). Attractors can be saved in a comma-separated values (csv) format. All images also have a save button.
Additionally, the user can select the Visualize option for all or some of the variables (one can see this option in Figure 3). When this option is selected then SteadyCellPhenotype will collect additional statistics. In particular, for each random starting state a trajectory (path) is recorded. The collection of all these trajectories are then aligned on the right to ensure that they all arrive at the same time at the fixed point or at a specified point on their cyclic attractor. The image in Figure 5 displays the mean value and standard deviation of the variable states along these trajectories. This feature is useful in demonstrating, for example, if a biological species of interest (LIP) had a cyclic behavior before entering a fixed point.
Tracing a Specific State
SteadyCellPhenotype offers an option to trace a specific state by selecting the Trace state(s) radio button. This allows the user to investigate the evolution of interesting states and visualize trajectories via a graph. Under the Initial State option the user can choose from a dropdown list the values 0, 1, 2, or * (see Figure 6). The symbol asterisk (*) means that all states for this particular species will be considered. If the user would like to investigate nearby states around a specific point of interest, then checking the box Include nearby states will include the evolution of trajectories from states that are Hamming distance one from the specified point, i.e., all states that differ from the specified state by one unit for exactly one species. SteadyCellPhenotype will display a heatmap that records the evolution of trajectories and a directed graph summarizing these paths (see Figure 7). The option to save the graph and heatmap are available. The values in the heatmap will be saved in a comma-separated values (cvs) format.
Note: for small models selecting asterisk (*) for all species will result in the computation of the entire state space. Using this option for large models is not advisable. The complete state space for our running example is displayed in Figure 8, below.
Knockout and Overexpression Experiments
SteadyCellPhenotype has an option to simulate the effects of knockout (k/o) or overexpression (o/e) by using an option Forcing and selecting a value from the dropdown list 0, 1, or 2 (Figure 9). This will set the update rule to a constant value of the selected species. Attractors then can be computed as described in State Space section.


Production Crews
We know that choosing the right crew can be difficult, and choosing the wrong crew can be devastating. That's why putting together a proven crew with the right temperament, creativity, and experience is important. Our crews are battle-tested. They arrive on time and hit the ground running, keeping your production looking great and moving on schedule.
We work every day to deliver dynamic, award-winning images from Columbus, Cincinnati, Dayton, Cleveland, and beyond. Our crews have tackled projects in 49 states and 17 countries.
Crew Coverage Areas
Ohio HD crews are available to a variety of locations within Ohio, Michigan, Indiana, West Virginia, Kentucky, and Pennsylvania. Special locations outside these regions are often available upon request. This map provides information for common locations and their drive-times.
Hover a location marker for detailed information.
Ready to book a production crew with us?
Contact UsWhat can you expect when you book a crew
with Ohio HD Video?
- We create a collaborative creative environment on-set.
- We will work to understand your project to create images that will have to most impact.
- Our crews arrive on time and ready to face the challenges of the day with a positive attitude and an air of professionalism.
- We work with you to make sure we have to right gear to match the shoot requirements.
- Our standard package is anything but standard. Our van is stocked with all the latest lighting, grip and gadgetry to insure we get the shot every time!
- A vast network of "A" list freelancers that run the gamut from DPs, Sound Techs, Gaffers, Grips, Data Wranglers, PAs, Teleprompter Ops, and Stylists.
Here's what some of our clients have been saying about Ohio HD
“Scott Handel and his entire crew could not have handled such a delicate story any better. Not only were they true professionals; he (and the DV op, audio) really took time to get to know our guest and shoot the story in a dignified style. What could have been done in an exploitative manner, they took time to care to set-up shots that were creative and allowed us to see our guest in a way that wouldn't make the viewer uncomfortable. I would highly recommend them on any story Harpo shoots in the future. I was truly impressed by them. Please let whomever their employers are know what an outstanding team they have working for them.
” Veronica
Field Producer Harpo Studios – Oprah Winfrey Show
“Scott, Finally editing the Westhaven story and you are getting tons of compliments on your shooting. You guys were spectacular and I had a great time with you. I told Moneytrack they should DEFINITELY use you again!
” Bonnie
Day Producer – PBS Moneytrack
“Just wanted to thank you for all of your help this past weekend. Everyone was really pleased with your work. Really fantastic! Should we be filming in Ohio again, we certainly will give you a call.
” Tricia
Production Coordinator Kaos Entertainment / TLC: How I Lost 100 Pounds


In this test/example you can see async loading of `test1.js`. You can try to change to `test2.js`.
sctript_


Abstract
FM-PLUGIN-TOOLS is a toolkit which enables you to write FileMaker plug-ins in Common Lisp. I personally think that with this library it is vastly easier to write plug-ins than with C++ or C. YMMV, of course.To use FM-PLUGIN-TOOLS you will need the Common Lisp implementation from LispWorks and of course FileMaker Pro (Advanced). You won't need a C or C++ compiler on Windows, though! (On OS X you will need Apple's Xcode which comes for free with every Mac.)
You can develop plug-ins for the Microsoft Windows platform or for Mac OS X (10.4 and higher) on Intel processors, but not on PowerPCs.
The code comes with a BSD-style license so you can basically do with it whatever you want.
Download shortcut: http://weitz.de/files/fm-plugin-tools.tar.gz.
You don't necessarily need to understand C or C++, but it helps if you can read C++ code. The documentation provided by FileMaker for plug-in authors is pretty scarce, and the FM-PLUGIN-TOOLS docs can't fill all the voids. Look at the C++ source code that comes with FileMaker to (hopefully) grasp more details.
You will need:
The list is also intended as a general forum for discussions about plug-in development with Common Lisp and to support plug-ins like RegexPlugIn or ExifPlugIn which were written with this toolkit.
Finally, the list is also a good choice if you want to be notified about future releases. It was made available thanks to the services of common-lisp.net.
If you want me to write custom FileMaker plug-ins for you, email me
privately, I might be available for consulting.
See my homepage for contact details.
So I chose not to include the bindings with FM-PLUGIN-TOOLS. Instead, a very simple parser is provided which will automatically create these bindings for you from the header files. In the rest of this section I will explain how to use it. My apologies for this little inconvenience, but I don't fancy fighting with lawyers for a product that I don't even charge money for...
Now for the good news: You need to do this only once! If a
new version of FM-PLUGIN-TOOLS is released, you can keep the
file fli.lisp
that the parser created for you. (Well,
unless I made a mistake in the parser itself. So, keep your fingers
crossed... To be absolutely sure, compare the version number of
PREPARE-FM-PLUGIN-TOOLS - in prepare-fm-plugin-tools.asd
- with the
previous one or check the file CHANGELOG.txt
.)
Here's how it works:
fli.lisp
.)
PREP:*FMX-EXTERN-LOCATION*
to
a pathname
designator denoting the location of the FMXExtern.h
C header file. If you don't do this, you'll get a dialog
asking for the location.
PREP:PREPARE
. It should
return :DONE
when it's finished.
fli.lisp
in your
FM-PLUGIN-TOOLS folder.
DEFPACKAGE
to modify the FM-PLUGIN-TOOLS package. That's OK, don't worry.)
A remark for the LispWorks experts: Yeah, in theory I could have used
the foreign
parser, but then you'd need a C compiler in order to make it work.
Plus, it is questionable whether this parser could cope with
FileMaker's C++ code.
To build the example plug-in you need to download and install (for
ASDF) a couple of open source Lisp libraries (see
file README.txt
), and then you'll have to adjust the
corresponding values in the delivery
file deliver.lisp
and the build
script build-plugin.cmd
(build-plugin.command
on OS X). Now just double-click the
build script - that should do the trick (hopefully).
Furthermore, you can study the source code
for RegexPlugIn which
was also written using FM-PLUGIN-TOOLS.
And please note that when this documentation was originally written FM-PLUGIN-TOOLS only worked on Windows. So, if you're seeing terms like DLL or Windows registry, they are now supposed to refer to (the corresponding equivalents in) OS X as well.
OK, let's start...
init.lisp
in the
afore-mentioned example.
[Special variable]
*plugin-id*
The ID of the plug-in. A four-character creator code string - see FileMaker documentation. Note that they recommend that you register your creator code with Apple even if you're only writing Windows plug-ins. This ID will also be used as a prefix for all your plug-in function names.This variable must be customized.
[Special variable]
*plugin-name*
The name of the plug-in as it will be shown by FileMaker.This variable must be customized.
[Special variable]
*plugin-bundle-identifier*
Used as theCFBundleIdentifier
for the loadable bundles generated on OS X.This variable must be customized, but only on OS X. It is not defined on Windows.
[Special variable]
*plugin-help-text*
The help text for the plug-in to display in FileMaker's Preferences dialog box.This variable must be customized.
[Special variable]
*plugin-version*
The version number of the plug-in. Should be a list of at most four integers, e.g. (4 2 1) would correspond to version "4.2.1".This variable must be customized.
[Special variable]
*company-name*
The name of the (i.e. your) company which created the plug-in. It will be used for entries into the Windows registry and in the DLL version info.This variable must be customized.
[Special variable]
*copyright-message*
The copyright message for the DLL version info.This variable must be customized.
[Special variable]
*product-name*
Will only be used as the product name for the DLL version info. The default value isNIL
. If no other name is set, the value of*PLUGIN-NAME*
is used instead - seeSET-PRODUCT-NAME
.
[Special variable]
*preferences-function*
A function designator for a 0-ary function to handle configuration options (in FileMaker's Preferences dialog box) for the plug-in user. The default value isNIL
, and if you leave it like that, the plug-in will be marked as non-configurable (i.e. the Configure... button will be greyed out) by FileMaker. The example code shows a simple preferences function. For a more complicated example see the source code for RegexPlugIn.This variable will currently be ignored on OS X, i.e. Mac plug-ins can't have configuration dialogs.
[Special variable]
*init-function*
A function designator for a 0-ary function which is called when the plug-in is initialized - orNIL
(the default) if you don't want to be called. An init function will typically restore values from the Windows registry - see example code.
[Special variable]
*shutdown-function*
A function designator for a 0-ary function which is called when the plug-in is shut down - orNIL
(the default) if we don't want to be called. You can perform last-minute clean-up operations here if you want.Specifically, you must make sure that all Lisp processes started by your code (whether directly or through a callback) are finished before the plug-in is shut down. (See
MP:PROCESS-ALIVE-P
andMP:KILL-PROCESS
.)
[Special variable]
*enable-idle-messages*
FileMaker will send messages to the plug-in if it is idle. If the value of this variable isNIL
(the default), these messages will simply be ignored. If it is notNIL
,HANDLE-IDLE-MESSAGE
will be called instead. See also*GC-INTERVAL*
.
[Generic function]
handle-idle-message idle-level => result*
This function will be called with the corresponding level when FileMaker is idle, but only if*ENABLE-IDLE-MESSAGES*
is true. The default method does nothing and you should write methods specialized to specific idle levels to customize this behaviour. The return values of this function are ignored.
[Constants]
+k-fmxt-user-idle+
+k-fmxt-user-not-idle+
+k-fmxt-script-paused+
+k-fmxt-script-running+
+k-fmxt-unsafe+
These are the five different idle levels used by FileMaker. See the FileMaker documentation for details.
[Special variable]
*gc-interval*
If this value is notNIL
it should be a positive integerN
. In this case, a full garbage collection (see LispWorks documentation for details) will be initiated from time to time but at most everyN
seconds. This will only happen if*ENABLE-IDLE-MESSAGES*
is true, though. The default is to collect every ten minutes.
Most of the objects below can be used as arguments to plug-in functions or as their return values. Locales, colors, and character styles are an exception, though - they are only used internally.
The individual classes and methods will be presented in the following
subsections. As a general rule, never create one of these
objects
with MAKE-INSTANCE
,
always use the provided MAKE-FOO
functions like MAKE-TEXT-OBJECT
and so on.
Note: I haven't implemented all functions which are available to C++ programmers, only those that seemed useful to me. If you think that something important is missing, don't hesitate to ask for it.
LOCALE-OBJECT
s
represent locales
and they are only used in one place - when the contents of
a DATA-OBJECT
are set to
a TEXT-OBJECT
or a string.
[Standard class]
locale-object
ALOCALE-OBJECT
is a Lisp object which is a proxy for a FileMaker "Locale" object.
[Function]
make-locale-object &optional input-type => locale-object
Creates and returns aLOCALE-OBJECT
with the input typeinput-type
.input-type
is a numerical value which determines which locale will be created, the default value is+K-TYPE-SYSTEM+
.
[Constant]
+k-type-none+
+k-type-system+
+k-type-unicode-raw+
+k-type-unicode-standard+
+k-type-invalid+
+k-type-ar+
+k-type-bg+
+k-type-cat+
+k-type-catalog+
+k-type-ces+
+k-type-chi+
+k-type-chi+
+k-type-chi-stroke+
+k-type-chi-stroke+
+k-type-dan+
+k-type-deu+
+k-type-deu-dictionary+
+k-type-ell+
+k-type-eng+
+k-type-et+
+k-type-fa+
+k-type-fin+
+k-type-fin-fmi+
+k-type-fra+
+k-type-he+
+k-type-hi+
+k-type-hrv+
+k-type-hun+
+k-type-isl+
+k-type-ita+
+k-type-jpn+
+k-type-lt+
+k-type-lv+
+k-type-nld+
+k-type-nor+
+k-type-pol+
+k-type-por+
+k-type-ron+
+k-type-rus+
+k-type-slk+
+k-type-slv+
+k-type-spa+
+k-type-spa-traditional+
+k-type-sr+
+k-type-swe+
+k-type-swe-fmi+
+k-type-th+
+k-type-tur+
+k-type-ukr+
+k-type-vi+
These are the possible values for theinput-type
parameter toMAKE-LOCALE-OBJECT
. See the FileMaker documentation for details.The availability of some of these input types depends on the version of FileMaker Pro you've created
fli.lisp
with.
COLOR-OBJECT
s represent
colors, obviously, with red, green, blue, and alpha channels. They
are only used together with character styles.
[Standard class]
color-object
ACOLOR-OBJECT
is a Lisp object which is a proxy for a FileMaker "Color" object.
[Function]
make-color-object &key red green blue alpha => result
Creates and returns aCOLOR-OBJECT
with color channels corresponding to the integersred
,green
,blue
, andalpha
. The default value for all the keyword parameters is 255.
[Specialized accessors]
red (color-object color-object) => red
(setf (red (color-object color-object)) new-value)
green (color-object color-object) => green
(setf (green (color-object color-object)) new-value)
blue (color-object color-object) => blue
(setf (blue (color-object color-object)) new-value)
alpha (color-object color-object) => alpha
(setf (alpha (color-object color-object)) new-value)
These are accessors to get and set the individual channels of aCOLOR-OBJECT
.
STYLE-OBJECT
s represent
FileMaker's character styles. Each character in
a TEXT-OBJECT
can have a
character style which controls aspects like the
character's font, its size or
its color - the stuff you usually deal with via FileMaker's
Format menu. In the following section we'll call these
individual aspects properties. (I don't know if that's the
official term in FileMaker.)
Note that for each character style you can set and enable/disable each property individually, i.e. you can have a style which only controls the size while another one is responsible for, say, the font and the face.
The source code for RegexPlugIn has some examples of the usage of character styles.
[Standard class]
style-object
ASTYLE-OBJECT
is a Lisp object which is a proxy for a FileMaker "CharacterStyle" object.
[Function]
make-style-object &key font face size color => style-object
Creates and returns aSTYLE-OBJECT
and sets and enablesfont
,face
,size
, andcolor
if provided.color
has to be aCOLOR-OBJECT
, the other keyword arguments are Lisp integers.
[Specialized accessors]
color-enabled-p (style-object style-object) => enabled-p
(setf (color-enabled-p (style-object style-object)) new-value)
face-enabled-p (style-object style-object) face => enabled-p
(setf (face-enabled-p (style-object style-object) face) new-value)
font-enabled-p (style-object style-object) => enabled-p
(setf (font-enabled-p (style-object style-object)) new-value)
size-enabled-p (style-object style-object) => enabled-p
(setf (size-enabled-p (style-object style-object)) new-value)
With these accessors you can check whether a certain property is enabled in a character style and you can enable or disable it -new-value
is always treated like a generalized boolean.Note that the
FACE-ENABLED-P
accessor is a bit different from the rest because you can obviously enable/disable each face individually.
[Method]
any-face-enabled-p (style-object style-object) => enabled-p
Checks whether any face ofstyle-object
is enabled.
[Method]
disable-all-faces (style-object style-object) => |
Disables all faces ofstyle-object
.
[Method]
disable-all (style-object style-object) => |
Disables all properties ofstyle-object
.
[Specialized accessors]
color (style-object style-object) => color-object
(setf (color (style-object style-object)) (new-value color-object))
face (style-object style-object) => face
(setf (face (style-object style-object)) new-value)
font (style-object style-object) => font
(setf (font (style-object style-object)) new-value)
size (style-object style-object) => size
(setf (size (style-object style-object)) new-value)
Accessors to get and set the corresponding properties ofstyle-object
. Note that in the case of(SETF COLOR)
new-value
has to be aCOLOR-OBJECT
.
[Constant]
+k-face-plain+
+k-face-bold+
+k-face-italic+
+k-face-underline+
+k-face-outline+
+k-face-shadow+
+k-face-condense+
+k-face-extend+
+k-face-strikethrough+
+k-face-small-caps+
+k-face-superscript+
+k-face-subscript+
+k-face-uppercase+
+k-face-lowercase+
+k-face-titlecase+
+k-face-word-underline+
+k-face-double-underline+
+k-face-all-styles+
These are constants that can be used asface
parameters in the functions above. See the FileMaker documentation for details.
TEXT-OBJECT
s represent text in
FileMaker. This is like a Lisp string but with
additional character styles. Methods are
provided to convert between text objects and strings, but you will
obviously lose the character styles if you do this.
[Standard class]
text-object
ATEXT-OBJECT
is a Lisp object which is a proxy for a FileMaker "Text" object.
[Function]
make-text-object &optional string => text-object
Creates and returns aTEXT-OBJECT
representing the (Lisp) stringstring
. The default value forstring
is the empty string.
[Specialized accessor]
as-string (text-object text-object) &key position size => string
(setf (as-string (text-object text-object) ) new-value)
This accessor is used to convert between Lisp strings and text objects.new-value
must be a Lisp string. Optionally, the reader can only return thesize
characters beginning at positionposition
. The default is to return the whole string, i.e.position
is0
andsize
is set to+K-SIZE-END+
.
[Method]
size (text-object text-object) => size
Returns the length (in characters) oftext-object
.
Appends to the end oftext-object
the part of sizesize
starting at positionposition
ofother-text-object
. The default value forposition
is0
, the default value forsize
is+K-SIZE-END+
. Returnstext-object
.
[Method]
delete-text (text-object text-object) position &key size => text-object
Deletes the part oftext-object
of sizesize
beginning at positionposition
. The default value forsize
is+K-SIZE-END+
. Returnstext-object
.
[Method]
insert-text (text-object text-object) (other-text-object text-object) &key position => text-object
Insertsother-text-object
at positionposition
oftext-object
. The default value forsize
is+K-SIZE-END+
. Returnstext-object
.
[Method]
set-text (text-object text-object) (other-text-object text-object) &key position size => text-object
Setstext-object
to be the part of sizesize
starting at positionposition
ofother-text-object
. The default value forposition
is0
, the default value forsize
is+K-SIZE-END+
. Returnstext-object
.
[Method]
get-style (text-object text-object) position => style-object
Returns the character style of the character at positionposition
oftext-object
.
[Method]
set-style (text-object text-object) (style-object style-object) position size => text-object
Sets the character style of thesize
characters oftext-object
beginning at positionposition
tostyle-object
. Returnstext-object
.
[Method]
get-default-style (text-object text-object) => style-object
Returns the default character style oftext-object
.
[Method]
remove-style (text-object text-object) (style-object style-object) => text-object
Removes the character stylestyle-object
fromtext-object
. Returnstext-object
.
[Method]
reset-all-style-buffers (text-object text-object) => text-object
Removes all characters styles fromtext-object
. Returnstext-object
.
[Constants]
+k-size-end+
+k-size-invalid+
These constants can be used as asize
parameter when working withTEXT-OBJECT
s. See the FileMaker documentation for details.
FIX-PT-OBJECT
s to proxy
them. Methods are provided to convert between these objects and Lisp numbers.
[Standard class]
fix-pt-object
AFIX-PT-OBJECT
is a Lisp object which is a proxy for a FileMaker "FixPt" object.
[Function]
make-fix-pt-object &key val precision => result
Creates and returns aFIX-PT-OBJECT
optionally representing the numberval
(a Lisp number) with precisionprecision
. The defaults forval
andprecision
are0
and+K-DEFLT-FIXED-PRECISION+
.
[Specialized accessor]
as-boolean (fix-pt-object fix-pt-object) => boolean
(setf (as-boolean (fix-pt-object fix-pt-object) ) new-value)
This accessor is used to convert between generalized Lisp booleans and FixPt objects.new-value
can be any Lisp object.
[Specialized accessor]
as-integer (fix-pt-object fix-pt-object) => integer
(setf (as-integer (fix-pt-object fix-pt-object) ) new-value)
This accessor is used to convert between Lisp integers and FixPt objects.new-value
must be a Lisp integer.
[Specialized accessor]
as-float (fix-pt-object fix-pt-object) => float
(setf (as-float (fix-pt-object fix-pt-object) ) new-value)
This accessor is used to convert between Lisp floats and FixPt objects.new-value
must be a Lisp float.
[Specialized accessor]
precision (fix-pt-object fix-pt-object) => precision
(setf (precision (fix-pt-object fix-pt-object)) new-value)
Gets or sets the precision ofFIX-PT-OBJECT
. See also+K-DEFLT-FIXED-PRECISION+
.
[Constant]
+k-deflt-fixed-precision+
This constant can be used in(SETF PRECISION)
orMAKE-FIX-PT-OBJECT
to denote fixed precision.
DATE-TIME-OBJECT
s.
The toolkit provides several different ways to get or set individual
parts of such an object.
Note: As far as I understand, FileMaker doesn't have a concept
of time zones, so
the corresponding Lisp functions don't use
the time-zone
parameter when dealing
with universal
times.
[Standard class]
date-time-object
ADATE-TIME-OBJECT
is a Lisp object which is a proxy for a FileMaker "DateTime" object.
Creates and returns a newDATE-TIME-OBJECT
. Ifuniversal-time
is provided, the new object is set to the Lisp universal timeuniversal-time
. Iftime
and/ordate
are provided (themselvesDATE-TIME-OBJECT
s), the corresponding parts of the new object are set accordingly. Likewise, if some or all values ofsecond
,minute
,hour
,day
,month
, andyear
are provided, they are used as expected. The three different ways to initialize the new object are mutually exclusive.
[Specialized accessor]
as-universal-time (date-time-object date-time-object) => universal-time
(setf (as-universal-time (date-time-object date-time-object)) new-value)
Returns the date and time represented bydate-time-object
as a Lisp universal time.
[Specialized reader and setf expansion]
as-second-minute-hour (date-time-object date-time-object) => second, minute, hour
(setf (as-second-minute-hour (date-time-object date-time-object)) (values second minute hour))
Gets or set as (as three values) the seconds, minutes, and hours represented bydate-time-object
.
[Specialized reader and setf expansion]
as-day-month-year (date-time-object date-time-object) => day, month, year
(setf (as-day-month-year (date-time-object date-time-object)) (values day month year))
Gets or sets (as three values) the day of the month, month, and year represented bydate-time-object
.
[Specialized accessor]
as-time (date-time-object date-time-object) => date-time-object
(setf (as-time (date-time-object date-time-object)) (new-value date-time-object))
Gets and sets the time of the day represented bydate-time-object
as anotherDATE-TIME-OBJECT
.
[Specialized accessor]
as-date (date-time-object date-time-object) => date-time-object
(setf (as-date (date-time-object date-time-object)) (new-value date-time-object))
Gets and sets the date represented bydate-time-object
as anotherDATE-TIME-OBJECT
.
[Specialized accessor]
as-seconds-since-epoch (date-time-object date-time-object) &optional as-fix-pt-p => seconds
(setf (as-seconds-since-epoch (date-time-object date-time-object)) (new-value integer))
(setf (as-seconds-since-epoch (date-time-object date-time-object)) (new-value fix-pt-object))
Gets or sets the seconds since the Unix epoch represented bydate-time-object
. Ifas-fix-pt-p
is true, the reader returns aFIX-PT-OBJECT
, otherwise a Lisp integer.
[Specialized accessor]
as-seconds-since-midnight (date-time-object date-time-object) &optional as-fix-pt-p => seconds
(setf (as-seconds-since-midnight (date-time-object date-time-object)) (new-value integer))
(setf (as-seconds-since-midnight (date-time-object date-time-object)) (new-value fix-pt-object))
Gets or sets the seconds since midnight represented by the time part ofdate-time-object
. Ifas-fix-pt-p
is true, the reader returns aFIX-PT-OBJECT
, otherwise a Lisp integer.
[Method]
get-second (date-time-object date-time-object) => second
get-minute (date-time-object date-time-object) => minute
get-hour (date-time-object date-time-object) => hour
get-day (date-time-object date-time-object) => day
get-month (date-time-object date-time-object) => month
get-year (date-time-object date-time-object) => year
These are obviously readers to get at the individual components ofdate-time-object
.
BINARY-DATA-OBJECT
s
to proxy these C++ objects. Streams are "mapped"
to vectors
of element
type (UNSIGNED-BYTE
8)
.
The example plug-in
uses BINARY-DATA-OBJECT
s to
read Exif data from JPG images.
[Standard class]
binary-data-object
ABINARY-DATA-OBJECT
is a Lisp object which is a proxy for a FileMaker "BinaryData" object.
[Function]
make-binary-data-object => result
Creates and returns a newBINARY-DATA-OBJECT
.
[Method]
get-count (binary-data-object binary-data-object) => count
Returns the number of streams ofbinary-data-object
.
[Method]
get-index (binary-data-object binary-data-object) data-type => index
Returns the index of the stream corresponding to the data typedata-type
(a four-character Lisp string) ofbinary-data-object
.
[Method]
get-size (binary-data-object binary-data-object) index => size
Returns the size of the stream with indexindex
ofbinary-data-object
.
[Method]
get-data (binary-data-object binary-data-object) index &key offset amount result start => result
Returnsamount
octets of the contents of the stream with indexindex
ofbinary-data-object
beginning at octetoffset
(the default is0
). Ifresult
is provided, it must be a Lisp vector of element type(UNSIGNED-BYTE 8)
with static allocation which will be filled with the corresponding data and returned. Ifresult
is not provided, a large enough vector will be created. Ifresult
is provided, the vector will be filled beginning from positionstart
. Ifresult
is not provided,start
will be ignored.
[Method]
get-type (binary-data-object binary-data-object) index => data-type
Returns the data type (as a Lisp string) of the stream with indexindex
ofbinary-data-object
.
[Method]
get-total-size (binary-data-object binary-data-object) => total-size
Returns the total size ofbinary-data-object
.
[Method]
add-data (binary-data-object binary-data-object) data-type data &key start end => binary-data-object
Adds data from the Lisp vector (of element type(UNSIGNED-BYTE 8)
)data
to the stream of data typedata-type
(a four-character Lisp string) ofbinary-data-object
. Ifstart
and/orend
are provided, only the vector data fromstart
toend
is used - the default is to use the whole vector. For large vectors, the operation is likely to be a tad faster ifdata
was allocated statically. Returnsbinary-data-object
.
[Method]
remove-data (binary-data-object binary-data-object) data-type => binary-data-object
Removes the stream of data typedata-type
(a four-character Lisp string) frombinary-data
. Returnsbinary-data-object
.
[Method]
remove-all (binary-data-object binary-data-object) => binary-data-object
Removes all streams frombinary-data-object
. Returnsbinary-data-object
.
[Method]
get-size-data (binary-data-object binary-data-object) => width, height
Returns as two values the width and height ofbinary-data-object
if it contains an image.
[Method]
add-size-data (binary-data-object binary-data-object) width height => binary-data-object
Sets the width and height of the image inbinary-data-object
. Returnsbinary-data-object
.
[Method]
get-fnam-data (binary-data-object binary-data-object) &optional as-text-p => file-path-list
Returns the file path list (that's how FileMaker calls it) of the special filename (FNAM) stream ofbinary-data-object
. Ifas-text-p
is true, the result will be aTEXT-OBJECT
, otherwise a Lisp string.
[Methods]
add-fnam-data (binary-data-object binary-data-object) (file-path-list string) => binary-data-object
add-fnam-data (binary-data-object binary-data-object) (file-path-list text-object) => binary-data-object
Sets the file path list of the filename (FNAM) stream ofbinary-data
tofile-path-list
. Returnsbinary-data-object
.
TEXT-OBJECT
or FIX-PT-OBJECT
.
FM-PLUGIN-TOOLS
uses DATA-OBJECT
s as proxies
for Data objects.
[Standard class]
data-object
ADATA-OBJECT
is a Lisp object which is a proxy for a FileMaker "Data" object.
[Function]
make-data-object => result
Creates and returns a newDATA-OBJECT
.
[Specialized accessors]
as-text-object (data-object data-object) => text-object
(setf (as-text-object (data-object data-object) &key source-locale native-type) text-object)
as-string (data-object data-object) => string
(setf (as-string (data-object data-object) &key source-locale native-type ) string)
as-fix-pt-object (data-object data-object) => fix-pt-object
(setf (as-fix-pt-object (data-object data-object) &key native-type) fix-pt-object)
as-integer (data-object data-object) => integer
(setf (as-integer (data-object data-object) &key native-type) integer)
as-float (data-object data-object) => float
(setf (as-float (data-object data-object) &key native-type) float)
as-boolean (data-object data-object) => boolean
(setf (as-boolean (data-object data-object) &key native-type) whatever)
as-date (data-object data-object) => date-time-object
(setf (as-date (data-object data-object) &key native-type) date-time-object)
as-time (data-object data-object) => date-time-object
(setf (as-time (data-object data-object) &key native-type) date-time-object)
as-timestamp (data-object data-object) => date-time-object
(setf (as-timestamp (data-object data-object) &key native-type) date-time-object)
as-binary-data (data-object data-object) => binary-data-object
(setf (as-binary-data (data-object data-object) &key force-binary-native-type) binary-data-object)
These are the various readers and writers to get and set the contents of theDATA-OBJECT
data-object
.source-locale
should be aLOCALE-OBJECT
(the default is a locale created with input type+K-TYPE-SYSTEM+
),force-binary-native-type
is a generalized boolean (the default isT
), andnative-type
will by default be the value correspoding to the new value. See the FileMaker documentation for more details about these keyword parameters.
[Constants]
+k-dtinvalid+
+k-dttext+
+k-dtnumber+
+k-dtboolean+
+k-dtdate+
+k-dttime+
+k-dttime-stamp+
+k-dtbinary+
These constants are usable asnative-type
parameters in the writers above.
[Function]
set-value value &key target result-type => target
Sets the contents of theDATA-OBJECT
target
tovalue
. Iftarget
is not provided, the return value of the currently executing plug-in function (see*RESULTS*
) is set.result-type
can be one of:BOOLEAN
,:DATE
,:TIME
,:TIMESTAMP
, or:UNIVERSAL-TIME
describing the intended FileMaker type ofvalue
.result-type
can also beNIL
in which case the function tries to do the right thing depending on the Lisp type ofvalue
- ifvalue
is a string,target
is changed withAS-STRING
, ifvalue
is aTEXT-OBJECT
,target
is changed withAS-TEXT-OBJECT
, and so on. Ifvalue
is a Lisp object for which there is no known conversion method, it is treated as a generalized boolean and converted to a FileMaker boolean.Finally,
result-type
can be:VOID
which means that this function does nothing. The function returnstarget
.This function is used internally by the plug-in function machinery of FM-PLUGIN-TOOLS to set the return value of these functions and it is assumed that you'll rarely, if ever, need it. But just in case it is exported anyway.
[Method]
get-font-id (data-object data-object) font-name font-script => font-id
Returns the ID of the font identified by (the Lisp string)font-name
and the font scriptfont-script
.
[Method]
get-font-info (data-object data-object) font-id => name, script
Returns as two values the name and the script of the font with the IDfont-id
.
[Constants]
+k-native+
+k-other+
+k-invalid-font+
+k-oem+
+k-symbol+
+k-dingbats+
+k-roman+
+k-greek+
+k-cyrillic+
+k-central-europe+
+k-shift-jis+
+k-traditional-chinese+
+k-simplified-chinese+
+k-korean+
+k-turkish+
These constants can be used asfont-script
parameters inGET-FONT-ID
. See the FileMaker documentation for details.
[Generic accessor]
as-string thing &key => string
(setf (as-string thing &key) new-value)
This accessor is used to convert between Lisp strings and FileMaker objects.new-value
must be a Lisp string. There are methods for text objects and for data objects.
[Generic accessor]
as-boolean thing => boolean
(setf (as-boolean thing &key) new-value)
This accessor is used to convert between generalized Lisp booleans and FileMaker objects.new-value
can be any Lisp object. There are methods for FixPt objects and for data objects.
[Generic accessor]
as-integer thing => integer
(setf (as-integer thing &key) new-value)
This accessor is used to convert between Lisp integers and FileMaker objects.new-value
must be a Lisp integer. There are methods for FixPt objects and for data objects.
[Generic accessor]
as-float thing => float
(setf (as-float thing &key) new-value)
This accessor is used to convert between Lisp floats and FileMaker objects.new-value
must be a Lisp float. There are methods for FixPt objects and for data objects.
[Generic accessor]
as-date thing => date-time-object
(setf (as-date thing &key) new-value)
This accessor is used to convert between a full timestamp and the date part of it.new-value
must be aDATE-TIME-OBJECT
. There are methods for DateTime objects and for data objects.
[Generic accessor]
as-time thing => date-time-object
(setf (as-time thing &key) new-value)
This accessor is used to convert between a full timestamp and the time part of it.new-value
must be aDATE-TIME-OBJECT
. There are methods for DateTime objects and for data objects.
[Generic function]
size thing => size
Returns the size of either a text object or a character style.
FM-PLUGIN-TOOLS tries to hide most of the complexity of this process
from you by providing
the DEFINE-PLUGIN-FUNCTION
macro which is intended to be used more or less
like DEFUN
- you define a function that almost looks like a Lisp function and the
toolkit does the rest. Specifically, your function will have a lambda
list
with optional
and rest
parameters, and you can already declare the desired object type (and a
default value if appropriate) in the lambda list. Likewise, in most
cases it will suffice to simply return a value from your function like
in Lisp, and FM-PLUGIN-TOOLS will make sure the correct data is sent
to FileMaker.
In the rare cases where you want to access the argument vector or the
result pointer directly, you can use the functions NTH-ARG
and
SET-VALUE
or manipulate
the *RESULTS*
object.
Errors occurring during the execution of a plug-in function are automatically caught and optionally logged.
[Macro]
define-plugin-function description lambda-list declaration* statement*
Defines a plug-in function.description
is either a string with the function prototype as it should be shown by FileMaker or a list where the first element is a prototype string followed by a plist with keyword parameters. FM-PLUGIN-TOOLS will automatically determine the name of the function from the prototype string by removing the argument list (if there is one). Furthermore, it will add the plugin ID and an underline to this name. So, if your prototype string is, say, "Foo( arg1; arg2 )" and your plugin ID is "Quux", then the function name reported to FileMaker will be "Quux_Foo". (This is the usual convention used for plug-ins.)The plist can have the properties (i.e. they keyword parameters)
:MAX-ARGS
,:FLAGS
, and:RESULT-TYPE
.max-args
is the maximal number of arguments for the function. This parameter will only be used if there's a&REST
parameter in the lambda list, i.e. if the toolkit can't determine the maximal number of arguments itself.
result-type
will be interpreted as bySET-VALUE
: If your function returnsvalue
, then FM-PLUGIN-TOOLS will call(set-value value :result-type result-type)before it returns to FileMaker. As explained in the entry forSET-VALUE
, in most cases you don't need to set the result type explicitly (leaving itNIL
), asSET-VALUE
will try to do the right itself.
flags
is a boolean combination of flags describing the behaviour of the function - see FileMaker documentation. The default is to use the combination of+K-DISPLAY-IN-ALL-DIALOGS+
and+K-MAY-EVALUATE-ON-SERVER+
.
lambda-list
is like a simplified version of a Lisp lambda list where only&OPTIONAL
and&REST
are allowed. Each parameter is either a symbol or a pair(NAME TYPE)
wheretype
is interpreted as byNTH-ARG
, i.e. it determines the desired type of the argument calledname
. Optional parameters can also look like(NAME TYPE DEFAULT-VALUE)
wheredefault-value
is of course the default value for this argument.
[Constant]
+k-may-evaluate-on-server+
+k-display-auto-enter+
+k-display-calc-fields+
+k-display-custom-functions+
+k-display-generic+
+k-display-in-all-dialogs+
+k-display-in-future1+
+k-display-in-future2+
+k-display-privileges+
+k-display-validation+
These are flags that can be used for theflags
parameter ofDEFINE-PLUGIN-FUNCTION
. See the FileMaker documentation for their meaning.
[Function]
nth-arg n &optional type => argument
Returns theN
th argument (starting to count at0
) of the currently executing plug-in function.type
determines how the argument should be returned and must be one of:TEXT
(for aTEXT-OBJECT
),:STRING
(for a Lisp string),:FIX-PT
(aFIX-PT-OBJECT
),:INTEGER
(a Lisp integer),:FLOAT
(a Lisp float),:BOOLEAN
(a Lisp boolean),:DATE
,:TIME
,:TIMESTAMP
(DATE-TIME-OBJECT
s),:UNIVERSAL-TIME
(a Lisp universal time),:BINARY-DATA
(aBINARY-DATA-OBJECT
), orNIL
(theDATA-OBJECT
itself).If there are fewer than
N
arguments, this function returnsNIL
.It is expected that you'll almost never need to call this function, because
DEFINE-PLUGIN-FUNCTION
will arrange to call it for you automatically if needed.
[Special variable]
*results*
During the execution of a plug-in function this variable is bound to the data object which will eventually contain the return value. Don't do anything with this variable unless you absolutely know what you're doing! Use the functionSET-VALUE
if needed.
[Function]
boolean-value thing => boolean
ReturnsT
ifthing
is notNIL
,NIL
otherwise. This is a convenience function which you can use to ensure that the return value of a plug-in function is interpreted as a boolean without explicitly setting its result type.
deliver.lisp
which already contains all the code
needed to do this. You'll just have to adjust a few special variables
(like the delivery level and where ASDF libraries are to be looked
for) to your local settings.
FM-PLUGIN-TOOLS also comes with a script build-plugin.cmd
(build-plugin.command
on OS X)
that will do all the work of creating a Lisp DLL for you once you have
adjusted it to your local settings. Actualy, the
file deliver.lisp
is set up in such a way that it is
expected to be invoked from the build script. Note that FileMaker
must not run when you copy the plug-in into
the Extensions
folder.
Note: It might be the case that your
DLL requires
the Microsoft Visual
Studio runtime library msvcr80.dll
. If you want to
make sure that the runtime library is available on the target machine,
you should probably provide an installer and use something like
Microsoft's Visual
C++ 2005 Redistributable Package.
[Function]
check-plugin-id => result
Checks whether*PLUGIN-ID*
has a valid value. Should be called in a delivery script. The filedeliver.lisp
the comes with FM-PLUGIN-TOOLS already contains a call to this function.
[Function]
set-product-name => set-product-name
Sets*PRODUCT-NAME*
from*PLUGIN-NAME*
if it hasn't been set explicitly. Should be called in a delivery script. The filedeliver.lisp
the comes with FM-PLUGIN-TOOLS already contains a call to this function.
[Special variable]
*symbols-to-keep*
The list of symbols which must remain in the delivered DLL image. Only needed for delivery level 5. See:KEEP-SYMBOLS
.FM-PLUGIN-TOOLS uses this variable internally. You are allowed to add symbols to this list and to remove symbols you've added yourself but you must not otherwise modify it. Modifications to this list obviously only make sense before the DLL is built, not at runtime.
The value of this variable is meaningless if you don't use the file
deliver.lisp
mentioned above.
[Methods]
evaluate (expression string) &optional result => result
evaluate (expression text-object) &optional result => result
Evaluates (as with FileMaker's "Evaluate" function) the expressionexpression
. The result is stored in theDATA-OBJECT
result
which is created if none is provided. The function returnsresult
.
[Methods]
execute-sql (expression string) column-separator row-separator &optional result => result
execute-sql (expression text-object) column-separator row-separator &optional result => result
Executes the SQL expressionexpression
(see FileMaker's "ExecuteSQL" which they describe as "experimental") using (for the return value) the column separatorcolumn-separator
and the row separatorrow-separator
both of which must be characters. The result is stored in theDATA-OBJECT
result
which is created if none is provided. The function returnsresult
.
[Methods]
start-script file-name (script-name string) &key control parameter => |
start-script (file-name string) script-name &key control parameter => |
start-script (file-name text-object) (script-name text-object) &key control parameter => |
Starts the FileMaker script with the namescript-name
in the filefile-name
(both arguments can be Lisp strings orTEXT-OBJECT
s).parameter
can be aDATA-OBJECT
or any other object that can be converted automatically to aDATA-OBJECT
withSET-VALUE
. The default behaviour is to not useparameter
, i.e. to hand over a CNULL
pointer to FileMaker. The default value forcontrol
is+K-FMXT-PAUSE+
.See the FileMaker documentation for the meaning of the
control
andparameter
arguments.
[Constants]
+k-fmxt-halt+
+k-fmxt-exit+
+k-fmxt-resume+
+k-fmxt-pause+
These constants can be used ascontrol
arguments forSTART-SCRIPT
. See the FileMaker documentation for details.
[Accessor]
plugin-preference path value-name => whatever
(setf (plugin-preference path value-name) new-value)
Stores and retrieves preferences (stored in the Windows registry) corresponding topath
andname
. See alsoUSER-PREFERENCE
- theproduct
parameter there is automatically set to a value appropriate for your plug-ing.
[Macro]
remember-interface-geometry interface-class-name
Convenience macro which sets up a user defined interface class such that its geometry will automatically be stored in the Windows registry between different invocations of the plug-in. See alsoTOP-LEVEL-INTERFACE-GEOMETRY-KEY
.
[Function]
version-string => string
Returns a string representation of the plug-in version.
[Function]
update-global-environment => |
If you call this function, a "global environment" will be set up (or updated). This environment can act as a fallback for functions likeEVALUATE
which need an environment. Such a global environment is not needed for functions that are called by FileMaker as these will always have an environment set up for them automatically.This function must only be called from within functions that are called by FileMaker. It is protected with a lock, so you don't need to care about concurrency.
If you don't understand this explanation, you very likely don't need this function...
[Function]
fm-log control-string &rest format-args => |
This function writes data to the file denoted by*FM-LOGFILE*
unless this value isNIL
.control-string
andformat-args
are interpreted as byFORMAT
.
[Special variable]
*fm-logfile*
Target file for thefm-log
function. A pathname designator, orT
for a default location in the user's local application data folder, orNIL
for no logging at all. The default value isT
.
[Special variable]
*log-errors-p*
Whether errors occurring during the execution of a plug-in function should be logged usingFM-LOG
. The default value isT
.
[Special variable]
*log-backtraces-p*
Whether error log entries created due to*LOG-ERROR-P*
should be followed by a backtrace. The default value isNIL
.
[Function]
top-level-hook fn interface => result
A function which can be used as a top-level hook for CAPI interfaces to make them more robust against unhandled conditions. It will log the condition if*LOG-ERRORS-P*
is true and then destroy the interface.See the reference entry for
CAPI:INTERFACE
. See also the source code of RegexPlugIn for an example of its usage.
add-data
add-fnam-data
add-size-data
alpha
any-face-enabled-p
append-text
as-binary-data
as-boolean
as-date
as-day-month-year
as-fix-pt-object
as-float
as-integer
as-second-minute-hour
as-seconds-since-epoch
as-seconds-since-midnight
as-string
as-text-object
as-time
as-universal-time
binary-data-object
blue
boolean-value
check-plugin-id
color
color-enabled-p
color-object
data-object
date-time-object
define-plugin-function
delete-text
disable-all
disable-all-faces
execute-sql
evaluate
face
face-enabled-p
fix-pt-object
fm-log
font
font-enabled-p
get-count
get-data
get-day
get-default-style
get-fnam-data
get-font-id
get-font-info
get-hour
get-index
get-minute
get-month
get-second
get-size
get-size-data
get-style
get-total-size
get-type
get-year
green
handle-idle-message
insert-text
locale-object
make-binary-data-object
make-color-object
make-data-object
make-date-time-object
make-fix-pt-object
make-locale-object
make-style-object
make-text-object
nth-arg
plugin-preference
precision
red
remember-interface-geometry
remove-all
remove-data
remove-style
reset-all-style-buffers
set-product-name
set-style
set-text
set-value
size
size-enabled-p
start-script
style-object
text-object
top-level-hook
update-global-environment
version-string
*company-name*
*copyright-message*
*enable-idle-messages*
*fm-logfile*
*gc-interval*
*init-function*
*log-backtraces-p*
*log-errors-p*
*plugin-bundle-identifier*
*plugin-help-text*
*plugin-id*
*plugin-name*
*plugin-version*
*preferences-function*
*product-name*
*results*
*shutdown-function*
*symbols-to-keep*
+k-central-europe+
+k-cyrillic+
+k-deflt-fixed-precision+
+k-dingbats+
+k-display-auto-enter+
+k-display-calc-fields+
+k-display-custom-functions+
+k-display-generic+
+k-display-in-all-dialogs+
+k-display-in-future1+
+k-display-in-future2+
+k-display-privileges+
+k-display-validation+
+k-dtbinary+
+k-dtboolean+
+k-dtdate+
+k-dtinvalid+
+k-dtnumber+
+k-dttext+
+k-dttime+
+k-dttime-stamp+
+k-face-all-styles+
+k-face-bold+
+k-face-condense+
+k-face-double-underline+
+k-face-extend+
+k-face-italic+
+k-face-lowercase+
+k-face-outline+
+k-face-plain+
+k-face-shadow+
+k-face-small-caps+
+k-face-strikethrough+
+k-face-subscript+
+k-face-superscript+
+k-face-titlecase+
+k-face-underline+
+k-face-uppercase+
+k-face-word-underline+
+k-fmxt-exit+
+k-fmxt-halt+
+k-fmxt-pause+
+k-fmxt-resume+
+k-fmxt-script-paused+
+k-fmxt-script-running+
+k-fmxt-unsafe+
+k-fmxt-user-idle+
+k-fmxt-user-not-idle+
+k-greek+
+k-invalid-font+
+k-korean+
+k-may-evaluate-on-server+
+k-native+
+k-oem+
+k-other+
+k-roman+
+k-shift-jis+
+k-simplified-chinese+
+k-size-end+
+k-size-invalid+
+k-symbol+
+k-traditional-chinese+
+k-turkish+
+k-type-ar+
+k-type-bg+
+k-type-cat+
+k-type-catalog+
+k-type-ces+
+k-type-chi+
+k-type-chi+
+k-type-chi-stroke+
+k-type-chi-stroke+
+k-type-dan+
+k-type-deu+
+k-type-deu-dictionary+
+k-type-ell+
+k-type-eng+
+k-type-et+
+k-type-fa+
+k-type-fin+
+k-type-fin-fmi+
+k-type-fra+
+k-type-he+
+k-type-hi+
+k-type-hrv+
+k-type-hun+
+k-type-invalid+
+k-type-isl+
+k-type-ita+
+k-type-jpn+
+k-type-lt+
+k-type-lv+
+k-type-nld+
+k-type-none+
+k-type-nor+
+k-type-pol+
+k-type-por+
+k-type-ron+
+k-type-rus+
+k-type-slk+
+k-type-slv+
+k-type-spa+
+k-type-spa-traditional+
+k-type-sr+
+k-type-swe+
+k-type-swe-fmi+
+k-type-system+
+k-type-th+
+k-type-tur+
+k-type-ukr+
+k-type-unicode-raw+
+k-type-unicode-standard+
+k-type-vi+
This documentation was prepared with DOCUMENTATION-TEMPLATE.
$Header: /usr/local/cvsrep/fm-plugin-tools/doc/index.html,v 1.80 2010/07/22 09:36:50 edi Exp $


1 hr
Just published my first app! It’s official. Msg me for details
3 hr
4 hr
Latest Posts
Need developers for my social media site. Willing to pay :)
Show more
Communities to Follow
50 users in this community
Show More


Terms of use
By using the bot and browsing this website, you agree to be bound by the following terms of use:
Privacy, and your data
Only the following information may retained:
- Channel IDs
- Guild names
- Guild member count
- Username, userid, discriminator and similar user information (retained only when an error occurs)
Data which is retained will be erased within a week of it being recorded, usually less.
Terms of use
“We" refers to the collective management and development team behind the Polaris bot.
- The “service" is provided “as is" without any warranty of any kind.
- We reserve the right to terminate your access to the service, in the form of a “blacklist". These blacklists may be issued for:
- Malicious use of the service – Spamming commands to damage or decrease the responsiveness of the service
- Using the service (bot) within a server which performs organised “raids", scamming or other illegal/undesirable activity as deemed by staff
- Using the service (bot) in a way which violates the discord terms of service
- Any other use of the service deemed illegal under UK law
- Other reason deemed to be disqualifying by the management
- We are not responsible for damage(s) to your guild or other intellectual property
- All queries and correspondence related to these terms should be sent to<EMAIL_ADDRESS>in the first instance.
- We reserve the right to change these conditions as we see fit and your continued use of the service will signify your acceptance of any adjustment to these terms


No Deposit Required
No Code Needed
Minimum Deposit-
Expiry14 days
Rollover Requirement-
RestrictionsUK and Ireland Only
100% Matched Deposit Bonus
No Deposit Required
No Code Needed
Minimum Deposit£10
Expiry14 days
Rollover Requirement20x
RestrictionsUK and Ireland Only
William Hill Casino Review
Since its launch in 2000, William Hill Casino has established itself as one of the top destinations for players around the UK. The company has the financial backing and operational experience to provide the latest games and more substantial new customer offers than most rivals (follow the link to compare). With over 150 titles available including progressive jackpots, live tables and mobile apps, plus some generous sign up offers, this site seems to have covered all the bases.
Fair play and security are guaranteed by the terms of their operating licence, issued in Gibraltar.
Bonus Codes and Promotions
To welcome new players, bonuses and codes are available, paid in the form of credits, which can be used to play the games. The bonus money must be wagered several times before a withdrawal can be requested. This prevents anyone from claiming the funds and then withdrawing them without actually playing.
Regulars are eligible to get extra bonuses which vary each month, but can include a monthly loyalty bonus for each deposit you make, while the Comp Points scheme means that you earn points every time you place a wager, which can then be converted to free casino money or merchandise. There is a VIP club, which gives frequent players a better Comp Points conversion rate as well as higher table limits, exclusive tournaments, invites to VIP events and even a personal account manager. Other regular promotions include competitions, double points and a £50 bonus when you refer a friend who subsequently joins up.
Games
William Hill uses Playtech software, which means that they have a good range of online games. A particular feature of Playtech slots is the number of film and TV show based games, making this range an essential choice for movie and popular culture fans. Among the most widely played titles are slots based on:
- Gladiator
- Rocky
- King Kong
- The Six Million Dollar Man
- The Pink Panther
- Iron Man
- The Hulk
- Ghost Rider
Progressive slots can have jackpots of well over $1,000,000, with Beach Life having the biggest prize and Gladiator not far behind. Roulette players will be spoilt for choice with twelve versions, Blackjack is available in seven varieties and there are lots of poker varieties to play as well. On top of these, the live casino offers Roulette, Blackjack, Baccarat and Holdem, and is the closest you can get to the full casino experience, without leaving home.
When you are away from home, you can still play a selection of the most popular games using the free mobile app, which is compatible with all Android and Apple devices. A useful feature of this app is that you can deposit funds and even open a new account via a mobile or tablet.
Banking
Few online casinos let you pay in using such a wide range of options and no fees are charged for deposits. Not all options are available in all territories, but there is a handy drop down menu in the Banking area which will inform you about which methods are open to you.
Withdrawing funds is simply a matter of entering your username and password and requesting the money.  Withdrawal requests are handled exceptionally quickly and securely, with processing carried out on the first business day, and all transactions carried out over 128 bit SSL servers. Once you have an account at William Hill, you can use the same details and deposited money to bet on sports, bingo, live casino, poker, and financials, as well as the mobile equivalents.
Conclusion
William Hill has established itself as one of the top online casinos in the UK. The range of quality games is good and bonuses, particularly ongoing offers, are competitive. Benefits include the ability to use one account across a number of sites and William Hill are very quick to return winnings to your account when you request a withdrawal.
Claim your William Hill Casino Bonus Today!
100% Deposit Bonus: £25
Just Deposit £10: £50
100% Deposit Bonus: £1200


Data sets utilized by the 'SGP' package as exemplars for users to conduct their own student growth percentiles (SGP) analyses.
| Version: | 20.0-0.0 |
| Depends: | R (≥ 3.2) |
| Imports: | crayon, data.table (≥ 1.9.6) |
| Suggests: | SGP (≥ 1.4-0.0), knitr, rmarkdown |
| Published: | 2018-04-10 |
| Author: | Damian W. Betebenner [aut, cre], Adam R. Van Iwaarden [aut], Ben Domingue [aut] |
| Maintainer: | Damian W. Betebenner <dbetebenner at nciea.org> |
| BugReports: | https://github.com/CenterForAssessment/SGPdata/issues |
| License: | GPL-3 |
| URL: | https://CenterForAssessment.github.io/SGPdata, https://github.com/CenterForAssessment/SGPdata, https://cran.r-project.org/package=SGPdata |
| NeedsCompilation: | no |
| Citation: | SGPdata citation info |
| Materials: | NEWS |
| CRAN checks: | SGPdata results |
| Reference manual: | SGPdata.pdf |
| Vignettes: |
Getting started with SGPdata |
| Package source: | SGPdata_20.0-0.0.tar.gz |
| Windows binaries: | r-devel: SGPdata_20.0-0.0.zip, r-release: SGPdata_20.0-0.0.zip, r-oldrel: SGPdata_20.0-0.0.zip |
| OS X binaries: | r-release: SGPdata_20.0-0.0.tgz, r-oldrel: SGPdata_20.0-0.0.tgz |
| Old sources: | SGPdata archive |
| Reverse suggests: | SGP |
Please use the canonical form https://CRAN.R-project.org/package=SGPdata to link to this page.


Home
Slides
Info
Workbench
Export
Signup
Feedback
caMicroscope
Digital pathology image viewer with support for human/machine generated annotations and markups.
Slides
Info
Collection
10 slides/page
20 slides/page
40 slides/page
50 slides/page
100 slides/page
Reload
Upload
Toggle Dropdown
Upload Batch
Upload New Slide
×
Steps for uploading.
Select the file as Input. The
Token
field should be filled automatically, and start uploading.
Provide the destination filename with extension.
Click on the
button to get check a preview of the slide
Finally
Finish Upload
to post the slide to caMicroscope
File
Choose file
Upload
Uploading...
Upload from URL
Upload from local
Filename
Token
Slidename
Filter (leave blank for public)
Finish Upload
Delete confirmation
×
Slide name change confirmation
×


Practicum/Project Overview
Agenda
- Project Overview
- A/B Testing and Experimentation - Usability Testing
- Project Deliverables
- Wireframes
- Insight and Research
Project Oveview
Overview
- Running A/B and Usability testing based on a set of goals
- Enhance the user experience (UX) and to achieve desired business outcome
Project Deliverables
- Wireframes
- Insightful UX Research
A/B testing Overview


Copyright © 2014 Glen Fernandes
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Contents
Introduction
Synopsis
align
aligned_alloc
aligned_free
aligned_allocator
is_aligned
Examples
Acknowledgments
History
The header
<boost/align.hpp> provides function boost::align
for implementations which do not have the C++11 standard
library function std::align
available.
It also provides functions boost::aligned_alloc
and
boost::aligned_free
, for aligned allocation, as these
functions are not yet available in the C++ standard library.
It also provides a C++ allocator, class template
boost::aligned_allocator
, which respects alignment and is
suitable for correct allocation for over-aligned types.
namespace boost { void* align(size_t alignment, size_t size, void*& ptr, size_t& space); void* aligned_alloc(size_t alignment, size_t size); void aligned_free(void* ptr); template<class T, size_t minimum_alignment = 1> class aligned_allocator; template<size_t A> class aligned_allocator<void, A>; template<class T1, class T2, size_t A> bool operator==(const aligned_allocator<T1, A>&, const aligned_allocator<T2, A>&); template<class T1, class T2, size_t A> bool operator!=(const aligned_allocator<T1, A>&, const aligned_allocator<T2, A>&); bool is_aligned(size_t alignment, const void* ptr); }
void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
Effects: If it is possible to fit
size
bytes of storage aligned by alignment into the buffer pointed to byptr
with lengthspace
, the function updatesptr
to point to the first possible address of such storage and decreasesspace
by the number of bytes used for alignment. Otherwise, the function does nothing.Requires:
—
alignment
shall be a fundamental alignment value or an extended alignment value and a power of two—
ptr
shall point to contiguous storage of at leastspace
bytesReturns: A null pointer if the requested aligned buffer would not fit into the available space, otherwise the adjusted value of
ptr
.Note: The function updates its
ptr
andspace
arguments so that it can be called repeatedly with possibly differentalignment
andsize
arguments for the same buffer.
void* aligned_alloc(size_t alignment, size_t size);
Description: The
aligned_alloc
function allocates space for an object whose alignment is specified byalignment
, whose size is specified bysize
, and whose value is indeterminate. The value ofalignment
shall be a power of two.Returns: The
aligned_alloc
function returns either a null pointer or a pointer to the allocated space.Note: On certain platforms the space allocated may be larger than
size
bytes, for alignment purposes, by an additionalsizeof(void*) - 1 + alignment
bytes.
void aligned_free(void* ptr);
Description: The
aligned_free
function causes the space pointed to byptr
to be deallocated, that is, made available for further allocation. Ifptr
is a null pointer, no action occurs. Otherwise, if the argument does not match a pointer earlier returned by thealigned_alloc
function, or if the space has been deallocated by a call toaligned_free
, the behavior is undefined.Returns: The
aligned_free
function returns no value.
template<class T, size_t minimum_alignment = 1> class aligned_allocator; template<size_t A> class aligned_allocator<void, A> { public: typedef void value_type; typedef void* pointer; typedef const void* const_pointer; template <class U> struct rebind { typedef aligned_allocator<U, A> other; }; }; template<class T, size_t A> class aligned_allocator { public: typedef T value_type; typedef T* pointer; typedef const T* const_pointer; typedef size_t size_type; typedef ptrdiff_t difference_type; typedef T& reference; typedef const T& const_reference; template<class U> struct rebind { typedef aligned_allocator<U, A> other; }; aligned_allocator(); template<class U> aligned_allocator(const aligned_allocator<U, A>&); pointer address(reference x) const; const_pointer address(const_reference x) const; pointer allocate(size_type n, aligned_allocator<void, A>::const_pointer = 0); void deallocate(pointer p, size_type); size_type max_size() const; template<class U, class... Args> void construct(U* memory, Args&&... args); template<class U> void destroy(U* memory); };
Except for the destructor, member functions of the default allocator shall not introduce data races as a result of concurrent calls to those member functions from different threads. Calls to these functions that allocate or deallocate a particular unit of storage shall occur in a single total order, and each such deallocation call shall happen before the next allocation (if any) in this order.
pointer address(reference x) const;
Returns: The actual address of the object referenced by
x
, even in the presence of an overloaded operator&.
const_pointer address(const_reference x) const;
Returns: The actual address of the object referenced by
x
, even in the presence of an overloaded operator&.
pointer allocate(size_type n, aligned_allocator<void, A>::const_pointer = 0);
Returns: A pointer to the initial element of an array of storage of size
n * sizeof(T)
, aligned on the lowest common multiple of the minimum alignment specified and the alignment of objects of typeT
.Remarks: The storage is obtained by calling
aligned_alloc
.Throws:
bad_alloc
if the storage cannot be obtained.
void deallocate(pointer p, size_type);
Requires:
p
shall be a pointer value obtained fromallocate()
.Effects: Deallocates the storage referenced by
memory
.Remarks: Uses
aligned_free
.
size_type max_size() const;
Returns: The largest value N for which the call
allocate(N)
might succeed.
template<class U, class... Args> void construct(U* p, Args&&... args);
Effects:
::new((void*)p) U(std::forward<Args>(args)...)
template<class U> void destroy(U* p);
Effects:
p->~U()
template<class T1, class T2, size_t A> bool operator==(const aligned_allocator<T1, A>&, const aligned_allocator<T2, A>&);
Returns:
true
.
template<class T2, class T2, size_t A> bool operator!=(const aligned_allocator<T1, A>&, const aligned_allocator<T2, A>&);
Returns:
false
.
Specifying minimum alignment is generally only suitable for containers such as vector and undesirable with other, node-based, containers.
bool is_aligned(size_t alignment, const void* ptr);
Description: The
is_aligned
function determines whether the space pointed to byptr
has alignment specified byalignment
.Returns: The
is_aligned
function returnstrue
if and only ifptr
points to space that has alignment specified byalignment
.
#include <boost/align.hpp> #include <memory> template<class T> struct aligned_delete { void operator()(T* ptr) { ptr->~T(); boost::aligned_free(ptr); } }; template<class T> struct aligned_delete<T[]> { }; template<class T> using aligned_ptr = std::unique_ptr<T, aligned_delete<T> >; template<class T> struct ptr_if { typedef aligned_ptr<T> type; }; template<class T> struct ptr_if<T[]> { }; template<class T, std::size_t N> struct ptr_if<T[N]> { }; template<class T, class... Args> inline typename ptr_if<T>::type make_aligned(Args&&... args) { void* p = boost::aligned_alloc(alignof(T), sizeof(T)); if (!p) { throw std::bad_alloc(); } try { T* q = ::new(p) T(std::forward<Args>(args)...); return aligned_ptr<T>(q); } catch (...) { boost::aligned_free(p); throw; } }
#include <boost/align.hpp> #include <vector> template<class T, std::size_t Alignment = 1> using aligned_vector = std::vector<T, boost::aligned_allocator<T, Alignment> >;
Peter Dimov provided valuable feedback on the design, implementation, and tests of this library.
Andrey Semashev suggested portability and design improvements.
On 19 February 2014, Glen Fernandes implemented Boost.Align.
Copyright © 2014 Glen Joseph Fernandes


Regular giveaways from DotaInventory.com and partner sites; Twitch streamers and channels. Check back often to be in for a chance to win FREE items for your heroes in Dota 2.
Host Your Giveaways at DotaInventory.com
Contact me on Steam to get startedAdvertisement
Host Your Giveaways at DotaInventory.com
Contact me on Steam to get started


--- layout: post title: DDD Exchange 2011 date: 2011-06-10 21:47:56.000000000 -06:00 type: post published: true status: publish categories: - Community Event - News tags: [] meta: _gcid: '350' _edit_last: '3' _wp_page_template: default _dependencies: s:6:"a:0:{}"; custom_permalink: events/dddx2011/ _custom_background: a:5:{s:3:"url";s:0:"";s:16:"background-color";s:0:"";s:17:"background-repeat";s:6:"repeat";s:21:"background-attachment";s:6:"scroll";s:19:"background-position";s:8:"left top";} _intro_text: default _intro_custom_banner: a:1:{s:3:"url";s:0:"";} _bitly_trim: http://dddcommunity.org/?p=116 _encloseme: '1' U_S_C_message: '' author: login: Eric Evans email<EMAIL_ADDRESS>display_name: Eric Evans first_name: Eric last_name: Evans ---
Our 3rd annual DDD Exchange, a one-day conference in London dedicated to DDD, was a big success.
This year's theme was 'DDD In a New Technical Landscape'. In the last few years, several exciting technological trends have
(Eric Evans wrote about this in a recent newsletter.)
There is a wide range of these trends. To move the conversation along, DDD Exchange had two talks along these lines:
Other talks:
Highlighted Speakers:
The attendance is capped at 140 (due to the size of the room). This makes for an intimate feeling, and the chance for everyone to interact with the speakers and each other.
There was wide participation in the Park Bench. The discussion was nicely facilitated by Zi Makki for the third year in a row. This has become almost a tradition of the event, he does such a fine job.
The event was hosted by Skills Matter


The electro-magnetic energy conversion is given by Ampere's law and Faraday's law respectively:
V_m = i * N N * dΦ/dt = -v
V_m is the magnetomotive force that is supplied to the connected magnetic circuit, Φ is the magnetic flux through the associated branch of this magnetic circuit. The negative sign of the induced voltage v is due to Lenz's law.
The flux linkage Ψ and the static inductance L_stat = |Ψ/i| are calculated for information only. Note that L_stat is set to |Ψ/eps| if |i| < eps (= 100*Modelica.Constants.eps).


@* * Copyright 2023 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import config.AppConfig @this( link: components.link, h3: components.h3 ) @(journeyId: String, searchResults: SearchResults)(implicit request: Request[_], messages: Messages, appConfig: AppConfig) @if(searchResults.sectors.size > 1) {


Demo
Basic Matrix Reordering
Les Misérables Co-occurrence
Paris-Saclay Co-authorship Matrix
Basic Parallel Coordinates
Cars Dataset Parallel Coordinates
Cars Dataset Parallel Coordinates using Parcoords ES


One of GObject's nice features is its generic get/set mechanism for object
properties. When an object
is instantiated, the object's class_init handler should be used to register
the object's properties with g_object_class_install_properties
(implemented in gobject.c
).
The best way to understand how object properties work is by looking at a real example on how it is used:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 |
/************************************************/ /* Implementation */ /************************************************/ enum { PROP_0, PROP_MAMAN_NAME, PROP_PAPA_NUMBER, N_PROPERTIES }; static GParamSpec *obj_properties[N_PROPERTIES] = { NULL, }; static void maman_bar_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { MamanBar *self = MAMAN_BAR (object); switch (property_id) { case PROP_MAMAN_NAME: g_free (self->priv->name); self->priv->name = g_value_dup_string (value); g_print ("maman: %s\n", self->priv->name); break; case PROP_PAPA_NUMBER: self->priv->papa_number = g_value_get_uchar (value); g_print ("papa: %u\n", self->priv->papa_number); break; default: /* We don't have any other property... */ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } } static void maman_bar_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { MamanBar *self = MAMAN_BAR (object); switch (property_id) { case PROP_MAMAN_NAME: g_value_set_string (value, self->priv->name); break; case PROP_PAPA_NUMBER: g_value_set_uchar (value, self->priv->papa_number); break; default: /* We don't have any other property... */ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } } static void maman_bar_class_init (MamanBarClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); gobject_class->set_property = maman_bar_set_property; gobject_class->get_property = maman_bar_get_property; obj_properties[PROP_NAME] = g_param_spec_string ("maman-name", "Maman construct prop", "Set maman's name", "no-name-set" /* default value */, G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE); obj_properties[PROP_NUMBER] = g_param_spec_uchar ("papa-number", "Number of current Papa", "Set/Get papa's number", 0 /* minimum value */, 10 /* maximum value */, 2 /* default value */, G_PARAM_READWRITE); g_object_class_install_properties (gobject_class, N_PROPERTIES, obj_properties); } /************************************************/ /* Use */ /************************************************/ GObject *bar; GValue val = G_VALUE_INIT; bar = g_object_new (MAMAN_TYPE_SUBBAR, NULL); g_value_init (&val, G_TYPE_CHAR); g_value_set_char (&val, 11); g_object_set_property (G_OBJECT (bar), "papa-number", &val); g_value_unset (&val); |
The client code just above looks simple but a lot of things happen under the hood:
g_object_set_property
first ensures a property
with this name was registered in bar's class_init handler. If so it walks the class hierarchy,
from bottom, most derived type, to top, fundamental type to find the class
which registered that property. It then tries to convert the user-provided GValue
into a GValue whose type is that of the associated property.
If the user provides a signed char GValue, as is shown
here, and if the object's property was registered as an unsigned int,
g_value_transform
will try to transform the input signed char into
an unsigned int. Of course, the success of the transformation depends on the availability
of the required transform function. In practice, there will almost always be a transformation
[4]
which matches and conversion will be carried out if needed.
After transformation, the GValue is validated by
g_param_value_validate
which makes sure the user's
data stored in the GValue matches the characteristics specified by
the property's GParamSpec.
Here, the GParamSpec we
provided in class_init has a validation function which makes sure that the GValue
contains a value which respects the minimum and maximum bounds of the
GParamSpec. In the example above, the client's GValue does not
respect these constraints (it is set to 11, while the maximum is 10). As such, the
g_object_set_property
function will return with an error.
If the user's GValue had been set to a valid value, g_object_set_property
would have proceeded with calling the object's set_property class method. Here, since our
implementation of Foo did override this method, the code path would jump to
foo_set_property
after having retrieved from the
GParamSpec the param_id
[5]
which had been stored by
g_object_class_install_property
.
Once the property has been set by the object's set_property class method, the code path
returns to g_object_set_property
which makes sure that
the "notify" signal is emitted on the object's instance with the changed property as
parameter unless notifications were frozen by g_object_freeze_notify
.
g_object_thaw_notify
can be used to re-enable notification of
property modifications through the "notify" signal. It is important to remember that
even if properties are changed while property change notification is frozen, the "notify"
signal will be emitted once for each of these changed properties as soon as the property
change notification is thawed: no property change is lost for the "notify" signal. Signal
can only be delayed by the notification freezing mechanism.
It sounds like a tedious task to set up GValues every time when one wants to modify a property.
In practice one will rarely do this. The functions g_object_set_property
and g_object_get_property
are meant to be used by language bindings. For application there is an easier way and
that is described next.
It is interesting to note that the g_object_set
and
g_object_set_valist
(vararg version) functions can be used to set
multiple properties at once. The client code shown above can then be re-written as:
MamanBar *foo; foo = /* */; g_object_set (G_OBJECT (foo), "papa-number", 2, "maman-name", "test", NULL);
This saves us from managing the GValues that we were needing to handle when using
g_object_set_property
.
The code above will trigger one notify signal emission for each property modified.
Of course, the _get versions are also available: g_object_get
and g_object_get_valist
(vararg version) can be used to get numerous
properties at once.
These high level functions have one drawback - they don't provide a return result. One should pay attention to the argument types and ranges when using them. A known source of errors is to e.g. pass a gfloat instead of a gdouble and thus shifting all subsequent parameters by four bytes. Also forgetting the terminating NULL will lead to unexpected behaviour.
Really attentive readers now understand how g_object_new
,
g_object_newv
and g_object_new_valist
work: they parse the user-provided variable number of parameters and invoke
g_object_set
on the parameters only after the object has been successfully constructed.
Of course, the "notify" signal will be emitted for each property set.
[4] Its behaviour might not be what you expect but it is up to you to actually avoid relying on these transformations.
[5] It should be noted that the param_id used here need only to uniquely identify each GParamSpec within the FooClass such that the switch used in the set and get methods actually works. Of course, this locally-unique integer is purely an optimization: it would have been possible to use a set of if (strcmp (a, b) == 0) {} else if (strcmp (a, b) == 0) {} statements.


This package contains classes that are used to keep track of students, grade projects, and submit assignments in CS410J.
When we test student code, we run a security manager to ensure that
their code does not do anything malicious and to allow us to run
multiple invocation of a main
without the JVM exiting.
We also employ a policy file that looks like this:
// Privileges for Dave's code and student's code // Dave's code grant codeBase "file:/u/whitlock/jars/cs410J.jar", codeBase "file:/u/whitlock/jars/grader.jar", codeBase "file:/u/whitlock/jars/xerces.jar", codeBase "file:/u/sjavata/classes-dave" { // Let my code do anything permission java.security.AllPermission; }; // Student's code grant codeBase "file:/u/sjavata/classes" { permission java.file.FilePermission "${user.home}/proj2/-", "read, write"; permission java.net.SocketPermission "localhost:12345", "accept,connect,listen"; };
A command line would look like:
$ java -Djava.security.policy=/u/sjavata/grader.policy \ -cp ~/classes-dave:/u/whitlock/jars/examples.jar \ edu.pdx.cs410J.grader.TestProject0b \ -studentClasses ~/classes whitlock


Ambroise Mean
Louis Merlin
Create ripples through websocket.
Procedural creation of a tree in javascript.
Live visualization of blockchain assets.


Panda UI is an experimental set of stylesheets and web components in the
likeness (and based on the work of)
InstUI.
View my source!
Alerts
Sample success alert text.
Sample info text.
Sample error text that continues for a while to demonstrate what
happens when the content stretches over several lines. It really does
take a lot of prose to get the text to wrap when you are on a high
resolution screen.


For skateboarders, By skateboarders.
High School Vibes.
Shine at your next party.
Simpy Perfect.
When style meets comfort.


10/25/14
Maybe it is because I'm really hungry right now as I type this, and hashes sound like hash browns, but to be a Ruby-ist, you would probably need a good balance of arrays and hashes in your diet. At the core of probably any programming language, you will get the opportunity to define your variables and define your methods. Sure, you will have different types of data, whether a string, integer, or root beer floats, but do you really think a language with just that complexity is really enough? What is the point of programming anything anyways?
The point of programming is to be able to represent information so that it can be of use to people. Do you honestly think to display the things we see on the World Wide Web that elementary data types like strings, integers can be enough? Arrays and hashes make the organization of information SO much easier.
You can think of arrays and hashes like that next level of data structure, similar to a list or table of information. They are built-into Ruby and you can make a new one by typing in to your shell: "Array.new" or "Hash.new" and setting that equal to a variable name. An alternative is to type arrays with these brackets [ ] and hashes with these curly braces { }. For example, an array and a hash would be ex1=[1,2,3] and ex2={a:1,b:2,c:3} respectively. You are probably wondering what those 3 pairs are in the hash. These are called key-value pairs, where the syntax is key:value. To retrieve the first values, in these examples, we can do this for arrays
ex1[0]
=> 2
and this for hashes:
ex2[:a]
=> 1
Note that for arrays, the index number you call starts from 0. They keys and values can be any data structure for arrays and hashes.
So, can you think of why you may want to use an array or hash over the other? Arrays are useful when you just need a list of items, throwing it all into the same bucket. Perhaps you want to put together a shopping list you need to buy at the groceries today, so you can create an array called shopping_list and throw each item in there. However, hashes are useful if you need to associate your items with something else (the key). Perhaps you want to keep a database of information like you wanted to label what each person's favorite color is. In this case, your key will be the person's name while the value will be their favorite color. Another example, if secured, would be something like usernames and passwords.
So that's the basics of arrays and hashes. Hope you had your fill, and enjoy using them!


Move cursor to center point of ellipse
Press 8 .
Rubber banding previews the axis.
Move the cursor to end of axis
Press 8.
Rubber banding previews the ellipse.
Move the cursor to end of other axis
Press 8.
Ellipse is displayed and sequence released.
Enter aborts creation of an ellipse.


--- layout: post title: Flash! ha haaaaa. category: [] tags: - 35mm - antoniocapelo - fed3b - galerias - kentmere400 - night - porto - shutter hell up - street status: publish type: post published: true meta: image_url: http://antoniocapelo.com/blog/wp-content/uploads/2011/08/img332.jpg image_tag: _edit_last: '1' ---
Some nice shots and some blurry shots are the results from a night out.
Head Banger
Shine so bright
Pickin' the nose and charming the ladiesss
hand-made cigarrettes in this time of economic crisis
Looks like a Facebook-kind photo, meh =/ But it turned out nice!
The magic hour
Why u take photo?
Music+music+boy+girl-light.
Late Night


Made a game of Tetris using Racket (a functional programming language). Users can control the speed and the position of the falling blocks generated. The game also features a real time loading screen.
Made a Line Follower bot by programming an Arduino and using IR sensors to check for the white line. DC motors were used to drive the bot.
Made a remote-controlled airplane using an ESC (Electronic Speed Controller) that handles the amperage draw of the motor. The plane body was made using a plastic called coroplast. A BLDC motor was used for the main rotor and servomotors were used to control the airfoil angle.
Made a remote-controlled bot which received signals using HC-05 via bluetooth from our mobile phone and processed it using an ATTiny chip (pre-programmed) to control our bot.


Raphael is the angry one of the team. Raphael's name is usually shortened to Raph Raph is one of the four main protagonists in Teenage Mutant Ninja Turtles. And a member of the TMNT. Raphael is the Turtle who is best known for his sarcastic mouth And his a straight-up brawler. He has very little patience. Very little patience for things like stealth. Very little patience for things like hiding in shadows. Very little patience for things like keeping his voice down.
Raphael is the Turtle who is best known for his hair-trigger temper. Which are present in almost all incarnations of the character. He is characterized by a red headband. Also being the only one of the four turtles to wear it. In all forms of media. While he's fiercely loyal to his brothers. He's also often the one giving them a hard time. Raphael is also the one most likely to strike out on his own. When he feels slighted or underappreciated. His closest animal friend was his pet turtle. Knowing the world would be dangerous and there would be a time where they want to explore the outside world, Splinter trained the boys in the art of Ninjitsu. Leo and his brothers were named after great Renaissance artists from a book Splinter fished out of the storm drain. Info From Wiki Fandom
And he wields two Sai in combat. He is the younger adoptive brother of Karai Younger brother of Leonardo. And older brother of Donatello. Also older brother of Michelangelo. His pet turtle named Spike. Raphael's temper can get the better of him causing him to get into situations over his head. Him and his brothers were adopted from a pet store by Hamoto Yoshi. He is a ninja.
 He is "The Muscle" of the team. The Group's Strong Sai-lent Type. Raphael is the most violent. The most violent of the four brothers. Raphael does not like making a plan. He'd rather fight first and ask questions later. If any shellbrains try to mess with Him and his brothers, they won't know what hit them. You bad guys heard me. Raph is a kelly green mutant, ninja turtle, with goo green eye color and is the second-oldest.


Unsupervised Crosslingual Embeddings¶
Overview¶
This model uses a GAN to learn mapping between two language embeddings without supervision as demonstrated in Word Translation Without Parallel Data 1.
Files¶
nlp_architect/data/fasttext_emb.py: Defines Fasttext object for loading Fasttext embeddings
nlp_architect/models/crossling_emb.py: Defines GAN for learning crosslingual embeddings
examples/crosslingembs/train.py: Trains the model and writes final crosslingual embeddings to weight_dir directory.
examples/crosslingembs/evaluate.py: Defines graph for evaluating the quality of crosslingual embeddings
Usage¶
Main arguments which need to be passed to train.py are
emb_dir: Directory where Fasttext embeddings are present or need to be downloaded
eval_dir: Directory where evaluation dictionary is downloaded
weight_dir: Directory where final crosslingual dictionaries are defined
Use the following command to run training and generate crosslingual embeddings file:
python train.py --data_dir <embedding dir> --eval_dir <evaluation data> \
--weight_dir <save_data> --epochs 1
Example Usage¶
Make directories for storing downloaded embeddings and multi language evaluation dictionaries
mkdir data
mkdir ./data/crosslingual/dictionaries
Run training sequence pointing to embedding directory and multi language evaluation dictionaries. After training it will store the mapping weight and new cross lingual embeddings in weight_dir
python train.py --data_dir ./data --eval_dir ./data/crosslingual/dictionaries --weight_dir ./
Results¶
When trained on English and French embeddings the results for word to word translation accuracy are as follows
Eval Method |
K=1 |
K=10 |
|---|---|---|
NN |
53.0 |
74.13 |
CSLS |
81.0 |
93.0 |
References¶
- 1
Alexis Conneau, Guillaume Lample, Marc’Aurelio Ranzato, Ludovic Denoyer, Herve Jegou Word Translation Without Parallel Data https://arxiv.org/pdf/1710.04087.pdf
- 2
P.Bojanowski, E. Grave, A. Joulin, T. Mikolov, Enriching Word Vectors with Subword Information https://arxiv.org/abs/1607.04606


Marius Laubers first project was Beat!Beat!Beat!, which was an indie teenage band where he was the drummer. Years later the band separated and he became a soloist. He then released his acclaimed debut EP 'Elliot' in 2013. The lead single 'Elliot' was named as Pitchfork's 'Best New Track'. Roosevelt then released the double-A side 'Night Moves/Hold On' in 2015 on Greco-Roman, which continued a warm synth-pop, Balearic-influenced sound.
In April 2016, he announced his self-titled debut album, set for release on August 19, 2016 on Greco-Roman/City Slang, with the video for tracks "Colours" and "Moving On". He has remixed the likes of Glass Animals, Jax Jones, Truls, Sundara Karma, Luka Vasta and Kakkmaddafakka, and on tour has supported Hot Chip, Totally Enormous Extinct Dinosaurs and Crystal Fighters. In June 2018, he announced a second album, Young Romance. It was released on September 28, 2018. The first single from this album, "Under the Sun," was released on June 27, 2018.
Roosevelts very first release was an EP titled "Sea" in 2012, which really set the tone for his upcoming releases. This single centered around a funky bass riff, layered with smooth synth sounds and a complimentary vocal melody.
Roosevelt's debut album was a cocktail of disco, French touch, Ibiza house, yacht rock, and electropop that evokes some crowded Tiki-torch dancefloor lost on the Mediterranean coast. It featrued hits such as "Fever", and "Colours/Moving On".
His 2016 debut was a pleasant enough collection of bittersweet, '80s-hued love songs that marked the indie musician turned DJ/producer as one to watch. Young Romance, his second outing, sees Marius raising the bar throughout in terms of production and overall tightness, while adding some funk-lite guitar work for good measure as well.