WWDC2004 Session 430

Transcript

Kind: captions
Language: en
good afternoon my name is Mark Luttrell
engineer in the cocoa framework screw
Tiger is going to include a lot of new
Koko scripting features and the focus of
all these is to make it as easy as
possible for you to implement great
script ability the prerequisites for the
stock if you've already done a lot of
basic cocoa programming you'll find out
how to add script ability to your
existing applications if you've been
working with cocoa scripting already
you'll find out what's new and tiger
there's a bunch and if so far you've
been programming in carbon land but you
know a bunch of out script ability this
will be a good opportunity for you to
get a sort of a feel for what how Co Co
differs today I'll be specifically
talking about the new SF file format
that cocoa supports for you to declare
your script ability I'll go into a good
bit of detail about how scripting uses
key value coding a fundamental mechanism
and foundation that's being reused for a
lot of things now in cocoa I'll talk
about error handling because it's so
important I'll go into some detail about
script ability and apps that use cocoa
bindings and I'll leave you with some
debugging tins so today sample app if
you're on the cocoa dev mailing lists
you know that Scott anguish and Malcolm
Crawford have been doing a tremendous
job of answering questions about cocoa
bindings and Malcolm has actually gone
to the trouble of creating a pretty nice
little sample of how to do hook up a
custom view to bindings so on Isaac
casting about for what should i make
scriptable this seemed like a pretty
obvious choice because one of the things
I want to show you is how well binding
some scripting interact now the first
thing you do when you add script ability
to an application is that you have to
declare the script ability so that
applications like script editor that
will drive the scripting can get the
scripting dictionary can show it to the
user can compile strips and compiled
scripts and things like that and then
tiger we're adding a new mechanism to do
that new file format actually called the
SF file format
so what is there to declare for an
application script ability well as you
can see in the screenshot which is from
script editor there's scriptable classes
and their scriptable commands this is
the scripting dictionary for the
graphics bindings that i'll be showing
you and it has a document class it's
very simple it just has circles the
circles you saw on the screen there and
there is a circle class also with a
variety of properties associated with it
like the position and the color and the
radius of the circle and some shadow
aspects so there are three main
categories of things you declare in
script ability the classes that the
scripture sees the commands that the
descriptor you know the person who's
writing the script can use and then
types that are used by class properties
and command prep parameters and we have
a pretty big variety of types available
now it expanded a lot actually and tiger
but just some of the more common ones
will be using our enumerations and
records which are new and support for
some custom types too so the old way in
panther and earlier for declaring your
application script ability it was done
by providing a pair of files in your
application a script sweet file and a
script terminology file the scripts we
file with fold implementation details
and the script terminology file is full
of human readable strings to show to the
user the always these always lived in
your applications Resources directory
and there are kind of hard to work with
mostly because they're split across two
different files that you always had to
keep in sync it was a feature had
something to with internationalization
it's not being really really being used
that much and actually there are other
mechanisms in cocoa for getting roughly
the same thing so but when I say that
was hard to work with don't let me talk
you out of you know trying script
ability right now they're not that hard
to work with in in you know you don't
have to wait for Tiger to get a good
head start on adding script ability to
your application and also some of the
things we're doing while adding support
for this new scripting declaration file
format are kind of carrying over into
the script Street world so you know
warnings about things that you do wrong
and stuff like
are also being applied to the old file
formats just serendipitously so working
with them is also getting easier while
we're doing this and of course if you an
script ability to your application now
because it's such a valuable feature you
know users want to do workflow things
like that you know of course we won't
break compatibility for your application
and tiger even though we are doing some
pretty big changes so that was the old
way of doing it I won't go into too much
detail about that I actually went into
quite a bit of detail about it like two
years ago the new way which I will
discuss in detail is s def files the FF
file format itself is not new is
introduced way back in Mac OS 10.2 in
the form of some documentation and a
command-line tool called sgp that was
pretty handy you could start with an s
Steph file and it would parse that an
output carbon AE te resources as well as
Coco script sweet and script terminology
file so even though Coco didn't have
built-in support for this more
convenient file format more powerful
file format it was still useful for you
to build your script ability and I think
some applications like at Apple like
mail for instance actually they write
all their script ability support in SF
and then they use sgp during a build
phase to output the scription script
terminology files that Coco needs at
runtime but that won't be necessary
anymore what's new and Coco is that it
parses use SF files natively the still
in general will probably live in your
applications Resources directory but
Coco is not going to just load them
automatically every a Stephanie
Resources directory like it did with
scripting script terminology file
because that was pretty inconvenient in
the past scripts sweet declarations
would get loaded into every application
whether they were applicable or not and
it wasn't exactly the perfect way to do
things so now what we're going to let
you do is you specifically specify in an
entry in your applications info.plist
what the top-level scripting definition
file is in our example it's going to be
graphics findings SF one thing that
hasn't changed is a still need an entry
in your info.plist NS applescript
enabled equals yes
turn on scripting in the first place so
the access file format is xml-based
nonetheless it is easier to edit than
the old scripts we can script
terminology formats were a lot of that
use comes from the fact that it's just
one file now programmatic information
and human readable information are all
in the same file it lends itself well to
attractive informative scripting
dictionaries it's it was really designed
to represent easily the things that
users need seeds be able to write
scripts easily and if you want to get
every last bit of detail about this file
format just go to terminal and type man
s Steph there's a pretty large manual
page that declares everything in big
detail so the first category of things
that you declare in SF files or class
declarations and you're declaring your
application scripting classes which very
often have a very tight coupling with
your implementation classes you know the
ones that came about just as the result
of your design your object model but not
always sometimes there are places where
you'll have classes that are just for
scripting we need to clear classes you
typically declare the scriptable
properties of those classes and
something that's a little rarer you
declare the commands that instances
those classes can handle and I say it's
rare because the the Apple script
standard suite includes a pretty
complete set of fundamental operations
so and customizing that is very often
not necessary the scripting class
declaration has a human readable name
and description a four character code
that identifies it and if you're hoping
that I'd be saying there are no more for
character codes for people have worked
with this in the past I won't be they're
still there but we know that people hate
to work with them so we make make some
progress in that in the future so also
has implementation details like the name
of the objective c or java class and
property declarations and just a
terminology mismatch for historical
reasons we call properties and
applescript are usually called
attributes and two and relationships by
coco programmers and element class
declarations and apple script are
usually called too many relationships by
coco programmers
so here's here zooming in on that on the
circle coil of the document and the
circle class that graphics binding app
so you can see the document class is
just one element class circle so the
elements of one of these documents are
circles and there is a circle class with
the properties i mentioned earlier
here's what you do to make that sort of
thing appear in your scripting
dictionary this is part of the deck Lord
this is most of the declaration for the
circle class has a name and a human
readable description and a four
character code when I talk about four
character codes by the way I'll be
pointing you later to some documentation
the new scripting interface guidelines
it give advice about how to pick those
implementation details like the cocoa
class we have an objective c class in
our project also called circle whenever
in a nest f file you see a cocoa element
with an attribute like class after it
that's always an implementation detail
these esta files are being are made to
be read by a number of different clients
like script editor will be reading them
as well as cocoa reading them for its
own purposes so all the implementation
details are are kept separate that way
properties also have names and
descriptions and for character codes but
they also something else they have a
type so in our simple example here the
types of the exposition of the wide
positions are real you know floats and
the type of the color is a color that's
built into our system called color an
implementation detail that you get to
provide when you're declaring the class
has property properties is the key for
the property and I'm going to be talking
about key value coding key value
observing a lot today these these keys
are the strings that identify the
properties for use by these fundamental
systems and foundation cocoa command
declarations which I won't go into in
too much detail because declaring custom
commands hopefully very rare look very
similar in SF same sort of shape cocoa
aren't includes declarations of the
commands in the standard suite Get Set
move duplicate open print clothes quit
save things like that
a new feature in SF something that
people have been asking for is the
ability to in rare situations replace
our command declarations with customized
ones that have more parameters things
like that so you're going to be able to
do that now with this new file format
we've adopted and you can as always add
your own custom commands so a command
declaration has human readable name
description 24 character codes instead
of just one and then an implementation
detail like the name of the objective c
or java class that encapsulate instances
of those commands that come over as a
result of running the script and
commands have direct parameters and they
also have other kinds of parameters
these are mentioned pretty much in the
apple script language guide but we do
let you declare them with great fidelity
so you're able to do things that match
exactly what people who've read the
apple script language guide would expect
and if a command has a return code you
get to declare the type of that too just
a quick example the send command from
males script ability declared as an f
stuff is very simple as a name of
description parent for character codes
and this one has a direct parameter that
represents the receiver of the command
in this case the type of the receiver
will be a message message is another
class it's also declared in mail script
ability so basic types that you get to
use the set is a is pretty clean the
names that you use in the SF are pretty
much the human readable names that users
see in scripting dictionaries when
they're opening up and script editor or
something like that so we provide the
set that people are expecting things
like boolean color date file integer
real so on each of these maps to a Coco
class so that your script ability code
will get an instance of the Coco class
and ever one of those fundamental types
appears in the script so bullion's map
to NS numbers integers also mapped to NS
numbers colors map to NS colors and so
on
another type that you'll see in SF is
the specifier type corresponds to an
applescript reference what's called an
apple script language guide a reference
and in cocoa the class that represents
this is ana Script object specifier and
a specifier identifies one or more
scriptable objects like words four
through eight of text of you know a text
at a document or something like that and
here's the example use of that just the
clothes command has a direct parameter
that represents the receivers of the
clothes command and the type is
specifier which means that you send a
clothe command to a set of objects that
are specified like for example you know
documents 1 through 3 or something like
that another type that you'll see in FF
is a location specifier which is a lot
like a specifier but not quite it
corresponds to an apple script language
guide insertion point and in cocoa the
classes used to represent this is an ass
traditional specifier and it identifies
an object location which will very often
be the same as the location of an actual
object sometimes it'll be the position
before or after a specified object and
here's an example use the standard
sweets move command has a two parameter
very popular to name parameters with
prepositions so in this case this very
fundamental command the two parameter
its type of location specifier so you're
specifying the location to which things
should be moved
some more types that you get to use in
SF another one is enumerations if you've
been programming in C this is a very old
news it's the same concept an apple
script there there named values here's
an example it's the declaration for the
printing error handling enumeration
which is used by the new enhanced print
apple event about which a tech note
appeared on our web about a year ago so
when you when you send a print command
to an application that supports
everything properly you get to specify
what kind of post script error handling
gets done detailed or or standard so and
that's specified just with an
enumeration so scripters don't have to
type in integers or things like that of
ancient applescript concept is the list
type but Coco hasn't really supported it
properly until now in tiger it will you
can preface just about any type name
with list of and that indicates that it
should be one or more of those things
your implementation in this case will
always be passed in this example for
list of file an NS array of NS URLs so
even when the script specifies for
example just one file we want to make it
very easy for your implementation code
not to have to to check multiple types
you know is it a Baroness URL is in an
NS array of URLs if you declared list of
file you'll always get an NS array of NS
URLs a new feature an F staff that we
think will turn out to be pretty useful
as complex types and i don't mean has a
real and imaginary part i mean that the
type is is one of a variety of different
types alternative types so this is this
will be useful in situations like
specifying the address book label in
address book scripting for a phone
number or an email message you can say
home or work or something like that you
can just do this with a string if you
want but there's a little bit more
checking that can go on it compile time
if you support
either a string for custom labels or one
of an enumeration for predefined labels
so and this not only lets scriptures
write what they want to write it lets
them know that they can write it because
information about this actually appears
in the scripting dictionary so scripting
dictionaries and esta are going to be
much richer filled with a lot more hints
descriptors about what they can actually
do what's worth trying and here's the
sample from the standard enhanced print
apple event the type of the direct
parameter the receiver of this command
is list of file or specifier which means
you can either print a list of files or
one file that is being picked picked
with the standard file chooser dialog or
something like that or a specifier for
example a list of documents that are
already open you can print those two
so something that s Steph has that the
older mechanisms didn't have is a way to
take real control over the reuse of
cocos standard declarations as I
mentioned cocoa doesn't automatically
just read all its own files anymore it
makes you import them so you'll have
much better control this is done with an
import tag and here's a sample of what
it will look like import name equals
foundation standard commands esta will
be bundling up all of our standard
command declarations in a nest f and you
can import them if you want to save
space and your own nest step and also to
take advantage of when we add new
standard command should that ever happen
or if you're doing heavy customization
you can just you know copy and paste
that all into your own half step and
make sure that you have complete control
over what goes on import can specify
more than just s def files that are in
one of the frameworks that the
application is linked against it can
specify esta files that are in other
bundles for instance or even anywhere at
all there's their forms of it the
specify for instance even absolute path
so this will be useful for example you
are going to be given the opportunity to
build your top level s step on the fly
if for example you have an application
that's heavily plug-in based and the
script abilities spread among many
different plugins potentially you're
going to be able to do that pretty
easily the mechanism how this appears in
cocoa is a little little undefined right
now there's probably going to be an
application delegate or something like
that but the the info.plist declarations
are already defined to support this
dynamic s def concept and and you'll
definitely be able to do that something
else that cocoa has been lacking but we
now have because we've adopted a stuff
is called the class extension tag and if
you've been working with Objective C and
you know all about categories it's
pretty much the same thing so actually
you can do a few of things that you
wouldn't expect to be able to do with
categories
so we're putting this here for one
reason it's going to be it's going to
make putting script ability and bundles
eat it easier so if you have a bundle or
a plug-in that adds properties to the
top level application class this is how
you'll do it you'll extend the
application class in the past people
have had to do strange things like
subclassing the application class even
when there wasn't really much reason to
do that except we didn't provide a
better way so now we are providing a
better way other features if you've been
working with cocoa scripting and you've
seen the scripting dictionaries that
result where things are a little bit
randomized that's because the script
sweet format is property list based and
what's more is using property lists
dictionaries which of course have no
inherent order so things get get moved
around a little bit and you can't really
control how things are presented to the
user that the writer of the scripts s
steph has no such problem a big feature
of a staff is that it's because it's
going to be a file format that's shared
outside of just cocoa there's actually
API in the OS a framework for reading
these they're going to be recognized
natively by script editor and presumably
hopefully other scripting tools too and
the result of that is that when script
editor or some similar application needs
to get at the scripting dictionary so
that it can compile a script or just
show it to the user they're not going to
have to launch your application to do it
it just has to look in your info.plist
and yes very old news in the carbon
world and Coco is finally catching up in
this regard so yeah there won't be any
more application watching script editor
we'll just dig around in the info.plist
and and you know we'll be able to to you
know follow the imports and things like
that one caveat for that with that by
the way is that if you're doing the
dynamic SF feature well just as in you
know old carbon tradition well then your
application will still have to be
launched so that you can actually build
it right then
other features SF includes help for
letting you provide backwards script
compatibility when you're rearranging
your scripting and seems that you know
nobody ever gets it right on the first
try you want to remove things you want
to rename things but you don't want to
break you know people's existing scripts
gratuitously that's kind of rude so
estephe has a couple features like the
hidden tag which means if you have you
know an element class or a command or
something like that that you're
deprecating is not you know you'll want
it on anymore it's just crossed you know
you can leave that in there so that
existing scripts keep running but new
users who open up your scripting
dictionary and look at it won't ever
know that those ever existed there
hidden so and the synonym tag fixes
similar problems when you're renaming
things or you know getting the fourth
character codes just write or something
like that one thing that's been a source
of big confusion in cocoa is how we
handle the scription of files and with s
def we're really going to be cleaning it
up there is a single type it's a public
type it's called file and it's public
unlike the old nsstring file path that
some of you are using in your scripts
weed files this one is genuinely public
and of course you can use list of file
and when you do your code will always
get an NS array of URLs and scriptures
you know the magic of Apple event
coercion gets use files aliases HFS pass
POSIX pass whatever they're most
comfortable with and your code will
never be able to tell the difference it
always just gets URL
so implementing your application script
ability you've declared it to the
outside world and now you actually want
to hook it up and make it work and this
requires you to know all about key value
coding and this isn't a change in Tiger
cocoa scripting has always been built on
top of key value coding now what that
means you have to make your scriptable
classes key value coding compliant and
just to do the same old terminology
review properties or attributes and
element classes are too many
relationships what does key value coding
do well first of all it's worth
mentioning that's the same mechanism
that cocoa bindings and now a core data
uses it gives access to object
properties using a very generic API that
identifies them by key and keys in this
case or just strings like in today's
example of the graphics bindings
application the circles of a graphics
binding document or the color or the
radius of one of those circles so the
same cheese that appear in SF files and
are actually also used in i beez
bindings inspector are used throughout
this API so it'll be kb c compliant the
short turfs answer is you have to
implement enough methods or whatever to
make these two methods in nsobject work
value for key and set value for key so
the quick and easy way to do that is for
each one of the keys implement a method
that has the exact same name as the key
so that when Coco scripting calls are
invoked value for key value for key is
smart enough to root around and your
classes method list and find that key
method and invoke it if the property is
mutable is read right then you also
implement a set key method and these are
just as simple looking as they sound for
our radius property where the KBC key is
radius there's method name radius and
there's a method names named set radius
creech to many relationship for each
collection of pointers to other objects
that you're scriptable has you have a
choice of how you implement that
typically you would again implement a
method named key that would return an NS
array a collection of the related
objects but sometimes for implementation
reasons complexities arise and you don't
have the pointers to the other objects
stored in an array if that's the case
and instead of implementing key just
implement count of key and object in key
at index and again key is replaced by
the actual key that we're talking about
and key value coding is smart enough it
will find those methods and use them
when it needs to so how do you decide
between the two of them just whichever
is easiest to implement is the general
rule if you change your mind later
perhaps as a result of measuring and you
know doing performance analysis it
really it makes no difference there's
nothing outside of key value coding
that's really going to see this unless
of course you declare these methods in a
header and show them to other
programmers on your project for each
mutable to many relationship where
objects can be inserted or removed you
know via scripting via cocoa bindings
via core data you would also implement
insert and remove methods whose names
fall the patterns you see here so a
quick sample the graphics binding
applications document class as a circles
relationship all the accessories that
key value coding needs are right here so
circles return as a pointer returns an
I've our insert object and circles that
index remove objects from circles that
index just invoke the regular NS mutable
array methods so that was just the tip
of the iceberg as far as what key value
coding lets you do you know writing
writing having you write accessor
methods is the simple way to introduce
it and is what people are most
comfortable with right off the bat
key-value coating has a couple other
different ways to grub in your objects
it even has direct Ivar access
so you don't even have to write any
accessor methods at all you just have to
give your I've are the same name as the
key and key value coatings value for key
and set value for key methods will poke
in it poke at it directly this is kind
of nice because of course it's lets less
code and it's also kind of nice because
if you do have to add code you actually
have to do something when somebody sets
the value you have to you know make
something else consistent or something
like that you can add the fed accessor
method and key value coating will simply
start using it it'll stop drubbing at
the I've are directly and use your set
accessor method so it's we have
different layers of functionality for
you to use depending on how much
customization you need to do how much
code you're willing to write you know it
goes all the way from virtually no code
to not that much code so so see the
documentation where this is all now
described in great detail for even
greater details see the turgid pros and
the NFC value coding dot H header file
which explains the default
implementations of methods like value
for key and set value for key and just
excruciating detail so great error
handling is worth singling out because
it's something that cocoa scripting
hasn't done so well in the past and it
is tremendously important error handling
is important because it helps scriptures
learn the language you know they learn
by doing that the scripting language
they learn by experimenting making
mistakes they need feedback about what
their mistake was so I'm as a nice side
benefit when you're testing your script
ability good error handling you know
helps you debug too we've made big
improvements to our hair and error
handling if you've our scripted akoukou
app and gotten it wrong or works with
things like apple scripts to do and
gotten it wrong you've seen these
incredibly unfriendly error messages
like NS cannot create command script
error entire messages like those will be
just completely disappearing we're just
going to do
we're just going to be doing the normal
apple event error messages that we
should have been doing all on so let me
show you what I mean so this is the
graphics binding project that I was just
telling you about let me just point you
at the eff stuff real quick here are
some import directives in the shipping
version of tiger these will actually be
a little more complicated because I'll
actually point to things in cocoa but
right now I just copy these standard s
steps into the project to demonstrate it
here so some imports of the standard
types and item and commands and classes
that are built into cocoa here's that
circle class I was telling you about
very simple implementation details are
tagged with the coco key element and
this is interesting down here you see
these have no coco key and it's because
there's a default value for those in
this case it's just color or radius or
shadow angle so it tries to save you a
little bit of typing but if you want to
be explicit that's okay too
so the class the actual source code is
pretty simple here is the the accessors
for the radius methods and really these
aren't even actually necessary either
but if you get things get a little
complicated you do have to start writing
accessor methods this is what they look
like
so let's launch graphics bindings so I
can show it to you here it is it's
pretty neat it's like super dot view
something like that so you can do things
like select different dots and this is
all done with cocoa bindings with very
little code there's a good bit of a good
bit of code in the actual view the
graphics view that you're seeing here
but that's meant to be highly reusable
the rest of it is is nearly nothing so
you can move things around you can
select a bunch of them there's this neat
little joystick control for moving the
shadows around of course the the
controls take effect on you know the
entire selection at the time so to
script that a little bit and here we are
so in an even simpler document
that does not actually work quite yet so
and plus this was already compiled
anyway so but its standard apple script
you know you get to do things like
setting the radius and apple event
coercion xand things like that work so
you get to set the radius to an actual
text string and if you tether test set
it to something that's complete nonsense
finally it actually says so hopefully
you can all read it it says cannot make
gobbledygook into type real which is
what it should have said all along and
we'll be doing more than just type
errors checking for indexes and things
like that graphics binding cannot get an
error can't get documents seven invalid
index because there's only one of them
open
that's it it's not supposed to be
anything earth-shattering so it just
works now so the kind of things that
cocoa is going to be check be able to
check for you are when the scripture
uses the wrong types nonsense object
specifiers you know document for of word
aight might not really be what they
intended to type we're going to catch
stuff like that things like out of range
index specifiers we're going to be able
to catch pretty much everything except
invalid property values pretty much so
when you want to clamp the values of
numbers or something like that cocoa
can't catch that for you everything else
it will what you're going to be doing
and this is not implemented in the seed
right here is use the standard key value
coding compliant or the standard key
value coding mechanism there's a method
on nsobject called validate value for
key error and what you'll be doing is
just implementing the method whose name
is validate key error to return an error
so validate radius colon ericone so and
what's really great about this is it's
tremendous code reviews because the
exact same mechanism that cocoa bindings
uses in more complicated situations if
you end up implementing your own custom
commands you should know about these
methods I think these are all added in
Panther actually an S script command
current command they weren't all added
current command misamis will get you
they can be the script command that's
being executed right now so if your
accessor method is being called and you
know you want to set an error number and
enter something like that this is how
you find out number one whether or not
your code is being called because of
scripting it's all meant to be highly
reusable like being being called because
of cocoa bindings or core data but if
it's being called because of scripting
there will be a current command and one
of the things you can do if something
goes wrong is to send that current
command set script error number now you
shouldn't just you know pick a number
out of the ether
for you you know or you may end up have
to having to but before you do that have
a look at the Apple script language
guide we're a bunch of error codes the
people who write scripts are expecting
to see are documented so and they're all
declared as constants in carbon core mac
types H which is typically import by
with the Umbrella headers so core
services core services done H there's
another method on ms script command
called set script error string don't use
this gratuitous ly like we were that's
how we ended up with things like NS
cannot create command script error if
you're using one of the numbers that
Apple script recognizes and it
recognizes a bunch don't set any air
string just set the number an apple
script will pick the right string for
you and when talking about error
handling it is worth focusing on the
specific brand of error handling type
checking because in addition to all the
other things where you want to help
scriptures experiment there's a big
reliability issue here that you might
not have realized I'll implementing your
own script ability if you haven't if
you've been doing so is that it's
possible for scriptures to crash your
app by arranging for objects of just the
wrong time to be passed to your code so
we're going to be closing that up
because FF has a very good support for
declaring exactly the types that your
implementation can handle cocos guard is
going to make sure that your
implementation is only past objects of
the exact right type too so and as a
result of the good type declaration the
user is going to get good hints about
what their scripts can do so sometimes
in in when in programming systems when
there's a lot of type checking that can
you know impinge flexibility but in this
case we don't think it will we think
there'll be more flexibility now because
Apple events upon which all the
scripting stuff is built has always had
a pretty good app levent coercion scheme
for coercing things of one type to
another and when cocoa has good type
information it's going to it uses that
proper
so the user will be able to you know do
things that are close enough typing in
text in you know taking in the number
and textual form instead of actually
getting the number right script ability
and cocoa bindings cocoa bindings is
hopefully all know by now is a big new
technology that was introduced last
year's WWDC for creating user interfaces
with not a lot of glue code we are
making improvements to how nicely script
ability interacts with that so both the
script ability and cocoa beans and now
core data to use key value coding very
heavily so when you make your classes
key value coding compliant you're
killing two or three birds with one
stone we also introduced last year
something that goes on top of key value
coating called key value observing now
script ability is not interested in key
value observing there's no way to write
a script that you know observes objects
in another application though that would
be very interesting it just sends I key
value coding but the same classes are
very often implemented or are very often
reused between script ability and
bindings so for bindings you have to be
Keeley observing compliant and we've
we've made some improvements to how
scripting uses KBC to make that easier
for you so Coco scripting now uses set
value for key which is a new method that
was introduced last year this is because
this makes it easier for you to use the
automatic kvo notification feature
you'll take value for key method which
scripting was using is now deprecated if
you have existing code and you're
overriding it for for some reason will
still invoke it in that case because we
don't want to break your application but
we encourage you to move to the newer
method because it works properly with
kbl something else that was added to key
value coding as part of the Coco
bindings feature is a new method called
mutable array value for key when I was
talking about those insert and remove
methods that you have to implement on
your too many relationships
this is the method that has the smarts
to go find those and again it takes
advantage of this automatic kvo
notification feature where key value
observers are notified merely because
you know a set accessor or an insertion
method to remove methodism is a invoked
and just as in the simpler case old
methods like insert valued index and
property with key will continue to be
invoked in Tiger for well for the
foreseeable future for backwards
compatibility reasons so automatic kvo
means because you have to be key value
coding compliant anyway for all your
properties that you're making scriptable
means that you're probably already KVL
compliant for those same properties so
you can do things like binding to them
from the user interface so for example
how this works when your scripting
object its end set value for key because
the user descriptor ran a script like
set radius of circle one a front
document something like that set value
for key will call and find your set key
method but then it also goes ahead and
does and notifies observers like bound
UI objects of that change too so the UI
will update automatically without you
having to write anything into your
accessory for too many relationships
mutable array value for key is used by
Coco scripting now how that works is
Coco scripting calls mutable array value
for key and what's returned is actually
collection proxy that represents the
relationship that your class has to
those other objects like an NS graphics
bindings documents relationship to
circles so it's returned looks just like
an NS mutable array to the client Coco
scripting themself in this case and as
NS mutable array API is used to insert
and remove or replace objects the
container objects insert object and key
to index and remove methods are invoked
automatically so the the client of Qi
decoding has a tremendous amount of
flexibility about what they can do
anything that an NS mutable array can do
including things add in categories but
the the owner of that relationship only
has to implement a pair of methods and
as all this happens bound UI objects get
updated automatically I've been talking
about automatic kvo notion notification
so i guess i should mention manual kto
notification just so you know what why
we bother to call it automatic at all
because there's a there's another system
too and they coexist very well you can
have kbo automatic kbo notification
turned on for class and then also use
manual kvo notification for more
complicated situations shouldn't be
needed that often for scriptable
properties but you can use it for
example when your your class is changing
its own ivars directly outside of a que
vc compliance method like set key and
it's pretty easy to use you just do it
will change value for key before the
change and it did change value for key
after the change so I'd like to leave
you some with some hints about debugging
your application script ability there's
a lot of logging available that cocoa
scripting will do to help you figure out
what's going wrong and also every time
we touch this stuff we seem to add or
clean up a description method in any of
the cocoa scripting classes so logging
cocoa as we wrote in the support for a
staff we made sure that all the errors
and warnings that it spits out are
useful so I'll demonstrate that in a
little bit so mistakes that you make are
easy to pin down instead of things just
going mysteriously wrong and we also
added this support for warnings and
errors improvements serendipitously to
the old file formats to scripts we in
the script terminology so when you see
these fix the warnings they all actually
mean something
and if it's not descriptive enough you
know send an email to one of the public
lists or two you know Coco feedback or
something like that you can have Coco
log information about every scriptable
command as it happens just with a simple
default defaults write and its global
domain and a scripting debug log level
one and if you only want to turn on
logging for one application substitute
and its global domain with the bundle
identifier for that application I
mentioned that we added a bunch of
description methods to classes one of
them is NS script sweet registry and
then all the classes like in this class
description and a script command
description things like that so if you
want to see what Coco pulled out of your
f Steph file or your old scripts read
file just break the application anywhere
and type what you see here p 0 NS
classroom string in the scripts
eregistry shared scripts free registry
will send a description message to the
scripts free registry and just an
enormous amount of information will be
presented to you so you can see exactly
what Coco thinks you said about your
application script ability there's some
other description methods to and a
script command has one I don't know if
if everybody's found it yet if you're in
the middle of one of your script ability
accessories and you're wondering why was
this called you know you're watching
script editor send events but it's still
not obvious then you can print a
description of the current command so
and if you are an old Apple events hand
and you want to see what Apple event
resulted in the creation of that NS
script command you can get the apple
event from the current command and print
its description too so demo
so let's very quickly just do something
stupid in our F def file
[Music]
and I just you know fat fingered one of
the type names here and cause the
dictionary to be loaded and it now gives
you a super informative message that
will help people debug SF warning for
attribute display name of class document
and sweet graphics bindings sweet Strang
is not a valid typing so we're trying to
help it make it easier you can debug
this stuff so I won't leave that broken
and just read launch graphics binding
again and let's look and all the
information that's available to help you
bug this stuff
so a tremendous amount of stuff so and
this is important because people had you
know a good bit of difficulty in
diagnosing their mistakes so now we're
going to you know make it easy for you
to see exactly what's going on so in
this circle class there's pretty much
every information that can be everything
that's worth knowing this here and while
I'm here let me show you another
debugging trick that I think you'll like
let me see here let me put a breakpoint
on one of our simple accessor methods so
just set radius and continue that
let's just cause it to be called with a
simple script so set radius there we go
so let me show you what Coco scripting
is doing right here by the way if you
follow the stack trace you know that the
apple event manager is getting the apple
event this Coco's apple event manager
making a script command out of it
executing the script command and this is
the set command it eventually boils down
to a call to the key value coding set
value for key method which is smart
enough to call your set radius method
now this one is interesting if you look
at this if you take a peek at one of
these private function names and a float
value and notify what is n notify mean
well it means it means that their key
value observers registered with this
object as a result of the bindings that
are in the UI of this program and it's
going to tell them that the value
changed even though this method does
almost nothing so let me put a good
break point at the method that does that
and the way automatic kvo works by the
way is it causes indications of will
change value for key and did change
value for key around the invocation of
your set method so let's put a
breakpoint around did change value for
key and continue and Xcode wants my
attention but I don't want to talk to so
set float value and notify just finished
calling your set accessor now it's
calling bid change value for key so it's
going to send did change value for key
is where notifications are sent to any
observers so if you've been working with
cocoa bindings by the way you might have
had some trouble figuring out who's
observing who let me show you this
little trick right now
p 0 self-observation info observation
info is declared as a void starts an
opaque type I don't want you to digging
around in there too much I don't want
you to write dependencies on the
internal structure of that but it's okay
to take peace so here's what it outputs
this object is one of the circles and
graphics binding and there's observers
of its shadow offset property color
radius shadow angle X lock why lock it's
because the graphics view is observing
all this stuff so that it knows whether
or not to redraw the circle so great
deal of information there for you so
that's it for demos so so one thing
we've learned over the past year since
releasing the cocoa bindings
functionality is that we achieved of our
goals and helping you to write not much
not much code but i think we ramped up
the the learning curve a little bit for
cocoa so and a big part of that is is
debug ability and if you are at the
cocoa binding session a couple of days
ago you know we pointed you to a new
default that we're adding for binding to
get give you more logging of what goes
on in bindings we're going to be doing
more stuff like that we want to make it
as easy as possible for you to find your
mistakes while you're learning to use
this stuff quickly so you'll you'll see
more you know description stuff more
logging special defaults that you know
you can turn on to do sources trickery
things like that so before I go I want
you to point point you to this very
important that i can make sure
absolutely everybody is reddit the
scripting interface guidelines which are
pretty new but they're not that nude i
think about four months old now there's
there since last WC though and i want
you to read this because consistency
across apps is tremendously important in
script ability just like as it is in
regular graphical user interfaces people
you know want to learn stuff once and
real
client over and over again following the
guidelines helps them do that it makes
your scriptable application look better
it makes other scriptable applications
look better too when everybody's looking
the same so Coco itself of course either
follow these rules scrupulously right
now or is about to start following these
rules scrupulously or we might just
change some of the rules a little bit so
but in general what Coco does is going
to be perfectly consistent with what we
suggest you do so and you know we're
making it easy for you to follow these
guidelines yourself and now that you
know about this read this if you're
going to buy about to start work on a
new application and you haven't read
this yet read it now because it actually
has some design advice about how you can
save yourself a little bit work later
and and things like that so it's a
developer apple com tech notes it's
number it's number 2 106 so for more
information you can go to our website
and just click click click away or you
can send an email to Matt Formica