WWDC2000 Session 143

Transcript

Kind: captions
Language: en
ladies and gentlemen please welcome
carbon technology manager David Wright
thank you welcome to session 143 high
level toolbox carbon enhancement one so
carbon Mac os10 the theme of this week
we cannot wait to get your applications
onto Mac os10 they've already been a
number of sessions this week letting you
know about some of the in my session i
called them closed roads and detours
there'll be a few more in this session
but we're also adding a lot of
functionality to carbon to make your
development lies you here again there
Rob already been sessions about that
this week carbon events being one of
them and so I was thinking about the
title of the high-level toolbox what
does that mean high level and I think
that another cool theme of this week is
that the high level toolbox is beginning
to do more and more on behalf of your
application thus making it even higher
so anyway to talk more about that I'd
like to introduce Pete gontier from the
high level toolbox team please welcome
Pete so you've been hearing a lot about
aqua this week and it's certainly the
case that the high level toolbox it is
enhancing growing and being enhanced in
order to make your job easier in
implementing aqua but it's also growing
enhancing just because it needs to grow
and enhance in order to stay a living
thing so we've added lots of features
some of which have to do with aqua some
of which don't and that's what we'll be
talking about in this session I want to
approach this topic from a couple of
different directions the first one we're
calling architectural changes and the
architectural changes have the view with
stuff that you pretty much need to do in
order to adopt carbon in order to
carbonize your application and those
things include such things as the fact
that window layering is now enforced
it's no longer optional you can't you
can't choose use it or not you pretty
much got to live with it route controls
are always created for any window that
has controls many rest is now opaque
which shouldn't be any surprise to
anybody who's been hearing about carbon
all this time we've been creating the
more opacity in the toolbox but with
respect to many refs it's met it's it's
a matter of some interesting semantic
changes that have more to do with or
have less to do with accessors and more
to do with your application code and the
scrap manager needed to change for
carbon and particularly for mac OS 10
which means that carbon lib also had to
change so we'll be talking a little bit
about that the second category of things
I want to talk about are the cool new
features we've been adding that you
aren't obligated to adopt but once you
learn about them you'll realize you want
to adopt them the first big category or
the first big subcategory there is the
menu manager we've been adding a lot of
stuff in recent versions of the OS to
control manager and window manager and
many managers sort and sort of been a
little bit neglected we've added a few
features here and there but in carbon
menu manager is really catching up in
terms of feature list we've also added a
whole new manager called help tag
manager and this is basically the
replacement for balloon help and we'll
be talking a little bit about that we've
added some new control creation ap is
there more intuitive they make more
sense you don't have to worry about
overridden parameters and there are some
whole new standard controls that we've
added mostly to support aqua but partly
to support you so
said something about window layering
earlier window lang of course is done
according to class the way it always has
been so when you create Windows you need
to be very conscious of the class that
you're creating because that will
basically imply the layer the window
will fall into in addition to that we've
also changed some existing window
manager api's so that they operate
within the layer of the window that you
pass to those API so when you call
select window or send behind you'll find
that the window is only changed
according to only change within its own
layer so if you have a document window
and you pass it to select window it's
not going to jump in front of your
floating palette windows it's just going
to come become the frontmost document
window the other API that's changing is
front window front well excuse me the
API that's not changing his front window
and you have to watch out for that
because when you call a front window you
will get the front window even if it's a
floating palette irrespective of layer
so if you need to be aware of the front
window the layer you need to actually
use the specific call get front window
of class instead of front window in Mac
OS 10 because we need to plan for future
enhancements we want to do to the
control manager we pretty much need to
require that your windows which have any
controls have root controls and
basically what happens is when you
create your first control we check to
see if there's already a route control
in that window and if there isn't then
we create one for you now but I said
just now that is this is a Mac os10
feature this might cause you trouble if
you're thinking oh no now I have to
write conditional code to figure out mi
on Mac os10 is there a route control
well the simple solution is during part
of your carpet as a part of your
carbonization process just add a call to
create route control and always create a
route control for all of your windows
that have controlled
it's a simple thing to do and it will
simplify your life in the long run
you'll always have a route control on
nine and on ten the one part of this is
not automatic is the route control
pretty much sticks around once it's been
created even if created automatically it
doesn't go away just because you deleted
all the child controls now this new
mandatory route control has some
implications for the dialogue manager
what you want the basically the moral
equivalent of creating a route control
and a dialogue is setting the youth
control hierarchy bit in your dialogue
resource and your dl GX resource I
should say but that bit really controls
two things one it ensures that you have
a control hierarchy in your dialogue but
the other thing is that it makes all of
your items into controls and once
they've become controlled you need to be
careful about how you access your
dialogue items and specifically you need
to be careful with set dialogue item
text because it expect it expect to
control now and that's done that's done
because of compatibility set dialogue
item text needs to search all of the
dialogue item lists and all the
dialogues in your application because
the API is not defined so as to allow us
to do anything else so it needs to find
that control handle in the dialogue item
in the dialogue that you care about and
the only way it can do that is by taking
a control hand control wrap now the
really clean thing for you to do is not
do this tricky typecasting thing to make
set dialogue item text like excuse me to
make set dialogue item text work the the
cleaner thing to do is to just use set
control data and pass it the tags for
the text of the item and the last sort
of implication for dialogues and the
mandatory route control is you basically
want to set this bit not only to make
your life easier but also because it's
the only way you can get
with savvy text in your edit text item
so I mentioned menu reps are now opaque
which should be no surprise but it's not
just a matter of of calling some new
access or function instead of directing
directly accessing the menu records we
would get menu used to work is that it
used to hand you back a resource handle
that came from a mini resource and it
would post process the resource hand a
little bit but pretty much it was a
resource handle and if you call get menu
over and over and over again you get the
same handle over and over and over again
that's no longer true get menu now
return to you a menu refs which is based
on the menu resource so it's not as if
you have to throw out your many
resources but that is a basically a
unique copy of that resource use it as a
template so not only can you not assume
that you've got a resource handle and
you'll get the same one every time but
you should also instead of calling
release resource which some
documentation tells you to do not many
people do it but that's what that's what
the recommendation used to be now we're
telling you go ahead and go call
disclose menu forget about release
resource because the menu is not a
resource so of course there are some
access or functions as a result of menu
ref opacity one of them is called
duplicate menu and it replaces the
ability you used to have to use the
memory manager say you might call hand
to hand to duplicate a menu well you
can't do that anymore because many refs
aren't handles anymore and then of
course copy menu items provides you with
the functionality you need to reach into
a menu and pull out specific items and
copy them into some other menu and of
course you used to be able to do that by
simple pointer arithmetic or actually it
was complicated pointer arithmetic in
any case we've given you an API now so
that you can reach in and do that same
stuff
the scrap manager is I hesitate to say
it's a new API pretty much what is an
old API with a lot of new names and a
few changes pretty much you still get
things from the scratch you still put
things on the scrap you still zero the
scrap or as we say in the new term law
terminology you clear the scrap but
basically we had to make some changes to
the scrap manager in in order to support
the way events work on Mac OS 10 on 9
your app would get a suspender vent and
if you were maintaining a private scrap
that the scrap manager didn't know about
yet you would take the suspend event as
your clue that it was time to export
your private scrap to the public scrap
on 10 suspend event work significantly
differently went by the time you've
received a suspended nth it's very
likely that your application has already
been pushed towards the background
because of pre-emptive multitasking and
so if you at that point try to export
your scrap it won't work because
background applications can't put things
on the scrap while we were in there
making these architectural changes to
the scrap manager we decided it was a
good time to add some features as well
so we added flavor flag and flavors legs
are pretty much like the drag manager
let me step back from on I didn't
explain the whole promise thing so to
replace the suspend event from a process
we added a promise feature which is much
like the drag manager you basically
supply a callback you associate it with
a scrap and when some other application
requests the data that you promise you
get called back and you provide the data
on the fly now when you make these
promises is pretty critical you want to
make these promises when the user
performs a copy operation are cut
operations you don't have to supply any
data up front but you do have to say I
have data of a certain type
and you may optionally if you know
supply the size of the data as well but
that's optional and the reason you want
to do this at this time is that there's
really no better time to do it because
otherwise you'll just be sitting in your
event loop waiting for an event come in
and by the time you receive your suspend
event it's too late so you really do
need to do the promising when the user
issues a command so now let's go back to
flavor flag flavor flags are also like
work very similarly to the flavor flags
and drag manager you can specify a
sender only flavor you can spend you can
test for whether a flavor that you are
pulling in from the scrap has been
translated and a previous session we
talked about translation manager and
that's what that bit is intended to be
used for we also added some api's for
introspection you used to be able to
look in low memory grab the scrap handle
out of low memory and then walk around
inside the scrap handle in order to
determine what flavors were on the scrap
how big they were and maybe even peek at
their data now you need to use some
clean API that basically tell you all
the same things in a way that we can
support into the future so I said that
many manager was catching up and the
menu manager is catching up so much that
we cannot cover all of the things that
have been added to the menu manager in
this session is you see there's a long
list there and we'll cover most of those
things but the last item is almost the
most important one because there are
probably six or seven important things
that we just don't have time to cover
and you can learn more by looking in the
headers and experimenting with the new
AP is and then maybe sending us feedback
to get the documentation finished sooner
but that's that's really important part
but I wish I could cover but just don't
have time for so before I go into too
much detail about the menu manager I
want to bring out guy Fullerton
shows a demo of some of these new
capabilities guy so it looks like all my
dark little sessions are coming out of
the conference we feel the water sure ok
so if Pete mentioned we've got an awful
lot of new features in the menu manager
I'm only going to touch on a few of them
but they're kind of the cooler ones
we've got a simple little application
here I showed this off in the Aqua
overview demo takes advantage of a few
of the new menu manager features first
one I want to touch on is the inclusion
of this font menu this font menu is
actually implemented by the system your
application can have any given menu and
it can call an API to tell the system
please put all the standard font
commands in its menu for me we even
offer a mechanism it's actually an
option bit that people talk about that
lets us hang submenus off of each of the
fonts that has the different types of
fonts available so in this case oh I
don't know Lusa that has a bold in a
regular version and those are both
automatically hung off the menu and the
system will keep track of the submenu
management for you automatically we also
provide some api's that allow you to
take a given menu selection and ask them
any manager hey what kind of font was it
so you can take that font and run with
it the other cool thing I want to show
off is something that we've needed for a
long time now and it's probably gets
requested every year and that's the
inclusion of dynamic menu items so you
might see something like this in one of
today's applications where you have a
bunch of commands and the commands names
are basically the same they have
basically the same functionality as well
with slightly different behavior I have
a blend command this blend command is
going to pop up a dialog and ask for all
kinds of custom information but you
might want to do a fast blend with the
last set of information so you need too
many commands on there and a lot of your
applications were relying on your own
custom MDF to do something that we call
dynamic menus and dynamic menus is a
technology that takes a menu that looks
like this and turns it into a menu that
looks like that it's the same basic
commands
we only show one of each variant in the
menu at a time and as I change the
modifier keys I hold down we simply
change the menu command that's
appropriate and you can have different
commands you can put different menu menu
manager command IDs between each item
and so that you know you can find out
what these are selected on a command ID
basis so the next thing I want to do is
actually show you how I implemented that
it's actually really really
straightforward the first step is done
just in your menu resource or if you're
using interface builder you can do it
straight in the nib resource this is the
menu that did not have any dynamic menu
commands in it your dynamic menu
resource or nib looks basically the same
in a dynamic menu if you have one item
that has three variants there are really
three menu items behind that one item so
your menu resource simply has each of
those three items I'll take the
amplified case for instance each of the
items which is ultimately going to show
up is just one visible item let's have
the same base command key but you can
specify different modifiers so for
instance the amplify item itself just
has the command key amplify all a shift
command and amplify selection is option
command so you build up your menu you
save that off and then you need to do
one step in the code and actually so
very small application uses carbon
events as do most of the work and one of
my subroutines is a routine that just
build up my menu bar one thing I happen
to do in here that people talk about as
well is get the root menu this is a
really convenient way to be able to get
your menu bar treat it as a menu and
iterate through things in a quick easy
way so I get my root menu and the first
thing I do is I pull the six men you out
of it which happens to be my dynamic
menu this is a number of other ways I
could have done this but for speed I
just knew it was this menu and grabbed
it and then I happen to iterate over
each of the items in the menu and change
in attributes just turn on the dynamic
bit for that item and that's really all
it takes for the dynamic stuff to work
as soon as you run the menu manager just
just does the rest of the work
so calling this API is a little
inconvenient and we're going to look at
getting that integrated directly into
interface builder so that interface
builder will let you you know click a
checkbox and mark an individual menu
item as dynamic and it'll just do it all
and you won't have to do any work you
just filled your menu and run it and
it's all dynamic and so now I think it's
going to talk a little bit more about
these api's I've shown you any some some
more stuff as well great thanks a lot
guy so now we're going to talk about
some AP is as sort of a background and
we're going to build up towards the
exact API is a guy showed just now in
that demo the first one we're going to
talk about are the menu attribute AP is
an ax men you attribute or I should say
a set of many attributes is just a
32-bit quantity a bunch of flags that
control the behavior of an individual
menu right now we define two attributes
one of them is to exclude the mark
column animart column of course is that
column down the left left hand side of
the menu with the check mark or the
diamond or whatever else you need to put
whatever other symbol you need to put in
there to tell the user that a certain
mode is in effect or some item has been
selected as the current item and
basically the reason you would want to
exclude that column the best example we
have is the path popup menu that Windows
support now there's no reason to mark
any of those items and it's much nicer
if the width of the item is very close
to the width of the title in the window
so we turn off the mark column for that
menu and you may encounter situations
like that in your app as well the other
bit that you can set in the menu
attributes is the auto disabled bit and
this bit basically we hope replaces a
lot of code in your application in which
you
to determine whether all the items in
your menu are disabled and if they are
go ahead and disable the title well if
you set this bit on a menu the menu
manager will figure all that out for you
and disabled the title on the fly on an
as-needed basis so there are a couple of
api's for accessing these bit the first
one is pretty simple you pass it the
menu you care about and it gives you
back the attributes for that menu the
second one is a little more interesting
it's it it has an idiom that we're
probably going to use a lot of in the
future for the toolbox and basically
where you would expect one parameter
there are two and the first one is the
attributes you're supposed that the menu
manager is supposed to set and the
second one is the attributes that the
menu manager is supposed to clear and
this replaces the code in your
application where you would get the
attributes and then do some bitwise
operation on those attributes and then
set them back onto the menu and of
course that's not nearly an atomic
operation so since thread safety is the
sort of thing we try to consider when
we're designing new AP is for carbon
that's what that's what this sort of
dual parameter strategy is all about now
of course there are attributes for menu
items as well and these are the
attributes that guy was talking about
when he showed you how the dynamic menu
support is implemented in his app the
first menu item attribute is the
disabled attribute and of course this is
an attribute that's used by disabled
menu item and enable a menu item and
there's no sort of recommendation that
you use the attribute version of this
capability the old api's works fine it's
just that it's nice to have all of these
attributes in a single place the second
half degree to the dynamic attribute
which guy talked about you turn that on
and you get that dynamic menu support
the third is a hidden attribute
and what that does is it allows you to
hide and show individual menu items in a
menu without deleting them so they're
still there but the mini manager simply
chooses not to display them and we'll
get to how that can be useful in a very
specific example in a few slides and
then the last attribute is the separator
attribute and the separator attribute
compensates for the the fact that we
still have one metacharacter in menu
items and that is a leading hyphen and
the leading hyphen of course causes the
item to become a separator line instead
of a hunk of texts with this attribute
you can turn that off and have a leading
hyphen in your menu items and this would
be useful if you don't want to know what
kind of data you're putting into the
menu say it comes from a file system or
it comes from a list of resources or
some database or something and you don't
want to have to process does this thing
have a hyphen in it and do we need to do
a special hack in order to make it work
just you just put text in the item as
long as that separator is set and you
won't get excuse me as long as that
attributed that you won't get items
turning into separators unintentionally
now there are lots of other menu item
attributes I probably as many as a half
dozen more they're a little more obscure
but they're worth looking at if you have
some time take a look at them and see if
they apply to your application they're
all commented the api's are much like
the menu attribute api's and of course
you specify a menu item but otherwise
they're pretty much the same so now
let's talk about that dynamic menu item
attribute now guys explain a little bit
of this but basically you create the
same old resources or you use interface
builder to create your menu and ex many
resources and in your ex many resources
of course you specify all the modifier
keys that you care about and basically
what you do is you specify multiple
quote redundant I say items and your
resources they're not redundant because
obviously they have different model
but they sort of look redundant they
have the same base command character
associated with them and that's how the
many manager figures out which items to
merge and which items to leave alone and
then once you've got your menus
instantiated in your application when
you set the dynamic attribute bit on the
item that tells the menu manager okay
you should look to see if this item
should be merged with another one above
or below it and of course you saw the
only the current set of modifier keys is
displayed in the menu if it should also
point out the items that aren't
displayed are still in the menu so the
many manager knows to return you the
index of those items according to which
modifier keys are down so you don't have
to worry about well I should say the
menu manager tells you if you've got
three items in a sequence in their
dynamic menu items say their items four
five and six if the user hold down the
modifier keys associated with item five
menu manager tells you that the user
selected item five and you don't have to
worry about all the fact that that many
manager hides all those other ones for
you so we did some work with
hierarchical menus as well a while back
we added some marant excuse me some
functions to allow you to get away from
overloading the semantics of existing
api's like set item mark and set item
command you used to have to pass all
sorts of goofy stuff according to all
sorts of rules that nobody wanted to
remember and everybody had to look up
every time but in the related to release
of carbon we are also finally
eliminating pretty much I think the last
weird case of overloaded parameters and
that is insert menu and passing negative
one for the for the after ID you can now
basically create a menu decide which
item to make it a hierarchical menu of
and pass the menu handle the menu
manager and let the menu manager worry
about the rest you don't have to worry
about what Id the menu has you don't
have to worry about doing something
special you have a name that actually
does what if
as it does and the only time that you
really have to worry about the menu ID
is if you don't take advantage of the
API is on following slide we've also had
menu command IDs for a while we had sort
of a sparse set of api's but I think we
are pretty much rounding out the API set
for menu command IDs in carbon the first
interesting one is enable menu command
and what this does is if you associate a
32-bit command ID with an item you can
enable that item or disable it according
to its command ID without worrying about
where it is in the menu hierarchy so
basically this allows you to not be
concerned about searching or or having a
list of constants in your application
that relates command IDs to items or
anything like that and we've added a
couple of other api's that allow you to
sort of query your existing menu bar to
figure out where command IDs appear in
your item hierarchy and this is going to
be useful for situations like when you
have your font menu and you want to
associate the same command with all the
items in your font menu yet you still
need to look up the text of the item of
the menu that was selected because
that's the font name and you need that
to obtain a fond ID and use that
speaking of the font menu we've added
some call to create a standard font menu
and of course you saw the demo where you
have the option of creating sort of an
old style font menu with just font names
in it or you can create a menu with font
names and their variants hanging off the
side as a hierarchical menu and of
course you make that decision by
choosing whether to pass the K
hierarchical font menu option flag to
create standard font menu some of the
other interesting parameters to this
function are the first hierarchical menu
ID if you
care about where your font variant
hierarchical menu start in the ID list
this is where you can specify where they
should start and you would use this if
say for example you had you know menu
starting at 128 say and going to 150
you're pretty sure you're not going to
use 50 more menus in this application so
you could tell menu manager okay start
my font during IDs at 200 and I'm pretty
sure there aren't going to be any cool
any collisions let's see so yes and the
other API will allow you to instead of
getting the string out of the menu and
having to figure out what that
corresponds to just ask directly for the
font family and font style and font
manager terms instead of you having to
do that yourself so one of the other
standard font menus that we're
supporting in carbon is a standard apple
menu or on 10 you'd call it the
application menu you no longer need to
call a pen dress menu and pass drvr to
build an apple menu and you also
obviously no longer need to call open
desk accessory because that's not
supported so you better not need it
under carbon lip we build the apple menu
and we handle selections in it and
pretty much it just works you don't have
to worry about it you still need to
worry about your about item but other
than that everything just works under
mac OS can we still build the menu for
you but we add a couple items that you
need to respond to one of which are
probably already responding to basically
the quit application pretty much
everybody supports it if you don't
support it you really can't even shut
down the mac properly so you're
definitely already there you need to add
a new apple event handler to handle the
Preferences event that will send your
application when the user selects the
Preferences item from the menu this is
pretty easy because if you have a
preferences dialog all you have to do is
call the existing code that brings up
that dialogue and you've done
if you don't have a preference with
dialogue and it's perfectly reasonable
for you to patch the Preferences command
ID to some of those IPS excuse me to
some of these those API as I mentioned
earlier to either hide the menu of the
Preferences menu item or disable it as
necessary and of course if your
application is in a state where it can't
quit it's perfectly reasonable to
disable the clip menu item for a while
and that sort of seems counterintuitive
because we built the menu but that's
sort of also why we built that whole
command ID support into the enable and
disable mechanism because we knew that
you were going to run into that problem
so go ahead and do that so I'm about to
explain these api's and you're going to
be wondering at the end why did they add
those api's and then i'll tell you you
can now clone menus and cloning really
is just terminology for reference
counting so if you explicitly clone a
menu you increment its reference count
if you insert a menu into a menu bar
that implicitly increments that menus
reference count and if you delete a menu
from a menu bar that implicitly
decrement the reference count and of
course when you dispose the menu the
reference count hopefully if you've
stayed balanced all this time the
reference count goes to zero and the
menu goes away now why would you need
this well one youth is the enhancements
we've made to get menu bar yet menu bar
is still still returns the handle that
you expect that weird packed array of
strange stuff that's kind of documented
in inside mac one I think and you can
still walk around in that handle and
extract information out of it but at the
same time you want to use some new AP is
that we've added expose menu bar will do
the right thing with all the menus that
happen to be in that menu bar so that
once you've gotten the menu bar and all
of those many reps have their reference
counting committed and then you just
close the menu bar those men us will
have their reference counts
decrement duplicate menu bar of course
will increment all the reference counts
of the menu rest in that menu bar so
that you can keep everything balanced
the thing that you want to avoid is
passing a menu bar handle to dispose
handle because that obviously won't give
us a chance to do all of that reference
count maintenance and thing goes for
hand hand equally it's a similar problem
and that memory manager has no idea that
it needs to do anything with many refs
another way though to access the minibar
is get root menu and it returns to you
what I think of as sort of a virtual
menu RF the root menu behaves as if it's
a menu and you can pass it to all the
menu well yes you can pass it to pretty
much all the menu manager api's but the
most important ones are account menu
items which immediately tells you how
many items there are in the menu bar so
you don't have to declare your own data
type and do tricky things to get that
simple information and the other thing I
will do is it will allow you to get the
menus that are in the menu bar their
menu ref really easily simply by calling
a new API instead of again walking
around in that weird handle when you're
done with the root menu you can just
call dispose many dispose menu just like
you would with any other menu ref so
what we're hoping is that if you're in
your code looking at all that weird menu
bar code instead of changing it to use
dispose menu bar or duplicate menu bar
which is perfectly acceptable to do
we're hoping that you have the
alternative to simply rip that out use
get root menu and the other menu manager
api's and then make your maintenance
like simpler over time
so it's been 15 years 15 years and we
still didn't add away to set the menu
title and carbon we finally did it so
the help tag manager there's good news
and bad news about the help tag manager
the good news is it's the replacement
for balloon help the bad news is you
have to give up all of those alternate
names for balloon help you've made up to
express to the world what you think of
it so the the help tag manager is we
think a big improvement on balloon
health the first improvement is that
it's object oriented and what that means
is you can associate a health tagged
with a toolbox object like a control or
a window or a menu item the second big
improvement is the human interface
instead of having those big cartoony
balloons what you've got is small yellow
rectangles just like you've seen for I
don't know how many years what what's
great about ours is that it had that
that flick aqua translucence that you
see everywhere else the content is a
little different for health tags
basically what we're expecting help tags
to be used for is three or four words
afraid so suppose for example you've had
you had a button with an icon with a
label and the button was supposed to
send an email message the button might
say at the comic caption it might say
send because after all it's in the
context of an email message window and
so send is pretty clear if the user for
some reason needs to know what the send
button does and hovered over that button
waiting for the balloon help is to
appear the balloon help might have might
have said something like
open a tcp/ip connection to the SMTP
server and squirt and RFC 822 message
over the link that's not what we expect
in a health tag what we expect them help
tag is something like send the current
message now we've added facilities for
you to leverage your existing balloon
help content because we know that's
important but we think that as you as
you experiment with that you'll find
that the content really doesn't fit the
help tag idiom it's sort of a stopgap
measure you can get your health system
back up and running with help tag but
the more you use it we think the more
you'll be motivated to rev your content
over time so here are some of the api's
that you use to specify help tag content
I'll just talk about the first one you
pass it a control rest and you pass it
this mu data structure called hm health
content wreck and basically it can help
content wreck is an expanded Atta
structure that specifies an expanding
number of data types for your content
and by expanding what I mean is we hope
to add lots of data types that help tag
support over time right now the one that
absolutely works flawlessly and the one
with it we fully intend to keep forever
is stir 255 this standard Pascal string
that you used to in the header you may
find other types but we recommend that
you stick with stir 255 for now because
that's the one that's going to stay
around some of the other interesting
fields in the HM help content wreck are
the tag display side and that of course
is less right bottom top so you can
specify where you expect the tag to
appear relative to the object you
specified and then the other interesting
field is the AHA track field now I said
earlier that this API is object oriented
in the sense that it talks to toolbox
objects and why would you need a hot
rack it could just ask the toolbox
object
well the relevant example is a window if
you attach a help tag to a window you
may have multiple hot wreck areas within
that window and we'll see why that's
relevant in a few seconds well actually
we'll see how you can customize that in
a few seconds it may not it may be
relevant even if you don't customized
for example if you're you've got a
window up and you're not using control
manager for some reason i mean i'm in
love with control manager and I can't
see why anyone would avoid it but some
people need to so if you're in that
situation that's where the hot rekt
comes in so I mentioned customization
these api so our api's you can use to
customize your health tag basically you
use the you use these api's to sort of
do lazy content to provide lazy content
you can do two main things you can you
can decide oh I don't want to use string
a I want to use string B and that may
have to do with what state the windows
in or what state the controls in or
something along those lines the other
thing you can do is specify the hot rack
on the fly so that so for example if
you've got the scenario i mentioned with
the window with multiple possible hot
rex if things are moving around you may
still wanted you want you still want to
inform the help tag manager when to take
down the help tag and so if you're in
that situation you need to turn to these
customization api's
so I mentioned balloons help
compatibility and these are the AP is
that you would use to specify your
existing balloon health resources as
help tag content resources and it does
preserve your investment and content but
it's really up to you to evaluate
whether you want to keep that content
for your help tag implementation or not
it's really sort of the honor system and
we hope you do the right thing I also
mentioned some new control functions
that we've added we're going to be
talking a lot more about controls in the
second session for carbon toolbox
enhancements tomorrow tomorrow at 98 99
am I believe that's in a1 a2 well we'll
find out later in the roadmap but
basically we wanted to cover a couple of
things in this session it used to be
when you wanted to create a pop-up menu
you would have to basically crack open
the documentation and read a short
paragraph on just about every parameter
to figure out what it really meant it
wasn't really the control wasn't really
the ref con it was really something else
so what we've done is for each control
or each standard control i should say
we've added individual creation function
so that you can pretty much look at the
prototype figure out the data you need
to provide and provide it instead of
spending a half an hour every time you
need to create a pop-up button the other
change we've made is we've made these
control creation functions return OS
status it used to be you'd call new
control you get back an ill control
wrath and then it would just be a big
mystery as to why it failed now that we
return OS status you can at least maybe
figure out okay I need to do this other
thing instead or maybe tell the user
what went wrong or something like that
it's no longer just this big mystery
I mentioned that we're going to have
some new standard controls in Mac OS 10
and and in fact in carbon in general the
first example is there was a session
this morning I hope you saw on the data
browser control it's a really wizzy new
hierarchical list control has excellent
user experience it supports all sorts of
features basically for free you get drag
and drop support get the little disclose
disclosure triangle support you get the
column headers and the and the movable
column from the whole nine yards
basically we're making finder level
functionality available to your
application with respect to list
management some of the other controls
are pretty cool in their own right but
gotta admit the data browser is great
the relevant indicator is a new control
that's basically the result of the fact
that the progress indicator is very
different in aqua and it no longer works
as a relevant control so we've created a
new control and for example this is used
by Sherlock to RZA to display search
results to tell you how relevant each
hit is to your search the round button
is basically intended as a navigational
aid we expect you to use it for things
like back and forward and home the
disclosure button is something that
you'll see in navigation services it's
basically for expanding and contracting
dialog windows so if you have expert
users who need access to more settings
than your your sort of main customer
base and you don't want to burden your
main customer base with too many
controls the disclosure button is a way
to give your expert users the
opportunity to need to twiddle the
settings that they want to twiddle
without distracting sort of your your
main line customers and then of course
in aqua we really really really want you
to use the standard prog
s Bar and the one barrier left to that
really was we didn't have a vertical
variant for it we really want you to get
away from drawing progress bars with
quick draw it's never going to look good
under aqua so if you've got a vertical
progress bar now now's the time so we've
talked about things you have to do we
talked about things that you're going to
want to do the things you have to do are
you have to watch out for mandatory
window layers and mandatory route
controls and the window layering is a
shouldn't be too onerous but it is a
little bit of work and as long as you
understand it I think you'll be okay the
route control stuff is even easier to
deal with because all you really need to
know is be aware of it for debugging and
for the most part you shouldn't have to
make too many changes because your code
will create controls and they'll go into
the they'll become child controls of the
route control and everything will pretty
much work the same watch out for get
menu returning copies don't assume that
it always returns the same handle over
and over again and check out the scrap
manager if you have some private scrap
code where you export your private scrap
during a suspender vent look out for
that stuff look forward to is all the
new menu manager api's
they are they basically enable you to
eliminate code support aqua without too
much effort and we'll keep working on
them as well but we're pretty happy with
them help tags is something that is
basically really the health system of
the future it's basically the way
balloon help should have worked in the
first place and we think you won't check
that out as well and of course there are
some control manager improvements that
you'll want to keep in mind and again if
you're interested in control manager the
carbon toolbox enhancement session to
tomorrow morning at nine is the place to
be so with that I'd like to bring out
Dave right again and he'll wrap things
up for us thanks Pete so just to take a
look at a where to take feedback about
this for carbon api's and ways that the
toolbox could better help you with your
programming efforts please feel free to
contact me at David Wright at up at
David Wright at apple com and for user
interface type issues please contact our
user experience technology manner
manager John Gill NZ at gallente at
apple com and for the roadmap as you can
see these carbon enhancement sessions
are very useful these are issues that
are going to affect you as your
carbonizing your applications so don't
miss tomorrow's a second session about
this stuff it's in a two at nine o'clock
I don't know about you but engineering
it at 9am is really early but it's
really important so be sure to be there
also be sure to go to navigation
services since that's the only standard
way to open and save files in a carbon
application now and for feedback again
that you'd be sending to John during
this conference please be sure to attend
the Aqua feedback forum because that's
where a user interface type feedback
should go during this conference and
again for programmatic type stuff waste
the toolbox can help you get your carbon
application going faster and better and
concerns that you have please attend the
feedback forum for the high level
toolbox so this time I'd like to invite
the panelists to come up for QA and will
move in