Wt (web toolkit)

Short description: C++ web application framework

WtOriginal author(s)| Emweb

|

Initial release| 1.0.0 / December 2005; 18 years ago (2005-12)
Stable release|

4.10.0 / May 30, 2023; 13 months ago (2023-05-30)[1]

Repository| Wt Repository
Written in| C++
Operating system| Cross-platform
Type| Web framework
License| Dual-licensed:

* GNU General Public License
* Commercial License

Website| www.webtoolkit.eu/wt

Wt (pronounced "witty") is an open-source widget-centric web framework for the C++ programming language. It has an API resembling that of Qt framework (although it was developed with Boost, and is incompatible when mixed with Qt), also using a widget-tree and an event-driven signal/slot system.[2]

The Wt's design goal is to benefit from the stateful component model used in desktop-applications APIs, applied to web development—instead of the traditional MVC (model–view–controller) design pattern. So rather than using MVC at the level of a web page, it is pushed to the level of individual components.[3]

While the library uses a desktop software development process, it does support some web-specific features, including:

* Semantic URLs
* Navigation of browser's history

One of the unique features of Wt is its abstraction layer of the browser rendering model. The library uses Ajax for communicating with browsers compatible with it, while using plain HTML-form post-backs for other user agents. Using a progressive bootstrap-method, the user interface is rendered as a plain HTML document first, then, provided its support in browser, it is automatically upgraded to use Ajax for increased interactivity. In this way, Wt is by definition:

* The only server-side framework implementing the strategy of progressive enhancement automatically;
* The only Ajax framework with search engine optimization (SEO) qualities.

Because of the popularity of C/C++ in embedded system environments, Wt is often used in such devices and (as a consequence) has been highly optimized for performance.

## Contents

* 1 Major features
* 2 Code example
* 3 See also
* 4 References
* 5 External links

## Major features

* Automatic graceful degradation and progressive enhancement
* Supports server-initiated events (Comet)
* A unified rendering API (SVG, the HTML5 canvas element, VML)
* Client\- and server-side validation
* Contains various security features to avoid Cross-site scripting and Cross-site request forgery (CSRF) vulnerabilities
* Includes a compact C++ ORM-layer ("Wt::Dbo")
* Uses the WebSocket networking protocol, if available, for Client–server model of communication, with fallbacks to Ajax or plain web page rendering

For a more detailed overview, see the Features section of official website.

## Code example

The "Hello, World!" program in Wt:

#include <Wt/WApplication.h>
#include <Wt/WBreak.h>
#include <Wt/WContainerWidget.h>
#include <Wt/WLineEdit.h>
#include <Wt/WPushButton.h>
#include <Wt/WText.h>

* A simple hello world application class which demonstrates how to react
* to events, read input, and give feed-back.

class HelloApplication : public Wt::WApplication

public:
HelloApplication(const Wt::WEnvironment& env);

private:
Wt::WLineEdit *nameEdit_;
Wt::WText     *greeting_;

void greet();

* The env argument contains information about the new session, and
* the initial request. It must be passed to the WApplication
* constructor so it is typically also an argument for your custom
* application constructor.

HelloApplication::HelloApplication(const Wt::WEnvironment& env)
: WApplication(env)

setTitle("Hello world");                            // application title

root()->addNew<Wt::WText>("Your name, please ? ");  // show some text

nameEdit_ = root()->addNew<Wt::WLineEdit>();        // allow text input
nameEdit_->setFocus();                              // give focus

auto button = root()->addNew<Wt::WPushButton>("Greet me."); // create a button
button->setMargin(5, Wt::Side::Left);                       // add 5 pixels margin

root()->addNew<Wt::WBreak>();            // insert a line break
greeting_ = root()->addNew<Wt::WText>(); // empty text

* Connect signals with slots
* - simple Wt-way: specify object and method

button->clicked().connect(this, &HelloApplication::greet);

* - using an arbitrary function object, e.g. useful to bind
*   values with std::bind() to the resulting method call

nameEdit_->enterPressed().connect(std::bind(&HelloApplication::greet, this));

* - using a lambda:

button->clicked().connect([=]() {
std::cerr << "Hello there, " << nameEdit_->text() << "\n";
});

void HelloApplication::greet()

* Update the text, using text input into the nameEdit_ field.

greeting_->setText("Hello there, " + nameEdit_->text());

int main(int argc, char **argv)

* Your main method may set up some shared resources, but should then
* start the server application (FastCGI or httpd) that starts listening
* for requests, and handles all of the application life cycles.
* The last argument to WRun specifies the function that will instantiate
* new application objects. That function is executed when a new user surfs
* to the Wt application, and after the library has negotiated browser
* support. The function should return a newly instantiated application
* object.

return Wt::WRun(argc, argv, [](const Wt::WEnvironment &env) {

* You could read information from the environment to decide whether
* the user has permission to start a new application

return std::make_unique<HelloApplication>(env);
});

## See also

* Comparison of web-frameworks
* JWt (Java web toolkit), a native Java version of Wt
* Other C++ web frameworks

## References

1. ↑ "Wt: Release notes". https://www.webtoolkit.eu/wt/doc/reference/html/Releasenotes.html.
2. ↑ Dumon, Wim; Deforche, Koen (February 11, 2008). "Wt: A Web Toolkit". http://www.drdobbs.com/web-development/wt-a-web-toolkit/206401952.
3. ↑ Volkman, Victor (June 6, 2008). "Wt: C++ Web Toolkit Library Lets You Write Scripting-Independent Web Apps". QuinStreet. http://www.codeguru.com/cpp/i-n/internet/browsercontrol/article.php/c15275/.

## External links

* v
* t
* e

Web frameworks

* Comparison

C++|

* CppCMS
* Wt

CLI|

* ASP.NET
* Core
* AJAX
* Dynamic Data
* MVC
* Razor
* Web Forms
* DNN
* BFC
* MonoRail
* OpenRasta
* Umbraco
* WebSharper

ColdFusion|

* CFWheels
* ColdBox Platform
* ColdSpring
* Fusebox
* Model-Glue

Common Lisp|

* Caveman2
* CL-HTTP
* Weblocks

Haskell|

* Yesod
* Snap

Java|

* AppFuse
* Flexive
* Grails
* GWT
* ICEfaces
* ItsNat
* JavaServer Faces
* JHipster
* Jspx
* JWt
* OpenXava
* Play
* Remote Application Platform
* RIFE
* Seam
* Sling
* Spring
* Stripes
* Struts
* Tapestry
* Vaadin
* Vert.x
* WebWork
* Wicket
* WaveMaker
* ZK

JavaScript|

* Angular/AngularJS
* Backbone.js
* Chaplin.js
* Closure
* Dojo Toolkit
* Ember.js
* Express.js
* Ext JS
* jQuery
* Knockout.js
* Meteor
* MooTools
* Node.js
* OpenUI5
* Prototype
* React
* Rico
* script.aculo.us
* Sencha Touch
* SproutCore
* Svelte
* Vue.js
* Wakanda

Perl|

* Catalyst
* Dancer
* Mason
* Maypole
* Mojolicious
* WebGUI

PHP|

* CakePHP
* CodeIgniter
* Drupal
* Fat-Free
* FuelPHP
* Flow
* Grav
* Gyroscope
* Horde
* Joomla
* Kohana
* Laravel
* Lithium
* Midgard
* MODX
* Nette
* Phalcon
* PHP-Fusion
* Pop PHP
* PRADO
* ProcessWire
* Qcodo
* Silex
* SilverStripe
* Symfony
* TYPO3
* WordPress
* XOOPS
* Yii
* Zend Framework

Python|

* BlueBream
* CherryPy
* Django
* Flask
* Grok
* Nevow
* Pyjs
* Pylons
* Pyramid
* Quixote
* TACTIC
* Tornado
* TurboGears
* web2py
* Webware
* Zope 2
* more...

Ruby|

* Camping
* Merb
* Padrino
* Ruby on Rails
* Sinatra

Scala|

* Lift
* Play
* Scalatra

Smalltalk|

* AIDA/Web
* Seaside

Other languages|

* Vibe.d (D)
* Application Express (PL/SQL)
* Grails (Groovy)
* Kepler (Lua)
* OpenACS (Tcl)
* Phoenix (Elixir)
* SproutCore (JavaScript-Ruby)
* Yaws (Erlang)

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Wt (web toolkit). Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Software:Wt_(web_toolkit)&oldid=3053019"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template