On Mar 17, 2010, at 2:38 AM, Max Roberts wrote:
There are some tricks you can do like find the tangent, then rotate
the line and arc together to whatever angle you need for the line.
Unfortunately, thats not really an option for what I do
Here's an interesting idea that would allow this - although I'm not
sure how hard it would be programmatically for the developers: have a
way to create a plugin that would be allowed to access the document
and do either create objects outright, or create temporary items -
such as guide lines.
I'm not sure how a plug-in to look for tangents to curves would work
though. You’d either have to have the plug-in have an initialization
routine that would be passed references to the document object and
all child objects. This routine would look at the bezier path,
circle, etc objects, and somehow (I don’t know how) figure out points
that would be likely tangent points (inflections would be one), or
specific information to be able to quickly find a tangent line to a
bezier object (I have no idea what that would be though).
Then another plug-in routine could be called any time a new object
of a particular type was created (having a general routine called for
every new object created would be too slow, especially if a plug-in
were only interested in a few types of objects). This would
calculate more “probable tangent” points or other information.
The some routine would be called repeatedly and asked if it had a
guide line (or lines) given the current location and size of an
object being manipulated. If it did, it would create a descriptor
for such a (each) guide. Probably this would be a slope and
intercept for each guide, and what the “target” object of the guide
was. Intaglio would then place the guide in an appropriate place
given the new “source” object and target. The plug-in could also
return some range of values that would create a “window” for which
that particular guide were visible perhaps. This would reduce the
number of redundant calls, as while the source object were moved
inside this “window”, the guide lines would not need to be updated,
nor would any new ones need to be created by the plugin (so Intaglio
wouldn’t call it).
A small problem is that each plug-in would have to have some
dedicated memory space - on a per-document basis. The bigger problem
is speed - such a “guide finder” plug-in would be called every time a
new object of particular types were created (bezier paths, circles,
etc), or when certain operations were performed on objects (skews,
translations, zooms). The plug-in could possibly have an optional
preferences panel that in the “guide-finder” example would let the
user determine exactly which kinds of things would be searched - for
example only bezier paths - then all other “object creation/
manipulation” calls to the plug-in would be cancelled.
Still, for a document that had a large number of paths, the plug-in
could possibly significantly slow down the program - which is not
good in a real-time drawing program. If the plug-in processing could
be shunted off to a secondary processor (if one were available - but
don’t all Macs currently in production have at least two cores?),
and then return guide-lines or whatever to Intaglio in an
asynchronous fashion - this would allow Intaglio itself to still
allow the drawing itself to be able to be done in real-time. The
problem here is what if the plug-in finds a guide or something
asynchronously that is no longer relevant because the user has moved
one of the objects the plug-in was analyzing?
Of course, *implementing* this would very likely be quite difficult
-
especially for a general plug-in architecture that would go beyond
just being able to find guide-lines, and could create objects in
the document. Transferring such a document would be difficult
(impossible) if it depended on the plug-in being around, but there
could be an option to have an actual created object be stored in the
document as a general bezier path, and then have extra data be
appended to the document structure for the plugin to use if indeed it
was there. If another user that didn’t have the plug-in opened the
document, the created object would be treated as a bezier path, but
only as that.
An interesting question relating to “guide-finding plugins” is this
-
can InterfaceBuilder plugin’s specify guidelines to be shown in
IB? If so, how does this mechanism work? Since IB is like Intaglio
in that it’s a near-real-time drawing environment (of sorts), it’s
implementation could offer a way to cut down on processing time.
Jim
Intaglio mailing list
email@hidden
Update your subscriptions at:
http://freewaytalk.net/person/options