- div (Contains the background and content. Class name: goog-roundedpanel) - div (Contains the background/rounded corners. Class name: goog-roundedpanel-bg) - div (Contains the content. Class name: goog-roundedpanel-content)
goog.ui.Button
s. Extends the superclass with
the following button-specific API methods:
getValue
- returns the button element's value
setValue
- updates the button element to reflect its new value
getTooltip
- returns the button element's tooltip text
setTooltip
- updates the button element's tooltip text
setCollapsed
- removes one or both of the button element's
borders
goog.ui.NativeButtonRenderer
,
goog.ui.CustomButtonRenderer
, and goog.ui.FlatButtonRenderer
.
goog.ui.MenuItem
by making it checkable.
goog.ui.Checkbox
s. Extends the superclass
to support checkbox states:
goog.ui.Button
, except it
defaults its renderer to goog.ui.ColorButtonRenderer
.
This button displays a particular color and is clickable.
It is primarily useful with goog.ui.ColorSplitBehavior
to cache the
last selected color.
goog.ui.ColorButton
s.
Uses goog.ui.ColorMenuButton
s but disables the dropdown.
goog.ui.MenuButton
by adding
an API for getting and setting the currently selected color from a menu of
color palettes.
#getSelectedColor
method.
goog.ui.Component
by adding
the following:
goog.events.KeyHandler
, to simplify keyboard handling,
goog.ui.Container
. Can be used as-is, but
subclasses of Container will probably want to use renderers specifically
tailored for them by extending this class.
goog.ui.Component
by adding
the following:
goog.events.KeyHandler
, to simplify keyboard handling,
goog.ui.Control
s. Can be used as-is, but
subclasses of Control will probably want to use renderers specifically
tailored for them by extending this class. Controls that use renderers
delegate one or more of the following API methods to the renderer:
createDom
- renders the DOM for the component
canDecorate
- determines whether an element can be decorated
by the component
decorate
- decorates an existing element with the component
setState
- updates the appearance of the component based on
its state
getContent
- returns the component's content
setContent
- sets the component's content
goog.ui.Button
s. Css3 buttons can contain
almost arbitrary HTML content, will flow like inline elements, but can be
styled like block-level elements.
goog.ui.MenuButton
s. Css3 buttons can contain
almost arbitrary HTML content, will flow like inline elements, but can be
styled like block-level elements.
goog.ui.Button
, except it
defaults its renderer to goog.ui.CustomButtonRenderer
. One could
just as easily pass goog.ui.CustomButtonRenderer.getInstance()
to
the goog.ui.Button
constructor and get the same result. Provided
for convenience.
goog.ui.Button
s. Custom buttons can contain
almost arbitrary HTML content, will flow like inline elements, but can be
styled like block-level elements.
goog.ui.DatePicker
. Renders the date picker's
navigation header and footer.
goog.ui.DatePicker
. Renders the date picker's
navigation header and footer.
Element Function Class-name, modal-dialog = default ---------------------------------------------------------------------------- - iframe Iframe mask modal-dialog-bg - div Background mask modal-dialog-bg - div Dialog area modal-dialog - div Title bar modal-dialog-title - span modal-dialog-title-text - text Title text N/A - span modal-dialog-title-close - ?? Close box N/A - div Content area modal-dialog-content - ?? User specified content N/A - div Button area modal-dialog-buttons - button N/A - button - ...
#getValue
method.
goog.ui.DimensionPicker
s. Renders the
palette as two divs, one with the un-highlighted background, and one with the
highlighted background.
goog.ui.FilterObservingMenuItem
s. Each item has
the following structure:
goog.ui.Button
s. Flat buttons can contain
almost arbitrary HTML content, will flow like inline elements, but can be
styled like block-level elements.
goog.ui.MenuButton
that doesn't look like a button and
doesn't have rounded corners. Uses just a goog.ui.Gauge#setTheme
.
triggerForElement
, shown without a delay by calling
showForElement
, or triggered over other elements by calling
attach
. For the latter two cases, the application is responsible
for calling detach
when finished.
HoverCard objects fire a TRIGGER event when the mouse moves over an element
that can trigger a hovercard, and BEFORE_SHOW when the hovercard is
about to be shown. Clients can respond to these events and can prevent the
hovercard from being triggered or shown.
goog.ui.Button
s. Imageless buttons can contain
almost arbitrary HTML content, will flow like inline elements, but can be
styled like block-level elements.
goog.ui.MenuButton
s. Imageless buttons can
contain almost arbitrary HTML content, will flow like inline elements, but
can be styled like block-level elements.
goog.ui.Button
s. Link buttons can contain
almost arbitrary HTML content, will flow like inline elements, but can be
styled like block-level elements.
goog.ui.Button
by composing a button
with a dropdown arrow and a popup menu.
goog.ui.MenuButton
s. This implementation overrides
goog.ui.CustomButtonRenderer#createButton
to create a separate
caption and dropdown element.
goog.ui.MenuItem
s. Each item has the following
structure:
...(menu item contents)...
goog.ui.Separator
by always setting its renderer to
goog.ui.MenuSeparatorRenderer
.
Element Function Class-name, goog-modalpopup = default ---------------------------------------------------------------------------- - iframe Iframe mask goog-modalpopup-bg - div Background mask goog-modalpopup-bg - div Modal popup area goog-modalpopup - span Tab catcher
goog.ui.Button
s. Renders and decorates native HTML
button elements. Since native HTML buttons have built-in support for many
features, overrides many expensive (and redundant) superclass methods to
be no-ops.
goog.ui.MenuItem
by making it selectable.
#getSelectedItem
or #getSelectedIndex
method.
Use this class as the base for components like color palettes or emoticon
pickers. Use #setContent
to set/change the items in the palette
after construction. See palette.html demo for example usage.
goog.ui.Palette
s. Renders the palette as an
HTML table wrapped in a DIV, with one palette item per cell:
...Item 0... | ...Item 1... | ... |
... |
goog.ui.MenuButton
by composing a
menu with a selection model, and automatically updating the button's caption
based on the current selection.
Select fires the following events:
CHANGE - after selection changes.
goog.ui.MenuButton
.
Menu contains 'select all' and 'select none' MenuItems for selecting all and
no items by default. Other MenuItems can be added by user.
The checkbox content fires the action events associated with the 'select all'
and 'select none' menu items.
goog.events.EventType.SELECT
event when a selection is made.
goog.ui.Control
,
the Separator class doesn't allocate any event handlers, nor does it change
its appearance on mouseover, etc.
goog.ui.ColorSplitBehavior
goog.ui.SubMenu
s. Each item has the following
structure:
goog.ui.TabBar
. The tab's
DOM may be different based on the configuration of the containing tab bar,
so tabs should only be rendered or decorated as children of a tab bar.
goog.ui.Component.EventType.ACTION
when activated via the
keyboard or the mouse,
goog.ui.Component.EventType.SELECT
when selected, and
goog.ui.Component.EventType.UNSELECT
when deselected.
SELECT
event and an ACTION
event; subsequent clicks on an
already selected tab only result in ACTION
events.
goog.ui.TabBar
s, based on the TabPane
code. The tab bar's DOM structure is determined by its orientation and
location relative to tab contents. For example, a horizontal tab bar
located above tab contents looks like this:
...(tabs here)...
goog.ui.Textarea
s. Renders and decorates native HTML
textarea elements. Since native HTML textareas have built-in support for
many features, overrides many expensive (and redundant) superclass methods to
be no-ops.
goog.ui.CustomButtonRenderer
by default, though any
goog.ui.ButtonRenderer
would work.
goog.ui.Container
that defaults to
having a horizontal orientation and goog.ui.ToolbarRenderer
as its
renderer.
goog.ui.Button
s, based on
goog.ui.CustomButtonRenderer
.
goog.ui.MenuButton
s, based on
goog.ui.MenuButtonRenderer
.
goog.ui.TriStateMenuItemRenderer
s. Each item has
the following structure:
![]()
Constants for button sides, see
goog.ui.Button.prototype.setCollapsed
for details.
Constants:
|
Code » |
Decorates the element with a suitable
goog.ui.Component instance, if
a matching decorator is found.
Arguments:
Returns: ?goog.ui.Component
New component instance, decorating the element.
|
code » |
![]()
Type declaration for text caption or DOM structure to be used as the content
of
goog.ui.Control s.
|
Code » | |
![]()
CSS class name for applying the "display: inline-block" property in a
cross-browser way.
|
Code » | |
![]()
No description.
|
Code » | |
![]()
No description.
|
Code » | |
![]()
No description.
|
Code » | |
![]()
No description.
|
Code » | |
![]()
No description.
|
Code » | |
![]()
No description.
|
Code » | |
![]()
No description.
|
Code » | |
![]()
No description.
|
Code » | |
![]()
No description.
|
Code » | |
![]()
No description.
|
Code » | |
![]()
No description.
|
Code » | |
![]()
No description.
|
Code » |