Home Class Reference

#include <Home.h>

Inheritance diagram for Home:

Inheritance graph
[legend]

List of all members.

Public Member Functions

 Home (const WEnvironment &env)
void refresh ()

Private Member Functions

WWidgetintroduction ()
WWidgetnews ()
WWidgetstatus ()
WWidgetfeatures ()
WWidgetdocumentation ()
WWidgetexamples ()
WWidgetdownload ()
WWidgetcommunity ()
void readNews (WTable *newsTable, const std::string newsfile)
void readReleases (WTable *releaseTable, const std::string releasefile)
WTreeNodemakeTreeMap (const std::string name, WTreeNode *parent)
WTreeNodemakeTreeFile (const std::string name, WTreeNode *parent)
WWidgethelloWorldExample ()
WWidgetchartExample ()
WWidgethomepageExample ()
WWidgettreeviewExample ()
WWidgetgitExample ()
WWidgetchatExample ()
WWidgetcomposerExample ()
WWidgetwidgetGalleryExample ()
WWidgetwrapViewOrDefer (WWidget *(Home::*createFunction)())
void updateTitle ()
void logInternalPath ()
void changeLanguage (int language)
void setLanguage (int language)
void setLanguageFromPath (std::string prefix)

Static Private Member Functions

static std::string href (const std::string url, const std::string description)
static WString tr (const char *key)

Private Attributes

WStackedWidgetcontents_
WTablerecentNews_
WTablehistoricalNews_
WTablereleases_
WMenumainMenu_
WTabWidgetexamplesMenu_
int language_
WContainerWidgetsideBarContent_


Detailed Description

Definition at line 22 of file Home.h.


Constructor & Destructor Documentation

Home::Home ( const WEnvironment env  ) 

Definition at line 87 of file Home.C.

00088   : WApplication(env),
00089     recentNews_(0),
00090     historicalNews_(0),
00091     releases_(0)
00092 {
00093   messageResourceBundle().use("wt-home", false);
00094   useStyleSheet("images/wt.css");
00095   useStyleSheet("images/wt_ie.css", "lt IE 7");
00096   useStyleSheet("home.css");
00097   setTitle("Wt, C++ Web Toolkit");
00098 
00099   setLocale("");
00100   language_ = 0;
00101 
00102   Div *topWrapper = new Div(root(), "top_wrapper");
00103   Div *topContent = new Div(topWrapper, "top_content");
00104 
00105   Div *languagesDiv = new Div(topContent, "top_languages");
00106 
00107   WSignalMapper<int> *lmap = new WSignalMapper<int>(this);
00108   lmap->mapped.connect(SLOT(this, Home::changeLanguage));
00109 
00110   for (unsigned i = 0; i < languages.size(); ++i) {
00111     if (i != 0)
00112       new WText("- ", languagesDiv);
00113 
00114     const Lang& l = languages[i];
00115 
00116     WAnchor *a = new WAnchor(bookmarkUrl(l.path), l.longDescription,
00117                              languagesDiv);
00118 
00119     lmap->mapConnect(a->clicked, i);
00120   }
00121 
00122   WText *topWt = new WText(tr("top_wt"), topContent);
00123   topWt->setInline(false);
00124   topWt->setId("top_wt");
00125 
00126   WText *bannerWt = new WText(tr("banner_wrapper"), root());
00127   bannerWt->setId("banner_wrapper");
00128 
00129   Div *mainWrapper = new Div(root(), "main_wrapper");
00130   Div *mainContent = new Div(mainWrapper, "main_content");
00131   Div *mainMenu = new Div(mainContent, "main_menu");
00132 
00133   WStackedWidget *contents = new WStackedWidget();
00134   contents->setId("main_page");
00135 
00136   mainMenu_ = new WMenu(contents, Vertical, mainMenu);
00137   mainMenu_->setRenderAsList(true);
00138 
00139   // Use "/" instead of "/introduction/" as internal path
00140   mainMenu_->addItem
00141     (tr("introduction"), introduction())->setPathComponent("");
00142   mainMenu_->addItem
00143     (tr("news"), deferCreate(boost::bind(&Home::news, this)),
00144      WMenuItem::PreLoading);
00145   mainMenu_->addItem
00146     (tr("features"), wrapViewOrDefer(&Home::features),
00147      WMenuItem::PreLoading);
00148   mainMenu_->addItem
00149     (tr("documentation"), wrapViewOrDefer(&Home::documentation),
00150      WMenuItem::PreLoading);
00151   mainMenu_->addItem
00152     (tr("examples"), examples(),
00153      WMenuItem::PreLoading);
00154   mainMenu_->addItem
00155     (tr("download"), deferCreate(boost::bind(&Home::download, this)),
00156      WMenuItem::PreLoading);
00157   mainMenu_->addItem
00158     (tr("community"), wrapViewOrDefer(&Home::community),
00159      WMenuItem::PreLoading);
00160 
00161   mainMenu_->itemSelectRendered.connect(SLOT(this, Home::updateTitle));
00162   mainMenu_->itemSelected.connect(SLOT(this, Home::logInternalPath));
00163   mainMenu_->select((int)0);
00164 
00165   // Make the menu be internal-path aware.
00166   mainMenu_->setInternalPathEnabled();
00167   mainMenu_->setInternalBasePath("/");
00168 
00169   sideBarContent_ = new WContainerWidget(mainMenu);
00170 
00171   mainContent->addWidget(contents);
00172   WContainerWidget *clearAll = new WContainerWidget(mainContent);
00173   clearAll->setStyleClass("clearall");
00174 
00175   WText *footerWrapper = new WText(tr("footer_wrapper"), root());
00176   footerWrapper->setId("footer_wrapper");
00177 
00178   internalPathChanged.connect(SLOT(this, Home::setLanguageFromPath));
00179 }


Member Function Documentation

void Home::refresh (  )  [virtual]

Reimplemented from Wt::WApplication.

Definition at line 254 of file Home.C.

00255 {
00256   if (recentNews_)
00257     readNews(recentNews_, "latest-news.txt");
00258 
00259   if (historicalNews_)
00260     readNews(historicalNews_, "historical-news.txt");
00261 
00262   if (releases_)
00263     readReleases(releases_, "releases.txt");
00264 
00265   WApplication::refresh();
00266 }

WWidget * Home::introduction (  )  [private]

Definition at line 249 of file Home.C.

00250 {
00251   return new WText(tr("home.intro"));
00252 }

WWidget * Home::news (  )  [private]

Definition at line 268 of file Home.C.

00269 {
00270   WContainerWidget *result = new WContainerWidget();
00271 
00272   result->addWidget(new WText(tr("home.news")));
00273 
00274   result->addWidget(new WText(tr("home.latest-news")));
00275   recentNews_ = new WTable();
00276   readNews(recentNews_, "latest-news.txt");
00277   result->addWidget(recentNews_);
00278 
00279   result->addWidget(new WText(tr("home.historical-news")));
00280   historicalNews_ = new WTable();
00281   readNews(historicalNews_, "historical-news.txt");
00282   result->addWidget(historicalNews_);
00283 
00284   return result;
00285 }

WWidget * Home::status (  )  [private]

Definition at line 287 of file Home.C.

00288 {
00289   return new WText(tr("home.status"));
00290 }

WWidget * Home::features (  )  [private]

Definition at line 292 of file Home.C.

00293 {
00294   return new WText(tr("home.features"));
00295 }

WWidget * Home::documentation (  )  [private]

Definition at line 297 of file Home.C.

00298 {
00299   return new WText(tr("home.documentation"));
00300 }

WWidget * Home::examples (  )  [private]

Definition at line 512 of file Home.C.

00513 {
00514   WContainerWidget *result = new WContainerWidget();
00515 
00516   result->addWidget(new WText(tr("home.examples")));
00517 
00518   examplesMenu_ = new WTabWidget(result);
00519 
00520   /*
00521    * The following code is functionally equivalent to:
00522    *
00523    *   examplesMenu_->addTab(helloWorldExample(), "Hello world");
00524    *
00525    * However, we optimize here for memory consumption (it is a homepage
00526    * after all, and we hope to be slashdotted some day)
00527    *
00528    * Therefore, we wrap all the static content (including the tree
00529    * widgets), into WViewWidgets with static models. In this way the
00530    * widgets are not actually stored in memory on the server.
00531    *
00532    * For the tree list example (for which we cannot use a view with a
00533    * static model, since we allow the tree to be manipulated) we use
00534    * the defer utility function to defer its creation until it is
00535    * loaded.
00536    */
00537 
00538   // The call ->setPathComponent() is to use "/examples" instead of
00539   // "/examples/hello_world" as internal path
00540   examplesMenu_->addTab(wrapViewOrDefer(&Home::helloWorldExample),
00541                         tr("hello-world"))->setPathComponent("");
00542 
00543   examplesMenu_->addTab(wrapViewOrDefer(&Home::chartExample),
00544                         tr("charts"));
00545   examplesMenu_->addTab(wrapViewOrDefer(&Home::homepageExample),
00546                         tr("wt-homepage"));
00547   examplesMenu_->addTab(wrapViewOrDefer(&Home::treeviewExample),
00548                         tr("treeview"));
00549   examplesMenu_->addTab(wrapViewOrDefer(&Home::gitExample),
00550                         tr("git"));
00551   examplesMenu_->addTab(wrapViewOrDefer(&Home::chatExample),
00552                         tr("chat"));
00553   examplesMenu_->addTab(wrapViewOrDefer(&Home::composerExample),
00554                         tr("mail-composer"));
00555   examplesMenu_->addTab(wrapViewOrDefer(&Home::widgetGalleryExample),
00556                         tr("widget-gallery"));
00557 
00558   examplesMenu_->currentChanged.connect(SLOT(this, Home::logInternalPath));
00559 
00560   // Enable internal paths for the example menu
00561   examplesMenu_->setInternalPathEnabled();
00562   examplesMenu_->setInternalBasePath("/examples");
00563 
00564   return result;
00565 }

WWidget * Home::download (  )  [private]

Definition at line 567 of file Home.C.

00568 {
00569   WContainerWidget *result = new WContainerWidget();
00570   result->addWidget(new WText(tr("home.download")));
00571   result->addWidget(new WText(tr("home.download.license")));
00572   result->addWidget(new WText(tr("home.download.requirements")));
00573   result->addWidget(new WText(tr("home.download.cvs")));
00574   result->addWidget(new WText(tr("home.download.packages")));
00575 
00576   releases_ = new WTable();
00577   readReleases(releases_, "releases.txt");
00578   result->addWidget(releases_);
00579 
00580   result->addWidget
00581     (new WText("<p>Older releases are still available at "
00582                + href("http://sourceforge.net/project/showfiles.php?"
00583                       "group_id=153710#files",
00584                       "sourceforge.net")
00585                + "</p>"));
00586 
00587   return result;
00588 }

WWidget * Home::community (  )  [private]

Definition at line 595 of file Home.C.

00596 {
00597   return new WText(tr("home.community"));
00598 }

void Home::readNews ( WTable newsTable,
const std::string  newsfile 
) [private]

Definition at line 600 of file Home.C.

00601 {
00602   std::ifstream f(newsfile.c_str());
00603 
00604   newsTable->clear();
00605 
00606   int row = 0;
00607 
00608   while (f) {
00609     std::string line;
00610     getline(f, line);
00611 
00612     if (f) {
00613       typedef boost::tokenizer<boost::escaped_list_separator<char> >
00614         CsvTokenizer;
00615       CsvTokenizer tok(line);
00616 
00617       CsvTokenizer::iterator i=tok.begin();
00618 
00619       newsTable->elementAt(row, 0)->
00620         addWidget(new WText("<p><b>" + *i + "</b></p>"));
00621       newsTable->elementAt(row, 0)
00622         ->setContentAlignment(AlignCenter | AlignTop);
00623       newsTable->elementAt(row, 0)
00624         ->resize(WLength(16, WLength::FontEx), WLength());
00625       newsTable
00626         ->elementAt(row, 1)->addWidget(new WText("<p>" + *(++i) + "</p>"));
00627 
00628       ++row;
00629     }
00630   }
00631 }

void Home::readReleases ( WTable releaseTable,
const std::string  releasefile 
) [private]

Definition at line 633 of file Home.C.

00634 {
00635   std::ifstream f(releasefile.c_str());
00636 
00637   releaseTable->clear();
00638 
00639   releaseTable->elementAt(0, 0)
00640     ->addWidget(new WText(tr("home.download.version")));
00641   releaseTable->elementAt(0, 1)
00642     ->addWidget(new WText(tr("home.download.date")));
00643   releaseTable->elementAt(0, 2)
00644     ->addWidget(new WText(tr("home.download.description")));
00645 
00646   releaseTable->elementAt(0, 0)->resize(WLength(10, WLength::FontEx),
00647                                         WLength());
00648   releaseTable->elementAt(0, 1)->resize(WLength(15, WLength::FontEx),
00649                                         WLength());
00650 
00651   int row = 1;
00652 
00653   while (f) {
00654     std::string line;
00655     getline(f, line);
00656 
00657     if (f) {
00658       typedef boost::tokenizer<boost::escaped_list_separator<char> >
00659         CsvTokenizer;
00660       CsvTokenizer tok(line);
00661 
00662       CsvTokenizer::iterator i=tok.begin();
00663 
00664       std::string version = *i;
00665       releaseTable->elementAt(row, 0)->addWidget
00666         (new WText(href("http://prdownloads.sourceforge.net/witty/wt-"
00667                         + version + ".tar.gz?download", "Wt " + version)));
00668       releaseTable->elementAt(row, 1)->addWidget(new WText(*(++i)));
00669       releaseTable->elementAt(row, 2)->addWidget(new WText(*(++i)));
00670 
00671       ++row;
00672     }
00673   }
00674 }

std::string Home::href ( const std::string  url,
const std::string  description 
) [static, private]

Definition at line 590 of file Home.C.

00591 {
00592   return "<a href=\"" + url + "\" target=\"_blank\">" + description + "</a>";
00593 }

WTreeNode * Home::makeTreeMap ( const std::string  name,
WTreeNode parent 
) [private]

Definition at line 676 of file Home.C.

00677 {
00678   WIconPair *labelIcon
00679     = new WIconPair("icons/yellow-folder-closed.png",
00680                     "icons/yellow-folder-open.png", false);
00681 
00682   WTreeNode *node = new WTreeNode(name, labelIcon, parent);
00683   node->label()->setFormatting(WText::PlainFormatting);
00684 
00685   if (!parent) {
00686     node->setImagePack("icons/");
00687     node->expand();
00688     node->setLoadPolicy(WTreeNode::NextLevelLoading);
00689   }
00690 
00691   return node;
00692 }

WTreeNode * Home::makeTreeFile ( const std::string  name,
WTreeNode parent 
) [private]

Definition at line 694 of file Home.C.

00695 {
00696   WIconPair *labelIcon
00697     = new WIconPair("icons/document.png",
00698                     "icons/yellow-folder-open.png", false);
00699 
00700   return new WTreeNode("<a href=\"" + fixRelativeUrl("wt/src/" + name)
00701                        + "\" target=\"_blank\">"
00702                        + name + "</a>", labelIcon, parent);
00703 }

WWidget * Home::helloWorldExample (  )  [private]

Definition at line 302 of file Home.C.

00303 {
00304   WContainerWidget *result = new WContainerWidget();
00305 
00306   new WText(tr("home.examples.hello"), result);
00307 
00308   WTreeNode *tree = makeTreeMap("Hello world", 0);
00309   makeTreeFile("hello.C", tree);
00310 
00311   tree->expand();
00312 
00313   result->addWidget(tree);
00314 
00315   return result;
00316 }

WWidget * Home::chartExample (  )  [private]

Definition at line 318 of file Home.C.

00319 {
00320   WContainerWidget *result = new WContainerWidget();
00321 
00322   new WText(tr("home.examples.chart"), result);
00323 
00324   WTreeNode *tree = makeTreeMap("Chart example", 0);
00325   WTreeNode *chartsExample = makeTreeMap("class ChartsExample", tree);
00326   makeTreeFile("ChartsExample.h", chartsExample);
00327   makeTreeFile("ChartsExample.C", chartsExample);
00328   WTreeNode *chartConfig = makeTreeMap("class ChartConfig", tree);
00329   makeTreeFile("ChartConfig.h", chartConfig);
00330   makeTreeFile("ChartConfig.C", chartConfig);
00331   WTreeNode *panelList = makeTreeMap("class PanelList", tree);
00332   makeTreeFile("PanelList.h", panelList);
00333   makeTreeFile("PanelList.C", panelList);
00334   makeTreeFile("CsvUtil.C", tree);
00335   makeTreeFile("charts.xml", tree);
00336   makeTreeFile("charts.css", tree);
00337 
00338   tree->expand();
00339 
00340   result->addWidget(tree);
00341 
00342   return result;
00343 }

WWidget * Home::homepageExample (  )  [private]

Definition at line 345 of file Home.C.

00346 {
00347   WContainerWidget *result = new WContainerWidget();
00348 
00349   new WText(tr("home.examples.wt"), result);
00350 
00351   WTreeNode *tree = makeTreeMap("Wt Homepage", 0);
00352   WTreeNode *home = makeTreeMap("class Home", tree);
00353   makeTreeFile("Home.h", home);
00354   makeTreeFile("Home.C", home);
00355   WTreeNode *treeexample = makeTreeMap("class TreeListExample", tree);
00356   makeTreeFile("TreeListExample.h", treeexample);
00357   makeTreeFile("TreeListExample.C", treeexample);
00358   makeTreeFile("wt-home.xml", tree);
00359 
00360   tree->expand();
00361 
00362   result->addWidget(tree);
00363 
00364   return result;
00365 }

WWidget * Home::treeviewExample (  )  [private]

Definition at line 367 of file Home.C.

00368 {
00369   WContainerWidget *result = new WContainerWidget();
00370 
00371   new WText(tr("home.examples.treeview"), result);
00372 
00373   WTreeNode *tree = makeTreeMap("Treeview example", 0);
00374 
00375   WTreeNode *classMap;
00376   classMap = makeTreeMap("class FolderView", tree);
00377   makeTreeFile("FolderView.h", classMap);
00378   makeTreeFile("FolderView.C", classMap);
00379   makeTreeFile("TreeViewDragDrop.C", tree);
00380   makeTreeFile("CsvUtil.C", tree);
00381   makeTreeFile("about.xml", tree);
00382   makeTreeFile("styles.css", tree);
00383 
00384   tree->expand();
00385 
00386   result->addWidget(tree);
00387 
00388   return result;
00389 }

WWidget * Home::gitExample (  )  [private]

Definition at line 391 of file Home.C.

00392 {
00393   WContainerWidget *result = new WContainerWidget();
00394 
00395   new WText(tr("home.examples.git"), result);
00396 
00397   WTreeNode *tree = makeTreeMap("Git example", 0);
00398 
00399   WTreeNode *classMap;
00400   classMap = makeTreeMap("class GitModel", tree);
00401   makeTreeFile("GitModel.h", classMap);
00402   makeTreeFile("GitModel.C", classMap);
00403   classMap = makeTreeMap("class Git", tree);
00404   makeTreeFile("Git.h", classMap);
00405   makeTreeFile("Git.C", classMap);
00406   makeTreeFile("GitView.C", tree);
00407   makeTreeFile("gitview.css", tree);
00408 
00409   tree->expand();
00410 
00411   result->addWidget(tree);
00412 
00413   return result;
00414 }

WWidget * Home::chatExample (  )  [private]

Definition at line 416 of file Home.C.

00417 {
00418   WContainerWidget *result = new WContainerWidget();
00419 
00420   new WText(tr("home.examples.chat"), result);
00421 
00422   WTreeNode *tree = makeTreeMap("Chat example", 0);
00423 
00424   WTreeNode *classMap;
00425   classMap = makeTreeMap("class SimpleChatWidget", tree);
00426   makeTreeFile("SimpleChatWidget.h", classMap);
00427   makeTreeFile("SimpleChatWidget.C", classMap);
00428   classMap = makeTreeMap("class SimpleChatServer", tree);
00429   makeTreeFile("SimpleChatServer.h", classMap);
00430   makeTreeFile("SimpleChatServer.C", classMap);
00431   makeTreeFile("simpleChat.C", tree);
00432   makeTreeFile("simplechat.css", tree);
00433   makeTreeFile("simplechat.xml", tree);
00434 
00435   tree->expand();
00436 
00437   result->addWidget(tree);
00438 
00439   return result;
00440 }

WWidget * Home::composerExample (  )  [private]

Definition at line 442 of file Home.C.

00443 {
00444   WContainerWidget *result = new WContainerWidget();
00445 
00446   new WText(tr("home.examples.composer"), result);
00447 
00448   WTreeNode *tree = makeTreeMap("Mail composer example", 0);
00449 
00450   WTreeNode *classMap;
00451   classMap = makeTreeMap("class AddresseeEdit", tree);
00452   makeTreeFile("AddresseeEdit.h", classMap);
00453   makeTreeFile("AddresseeEdit.C", classMap);
00454   classMap = makeTreeMap("class AttachmentEdit", tree);
00455   makeTreeFile("AttachmentEdit.h", classMap);
00456   makeTreeFile("AttachmentEdit.C", classMap);
00457   classMap = makeTreeMap("class ComposeExample", tree);
00458   makeTreeFile("ComposeExample.h", classMap);
00459   makeTreeFile("ComposeExample.C", classMap);
00460   classMap = makeTreeMap("class Composer", tree);
00461   makeTreeFile("Composer.h", classMap);
00462   makeTreeFile("Composer.C", classMap);
00463   classMap = makeTreeMap("class ContactSuggestions", tree);
00464   makeTreeFile("ContactSuggestions.h", classMap);
00465   makeTreeFile("ContactSuggestions.C", classMap);
00466   classMap = makeTreeMap("class Label", tree);
00467   makeTreeFile("Label.h", classMap);
00468   makeTreeFile("Label.C", classMap);
00469   classMap = makeTreeMap("class Option", tree);
00470   makeTreeFile("Option.h", classMap);
00471   makeTreeFile("Option.C", classMap);
00472   classMap = makeTreeMap("class OptionList", tree);
00473   makeTreeFile("OptionList.h", classMap);
00474   makeTreeFile("OptionList.C", classMap);
00475   makeTreeFile("Contact.h", tree);
00476   makeTreeFile("Attachment.h", tree);
00477   makeTreeFile("composer.xml", tree);
00478   makeTreeFile("composer.css", tree);
00479 
00480   tree->expand();
00481 
00482   result->addWidget(tree);
00483 
00484   return result;
00485 }

WWidget * Home::widgetGalleryExample (  )  [private]

Definition at line 487 of file Home.C.

00488 {
00489   WContainerWidget *result = new WContainerWidget();
00490 
00491   new WText(tr("home.examples.widgetgallery"), result);
00492 
00493   return result;
00494 }

WWidget * Home::wrapViewOrDefer ( WWidget *(Home::*)()  createFunction  )  [private]

Definition at line 496 of file Home.C.

00497 {
00498   /*
00499    * We can only create a view if we have javascript for the
00500    * client-side tree manipulation -- otherwise we require server-side
00501    * event handling which is not possible with a view since the
00502    * server-side widgets do not exist. Therefore, all we can do to
00503    * avoid unnecessary server-side resources when JavaScript is not
00504    * available is deferring creation until load time.
00505    */
00506   if (!environment().agentIEMobile() && environment().javaScript())
00507     return makeStaticModel(boost::bind(createWidget, this));
00508   else
00509     return deferCreate(boost::bind(createWidget, this));
00510 }

void Home::updateTitle (  )  [private]

Definition at line 238 of file Home.C.

00239 {
00240   setTitle(tr("wt") + " - " + mainMenu_->currentItem()->text());
00241 }

void Home::logInternalPath (  )  [private]

Definition at line 243 of file Home.C.

00244 {
00245   // simulate an access log for the interal paths
00246   log("path") << internalPath();
00247 }

void Home::changeLanguage ( int  language  )  [private]

Definition at line 181 of file Home.C.

00182 {
00183   if (index == language_)
00184     return;
00185 
00186   int prevLanguage = language_;
00187 
00188   setLanguage(index);
00189 
00190   std::string langPath = languages[index].path;
00191   if (internalPath().empty())
00192     setInternalPath(langPath);
00193   else {
00194     std::string prevLangPath = languages[prevLanguage].path;
00195     std::string path = internalPath().substr(prevLangPath.length());
00196     setInternalPath(langPath + path);
00197   }
00198 }

void Home::setLanguage ( int  language  )  [private]

Definition at line 200 of file Home.C.

00201 {
00202   const Lang& l = languages[index];
00203 
00204   setLocale(l.code);
00205 
00206   std::string langPath = l.path;
00207   mainMenu_->setInternalBasePath(langPath);
00208   examplesMenu_->setInternalBasePath(langPath + "examples");
00209   updateTitle();
00210 
00211   language_ = index;
00212 }

void Home::setLanguageFromPath ( std::string  prefix  )  [private]

Definition at line 214 of file Home.C.

00215 {
00216   if (prefix == "/") {
00217     std::string langPath = internalPathNextPart(prefix);
00218 
00219     if (langPath.empty())
00220       langPath = '/';
00221     else
00222       langPath = '/' + langPath + '/';
00223 
00224     int newLanguage = 0;
00225 
00226     for (unsigned i = 0; i < languages.size(); ++i) {
00227       if (languages[i].path == langPath) {
00228         newLanguage = i;
00229         break;
00230       }
00231     }
00232 
00233     if (newLanguage != language_)
00234       setLanguage(newLanguage);
00235   }
00236 }

WString Home::tr ( const char *  key  )  [static, private]

Definition at line 705 of file Home.C.

00706 {
00707   return WString::tr(key);
00708 }


Member Data Documentation

Definition at line 30 of file Home.h.

Definition at line 41 of file Home.h.

Definition at line 42 of file Home.h.

WTable* Home::releases_ [private]

Definition at line 43 of file Home.h.

WMenu* Home::mainMenu_ [private]

Definition at line 45 of file Home.h.

Definition at line 46 of file Home.h.

int Home::language_ [private]

Definition at line 48 of file Home.h.

Definition at line 77 of file Home.h.


The documentation for this class was generated from the following files:

Generated on Mon Jan 26 14:14:22 2009 for Wt by doxygen 1.5.6