bool WText::RichText::checkWellFormed()
{
if (format == XHTMLText && text.literal()) {
return removeScript(text);
} else
return true;
}
void WTemplate::setTemplateText(const WString& text, TextFormat textFormat)
{
text_ = text;
if (textFormat == XHTMLText && text_.literal()) {
if (!removeScript(text_))
text_ = escapeText(text_, true);
} else if (textFormat == PlainText)
text_ = escapeText(text_, true);
if (!text_.literal() && !text_.isLanguage())
{
WLocalizedStrings *ls = 0;
WApplication *app = WApplication::instance();
if (app)
ls = app->localizedStrings();
if (!ls) {
WServer *server = WServer::instance();
if (server)
ls = server->localizedStrings();
}
ls->loadTemplateStyleSheet(text_.key(), text_.moduleAuthorId());
}
changed_ = true;
repaint(RepaintSizeAffected);
}
bool WText::checkWellFormed()
{
if (textFormat_ == XHTMLText && text_.literal()) {
return removeScript(text_);
} else
return true;
}
void ScriptTarget::clearScripts()
{
while (_scripts)
{
removeScript(_scripts);
}
}
void WTemplate::format(std::ostream& result, const WString& s,
TextFormat textFormat)
{
WString v = s;
if (textFormat == XHTMLText) {
if (!removeScript(v))
v = escapeText(v, true);
} else if (textFormat == PlainText)
v = escapeText(v, true);
result << v.toUTF8();
}
void WTemplate::setTemplateText(const WString& text, TextFormat textFormat)
{
text_ = text;
if (textFormat == XHTMLText && text_.literal()) {
if (!removeScript(text_))
text_ = escapeText(text_, true);
} else if (textFormat == PlainText)
text_ = escapeText(text_, true);
changed_ = true;
repaint(RepaintInnerHtml);
}
int16 Op_RemoveProc() {
int idx;
int overlay;
idx = popVar();
overlay = popVar();
if (!overlay) {
overlay = currentScriptPtr->overlayNumber;
}
removeScript(overlay, idx, &procHead);
return (0);
}
bool ScriptTarget::removeScript(const char* path)
{
GP_ASSERT(path);
ScriptEntry* se = _scripts;
while (se)
{
if (strcmp(se->script->getPath(), path) == 0 && se->script->getScope() == Script::PROTECTED)
{
removeScript(se);
return true;
}
se = se->next;
}
return false;
}
void WProgressBar::updateDom(DomElement& element, bool all)
{
DomElement *bar = 0, *label = 0;
if (all) {
WApplication *app = WApplication::instance();
bar = DomElement::createNew(DomElement_DIV);
bar->setId("bar" + id());
bar->setProperty(PropertyClass, valueStyleClass_);
app->theme()->apply(this, *bar, ProgressBarBarRole);
label = DomElement::createNew(DomElement_DIV);
label->setId("lbl" + id());
app->theme()->apply(this, *label, ProgressBarLabelRole);
}
if (changed_ || all) {
if (!bar)
bar = DomElement::getForUpdate("bar" + id(), DomElement_DIV);
if (!label)
label = DomElement::getForUpdate("lbl" + id(), DomElement_DIV);
bar->setProperty(PropertyStyleWidth,
boost::lexical_cast<std::string>(percentage()) + "%");
WString s = text();
removeScript(s);
label->setProperty(PropertyInnerHTML, s.toUTF8());
changed_ = false;
}
if (bar)
element.addChild(bar);
if (label)
element.addChild(label);
WInteractWidget::updateDom(element, all);
}
void WTemplate::format(std::ostream& result, const WString& s,
TextFormat textFormat)
{
if (textFormat == XHTMLText) {
WString v = s;
if (removeScript(v)) {
result << v.toUTF8();
return;
} else {
EscapeOStream sout(result);
sout.append(v.toUTF8(), *plainTextNewLineEscStream_);
return;
}
} else if (textFormat == PlainText) {
EscapeOStream sout(result);
sout.append(s.toUTF8(), *plainTextNewLineEscStream_);
return;
}
result << s.toUTF8();
}
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);
}
}
int freeOverlay(int overlayIdx) {
ovlDataStruct *ovlDataPtr;
int i;
if (overlayTable[overlayIdx].alreadyLoaded == 0)
return -4;
overlayTable[overlayIdx].alreadyLoaded = 0;
ovlDataPtr = overlayTable[overlayIdx].ovlData;
if (!ovlDataPtr)
return -4;
/*
if (overlayTable[overlayIdx].var1E) {
MemFree(overlayTable[overlayIdx].var1E);
overlayTable[overlayIdx].var1E = NULL;
}
if (overlayTable[overlayIdx].var16) {
MemFree(overlayTable[overlayIdx].var16);
overlayTable[overlayIdx].var16 = NULL;
} */
removeScript(overlayIdx, -1, &procHead);
removeScript(overlayIdx, -1, &procHead);
removeScript(overlayIdx, -1, &relHead);
removeScript(overlayIdx, -1, &relHead);
if (ovlDataPtr->stringTable) {
for (i = 0; i < ovlDataPtr->numStrings; ++i)
MemFree(ovlDataPtr->stringTable[i].string);
MemFree(ovlDataPtr->stringTable);
}
if (ovlDataPtr->arrayProc) {
ovlData3Struct *tempPtr = ovlDataPtr->arrayProc;
for (i = 0; i < ovlDataPtr->numProc; ++i, ++tempPtr)
MemFree(tempPtr->dataPtr);
MemFree(ovlDataPtr->arrayProc);
}
if (ovlDataPtr->ptr1) {
ovlData3Struct *tempPtr = (ovlData3Struct *)ovlDataPtr->ptr1;
for (i = 0; i < ovlDataPtr->numRel; ++i, ++tempPtr)
MemFree(tempPtr->dataPtr);
MemFree(ovlDataPtr->ptr1);
}
MemFree(ovlDataPtr->arraySymbGlob);
MemFree(ovlDataPtr->arrayNameSymbGlob);
MemFree(ovlDataPtr->data4Ptr);
MemFree(ovlDataPtr->arrayMsgRelHeader);
MemFree(ovlDataPtr->ptr8);
MemFree(ovlDataPtr->arrayObject);
MemFree(ovlDataPtr->arrayObjVar);
MemFree(ovlDataPtr->arrayStates);
MemFree(ovlDataPtr->nameVerbGlob);
MemFree(ovlDataPtr->arrayNameObj);
MemFree(ovlDataPtr->arrayRelocGlob);
MemFree(ovlDataPtr->arrayNameRelocGlob);
MemFree(ovlDataPtr);
overlayTable[overlayIdx].ovlData = NULL;
debug(1, "freeOverlay: finish !");
return 0;
}
DlgPrefController::DlgPrefController(QWidget* parent, Controller* controller,
ControllerManager* controllerManager,
UserSettingsPointer pConfig)
: DlgPreferencePage(parent),
m_pConfig(pConfig),
m_pControllerManager(controllerManager),
m_pController(controller),
m_pDlgControllerLearning(NULL),
m_pInputTableModel(NULL),
m_pInputProxyModel(NULL),
m_pOutputTableModel(NULL),
m_pOutputProxyModel(NULL),
m_bDirty(false) {
m_ui.setupUi(this);
initTableView(m_ui.m_pInputMappingTableView);
initTableView(m_ui.m_pOutputMappingTableView);
initTableView(m_ui.m_pScriptsTableWidget);
connect(m_pController, SIGNAL(presetLoaded(ControllerPresetPointer)),
this, SLOT(slotPresetLoaded(ControllerPresetPointer)));
// TODO(rryan): Eh, this really isn't thread safe but it's the way it's been
// since 1.11.0. We shouldn't be calling Controller methods because it lives
// in a different thread. Booleans (like isOpen()) are fine but a complex
// object like a preset involves QHash's and other data structures that
// really don't like concurrent access.
ControllerPresetPointer pPreset = m_pController->getPreset();
slotPresetLoaded(pPreset);
m_ui.labelDeviceName->setText(m_pController->getName());
QString category = m_pController->getCategory();
if (!category.isEmpty()) {
m_ui.labelDeviceCategory->setText(category);
} else {
m_ui.labelDeviceCategory->hide();
}
// When the user picks a preset, load it.
connect(m_ui.comboBoxPreset, SIGNAL(activated(int)),
this, SLOT(slotLoadPreset(int)));
// When the user toggles the Enabled checkbox, toggle.
connect(m_ui.chkEnabledDevice, SIGNAL(clicked(bool)),
this, SLOT(slotEnableDevice(bool)));
// Connect our signals to controller manager.
connect(this, SIGNAL(openController(Controller*)),
m_pControllerManager, SLOT(openController(Controller*)));
connect(this, SIGNAL(closeController(Controller*)),
m_pControllerManager, SLOT(closeController(Controller*)));
connect(this, SIGNAL(loadPreset(Controller*, ControllerPresetPointer)),
m_pControllerManager, SLOT(loadPreset(Controller*, ControllerPresetPointer)));
// Input mappings
connect(m_ui.btnAddInputMapping, SIGNAL(clicked()),
this, SLOT(addInputMapping()));
connect(m_ui.btnRemoveInputMappings, SIGNAL(clicked()),
this, SLOT(removeInputMappings()));
connect(m_ui.btnLearningWizard, SIGNAL(clicked()),
this, SLOT(showLearningWizard()));
connect(m_ui.btnClearAllInputMappings, SIGNAL(clicked()),
this, SLOT(clearAllInputMappings()));
// Output mappings
connect(m_ui.btnAddOutputMapping, SIGNAL(clicked()),
this, SLOT(addOutputMapping()));
connect(m_ui.btnRemoveOutputMappings, SIGNAL(clicked()),
this, SLOT(removeOutputMappings()));
connect(m_ui.btnClearAllOutputMappings, SIGNAL(clicked()),
this, SLOT(clearAllOutputMappings()));
// Scripts
connect(m_ui.m_pScriptsTableWidget, SIGNAL(cellChanged(int, int)),
this, SLOT(slotDirty()));
connect(m_ui.btnAddScript, SIGNAL(clicked()),
this, SLOT(addScript()));
connect(m_ui.btnRemoveScript, SIGNAL(clicked()),
this, SLOT(removeScript()));
connect(m_ui.btnOpenScript, SIGNAL(clicked()),
this, SLOT(openScript()));
}
void ScriptTarget::removeScriptCallback(const Event* event, const char* function)
{
// Parse the script name (if it exists) and function out
std::string scriptPath, func;
splitURL(function, &scriptPath, &func);
if (func.length() == 0)
{
// The url doesn't reference a script, only a function
func = scriptPath;
scriptPath = "";
}
// Find the script entry for this callback
ScriptEntry* scriptEntry = NULL;
if (!scriptPath.empty())
{
ScriptEntry* se = _scripts;
while (se)
{
if (scriptPath == se->script->getPath() && se->script->getScope() == Script::GLOBAL)
{
scriptEntry = se;
break;
}
se = se->next;
}
}
Script* script = scriptEntry ? scriptEntry->script : NULL;
// Remove any registered callback functions that match the specified one
int removedCallbacks = 0;
int totalCallbacks = 0;
if (_scriptCallbacks)
{
std::map<const Event*, std::vector<CallbackFunction>>::iterator itr = _scriptCallbacks->begin();
for (; itr != _scriptCallbacks->end(); ++itr)
{
// Erase matching callback functions for this event
bool forEvent = itr->first == event;
std::vector<CallbackFunction>& callbacks = itr->second;
std::vector<CallbackFunction>::iterator itr2 = callbacks.begin();
while (itr2 != callbacks.end())
{
if (itr2->script == script)
{
++totalCallbacks; // sum total number of callbacks found for this script
if (forEvent && itr2->function == func)
{
itr2 = callbacks.erase(itr2);
++removedCallbacks; // sum number of callbacks removed
}
else
++itr2;
}
}
}
}
// Cleanup the script if there are no remaining callbacks for it
if (scriptEntry && (totalCallbacks - removedCallbacks) <= 0)
{
removeScript(scriptEntry);
}
}
