Likely one of the first things you’ll encounter if using the themebuilder is how to create a custom style for something the themebuilder doesn’t support. In my adventures trying to build on top of Sencha’s themebuilder, it became apparent to me that they intended the tool to be used in a standalone fashion. That is, one runs the themer.sh or themer.bat file to generate the theme.jar file and you plug and play it in conjunction with GWT.
However, because the theme file is applied uniformly across your application, what happens if you don’t want buttons in one place to look like buttons in another? This came up when building our webapp, where we wanted our top-level nav to have one color and appearance on hover and other buttons within the application to have another color. As it turns out, there’s no way to specify this in the .theme file.
So how did I do this? In fact, there isn’t an easy way currently. I had to go digging through the compiled appearance classes made by the themebuilder.jar file in search of an answer. Here’s an example of what the themebuilder spits out for a button made with your custom .theme file.
Step 1: Create an custom appearance class for your button/widget that extends Sencha’s appearance class
So the first step I found to creating custom styling on top of the themebuilder was to create my own appearance class. However, I didn’t want to start from scratch because Sencha already provides a good basis (e.g. by applying the fonts, default colors, creating sliced image files, etc). It’s true that a lot of these things go out of the window when creating your own appearance class and you can lose multi-browser support, but in our case, it was better than keeping all the buttons looking exactly the same.
Here’s example of a custom appearance class for the dark grey buttons you see above.
/**
* HeaderButtonAppearance extends a theme appearance created by Sencha's
* themebuilder.jar file. It uses the gifs and base css created by Sencha's
* themebuilder then adds additional css styling and modifies the rendering
* logic to display header buttons.
*/
public class HeaderButtonAppearance<M> extends ButtonCellDefaultAppearance<M> {
final HeaderButtonStyle customStyle;
/**
* These are "resources" that comprise a ButtonCellAppearance
* This interface describes the resources used by this button appearance. This is not
* Sencha-specific. I had originally tried extending the Css3ButtonResources class that
* the themebuilder spits out, but it required keeping the entire .css class in my package as well.
*/
public interface HeaderButtonResources extends ClientBundle {
@Source("HeaderButtonCell.css")
HeaderButtonStyle style();
}
//These methods are my new styles.
public interface HeaderButtonStyle extends CssResource {
String headerButton();
String outerButton();
}
public HeaderButtonAppearance() {
HeaderButtonResources headerResources = GWT.create(HeaderButtonResources.class);
customStyle = headerResources.style();
StyleInjectorHelper.ensureInjected(headerResources.style(), true);
}
@Override
public void render(ButtonCell<M> cell, Context context, M value, SafeHtmlBuilder sb) {
Css3ButtonResources resources = GWT.create(Css3ButtonResources.class);
Css3ButtonStyle style = resources.style();
//Additional rendering stuff here, use style.____() to access the custom themebuilder styles
//Sencha by default uses a two nested divs to render a button. You may have to extract the precise
//.class file from the theme.jar file to see how the html is constructed.
}
}
-
There are a few quirks regarding this appearance class to be aware of:
- In the *ButtonStyle interface, the string method maps to a css class name in the *ButtonResources interface css file.
- The .css file that is used for the mapping must be in the same package as the appearance class
- In order to use the styles made available through the compiled css and appearance classes built by the themebuilder, you have to instantiate a ClientBundle and access the css classes through the Css3ButtonStyle interface.
- Because the default rendering of the button renders the themebuilder’s classes (e.g. for buttons, there are two nested divs, where the outer has .button {} applied and the inner has .buttonInner {} applied, I had to rewrite the render method myself. In my replacement, I swapped out the .button and .buttonInner classes for my own css classes. I maintain everything else.
- I think there has to be a better way to do this. For example, I experimented with injecting html (an innermost div) into the cell which accepts only my css. That way, I could avoid having to @Override the render class and modify the html on the backend. However, it didn’t end up working very well because even with injecting my own css, I could not overwrite the styling applied to the parent divs. Ultimately, I think one could write a utility to go in and scrape out the other classes applied by the themebuilder, but this seemed like it would be a real hassle.
Step 2: Define the .css classes in a file in the same package for your custom appearance
Here’s an example of what my .css class looked like.
.outerButton {
border: none;
background-color: #3892D3;
background: transparent;
padding: 4px;
cursor: pointer;
outline: none;
padding-right:30px;
}
.headerButton {
padding: 0px;
text-align: left;
font-family: Arial, Helvetica, sans-serif; /* actual font is not arial */
font-size: 17px;
}
.headerButton:hover {
color: white;
}
If you look at my HeaderButtonStyle class, you’ll notice that the css class names map directly to the functions in the interface. GWT takes care of the actual mapping of values. These are the classes that I can use to style my widget and are accessible via my instance of the HeaderButtonStyle. Here’s an example of how I render the HeaderStyleButton:
@Override
public void render(ButtonCell<M> cell, Context context, M value, SafeHtmlBuilder sb) {
//The default style CSS Resource in case I need to access styles built by the themebuilder
Css3ButtonResources resources = GWT.create(Css3ButtonResources.class);
Css3ButtonStyle style = resources.style();
//Begin actual construction of the button widget
String constantHtml = cell.getHTML();
boolean hasConstantHtml = constantHtml != null && constantHtml.length() != 0;
boolean isBoolean = value != null && value instanceof Boolean;
String text = hasConstantHtml ? cell.getText() : (value != null && !isBoolean)
? SafeHtmlUtils.htmlEscape(value.toString()) : "";
String scaleClass = "";
String iconClass = "";
String additionalCssClasses = customStyle.headerButton();
//Size-dependent styling
ButtonScale scale = cell.getScale();
switch (scale) {
case SMALL:
scaleClass = style.small();
break;
case MEDIUM:
scaleClass = style.medium();
break;
case LARGE:
scaleClass = style.large();
break;
}
//Outer button class, you could add anything else you want here
String buttonClass = customStyle.outerButton();
boolean hasText = text != null && !text.equals("");
if (!hasText) {
buttonClass += " " + style.noText();
}
//The css classes applied to the inner div
String innerClass = "";
innerClass += " " + scaleClass;
innerClass += " " + additionalCssClasses;
SafeHtmlBuilder builder = new SafeHtmlBuilder();
builder.appendHtmlConstant("<div class='" + buttonClass + "'>");
builder.appendHtmlConstant("<div class='" + innerClass + "'>");
builder.appendHtmlConstant(text);
builder.appendHtmlConstant("</div></div>");
sb.append(builder.toSafeHtml());
}
Step 3: Instantiate your widget using your custom appearance.
TextButton button = new TextButton(new TextButtonCell(
new HeaderButtonAppearance<String>()), "Text for Button");
You can see that when I instantiate a button, I pass in an appearance class instantiated with the type of value that the button receives (a string in this case). If you look at the prebuilt java classes (e.g. Css3ButtonCellAppearance) from the themebuilder, you’ll notice that the default constructor with no parameters will instantiate a cell with the default appearance. That’s why it’s necessary to use the constructor where you pass in the actual custom appearance class.
Code and Codes 