> 1) background color
> Why do some themes don't allow to change the background color. My
> application uses three different backgrounds depending on state:
> warning, error, active. Consider 'warning' when the entered value is
> near some limit, error if its out of limit, active if its currently
> processed.
> I considers this flaw as a no-go.

Yes and no. I agree it is silly you can't just specify background,
especially if you'd use "background" element.
I think it's OSX's theme's fault since you can do that on any platform
except for OSX. I remember seeing some

However, you can easily work around this - I needed a white frame/
label/checkbutton and native frame/label/checkbutton. So, I created
this:

image create photo image_osxWhite -width 16 -height 16
image_osxWhite put \#ffffff -to 0 0 16 16

ttk::style element create OSXWhiteBackground image image_osxBlank16 \
    -border {6 6 6 6} -padding {0} -sticky news
# (although I don't think -border is needed, not sure)

ttk::style layout OSXWhiteFrame {
    OSXWhiteWidget.background

}

ttk::style layout OSXWhiteLabel {
    OSXWhiteWidget.background -children {
        OSXWhiteLabel.label
    }

}

Again, I do agree here that if someone sets -background, it should be
doable.

But I found ttk layouts VERY useful - for example if you want to just
grab the highlighted frame OSX gives you, you can do:

ttk::style layout OSXHighlightedFrame {
    Entry.field

}

bind OSXHighlightedFrame <FocusIn> {%W state focus}
bind OSXHighlightedFrame <FocusOut> {%W state !focus}

And then for the widget:

$path configure -style OSXHighlightedFrame -padding {4 4}
bindtags $path [linsert [bindtags $path] 0 OSXHighlightedFrame]

I create an empty frame for non-OSX, a highlighted frame for OSX and
you can just put widgets in there (like text that doesn't have native
frames) - and they get OSX native frame for free :-)

So, while this particular thing is missing, ttk gives you enough tools
to work around it.

I think the worse thing is lack of introspection - if you want to
"mimic" ttk::checkbutton's default layout, you need to look in OSX
source code and TTK_BEGIN_LAYOUT to get the thing done right.
But, again, I think the advantages overwhelm the problems you can find
with ttk - if you fight such things, my recommendation is to learn ttk
elements, layouts etc.

>Does the vista theme, support changing the background color?
>I'm asking because i'm using this piece of code
>ttk::style map TEntry -fieldbackground list focus yellow
>which doesn't seem to be working.

The XP theme field element is drawn by the native XP themeing engine so
you don't get to pick and choose - the user gets what she expects from
the theme she has chosen for Windows (be it blue, green, silver or Zune)

To override this you need to replace the field element with one that you
can control more directly. You can do this by cloning the corresponding
element from one of the other themes (default will work) and configuring
it appropriately. The downside in this case is that the field is
handling the border style for the entry widget so you will get control
of the background but you loose control of the border. Maybe you can
work around that -- you can use the vsapi engine to create any XP
theming element you want and try to wrap that around the new background.

Anyway - an example:

# Sample of an overridden Entry widget which has an alternative
# background element that may be set to a given colour.
# Note that the colour is part of the style - not part of the widget data
# so all Plain.Entry widgets will use the same background colours.
#

package require Tk 8.5

proc PlainEntryInit {} {
    catch {
        # Import the 'default' theme field element.
        ttk::style element create plain.field from default
    }

    # Create a new style using the imported element.
    ttk::style layout Plain.Entry {
        Plain.Entry.plain.field -sticky nswe -border 1 -children {
             Plain.Entry.padding -sticky nswe -children {
                 Plain.Entry.textarea -sticky nswe
             }
         }
     }

     # Configure the colour and padding for our new style.
     ttk::style configure Plain.Entry {*}[ttk::style configure TEntry] \
         -fieldbackground LightSteelBlue -cursor hand2
     ttk::style map Plain.Entry {*}[ttk::style map TEntry] \
         -fieldbackground {!focus SteelBlue}

     # Re-do if the user changes theme.
     if {[lsearch -exact [bind . <<ThemeChanged>>] PlainEntryInit] == -1} {
         bind . <<ThemeChanged>> +PlainEntryInit
     }
  }

# Create a dialog to demonstrate the plain entry widget style
proc Test {dlg} {
    variable e "Plain.Entry widget"
    variable e2 "normal widget"
    wm title $dlg "Plain entry test"
    ttk::entry $dlg.e -style Plain.Entry -textvariable ::e
    ttk::entry $dlg.e2 -textvariable ::e2
    grid $dlg.e -pady 2 -padx 2
    grid $dlg.e2 -pady 2 -padx 2
    bind $dlg <Control-F2> {console show}
    return $dlg
}

if {!$tcl_interactive} {
    PlainEntryInit
    if {![winfo exists .plainentry]} {
        wm withdraw .
        set dlg [Test [toplevel .plainentry -class Dialog]]
        tkwait window $dlg
        exit
    }
}

package require Tcl 8.5
package require Tk

namespace eval ::ttk {
    bind Wrapframe <FocusIn>  {%W#border state  focus}
    bind Wrapframe <FocusOut> {%W#border state !focus}
}

# wraps a plain Tk widget inside a ttk frame
proc ::ttk::WrapWidget {class path args} {
    # handle the args
    set args [dict replace $args \
        -background white \
        -borderwidth 0 \
        -highlightthickness 0]
    set args [dict remove $args -bg -bd]

    # real widget
    set rw $path.$class

    # create the container frame and the widget
    frame $path -style TEntry -class Wrapframe
    ::$class $rw {*}$args
    bindtags $rw [list $path $rw [string totitle $class] [winfo toplevel $path] all]

    # rename the container widget cmd and install
    # a proxy cmd to the real one
    rename ::$path ::${path}#border
    interp alias {} $path {} ::ttk::WrapProxy $rw

    pack $rw -expand 1 -fill both -padx 2 -pady 2

    # adjust the select{fore|back}ground with the theme
    bind $rw <<ThemeChanged>> [list apply {rw {
        set sb [ttk::style configure . -selectbackground]
        set sf [ttk::style configure . -selectforeground]
        $rw configure -selectbackground $sb
        $rw configure -selectforeground $sf
    }} $rw]
    after idle [list after 0 [list \
        event generate $rw <<ThemeChanged>>]]

    return $path

}

proc ::ttk::WrapProxy {w args} {
    # prevent the border window to take focus
    if {[lindex $args 0] eq "cget" &&
        [lindex $args 1] eq "-takefocus"} {
        return 0
    }
    uplevel 1 [linsert $args 0 $w]

}

interp alias {} ::ttk::text    {} ::ttk::WrapWidget text
interp alias {} ::ttk::listbox {} ::ttk::WrapWidget listbox
interp alias {} ::ttk::canvas  {} ::ttk::WrapWidget canvas

# demo
pack [ttk::text .t -width 20 -height 4] -padx 6 -pady 6
pack [ttk::entry .e -width 20] -padx 6 -pady 6
after 2000 {ttk::setTheme clam}

One of the original intents of 'tile' was to make it simpler to create
Tk widgets. There's quite a lot of tedious boilerplate in Tk widget
creation. See http://tktable.sourceforge.net/tile/WidgetGuide.html  for
something about this. However, when 'tile' got integrated the necessary
functions were not exposed as part of the tk stubs and its currently
somewhat hidden.

Related to this -- to construct new UI's using elements you need a
reasonably general purpose element engine. I one toyed with using GDI+
so I could specify an element with, for instance, a certain gradient or
shape. Working with this leads to the obvious conclusion that it would
be great to be able to specify the look of an element using something
like SVG. (See http://tktable.sourceforge.net/tile/Gdiplus.html 
and http://www.patthoyts.tk/gitweb.cgi?p=gdiplus;a=summary )

There might be more involved in making the widget functionality easy to
hook together but this would cover the look part of look and
feel. Events mostly deal with 'feel'.