/*
* Generate the API file.
*/
void generateAPI(sipSpec *pt, moduleDef *mod, const char *apiFile)
{
overDef *od;
classDef *cd;
FILE *fp;
/* Generate the file. */
if ((fp = fopen(apiFile, "w")) == NULL)
fatal("Unable to create file \"%s\"\n", apiFile);
apiEnums(pt, mod, NULL, fp);
apiVars(pt, mod, NULL, fp);
for (od = mod->overs; od != NULL; od = od->next)
{
if (od->common->module != mod)
continue;
if (od->common->slot != no_slot)
continue;
apiOverload(pt, mod, NULL, od, fp);
}
for (cd = pt->classes; cd != NULL; cd = cd->next)
{
ctorDef *ct;
if (cd->iff->module != mod)
continue;
if (isExternal(cd))
continue;
apiEnums(pt, mod, cd, fp);
apiVars(pt, mod, cd, fp);
for (ct = cd->ctors; ct != NULL; ct = ct->next)
{
if (isPrivateCtor(ct))
continue;
apiCtor(pt, mod, cd, ct, fp);
}
for (od = cd->overs; od != NULL; od = od->next)
{
if (isPrivate(od))
continue;
if (od->common->slot != no_slot)
continue;
apiOverload(pt, mod, cd, od, fp);
}
}
fclose(fp);
}
void Window::notifyRequestedOpenUrl(const QUrl &url, OpenHints hints)
{
if (isPrivate())
{
hints |= PrivateOpen;
}
emit requestedOpenUrl(url, hints);
}
void WebContentsWidget::updateFind(bool backwards)
{
if (m_quickFindTimer != 0)
{
killTimer(m_quickFindTimer);
m_quickFindTimer = startTimer(2000);
}
if (sender() && sender()->objectName() == QLatin1String("findPreviousButton"))
{
backwards = true;
}
FindFlags flags;
if (backwards)
{
flags |= BackwardFind;
}
if (m_ui->caseSensitiveButton->isChecked())
{
flags |= CaseSensitiveFind;
}
QPalette palette = parentWidget()->palette();
const bool found = m_webWidget->find(m_ui->findLineEdit->text(), flags);
if (!m_ui->findLineEdit->text().isEmpty())
{
if (found)
{
palette.setColor(QPalette::Base, QColor(QLatin1String("#CEF6DF")));
}
else
{
palette.setColor(QPalette::Base, QColor(QLatin1String("#F1E7E4")));
}
}
m_ui->findLineEdit->setPalette(palette);
m_ui->findNextButton->setEnabled(found);
m_ui->findPreviousButton->setEnabled(found);
if (sender() && sender()->objectName() == QLatin1String("caseSensitiveButton"))
{
m_webWidget->find(m_ui->findLineEdit->text(), (flags | BackwardFind));
}
if (m_ui->findWidget->isVisible() && !isPrivate())
{
m_quickFindQuery = m_ui->findLineEdit->text();
}
updateFindHighlight();
}
void WebContentsWidget::notifyRequestedOpenUrl(const QUrl &url, OpenHints hints)
{
if (isPrivate())
{
hints |= PrivateOpen;
}
emit requestedOpenUrl(url, hints);
}
QIcon QtWebKitWebWidget::getIcon() const
{
if (isPrivate())
{
return Utils::getIcon(QLatin1String("tab-private"));
}
const QIcon icon = m_webView->icon();
return (icon.isNull() ? Utils::getIcon(QLatin1String("tab")) : icon);
}
WebWidget* QtWebKitWebWidget::clone(ContentsWidget *parent)
{
QtWebKitWebWidget *widget = new QtWebKitWebWidget(isPrivate(), parent);
widget->setDefaultTextEncoding(getDefaultTextEncoding());
widget->setQuickSearchEngine(m_searchEngine);
widget->setUrl(getUrl());
widget->setHistory(getHistory());
widget->setZoom(getZoom());
return widget;
}
// public
bool IPAddressV4::isNonroutable() const {
auto ip = toLongHBO();
return isPrivate() ||
(ip <= 0x00FFFFFF) || // 0.0.0.0-0.255.255.255
(ip >= 0xC0000000 && ip <= 0xC00000FF) || // 192.0.0.0-192.0.0.255
(ip >= 0xC0000200 && ip <= 0xC00002FF) || // 192.0.2.0-192.0.2.255
(ip >= 0xC6120000 && ip <= 0xC613FFFF) || // 198.18.0.0-198.19.255.255
(ip >= 0xC6336400 && ip <= 0xC63364FF) || // 198.51.100.0-198.51.100.255
(ip >= 0xCB007100 && ip <= 0xCB0071FF) || // 203.0.113.0-203.0.113.255
(ip >= 0xE0000000 && ip <= 0xFFFFFFFF); // 224.0.0.0-255.255.255.255
}
void
InputParameters::checkParams(const std::string & parsing_syntax)
{
std::string l_prefix = this->have_parameter<std::string>("_object_name") ? this->get<std::string>("_object_name") : parsing_syntax;
std::ostringstream oss;
// Required parameters
for (InputParameters::const_iterator it = this->begin(); it != this->end(); ++it)
{
if (!isParamValid(it->first) && isParamRequired(it->first))
{
// The parameter is required but missing
if (oss.str().empty())
oss << "The following required parameters are missing:" << std::endl;
oss << l_prefix << "/" << it->first << std::endl;
oss << "\tDoc String: \"" + getDocString(it->first) + "\"" << std::endl;
}
}
// Range checked parameters
for (InputParameters::const_iterator it = this->begin(); it != this->end(); ++it)
{
std::string long_name(l_prefix + "/" + it->first);
dynamicCastRangeCheck(Real, Real, long_name, it->first, it->second, oss);
dynamicCastRangeCheck(int, long, long_name, it->first, it->second, oss);
dynamicCastRangeCheck(long, long, long_name, it->first, it->second, oss);
dynamicCastRangeCheck(unsigned int, long, long_name, it->first, it->second, oss);
}
if (!oss.str().empty())
mooseError(oss.str());
// Controllable parameters
for (std::set<std::string>::const_iterator it = _controllable_params.begin(); it != _controllable_params.end(); ++it)
{
// Check that parameter is valid
if (!isParamValid(*it))
mooseError("The parameter '" << *it << "' is not a valid parameter for the object " << l_prefix << " thus cannot be marked as controllable.");
if (isPrivate(*it))
mooseError("The parameter, '" << *it << "', in " << l_prefix << " is a private parameter and cannot be marked as controllable");
checkMooseType(NonlinearVariableName, *it);
checkMooseType(AuxVariableName, *it);
checkMooseType(VariableName, *it);
checkMooseType(BoundaryName, *it);
checkMooseType(SubdomainName, *it);
checkMooseType(PostprocessorName, *it);
checkMooseType(VectorPostprocessorName, *it);
checkMooseType(UserObjectName, *it);
checkMooseType(MaterialPropertyName, *it);
}
}
void
InputParameters::applyParameters(const InputParameters & common)
{
// Disable the display of deprecated message when applying common parameters, this avoids a dump of messages
_show_deprecated_message = false;
// Loop through the common parameters
for (InputParameters::const_iterator it = common.begin(); it != common.end(); ++it)
{
// Common parameter name
const std::string & common_name = it->first;
// Extract the properties from the local parameter for the current common parameter name
bool local_exist = _values.find(common_name) != _values.end();
bool local_set = _set_by_add_param.find(common_name) == _set_by_add_param.end();
bool local_priv = isPrivate(common_name);
bool local_valid = isParamValid(common_name);
// Extract the properties from the common parameter
bool common_valid = common.isParamValid(common_name);
bool common_priv = common.isPrivate(common_name);
/* In order to apply common parameter 4 statements must be satisfied
* (1) A local parameter must exist with the same name as common parameter
* (2) Common parameter must valid
* (3) Local parameter must be invalid OR not have been set from its default
* (4) Neither may be private
*/
if ( local_exist && common_valid && (!local_valid || !local_set) && (!common_priv || !local_priv))
{
delete _values[common_name];
_values[common_name] = it->second->clone();
set_attributes(common_name, false);
}
}
// Loop through the coupled variables
for (std::set<std::string>::const_iterator it = common.coupledVarsBegin(); it != common.coupledVarsEnd(); ++it)
{
// If the local parameters has a coupled variable, populate it with the value from the common parameters
const std::string var_name = *it;
if (hasCoupledValue(var_name))
{
if (common.hasDefaultCoupledValue(var_name))
addCoupledVar(var_name, common.defaultCoupledValue(var_name), common.getDocString(var_name));
else
addCoupledVar(var_name, common.getDocString(var_name));
}
}
// Enable deprecated message printing
_show_deprecated_message = true;
}
void Window::search(const QString &query, const QString &engine)
{
WebContentsWidget *widget = qobject_cast<WebContentsWidget*>(m_contentsWidget);
if (!widget)
{
widget = new WebContentsWidget(isPrivate(), NULL, this);
setContentsWidget(widget);
}
widget->search(query, engine);
}
void UnconventionalAssignOperatorCheck::registerMatchers(
ast_matchers::MatchFinder *Finder) {
// Only register the matchers for C++; the functionality currently does not
// provide any benefit to other languages, despite being benign.
if (!getLangOpts().CPlusPlus)
return;
const auto HasGoodReturnType = cxxMethodDecl(returns(lValueReferenceType(
pointee(unless(isConstQualified()),
anyOf(autoType(), hasDeclaration(equalsBoundNode("class")))))));
const auto IsSelf = qualType(
anyOf(hasDeclaration(equalsBoundNode("class")),
referenceType(pointee(hasDeclaration(equalsBoundNode("class"))))));
const auto IsAssign =
cxxMethodDecl(unless(anyOf(isDeleted(), isPrivate(), isImplicit())),
hasName("operator="), ofClass(recordDecl().bind("class")))
.bind("method");
const auto IsSelfAssign =
cxxMethodDecl(IsAssign, hasParameter(0, parmVarDecl(hasType(IsSelf))))
.bind("method");
Finder->addMatcher(
cxxMethodDecl(IsAssign, unless(HasGoodReturnType)).bind("ReturnType"),
this);
const auto BadSelf = referenceType(
anyOf(lValueReferenceType(pointee(unless(isConstQualified()))),
rValueReferenceType(pointee(isConstQualified()))));
Finder->addMatcher(
cxxMethodDecl(IsSelfAssign,
hasParameter(0, parmVarDecl(hasType(BadSelf))))
.bind("ArgumentType"),
this);
Finder->addMatcher(
cxxMethodDecl(IsSelfAssign, anyOf(isConst(), isVirtual())).bind("cv"),
this);
const auto IsBadReturnStatement = returnStmt(unless(has(ignoringParenImpCasts(
anyOf(unaryOperator(hasOperatorName("*"), hasUnaryOperand(cxxThisExpr())),
cxxOperatorCallExpr(argumentCountIs(1),
callee(unresolvedLookupExpr()),
hasArgument(0, cxxThisExpr())))))));
const auto IsGoodAssign = cxxMethodDecl(IsAssign, HasGoodReturnType);
Finder->addMatcher(returnStmt(IsBadReturnStatement, forFunction(IsGoodAssign))
.bind("returnStmt"),
this);
}
void print_access(u2 flags) {
if(isPublic(flags))
printf("public ");
if(isPrivate(flags))
printf("private ");
if(isProtected(flags))
printf("protected ");
if(isFinal(flags))
printf("final ");
if(isAbstract(flags))
printf("abstract ");
if(isStatic(flags))
printf("static ");
}
int UtlCryptoKeyRsa::decrypt(const unsigned char* pSrc,
int srcLen,
unsigned char* pDest,
int* pDestLen) const
{
if (isPrivate())
return decryptPrivate(pSrc, srcLen, pDest, pDestLen);
else if (isPublic())
return decryptPublic(pSrc, srcLen, pDest, pDestLen);
if (pDestLen)
*pDestLen = 0;
return 0; // TODO: Set lastError?
}
bool Namespace::EqualTo(const Namespace* other) const
{
if (isPrivate() || other->isPrivate())
{
// one of these namespaces is private, so compare using object identity
return this == other;
}
else
{
// both are public, so compare using uri's. they are intern'ed so we
// can do a fast pointer compare.
return m_uri == other->m_uri && m_api==other->m_api;
}
}
void Window::search(const QString &query, const QString &engine)
{
WebContentsWidget *widget = qobject_cast<WebContentsWidget*>(m_contentsWidget);
if (!widget)
{
widget = new WebContentsWidget(isPrivate(), NULL, this);
setContentsWidget(widget);
}
m_ui->addressWidget->clearFocus();
widget->search(query, engine);
m_ui->addressWidget->setUrl(getUrl());
}
/*
* Generate the XML for a function.
*/
static void xmlFunction(sipSpec *pt, classDef *scope, memberDef *md,
overDef *oloads, int indent, FILE *fp)
{
overDef *od;
const char *default_str = "default=\"1\" ";
for (od = oloads; od != NULL; od = od->next)
{
int isstat;
classDef *xtnds;
if (od->common != md)
continue;
if (isPrivate(od))
continue;
if (isSignal(od))
{
xmlIndent(indent, fp);
fprintf(fp, "<Signal %sname=\"", default_str);
prScopedPythonName(fp, scope, md->pyname->text);
fprintf(fp, "\" sig=\"");
xmlCppSignature(fp, od);
fprintf(fp, "\"/>\n");
default_str = "";
continue;
}
xtnds = NULL;
isstat = (scope == NULL || scope->iff->type == namespace_iface || isStatic(od));
if (scope == NULL && md->slot != no_slot && od->pysig.args[0].atype == class_type)
{
xtnds = od->pysig.args[0].u.cd;
isstat = FALSE;
}
if (xmlOverload(pt, scope, md, od, xtnds, isstat, FALSE, indent, fp))
xmlOverload(pt, scope, md, od, xtnds, isstat, TRUE, indent, fp);
}
}
int WindowsManager::getWindowCount(bool onlyPrivate) const
{
if (!onlyPrivate || isPrivate())
{
return m_mainWindow->getTabBar()->count();
}
int amount = 0;
for (int i = 0; i < m_mainWindow->getTabBar()->count(); ++i)
{
if (getWindowByIndex(i)->isPrivate())
{
++amount;
}
}
return amount;
}
void QtWebKitWebWidget::pageLoadFinished(bool ok)
{
if (!m_isLoading)
{
return;
}
m_isLoading = false;
m_thumbnail = QPixmap();
m_networkAccessManager->resetStatistics();
if (m_actions.contains(ReloadOrStopAction))
{
QAction *action = getAction(ReloadOrStopAction);
ActionsManager::setupLocalAction(action, QLatin1String("Reload"));
action->setShortcut(QKeySequence());
}
if (!isPrivate())
{
if (ok)
{
SessionsManager::markSessionModified();
if (m_historyEntry >= 0)
{
HistoryManager::updateEntry(m_historyEntry, getUrl(), m_webView->title(), m_webView->icon());
}
}
else if (m_historyEntry >= 0)
{
HistoryManager::removeEntry(m_historyEntry);
}
}
emit loadingChanged(false);
}
struct visiMatch *visiSearch(struct sqlConnection *conn, char *searchString)
/* visiSearch - return list of images that match searchString sorted
* by how well they match. This will search most fields in the
* database. */
{
char *dupe = cloneString(searchString);
struct trix *trix = trixOpen("visiGeneData/visiGene.ix");
struct trixSearchResult *tsrList, *tsr;
struct visiMatch *matchList = NULL, *match;
int wordCount = chopByWhite(dupe, NULL, 0);
char **words;
boolean hasWild;
struct hash *privateHash = makePrivateHash(conn);
tolowers(dupe);
hasWild = (strchr(searchString, '*') != NULL);
if (hasWild)
stripChar(dupe, '*');
AllocArray(words, wordCount);
chopByWhite(dupe, words, wordCount);
/* if (wordCount != 1 ||
(matchList = matchGeneName(conn, words[0],privateHash)) == NULL) */
{
tsrList = trixSearch(trix, wordCount, words, hasWild);
for (tsr = tsrList; tsr != NULL; tsr = tsr->next)
{
if (!isPrivate(conn, privateHash, tsr->itemId))
{
AllocVar(match);
match->imageId = sqlUnsigned(tsr->itemId);
slAddHead(&matchList, match);
}
}
trixSearchResultFreeList(&tsrList);
trixClose(&trix);
slReverse(&matchList);
}
freeMem(dupe);
return matchList;
}
void NewDeleteOverloadsCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus)
return;
// Match all operator new and operator delete overloads (including the array
// forms). Do not match implicit operators, placement operators, or
// deleted/private operators.
//
// Technically, trivially-defined operator delete seems like a reasonable
// thing to also skip. e.g., void operator delete(void *) {}
// However, I think it's more reasonable to warn in this case as the user
// should really be writing that as a deleted function.
Finder->addMatcher(
functionDecl(unless(anyOf(isImplicit(), isPlacementOverload(),
isDeleted(), cxxMethodDecl(isPrivate()))),
anyOf(hasOverloadedOperatorName("new"),
hasOverloadedOperatorName("new[]"),
hasOverloadedOperatorName("delete"),
hasOverloadedOperatorName("delete[]")))
.bind("func"),
this);
}
void QtWebKitWebWidget::pageLoadStarted()
{
m_isLoading = true;
m_thumbnail = QPixmap();
if (m_actions.contains(RewindBackAction))
{
getAction(RewindBackAction)->setEnabled(getAction(GoBackAction)->isEnabled());
}
if (m_actions.contains(RewindForwardAction))
{
getAction(RewindForwardAction)->setEnabled(getAction(GoForwardAction)->isEnabled());
}
if (m_actions.contains(ReloadOrStopAction))
{
QAction *action = getAction(ReloadOrStopAction);
ActionsManager::setupLocalAction(action, QLatin1String("Stop"));
action->setShortcut(QKeySequence());
action->setEnabled(true);
}
if (!isPrivate())
{
SessionsManager::markSessionModified();
m_historyEntry = HistoryManager::addEntry(getUrl(), m_webView->title(), m_webView->icon(), m_isTyped);
m_isTyped = false;
}
emit loadingChanged(true);
emit statusMessageChanged(QString());
}
result_t PKey::sign(Buffer_base *data, int32_t alg, obj_ptr<Buffer_base> &retVal,
AsyncEvent *ac)
{
if (!ac)
return CHECK_ERROR(CALL_E_NOSYNC);
result_t hr;
bool priv;
hr = isPrivate(priv);
if (hr < 0)
return hr;
if (!priv)
return CHECK_ERROR(CALL_E_INVALID_CALL);
int32_t ret;
std::string str;
std::string output;
size_t olen;
data->toString(str);
output.resize(MBEDTLS_PREMASTER_SIZE);
//alg=0~9 see https://tls.mbed.org/api/md_8h.html enum mbedtls_md_type_t
ret = mbedtls_pk_sign(&m_key, (mbedtls_md_type_t)alg,
(const unsigned char *)str.c_str(), str.length(),
(unsigned char *)&output[0], &olen,
mbedtls_ctr_drbg_random, &g_ssl.ctr_drbg);
if (ret != 0)
return CHECK_ERROR(_ssl::setError(ret));
output.resize(olen);
retVal = new Buffer(output);
return 0;
}
result_t PKey::exportDer(obj_ptr<Buffer_base> &retVal)
{
result_t hr;
bool priv;
hr = isPrivate(priv);
if (hr < 0)
return hr;
int ret;
std::string buf;
buf.resize(8192);
if (priv)
ret = pk_write_key_der(&m_key, (unsigned char *)&buf[0], buf.length());
else
ret = pk_write_pubkey_der(&m_key, (unsigned char *)&buf[0], buf.length());
if (ret < 0)
return CHECK_ERROR(_ssl::setError(ret));
retVal = new Buffer(buf.substr(buf.length() - ret));
return 0;
}
result_t PKey::sign(Buffer_base *data, obj_ptr<Buffer_base> &retVal,
exlib::AsyncEvent *ac)
{
if (switchToAsync(ac))
return CHECK_ERROR(CALL_E_NOSYNC);
result_t hr;
bool priv;
hr = isPrivate(priv);
if (hr < 0)
return hr;
if (!priv)
return CHECK_ERROR(CALL_E_INVALID_CALL);
int ret;
std::string str;
std::string output;
size_t olen;
data->toString(str);
output.resize(POLARSSL_PREMASTER_SIZE);
ret = pk_sign(&m_key, POLARSSL_MD_NONE,
(const unsigned char *)str.c_str(), str.length(),
(unsigned char *)&output[0], &olen,
ctr_drbg_random, &g_ssl.ctr_drbg);
if (ret != 0)
return CHECK_ERROR(_ssl::setError(ret));
output.resize(olen);
retVal = new Buffer(output);
return 0;
}
void Window::notifyRequestedOpenUrl(const QUrl &url, bool background, bool newWindow)
{
emit requestedOpenUrl(url, isPrivate(), background, newWindow);
}
void UseEmplaceCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus11)
return;
// FIXME: Bunch of functionality that could be easily added:
// + add handling of `push_front` for std::forward_list, std::list
// and std::deque.
// + add handling of `push` for std::stack, std::queue, std::priority_queue
// + add handling of `insert` for stl associative container, but be careful
// because this requires special treatment (it could cause performance
// regression)
// + match for emplace calls that should be replaced with insertion
// + match for make_pair calls.
auto callPushBack = cxxMemberCallExpr(
hasDeclaration(functionDecl(hasName("push_back"))),
on(hasType(cxxRecordDecl(hasAnyName(SmallVector<StringRef, 5>(
ContainersWithPushBack.begin(), ContainersWithPushBack.end()))))));
// We can't replace push_backs of smart pointer because
// if emplacement fails (f.e. bad_alloc in vector) we will have leak of
// passed pointer because smart pointer won't be constructed
// (and destructed) as in push_back case.
auto isCtorOfSmartPtr = hasDeclaration(cxxConstructorDecl(ofClass(hasAnyName(
SmallVector<StringRef, 5>(SmartPointers.begin(), SmartPointers.end())))));
// Bitfields binds only to consts and emplace_back take it by universal ref.
auto bitFieldAsArgument = hasAnyArgument(
ignoringImplicit(memberExpr(hasDeclaration(fieldDecl(isBitField())))));
// Initializer list can't be passed to universal reference.
auto initializerListAsArgument = hasAnyArgument(
ignoringImplicit(cxxConstructExpr(isListInitialization())));
// We could have leak of resource.
auto newExprAsArgument = hasAnyArgument(ignoringImplicit(cxxNewExpr()));
// We would call another constructor.
auto constructingDerived =
hasParent(implicitCastExpr(hasCastKind(CastKind::CK_DerivedToBase)));
// emplace_back can't access private constructor.
auto isPrivateCtor = hasDeclaration(cxxConstructorDecl(isPrivate()));
auto hasInitList = has(ignoringImplicit(initListExpr()));
// FIXME: Discard 0/NULL (as nullptr), static inline const data members,
// overloaded functions and template names.
auto soughtConstructExpr =
cxxConstructExpr(
unless(anyOf(isCtorOfSmartPtr, hasInitList, bitFieldAsArgument,
initializerListAsArgument, newExprAsArgument,
constructingDerived, isPrivateCtor)))
.bind("ctor");
auto hasConstructExpr = has(ignoringImplicit(soughtConstructExpr));
auto ctorAsArgument = materializeTemporaryExpr(
anyOf(hasConstructExpr, has(cxxFunctionalCastExpr(hasConstructExpr))));
Finder->addMatcher(cxxMemberCallExpr(callPushBack, has(ctorAsArgument),
unless(isInTemplateInstantiation()))
.bind("call"),
this);
}
/*
* Generate the type hints for a class.
*/
static void pyiClass(sipSpec *pt, moduleDef *mod, classDef *cd,
ifaceFileList **defined, int indent, FILE *fp)
{
int first, no_body, nr_overloads;
classDef *nested;
ctorDef *ct;
memberDef *md;
separate(TRUE, indent, fp);
prIndent(indent, fp);
fprintf(fp, "class %s(", cd->pyname->text);
if (cd->supers != NULL)
{
classList *cl;
for (cl = cd->supers; cl != NULL; cl = cl->next)
{
if (cl != cd->supers)
fprintf(fp, ", ");
prClassRef(cl->cd, mod, *defined, TRUE, fp);
}
}
else if (cd->supertype != NULL)
{
fprintf(fp, "%s", cd->supertype->text);
}
else if (cd->iff->type == namespace_iface)
{
fprintf(fp, "sip.simplewrapper");
}
else
{
fprintf(fp, "sip.wrapper");
}
/* See if there is anything in the class body. */
nr_overloads = 0;
for (ct = cd->ctors; ct != NULL; ct = ct->next)
{
if (isPrivateCtor(ct))
continue;
if (ct->no_typehint)
continue;
if (!inDefaultAPI(pt, ct->api_range))
continue;
++nr_overloads;
}
no_body = (cd->typehintcode == NULL && nr_overloads == 0);
if (no_body)
{
overDef *od;
for (od = cd->overs; od != NULL; od = od->next)
{
if (isPrivate(od))
continue;
if (od->no_typehint)
continue;
if (inDefaultAPI(pt, od->api_range))
{
no_body = FALSE;
break;
}
}
}
if (no_body)
{
enumDef *ed;
for (ed = pt->enums; ed != NULL; ed = ed->next)
{
if (ed->no_typehint)
continue;
if (ed->ecd == cd)
{
no_body = FALSE;
break;
}
}
}
if (no_body)
{
for (nested = pt->classes; nested != NULL; nested = nested->next)
{
if (nested->no_typehint)
continue;
if (nested->ecd == cd)
{
no_body = FALSE;
break;
}
}
}
if (no_body)
{
varDef *vd;
for (vd = pt->vars; vd != NULL; vd = vd->next)
{
if (vd->no_typehint)
continue;
if (vd->ecd == cd)
{
no_body = FALSE;
break;
}
}
}
fprintf(fp, "):%s\n", (no_body ? " ..." : ""));
++indent;
pyiTypeHintCode(cd->typehintcode, indent, fp);
pyiEnums(pt, mod, cd->iff, *defined, indent, fp);
/* Handle any nested classes. */
for (nested = pt->classes; nested != NULL; nested = nested->next)
{
classDef *impl = getClassImplementation(pt, nested);
if (impl != NULL && impl->ecd == cd && !impl->no_typehint)
pyiClass(pt, mod, impl, defined, indent, fp);
}
pyiVars(pt, mod, cd, *defined, indent, fp);
first = TRUE;
for (ct = cd->ctors; ct != NULL; ct = ct->next)
{
int implicit_overloads, overloaded;
if (isPrivateCtor(ct))
continue;
if (ct->no_typehint)
continue;
if (!inDefaultAPI(pt, ct->api_range))
continue;
implicit_overloads = hasImplicitOverloads(&ct->pysig);
overloaded = (implicit_overloads || nr_overloads > 1);
first = separate(first, indent, fp);
pyiCtor(pt, mod, NULL, ct, overloaded, FALSE, *defined, indent, fp);
if (implicit_overloads)
pyiCtor(pt, mod, NULL, ct, overloaded, TRUE, *defined, indent, fp);
}
first = TRUE;
for (md = cd->members; md != NULL; md = md->next)
{
/*
* Ignore slots which can return Py_NotImplemented as code may be
* correctly handled elsewhere. We also have to include the sequence
* slots because they can't be distinguished from the number slots of
* the same name.
*/
if (isNumberSlot(md) || isInplaceNumberSlot(md) || isRichCompareSlot(md) || md->slot == concat_slot || md->slot == iconcat_slot || md->slot == repeat_slot || md->slot == irepeat_slot)
continue;
first = separate(first, indent, fp);
pyiCallable(pt, mod, md, cd->overs, TRUE, *defined, indent, fp);
}
/*
* Keep track of what has been defined so that forward references are no
* longer required.
*/
appendToIfaceFileList(defined, cd->iff);
}
void QtWebKitWebWidget::triggerAction(WindowAction action, bool checked)
{
const QWebPage::WebAction webAction = mapAction(action);
if (webAction != QWebPage::NoWebAction)
{
m_webView->triggerPageAction(webAction, checked);
return;
}
switch (action)
{
case RewindBackAction:
m_webView->page()->history()->goToItem(m_webView->page()->history()->itemAt(0));
break;
case RewindForwardAction:
m_webView->page()->history()->goToItem(m_webView->page()->history()->itemAt(m_webView->page()->history()->count() - 1));
break;
case CopyAddressAction:
QApplication::clipboard()->setText(getUrl().toString());
break;
case ZoomInAction:
setZoom(qMin((getZoom() + 10), 10000));
break;
case ZoomOutAction:
setZoom(qMax((getZoom() - 10), 10));
break;
case ZoomOriginalAction:
setZoom(100);
break;
case ReloadOrStopAction:
if (isLoading())
{
triggerAction(StopAction);
}
else
{
triggerAction(ReloadAction);
}
break;
case OpenLinkInNewTabAction:
if (m_hitResult.linkUrl().isValid())
{
emit requestedOpenUrl(m_hitResult.linkUrl(), false, false);
}
break;
case OpenLinkInNewTabBackgroundAction:
if (m_hitResult.linkUrl().isValid())
{
emit requestedOpenUrl(m_hitResult.linkUrl(), true, false);
}
break;
case OpenLinkInNewWindowAction:
if (m_hitResult.linkUrl().isValid())
{
emit requestedOpenUrl(m_hitResult.linkUrl(), false, true);
}
break;
case OpenLinkInNewWindowBackgroundAction:
if (m_hitResult.linkUrl().isValid())
{
emit requestedOpenUrl(m_hitResult.linkUrl(), true, true);
}
break;
case BookmarkLinkAction:
if (m_hitResult.linkUrl().isValid())
{
emit requestedAddBookmark(m_hitResult.linkUrl(), m_hitResult.element().attribute(QLatin1String("title")));
}
break;
case OpenSelectionAsLinkAction:
emit requestedOpenUrl(m_webView->selectedText(), false, false);
break;
case ImagePropertiesAction:
{
ImagePropertiesDialog dialog(m_hitResult.imageUrl(), m_hitResult.element().attribute(QLatin1String("alt")), m_hitResult.element().attribute(QLatin1String("longdesc")), m_hitResult.pixmap(), (m_networkAccessManager->cache() ? m_networkAccessManager->cache()->data(m_hitResult.imageUrl()) : NULL), this);
QEventLoop eventLoop;
m_parent->showDialog(&dialog);
connect(&dialog, SIGNAL(finished(int)), &eventLoop, SLOT(quit()));
connect(this, SIGNAL(destroyed()), &eventLoop, SLOT(quit()));
eventLoop.exec();
m_parent->hideDialog(&dialog);
}
break;
case InspectPageAction:
if (!m_inspector)
{
m_inspector = new QWebInspector(this);
m_inspector->setPage(m_webView->page());
m_inspector->setContextMenuPolicy(Qt::NoContextMenu);
m_inspector->setMinimumHeight(200);
m_splitter->addWidget(m_inspector);
}
m_inspector->setVisible(checked);
getAction(InspectPageAction)->setChecked(checked);
emit actionsChanged();
emit progressBarGeometryChanged();
break;
case SaveLinkToDownloadsAction:
TransfersManager::startTransfer(m_hitResult.linkUrl().toString(), QString(), isPrivate(), true);
break;
case OpenFrameInThisTabAction:
if (m_hitResult.frame())
{
setUrl(m_hitResult.frame()->url().isValid() ? m_hitResult.frame()->url() : m_hitResult.frame()->requestedUrl());
}
break;
case OpenFrameInNewTabBackgroundAction:
if (m_hitResult.frame())
{
emit requestedOpenUrl((m_hitResult.frame()->url().isValid() ? m_hitResult.frame()->url() : m_hitResult.frame()->requestedUrl()), true, false);
}
break;
case CopyFrameLinkToClipboardAction:
if (m_hitResult.frame())
{
QGuiApplication::clipboard()->setText((m_hitResult.frame()->url().isValid() ? m_hitResult.frame()->url() : m_hitResult.frame()->requestedUrl()).toString());
}
break;
case ReloadFrameAction:
if (m_hitResult.frame())
{
const QUrl url = (m_hitResult.frame()->url().isValid() ? m_hitResult.frame()->url() : m_hitResult.frame()->requestedUrl());
m_hitResult.frame()->setUrl(QUrl());
m_hitResult.frame()->setUrl(url);
}
break;
case SearchAction:
search(getAction(SearchAction));
break;
case CreateSearchAction:
{
QWebElement parentElement = m_hitResult.element().parent();
while (!parentElement.isNull() && parentElement.tagName().toLower() != "form")
{
parentElement = parentElement.parent();
}
const QWebElementCollection inputs = parentElement.findAll(QLatin1String("input:not([disabled])[name], select:not([disabled])[name], textarea:not([disabled])[name]"));
if (!parentElement.isNull() && parentElement.hasAttribute(QLatin1String("action")) && inputs.count() > 0)
{
QUrlQuery parameters;
for (int i = 0; i < inputs.count(); ++i)
{
QString value;
if (inputs.at(i).tagName().toLower() == QLatin1String("textarea"))
{
value = inputs.at(i).toPlainText();
}
else if (inputs.at(i).tagName().toLower() == QLatin1String("select"))
{
const QWebElementCollection options = inputs.at(i).findAll(QLatin1String("option"));
for (int j = 0; j < options.count(); ++j)
{
if (options.at(j).hasAttribute(QLatin1String("selected")))
{
value = options.at(j).attribute(QLatin1String("value"), options.at(j).toPlainText());
break;
}
}
}
else
{
if ((inputs.at(i).attribute(QLatin1String("type")) == QLatin1String("checkbox") || inputs.at(i).attribute(QLatin1String("type")) == QLatin1String("radio")) && !inputs.at(i).hasAttribute(QLatin1String("checked")))
{
continue;
}
value = inputs.at(i).attribute(QLatin1String("value"));
}
parameters.addQueryItem(inputs.at(i).attribute(QLatin1String("name")), ((inputs.at(i) == m_hitResult.element()) ? QLatin1String("{searchTerms}") : value));
}
const QStringList identifiers = SearchesManager::getSearchEngines();
QStringList shortcuts;
QList<SearchInformation*> engines;
for (int i = 0; i < identifiers.count(); ++i)
{
SearchInformation *engine = SearchesManager::getSearchEngine(identifiers.at(i));
if (!engine)
{
continue;
}
engines.append(engine);
const QString shortcut = engine->shortcut;
if (!shortcut.isEmpty())
{
shortcuts.append(shortcut);
}
}
QString identifier = getUrl().host().toLower().remove(QRegularExpression(QLatin1String("[^a-z0-9]")));
while (identifier.isEmpty() || identifiers.contains(identifier))
{
identifier = QInputDialog::getText(this, tr("Select Identifier"), tr("Input Unique Search Engine Identifier:"));
if (identifier.isEmpty())
{
return;
}
}
const QIcon icon = m_webView->icon();
const QUrl url(parentElement.attribute(QLatin1String("action")));
QVariantHash engineData;
engineData[QLatin1String("identifier")] = identifier;
engineData[QLatin1String("isDefault")] = false;
engineData[QLatin1String("encoding")] = QLatin1String("UTF-8");
engineData[QLatin1String("selfUrl")] = QString();
engineData[QLatin1String("resultsUrl")] = (url.isEmpty() ? getUrl() : (url.isRelative() ? getUrl().resolved(url) : url)).toString();
engineData[QLatin1String("resultsEnctype")] = parentElement.attribute(QLatin1String("enctype"));
engineData[QLatin1String("resultsMethod")] = ((parentElement.attribute(QLatin1String("method"), QLatin1String("get")).toLower() == QLatin1String("post")) ? QLatin1String("post") : QLatin1String("get"));
engineData[QLatin1String("resultsParameters")] = parameters.toString(QUrl::FullyDecoded);
engineData[QLatin1String("suggestionsUrl")] = QString();
engineData[QLatin1String("suggestionsEnctype")] = QString();
engineData[QLatin1String("suggestionsMethod")] = QLatin1String("get");
engineData[QLatin1String("suggestionsParameters")] = QString();
engineData[QLatin1String("shortcut")] = QString();
engineData[QLatin1String("title")] = getTitle();
engineData[QLatin1String("description")] = QString();
engineData[QLatin1String("icon")] = (icon.isNull() ? Utils::getIcon(QLatin1String("edit-find")) : icon);
SearchPropertiesDialog dialog(engineData, shortcuts, this);
if (dialog.exec() == QDialog::Rejected)
{
return;
}
engineData = dialog.getEngineData();
if (shortcuts.contains(engineData[QLatin1String("shortcut")].toString()))
{
engineData[QLatin1String("shortcut")] = QString();
}
SearchInformation *engine = new SearchInformation();
engine->identifier = engineData[QLatin1String("identifier")].toString();
engine->title = engineData[QLatin1String("title")].toString();
engine->description = engineData[QLatin1String("description")].toString();
engine->shortcut = engineData[QLatin1String("shortcut")].toString();
engine->encoding = engineData[QLatin1String("encoding")].toString();
engine->selfUrl = engineData[QLatin1String("selfUrl")].toString();
engine->resultsUrl.url = engineData[QLatin1String("resultsUrl")].toString();
engine->resultsUrl.enctype = engineData[QLatin1String("resultsEnctype")].toString();
engine->resultsUrl.method = engineData[QLatin1String("resultsMethod")].toString();
engine->resultsUrl.parameters = QUrlQuery(engineData[QLatin1String("resultsParameters")].toString());
engine->icon = engineData[QLatin1String("icon")].value<QIcon>();
engines.append(engine);
if (SearchesManager::setSearchEngines(engines) && engineData[QLatin1String("isDefault")].toBool())
{
SettingsManager::setValue(QLatin1String("Browser/DefaultSearchEngine"), engineData[QLatin1String("identifier")].toString());
}
}
}
break;
case ClearAllAction:
triggerAction(SelectAllAction);
triggerAction(DeleteAction);
break;
default:
break;
}
}
void QtWebKitWebWidget::downloadFile(QNetworkReply *reply)
{
TransfersManager::startTransfer(reply, QString(), isPrivate());
}
void QtWebKitWebWidget::downloadFile(const QNetworkRequest &request)
{
TransfersManager::startTransfer(request, QString(), isPrivate());
}
