SIZE, SHAPE, and BEHAVIOR Themability

[Shane Lenagh <sml13 cornell edu>]

O.K., after having gotten themes working from CVS and done some little
(trivial) capplets that were themeable, I have every reason to make
Raster (and all the other theme-meisters who made this possible) my new
god(s).  Well, instead, I'm coming to these lists with yet another
handful of "oh, wouldn't it be neat if..." ideas.  And, to make matters
worse, I don't have any prototype code to show or even a really clear
picture of how one would start to do this.  So, if Raster or any of the
other theme coders want to tell me to take my suggestions and shove them
where the sun don't shine (and maybe come back when I have some code to
show for my brilliant insights)...then I will quietly slink away with my
tail between my legs.

With that said, here are my thoughts ("wouldn't it be neat if..."):
[some of you subscribed to gtk-list may recognize some of these from a
smaller post I made their a little while ago]

1.) Size themeability

In playing around with the Mac Look-and-Feel (trying to get it more 
true-to-life...although, I must say Zaphod did a great job), I 
was wondering if there was any way to get the scrollbars to be
"fatter."  
Right now they don't really look like bona fide Mac scrollbars because 
they are too skinny, more like your Motif scrollbars:

http://24.3.242.128/981119182230.jpg
http://24.3.242.128/981119183033.jpg

This raises a broader question:  Is the SIZE of a widget "themeable?"  I
can see how this _might_ be problematic for a developer who didn't know
what size his widgets were going to be "themed" to (if the final app was
themeable by a user), but I also think it would be "cool" to make the 
"emulator" themes look as accurate as possible...as well as providing a
greater degree of flexibility to the user.  I know you can achieve a
kind of pseudo-size/shape-themability with transparent pixmaps, but that
isn't really the same thing (it's kind of a hack).  That only works if
the size that you are trying to achieve is SMALLER than the default. 
And, if you want to have another component IN BACK of a large one (that
uses transparent pixmaps to appear smaller) than you can't get to it
because the "small" one is in the way.  Otherwise, you would have to
create a whole new component by subclassing an existing one (right?) to
get a skinnier scrollbar.  Maybe that's the best policy anyway (to
ensure consistency of size -- so an app doesn't end up being "themed" to
some ungodly dimension that makes it look bad).  But maybe it would be
good to have size "themeable" as an attribute in the .gtkrc file along
with the pixmap -- or, at least, a "preferred size" (like in Java).   

The Win95 rendering engine  also suffers from this same "skinny
scrollbar" problem.  
Is it easier (or even possible) to set the size of standard widgets when 
you do your own engine?  I know Java's Swing widgets--which use a sort
of rendering-engine architecture--allow you to customize this (not very
easily, I'm sure).

Who cares?  Well, this could be an issue for handicapped (read: near
blind, like my ultra-mypoic mother -- and, increasingly and
unfortunately, myself) individuals who need "accessibility" features
that make standard widgets larger than usual.  With a flexible
architecture like this, you could a "Myopia Theme" that had widgets that
were three times their normal size :-)  And, again, there is the purely
aesthetic issue of having things look right for "emulator" themes like
the Mac and Win95 ones.

2.) Shape themeability

Another thing I noticed in playing around with the wonderful themes
engines is that all of the slider controls (just as an example -- the
buttons are the same way, too) are basically the same shape -- with
either a different pixmap mapped on to them or a different rendering
done by the special purpose engine.  Again, transparent pixmaps can be
used to do a little "theming" in the way of rounded button corners,
etc.  But, is it possible with the current engines to do, for example, a
slider bar that looks like the sliders at
http://java.sun.com/products/jfc/tsc/plaf_report/jlf/jlf.html# -- and
have it react to clicks on the trough immediately to the right of the
slider the right way.  This slider has a radically different shape and
size than anything I have seen at http://gtk.themes.org and I was
curious if this was "doable" with the current engines.

3.) Feel (Behavior -- or "behaviour" :-)

I know being a Java fan might not make me too popular around these parts
(hey, I admit, GTK+ leaves Swing IN THE DUST in terms of
performance)...but I think there are some really cool things in Java's
Pluggable-Look-and-Feel (PLAF) architecture that merit consideration. 
One of them (as the name implies) is that "Feel" is themeable, too. 
This seems to be a step beyond merely theming "appearance" with pixmaps
and rendering engines, and actually separating the look from the feel
from the data (the whole Model-View-Controller thing).  Is there any
moderately easy way using the current engines to change the way a given
component BEHAVES (e.g., get a popup menu to sort of "slither" out like
like that annoying Windows 98 $hit (hey, I'm not saying YOU would
actually _want_ to do this :-))?  Or do you have to subclass an existing
component (or, worse, make a brand new one from a raw canvas) and define
it's behavior to do such strange things in it's rendering code.  How
"pluggable" are attributes like this with the current code?  (And how
can I help make it better? :-)

Are any of these things slated for future releases?

just curious,

shane