void MidiKeyboardComponent::timerCallback()
{
if (shouldCheckState)
{
shouldCheckState = false;
for (int i = rangeStart; i <= rangeEnd; ++i)
{
bool isOn = state.isNoteOnForChannels (midiInChannelMask, i);
if (keysCurrentlyDrawnDown[i] != isOn)
{
keysCurrentlyDrawnDown.setBit (i, isOn);
repaintNote (i);
}
}
}
if (shouldCheckMousePos)
{
for (auto& ms : Desktop::getInstance().getMouseSources())
if (ms.getComponentUnderMouse() == this || isParentOf (ms.getComponentUnderMouse()))
updateNoteUnderMouse (getLocalPoint (nullptr, ms.getScreenPosition()), ms.isDragging(), ms.getIndex());
}
}
void QStorageInfoPrivate::initRootPath()
{
rootPath = QFileInfo(rootPath).canonicalFilePath();
if (rootPath.isEmpty())
return;
QStorageIterator it;
if (!it.isValid()) {
rootPath = QStringLiteral("/");
return;
}
int maxLength = 0;
const QString oldRootPath = rootPath;
rootPath.clear();
while (it.next()) {
const QString mountDir = it.rootPath();
const QByteArray fsName = it.fileSystemType();
// we try to find most suitable entry
if (isParentOf(mountDir, oldRootPath) && maxLength < mountDir.length()) {
maxLength = mountDir.length();
rootPath = mountDir;
device = it.device();
fileSystemType = fsName;
}
}
}
size_t TypeSystem::ancestor(size_t l, size_t r) {
while (l > 0) {
if (isParentOf(l, r)) return l;
l = types[l].parent;
}
return 1; // Object is always an ancestor
}
bool DirDef::isParentOf(DirDef *dir) const
{
if (dir->parent()==this) // this is a parent of dir
return TRUE;
else if (dir->parent()) // repeat for the parent of dir
return isParentOf(dir->parent());
else
return FALSE;
}
void Toolbar::itemDragExit (const SourceDetails& dragSourceDetails)
{
ToolbarItemComponent* const tc = dynamic_cast <ToolbarItemComponent*> (dragSourceDetails.sourceComponent.get());
if (tc != nullptr && isParentOf (tc))
{
items.removeObject (tc, false);
removeChildComponent (tc);
updateAllItemPositions (true);
}
}
void RecipeFilter::filter( const QString &s )
{
//do this to only iterate over children of 'currentCategory'
Q3ListViewItem * pEndItem = NULL;
if ( currentCategory ) {
Q3ListViewItem * pStartItem = currentCategory;
do {
if ( pStartItem->nextSibling() )
pEndItem = pStartItem->nextSibling();
else
pStartItem = pStartItem->parent();
}
while ( pStartItem && !pEndItem );
}
//Re-show everything
Q3ListViewItemIterator list_it;
if ( currentCategory )
list_it = Q3ListViewItemIterator( currentCategory );
else
list_it = Q3ListViewItemIterator( listview );
while ( list_it.current() != pEndItem ) {
list_it.current() ->setVisible( true );
list_it++;
}
// Only filter if the filter text isn't empty
if ( !s.isEmpty() ) {
Q3ListViewItemIterator list_it( listview );
while ( Q3ListViewItem * it = list_it.current() ) {
if ( it->rtti() == 1000 ) // Its a recipe
{
RecipeListItem * recipe_it = ( RecipeListItem* ) it;
if ( recipe_it->title().contains( s, Qt::CaseInsensitive ) )
{
if ( currentCategory ) {
if ( isParentOf( currentCategory, recipe_it ) )
recipe_it->setVisible( true );
else
recipe_it->setVisible( false );
}
else
recipe_it->setVisible( true );
}
else
recipe_it->setVisible( false );
}
++list_it;
}
hideIfEmpty();
}
}
void ParentVirtualCallCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Member = Result.Nodes.getNodeAs<MemberExpr>("member");
assert(Member);
if (!Member->getQualifier())
return;
const auto *MemberDecl = cast<CXXMethodDecl>(Member->getMemberDecl());
const auto *ThisTypePtr = Result.Nodes.getNodeAs<PointerType>("thisType");
assert(ThisTypePtr);
const auto *ThisType = ThisTypePtr->getPointeeCXXRecordDecl();
assert(ThisType);
const auto *CastToTypePtr = Result.Nodes.getNodeAs<Type>("castToType");
assert(CastToTypePtr);
const auto *CastToType = CastToTypePtr->getAsCXXRecordDecl();
assert(CastToType);
if (isParentOf(*CastToType, *ThisType))
return;
const BasesVector Parents =
getParentsByGrandParent(*CastToType, *ThisType, *MemberDecl);
if (Parents.empty())
return;
std::string ParentsStr;
ParentsStr.reserve(30 * Parents.size());
for (const CXXRecordDecl *Parent : Parents) {
if (!ParentsStr.empty())
ParentsStr.append(" or ");
ParentsStr.append("'").append(getNameAsString(Parent)).append("'");
}
assert(Member->getQualifierLoc().getSourceRange().getBegin().isValid());
auto Diag = diag(Member->getQualifierLoc().getSourceRange().getBegin(),
"qualified name '%0' refers to a member overridden "
"in subclass%1; did you mean %2?")
<< getExprAsString(*Member, *Result.Context)
<< (Parents.size() > 1 ? "es" : "") << ParentsStr;
// Propose a fix if there's only one parent class...
if (Parents.size() == 1 &&
// ...unless parent class is templated
!isa<ClassTemplateSpecializationDecl>(Parents.front()))
Diag << FixItHint::CreateReplacement(
Member->getQualifierLoc().getSourceRange(),
getNameAsString(Parents.front()) + "::");
}
bool DragonDiagramMetamodelPlugin::isParentOf(QString const &parentDiagram, QString const &parentElement, QString const &childDiagram, QString const &childElement) const
{
if (childDiagram == parentDiagram && childElement == parentElement)
return true;
if (mParentsMap[childDiagram][childElement].contains(qMakePair(parentDiagram, parentElement)))
return true;
typedef QPair<QString, QString> StringPair;
foreach (StringPair const &pair, mParentsMap[childDiagram][childElement])
if (isParentOf(parentDiagram, parentElement, pair.first, pair.second))
return true;
return false;
}
void ProjectContentComponent::globalFocusChanged (Component* focusedComponent)
{
const bool nowForeground = (Process::isForegroundProcess()
&& (focusedComponent == this || isParentOf (focusedComponent)));
if (nowForeground != isForeground)
{
isForeground = nowForeground;
if (childProcess != nullptr)
childProcess->processActivationChanged (isForeground);
}
}
std::vector<Cylinder>
Cylinder::getChildren (std::vector<Cylinder>& cylinders)
{
std::vector<Cylinder> children;
for (std::vector<Cylinder>::iterator it = cylinders.begin (); it != cylinders.end (); it++)
{
Cylinder cylinder = *it;
if (isParentOf (cylinder))
{
children.push_back (cylinder);
}
}
return children;
}
static bool isPseudoFs(const QStorageIterator &it)
{
QString mountDir = it.rootPath();
if (isParentOf(QLatin1String("/dev"), mountDir)
|| isParentOf(QLatin1String("/proc"), mountDir)
|| isParentOf(QLatin1String("/sys"), mountDir)
|| isParentOf(QLatin1String("/var/run"), mountDir)
|| isParentOf(QLatin1String("/var/lock"), mountDir)) {
return true;
}
QByteArray type = it.fileSystemType();
if (type == "tmpfs")
return false;
#if defined(Q_OS_LINUX)
if (type == "rootfs" || type == "rpc_pipefs")
return true;
#endif
if (!it.device().startsWith('/'))
return true;
return false;
}
void RecipeFilter::filterCategory( int categoryID )
{
kDebug() << "I got category :" << categoryID ;
if ( categoryID == -1 )
currentCategory = 0;
else {
Q3ListViewItemIterator list_it( listview );
while ( Q3ListViewItem * it = list_it.current() ) {
if ( it->rtti() == 1001 ) {
CategoryListItem * cat_it = ( CategoryListItem* ) it;
if ( cat_it->categoryId() == categoryID ) {
currentCategory = cat_it;
break;
}
}
++list_it;
}
}
Q3ListViewItemIterator list_it( listview );
while ( Q3ListViewItem * it = list_it.current() ) {
if ( categoryID == -1 )
it->setVisible( true ); // We're not filtering categories
else if ( it == currentCategory || isParentOf( it, currentCategory ) || isParentOf( currentCategory, it ) )
it->setVisible( true );
else
it->setVisible( false );
++list_it;
}
if ( currentCategory )
currentCategory->setOpen( true );
}
/* returns the row for placing next node */
static INT local addClassToGraph(HDC hDC, INT Column, INT startRow, Class ThisClass)
{
Node newNode = LastNode++;
SIZE Size;
INT row = startRow;
/* Get size of class name on the screen */
fprintf(stdstr, "%s\n",textToStr(cclass(ThisClass).text));
GetTextExtentPoint(hDC,(LPSTR)stdstrbuff, (INT)strlen(stdstrbuff), &Size);
Nodes[newNode].Class = ThisClass;
Nodes[newNode].Pos.left = Column;
Nodes[newNode].Pos.top = startRow;
Nodes[newNode].Pos.right = Nodes[newNode].Pos.left + Size.cx;
Nodes[newNode].Pos.bottom = Nodes[newNode].Pos.top + Size.cy;
/* Add subclasses of ThisClass */
{ Class cls;
INT col = Nodes[newNode].Pos.right+HORIZONTAL_SEPARATION;
INT child = 0;
for(cls=CLASSMIN; cls<classMax(); cls++) {
if (-1 == findClassInNodes(cls) /* Check for cycles in graph */
&& isParentOf(ThisClass, cls)) {
if (child++ > 0) {
row += VERTICAL_SEPARATION;
}
row = addClassToGraph(hDC, col, row, cls);
}
}
}
/* Set to average position of children */
{ INT height = row-startRow;
Nodes[newNode].Pos.top += height/2;
Nodes[newNode].Pos.bottom += height/2;
}
return row;
}
bool TypeSystem::isChildType(size_t t1, size_t t2) {
return isParentOf(t2, t1);
}
void RDirNode::applyForces(QuadTree& quadtree) {
//child nodes
for(std::list<RDirNode*>::iterator it = children.begin(); it != children.end(); it++) {
RDirNode* node = (*it);
node->applyForces(quadtree);
}
if(parent == 0) return;
std::vector<QuadItem*> inbounds;
int found = quadtree.getItemsInBounds(inbounds, quadItemBounds);
std::set<std::string> seen;
std::set<std::string>::iterator seentest;
//apply forces with other that are inside the 'box' of this nodes radius
for(std::vector<QuadItem*>::iterator it = inbounds.begin(); it != inbounds.end(); it++) {
RDirNode* d = (RDirNode*) (*it);
if(d==this) continue;
if(d==parent) continue;
if(d->parent==this) continue;
if((seentest = seen.find(d->getPath())) != seen.end()) {
continue;
}
seen.insert(d->getPath());
if(isParentOf(d)) continue;
if(d->isParentOf(this)) continue;
applyForceDir(d);
gGourceDirNodeInnerLoops++;
}
//always call on parent no matter how far away
applyForceDir(parent);
//pull towards parent
float parent_dist = distanceTo(parent);
// * dirs should attract to sit on the radius of the parent dir ie:
// should attract to distance_to_parent * normal_to_parent
accel += gGourceForceGravity * parent_dist * (parent->getPos() - pos).normal();
// * dirs should be pushed along the parent_parent to parent normal by a force smaller than the parent radius force
RDirNode* pparent = parent->getParent();
if(pparent != 0) {
vec2f parent_edge = (parent->getPos() - pparent->getPos());
vec2f parent_edge_normal = parent_edge.normal();
vec2f dest = (parent->getPos() + (parent->getRadius() + getRadius()) * parent_edge_normal) - pos;
accel += dest;
}
// * dirs should repulse from other dirs of this parent
std::list<RDirNode*>* siblings = parent->getChildren();
if(siblings->size() > 0) {
vec2f sib_accel;
int visible = 1;
for(std::list<RDirNode*>::iterator it = siblings->begin(); it != siblings->end(); it++) {
RDirNode* node = (*it);
if(node == this) continue;
if(!node->isVisible()) continue;
visible++;
sib_accel -= (node->getPos() - pos).normal();
}
//parent circumfrence divided by the number of visible child nodes
if(visible>1) {
float slice_size = (parent->getRadius() * PI) / (float) (visible+1);
sib_accel *= slice_size;
accel += sib_accel;
}
}
}
void updateComponents()
{
const int visibleTop = -getY();
const int visibleBottom = visibleTop + getParentHeight();
{
for (int i = items.size(); --i >= 0;)
items.getUnchecked(i)->shouldKeep = false;
}
{
TreeViewItem* item = owner.rootItem;
int y = (item != 0 && ! owner.rootItemVisible) ? -item->itemHeight : 0;
while (item != 0 && y < visibleBottom)
{
y += item->itemHeight;
if (y >= visibleTop)
{
RowItem* const ri = findItem (item->uid);
if (ri != 0)
{
ri->shouldKeep = true;
}
else
{
Component* const comp = item->createItemComponent();
if (comp != 0)
{
items.add (new RowItem (item, comp, item->uid));
addAndMakeVisible (comp);
}
}
}
item = item->getNextVisibleItem (true);
}
}
for (int i = items.size(); --i >= 0;)
{
RowItem* const ri = items.getUnchecked(i);
bool keep = false;
if (isParentOf (ri->component))
{
if (ri->shouldKeep)
{
Rectangle<int> pos (ri->item->getItemPosition (false));
pos.setSize (pos.getWidth(), ri->item->itemHeight);
if (pos.getBottom() >= visibleTop && pos.getY() < visibleBottom)
{
keep = true;
ri->component->setBounds (pos);
}
}
if ((! keep) && isMouseDraggingInChildCompOf (ri->component))
{
keep = true;
ri->component->setSize (0, 0);
}
}
if (! keep)
items.remove (i);
}
}
void VariablesChecker::preCheckNode(const ast::Exp & e, SLintContext & context, SLintResult & result)
{
if (e.isFunctionDec())
{
const ast::FunctionDec & fd = static_cast<const ast::FunctionDec &>(e);
if (!assigned.empty())
{
// we declare the function in the current scope
std::pair<Location, ast::AssignListExp *> p = { e.getLocation(), nullptr };
assigned.top().emplace(fd.getSymbol().getName(), p);
}
assigned.emplace(std::unordered_map<std::wstring, std::pair<Location, ast::AssignListExp *>>());
used.emplace(std::unordered_map<std::wstring, const ast::Exp *>());
// a function cans refer to itself
std::pair<Location, ast::AssignListExp *> p = { e.getLocation(), nullptr };
assigned.top().emplace(fd.getSymbol().getName(), p);
}
else
{
if (!used.empty())
{
if (e.isSimpleVar())
{
const ast::SimpleVar & var = static_cast<const ast::SimpleVar &>(e);
if (context.isAssignedVar(var))
{
// if we are not in the context on a nested assignment in a function call (foo(a,b=2))
if (!var.getParent()->getParent() || !var.getParent()->getParent()->isCallExp())
{
const std::wstring & name = var.getSymbol().getName();
auto i = used.top().find(name);
if (!context.topLoop() || (i == used.top().end()) || !isParentOf(context.topLoop(), i->second))
{
// the variable has never been used or the last time it wasn't in a loop
if (i != used.top().end())
{
used.top().erase(i);
}
if (var.getParent() == context.getLHSExp() && var.getParent()->isAssignListExp())
{
// we have something like [lhs, rhs] = argn(0)
// if rhs is used and lhs is not used then this not an "error":
// we are obliged to define lhs just to get rhs.
// So when rhs is used lhs is "used" too.
std::pair<Location, ast::AssignListExp *> p = { var.getLocation(), static_cast<ast::AssignListExp *>(var.getParent()) };
assigned.top().emplace(name, p);
}
else
{
std::pair<Location, ast::AssignListExp *> p = { var.getLocation(), nullptr };
assigned.top().emplace(name, p);
}
}
else /*if (context.topLoop() && i != used.top.end() && isParentOf(context.topLoop(), i->second))*/
{
// Just to remember...
// Here the variable has already been used in the current loop and we reassign it
// something like:
// while (...)
// ... use i
// ...
// i = ...
// end
// In general the loop will looping so the assignment is implicitly destroyed by the use in the next iteration
// so we don't add this assignment !
}
}
}
else if (!e.getParent()->isFieldExp() || static_cast<const ast::FieldExp *>(e.getParent())->getTail() != &e)
{
const symbol::Symbol & sym = var.getSymbol();
const std::wstring & name = sym.getName();
if (used.top().find(name) == used.top().end())
{
used.top().emplace(name, context.topLoop());
auto i = assigned.top().find(name);
if (i == assigned.top().end())
{
if (!context.isFunIn(name) && !SLintChecker::isScilabConstant(name))
{
types::InternalType * pIT = symbol::Context::getInstance()->get(sym);
if (pIT)
{
if (!pIT->isFunction() && !pIT->isMacroFile() && !pIT->isMacro())
{
result.report(context, e.getLocation(), *this, _("Use of non-initialized variable \'%s\' may have any side-effects."), name);
}
}
else if (!context.isPrivateFunction(sym))
{
/* The symbol doesn't correspond to a private function:
function tata()
titi()
end
function titi()
...
end
titi is private but usable in tata.
*/
std::wstring fname;
if (context.isExternPrivateFunction(sym, fname))
{
result.report(context, e.getLocation(), *this, _("Use of a private macro \'%s\' defined in an other file %s."), name, fname);
}
else if (!context.getPublicFunction(fname))
{
// The macro has not been declared somewhere in the project
result.report(context, e.getLocation(), *this, _("Use of non-initialized variable \'%s\' may have any side-effects."), name);
}
}
}
}
else
{
if (ast::AssignListExp * ale = i->second.second)
{
// the variable is in an AssignListExp
// so we must "use" the variables which preceed it too
for (auto e : ale->getExps())
{
if (e->isSimpleVar())
{
const std::wstring & prevName = static_cast<ast::SimpleVar *>(e)->getSymbol().getName();
assigned.top().erase(prevName);
if (prevName == name)
{
break;
}
else
{
used.top().emplace(prevName, context.topLoop());
}
}
}
}
else
{
assigned.top().erase(i);
}
}
}
}
}
// for i=1:10... end even if i is not used, i is useful to make the loop
/*else if (e.isVarDec())
{
const ast::VarDec & vd = static_cast<const ast::VarDec &>(e);
const std::wstring & name = vd.getSymbol().getName();
std::pair<Location, ast::AssignListExp *> p = { vd.getLocation(), nullptr };
assigned.top().emplace(name, p);
used.top().erase(name);
}*/
}
}
}