/* **************************************************************************** * Edit Users */ EditUsers::EditUsers(Wt::Dbo::Session& aSession, const std::string& basePath) : session_(aSession), basePath_(basePath) { setStyleClass("user-editor"); setTemplateText(tr("edit-users-list")); limitEdit_ = new Wt::WLineEdit; Wt::WPushButton* goLimit = new Wt::WPushButton(tr("go-limit")); goLimit->clicked().connect(SLOT(this, EditUsers::LimitList)); bindWidget("limit-edit",limitEdit_); bindWidget("limit-button",goLimit); LimitList(); } // end EditUsers::EditUsers
void AuthWidget::updatePasswordLoginView() { if (model_->passwordAuth()) { setCondition("if:passwords", true); updateView(model_); WInteractWidget *login = resolve<WInteractWidget *>("login"); if (!login) { login = new WPushButton(tr("Wt.Auth.login")); login->clicked().connect(this, &AuthWidget::attemptPasswordLogin); bindWidget("login", login); model_->configureThrottling(login); if (model_->baseAuth()->emailVerificationEnabled()) { WText *text = new WText(tr("Wt.Auth.lost-password")); text->clicked().connect(this, &AuthWidget::handleLostPassword); bindWidget("lost-password", text); } else bindEmpty("lost-password"); if (registrationEnabled_) { WInteractWidget *w; if (!basePath_.empty()) { w = new WAnchor (WLink(WLink::InternalPath, basePath_ + "register"), tr("Wt.Auth.register")); } else { w = new WText(tr("Wt.Auth.register")); w->clicked().connect(this, &AuthWidget::registerNewUser); } bindWidget("register", w); } else bindEmpty("register"); if (model_->baseAuth()->emailVerificationEnabled() && registrationEnabled_) bindString("sep", " | "); else bindEmpty("sep"); } model_->updateThrottling(login); } else { bindEmpty("lost-password"); bindEmpty("sep"); bindEmpty("register"); bindEmpty("login"); } }
void WTemplateFormView::setFormWidget(WFormModel::Field field, Wt::WWidget *formWidget) { fields_[field] = FieldData(); fields_[field].formWidget = formWidget; bindWidget(field, formWidget); }
void AuthWidget::createOAuthLoginView() { if (!model_->oAuth().empty()) { setCondition("if:oauth", true); WContainerWidget *icons = new WContainerWidget(); icons->setInline(isInline()); for (unsigned i = 0; i < model_->oAuth().size(); ++i) { const OAuthService *auth = model_->oAuth()[i]; WImage *w = new WImage("css/oauth-" + auth->name() + ".png", icons); w->setToolTip(auth->description()); w->setStyleClass("Wt-auth-icon"); w->setVerticalAlignment(AlignMiddle); OAuthProcess *const process = auth->createProcess(auth->authenticationScope()); #ifndef WT_TARGET_JAVA w->clicked().connect(process, &OAuthProcess::startAuthenticate); #else process->connectStartAuthenticate(w->clicked()); #endif process->authenticated().connect (boost::bind(&AuthWidget::oAuthDone, this, process, _1)); WObject::addChild(process); } bindWidget("icons", icons); } }
void CommentsWidget::show_form_() { if (fApp->is_banned()) { bindString("add", tr("facts.common.BannedIp")); } else { bindWidget("add", new CommentAddForm(this)); } }
void WTemplateFormView::updateViewField(WFormModel *model, WFormModel::Field field) { const std::string var = field; if (model->isVisible(field)) { setCondition("if:" + var, true); WWidget *edit = resolveWidget(var); if (!edit) { edit = createFormWidget(field); if (!edit) { LOG_ERROR("updateViewField: createFormWidget('" << field << "') returned 0"); return; } bindWidget(var, edit); } WFormWidget *fedit = dynamic_cast<WFormWidget *>(edit); if (fedit) { if (fedit->validator() != model->validator(field) && model->validator(field)) fedit->setValidator(model->validator(field)); updateViewValue(model, field, fedit); } else updateViewValue(model, field, edit); WText *info = resolve<WText *>(var + "-info"); if (!info) { info = new WText(); bindWidget(var + "-info", info); } bindString(var + "-label", model->label(field)); const WValidator::Result& v = model->validation(field); info->setText(v.message()); indicateValidation(field, model->isValidated(field), info, edit, v); edit->setDisabled(model->isReadOnly(field)); } else { setCondition("if:" + var, false); bindEmpty(var); bindEmpty(var + "-info"); } }
void WTemplateFormView ::setFormWidget(WFormModel::Field field, WWidget *formWidget, FieldView *fieldView) { fields_[field] = FieldData(); fields_[field].formWidget = formWidget; fields_[field].updateFunctions = fieldView; bindWidget(field, formWidget); }
SpinBoxField::SpinBoxField() : AbstractField(), _fieldLabel(new Wt::WText("Campo")), _fieldInvalidMessage(new Wt::WText("Dados incorretos")), _fieldInput(new Wt::WSpinBox()){ setEmptyValidator(); _fieldInput->setMinimum(0); _fieldInput->setWidth(100); setInvalidMessage("Selecione/Digite um numero valido"); _setTemplate(); _fieldInput->setStyleClass("form-control"); _fieldInvalidMessage->hide(); bindWidget("label", _fieldLabel); bindWidget("info", _fieldInvalidMessage); bindWidget("field", _fieldInput); }
void AuthWidget::createLoggedInView() { setTemplateText(tr("Wt.Auth.template.logged-in")); bindString("user-name", login_.user().identity(Identity::LoginName)); WPushButton *logout = new WPushButton(tr("Wt.Auth.logout")); logout->clicked().connect(this, &AuthWidget::logout); bindWidget("logout", logout); }
void WTemplateFormView ::setFormWidget(WFormModel::Field field, WWidget *formWidget, const boost::function<void()>& updateViewValue, const boost::function<void()>& updateModelValue) { fields_[field].formWidget = formWidget; fields_[field].updateView = updateViewValue; fields_[field].updateModel = updateModelValue; bindWidget(field, formWidget); }
CommentsWidget::CommentsWidget(const FactPtr& fact, Wt::WContainerWidget* p): Wt::WTemplate(tr("facts.comment.comments_template"), p), fact_(fact) { dbo::Transaction t(fApp->session()); Q query = fact->comments().find(); query.orderBy("comment_index desc"); CommentsModel* model = new CommentsModel(query, this); view_ = new CommentsView(model); show_button_(); bindWidget("comments", view_); if (fApp->admin() && !fApp->environment().ajax()) { bindWidget("save", new Wt::WPushButton(tr("facts.admin.Save"))); } else { bindString("save", ""); } int index = fApp->comment_index(fact); if (index != -1) { view_->goto_index(index); } t.commit(); }
void WNavigationBar::setTitle(const WString& title, const WLink& link) { WAnchor *titleLink = resolve<WAnchor *>("title-link"); if (!titleLink) { bindWidget("title-link", titleLink = new WAnchor()); wApp->theme()->apply(this, titleLink, NavBrandRole); } titleLink->setText(title); titleLink->setLink(link); }
void WNavigationBar::setResponsive(bool responsive) { NavContainer *contents = resolve<NavContainer *>("contents"); if (responsive) { WInteractWidget *collapseButton = resolve<WInteractWidget *>("collapse-button"); WInteractWidget *expandButton = resolve<WInteractWidget *>("expand-button"); if (!collapseButton) { bindWidget("collapse-button", collapseButton = createCollapseButton()); collapseButton->clicked().connect(this, &WNavigationBar::collapseContents); collapseButton->hide(); bindWidget("expand-button", expandButton = createExpandButton()); expandButton->clicked().connect(this, &WNavigationBar::expandContents); } wApp->theme()->apply(this, contents, NavCollapseRole); contents->hide(); if (contents->isBootstrap2Responsive()) { /* Comply with bootstrap responsive CSS assumptions */ contents->setJavaScriptMember ("wtAnimatedHidden", "function(hidden) {" """if (hidden) " "" "this.style.height=''; this.style.display='';" "}"); } } else { bindEmpty("collapse-button"); } }
WNavigationBar::WNavigationBar(WContainerWidget *parent) : WTemplate(tr("Wt.WNavigationBar.template"), parent) { bindEmpty("collapse-button"); bindEmpty("expand-button"); bindEmpty("title-link"); bindWidget("contents", new NavContainer()); implementStateless(&WNavigationBar::collapseContents, &WNavigationBar::undoExpandContents); implementStateless(&WNavigationBar::expandContents, &WNavigationBar::undoExpandContents); }
CommentAddForm(CommentsWidget* comments): Wt::WTemplate(tr("facts.comment.add_template")), comments_(comments) { username_ = new Wt::WLineEdit(); username_->setEmptyText(tr("facts.comment.Username")); username_->setTextSize(INPUT_SIZE); username_->setValidator(new Wt::WLengthValidator(MIN_INPUT_SIZE, INPUT_SIZE)); username_->validator()->setMandatory(true); email_ = new Wt::WLineEdit(); email_->setEmptyText(tr("facts.comment.Email")); email_->setTextSize(INPUT_SIZE); email_->setValidator(new Wt::WRegExpValidator(EMAIL_PATTERN)); text_ = new Wt::WTextEdit(); text_->setColumns(TEXT_COLUMNS); Wt::WPushButton* add_button = new Wt::WPushButton(tr("facts.comment.Add")); add_button->clicked().connect(this, &CommentAddForm::add_handler_); error_ = new Wt::WText(); bindWidget("username", username_); bindWidget("email", email_); bindWidget("text", text_); bindWidget("button", add_button); bindWidget("error", error_); }
LoginWindow::LoginWindow(WContainerWidget* parent) : MoreAwesomeTemplate(parent) { setTemplateText(tr("login-template")); addStyleClass("yui-gd dialog form"); // 1/3 + 2/3 style bindAndCreateField(_usernameLabel, _usernameEdit, "username"); // Password bindAndCreateField(_passwordLabel, _passwordEdit, "password"); _passwordEdit->setEchoMode(WLineEdit::Password); // Buttons bindWidget("btn-bar", _btnBar = new ButtonBar(tr("Login"), tr("Cancel"))); _btnBar->btn1()->clicked().connect(this, &LoginWindow::handleOKHit); _btnBar->btn2()->clicked().connect(this, &LoginWindow::handleCancelHit); // Hook up accept and reject signals // All these do an accept _passwordEdit->enterPressed().connect(this, &LoginWindow::handleOKHit); // These do reject _usernameEdit->escapePressed().connect(this, &LoginWindow::handleCancelHit); _passwordEdit->escapePressed().connect(this, &LoginWindow::handleCancelHit); }
/* **************************************************************************** * Limit List */ void EditUsers::LimitList() { Wt::WContainerWidget* list = new Wt::WContainerWidget; bindWidget("user-list",list); typedef Wt::Dbo::collection<Wt::Dbo::ptr<User> > UserList; Wt::Dbo::Transaction t(session_); UserList users = session_.find<User>().where("name like ?").bind("%"+limitEdit_->text()+"%").orderBy("name"); Wt::WSignalMapper<Wt::Dbo::dbo_traits<User>::IdType >* userLinkMap = new Wt::WSignalMapper<Wt::Dbo::dbo_traits<User>::IdType >(this); userLinkMap->mapped().connect(this,&EditUsers::OnUserClicked); for (UserList::const_iterator i = users.begin(); i != users.end(); ++i) { Wt::WText* t = new Wt::WText((*i)->name, list); t->setStyleClass("link"); new Wt::WBreak(list); userLinkMap->mapConnect(t->clicked(), (*i).id()); } if (!users.size()) { new Wt::WText(tr("no-users-found"),list); } } // end void EditUsers::LimitList
void WTemplate::bindString(const std::string& varName, const WString& value, TextFormat textFormat) { WWidget *w = resolveWidget(varName); if (w) bindWidget(varName, 0); WString v = value; if (textFormat == XHTMLText && v.literal()) { if (!removeScript(v)) v = escapeText(v, true); } else if (textFormat == PlainText) v = escapeText(v, true); StringMap::const_iterator i = strings_.find(varName); if (i == strings_.end() || i->second != v.toUTF8()) { strings_[varName] = v.toUTF8(); changed_ = true; repaint(RepaintInnerHtml); } }
UpdatePasswordWidget::UpdatePasswordWidget(const User& user, RegistrationModel *registrationModel, AuthModel *authModel, WContainerWidget *parent) : WTemplateFormView(tr("Wt.Auth.template.update-password"), parent), user_(user), registrationModel_(registrationModel), authModel_(authModel) { registrationModel_->setValue(RegistrationModel::LoginNameField, user.identity(Identity::LoginName)); registrationModel_->setReadOnly(RegistrationModel::LoginNameField, true); if (authModel_->baseAuth()->emailVerificationEnabled()) { /* * This is set in the model so that the password checker can take * into account whether the password is derived from the email * address. */ registrationModel_->setValue(RegistrationModel::EmailField, WT_USTRING::fromUTF8(user.email() + " " + user.unverifiedEmail())); registrationModel_->setVisible(RegistrationModel::EmailField, false); } WPushButton *okButton = new WPushButton(tr("Wt.WMessageBox.Ok")); WPushButton *cancelButton = new WPushButton(tr("Wt.WMessageBox.Cancel")); if (authModel_) { authModel_->setValue(AuthModel::LoginNameField, user.identity(Identity::LoginName)); updateViewField(authModel_, AuthModel::PasswordField); authModel_->configureThrottling(okButton); WLineEdit *password = resolve<WLineEdit *>(AuthModel::PasswordField); password->setFocus(); } updateView(registrationModel_); WLineEdit *password = resolve<WLineEdit *> (RegistrationModel::ChoosePasswordField); WLineEdit *password2 = resolve<WLineEdit *> (RegistrationModel::RepeatPasswordField); WText *password2Info = resolve<WText *> (RegistrationModel::RepeatPasswordField + std::string("-info")); registrationModel_->validatePasswordsMatchJS(password, password2, password2Info); if (!authModel_) password->setFocus(); okButton->clicked().connect(this, &UpdatePasswordWidget::doUpdate); cancelButton->clicked().connect(this, &UpdatePasswordWidget::close); bindWidget("ok-button", okButton); bindWidget("cancel-button", cancelButton); }
void RegistrationWidget::update() { if (model_->passwordAuth()) bindString("password-description", tr("Wt.Auth.password-registration")); else bindEmpty("password-description"); updateView(model_); if (!created_) { WLineEdit *password = resolve<WLineEdit *> (RegistrationModel::ChoosePasswordField); WLineEdit *password2 = resolve<WLineEdit *> (RegistrationModel::RepeatPasswordField); WText *password2Info = resolve<WText *> (RegistrationModel::RepeatPasswordField + std::string("-info")); if (password && password2 && password2Info) model_->validatePasswordsMatchJS(password, password2, password2Info); } WAnchor *isYou = resolve<WAnchor *>("confirm-is-you"); if (!isYou) { isYou = new WAnchor(std::string("#"), tr("Wt.Auth.confirm-is-you")); isYou->hide(); bindWidget("confirm-is-you", isYou); } if (model_->isConfirmUserButtonVisible()) { if (!isYou->clicked().isConnected()) isYou->clicked().connect(this, &RegistrationWidget::confirmIsYou); isYou->show(); } else isYou->hide(); if (model_->isFederatedLoginVisible()) { if (!conditionValue("if:oauth")) { setCondition("if:oauth", true); if (model_->passwordAuth()) bindString("oauth-description", tr("Wt.Auth.or-oauth-registration")); else bindString("oauth-description", tr("Wt.Auth.oauth-registration")); WContainerWidget *icons = new WContainerWidget(); icons->addStyleClass("Wt-field"); for (unsigned i = 0; i < model_->oAuth().size(); ++i) { const OAuthService *service = model_->oAuth()[i]; WImage *w = new WImage("css/oauth-" + service->name() + ".png", icons); w->setToolTip(service->description()); w->setStyleClass("Wt-auth-icon"); w->setVerticalAlignment(AlignMiddle); OAuthProcess *const process = service->createProcess(service->authenticationScope()); w->clicked().connect(process, &OAuthProcess::startAuthenticate); process->authenticated().connect (boost::bind(&RegistrationWidget::oAuthDone, this, process, _1)); WObject::addChild(process); } bindWidget("icons", icons); } } else { setCondition("if:oauth", false); bindEmpty("icons"); } if (!created_) { WPushButton *okButton = new WPushButton(tr("Wt.Auth.register")); WPushButton *cancelButton = new WPushButton(tr("Wt.WMessageBox.Cancel")); bindWidget("ok-button", okButton); bindWidget("cancel-button", cancelButton); okButton->clicked().connect(this, &RegistrationWidget::doRegister); cancelButton->clicked().connect(this, &RegistrationWidget::close); created_ = true; } }
void WTemplate::bindEmpty(const std::string& varName) { bindWidget(varName, 0); }
// inline constructor UserFormView() { model_ = new UserFormModel(this); setTemplateText(tr("userForm-template")); addFunction("id", &WTemplate::Functions::id); /* * First Name */ setFormWidget(UserFormModel::FirstNameField, new Wt::WLineEdit()); /* * Last Name */ setFormWidget(UserFormModel::LastNameField, new Wt::WLineEdit()); /* * Country */ Wt::WComboBox *countryCB = new Wt::WComboBox(); countryCB->setModel(model_->countryModel()); countryCB->activated().connect(std::bind([=] () { std::string code = model_->countryCode(countryCB->currentIndex()); model_->updateCityModel(code); })); setFormWidget(UserFormModel::CountryField, countryCB, [=] () { // updateViewValue() std::string code = boost::any_cast<std::string> (model_->value(UserFormModel::CountryField)); int row = model_->countryModelRow(code); countryCB->setCurrentIndex(row); }, [=] () { // updateModelValue() std::string code = model_->countryCode(countryCB->currentIndex()); model_->setValue(UserFormModel::CountryField, code); }); /* * City */ Wt::WComboBox *cityCB = new Wt::WComboBox(); cityCB->setModel(model_->cityModel()); setFormWidget(UserFormModel::CityField, cityCB); /* * Birth Date */ Wt::WLineEdit *dateEdit = new Wt::WLineEdit(); Wt::WDatePicker *birthDP = new Wt::WDatePicker(dateEdit); bindWidget("birth-dp", birthDP); setFormWidget(UserFormModel::BirthField, dateEdit, [=] () { // updateViewValue() Wt::WDate date = boost::any_cast<Wt::WDate> (model_->value(UserFormModel::BirthField)); birthDP->setDate(date); }, [=] () { // updateModelValue() Wt::WDate date = birthDP->date(); model_->setValue(UserFormModel::BirthField, date); }); /* * Children */ setFormWidget(UserFormModel::ChildrenField, new Wt::WSpinBox()); /* * Remarks */ Wt::WTextArea *remarksTA = new Wt::WTextArea(); remarksTA->setColumns(40); remarksTA->setRows(5); setFormWidget(UserFormModel::RemarksField, remarksTA); /* * Title & Buttons */ Wt::WString title = Wt::WString("Create new user"); bindString("title", title); Wt::WPushButton *button = new Wt::WPushButton("Save"); bindWidget("submit-button", button); bindString("submit-info", Wt::WString()); button->clicked().connect(this, &UserFormView::process); updateView(model_); }
UpdatePasswordWidget::UpdatePasswordWidget(const User& user, const AbstractPasswordService& auth, Login& login, bool promptPassword, WContainerWidget *parent) : WTemplate(tr("Wt.Auth.template.update-password"), parent), user_(user), promptPassword_(promptPassword), validated_(false), enterPasswordFields_(0) { addFunction("id", &WTemplate::Functions::id); addFunction("tr", &WTemplate::Functions::tr); WLineEdit *nameEdit = new WLineEdit(user.identity(Identity::LoginName)); nameEdit->disable(); nameEdit->addStyleClass("Wt-disabled"); bindWidget("user-name", nameEdit); WPushButton *okButton = new WPushButton(tr("Wt.WMessageBox.Ok")); WPushButton *cancelButton = new WPushButton(tr("Wt.WMessageBox.Cancel")); if (promptPassword_) { setCondition("if:old-password", true); WLineEdit *oldPasswd = new WLineEdit(); WText *oldPasswdInfo = new WText(); enterPasswordFields_ = new EnterPasswordFields(auth, oldPasswd, oldPasswdInfo, okButton, this); oldPasswd->setFocus(); bindWidget("old-password", oldPasswd); bindWidget("old-password-info", oldPasswdInfo); } WLineEdit *password = new WLineEdit(); password->setEchoMode(WLineEdit::Password); password->keyWentUp().connect (boost::bind(&UpdatePasswordWidget::checkPassword, this)); password->changed().connect (boost::bind(&UpdatePasswordWidget::checkPassword, this)); WText *passwordInfo = new WText(); WLineEdit *password2 = new WLineEdit(); password2->setEchoMode(WLineEdit::Password); password2->changed().connect (boost::bind(&UpdatePasswordWidget::checkPassword2, this)); WText *password2Info = new WText(); bindWidget("choose-password", password); bindWidget("choose-password-info", passwordInfo); bindWidget("repeat-password", password2); bindWidget("repeat-password-info", password2Info); model_ = new RegistrationModel(auth.baseAuth(), *user.database(), login, this); model_->addPasswordAuth(&auth); model_->setValue(RegistrationModel::LoginName, user.identity(Identity::LoginName)); model_->setValue(RegistrationModel::Email, WT_USTRING::fromUTF8(user.email() + " " + user.unverifiedEmail())); model_->validatePasswordsMatchJS(password, password2, password2Info); passwordInfo->setText(model_->validationResult (RegistrationModel::Password).message()); password2Info->setText(model_->validationResult (RegistrationModel::Password2).message()); okButton->clicked().connect(this, &UpdatePasswordWidget::doUpdate); cancelButton->clicked().connect(this, &UpdatePasswordWidget::close); bindWidget("ok-button", okButton); bindWidget("cancel-button", cancelButton); if (!promptPassword_) password->setFocus(); }
void setBody(WWidget* newChild) { bindWidget("content", newChild); }
// inline constructor UserFormView() { model = std::make_shared<UserFormModel>(); setTemplateText(tr("userForm-template")); addFunction("id", &WTemplate::Functions::id); addFunction("block", &WTemplate::Functions::id); /* * First Name */ setFormWidget(UserFormModel::FirstNameField, Wt::cpp14::make_unique<Wt::WLineEdit>()); /* * Last Name */ setFormWidget(UserFormModel::LastNameField, Wt::cpp14::make_unique<Wt::WLineEdit>()); /* * Country */ auto countryCB = Wt::cpp14::make_unique<Wt::WComboBox>(); auto countryCB_ = countryCB.get(); countryCB->setModel(model->countryModel()); countryCB_->activated().connect([=] { std::string code = model->countryCode(countryCB_->currentIndex()); model->updateCityModel(code); }); setFormWidget(UserFormModel::CountryField, std::move(countryCB), [=] { // updateViewValue() std::string code = Wt::asString(model->value(UserFormModel::CountryField)).toUTF8(); int row = model->countryModelRow(code); countryCB_->setCurrentIndex(row); }, [=] { // updateModelValue() std::string code = model->countryCode(countryCB_->currentIndex()); model->setValue(UserFormModel::CountryField, code); }); /* * City */ auto cityCB = Wt::cpp14::make_unique<Wt::WComboBox>(); cityCB->setModel(model->cityModel()); setFormWidget(UserFormModel::CityField, std::move(cityCB)); /* * Birth Date */ auto dateEdit = Wt::cpp14::make_unique<Wt::WDateEdit>(); auto dateEdit_ = dateEdit.get(); setFormWidget(UserFormModel::BirthField, std::move(dateEdit), [=] { // updateViewValue() Wt::WDate date = Wt::cpp17::any_cast<Wt::WDate> (model->value(UserFormModel::BirthField)); dateEdit_->setDate(date); }, [=] { // updateModelValue() Wt::WDate date = dateEdit_->date(); model->setValue(UserFormModel::BirthField, date); }); /* * Children */ setFormWidget(UserFormModel::ChildrenField, Wt::cpp14::make_unique<Wt::WSpinBox>()); /* * Remarks */ auto remarksTA = Wt::cpp14::make_unique<Wt::WTextArea>(); remarksTA->setColumns(40); remarksTA->setRows(5); setFormWidget(UserFormModel::RemarksField, std::move(remarksTA)); /* * Title & Buttons */ Wt::WString title = Wt::WString("Create new user"); bindString("title", title); auto button = Wt::cpp14::make_unique<Wt::WPushButton>("Save"); auto button_ = bindWidget("submit-button", std::move(button)); bindString("submit-info", Wt::WString()); button_->clicked().connect(this, &UserFormView::process); updateView(model.get()); }
GoogleMapExample() : WContainerWidget() { auto layout = setLayout(cpp14::make_unique<WHBoxLayout>()); setHeight(400); auto map = cpp14::make_unique<WGoogleMap>(GoogleMapsVersion::v3); map_ = map.get(); layout->addWidget(std::move(map), 1); map_->setMapTypeControl(MapTypeControl::Default); map_->enableScrollWheelZoom(); auto controls = cpp14::make_unique<WTemplate>(tr("graphics-GoogleMap-controls")); auto controls_ = controls.get(); layout->addWidget(std::move(controls)); auto zoomIn = cpp14::make_unique<WPushButton>("+"); auto zoomIn_ = controls_->bindWidget("zoom-in", std::move(zoomIn)); zoomIn_->addStyleClass("zoom"); zoomIn_->clicked().connect([=] { map_->zoomIn(); }); auto zoomOut = cpp14::make_unique<WPushButton>("-"); auto zoomOut_ = controls_->bindWidget("zoom-out", std::move(zoomOut)); zoomOut_->addStyleClass("zoom"); zoomOut_->clicked().connect([=] { map_->zoomOut(); }); std::string cityNames[] = { "Brussels", "Lisbon", "Paris" }; WGoogleMap::Coordinate cityCoords[] = { WGoogleMap::Coordinate(50.85034,4.35171), WGoogleMap::Coordinate(38.703731,-9.135475), WGoogleMap::Coordinate(48.877474, 2.312579) }; for (unsigned i = 0; i < 3; ++i) { auto city = cpp14::make_unique<WPushButton>(cityNames[i]); auto city_ = controls_->bindWidget(cityNames[i], std::move(city)); WGoogleMap::Coordinate coord = cityCoords[i]; city_->clicked().connect([=] { map_->panTo(coord); }); } auto reset = cpp14::make_unique<WPushButton>("Reset"); auto reset_ = controls_->bindWidget("emweb", std::move(reset)); reset_->clicked().connect([=] { this->panToEmWeb(); }); auto savePosition = cpp14::make_unique<WPushButton>("Save current position"); auto savePosition_ = controls_->bindWidget("save-position", std::move(savePosition)); savePosition_->clicked().connect([=] { this->savePosition(); }); auto returnToPosition = cpp14::make_unique<WPushButton>("Return to saved position"); returnToPosition_ = controls_->bindWidget("return-to-saved-position", std::move(returnToPosition)); returnToPosition_->setEnabled(false); returnToPosition_->clicked().connect([=] { map_->returnToSavedPosition(); }); mapTypeModel_ = std::make_shared<WStringListModel>(); addMapTypeControl("No control", MapTypeControl::None); addMapTypeControl("Default", MapTypeControl::Default); addMapTypeControl("Menu", MapTypeControl::Menu); if (map_->apiVersion() == GoogleMapsVersion::v2) addMapTypeControl("Hierarchical", MapTypeControl::Hierarchical); if (map_->apiVersion() == GoogleMapsVersion::v3) addMapTypeControl("Horizontal bar", MapTypeControl::HorizontalBar); auto menuControls = cpp14::make_unique<WComboBox>(); auto menuControls_ = controls_->bindWidget("control-menu-combo", std::move(menuControls)); menuControls_->setModel(mapTypeModel_); menuControls_->setCurrentIndex(1); menuControls_->activated().connect([=] (int mapType) { this->setMapTypeControl(mapType); }); auto draggingCB = cpp14::make_unique<WCheckBox>("Enable dragging"); auto draggingCB_ = controls_->bindWidget("dragging-cb", std::move(draggingCB)); draggingCB_->setChecked(true); map_->enableDragging(); draggingCB_->checked().connect([=] { map_->enableDragging(); }); draggingCB_->unChecked().connect([=] { map_->disableDragging(); }); auto enableDoubleClickZoomCB = cpp14::make_unique<WCheckBox>("Enable double click zoom"); auto enableDoubleClickZoomCB_ = controls_->bindWidget("double-click-zoom-cb", std::move(enableDoubleClickZoomCB)); enableDoubleClickZoomCB_->setChecked(false); map_->disableDoubleClickZoom(); enableDoubleClickZoomCB_->checked().connect([=] { map_->enableDoubleClickZoom(); }); enableDoubleClickZoomCB_->unChecked().connect([=] { map_->disableDoubleClickZoom(); }); auto enableScrollWheelZoomCB = cpp14::make_unique<WCheckBox>("Enable scroll wheel zoom"); auto enableScrollWheelZoomCB_ = controls_->bindWidget("scroll-wheel-zoom-cb", std::move(enableScrollWheelZoomCB)); enableScrollWheelZoomCB_->setChecked(true); map_->enableScrollWheelZoom(); enableScrollWheelZoomCB_->checked().connect([=] { map_->enableScrollWheelZoom(); }); enableScrollWheelZoomCB_->unChecked().connect([=] { map_->disableScrollWheelZoom(); }); std::vector<WGoogleMap::Coordinate> road = roadDescription(); map_->addPolyline(road, WColor(0, 191, 255)); //Koen's favourite bar! map_->addMarker(WGoogleMap::Coordinate(50.885069,4.71958)); map_->setCenter(road[road.size()-1]); map_->openInfoWindow(road[0], "<img src=\"http://www.emweb.be/css/emweb_small.jpg\" />" "<p><strong>Emweb office</strong></p>"); map_->clicked().connect([=] (WGoogleMap::Coordinate c) { this->googleMapClicked(c); }); map_->doubleClicked().connect([=] (WGoogleMap::Coordinate c) { this->googleMapDoubleClicked(c); }); }
/* **************************************************************************** * Edit User */ EditUser::EditUser(Wt::Dbo::Session& aSession) : Wt::WTemplate(tr("edit-user")), session_(aSession), roleButton_(new Wt::WPushButton) { bindWidget("role-button",roleButton_); roleButton_->clicked().connect(SLOT(this, EditUser::SwitchRole)); } // end EditUser::EditUser
void CommentsWidget::show_button_() { Wt::WPushButton* add = new Wt::WPushButton(tr("facts.comment.Add")); add->clicked().connect(this, &CommentsWidget::show_form_); bindWidget("add", add); }