void WSlider::updateDom(DomElement& element, bool all)
{
if (paintedSlider_)
paintedSlider_->doUpdateDom(element, all);
else {
if (all || changed_) {
element.setAttribute("type", "range");
element.setProperty(Wt::PropertyValue,
boost::lexical_cast<std::string>(value_));
element.setAttribute("min",
boost::lexical_cast<std::string>(minimum_));
element.setAttribute("max",
boost::lexical_cast<std::string>(maximum_));
if (!changedConnected_
&& (valueChanged_.isConnected() || sliderMoved_.isConnected())) {
changedConnected_ = true;
changed().connect(this, &WSlider::onChange);
}
changed_ = false;
}
}
WFormWidget::updateDom(element, all);
}
void WLineEdit::updateDom(DomElement& element, bool all)
{
if (all || flags_.test(BIT_CONTENT_CHANGED)) {
element.setProperty(Wt::PropertyValue, content_.toUTF8());
flags_.reset(BIT_CONTENT_CHANGED);
}
if (all || flags_.test(BIT_ECHO_MODE_CHANGED)) {
element.setAttribute("type", echoMode_ == Normal ? "text" : "password");
flags_.reset(BIT_ECHO_MODE_CHANGED);
}
if (all || flags_.test(BIT_TEXT_SIZE_CHANGED)) {
element.setAttribute("size",
boost::lexical_cast<std::string>(textSize_));
flags_.reset(BIT_TEXT_SIZE_CHANGED);
}
if (all || flags_.test(BIT_MAX_LENGTH_CHANGED)) {
if (!all || maxLength_ > 0)
element.setAttribute("maxLength",
boost::lexical_cast<std::string>(maxLength_));
flags_.reset(BIT_MAX_LENGTH_CHANGED);
}
WFormWidget::updateDom(element, all);
}
void WWidgetCanvasPainter::createContents(DomElement *result,
WPaintDevice *device)
{
std::string wstr = boost::lexical_cast<std::string>(widget_->renderWidth_);
std::string hstr = boost::lexical_cast<std::string>(widget_->renderHeight_);
result->setProperty(PropertyStylePosition, "relative");
result->setProperty(PropertyStyleOverflowX, "hidden");
DomElement *canvas = DomElement::createNew(DomElement_CANVAS);
canvas->setId('c' + widget_->id());
canvas->setProperty(PropertyStyleDisplay, "block");
canvas->setAttribute("width", wstr);
canvas->setAttribute("height", hstr);
result->addChild(canvas);
WCanvasPaintDevice *canvasDevice = dynamic_cast<WCanvasPaintDevice *>(device);
DomElement *text = 0;
if (canvasDevice->textMethod() == WCanvasPaintDevice::DomText) {
text = DomElement::createNew(DomElement_DIV);
text->setId('t' + widget_->id());
text->setProperty(PropertyStylePosition, "absolute");
text->setProperty(PropertyStyleZIndex, "1");
text->setProperty(PropertyStyleTop, "0px");
text->setProperty(PropertyStyleLeft, "0px");
}
canvasDevice->render("c" + widget_->id(), text ? text : result);
if (text)
result->addChild(text);
delete device;
}
void WWidgetCanvasPainter::updateContents(std::vector<DomElement *>& result,
WPaintDevice *device)
{
WCanvasPaintDevice *canvasDevice = dynamic_cast<WCanvasPaintDevice *>(device);
if (widget_->sizeChanged_) {
DomElement *canvas = DomElement::getForUpdate('c' + widget_->id(),
DomElement_CANVAS);
canvas->setAttribute("width",
boost::lexical_cast<std::string>(widget_->renderWidth_));
canvas->setAttribute("height",
boost::lexical_cast<std::string>(widget_->renderHeight_));
result.push_back(canvas);
widget_->sizeChanged_ = false;
}
bool domText = canvasDevice->textMethod() == WCanvasPaintDevice::DomText;
DomElement *el
= DomElement::getForUpdate(domText ? 't' + widget_->id() : widget_->id(),
DomElement_DIV);
if (domText)
el->removeAllChildren();
canvasDevice->render('c' + widget_->id(), el);
result.push_back(el);
delete device;
}
void WWidgetCanvasPainter::createContents(DomElement *result,
WPaintDevice *device)
{
std::string wstr = boost::lexical_cast<std::string>(widget_->renderWidth_);
std::string hstr = boost::lexical_cast<std::string>(widget_->renderHeight_);
result->setProperty(PropertyStylePosition, "relative");
result->setProperty(PropertyStyleOverflowX, "hidden");
result->setProperty(PropertyStyleOverflowY, "hidden");
DomElement *canvas = DomElement::createNew(DomElement_CANVAS);
canvas->setId('c' + widget_->id());
canvas->setProperty(PropertyStyleDisplay, "block");
canvas->setAttribute("width", wstr);
canvas->setAttribute("height", hstr);
result->addChild(canvas);
widget_->sizeChanged_ = false;
WCanvasPaintDevice *canvasDevice = dynamic_cast<WCanvasPaintDevice *>(device);
DomElement *text = 0;
if (canvasDevice->textMethod() == WCanvasPaintDevice::DomText) {
text = DomElement::createNew(DomElement_DIV);
text->setId('t' + widget_->id());
text->setProperty(PropertyStylePosition, "absolute");
text->setProperty(PropertyStyleZIndex, "1");
text->setProperty(PropertyStyleTop, "0px");
text->setProperty(PropertyStyleLeft, "0px");
}
DomElement *el = text ? text : result;
bool hasJsObjects = widget_->jsObjects_.size() > 0;
if (hasJsObjects) {
WStringStream ss;
WApplication *app = WApplication::instance();
ss << "new " WT_CLASS ".WPaintedWidget("
<< app->javaScriptClass() << "," << widget_->jsRef() << ");";
widget_->jsObjects_.updateJs(ss);
el->callJavaScript(ss.str());
}
canvasDevice->render('c' + widget_->id(), el);
if (hasJsObjects) {
WStringStream ss;
ss << widget_->objJsRef() << ".repaint=function(){";
ss << canvasDevice->recordedJs_.str();
ss << "};";
el->callJavaScript(ss.str());
}
if (text)
result->addChild(text);
delete device;
}
bool WCircleArea::updateDom(DomElement& element, bool all)
{
element.setAttribute("shape", "circle");
std::stringstream coords;
coords << static_cast<int>(x_) << ','
<< static_cast<int>(y_) << ','
<< static_cast<int>(r_);
element.setAttribute("coords", coords.str());
return WAbstractArea::updateDom(element, all);
}
DomElement *WFileUpload::createDomElement()
{
if (methodIframe_) {
DomElement *form = DomElement::createNew(DomElement::FORM);
form->setId(this, true);
form->setAttribute("method", "post");
form->setAttribute("action", generateUrl());
form->setAttribute("enctype", "multipart/form-data");
form->setAttribute("style", "margin:0;padding:0;display:inline");
DomElement *input = DomElement::createNew(DomElement::INPUT);
input->setAttribute("type", "file");
input->setAttribute("name", "data");
input->setAttribute("size", boost::lexical_cast<std::string>(textSize_));
input->setId("in" + formName());
updateSignalConnection(*input, changed, "change", true);
form->addChild(input);
updateDom(*form, true);
return form;
} else {
DomElement *result = DomElement::createNew(DomElement::INPUT);
result->setAttribute("type", "file");
result->setAttribute("size", boost::lexical_cast<std::string>(textSize_));
result->setId(this, true);
updateSignalConnection(*result, changed, "change", true);
updateDom(*result, true);
return result;
}
}
bool WRectArea::updateDom(DomElement& element, bool all)
{
element.setAttribute("shape", "rect");
std::stringstream coords;
if (x_ == 0 && y_ == 0 && width_ == 0 && height_ == 0)
coords << "0%,0%,100%,100%";
else
coords << x_ << ',' << y_ << ',' << (x_ + width_) << ',' << (y_ + height_);
element.setAttribute("coords", coords.str());
return WAbstractArea::updateDom(element, all);
}
bool WPolygonArea::updateDom(DomElement& element, bool all)
{
element.setAttribute("shape", "poly");
std::stringstream coords;
for (unsigned i = 0; i < points_.size(); ++i) {
if (i != 0)
coords << ',';
coords << static_cast<int>(points_[i].x()) << ','
<< static_cast<int>(points_[i].y());
}
element.setAttribute("coords", coords.str());
return WAbstractArea::updateDom(element, all);
}
void WComboBox::updateDom(DomElement& element, bool all)
{
if (itemsChanged_ || all) {
if (!all)
element.removeAllChildren();
for (unsigned i = 0; i < items_.size(); ++i) {
DomElement *item = DomElement::createNew(DomElement::OPTION);
item->setAttribute("value", boost::lexical_cast<std::string>(i));
item->setProperty(Wt::PropertyInnerHTML,
toUTF8(escapeText(items_[i].value())));
if ((int)i == currentIndex_)
item->setProperty(Wt::PropertySelected, "true");
element.addChild(item);
}
itemsChanged_ = false;
}
if (selectionChanged_) {
element.setProperty(Wt::PropertySelectedIndex,
boost::lexical_cast<std::string>(currentIndex_));
selectionChanged_ = false;
}
if (activated.isConnected() || sactivated.isConnected())
changed.connect(SLOT(this, WComboBox::propagateChange));
WFormWidget::updateDom(element, all);
renderOk();
}
void WSpinBox::updateDom(DomElement& element, bool all)
{
if (all || changed_) {
if (nativeControl()) {
element.setAttribute("min", boost::lexical_cast<std::string>(min_));
element.setAttribute("max", boost::lexical_cast<std::string>(max_));
element.setAttribute("step", boost::lexical_cast<std::string>(step_));
} else {
/* Make sure the JavaScript validator is loaded */
WIntValidator v;
v.javaScriptValidate();
}
}
WAbstractSpinBox::updateDom(element, all);
}
void WFileUpload::getDomChanges(std::vector<DomElement *>& result)
{
if (renderState() == RenderUpdate) {
if (!methodIframe_) {
DomElement *e = DomElement::getForUpdate(this, DomElement::INPUT);
updateDom(*e, false);
result.push_back(e);
} else {
DomElement *e = DomElement::getForUpdate(this, DomElement::FORM);
updateDom(*e, false);
if (doUpload_) {
iframe_ = wApp->useIframe();
e->setAttribute("target", iframe_->formName());
e->callMethod("submit()");
doUpload_ = false;
}
result.push_back(e);
}
}
}
virtual void updateDom(DomElement& element, bool all)
{
if (all)
element.setAttribute("name", id());
WContainerWidget::updateDom(element, all);
}
void WSelectionBox::updateDom(DomElement& element, bool all)
{
if (configChanged_ || all) {
element.setAttribute("size", std::to_string(verticalSize_));
if (!all || (selectionMode_ == SelectionMode::Extended)) {
element.setProperty(Property::Multiple,
selectionMode_ == SelectionMode::Extended
? "true" : "false");
if (!all)
selectionChanged_ = true;
}
configChanged_ = false;
}
if (selectionMode_ == SelectionMode::Extended) {
if (selectionChanged_ && !all) {
for (int i = 0; i < count(); ++i) {
element.callMethod("options[" + std::to_string(i) + "].selected="
+ (isSelected(i) ? "true" : "false"));
}
}
selectionChanged_ = false;
}
WComboBox::updateDom(element, all);
}
void WComboBox::updateDom(DomElement& element, bool all)
{
if (itemsChanged_ || all) {
if (!all)
element.removeAllChildren();
for (unsigned i = 0; i < items_.size(); ++i) {
DomElement *item = DomElement::createNew(DomElement::OPTION);
item->setAttribute("value", boost::lexical_cast<std::string>(i));
item->setProperty(Wt::PropertyInnerHTML, items_[i]);
if ((int)i == currentIndex_)
item->setProperty(Wt::PropertySelected, "true");
element.addChild(item);
}
itemsChanged_ = false;
}
if (selectionChanged_) {
element.setProperty(Wt::PropertySelectedIndex,
boost::lexical_cast<std::string>(currentIndex_));
selectionChanged_ = false;
}
const WSignalInstance_ *s1 = getSignal(SIGNAL(activated(int)));
const WSignalInstance_ *s2 = getSignal(SIGNAL(activated(const std::string)));
if (isConnected(s1) || isConnected(s2))
connect(this, SIGNAL(changed()), this, SLOT(propagateChanged()));
WFormWidget::updateDom(element, all);
renderOk();
}
void WWidgetCanvasPainter::updateContents(std::vector<DomElement *>& result,
WPaintDevice *device)
{
WCanvasPaintDevice *canvasDevice = dynamic_cast<WCanvasPaintDevice *>(device);
if (widget_->sizeChanged_) {
DomElement *canvas = DomElement::getForUpdate('c' + widget_->id(),
DomElement_CANVAS);
canvas->setAttribute("width",
boost::lexical_cast<std::string>(widget_->renderWidth_));
canvas->setAttribute("height",
boost::lexical_cast<std::string>(widget_->renderHeight_));
result.push_back(canvas);
widget_->sizeChanged_ = false;
}
bool domText = canvasDevice->textMethod() == WCanvasPaintDevice::DomText;
DomElement *el
= DomElement::getForUpdate(domText ? 't' + widget_->id() : widget_->id(),
DomElement_DIV);
if (domText)
el->removeAllChildren();
bool hasJsObjects = widget_->jsObjects_.size() > 0;
if (hasJsObjects) {
WStringStream ss;
widget_->jsObjects_.updateJs(ss);
el->callJavaScript(ss.str());
}
canvasDevice->render('c' + widget_->id(), el);
if (hasJsObjects) {
WStringStream ss;
ss << widget_->objJsRef() << ".repaint=function(){";
ss << canvasDevice->recordedJs_.str();
ss << "};";
el->callJavaScript(ss.str());
}
result.push_back(el);
delete device;
}
void WVideo::updateMediaDom(DomElement& element, bool all)
{
WAbstractMedia::updateMediaDom(element, all);
// Video has a few extra attributes...
if (all || sizeChanged_) {
if ((!all) || !width().isAuto())
element.setAttribute("width",
width().isAuto() ? "" : std::to_string((int)width().toPixels()));
if ((!all) || !height().isAuto())
element.setAttribute("height",
height().isAuto() ? "" : std::to_string((int)height().toPixels()));
}
if (all || posterChanged_) {
if ((!all) || posterUrl_ != "") {
element.setAttribute("poster", resolveRelativeUrl(posterUrl_));
}
}
sizeChanged_ = posterChanged_ = false;
}
void WTextArea::updateDom(DomElement& element, bool all)
{
if (element.type() == DomElement_TEXTAREA)
if (contentChanged_ || all) {
element.setProperty(Wt::PropertyValue, content_.toUTF8());
contentChanged_ = false;
}
if (attributesChanged_ || all) {
element.setAttribute("cols",
boost::lexical_cast<std::string>(cols_));
element.setAttribute("rows",
boost::lexical_cast<std::string>(rows_));
attributesChanged_ = false;
}
WFormWidget::updateDom(element, all);
}
DomElement *WPushButton::createDomElement()
{
DomElement *result = DomElement::createNew(DomElement::BUTTON);
result->setAttribute("type", "button"); // default button
result->setId(this);
updateDom(*result, true);
return result;
}
void WSpinBox::updateDom(DomElement& element, bool all)
{
if (all || changed_) {
if (nativeControl()) {
element.setAttribute("min", boost::lexical_cast<std::string>(min_));
element.setAttribute("max", boost::lexical_cast<std::string>(max_));
element.setAttribute("step", boost::lexical_cast<std::string>(step_));
} else {
/* Make sure the JavaScript validator is loaded */
WIntValidator v;
v.javaScriptValidate();
doJavaScript("jQuery.data(" + jsRef() + ", 'obj')"
+ ".setWrapAroundEnabled("
+ (wrapAroundEnabled() ? "true" : "false") + ");");
}
}
WAbstractSpinBox::updateDom(element, all);
}
void WWidgetRasterPainter::updateContents(std::vector<DomElement *>& result,
WPaintDevice *device)
{
WResource *resource = dynamic_cast<WResource *>(device);
DomElement *img
= DomElement::getForUpdate('i' + widget_->id(), DomElement_IMG);
if (widget_->sizeChanged_) {
img->setAttribute("width",
boost::lexical_cast<std::string>(widget_->renderWidth_));
img->setAttribute("height",
boost::lexical_cast<std::string>(widget_->renderHeight_));
widget_->sizeChanged_ = false;
}
img->setAttribute("src", resource->generateUrl());
result.push_back(img);
}
void WSelectionBox::updateDom(DomElement& element, bool all)
{
if (verticalSizeChanged_ || all) {
element.setAttribute("size",
boost::lexical_cast<std::string>(verticalSize_));
verticalSizeChanged_ = false;
}
WComboBox::updateDom(element, all);
renderOk();
}
void WImage::updateDom(DomElement& element, bool all)
{
DomElement *img = &element;
if (all && element.type() == DomElement_SPAN) {
DomElement *map = map_->createSDomElement(WApplication::instance());
element.addChild(map);
img = DomElement::createNew(DomElement_IMG);
img->setId("i" + id());
}
if (flags_.test(BIT_IMAGE_LINK_CHANGED) || all) {
if (!imageLink_.isNull()) {
std::string url = resolveRelativeUrl(imageLink_.url());
WApplication *app = WApplication::instance();
url = app->encodeUntrustedUrl(url);
img->setProperty(Wt::PropertySrc, url);
} else
img->setProperty(Wt::PropertySrc, "#");
flags_.reset(BIT_IMAGE_LINK_CHANGED);
}
if (flags_.test(BIT_ALT_TEXT_CHANGED) || all) {
img->setAttribute("alt", altText_.toUTF8());
flags_.reset(BIT_ALT_TEXT_CHANGED);
}
if (flags_.test(BIT_MAP_CREATED) || (all && map_)) {
img->setAttribute("usemap", '#' + map_->id());
flags_.reset(BIT_MAP_CREATED);
}
WInteractWidget::updateDom(*img, all);
if (&element != img)
element.addChild(img);
}
void WLineEdit::updateDom(DomElement& element, bool all)
{
if (all || flags_.test(BIT_CONTENT_CHANGED)) {
WT_USTRING t = content_;
if (!mask_.empty() && (inputMaskFlags_.test(
InputMaskFlag::KeepMaskWhileBlurred)))
t = displayContent_;
if (!all || !t.empty())
element.setProperty(Wt::Property::Value, t.toUTF8());
flags_.reset(BIT_CONTENT_CHANGED);
}
if (all || flags_.test(BIT_ECHO_MODE_CHANGED)) {
element.setAttribute("type", echoMode_ == EchoMode::Normal
? "text" : "password");
flags_.reset(BIT_ECHO_MODE_CHANGED);
}
if (all || flags_.test(BIT_AUTOCOMPLETE_CHANGED)) {
if (!all || !autoComplete_) {
element.setAttribute("autocomplete",
autoComplete_ == true ? "on" : "off");
}
flags_.reset(BIT_AUTOCOMPLETE_CHANGED);
}
if (all || flags_.test(BIT_TEXT_SIZE_CHANGED)) {
element.setAttribute("size", std::to_string(textSize_));
flags_.reset(BIT_TEXT_SIZE_CHANGED);
}
if (all || flags_.test(BIT_MAX_LENGTH_CHANGED)) {
if (!all || maxLength_ > 0)
element.setAttribute("maxLength", std::to_string(maxLength_));
flags_.reset(BIT_MAX_LENGTH_CHANGED);
}
WFormWidget::updateDom(element, all);
}
void WPushButton::updateDom(DomElement& element, bool all)
{
if (all && element.type() == DomElement_BUTTON)
element.setAttribute("type", "button");
bool updateInnerHtml = !icon_.isNull() && flags_.test(BIT_TEXT_CHANGED);
if (updateInnerHtml || flags_.test(BIT_ICON_CHANGED)
|| (all && !icon_.isNull())) {
DomElement *image = DomElement::createNew(DomElement_IMG);
image->setProperty(PropertySrc, icon_.resolveUrl(WApplication::instance()));
image->setId("im" + formName());
element.insertChildAt(image, 0);
flags_.set(BIT_ICON_RENDERED);
flags_.reset(BIT_ICON_CHANGED);
}
if (flags_.test(BIT_TEXT_CHANGED) || all) {
element.setProperty(Wt::PropertyInnerHTML, text_.formattedText());
flags_.reset(BIT_TEXT_CHANGED);
}
// bool needsUrlResolution = false;
if (flags_.test(BIT_LINK_CHANGED) || all) {
if (element.type() == DomElement_A) {
/* needsUrlResolution = */ WAnchor::renderHRef(this, linkState_, element);
WAnchor::renderHTarget(linkState_, element, all);
} else
renderHRef(element);
flags_.reset(BIT_LINK_CHANGED);
}
if (isCheckable()) {
if (flags_.test(BIT_CHECKED_CHANGED) || all) {
if (!all || flags_.test(BIT_IS_CHECKED)) {
toggleStyleClass("active", flags_.test(BIT_IS_CHECKED), true);
}
flags_.reset(BIT_CHECKED_CHANGED);
}
}
if (!all)
WApplication::instance()->theme()->apply(this, element,
MainElementThemeRole);
WFormWidget::updateDom(element, all);
}
void WAbstractMedia::updateMediaDom(DomElement& element, bool all)
{
// Only if not IE
if (all && alternative_) {
element.setAttribute("onerror",
"""if(event.target.error && event.target.error.code=="
"" "event.target.error.MEDIA_ERR_SRC_NOT_SUPPORTED){"
"" "while (this.hasChildNodes())"
"" "if (" WT_CLASS ".hasTag(this.firstChild,'SOURCE')){"
"" "this.removeChild(this.firstChild);"
"" "}else{"
"" "this.parentNode.insertBefore(this.firstChild, this);"
"" "}"
"" "this.style.display= 'none';"
"""}"
);
}
if (all || flagsChanged_) {
if ((!all) || flags_.test(PlayerOption::Controls))
element.setAttribute("controls",
flags_.test(PlayerOption::Controls) ? "controls" : "");
if ((!all) || flags_.test(PlayerOption::Autoplay))
element.setAttribute("autoplay",
flags_.test(PlayerOption::Autoplay) ? "autoplay" : "");
if ((!all) || flags_.test(PlayerOption::Loop))
element.setAttribute("loop",
flags_.test(PlayerOption::Loop) ? "loop" : "");
}
if (all || preloadChanged_) {
switch (preloadMode_) {
case MediaPreloadMode::None:
element.setAttribute("preload", "none");
break;
default:
case MediaPreloadMode::Auto:
element.setAttribute("preload", "auto");
break;
case MediaPreloadMode::Metadata:
element.setAttribute("preload", "metadata");
break;
}
}
updateEventSignals(element, all);
if (all)
if (alternative_) {
element.addChild(alternative_->createSDomElement(wApp));
}
flagsChanged_ = preloadChanged_ = false;
}
void WAbstractSpinBox::updateDom(DomElement& element, bool all)
{
if (all || changed_) {
if (!all) {
if (!nativeControl())
doJavaScript("jQuery.data(" + jsRef() + ", 'obj')"
".update(" + jsMinMaxStep() + ","
+ boost::lexical_cast<std::string>(decimals()) + ");");
else
setValidator(createValidator());
}
}
changed_ = false;
WLineEdit::updateDom(element, all);
if (all && nativeControl())
element.setAttribute("type", "number");
}
void WWidgetRasterPainter::createContents(DomElement *result,
WPaintDevice *device)
{
std::string wstr = boost::lexical_cast<std::string>(widget_->renderWidth_);
std::string hstr = boost::lexical_cast<std::string>(widget_->renderHeight_);
DomElement *img = DomElement::createNew(DomElement_IMG);
img->setId('i' + widget_->id());
img->setAttribute("width", wstr);
img->setAttribute("height", hstr);
img->setAttribute("class", "unselectable");
img->setAttribute("unselectable", "on");
img->setAttribute("onselectstart", "return false;");
img->setAttribute("onmousedown", "return false;");
WResource *resource = dynamic_cast<WResource *>(device);
img->setAttribute("src", resource->generateUrl());
result->addChild(img);
}
void WAbstractSpinBox::updateDom(DomElement& element, bool all)
{
if (all || changed_) {
if (!all) {
if (!nativeControl())
doJavaScript("jQuery.data(" + jsRef() + ", 'obj')"
".configure("
+ std::to_string(decimals()) + ","
+ prefix().jsStringLiteral() + ","
+ suffix().jsStringLiteral() + ","
+ jsMinMaxStep() + ");");
else
setValidator(std::shared_ptr<WValidator>(createValidator().release()));
}
}
changed_ = false;
WLineEdit::updateDom(element, all);
if (all && nativeControl())
element.setAttribute("type", "number");
}
DomElement *WFileUpload::createDomElement(WApplication *app)
{
DomElement *result = DomElement::createNew(domElementType());
if (result->type() == DomElement_FORM)
result->setId(id());
else
result->setName(id());
EventSignal<> *change = voidEventSignal(CHANGE_SIGNAL, false);
if (fileUploadTarget_) {
DomElement *i = DomElement::createNew(DomElement_IFRAME);
i->setProperty(PropertyClass, "Wt-resource");
i->setProperty(PropertySrc, fileUploadTarget_->url());
i->setName("if" + id());
if (app->environment().agentIsIE()) {
// http://msdn.microsoft.com/en-us/library/ms536474%28v=vs.85%29.aspx
// HTA's (started by mshta.exe) have a different security model than
// a normal web app, and therefore a HTA browser does not allow
// interaction from iframes to the parent window unless this
// attribute is set. If omitted, this causes the 'uploaded()'
// signal to be blocked when a Wt app is executed as a HTA.
i->setAttribute("APPLICATION", "yes");
}
DomElement *form = result;
form->setAttribute("method", "post");
form->setAttribute("action", fileUploadTarget_->url());
form->setAttribute("enctype", "multipart/form-data");
form->setProperty(PropertyStyle, "margin:0;padding:0;display:inline");
form->setProperty(PropertyTarget, "if" + id());
/*
* wrap iframe in an extra span to work around bug in IE which does
* not set the name use DOM methods
*/
DomElement *d = DomElement::createNew(DomElement_SPAN);
d->addChild(i);
form->addChild(d);
DomElement *input = DomElement::createNew(DomElement_INPUT);
input->setAttribute("type", "file");
if (flags_.test(BIT_MULTIPLE))
input->setAttribute("multiple", "multiple");
input->setAttribute("name", "data");
input->setAttribute("size", boost::lexical_cast<std::string>(textSize_));
input->setId("in" + id());
if (!isEnabled())
input->setProperty(Wt::PropertyDisabled, "true");
if (change)
updateSignalConnection(*input, *change, "change", true);
form->addChild(input);
} else {
result->setAttribute("type", "file");
if (flags_.test(BIT_MULTIPLE))
result->setAttribute("multiple", "multiple");
result->setAttribute("size", boost::lexical_cast<std::string>(textSize_));
if (!isEnabled())
result->setProperty(Wt::PropertyDisabled, "true");
if (change)
updateSignalConnection(*result, *change, "change", true);
}
updateDom(*result, true);
flags_.reset(BIT_ENABLE_AJAX);
return result;
}
