Wt

https://www.webtoolkit.eu/wt/doc/
Admin
Wt is a C++ library for developing highly interactive and maintainable web applications, featuring a...
Tokens:3,026,761
Snippets:25,757
Trust Score:9.9
Update:5 days ago
Show doc for...
Tokens:
Raw
### main function with server setup and entry points

Source: https://www.webtoolkit.eu/wt/doc/examples/html/simpleChat_8C_source.html

Main entry point. Creates a Wt::WServer, a SimpleChatServer, adds two entry points (Application and WidgetSet), starts the server, and waits for shutdown.

```cpp
int main(int argc, char **argv)
{
Wt::WServer server(argc, argv, WTHTTP_CONFIGURATION);
SimpleChatServer chatServer(server);

/*
* We add two entry points: one for the full-window application,
* and one for a widget that can be integrated in another page.
*/
server.addEntryPoint(Wt::EntryPointType::Application,
std::bind(createApplication, std::placeholders::_1,
std::ref(chatServer)));
server.addEntryPoint(Wt::EntryPointType::WidgetSet,
std::bind(createWidget, std::placeholders::_1,
std::ref(chatServer)), "/chat.js");

if (server.start()) {
int sig = Wt::WServer::waitForShutdown();
std::cerr << "Shutting down: (signal = " << sig << ")" << std::endl;
server.stop();
}
}
```

--------------------------------

### Build the examples with make

Source: https://www.webtoolkit.eu/wt/doc/reference/html/InstallationUnix.html

Builds the Wt examples using the make command. This is the first step before running any example.

```bash
    $ make -C examples

```

--------------------------------

### hello.C: Full source code of the Wt hello world example

Source: https://www.webtoolkit.eu/wt/doc/examples/html/hello_8C_source.html

Complete source code of the hello.C example. It defines the HelloApplication class, its constructor, the greet() slot, and the main() function. The constructor sets up a text label, a line edit, a push button, and connects signals using three different methods: member function, std::bind, and lambda. The main() function starts the Wt server with Wt::WRun.

```cpp
/*
 * Copyright (C) 2008 Emweb bv, Herent, Belgium.
 *
 * See the LICENSE file for terms of use.
 */

#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()->addWidget(std::make_unique<Wt::WText>("Your name, please ? ")); // show some text

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

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

 root()->addWidget(std::make_unique<Wt::WBreak>()); // insert a line break
 greeting_ = root()->addWidget(std::make_unique<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() << std::endl;
 });
}

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);
 });
}

```

--------------------------------

### WRun() implementation example

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WServer.html

Example implementation of WRun() that starts a WServer, adds an entry point, waits for a shutdown signal, and handles restart via SIGHUP. It uses WTHTTP_CONFIGURATION for server configuration and catches WServer::Exception and std::exception.

```cpp
int WRun(int argc, char *argv[], ApplicationCreator createApplication)
{
  try {
    // use argv[0] as the application name to match a suitable entry
    // in the Wt configuration file, and use the default configuration
    // file (which defaults to /etc/wt/wt_config.xml unless the environment
    // variable WT_CONFIG_XML is set)
    WServer server(argv[0]);

    // WTHTTP_CONFIGURATION is e.g. "/etc/wt/wthttpd"
    server.setServerConfiguration(argc, argv, WTHTTP_CONFIGURATION);

    // add a single entry point, at the default location (as determined
    // by the server configuration's deploy-path)
    server.addEntryPoint(Wt::EntryPointType::Application, createApplication);

    if (server.start()) {
      int sig = WServer::waitForShutdown();
      std::cerr << "Shutdown (signal = " << sig << ")" << std::endl;
      server.stop();

      if (sig == SIGHUP)
        WServer::restart(argc, argv, environ);
    }
  } catch (WServer::Exception& e) {
    std::cerr << e.what() << "\n";
    return 1;
  } catch (std::exception& e) {
    std::cerr << "exception: " << e.what() << "\n";
    return 1;
  }
}
```

--------------------------------

### Install the library with make install

Source: https://www.webtoolkit.eu/wt/doc/reference/html/InstallationUnix.html

Run make install as a user with sufficient permissions to install the library.

```bash
    $ make install

```

--------------------------------

### start()

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WIOService.html

Starts the I/O service.

```APIDOC
## start()

### Description
Starts the I/O service.

### Method
Member function

### Signature
`void Wt::WIOService::start()`

### Parameters
None

### Returns
Void.
```

--------------------------------

### void start()

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WTimer.html

Starts the timer.

```APIDOC
## void start()

### Description
Starts the timer.

### Method
Action

### Signature
`void start()`

### Parameters
None.

### Returns
None.

```

--------------------------------

### start()

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WServer.html

Starts the server in the background. Returns whether the server could be successfully started.

```APIDOC
## start()

### Description
Starts the server in the background. Returns whether the server could be successfully started.

### Method
start

### Signature
`bool Wt::WServer::start()`

### Returns
- **bool** - True if the server started successfully, false otherwise.

### Exceptions
- **Exception** - Indicates a problem starting the server.

### See Also
- isRunning(), stop()
```

--------------------------------

### Deploy the _foobar_ example to Apache

Source: https://www.webtoolkit.eu/wt/doc/reference/html/InstallationUnix.html

Copies the example binary, source directory, and resources to the Apache document root. The DESTINATION variable sets the target directory.

```bash
    $ export DESTINATION=/var/www/localhost/htdocs/wt-examples
    $ mkdir -p $DESTINATION/_foobar_
    $ cp -r examples/_foobar_/* resources/* build/examples/_foobar_/*.wt $DESTINATION/_foobar_/

```

--------------------------------

### start()

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WServer.html

Starts the server in the background.

```APIDOC
## start()

### Description
Starts the server in the background.

### Method
start

### Signature
`WTCONNECTOR_API bool Wt::WServer::start()`

### Parameters
None.

### Returns
- `bool` - Returns true if the server started successfully, false otherwise.
```

--------------------------------

### start()

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WServer.html

Starts the server in the background.

```APIDOC
## bool start()

### Description
Starts the server in the background.

### Returns
True if the server started successfully, false otherwise.
```

--------------------------------

### start()

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WIOService-members.html

Starts the service.

```APIDOC
## start()

### Description
Starts the service, initializing its threads.

### Method
start

### Signature
`void start()`
```

--------------------------------

### ExampleSourceViewer Constructor

Source: https://www.webtoolkit.eu/wt/doc/examples/html/classExampleSourceViewer-members.html

Constructs an ExampleSourceViewer with the given deployment path, examples root, and examples type.

```APIDOC
## ExampleSourceViewer(const std::string &deployPath, const std::string &examplesRoot, const std::string &examplesType)

### Description
Constructs an ExampleSourceViewer widget.

### Parameters
- **deployPath** (const std::string&) - Required - The deployment path for the viewer.
- **examplesRoot** (const std::string&) - Required - The root directory of the examples.
- **examplesType** (const std::string&) - Required - The type of examples (e.g., 'wt' or 'wt-examples').
```

--------------------------------

### Run a Wt example with wthttpd

Source: https://www.webtoolkit.eu/wt/doc/reference/html/InstallationUnix.html

Commands to run a Wt example using the built-in web server. The working directory must be the example's source directory, and a symlink to the resources folder is needed. The server listens on all interfaces on port 8080.

```bash
    $ cd ../examples/_foobar_ # source directory for example _foobar_
    $ ln -s ../../resources . # include standard Wt resource files
    $ ../../build/examples/_foobar_/_foobar_.wt --docroot . --http-listen 0.0.0.0:8080

```

--------------------------------

### start()

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WIOService.html

Starts the I/O service, initializing the internal thread pool if not already started.

```APIDOC
## start()

### Description
Starts the I/O service. This will start the internal thread pool to process work for the I/O service, if not already started.

### Method
start

### Signature
void Wt::WIOService::start()

### Parameters
None

### Returns
void
```

--------------------------------

### WLogger usage example

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WLogger.html

Shows how to set up a Wt::WLogger with fields and a file, then create a log entry using Wt::WLogEntry. The example uses Wt::WLogger::timestamp, Wt::WLogger::sep, and wApp->sessionId().

```cpp
// Setup the logger
Wt::WLogger logger;
logger.addField("datetime", false);
logger.addField("session", false);
logger.addField("type", false);
logger.addField("message", true);
logger.setFile("/tmp/mylog.txt");

// Add an entry
Wt::WLogEntry entry = logger.entry();
entry << Wt::WLogger::timestamp << Wt::WLogger::sep
<< '[' << wApp->sessionId() << ']' << Wt::WLogger::sep
<< '[' << "notice" << ']' << Wt::WLogger::sep
<< "Succesfully started.";
```

--------------------------------

### createApplication callback example

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WServer.html

Example of a function that can be passed as the createApplication parameter to WRun(). It creates a new WApplication instance for each user visiting the application.

```cpp
Wt::WApplication *createApplication(const Wt::WEnvironment& env)
{
  // ...
}

```

--------------------------------

### Build and install dependencies from source

Source: https://www.webtoolkit.eu/wt/doc/reference/html/saml_linux.html

Build and install dependencies from source using configure and make, with optional PKG_CONFIG_PATH for custom prefix.

```bash
PKG_CONFIG_PATH=$PREFIX/lib/pkgconfig ./configure --prefix=$PREFIX
make
make install
```

--------------------------------

### Query usage example with find, where, bind, and resultList

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1Dbo_1_1Query.html

Shows how to create a query using Session::find(), add a condition with where(), bind a parameter, and retrieve results as a collection. The example iterates over the results and prints account names.

```cpp
typedef Wt::Dbo::ptr<Account> AccountPtr;
typedef Wt::Dbo::collection<AccountPtr> Accounts;
Wt::Dbo::Query<AccountPtr> query = session.find<Account>().where("balance > ?").bind(100000);
Accounts accounts = query.resultList();
for (Accounts::const_iterator i = accounts.begin(); i != accounts.end(); ++i)
std::cerr << "Name: " << (*i)->name << std::end;
```

--------------------------------

### Wt::WFileUpload usage example

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WFileUpload.html

Shows how to create a WFileUpload widget, connect its signals, and handle upload completion. The example includes a button to trigger the upload and disables the button to prevent double uploads.

```cpp
Wt::WFileUpload *upload = addWidget(std::make_unique<Wt::WFileUpload>());
upload->setFileTextSize(40);
// Provide a button
Wt::WPushButton *uploadButton =
addWidget(std::make_unique<Wt::WPushButton>("Send"));
// Upload when the button is clicked.
uploadButton->clicked().connect(upload, &Wt::WFileUpload::upload);
uploadButton->clicked().connect(uploadButton, &Wt::WPushButton::disable);
// Upload automatically when the user entered a file.
upload->changed().connect(upload, &WFileUpload::upload);
upload->changed().connect(uploadButton, &Wt::WPushButton::disable);
// React to a succesfull upload.
upload->uploaded().connect(this, &MyWidget::fileUploaded);
// React to a fileupload problem.
upload->fileTooLarge().connect(this, &MyWidget::fileTooLarge);
```

--------------------------------

### OAuthService usage example

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1Auth_1_1OAuthService.html

Shows how to create an OAuth process, connect it to an icon click, and capture the authentication result. The example assumes an existing OAuthService pointer and a MyWidget class with an oauthDone method.

```cpp
const OAuthService *oauth = ...;
// Creates an icon which prompts for authentication using this OAuth service.
WImage *icon = icons->addWidget(std::make_unique<WImage>("css/oauth-" + auth->name() + ".png"));
icon->setToolTip(auth->description());
// Creates a new process for authentication, which is started by a click on the icon
process = oauth->createProcess(oauth->authenticationScope());
icon->clicked().connect(process_, &OAuthProcess::startAuthenticate);
// And capture the result in a method.
process_->authenticated().connect(this, &MyWidget::oauthDone);
```

--------------------------------

### Set up application server with createApplication and main

Source: https://www.webtoolkit.eu/wt/doc/tutorial/auth.html

Defines the createApplication factory and main function that initializes Wt::WServer, adds the application entry point, configures authentication, and runs the server. Catches Wt::WServer::Exception, Wt::Dbo::Exception, and std::exception.

```cpp
std::unique_ptr<Wt::WApplication> createApplication(const Wt::WEnvironment &env)
{
  return std::make_unique<AuthApplication>(env);
}

int main(int argc, char **argv)
{
  try {
    Wt::WServer server{argc, argv, WTHTTP_CONFIGURATION};

    server.addEntryPoint(Wt::EntryPointType::Application, createApplication);

    Session::configureAuth();

    server.run();
  } catch (Wt::WServer::Exception& e) {
    std::cerr << e.what() << '\n';
  } catch (Wt::Dbo::Exception &e) {
    std::cerr << "Dbo exception: " << e.what() << '\n';
  } catch (std::exception &e) {
    std::cerr << "exception: " << e.what() << '\n';
  }
}
```

--------------------------------

### WTimer usage example: setup a timer that calls MyClass::timeout() every 2 seconds

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WTimer.html

Creates a WTimer, sets an interval of 2 seconds, connects the timeout signal to a member function, and starts the timer. The timer continues firing until stop() is called.

```cpp
// setup a timer which calls MyClass::timeout() every 2 seconds, until timer->stop() is called.
auto timer = root()->addChild(std::make_unique<Wt::WTimer>());
timer->setInterval(std::chrono::seconds(2));
timer->timeout().connect(this, &MyClass::timeout);
timer->start();
```

--------------------------------

### get(const std::string &url)

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1Http_1_1Client.html

Starts a GET request to the specified URL.

```APIDOC
## get(const std::string &url)

### Description
Starts a GET request to the specified URL.

### Method
GET

### Endpoint
`{url}`

### Parameters
#### Path Parameters
- **url** (string) - Required - The URL to send the GET request to.

### Returns
- **bool** - True if the request was successfully started, false otherwise.

```

--------------------------------

### get(const std::string &url, const std::vector<Message::Header> headers)

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1Http_1_1Client.html

Starts a GET request with custom headers.

```APIDOC
## get(const std::string &url, const std::vector<Message::Header> headers)

### Description
Starts a GET request with custom headers.

### Method
GET

### Endpoint
`{url}`

### Parameters
#### Path Parameters
- **url** (string) - Required - The URL to send the GET request to.

#### Request Headers
- **headers** (vector<Message::Header>) - Required - A list of HTTP headers to include in the request.

### Returns
- **bool** - True if the request was successfully started, false otherwise.

```

--------------------------------

### main() - Entry point

Source: https://www.webtoolkit.eu/wt/doc/examples/html/TreeViewDragDrop_8C_source.html

Calls WRun with the command-line arguments and the createApplication factory.

```cpp
int main(int argc, char **argv)
{
return WRun(argc, argv, &createApplication);
}
```

```cpp
int main(int argc, char **argv) {…}
```

--------------------------------

### setExample() implementation

Source: https://www.webtoolkit.eu/wt/doc/examples/html/classExampleSourceViewer.html

Clears the viewer, checks if the example directory exists, and if not, sets the internal path invalid and shows an error message. Otherwise, builds a WStandardItemModel by traversing the directory based on examplesType_, sets up a WTreeView and SourceView, expands to the first file, and lays out the UI.

```cpp
95{
96 clear();
97
98 bool exists = false;
99 try {
100 exists = fs::exists(exampleDir);
101 } catch (std::exception&) {
102 }
103
104 if (!exists) {
105 WApplication::instance()->setInternalPathValid(false);
106 addWidget(std::make_unique<WText>("No such example: " + exampleDir));
107 return;
108 }
109
110 model_ = std::make_shared<WStandardItemModel>(0, 1);
111 if (examplesType_ == "CPP") {
112 cppTraverseDir(model_->invisibleRootItem(), exampleDir);
113 } else if (examplesType_ == "JAVA") {
114 javaTraverseDir(model_->invisibleRootItem(), exampleDir);
115 }
116
117 WApplication::instance()->setTitle(tr("srcview.title." + example));
118 std::unique_ptr<WText> title(std::make_unique<WText>(
119 tr("srcview.title." + examplesType_ + "." + example)));
120 title->setInternalPathEncoding(true);
121
122 auto exampleView = std::make_unique<WTreeView>();
123 exampleView_ = exampleView.get();
124 exampleView_->setHeaderHeight(0);
125 exampleView_->resize(300, WLength::Auto);
126 exampleView_->setSortingEnabled(false);
127 exampleView_->setModel(model_);
128 exampleView_->expandToDepth(1);
129 exampleView_->setSelectionMode(SelectionMode::Single);
130 exampleView_->setAlternatingRowColors(false);
131 exampleView_->selectionChanged().connect
132 (this, &ExampleSourceViewer::showFile);
133
134 auto sourceView =
135 std::make_unique<SourceView>(FileItem::FileNameRole,
136 FileItem::ContentsRole,
137 FileItem::FilePathRole);
138 sourceView_ = sourceView.get();
139 sourceView_->setStyleClass("source-view");
140
141 /*
142 * Expand path to first file, to show something in the source viewer
143 */
144 WStandardItem *w = model_->item(0);
145 do {
146 exampleView_->setExpanded(w->index(), true);
147 if (w->rowCount() > 0)
148 w = w->child(0);
149 else {
150 exampleView_->select(w->index());
151 w = 0;
152 }
153 } while (w);
154
155 auto topLayout = std::make_unique<WVBoxLayout>();
156 topLayout->addWidget(std::move(title));
157
158 auto gitLayout = std::make_unique<WHBoxLayout>();
159 WHBoxLayout *g = gitLayout.get();
160 gitLayout->addWidget(std::move(exampleView), 0);
161 gitLayout->addWidget(std::move(sourceView), 1);
162 topLayout->addLayout(std::move(gitLayout), 1);
163 g->setResizable(0);
164
165 /*
166 * FIXME, in plain HTML mode, we should set a minimum size to the source
167 * view, and remove this in enableAjax() ?
168 */
169 // sourceView_->setHeight("100%");
170
171 setLayout(std::move(topLayout));
172 setStyleClass("maindiv");
173}
```

--------------------------------

### Set Command Arguments for wthttpd in MSVC IDE

Source: https://www.webtoolkit.eu/wt/doc/reference/html/InstallationWindows.html

Set these command arguments in the MSVC IDE Debugging properties to run a Wt example with wthttpd. This starts a server on all interfaces, port 8080, with deployment path /hello and document root as the current directory. Browse the example at http://127.0.0.1:8080/hello.

```plaintext
--http-address=0.0.0.0 --http-port=8080 --deploy-path=/hello --docroot=.
```

--------------------------------

### main() - Run the Wt application

Source: https://www.webtoolkit.eu/wt/doc/examples/html/ComposeExample_8C_source.html

Entry point that calls WRun with the createApplication function.

```cpp
int main(int argc, char **argv)
{
  return WRun(argc, argv, &createApplication);
}
```

--------------------------------

### Usage example for WEnvironment

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WEnvironment.html

Shows how to obtain the environment from the current application instance, read a startup argument (e.g., 'login'), and conditionally create widgets based on AJAX support. Note the comment about providing an HTML text editor vs. a plain text area.

```cpp
const WEnvironment& env = WApplication::instance()->environment();
// read an application startup argument
// (passed as argument in the URL or POST'ed to the application).
if (!env.getParameterValues("login").empty()) {
std::string login = env.getParameterValues("login")[0];
...
}
// Check for JavaScript/AJAX availability before using AJAX-only
// widgets
std::unique_ptr<Wt::WTextArea> textEdit;
if (!env.ajax())
textEdit = std::make_unique<Wt::WTextEdit>(); // provide an HTML text editor
else
textEdit = std::make_unique<Wt::WTextArea>(); // fall-back to a plain old text area.
```

--------------------------------

### bool Wt::Http::Client::get(const std::string &url)

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1Http_1_1Client.html

Starts an asynchronous GET request. Returns true if the request was scheduled, false otherwise.

```APIDOC
## bool Wt::Http::Client::get(const std::string &url)

### Description
Starts an asynchronous GET request. The function returns immediately. Returns `true` when the GET request has been scheduled, and thus done() will be emitted eventually. Returns `false` if the client could not schedule the request, for example if the `url` is invalid or if the URL scheme is not supported.

### Method
GET

### Endpoint
Not applicable (C++ method)

### Parameters
#### Parameters
- **url** (const std::string&) - Required - The URL to send the GET request to.

### Return Value
- **bool** - `true` if the request was scheduled, `false` otherwise.

### See Also
- request()
- done()

```

--------------------------------

### begin(WPaintDevice *device)

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WPainter-members.html

Begins painting on the given device. Returns true if successful.

```APIDOC
## begin(WPaintDevice *device)

### Description
Begins painting on the given device. Returns true if successful.

### Method
Member function

### Signature
`bool begin(WPaintDevice *device)`

### Parameters
- **device** (WPaintDevice*) - Required - The device to begin painting on.

### Returns
- **bool** - True if painting started successfully, false otherwise.

```

--------------------------------

### Extracting a string value with exception handling

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1Json_1_1Value.html

Demonstrates using operator std::string to get a string value from a JSON object. The example uses try-catch to handle TypeException when the value is not a string.

```cpp
const Json::Object& person = ...;
try {
  std::string occupation = person.get("occupation");
  ...
} catch (const std::exception& e) {
  ...
}
```

--------------------------------

### Accessing and modifying an object value in-place

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1Json_1_1Value.html

Shows how to use operator Object& to get a reference to the contained object and modify it in-place. The example iterates over an array, adds new object values, and accesses the back element.

```cpp
Json::Array& children = ...;
for (unsigned i = 0; i < 3; ++i) {
  children.push_back(Json::Value(Json::Type::Object));
  Json::Object& child = children.back();
  ...
}
```

--------------------------------

### SimpleChatWidget::login() method

Source: https://www.webtoolkit.eu/wt/doc/examples/html/SimpleChatWidget_8C_source.html

Handles the login action. It checks if not already logged in, gets the user name, creates a sound for message received if not already created, and attempts to start the chat. If the name is taken, it sets a status message.

```cpp
void SimpleChatWidget::login()
{
 if (!loggedIn()) {
 Wt::WString name = userNameEdit_->text();

 if (!messageReceived_)
 messageReceived_ = std::make_unique<Wt::WSound>("sounds/message_received.mp3");

 if (!startChat(name))
 statusMsg_->setText("Sorry, name '" + escapeText(name) +
 "' is already taken.");
 }
}
```

--------------------------------

### setup()

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1Payment_1_1PayPalExpressCheckout.html

Sets up the transaction and returns a signal for the result.

```APIDOC
## setup()

### Description
Sets up the transaction. The returned signal is emitted when the setup completes.

### Method
Signal< Result > & setup()

### Returns
- **Signal<Result>&** - A signal that fires with the result of the setup.

```

--------------------------------

### bool Wt::Http::Client::get(const std::string &url, const std::vector<Message::Header> &headers)

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1Http_1_1Client.html

Starts an asynchronous GET request with additional headers. Returns true if the request was scheduled, false otherwise.

```APIDOC
## bool Wt::Http::Client::get(const std::string &url, const std::vector<Message::Header> &headers)

### Description
Starts an asynchronous GET request with additional headers. The function returns immediately. Returns `true` when the GET request has been scheduled, and thus done() will be emitted eventually. Returns `false` if the client could not schedule the request, for example if the `url` is invalid or if the URL scheme is not supported.

### Method
GET

### Endpoint
Not applicable (C++ method)

### Parameters
#### Parameters
- **url** (const std::string&) - Required - The URL to send the GET request to.
- **headers** (const std::vector<Message::Header>&) - Required - A vector of headers to include in the request.

### Return Value
- **bool** - `true` if the request was scheduled, `false` otherwise.

### See Also
- request()
- done()

```

--------------------------------

### JavascriptExample(const WEnvironment &env)

Source: https://www.webtoolkit.eu/wt/doc/examples/html/classJavascriptExample.html

Creates the example application. This is the constructor for the JavascriptExample class, taking a reference to the WEnvironment.

```APIDOC
## JavascriptExample(const WEnvironment &env)

### Description
Creates the example application.

### Method
Constructor

### Parameters
- **env** (const WEnvironment &) - Required - The environment for the application.

```

--------------------------------

### createApplication() - Set up WApplication with resources

Source: https://www.webtoolkit.eu/wt/doc/examples/html/ComposeExample_8C_source.html

Creates the WApplication, loads the message resource bundle from 'composer.xml' in the app root, uses the stylesheet 'composer.css', sets the title, and adds the ComposeExample widget to the root.

```cpp
std::unique_ptr<WApplication> createApplication(const WEnvironment& env)
{
  std::unique_ptr<WApplication> app
    = std::make_unique<WApplication>(env);

  // The following assumes composer.xml is in the webserver working directory
  // (but does not need to be deployed within docroot):
  app->messageResourceBundle().use(WApplication::appRoot() + "composer");

  // The following assumes composer.css is deployed in the seb server at the
  // same location as the application:
  app->useStyleSheet("composer.css");

  app->setTitle("Composer example");

  app->root()->addWidget(std::make_unique<ComposeExample>());

  return app;
}
```

--------------------------------

### main function: server setup and entry points

Source: https://www.webtoolkit.eu/wt/doc/examples/html/main_8C.html

The main function initializes a WServer with the HTTP configuration, configures authentication, creates a blog database connection pool, adds an RSS feed resource at '/wt/blog/feed/', and registers two application entry points: '/jwt' for JWt and '' for Wt. It catches Wt::WServer::Exception and std::exception, printing errors to stderr.

```cpp
int main(int argc, char **argv)
{
  try {
    WServer server(argc, argv, WTHTTP_CONFIGURATION);

    BlogSession::configureAuth();

    std::unique_ptr<Dbo::SqlConnectionPool> blogDb
      = BlogSession::createConnectionPool(server.appRoot() + "blog.db");

    auto rssFeed = std::make_shared<BlogRSSFeed>(*blogDb,
      "Wt and JWt blog",
      "http://www.webtoolkit.eu/wt/blog",
      "We care about our webtoolkits.");

    server.addResource(rssFeed, "/wt/blog/feed/");

    server.addEntryPoint(EntryPointType::Application,
      std::bind(&createJWtHomeApplication, std::placeholders::_1, blogDb.get()),
      "/jwt", "/css/jwt/favicon.ico");
    server.addEntryPoint(EntryPointType::Application,
      std::bind(&createWtHomeApplication, std::placeholders::_1, blogDb.get()),
      "", "/css/wt/favicon.ico");

    server.run();

  } catch (Wt::WServer::Exception& e) {
    std::cerr << e.what() << std::endl;
  } catch (std::exception &e) {
    std::cerr << "exception: " << e.what() << std::endl;
  }
}
```

--------------------------------

### main function in main.C

Source: https://www.webtoolkit.eu/wt/doc/examples/html/main_8C_source.html

The main entry point for the Wt homepage example. It creates a WServer, configures authentication, creates a blog database connection pool, adds an RSS feed resource at '/wt/blog/feed/', and registers entry points for JWt and Wt applications. Catches Wt::WServer::Exception and std::exception.

```cpp
/*
 * Copyright (C) 2009 Emweb bv, Herent, Belgium.
 *
 * See the LICENSE file for terms of use.
 */

#include <Wt/WServer.h>
#include <Wt/Dbo/SqlConnectionPool.h>

#include "BlogRSSFeed.h"
#include "model/BlogSession.h"
#include "model/Token.h"
#include "model/User.h"
#include "WtHome.h"
#include "JWtHome.h"

using namespace Wt;

int main(int argc, char **argv)
{
 try {
 WServer server(argc, argv, WTHTTP_CONFIGURATION);

 BlogSession::configureAuth();

 std::unique_ptr<Dbo::SqlConnectionPool> blogDb
 = BlogSession::createConnectionPool(server.appRoot() + "blog.db");

 auto rssFeed = std::make_shared<BlogRSSFeed>(*blogDb,
 "Wt and JWt blog",
 "http://www.webtoolkit.eu/wt/blog",
 "We care about our webtoolkits.");

 server.addResource(rssFeed, "/wt/blog/feed/");

 server.addEntryPoint(EntryPointType::Application,
 std::bind(&createJWtHomeApplication, std::placeholders::_1, blogDb.get()),
 "/jwt", "/css/jwt/favicon.ico");
 server.addEntryPoint(EntryPointType::Application,
 std::bind(&createWtHomeApplication, std::placeholders::_1, blogDb.get()),
 "", "/css/wt/favicon.ico");

 server.run();

 } catch (Wt::WServer::Exception& e) {
 std::cerr << e.what() << std::endl;
 } catch (std::exception &e) {
 std::cerr << "exception: " << e.what() << std::endl;
 }
}
```

--------------------------------

### Session constructor with database setup

Source: https://www.webtoolkit.eu/wt/doc/examples/html/Session_8C_source.html

Creates the database connection, sets up authentication services, and initializes the user database. If the database does not exist, it creates tables and a default guest user; otherwise it logs that the existing database is used.

```cpp
Session::Session() {…}
```

```cpp
myPasswordService.updatePassword(guestUser, "guest");

log("info") << "Database created";
} catch (...) {
log("info") << "Using existing database";
}

transaction.commit();
}
```

--------------------------------

### WLineEdit::setSelection(int start, int length)

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WDoubleSpinBox.html

Selects length characters starting from the start position.

```APIDOC
## WLineEdit::setSelection(int start, int length)

### Description
Selects length characters starting from the start position.

### Method
void setSelection(int start, int length)

### Parameters
- **start** (int) - The start position.
- **length** (int) - The number of characters to select.

```

--------------------------------

### init()

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WCanvasPaintDevice.html

Initializes the device for painting.

```APIDOC
## init()

### Description
Initializes the device for painting.

### Method
virtual void init() override
```

--------------------------------

### Configure and initialize MySamlService

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1Auth_1_1Saml_1_1Service.html

Shows the recommended configuration and initialization of a Saml::Service instance. Must be done once at application startup, and the service destructor should run before main() exits to avoid crashes.

```cpp
// baseAuth is a const AuthService&
MySamlService service(baseAuth);
// It's common for the SP entityId to be the same as the metadata endpoint URL, but this
// could be anything
service.setSPEntityId("https://sp.example.com/metadata.xml");
service.setAcsUrl("https://sp.example.com/acs");
service.setMetadataPath("/metadata.xml");
service.setIdpEntityId("https://idp.example.com/sso");
service.setMetadataProviderPath("metadata_provider.xml");
service.setAuthnRequestSigningEnabled(true);
service.setCredentialResolverPath("credential_resolver.xml");
service.initialize();
```

--------------------------------

### setSelection

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WDateEdit.html

Selects length characters starting from the start position.

```APIDOC
## setSelection(int start, int length)

### Description
Selects length characters starting from the start position.

### Method
void setSelection(int start, int length)

### Parameters
- **start** (int) - Required - Start position.
- **length** (int) - Required - Number of characters to select.

```

--------------------------------

### WPainterPath Usage Example

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WPainterPath.html

Example demonstrating how to create and draw a WPainterPath with WPainter.

```APIDOC
## WPainterPath Usage Example

### Description
Creates a painter path, adds line segments, closes the sub-path, and draws it with a painter.

### Code Example
```cpp
Wt::WPainter painter(...);
Wt::WPainterPath path(Wt::WPointF(10, 10));
path.lineTo(10, 20);
path.lineTo(30, 20);
path.closeSubPath();
painter.setPen(Wt::StandardColor::Red);
painter.setBrush(Wt::StandardColor::Blue);
painter.drawPath(path);
```
```

--------------------------------

### WServer Constructor (applicationPath and args)

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WServer.html

Creates a new server instance and configures it using an application path and argument vector.

```APIDOC
## WServer(const std::string &applicationPath, const std::vector<std::string> &args, const std::string &wtConfigurationFile)

### Description
Creates a new server instance and configures it.

### Parameters
- **applicationPath** (const std::string&) - Required - The application path.
- **args** (const std::vector<std::string>&) - Required - Configuration arguments.
- **wtConfigurationFile** (const std::string&) - Optional - The configuration file path.

### Returns
A new WServer object.
```

--------------------------------

### Example: data() with WDate

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WAbstractItemModel.html

Example of extracting a WDate from a Wt::any returned by data().

```cpp
WDate d = Wt::any_cast<WDate>(model->data(row, column));
```

--------------------------------

### CountDownWidget::CountDownWidget(int start, int stop, std::chrono::milliseconds msec)

Source: https://www.webtoolkit.eu/wt/doc/examples/html/CountDownWidget_8C_source.html

Creates a new CountDownWidget. Initializes the countdown with the given start and stop values, sets the timer interval, and starts the timer.

```APIDOC
## CountDownWidget::CountDownWidget(int start, int stop, std::chrono::milliseconds msec)

### Description
Creates a new CountDownWidget. Initializes the countdown with the given start and stop values, sets the timer interval, and starts the timer.

### Method
Constructor

### Parameters
- **start** (int) - Required - The starting value of the countdown.
- **stop** (int) - Required - The stopping value of the countdown. It is adjusted to be at most start - 1.
- **msec** (std::chrono::milliseconds) - Required - The timer interval in milliseconds.

### Behavior
- Sets the current value to start.
- Creates a WTimer with the specified interval.
- Connects the timer's timeout signal to the timerTick method.
- Starts the timer.
- Sets the text to the current value.
```

--------------------------------

### WServer Constructor (argc/argv)

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WServer.html

Creates a new server instance and configures it using command-line arguments.

```APIDOC
## WServer(int argc, char *argv[], const std::string &wtConfigurationFile)

### Description
Creates a new server instance and configures it.

### Parameters
- **argc** (int) - Required - Number of command-line arguments.
- **argv** (char*[]) - Required - Command-line arguments.
- **wtConfigurationFile** (const std::string&) - Optional - The configuration file path.

### Returns
A new WServer object.
```

--------------------------------

### Example: setData with WDate

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WAbstractItemModel.html

Example of converting a WDate object to Wt::any and passing it to setData().

```cpp
WDate d(1976,6,14);
model->setData(row, column, Wt::any(d));
```

--------------------------------

### std::chrono::steady_clock::duration timeout() const

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1Dbo_1_1FixedSqlConnectionPool.html

Gets the timeout for getting a connection from the pool.

```APIDOC
## std::chrono::steady_clock::duration timeout() const

### Description
Gets the timeout for getting a connection from the pool.

### Returns
- **std::chrono::steady_clock::duration** - The timeout duration.

```

--------------------------------

### start()

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WTimer.html

Starts the timer. The timer will be active until the interval elapses, after which the timeout signal is activated, or until stop() is called.

```APIDOC
## start()

### Description
Starts the timer. The timer will be isActive(), until either the interval has elapsed, after which the timeout signal is activated, or until stop() is called.

### Method
`void Wt::WTimer::start()`
```

--------------------------------

### init(WApplication *app) const override

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WBootstrap3Theme-members.html

Initializes the theme for a given application.

```APIDOC
## init(WApplication *app) const override

### Description
Performs theme-specific initialization for the given application instance.

### Method
Member function

### Signature
`void init(WApplication *app) const override`

### Parameters
- **app** (WApplication*) - The application to initialize.
```

--------------------------------

### Set up a Wt::Dbo session with SQLite3 backend

Source: https://www.webtoolkit.eu/wt/doc/tutorial/dbo.html

Creates a session with a SQLite3 backend and assigns a connection. Typically done once at application startup.

```cpp
void run()
{
    /*
     * Setup a session, would typically be done once at application startup.
     */
    auto sqlite3 = std::make_unique<dbo::backend::Sqlite3>("blog.db");
    dbo::Session session;
    session.setConnection(std::move(sqlite3));

    ...
```

--------------------------------

### Install SAML dependencies on Debian/Ubuntu

Source: https://www.webtoolkit.eu/wt/doc/reference/html/saml_linux.html

Install the required packages for building Wt with SAML support on Debian or Ubuntu.

```bash
apt install libsaml-dev opensaml-schemas xmltooling-schemas
```

--------------------------------

### WPaintDevice::init()

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WPaintDevice.html

Initializes the device for painting.

```APIDOC
## WPaintDevice::init()

### Description
Initializes the device for painting.

### Method
init

### Signature
`virtual void init() = 0`

### Parameters
None

### Returns
None

```

--------------------------------

### run()

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WServer.html

Starts the server, waits for shutdown, then stops the server. Equivalent to calling start(), waitForShutdown(), and stop() in sequence.

```APIDOC
## run()

### Description
Starts the server, waits for shutdown, then stops the server. This is equivalent to:
```cpp
if (start()) {
    WServer::waitForShutdown();
    stop();
}
```

### Method
run

### Signature
`WTCONNECTOR_API void Wt::WServer::run()`

### Parameters
None.

### Returns
void

### See Also
- start()
- stop()
- waitForShutdown()
```

--------------------------------

### Deploy at root with static asset folders

Source: https://www.webtoolkit.eu/wt/doc/reference/html/overview.html

Command-line example showing how to deploy the application at the root URL while specifying static asset folders in --docroot to enable clean URLs. The trailing ';' is required.

```bash
$ ../../build/examples/wt-homepage/Home.wt --docroot=".;/favicon.ico,/css,/resources,/style,/icons" ...
```

--------------------------------

### Wt::WFileUpload usage example

Source: https://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WFileUpload.html

Example code demonstrating how to create a WFileUpload widget, connect signals, and handle uploads.

```APIDOC
## Wt::WFileUpload Usage Example

### Description
Example code showing how to create a WFileUpload widget, connect signals, and handle uploads.

### Code
```cpp
Wt::WFileUpload *upload = addWidget(std::make_unique<Wt::WFileUpload>());
upload->setFileTextSize(40);
// Provide a button
Wt::WPushButton *uploadButton = addWidget(std::make_unique<Wt::WPushButton>("Send"));
// Upload when the button is clicked.
uploadButton->clicked().connect(upload, &Wt::WFileUpload::upload);
uploadButton->clicked().connect(uploadButton, &Wt::WPushButton::disable);
// Upload automatically when the user entered a file.
upload->changed().connect(upload, &WFileUpload::upload);
upload->changed().connect(uploadButton, &Wt::WPushButton::disable);
// React to a succesfull upload.
upload->uploaded().connect(this, &MyWidget::fileUploaded);
// React to a fileupload problem.
upload->fileTooLarge().connect(this, &MyWidget::fileTooLarge);
```
```

--------------------------------

### main function in hello.C

Source: https://www.webtoolkit.eu/wt/doc/examples/html/hello_8C.html

The main function starts the Wt server via Wt::WRun, passing a lambda that creates a new HelloApplication for each user session. It reads the environment to potentially check permissions before creating the application.

```cpp
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);
  });
}
```
Tokens:
Raw