static ZRef<ZTBQueryNode> sNodeFromTuple(const ZTuple& iTuple)
{
string nodeKind = iTuple.GetString("Kind");
if (false)
{}
else if (nodeKind == "All")
{
return new ZTBQueryNode_All;
}
else if (nodeKind == "Combo")
{
vector<ZTBQuery::SortSpec> theSort;
const vector<ZTupleValue>& vectorSort = iTuple.GetVector("Sort");
for (vector<ZTupleValue>::const_iterator i = vectorSort.begin(); i != vectorSort.end(); ++i)
{
const ZTuple& temp = (*i).GetTuple();
theSort.push_back(ZTBQuery::SortSpec(
temp.GetString("PropName"), temp.GetBool("Ascending"), temp.GetInt32("Strength")));
}
const vector<ZTupleValue>& sourceSect = iTuple.GetVector("Intersections");
vector<ZTBQueryNode_Combo::Intersection> theIntersections;
for (vector<ZTupleValue>::const_iterator i = sourceSect.begin(); i != sourceSect.end(); ++i)
theIntersections.push_back(ZTBQueryNode_Combo::Intersection((*i).GetTuple()));
return new ZTBQueryNode_Combo(theSort, theIntersections);
}
else if (nodeKind == "Difference")
{
ZRef<ZTBQueryNode> leftNode = sNodeFromTuple(iTuple.GetTuple("LeftNode"));
ZRef<ZTBQueryNode> rightNode = sNodeFromTuple(iTuple.GetTuple("RightNode"));
return new ZTBQueryNode_Difference(leftNode, rightNode);
}
else if (nodeKind == "First")
{
string propName = iTuple.GetString("PropName");
ZRef<ZTBQueryNode> sourceNode = sNodeFromTuple(iTuple.GetTuple("SourceNode"));
return new ZTBQueryNode_First(propName, sourceNode);
}
else if (nodeKind == "ID_Constant")
{
vector<uint64> theIDs;
iTuple.GetVector_T("IDs", back_inserter(theIDs), uint64());
return new ZTBQueryNode_ID_Constant(theIDs, true);
}
else if (nodeKind == "ID_FromSource")
{
ZRef<ZTBQueryNode> sourceNode = sNodeFromTuple(iTuple.GetTuple("SourceNode"));
string sourcePropName = iTuple.GetString("SourcePropName");
return new ZTBQueryNode_ID_FromSource(sourceNode, sourcePropName);
}
else if (nodeKind == "Property")
{
string propName = iTuple.GetString("PropName");
ZRef<ZTBQueryNode> sourceNode = sNodeFromTuple(iTuple.GetTuple("SourceNode"));
return new ZTBQueryNode_Property(propName, sourceNode);
}
throw runtime_error(string("ZTBQuery, sNodeFromTuple, unknown nodeKind: " + nodeKind));
}
bool ZUITextEngine::MenuMessage(const ZMessage& inMessage)
{
switch (inMessage.GetInt32("menuCommand"))
{
case mcCopy:
case mcCut:
{
size_t selectStart, selectLength;
this->GetSelection(selectStart, selectLength);
if (selectLength != 0)
{
if (inMessage.GetInt32("menuCommand") == mcCopy || this->IsRangeEditable(selectStart, selectLength))
{
ZTuple theTuple = this->GetTuple(selectStart, selectLength);
ZClipboard::sSet(theTuple);
if (inMessage.GetInt32("menuCommand") == mcCut)
this->DeleteText(selectStart, selectLength);
}
}
return true;
break;
}
case mcClear:
{
size_t selectStart, selectLength;
this->GetSelection(selectStart, selectLength);
if (selectLength != 0 && this->IsRangeEditable(selectStart, selectLength))
{
this->DeleteText(selectStart, selectLength);
return true;
}
return true;
break;
}
case mcPaste:
{
size_t selectStart, selectLength;
this->GetSelection(selectStart, selectLength);
if (this->IsRangeEditable(selectStart, selectLength))
{
ZTuple theTuple = ZClipboard::sGet();
if (theTuple.Has("text/plain"))
{
this->ReplaceSelection(theTuple.GetString("text/plain"));
return true;
}
}
return true;
break;
}
case mcSelectAll:
{
this->SetSelection(0, this->GetTextLength());
return true;
}
}
return false;
}
static bool sGetStringAt(const ZTuple& iTuple, const string& iName, string& oString)
{
if (iTuple.GetString(iName, oString))
return true;
const vector<ZTupleValue>& theVector = iTuple.GetVector(iName);
if (!theVector.empty())
return theVector[0].GetString(oString);
return false;
}
void ZUITextEngine::HandleDrop(ZPoint inPoint, ZDrop& inDrop)
{
if (!this->AcceptsDragDrop(inDrop))
return;
if (inDrop.GetDragSource() == this)
{
size_t dragOffset = this->PointToOffset(this->FromHost(inPoint));
size_t selectStart, selectLength;
this->GetSelection(selectStart, selectLength);
if (dragOffset < selectStart)
{
string selectedText = this->GetText(selectStart, selectLength);
this->DeleteText(selectStart, selectLength);
this->InsertText(dragOffset, selectedText);
this->SetSelection(dragOffset, selectLength);
}
else if (dragOffset > selectStart+selectLength)
{
string selectedText = this->GetText(selectStart, selectLength);
this->DeleteText(selectStart, selectLength);
this->InsertText(dragOffset-selectLength, selectedText);
this->SetSelection(dragOffset-selectLength, selectLength);
}
}
else
{
size_t dragOffset = this->PointToOffset(inPoint);
if (!this->IsRangeEditable(dragOffset, 0))
return;
for (size_t currentTupleIndex = 0; currentTupleIndex < inDrop.CountTuples(); ++currentTupleIndex)
{
ZTuple currentTuple = inDrop.GetTuple(currentTupleIndex);
if (currentTuple.Has("text/plain"))
{
string droppedString = currentTuple.GetString("text/plain");
this->InsertText(dragOffset, droppedString);
this->SetSelection(dragOffset, droppedString.size());
// Return now, so we only drop text from the first tuple that had any
return;
}
}
}
}
bool ZTBSpec::Criterion::Matches(const ZTuple& iTuple) const
{
ZTuple::const_iterator propIter = iTuple.IteratorOf(this->GetPropName());
if (propIter == iTuple.end())
{
// iTuple does not have a property named fPropName. For
// 'Lacks' and 'LacksOfType' relationships that means
// we match iTuple, for all other relationships we don't.
return this->GetComparator().fRel == eRel_Lacks
|| this->GetComparator().fRel == eRel_LacksOfType;
}
switch (this->GetComparator().fRel)
{
case eRel_Has:
{
return true;
}
case eRel_HasOfType:
{
return iTuple.TypeOf(propIter) == this->GetTupleValue().GetType();
}
case eRel_Lacks:
{
// iTuple has a property named fPropName,
// so it doesn't lack a property named fPropName.
return false;
}
case eRel_LacksOfType:
{
return iTuple.TypeOf(propIter) != this->GetTupleValue().GetType();
}
case eRel_VectorContains:
{
if (iTuple.TypeOf(propIter) != eZType_Vector)
return false;
const vector<ZTupleValue>& theVector = iTuple.GetVector(propIter);
for (vector<ZTupleValue>::const_iterator i = theVector.begin();
i != theVector.end(); ++i)
{
if (*i == this->GetTupleValue())
return true;
#if 0 //##
if ((*i).TypeOf() == this->GetTupleValue().TypeOf())
{
if ((*i).UncheckedEqual(this->GetTupleValue()))
return true;
}
#endif
}
return false;
}
case eRel_StringContains:
{
string pattern;
if (!this->GetTupleValue().GetString(pattern) || pattern.empty())
return true;
string target;
if (!iTuple.GetString(propIter, target) || target.empty())
return false;
if (!fRep->fTextCollator)
{
fRep->fTextCollator =
ZTextCollator(this->GetComparator().fStrength);
}
return fRep->fTextCollator.Contains(pattern, target);
}
case eRel_Regex:
{
#if ZCONFIG_API_Enabled(Regex)
string target;
if (!iTuple.GetString(propIter, target) || target.empty())
return false;
if (!fRep->fRegex)
{
fRep->fRegex =
ZRegex(this->GetTupleValue().GetString(), this->GetComparator().fStrength);
}
if (!fRep->fRegex)
return false;
return fRep->fRegex.Matches(target);
#else
return false;
#endif
}
default:
{
const ZTupleValue& leftValue = iTuple.GetValue(propIter);
ZType leftType = leftValue.TypeOf();
ZType rightType = this->GetTupleValue().TypeOf();
if (this->GetComparator().fRel == eRel_Equal)
{
if (leftType != rightType)
{
return false;
}
else
{
if (leftType == eZType_String && this->GetComparator().fStrength != 0)
{
// We're doing string compares where the strength is non zero and
// so we need to use a collator to do the comparison.
if (!fRep->fTextCollator)
{
fRep->fTextCollator =
ZTextCollator(this->GetComparator().fStrength);
}
return fRep->fTextCollator.Equals(
leftValue.GetString(), this->GetTupleValue().GetString());
}
else
{
// The type matches, so do the appropriate comparison.
// return leftValue.pUncheckedEqual(this->GetTupleValue());
return leftValue == this->GetTupleValue();
}
}
}
else
{
int compare;
if (leftType != rightType)
{
compare = int(leftType) - int(rightType);
}
else
{
if (leftType == eZType_String && this->GetComparator().fStrength != 0)
{
// We're doing string compares where the strength is non zero and
// so we need to use a collator to do the comparison.
if (!fRep->fTextCollator)
{
fRep->fTextCollator =
ZTextCollator(this->GetComparator().fStrength);
}
compare = fRep->fTextCollator.Compare(
leftValue.GetString(), this->GetTupleValue().GetString());
}
else
{
// The type matches, so do the appropriate comparison.
// compare = leftValue.pUncheckedCompare(this->GetTupleValue());
compare = leftValue.Compare(this->GetTupleValue());
}
}
switch (this->GetComparator().fRel)
{
case eRel_Less: return compare < 0;
case eRel_LessEqual: return compare <= 0;
case eRel_GreaterEqual: return compare >= 0;
case eRel_Greater: return compare > 0;
}
}
}
}
// Can't get here.
ZUnimplemented();
return false;
}
ZTBSpec::Criterion::Rep::Rep(const ZTuple& iTuple)
: fPropName(iTuple.GetString("PropName")),
fComparator(sRelFromString(iTuple.GetString("Rel")), iTuple.GetInt32("Strength")),
fTupleValue(iTuple.GetValue("Value"))
{}