Wt  3.3.0
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Groups Pages
Classes | Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Related Functions | List of all members
Wt::WApplication Class Reference

Represents an application instance for a single session. More...

#include <Wt/WApplication>

Inheritance diagram for Wt::WApplication:
Inheritance graph
[legend]

Classes

class  UpdateLock
 A RAII lock for manipulating and updating the application and its widgets outside of the event loop. More...
 

Public Types

enum  AjaxMethod { XMLHttpRequest, DynamicScriptTag }
 Enumeration that indicates the method for dynamic (AJAX-alike) updates ((deprecated). More...
 
typedef Wt::ApplicationCreator ApplicationCreator
 Typedef for a function that creates WApplication objects. More...
 
- Public Types inherited from Wt::WObject
typedef void(WObject::* Method )()
 Typedef for a WObject method without arguments.
 

Public Member Functions

 WApplication (const WEnvironment &environment)
 Creates a new application instance. More...
 
 ~WApplication ()
 Destructor. More...
 
const WEnvironmentenvironment () const
 Returns the environment information. More...
 
WContainerWidgetroot () const
 Returns the root container. More...
 
WWidgetfindWidget (const std::string &name)
 Finds a widget by name. More...
 
void setTitle (const WString &title)
 Sets the window title. More...
 
const WStringtitle () const
 Returns the window title. More...
 
const WStringcloseMessage () const
 Returns the close message. More...
 
WLocalizedStringslocalizedStrings ()
 Returns the resource object that provides localized strings. More...
 
void setLocalizedStrings (WLocalizedStrings *stringResolver)
 Sets the resource object that provides localized strings. More...
 
WMessageResourceBundlemessageResourceBundle ()
 Returns the message resource bundle. More...
 
void setLocale (const WLocale &locale)
 Changes the locale. More...
 
const WLocalelocale () const
 Returns the current locale. More...
 
virtual void refresh ()
 Refreshes the application. More...
 
void bindWidget (WWidget *widget, const std::string &domId)
 Binds a top-level widget for a WidgetSet deployment. More...
 
std::string docRoot () const
 Returns the server document root. More...
 
std::string sessionId () const
 Returns the unique identifier for the current session. More...
 
void changeSessionId ()
 Changes the session id. More...
 
void processEvents ()
 Processes UI events. More...
 
void setAjaxMethod (AjaxMethod method)
 Sets the Ajax communication method (deprecated). More...
 
AjaxMethod ajaxMethod () const
 Returns the Ajax communication method (deprecated). More...
 
virtual void initialize ()
 Initializes the application, post-construction. More...
 
virtual void finalize ()
 Finalizes the application, pre-destruction. More...
 
void setTwoPhaseRenderingThreshold (int size)
 Changes the threshold for two-phase rendering. More...
 
void setCookie (const std::string &name, const std::string &value, int maxAge, const std::string &domain="", const std::string &path="", bool secure=false)
 Sets a new cookie. More...
 
void removeCookie (const std::string &name, const std::string &domain="", const std::string &path="")
 Removes a cookie. More...
 
void addMetaLink (const std::string &href, const std::string &rel, const std::string &media, const std::string &hreflang, const std::string &type, const std::string &sizes, bool disabled)
 Adds an HTML meta link. More...
 
void removeMetaLink (const std::string &href)
 Removes the HTML meta link. More...
 
void addMetaHeader (const std::string &name, const WString &content, const std::string &lang="")
 Adds an HTML meta header. More...
 
void addMetaHeader (MetaHeaderType type, const std::string &name, const WString &content, const std::string &lang="")
 Adds an HTML meta header. More...
 
void removeMetaHeader (MetaHeaderType type, const std::string &name="")
 Removes one or all meta headers. More...
 
WLogEntry log (const std::string &type) const
 Adds an entry to the application log. More...
 
void setLoadingIndicator (WLoadingIndicator *indicator)
 Sets the loading indicator. More...
 
WLoadingIndicatorloadingIndicator () const
 Returns the loading indicator. More...
 
void quit ()
 Quits the application. More...
 
bool isQuited () const
 Returns whether the application has quit. (deprecated) More...
 
bool hasQuit () const
 Returns whether the application has quit. More...
 
::int64_t maximumRequestSize () const
 Returns the current maximum size of a request to the application. More...
 
Signal< ::int64_t > & requestTooLarge ()
 Signal which indicates that too a large request was received. More...
 
void setConfirmCloseMessage (const WString &message)
 Sets the message for the user to confirm closing of the application window/tab. More...
 
void deferRendering ()
 Defers rendering of the current event response. More...
 
void resumeRendering ()
 Resumes rendering of a deferred event response. More...
 
template<typename F >
boost::function< void()> bind (const F &f)
 Protects a function against deletion of the target object. More...
 
std::string encodeUntrustedUrl (const std::string &url) const
 Encodes an untrusted URL to prevent referer leaks. More...
 
void pushExposedConstraint (WWidget *w)
 Pushes a (modal) widget onto the expose stack. More...
 
Style sheets and CSS
WCssStyleSheetstyleSheet ()
 Returns a reference to the inline style sheet. More...
 
void useStyleSheet (const WLink &link, const std::string &media="all")
 Adds an external style sheet. More...
 
void useStyleSheet (const WLink &link, const std::string &condition, const std::string &media)
 Conditionally adds an external style sheet. More...
 
void useStyleSheet (const WCssStyleSheet &styleSheet, const std::string &condition="")
 Adds an external stylesheet. More...
 
void setTheme (const WTheme *theme)
 Sets the theme. More...
 
const WThemetheme () const
 Returns the theme.
 
void setCssTheme (const std::string &name)
 Sets a CSS theme. More...
 
void setLayoutDirection (LayoutDirection direction)
 Sets the layout direction. More...
 
LayoutDirection layoutDirection () const
 Returns the layout direction. More...
 
void setBodyClass (const std::string &styleClass)
 Sets a style class to the entire page <body>. More...
 
std::string bodyClass () const
 Returns the style class set for the entire page <body>. More...
 
void setHtmlClass (const std::string &styleClass)
 Sets a style class to the entire page <html>. More...
 
std::string htmlClass () const
 Returns the style class set for the entire page <html>. More...
 
URLs and internal paths
std::string url (const std::string &internalPath=std::string()) const
 Returns a URL for the current session. More...
 
virtual std::string makeAbsoluteUrl (const std::string &url) const
 Makes an absolute URL. More...
 
std::string resolveRelativeUrl (const std::string &url) const
 "Resolves" a relative URL taking into account internal paths. More...
 
std::string bookmarkUrl () const
 Returns a bookmarkable URL for the current internal path. More...
 
std::string bookmarkUrl (const std::string &internalPath) const
 Returns a bookmarkable URL for a given internal path. More...
 
void setInternalPath (const std::string &path, bool emitChange=false)
 Changes the internal path. More...
 
void setInternalPathDefaultValid (bool valid)
 Sets whether an internal path is valid by default. More...
 
bool internalPathDefaultValid () const
 Returns whether an internal path is valid by default. More...
 
void setInternalPathValid (bool valid)
 Sets whether the current internal path is valid. More...
 
bool internalPathValid () const
 Returns whether the current internal path is valid. More...
 
std::string internalPath () const
 Returns the current internal path. More...
 
std::string internalPathNextPart (const std::string &path) const
 Returns a part of the current internal path. More...
 
std::string internalSubPath (const std::string &path) const
 Returns a URL for the current session. More...
 
bool internalPathMatches (const std::string &path) const
 Checks if the internal path matches a given path. More...
 
Signal< std::string > & internalPathChanged ()
 Signal which indicates that the user changes the internal path. More...
 
Signal< std::string > & internalPathInvalid ()
 Returns a URL for the current session. More...
 
void redirect (const std::string &url)
 Redirects the application to another location. More...
 
Manipulation outside the main event loop
void enableUpdates (bool enabled=true)
 Enables server-initiated updates. More...
 
bool updatesEnabled () const
 Returns whether server-initiated updates are enabled. More...
 
void triggerUpdate ()
 Propagates server-initiated updates. More...
 
UpdateLock getUpdateLock ()
 Grabs and returns the lock for manipulating widgets outside the event loop (deprecated). More...
 
void attachThread (bool attach=true)
 Attach an auxiliary thread to this application. More...
 
Invoking JavaScript or including scripts
void doJavaScript (const std::string &javascript, bool afterLoaded=true)
 Executes some JavaScript code. More...
 
void addAutoJavaScript (const std::string &javascript)
 Adds JavaScript statements that should be run continuously. More...
 
void declareJavaScriptFunction (const std::string &name, const std::string &function)
 Declares an application-wide JavaScript function. More...
 
bool require (const std::string &url, const std::string &symbol=std::string())
 Loads a JavaScript library. More...
 
bool requireJQuery (const std::string &url)
 Loads a custom JQuery library. More...
 
bool customJQuery () const
 Executes some JavaScript code. More...
 
void setJavaScriptClass (const std::string &className)
 Sets the name of the application JavaScript class. More...
 
std::string javaScriptClass ()
 Returns the name of the application JavaScript class. More...
 
Global keyboard and mouse events
EventSignal< WKeyEvent > & globalKeyWentDown ()
 Event signal emitted when a keyboard key is pushed down. More...
 
EventSignal< WKeyEvent > & globalKeyPressed ()
 Event signal emitted when a "character" was entered. More...
 
EventSignal< WKeyEvent > & globalKeyWentUp ()
 Event signal emitted when a keyboard key is released. More...
 
EventSignalglobalEnterPressed ()
 Event signal emitted when enter was pressed. More...
 
EventSignalglobalEscapePressed ()
 Event signal emitted when escape was pressed. More...
 
- Public Member Functions inherited from Wt::WObject
 WObject (WObject *parent=0)
 Create a WObject with a given parent object. More...
 
virtual ~WObject ()
 Destructor. More...
 
virtual const std::string id () const
 Returns the (unique) identifier for this object. More...
 
void setObjectName (const std::string &name)
 Sets an object name. More...
 
virtual std::string objectName () const
 Returns the object name. More...
 
void resetLearnedSlots ()
 Resets learned stateless slot implementations. More...
 
template<class T >
void resetLearnedSlot (void(T::*method)())
 Resets a learned stateless slot implementation. More...
 
template<class T >
WStatelessSlot * implementStateless (void(T::*method)())
 Declares a slot to be stateless and learn client-side behaviour on first invocation. More...
 
template<class T >
WStatelessSlot * implementStateless (void(T::*method)(), void(T::*undoMethod)())
 Declares a slot to be stateless and learn client-side behaviour in advance. More...
 
template<class T >
WStatelessSlot * implementJavaScript (void(T::*method)(), const std::string &jsCode)
 Provides a JavaScript implementation for a method. More...
 
void addChild (WObject *child)
 Adds a child object. More...
 
virtual void removeChild (WObject *child)
 Removes a child object. More...
 
const std::vector< WObject * > & children () const
 Returns the children.
 
WObjectparent () const
 Returns the parent object.
 

Static Public Member Functions

static WApplicationinstance ()
 Returns the current application instance. More...
 
static std::string resourcesUrl ()
 Returns the URL at which the resources are deployed. More...
 
static std::string relativeResourcesUrl ()
 Returns the URL at which the resources are deployed. More...
 
static std::string appRoot ()
 Returns the appRoot special property. More...
 
static bool readConfigurationProperty (const std::string &name, std::string &value)
 Reads a configuration property. More...
 

Protected Member Functions

virtual void notify (const WEvent &e)
 Notifies an event to the application. More...
 
virtual bool isExposed (WWidget *w) const
 Returns whether a widget is exposed in the interface. More...
 
virtual void enableAjax ()
 Progresses to an Ajax-enabled user interface. More...
 
virtual void unload ()
 Handles a browser unload event. More...
 
- Protected Member Functions inherited from Wt::WObject
virtual WStatelessSlot * getStateless (Method method)
 On-demand stateless slot implementation. More...
 

Related Functions

(Note that these are not member functions.)

typedef boost::function
< WApplication *(const
WEnvironment &)> 
ApplicationCreator
 Typedef for a function that creates WApplication objects. More...
 

Additional Inherited Members

- Static Protected Member Functions inherited from Wt::WObject
static WObjectsender ()
 Returns the sender of the current slot call. More...
 

Detailed Description

Represents an application instance for a single session.

Each user session of your application has a corresponding WApplication instance. You need to create a new instance and return it as the result of the callback function passed to WRun(). The instance is the main entry point to session information, and holds a reference to the root() of the widget tree.

The recipe for a Wt web application, which allocates new WApplication instances for every user visiting the application is thus:

WApplication *createApplication(const WEnvironment WEnvironment& env)
{
//
// Optionally, check the environment and redirect to an error page.
//
bool valid = ...;
if (!valid) {
app = new WApplication(env);
app->redirect("error.html");
app->quit();
} else {
// usually you will specialize your application class
app = new WApplication(env);
//
// Add widgets to app->root() and return the application object.
//
}
return app;
}

Throughout the session, the instance is available through WApplication::instance() (or through #wApp). The application may be quited either using the method quit(), or because of a timeout after the user has closed the window, but not because the user does not interact: keep-alive messages in the background will keep the session around as long as the user has the page opened. In either case, the application object is deleted, allowing for cleanup of the entire widget tree, and any other resources.

The WApplication object provides access to session-wide settings, including:

Member Typedef Documentation

typedef Wt::ApplicationCreator Wt::WApplication::ApplicationCreator

Typedef for a function that creates WApplication objects.

See Also
WRun()

Member Enumeration Documentation

Enumeration that indicates the method for dynamic (AJAX-alike) updates ((deprecated).

See Also
setAjaxMethod()
Enumerator
XMLHttpRequest 

Using the XMLHttpRequest object (real AJAX)

DynamicScriptTag 

Using dynamic script tags (for cross-domain AJAX)

Constructor & Destructor Documentation

Wt::WApplication::WApplication ( const WEnvironment environment)

Creates a new application instance.

The environment provides information on the initial request, user agent, and deployment-related information.

Wt::WApplication::~WApplication ( )

Destructor.

The destructor deletes the root() container, and as a consequence the entire widget tree.

Member Function Documentation

void Wt::WApplication::addAutoJavaScript ( const std::string &  javascript)

Adds JavaScript statements that should be run continuously.

This is an internal method.

It is used by for example layout managers to adjust the layout
whenever the DOM tree is manipulated.
See Also
doJavaScript()
void Wt::WApplication::addMetaHeader ( const std::string &  name,
const WString content,
const std::string &  lang = "" 
)

Adds an HTML meta header.

A meta header can only be added in the following situations:

  • when a plain HTML session is used (including when the user agent is a bot), you can add meta headers at any time.
  • or, when progressive bootstrap is used, you can set meta headers for any type of session, from within the application constructor (which corresponds to the initial request).
  • but never for a Wt::WidgetSet mode application since then the application is hosted within a foreign HTML page.

When a header was previously set for the same name, its contents is replaced.

These situations coincide with WEnvironment::ajax() returning false (see environment()).

void Wt::WApplication::addMetaHeader ( MetaHeaderType  type,
const std::string &  name,
const WString content,
const std::string &  lang = "" 
)

Adds an HTML meta header.

This overloaded method allows to define both "name" meta headers,
relating to document properties as well as "http-equiv" meta
headers, which define HTTP headers.
See Also
removeMetaHeader()
void Wt::WApplication::addMetaLink ( const std::string &  href,
const std::string &  rel,
const std::string &  media,
const std::string &  hreflang,
const std::string &  type,
const std::string &  sizes,
bool  disabled 
)

Adds an HTML meta link.

When a link was previously set for the same \p href, its contents
are replaced.
When an empty string is used for the arguments \p media, \p hreflang, 
\p type or \p sizes, they will be ignored.
See Also
removeMetaLink()
AjaxMethod Wt::WApplication::ajaxMethod ( ) const

Returns the Ajax communication method (deprecated).

See Also
setAjaxMethod()
std::string Wt::WApplication::appRoot ( )
static

Returns the appRoot special property.

This returns the "appRoot" property, with a trailing slash added
to the end if it was not yet present.

The property "appRoot" was introduced as a generalization of the
working directory for the location of files that do not need to
be served over http to the client, but are required by the
program to run properly. Typically, these are message resource
bundles (xml), CSV files, database files (e.g. SQLite files for
Wt::Dbo), ...

Some connectors do not allow you to control what the current
working directory (CWD) is set to (fcgi, isapi). Instead of
referring to files assuming a sensible CWD, it is therefore
better to refer to them relative to the application root.

The appRoot property is special in the sense that it can be set
implicitly by the connector (see the connector documentation for
more info). If it was not set by the connector, it can be set as
a normal property in the configuration file (the default
wt_config.xml describes how to set properties). If the property
is not set at all, it is assumed that the appRoot is CWD and this
function will return an empty string.

Usage example:
Wt::Dbo::backend::Sqlite3 sqlite3_(appRoot() + "planner.db");
See Also
WServer::appRoot(), docRoot()
void Wt::WApplication::attachThread ( bool  attach = true)

Attach an auxiliary thread to this application.

In a multi-threaded environment, WApplication::instance() uses thread-local data to retrieve the application object that corresponds to the session currently being handled by the thread. This is set automatically by the library whenever an event is delivered to the application, or when you use the UpdateLock to modify the application from an auxiliary thread outside the normal event loop.

When you want to manipulate the widget tree inside the main event loop, but from within an auxiliary thread, then you cannot use the UpdateLock since this will create an immediate dead lock. Instead, you may attach the auxiliary thread to the application, by calling this method from the auxiliary thread, and in this way you can modify the application from within that thread without needing the update lock.

Calling attachThread() with attach = false, detaches the current thread.

template<typename F >
boost::function< void()> Wt::WApplication::bind ( const F &  f)

Protects a function against deletion of the target object.

When posting an event using WServer::post(), it is convenient to bind an object method to be called. However, while WServer::post() guarantees that the application to which an event is posted is still alive, it may be that the targeted widget (or WObject in general) has been deleted.

This function wraps such an object method with a protection layer which guarantees that the method is only called when the targeted object is alive, in the same way as how a signal automatically disconnects slots from objects that are being deleted.

You typically will bind the function immediately within the event loop where you register the "callback", and pass this bound function to (typically an external thread) which calls post() later on. What you cannot do is bind the function only later on, since at that time the target object may already have been destroyed.

As with the signal/slot connection tracking mechanism, this requires that the object is a WObject.

void Wt::WApplication::bindWidget ( WWidget widget,
const std::string &  domId 
)

Binds a top-level widget for a WidgetSet deployment.

This method binds a \p widget to an existing element with DOM id
\p domId on the page. The element type should correspond with
the widget type (e.g. it should be a &lt;div&gt; for a
WContainerWidget, or a &lt;table&gt; for a WTable).
See Also
root()
Wt::WidgetSet
std::string Wt::WApplication::bodyClass ( ) const

Returns the style class set for the entire page <body>.

See Also
setBodyClass()
std::string Wt::WApplication::bookmarkUrl ( ) const

Returns a bookmarkable URL for the current internal path.

Is equivalent to <tt>bookmarkUrl(internalPath())</tt>, see
bookmarkUrl(const std::string&) const.

To obtain a URL that is refers to the current session of the
application, use url() instead.
See Also
url(), bookmarkUrl(const std::string&) const
std::string Wt::WApplication::bookmarkUrl ( const std::string &  internalPath) const

Returns a bookmarkable URL for a given internal path.

Returns the (relative) URL for this application that includes the
internal path \p internalPath, usable across sessions.

The returned URL concatenates the internal path to the application
base URL, and when no JavaScript is available and URL rewriting is used
for session-tracking, a session Id is appended to reuse an existing
session if available.

See also \ref config_session for configuring the session-tracking 
method.

For the built-in httpd, when the application is deployed at a folder
(ending with '/'), only an exact matching path is routed to
the application (this can be changed since Wt 3.1.9, see
\ref wthttpd ), making clean URLs impossible. Returned URLs then
include a <tt>"?_="</tt> encoding for the internal path.

You can use bookmarkUrl() as the destination for a WAnchor, and
listen to a click event is attached to a slot that switches to
the internal path \p internalPath (see
WAnchor::setRefInternalPath()). In this way, an anchor can be
used to switch between internal paths within an application
regardless of the situation (browser with or without Ajax
support, or a web spider bot), but still generates suitable URLs
across sessions, which can be used for bookmarking, opening in a
new window/tab, or indexing.

To obtain a URL that refers to the current session of the
application, use url() instead.
See Also
url(), bookmarkUrl()
Note
the internalPath should be UTF8 encoded (we may fix the API to use WString in the future).
void Wt::WApplication::changeSessionId ( )

Changes the session id.

To mitigate session ID fixation attacks, you should use this
method to change the session ID to a new random value after a
user has authenticated himself.
See Also
sessionId()
const WString& Wt::WApplication::closeMessage ( ) const

Returns the close message.

See Also
setConfirmCloseMessage()
bool Wt::WApplication::customJQuery ( ) const

Executes some JavaScript code.

This method may be used to call some custom \p javaScript code as
part of an event response.

This function does not wait until the JavaScript is run, but
returns immediately. The JavaScript will be run after the normal
event handling, unless \p afterLoaded is set to \c false.
See Also
addAutoJavaScript(), declareJavaScriptFunction()
void Wt::WApplication::declareJavaScriptFunction ( const std::string &  name,
const std::string &  function 
)

Declares an application-wide JavaScript function.

The function is stored in WApplication::javaScriptClass().

The next code snippet declares and invokes function foo:
app->declareJavaScriptFunction("foo",
"function(id) { ... }");
...
std::string id("myId");
app->doJavaScript(app->javaScriptClass() + ".foo('" + id + "');");
void Wt::WApplication::deferRendering ( )

Defers rendering of the current event response.

This method defers the rendering of the current event response
until resumeRendering() is called. This may be used if you do not
want to actively block the current thread while waiting for an
event which is needed to complete the current event
response. Note that this effectively freezes the user interface,
and thus you should only do this if you know that the event you
are waiting for will arrive shortly, or there is really nothing more
useful for the user to do than wait for the action to complete.

A typical use case is in conjunction with the Http::Client, to
defer the rendering while waiting for the Http::Client to
complete.

The function may be called multiple times and the number of deferral
requests is counted. The current response is deferred until as
many calls to resumeRendering() have been performed.
See Also
resumeRendering()
std::string Wt::WApplication::docRoot ( ) const

Returns the server document root.

This returns the filesystem path that corresponds to the document root
of the webserver.
Note
This does not work reliably for complex webserver configurations (e.g. using FastCGI with Apache and rewrite rules). See also the discussion here.
See Also
appRoot()
void Wt::WApplication::doJavaScript ( const std::string &  javascript,
bool  afterLoaded = true 
)

Executes some JavaScript code.

This method may be used to call some custom \p javaScript code as
part of an event response.

This function does not wait until the JavaScript is run, but
returns immediately. The JavaScript will be run after the normal
event handling, unless \p afterLoaded is set to \c false.
See Also
addAutoJavaScript(), declareJavaScriptFunction()
void Wt::WApplication::enableAjax ( )
protectedvirtual

Progresses to an Ajax-enabled user interface.

This method is called when the progressive bootstrap method is used, and
support for AJAX has been detected. The default behavior will propagate
the WWidget::enableAjax() method through the widget hierarchy.

You may want to reimplement this method if you want to make
changes to the user-interface when AJAX is enabled. You should
always call the base implementation.
See Also
WWidget::enableAjax()
void Wt::WApplication::enableUpdates ( bool  enabled = true)

Enables server-initiated updates.

By default, updates to the user interface are possible only at
startup, during any event (in a slot), or at regular time points
using WTimer. This is the normal %Wt event loop.

In some cases, one may want to modify the user interface from a
second thread, outside the event loop. While this may be worked
around by the WTimer, in some cases, there are bandwidth and
processing overheads associated which may be unnecessary, and
which create a trade-off with time resolution of the updates.

When \p enabled is \c true, this enables "server push" (what is
called 'comet' in AJAX terminology). Widgets may then be
modified, created or deleted outside of the event loop (e.g. in
response to execution of another thread), and these changes are
propagated by calling triggerUpdate().

There are two ways for safely manipulating a session's UI, with
respect to thread-safety and application life-time (the library
can decide to terminate an application if it lost connectivity
with the browser).

<h3>WServer::post()</h3>

The easiest and less error-prone solution is to post an event,
represented by a function/method call, to a session using
WServer::post().

The method is non-blocking: it returns immediately, avoiding
dead-lock scenarios. The function is called from within a thread
of the server's thread pool, and not if the session has been or
is being terminated. The function is called in the context of the
targeted application session, and with exclusive access to the
session.

<h3>WApplication::UpdateLock</h3>

A more direct approach is to grab the application's update lock and
manipulate the application's state directly from another thread.

At any time, the application may be deleted (e.g. because of a
time out or because the user closes the application window). You
should thus make sure you do no longer reference an application
after it has been deleted. When %Wt decides to delete an
application, it first runs WApplication::finalize() and then
invokes the destructor. While doing this, any other thread trying
to grab the update lock will unblock, but the lock will return \c
false. You should therefore always check whether the lock is
valid.


An example of how to modify the widget tree outside the event loop
and propagate changes is:
// You need to have a reference to the application whose state
// you are about to manipulate.
// You should prevent the application from being deleted somehow,
// before you could grab the application lock.
Wt::WApplication *app = ...;
{
// Grab the application lock. It is a scoped lock.
if (lock) {
// We now have exclusive access to the application: we can safely modify the widget tree for example.
app->root()->addWidget(new Wt::WText("Something happened!"));
// Push the changes to the browser
app->triggerUpdate();
}
}
Note
This works only if JavaScript is available on the client.
See Also
triggerUpdate()
std::string Wt::WApplication::encodeUntrustedUrl ( const std::string &  url) const

Encodes an untrusted URL to prevent referer leaks.

This encodes an URL so that in case the session ID is present in the current URL, this session ID does not leak to the refenced URL.

Wt will safely handle URLs in the API (in WImage and WAnchor) but you may want to use this function to encode URLs which you use in WTemplate texts.

const WEnvironment & Wt::WApplication::environment ( ) const

Returns the environment information.

This method returns the environment object that was used when
constructing the application. The environment provides
information on the initial request, user agent, and
deployment-related information.
See Also
url(), sessionId()
void Wt::WApplication::finalize ( )
virtual

Finalizes the application, pre-destruction.

This method is invoked by the Wt library before destruction of a new application. You may reimplement this method to do additional finalization that is not possible from the destructor (e.g. which uses virtual methods).

WWidget * Wt::WApplication::findWidget ( const std::string &  name)

Finds a widget by name.

This finds a widget in the application's widget hierarchy. It
does not only consider widgets in the root(), but also widgets
that are placed outside this root, such as in dialogs, or other
"roots" such as all the bound widgets in a widgetset application.
See Also
WWidget::setObjectName(), WWidget::find()
WApplication::UpdateLock Wt::WApplication::getUpdateLock ( )

Grabs and returns the lock for manipulating widgets outside the event loop (deprecated).

You need to keep this lock in scope while manipulating widgets
outside of the event loop. In normal cases, inside the %Wt event
loop, you do not need to care about it.
See Also
enableUpdates(), triggerUpdate()
Deprecated:
Use the RAII-style UpdateLock(WApplication *) constructor instead.
EventSignal & Wt::WApplication::globalEnterPressed ( )

Event signal emitted when enter was pressed.

The application receives key events when no widget currently
has focus. Otherwise, key events are handled by the widget in focus,
and its ancestors.
See Also
See WInteractWidget::enterPressed()
EventSignal & Wt::WApplication::globalEscapePressed ( )

Event signal emitted when escape was pressed.

The application receives key events when no widget currently
has focus. Otherwise, key events are handled by the widget in focus,
and its ancestors.
See Also
See WInteractWidget::escapePressed()
EventSignal< WKeyEvent > & Wt::WApplication::globalKeyPressed ( )

Event signal emitted when a "character" was entered.

The application receives key events when no widget currently
has focus. Otherwise, key events are handled by the widget in focus,
and its ancestors.
See Also
See WInteractWidget::keyPressed()
EventSignal< WKeyEvent > & Wt::WApplication::globalKeyWentDown ( )

Event signal emitted when a keyboard key is pushed down.

The application receives key events when no widget currently
has focus. Otherwise, key events are handled by the widget in focus,
and its ancestors.
See Also
See WInteractWidget::keyWentDown()
EventSignal< WKeyEvent > & Wt::WApplication::globalKeyWentUp ( )

Event signal emitted when a keyboard key is released.

The application receives key events when no widget currently
has focus. Otherwise, key events are handled by the widget in focus,
and its ancestors.
See Also
See WInteractWidget::keyWentUp()
bool Wt::WApplication::hasQuit ( ) const

Returns whether the application has quit.

See Also
quit()
std::string Wt::WApplication::htmlClass ( ) const

Returns the style class set for the entire page <html>.

See Also
setHtmlClass()
void Wt::WApplication::initialize ( )
virtual

Initializes the application, post-construction.

This method is invoked by the Wt library after construction of a new application. You may reimplement this method to do additional initialization that is not possible from the constructor (e.g. which uses virtual methods).

WApplication * Wt::WApplication::instance ( )
static

Returns the current application instance.

This is the same as the global define #wApp. In a multi-threaded server, this method uses thread-specific storage to fetch the current session.

std::string Wt::WApplication::internalPath ( ) const

Returns the current internal path.

When the application is just created, this is equal to
WEnvironment::internalPath().
See Also
setInternalPath(), internalPathNextPart(), internalPathMatches()
Note
the returned path is UTF8 (we may fix the API to use WString in the future).
Signal< std::string > & Wt::WApplication::internalPathChanged ( )

Signal which indicates that the user changes the internal path.

This signal indicates a change to the internal path, which is
usually triggered by the user using the browser back/forward
buttons.

The argument contains the new internal path.
See Also
setInternalPath()
Note
the internal path is UTF8 encoded (we may fix the API to use WString in the future).
bool Wt::WApplication::internalPathDefaultValid ( ) const

Returns whether an internal path is valid by default.

See Also
setInternalPathDefaultValid()
Signal<std::string>& Wt::WApplication::internalPathInvalid ( )

Returns a URL for the current session.

Returns the (relative) URL for this application session
(including the session ID if necessary). The URL includes the
full application path, and is expanded by the browser into a full
URL.

For example, for an application deployed at@code 
http://www.mydomain.com/stuff/app.wt \endcode this method might
return <tt>"/stuff/app.wt?wtd=AbCdEf"</tt>. Additional query
parameters can be appended in the form of
<tt>"&param1=value&param2=value"</tt>.

To obtain a URL that is suitable for bookmarking the current
application state, to be used across sessions, use bookmarkUrl()
instead.
See Also
redirect(), WEnvironment::hostName(), WEnvironment::urlScheme()
bookmarkUrl()
bool Wt::WApplication::internalPathMatches ( const std::string &  path) const

Checks if the internal path matches a given path.

Returns whether the current internalPath() starts with
\p path (or is equal to \p path). You will typically use
this method within a slot conneted to the internalPathChanged()
signal, to check that an internal path change affects the
widget. It may also be useful before changing \p path using
setInternalPath() if you do not intend to remove sub paths when
the current internal path already matches \p path.

The \p path must start with a '/'.
See Also
setInternalPath(), internalPath()
Note
the internal path is UTF8 encoded (we may fix the API to use WString in the future).
std::string Wt::WApplication::internalPathNextPart ( const std::string &  path) const

Returns a part of the current internal path.

This is a convenience method which returns the next \p folder
in the internal path, after the given \p path.

For example, when the current internal path is
<tt>"/project/z3cbc/details"</tt>, this method returns
<tt>"details"</tt> when called with <tt>"/project/z3cbc/"</tt> as
\p path argument.

The \p path must start with a '/', and internalPathMatches()
should evaluate to \c true for the given \p path. If not,
an empty string is returned and an error message is logged.
See Also
internalPath(), internalPathChanged()
Note
the internal path is UTF8 encoded (we may fix the API to use WString in the future).
bool Wt::WApplication::internalPathValid ( ) const

Returns whether the current internal path is valid.

See Also
setInternalPathValid()
std::string Wt::WApplication::internalSubPath ( const std::string &  path) const

Returns a URL for the current session.

Returns the (relative) URL for this application session
(including the session ID if necessary). The URL includes the
full application path, and is expanded by the browser into a full
URL.

For example, for an application deployed at@code 
http://www.mydomain.com/stuff/app.wt \endcode this method might
return <tt>"/stuff/app.wt?wtd=AbCdEf"</tt>. Additional query
parameters can be appended in the form of
<tt>"&param1=value&param2=value"</tt>.

To obtain a URL that is suitable for bookmarking the current
application state, to be used across sessions, use bookmarkUrl()
instead.
See Also
redirect(), WEnvironment::hostName(), WEnvironment::urlScheme()
bookmarkUrl()
bool Wt::WApplication::isExposed ( WWidget w) const
protectedvirtual

Returns whether a widget is exposed in the interface.

The default implementation simply returns true, unless a modal dialog is active, in which case it returns true only for widgets that are inside the dialog.

You may want to reimplement this method if you wish to disallow events from certain widgets even when they are inserted in the widget hierachy.

bool Wt::WApplication::isQuited ( ) const

Returns whether the application has quit. (deprecated)

See Also
quit()
Deprecated:
hasQuit() is proper English
std::string Wt::WApplication::javaScriptClass ( )

Returns the name of the application JavaScript class.

This JavaScript class encapsulates all JavaScript methods specific to this application instance. The method is foreseen to allow multiple applications to run simultaneously on the same page in Wt::WidgtSet mode, without interfering.

LayoutDirection Wt::WApplication::layoutDirection ( ) const

Returns the layout direction.

See Also
setLayoutDirection()
WLoadingIndicator* Wt::WApplication::loadingIndicator ( ) const

Returns the loading indicator.

See Also
setLoadingIndicator()
const WLocale& Wt::WApplication::locale ( ) const

Returns the current locale.

See Also
setLocale(const std::string&)
WLocalizedStrings * Wt::WApplication::localizedStrings ( )

Returns the resource object that provides localized strings.

The default value is a WMessageResourceBundle instance, which
uses XML files to resolve localized strings, but you can set a
custom class using setLocalizedStrings().

WString::tr() is used to create localized strings, whose
localized translation is looked up through this object, using a
key.
See Also
WString::tr(), messageResourceBundle()
WLogEntry Wt::WApplication::log ( const std::string &  type) const

Adds an entry to the application log.

 Starts a new log entry of the given \p type in the %Wt
 application log file. This method returns a stream-like object to
 which the message may be streamed.

 A typical usage would be:
wApp->log("notice") << "User " << userName << " logged in successfully.";

This would create a log entry that looks like:

[2008-Jul-13 14:01:17.817348] 16879 [/app.wt Z2gCmSxIGjLHD73L] [notice] "User bart logged in successfully."
   * 
See Also
10.2 General application settings (wt_config.xml)
std::string Wt::WApplication::makeAbsoluteUrl ( const std::string &  url) const
virtual

Makes an absolute URL.

Returns an absolute URL for a given (relative url) by including the schema, hostname, and deployment path.

If url is "", then the absolute base URL is returned. This is the absolute URL at which the application is deployed, up to the last '/'.

This is not used in the library, except when a public URL is needed, e.g. for inclusion in an email.

You may want to reimplement this method when the application is hosted behind a reverse proxy or in general the public URL of the application cannot be guessed correctly by the application.

int64_t Wt::WApplication::maximumRequestSize ( ) const

Returns the current maximum size of a request to the application.

The returned value is the maximum request size in bytes.

The maximum request size is configured in the configuration file,
see \ref config_general.
See Also
requestTooLarge()
WMessageResourceBundle & Wt::WApplication::messageResourceBundle ( )

Returns the message resource bundle.

The message resource bundle defines the list of external XML
files that are used to lookup localized strings.

The default localizedStrings() is a WMessageResourceBundle
object, and this method returns localizedStrings() upcasted to
this type.
See Also
WString::tr(const char *key)
void Wt::WApplication::notify ( const WEvent e)
protectedvirtual

Notifies an event to the application.

This method is called by the event loop for propagating an event
to the application. It provides a single point of entry for
events to the application, besides the application constructor.

You may want to reimplement this method for two reasons:

- for having a single point for exception handling: while you may want
  to catch recoverable exceptions in a more appropriate place, general
  (usually fatal) exceptions may be caught here. You will in probably
  also want to catch the same exceptions in the application constructor
  in the same way.
- you want to manage resource usage during requests. For example, at
  the end of request handling, you want to return a database session
  back to the pool. Since %notify() is also used for rendering right after
  the application is created, this will also clean up resources after
  application construction.

In either case, you will need to call the base class
implementation of %notify(), as otherwise no events will be
delivered to your application.

The following shows a generic template for reimplementhing this
method for both managing request resources and generic exception
handling.
MyApplication::notify(const WEvent& event)
{
// Grab resources for during request handling
try {
} catch (MyException& exception) {
// handle this exception in a central place
}
// Free resources used during request handling
}

Note that any uncaught exception throw during event handling terminates the session.

void Wt::WApplication::processEvents ( )

Processes UI events.

You may call this method during a long operation to:

  • propagate widget changes to the client.
  • process UI events.

This method starts a recursive event loop, blocking the current thread, and resumes when all pending user interface events have been processed.

Because a thread is blocked, this may affect your application scalability.

void Wt::WApplication::pushExposedConstraint ( WWidget w)

Pushes a (modal) widget onto the expose stack.

This defines a new context of widgets that are currently visible.

void Wt::WApplication::quit ( )

Quits the application.

The method returns immediately, but has as effect that the
application will be terminated after the current event is
completed.

The current widget tree (including any modifications still
pending and applied during the current event handling) will still
be rendered, after which the application is terminated.

You might want to make sure no more events can be received from
the user, by not having anything clickable, for example by
displaying only text. Even better is to redirect() the user to
another, static, page in conjunction with %quit().
See Also
redirect()
bool Wt::WApplication::readConfigurationProperty ( const std::string &  name,
std::string &  value 
)
static

Reads a configuration property.

Tries to read a configured value for the property
\p name. The method returns whether a value is defined for
the property, and sets it to \p value.
See Also
WServer::readConfigurationProperty()
void Wt::WApplication::redirect ( const std::string &  url)

Redirects the application to another location.

The client will be redirected to a new location identified by url. Use this in conjunction with quit() if you want to the application to be terminated as well.

Calling redirect() does not imply quit() since it may be useful to switch between a non-secure and secure (SSL) transport connection.

void Wt::WApplication::refresh ( )
virtual

Refreshes the application.

This lets the application to refresh its data, including strings
from message-resource bundles. This done by propagating
WWidget::refresh() through the widget hierarchy.

This method is also called when the user hits the refresh (or
reload) button, if this can be caught within the current session.


The reload button may only be caught when %Wt is configured so that
reload should not spawn a new session. When URL rewriting is used for
session tracking, this will cause an ugly session ID to be added to the
URL. See \ref config_session for configuring the reload
behavior ("<reload-is-new-session>").
See Also
WWidget::refresh()
std::string Wt::WApplication::relativeResourcesUrl ( )
static

Returns the URL at which the resources are deployed.

This returns the value of the 'resources' property set in the
configuration file, and may thus be a URL relative to the deployment
path.
See Also
resolveRelativeUrl()
void Wt::WApplication::removeCookie ( const std::string &  name,
const std::string &  domain = "",
const std::string &  path = "" 
)

Removes a cookie.

See Also
setCookie()
void Wt::WApplication::removeMetaHeader ( MetaHeaderType  type,
const std::string &  name = "" 
)

Removes one or all meta headers.

Removes the meta header with given type and name (if it is present).
If name is empty, all meta headers of the given type are removed.
See Also
addMetaHeader()
void Wt::WApplication::removeMetaLink ( const std::string &  href)

Removes the HTML meta link.

See Also
addMetaLink()
Signal< ::int64_t >& Wt::WApplication::requestTooLarge ( )

Signal which indicates that too a large request was received.

The integer parameter is the request size that was received in bytes.

bool Wt::WApplication::require ( const std::string &  url,
const std::string &  symbol = std::string() 
)

Loads a JavaScript library.

Loads a JavaScript library located at the URL url. Wt keeps track of libraries (with the same URL) that already have been loaded, and will load a library only once. In addition, you may provide a symbol which if already defined will also indicate that the library was already loaded (possibly outside of Wt when in WidgetSet mode).

This method returns true only when the library is loaded for the first time.

JavaScript libraries may be loaded at any point in time. Any JavaScript code is deferred until the library is loaded, except for JavaScript that was defined to load before, passing false as second parameter to doJavaScript().

Although Wt includes an off-the-shelf JQuery version (which can also be used by your own JavaScript code), you can override the one used by Wt and load another JQuery version instead, but this needs to be done using requireJQuery().

bool Wt::WApplication::requireJQuery ( const std::string &  url)

Loads a custom JQuery library.

%Wt ships with a rather old version of JQuery (1.4.1) which is
sufficient for its needs and is many times smaller than more recent
JQuery releases (about 50% smaller).

Using this function, you can replace Wt's JQuery version with another
version of JQuery.
requireJQuery("jquery/jquery-1.7.2.min.js");
std::string Wt::WApplication::resolveRelativeUrl ( const std::string &  url) const

"Resolves" a relative URL taking into account internal paths.

Using HTML5 History API or in a plain HTML session (without ugly internal paths), the internal path is present as a full part of the URL. This has a consequence that relative URLs, if not dealt with, would be resolved against the last 'folder' name of the internal path, rather than against the application deployment path (which is what you probably want).

When using a widgetset mode deployment, or when configuring a baseURL property in the configuration, this method will make an absolute URL so that the property is fetched from the right server.

Otherwise, this method will fixup a relative URL so that it resolves correctly against the base path of an application. This does not necessarily mean that the URL is resolved into an absolute URL. In fact, Wt will simply prepend a sequence of "../" path elements to correct for the internal path. When passed an absolute URL (i.e. starting with '/'), the url is returned unchanged.

For URLs passed to the Wt API (and of which the library knows it is represents a URL) this method is called internally by the library. But it may be useful for URLs which are set e.g. inside a WTemplate.

std::string Wt::WApplication::resourcesUrl ( )
static

Returns the URL at which the resources are deployed.

Returns resolveRelativeUrl(relativeResourcesUrl())

void Wt::WApplication::resumeRendering ( )

Resumes rendering of a deferred event response.

See Also
deferRendering()
WContainerWidget* Wt::WApplication::root ( ) const

Returns the root container.

This is the top-level widget container of the application, and corresponds to entire browser window. The user interface of your application is represented by the content of this container.

The %root() widget is only defined when the application manages
the entire window. When deployed as a \link Wt::WidgetSet
WidgetSet\endlink application, there is no %root() container, and
\c 0 is returned.  Instead, use bindWidget() to bind one or more
root widgets to existing HTML &lt;div&gt; (or other) elements on
the page.
std::string Wt::WApplication::sessionId ( ) const

Returns the unique identifier for the current session.

The session id is a string that uniquely identifies the current session. Note that the actual contents has no particular meaning and client applications should in no way try to interpret its value.

void Wt::WApplication::setAjaxMethod ( AjaxMethod  method)

Sets the Ajax communication method (deprecated).

This method has no effect.

Since %Wt 3.1.8, a communication method that works is detected at
run time. For widget set mode, cross-domain Ajax is chosen if
available.
Deprecated:
this setting is no longer needed.
void Wt::WApplication::setBodyClass ( const std::string &  styleClass)

Sets a style class to the entire page <body>.

See Also
setHtmlClass()
void Wt::WApplication::setConfirmCloseMessage ( const WString message)

Sets the message for the user to confirm closing of the application window/tab.

If the message is empty, then the user may navigate away from the page
without confirmation.

Otherwise the user will be prompted with a browser-specific
dialog asking him to confirm leaving the page. This \p message is
added to the page.
See Also
unload()
void Wt::WApplication::setCookie ( const std::string &  name,
const std::string &  value,
int  maxAge,
const std::string &  domain = "",
const std::string &  path = "",
bool  secure = false 
)

Sets a new cookie.

Use cookies to transfer information across different sessions
(e.g. a user name). In a subsequent session you will be able to
read this cookie using WEnvironment::getCookie(). You cannot use
a cookie to store information in the current session.

The name must be a valid cookie name (of type 'token': no special
characters or separators, see RFC2616 page 16). The value may be
anything. Specify the maximum age (in seconds) after which the
client must discard the cookie. To delete a cookie, use a value of '0'.

By default the cookie only applies to the application deployment
path (WEnvironment::deploymentPath()) in the current domain. To
set a proper value for domain, see also RFC2109.
Note
Wt provides session tracking automatically, and may be configured to use a cookie for this. You only need to use cookies yourself if you want to remember some information (like a logged in identity) across sessions.
See Also
WEnvironment::supportsCookies(), WEnvironment::getCookie()
void Wt::WApplication::setCssTheme ( const std::string &  name)

Sets a CSS theme.

This sets a WCssTheme as theme.

The theme provides the look and feel of several built-in widgets, using CSS style rules. Rules for each CSS theme are defined in the resources/themes/name/ folder.

The default theme is "default". Setting an empty theme "" will result in a stub CSS theme that does not load any stylesheets.

void Wt::WApplication::setHtmlClass ( const std::string &  styleClass)

Sets a style class to the entire page <html>.

See Also
setBodyClass()
void Wt::WApplication::setInternalPath ( const std::string &  path,
bool  emitChange = false 
)

Changes the internal path.

A %Wt application may manage multiple virtual paths. The virtual
path is appended to the application URL. Depending on the
situation, the path is directly appended to the application URL
or it is appended using a name anchor (#).

For example, for an application deployed at:
http://www.mydomain.com/stuff/app.wt

for which an internalPath "/project/z3cbc/details/" is set, the two forms for the application URL are:

  • in an AJAX session (HTML5):
    http://www.mydomain.com/stuff/app.wt/project/z3cbc/details/
  • in an AJAX session (HTML4):
    http://www.mydomain.com/stuff/app.wt#/project/z3cbc/details/
  • in a plain HTML session:
    http://www.mydomain.com/stuff/app.wt/project/z3cbc/details/

Note, since Wt 3.1.9, the actual form of the URL no longer affects relative URL resolution, since now Wt includes an HTML meta base tag which points to the deployment path, regardless of the current internal path. This does break deployments behind a reverse proxy which changes paths.

For the built-in httpd, when the application is deployed at a folder (ending with '/'), only an exact matching path is routed to the application (this can be changed since Wt 3.1.9, see 9.2 Built-in httpd ), making clean URLs impossible. Returned URLs then include a "?_=" encoding for the internal path:

http://www.mydomain.com/stuff/?_=/project/z3cbc/details/

When the internal path is changed, an entry is added to the browser history. When the user navigates back and forward through this history (using the browser back/forward buttons), an internalPathChanged() event is emitted. You should listen to this signal to switch the application to the corresponding state. When emitChange is true, this signal is also emitted by setting the path.

A url that includes the internal path may be obtained using bookmarkUrl().

The internalPath must start with a '/'. In this way, you can still use normal anchors in your HTML. Internal path changes initiated in the browser to paths that do not start with a '/' are ignored.

See Also
bookmarkUrl(), internalPath(), internalPathChanged()
Note
the path should be UTF8 encoded (we may fix the API to use WString in the future).
void Wt::WApplication::setInternalPathDefaultValid ( bool  valid)

Sets whether an internal path is valid by default.

This configures how you treat (invalid) internal paths. If an internal path is treated valid by default then you need to call setInternalPath(false) for an invalid path. If on the other hand you treat an internal path as invalid by default, then you need to call setInternalPath(true) for a valid path.

A user which opens an invalid internal path will receive a HTTP 404-Not Found response code (if sent an HTML response).

The default value is true.

void Wt::WApplication::setInternalPathValid ( bool  valid)

Sets whether the current internal path is valid.

You can use this function in response to an internal path change
event (or at application startup) to indicate whether the new (or
initial) internal path is valid. This has only an effect on plain
HTML sessions, or on the first response in an application
deployed with progressive bootstrap settings, as this generates
then a 404 Not-Found response.
See Also
internalPathChanged(), setInternalPathDefaultValid()
void Wt::WApplication::setJavaScriptClass ( const std::string &  className)

Sets the name of the application JavaScript class.

This should be called right after construction of the application, and changing the JavaScript class is only supported for WidgetSet mode applications. The className should be a valid JavaScript identifier, and should also be unique in a single page.

void Wt::WApplication::setLayoutDirection ( LayoutDirection  direction)

Sets the layout direction.

The default direction is LeftToRight.

This sets the language text direction, which by itself sets the
default text alignment and reverse the column orders of &lt;table&gt;
elements.

In addition, %Wt will take this setting into account in WTextEdit,
WTableView and WTreeView (so that columns are reverted), and swap
the behaviour of WWidget::setFloatSide() and
WWidget::setOffsets() for RightToLeft languages. Note that CSS
settings themselves are not affected by this setting, and thus
for example <tt>"float: right"</tt> will move a box to the right,
irrespective of the layout direction.

The library sets <tt>"Wt-ltr"</tt> or <tt>"Wt-rtl"</tt> as style
classes for the document body. You may use this if to override
certain style rules for a Right-to-Left document.

For example:
body .sidebar { float: right; }
body.Wt-rtl .sidebar { float: left; }
Note
The layout direction can be set only at application startup and does not have the effect of rerendering the entire UI.
void Wt::WApplication::setLoadingIndicator ( WLoadingIndicator indicator)

Sets the loading indicator.

The loading indicator is shown to indicate that a response from the server is pending or JavaScript is being evaluated.

The default loading indicator is a WDefaultLoadingIndicator.

When setting a new loading indicator, the previous one is deleted.

void Wt::WApplication::setLocale ( const WLocale locale)

Changes the locale.

The locale is used by the localized strings resource to resolve
localized strings.

By passing an empty \p locale, the default locale is
chosen.

When the locale is changed, refresh() is called, which will
resolve the strings of the current user-interface in the new
locale.

At construction, the locale is copied from the environment
(WEnvironment::locale()), and this is the locale that was
configured by the user in his browser preferences, and passed
using an HTTP request header.
See Also
localizedStrings(), WString::tr()
void Wt::WApplication::setLocalizedStrings ( WLocalizedStrings stringResolver)

Sets the resource object that provides localized strings.

The \p translator resolves localized strings within the current
application locale.

The previous resource is deleted, and ownership of the new resource
passes to the application.
See Also
localizedStrings(), WString::tr(const char *key)
void Wt::WApplication::setTheme ( const WTheme theme)

Sets the theme.

The theme provides the look and feel of several built-in widgets, using CSS style rules. Rules for each theme are defined in the resources/themes/theme/ folder.

The default theme is "default" CSS theme.

void Wt::WApplication::setTitle ( const WString title)

Sets the window title.

Sets the browser window title to \p title.

The default title is "".
See Also
title()
void Wt::WApplication::setTwoPhaseRenderingThreshold ( int  size)

Changes the threshold for two-phase rendering.

This changes the threshold for the size of a JavaScript response (in bytes) to render invisible changes in one go. If the bandwidth for rendering the invisible changes exceed the threshold, they will be fetched in a second communication, after the visible changes have been rendered.

The value is a trade-off: setting it smaller will always use two-phase rendering, increasing the total render time but reducing the latency for the visible changes. Setting it too large will increase the latency to render the visible changes, since first also all invisible changes need to be computed and received in the browser.

The initial value is read from the configuration file, see 10.2 General application settings (wt_config.xml).

WCssStyleSheet& Wt::WApplication::styleSheet ( )

Returns a reference to the inline style sheet.

Widgets may allow configuration of their look and feel through
style classes. These may be defined in this inline stylesheet, or
in external style sheets.

It is usually preferable to use external stylesheets (and
consider more accessible). Still, the internal stylesheet has as
benefit that style rules may be dynamically updated, and it is
easier to manage logistically.
See Also
useStyleSheet()
WWidget::setStyleClass()
const WString& Wt::WApplication::title ( ) const

Returns the window title.

See Also
setTitle(const WString&)
void Wt::WApplication::triggerUpdate ( )

Propagates server-initiated updates.

When the lock to the application is released, changes will
propagate to the user interface. This call only has an effect
after updates have been enabled from within the normal event loop
using enableUpdates().

This is typically used only outside of the main event loop,
e.g. from another thread or from within a method posted to an
application using WServer::post(), since changes always propagate
within the event loop at the end of the event.

The update is not immediate, and thus changes that happen after this
call will equally be pushed to the client.
See Also
enableUpdates()
void Wt::WApplication::unload ( )
protectedvirtual

Handles a browser unload event.

The browser unloads the application when the user navigates away or when he closes the window or tab.

When reload-is-new-session is set to true, then the default implementation of this method terminates this session by calling quit(), otherwise the session is scheduled to expire within seconds (since it may be a refresh).

You may want to reimplement this if you want to keep the application running until it times out (as was the behaviour before Wt 3.1.6).

bool Wt::WApplication::updatesEnabled ( ) const

Returns whether server-initiated updates are enabled.

See Also
enableUpdates()
std::string Wt::WApplication::url ( const std::string &  internalPath = std::string()) const

Returns a URL for the current session.

Returns the (relative) URL for this application session
(including the session ID if necessary). The URL includes the
full application path, and is expanded by the browser into a full
URL.

For example, for an application deployed at@code 
http://www.mydomain.com/stuff/app.wt \endcode this method might
return <tt>"/stuff/app.wt?wtd=AbCdEf"</tt>. Additional query
parameters can be appended in the form of
<tt>"&param1=value&param2=value"</tt>.

To obtain a URL that is suitable for bookmarking the current
application state, to be used across sessions, use bookmarkUrl()
instead.
See Also
redirect(), WEnvironment::hostName(), WEnvironment::urlScheme()
bookmarkUrl()
void Wt::WApplication::useStyleSheet ( const WLink link,
const std::string &  media = "all" 
)

Adds an external style sheet.

The \p link is a link to a stylesheet.

The \p media indicates the CSS media to which this stylesheet
applies. This may be a comma separated list of media. The default
value is "all" indicating all media.

This is an overloaded method for convenience, equivalent to:
void Wt::WApplication::useStyleSheet ( const WLink link,
const std::string &  condition,
const std::string &  media 
)

Conditionally adds an external style sheet.

This is an overloaded method for convenience, equivalent to:
useStyleSheet(Wt::WCssStyleSheet(link, media), condition)
void Wt::WApplication::useStyleSheet ( const WCssStyleSheet styleSheet,
const std::string &  condition = "" 
)

Adds an external stylesheet.

Widgets may allow configuration of their look and feel through
style classes. These may be defined in an inline stylesheet,
or in external style sheets.

External stylesheets are inserted after the internal style sheet,
and can therefore override default styles set by widgets in the
internal style sheet.

If not empty, \p condition is a string that is used to apply the
stylesheet to specific versions of IE. Only a limited subset of
the IE conditional comments syntax is supported (since these are
in fact interpreted server-side instead of client-side). Examples
are:

- "IE gte 6": only for IE version 6 or later.
- "!IE gte 6": only for IE versions prior to IE6.
- "IE lte 7": only for IE versions prior to IE7.
See Also
styleSheet(), useStyleSheet(const std::string&, const std::string&)
WWidget::setStyleClass()

Friends And Related Function Documentation

typedef boost::function<WApplication* (const WEnvironment&)> ApplicationCreator
related

Typedef for a function that creates WApplication objects.

See Also
WRun()

Generated on Fri May 31 2013 for the C++ Web Toolkit (Wt) by doxygen 1.8.3.1