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);
}
}
}
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;
}
}
void WPaintedWidget::getDomChanges(std::vector<DomElement *>& result,
WApplication *app)
{
DomElement *e = DomElement::getForUpdate(this, DomElement_DIV);
updateDom(*e, false);
result.push_back(e);
bool createdNew = createPainter();
if (needRepaint_) {
WPaintDevice *device = painter_->getPaintDevice
((repaintFlags_ & PaintUpdate) && !createdNew);
if (renderWidth_ != 0 && renderHeight_ != 0) {
paintEvent(device);
#ifdef WT_TARGET_JAVA
if (device->painter())
device->painter()->end();
#endif // WT_TARGET_JAVA
}
if (createdNew) {
DomElement *canvas = DomElement::getForUpdate('p' + id(), DomElement_DIV);
canvas->removeAllChildren();
painter_->createContents(canvas, device);
result.push_back(canvas);
} else {
painter_->updateContents(result, device);
}
needRepaint_ = false;
repaintFlags_ = 0;
}
}
void WTextEdit::getDomChanges(std::vector<DomElement *>& result,
WApplication *app)
{
/*
* We apply changes directly to the table element, except of the textarea
* contents. Therefore we first update the TABLE element, then collect
* the contentChange to the TEXTAREA element, but reverse the order in
* which they get applied since the load() statement expects the contents
* to be set in the textarea first.
*/
/*
* Problem! ed.render() returns before the element is actually rendered,
* and therefore, the _tbl element may not yet be available.
*
* This causes fail when a text edit is progressively enhanced. The solution
* is to listen for the onInit() event -> we should be able to add a
* wrapping ... .onInit(function(ed) { .... }) around the changes
*/
DomElement *e = DomElement::getForUpdate(formName() + "_tbl",
DomElement_TABLE);
updateDom(*e, false);
WTextArea::getDomChanges(result, app);
result.push_back(e);
}
void WPushButton::getDomChanges(std::vector<DomElement *>& result)
{
if (renderState() == RenderUpdate) {
DomElement *e = DomElement::getForUpdate(this, DomElement::INPUT);
updateDom(*e, false);
result.push_back(e);
}
}
void WComboBox::getDomChanges(std::vector<DomElement *>& result)
{
if (renderState() == RenderUpdate) {
DomElement *e = DomElement::getForUpdate(this, DomElement::SELECT);
updateDom(*e, false);
result.push_back(e);
}
}
DomElement *WScrollArea::createDomElement()
{
DomElement *result = DomElement::createNew(DomElement::DIV);
result->setId(this, true);
updateDom(*result, true);
return result;
}
DomElement *WTable::createDomElement(WApplication *app)
{
bool withIds = !app->environment().agentIsSpiderBot();
DomElement *table = DomElement::createNew(domElementType());
setId(table, app);
DomElement *thead = 0;
if (headerRowCount_ != 0) {
thead = DomElement::createNew(DomElement_THEAD);
if (withIds)
thead->setId(id() + "th");
}
DomElement *tbody = DomElement::createNew(DomElement_TBODY);
if (withIds)
tbody->setId(id() + "tb");
DomElement *colgroup = DomElement::createNew(DomElement_COLGROUP);
for (unsigned col = 0; col < columns_.size(); ++col) {
DomElement *c = DomElement::createNew(DomElement_COL);
if (withIds)
c->setId(columns_[col]->id());
columns_[col]->updateDom(*c, true);
colgroup->addChild(c);
}
table->addChild(colgroup);
flags_.reset(BIT_COLUMNS_CHANGED);
for (unsigned row = 0; row < (unsigned)rowCount(); ++row)
for (unsigned col = 0; col < (unsigned)columnCount(); ++col)
itemAt(row, col).overSpanned = false;
for (unsigned row = 0; row < (unsigned)rowCount(); ++row) {
DomElement *tr = createRowDomElement(row, withIds, app);
if (row < static_cast<unsigned>(headerRowCount_))
thead->addChild(tr);
else
tbody->addChild(tr);
}
rowsAdded_ = 0;
if (thead)
table->addChild(thead);
table->addChild(tbody);
updateDom(*table, true);
flags_.reset(BIT_GRID_CHANGED);
delete rowsChanged_;
rowsChanged_ = 0;
return table;
}
DomElement *WImage::createDomElement()
{
DomElement *result = DomElement::createNew(DomElement::IMG);
result->setId(this);
updateDom(*result, true);
return result;
}
DomElement *WComboBox::createDomElement()
{
DomElement *result = DomElement::createNew(DomElement::SELECT);
result->setId(this, true);
updateDom(*result, true);
return result;
}
void WTextEdit::updateDom(DomElement& element, bool all)
{
WTextArea::updateDom(element, all);
if (element.type() == DomElement_TEXTAREA)
element.removeProperty(PropertyStyleDisplay);
// we are creating the actual element
if (all && element.type() == DomElement_TEXTAREA) {
std::stringstream config;
config << "{";
bool first = true;
for (SettingsMapType::const_iterator it = configurationSettings_.begin();
it != configurationSettings_.end(); ++it) {
if (it->first == "plugins")
continue;
if (!first)
config << ',';
first = false;
config << it->first << ": "
<< Impl::asJSLiteral(it->second, XHTMLUnsafeText);
}
if (!first)
config << ',';
config << "plugins: '" << plugins() << "'";
config <<
",init_instance_callback: obj.init"
"}";
DomElement dummy(DomElement::ModeUpdate, DomElement_TABLE);
updateDom(dummy, true);
element.callJavaScript("(function() { "
"""var obj = $('#" + id() + "').data('obj');"
"""obj.render(" + config.str() + ","
+ jsStringLiteral(dummy.cssStyle()) + ","
+ (changed().isConnected() ? "true" : "false")
+ ");"
"})();");
contentChanged_ = false;
}
if (!all && contentChanged_) {
element.callJavaScript(jsRef() + ".ed.load();");
contentChanged_ = false;
}
}
DomElement *WPushButton::createDomElement()
{
DomElement *result = DomElement::createNew(DomElement::BUTTON);
result->setAttribute("type", "button"); // default button
result->setId(this);
updateDom(*result, true);
return result;
}
DomElement *WPaintedWidget::createDomElement(WApplication *app)
{
createPainter();
DomElement *result = DomElement::createNew(domElementType());
setId(result, app);
DomElement *wrap = result;
if (width().isAuto() && height().isAuto()) {
result->setProperty(PropertyStylePosition, "relative");
wrap = DomElement::createNew(DomElement_DIV);
wrap->setProperty(PropertyStylePosition, "absolute");
wrap->setProperty(PropertyStyleLeft, "0");
wrap->setProperty(PropertyStyleRight, "0");
}
DomElement *canvas = DomElement::createNew(DomElement_DIV);
if (!app->environment().agentIsSpiderBot())
canvas->setId('p' + id());
WPaintDevice *device = painter_->getPaintDevice(false);
//handle the widget correctly when inline and using VML
if (painter_->renderType() == WWidgetPainter::InlineVml && isInline()) {
result->setProperty(PropertyStyle, "zoom: 1;");
canvas->setProperty(PropertyStyleDisplay, "inline");
canvas->setProperty(PropertyStyle, "zoom: 1;");
}
if (renderWidth_ != 0 && renderHeight_ != 0) {
paintEvent(device);
#ifdef WT_TARGET_JAVA
if (device->painter())
device->painter()->end();
#endif // WT_TARGET_JAVA
}
painter_->createContents(canvas, device);
needRepaint_ = false;
wrap->addChild(canvas);
if (wrap != result)
result->addChild(wrap);
updateDom(*result, true);
return result;
}
void WContainerWidget::getDomChanges(std::vector<DomElement *>& result)
{
if (renderState() == RenderUpdate) {
DomElement *e
= DomElement::getForUpdate(this, isInline() ? DomElement::SPAN
: DomElement::DIV);
updateDom(*e, false);
result.push_back(e);
}
renderOk();
}
void WScrollArea::getDomChanges(std::vector<DomElement *>& result)
{
if (renderState() == RenderUpdate) {
DomElement *e = DomElement::getForUpdate(this, DomElement::DIV);
updateDom(*e, false);
result.push_back(e);
}
/*
if (widget_)
widget_->webWidget()->getSDomChanges(result);
*/
}
void WImage::getDomChanges(std::vector<DomElement *>& result,
WApplication *app)
{
if (map_) {
// TODO: check if BIT_MAP_CREATED: then need to replace the whole
// element with a <span><img/><map/></span>. Currently we document
// this as a limitation.
DomElement *e = DomElement::getForUpdate("i" + id(), DomElement_IMG);
updateDom(*e, false);
result.push_back(e);
} else
WInteractWidget::getDomChanges(result, app);
}
void WTable::getDomChanges(std::vector<DomElement *>& result,
WApplication *app)
{
DomElement *e = DomElement::getForUpdate(this, domElementType());
if (!isStubbed() && flags_.test(BIT_GRID_CHANGED)) {
DomElement *newE = createDomElement(app);
e->replaceWith(newE);
} else {
if (rowsChanged_) {
for (std::set<WTableRow *>::iterator i = rowsChanged_->begin();
i != rowsChanged_->end(); ++i) {
DomElement *e2 = DomElement::getForUpdate(*i, DomElement_TR);
(*i)->updateDom(*e2, false);
result.push_back(e2);
}
delete rowsChanged_;
rowsChanged_ = 0;
}
if (rowsAdded_) {
DomElement *etb = DomElement::getForUpdate(id() + "tb",
DomElement_TBODY);
for (unsigned i = 0; i < static_cast<unsigned>(rowsAdded_); ++i) {
DomElement *tr = createRowDomElement(rowCount() - rowsAdded_ + i, true, app);
etb->addChild(tr);
}
result.push_back(etb);
rowsAdded_ = 0;
}
if (flags_.test(BIT_COLUMNS_CHANGED)) {
for (unsigned i = 0; i < columns_.size(); ++i) {
DomElement *e2
= DomElement::getForUpdate(columns_[i], DomElement_COL);
columns_[i]->updateDom(*e2, false);
result.push_back(e2);
}
flags_.reset(BIT_COLUMNS_CHANGED);
}
updateDom(*e, false);
}
result.push_back(e);
}
void WTable::getDomChanges(std::vector<DomElement *>& result)
{
if (renderState() == RenderUpdate) {
DomElement *e = DomElement::getForUpdate(this, DomElement::TABLE);
if (gridChanged_) {
DomElement *newE = createDomElement();
e->replaceWith(newE);
} else {
updateDom(*e, false);
}
result.push_back(e);
}
}
std::string Widget::createExtElement(std::stringstream& alljs,
DomElement *inContainer)
{
if (inContainer) {
updateDom(*inContainer, true);
inContainer->removeProperty(PropertyStyleDisplay);
}
setRendered(false);
alljs << "var " << elVar() << ";"
<< createJS(inContainer)
<< elRef() << "=" << elVar() << ";";
if (isHidden())
alljs << elVar() << ".hide();";
jsUpdates_.clear();
if (!inContainer) {
DomElement *e
= DomElement::updateGiven(elVar() + ".getEl().dom", domElementType());
updateDom(*e, true);
{
EscapeOStream out(alljs);
e->asJavaScript(out, DomElement::Update);
}
delete e;
}
setRendered(true);
return elVar();
}
DomElement *WGroupBox::createDomElement()
{
DomElement *result = DomElement::createNew(DomElement::FIELDSET);
result->setId(this);
DomElement *legend = DomElement::createNew(DomElement::LEGEND);
legend->setId(formName() + "l");
legend->setProperty(Wt::PropertyInnerHTML,
toUTF8(escapeText(title_.value())));
result->addChild(legend);
createDomChildren(*result);
updateDom(*result, true);
return result;
}
DomElement *WGLWidget::createDomElement(WApplication *app)
{
DomElement *result = nullptr;
if (!pImpl_) { // no GL support whatsoever
result = DomElement::createNew(DomElementType::DIV);
result->addChild(alternative_->createSDomElement(app));
webGlNotAvailable_ = true;
} else {
result = DomElement::createNew(domElementType());
repaintGL(GLClientSideRenderer::PAINT_GL | GLClientSideRenderer::RESIZE_GL);
}
setId(result, app);
updateDom(*result, true);
return result;
}
void Widget::getDomChanges(std::vector<DomElement *>& result,
WApplication *app)
{
std::string el = elRef() + ".el.dom";
DomElement *e = DomElement::updateGiven(el, domElementType());
updateExt();
if (!jsUpdates_.empty()) {
e->callJavaScript("var " + elVar() + "=" + elRef() + ";" + jsUpdates_);
jsUpdates_.clear();
}
updateDom(*e, false);
e->removeProperty(PropertyStyleDisplay);
result.push_back(e);
}
DomElement *WTable::createDomElement()
{
//printDebug();
DomElement *table = DomElement::createNew(DomElement::TABLE);
table->setId(this);
DomElement *tbody = DomElement::createNew(DomElement::TBODY);
for (unsigned row = 0; row < (unsigned)numRows(); ++row)
for (unsigned col = 0; col < (unsigned)numColumns(); ++col)
itemAt(row, col).overSpanned = false;
for (unsigned row = 0; row < (unsigned)numRows(); ++row) {
DomElement *tr = DomElement::createNew(DomElement::TR);
tr->setId(rows_[row]);
for (unsigned col = 0; col < (unsigned)numColumns(); ++col) {
WTableRow::TableData& d = itemAt(row, col);
if (!d.overSpanned) {
DomElement *td = d.cell->createSDomElement();
tr->addChild(td);
for (int i = 0; i < d.cell->rowSpan(); ++i)
for (int j = 0; j < d.cell->columnSpan(); ++j)
if (i + j > 0)
itemAt(row + i, col + j).overSpanned = true;
}
}
tbody->addChild(tr);
}
table->addChild(tbody);
updateDom(*table, true);
gridChanged_ = false;
return table;
}
DomElement *
WContainerWidget::createDomElement()
{
DomElement *result;
result = DomElement::createNew(isInline() ?
DomElement::SPAN : DomElement::DIV);
result->setId(this);
if (addedChildren_) {
delete addedChildren_;
addedChildren_ = 0;
}
updateDom(*result, true);
createDomChildren(*result);
renderOk();
return result;
}
void WContainerWidget::getDomChanges(std::vector<DomElement *>& result,
WApplication *app)
{
DomElement *e = DomElement::getForUpdate(this, domElementType());
#ifndef WT_NO_LAYOUT
if (!app->session()->renderer().preLearning()) {
if (flags_.test(BIT_LAYOUT_NEEDS_RERENDER)) {
e->removeAllChildren(firstChildIndex());
createDomChildren(*e, app);
flags_.reset(BIT_LAYOUT_NEEDS_RERENDER);
flags_.reset(BIT_LAYOUT_NEEDS_UPDATE);
}
}
#endif // WT_NO_LAYOUT
updateDomChildren(*e, app);
updateDom(*e, false);
result.push_back(e);
}
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;
}
