| //======================================================================== |
| // |
| // OptionalContent.cc |
| // |
| // Copyright 2007 Brad Hards <bradh@kde.org> |
| // Copyright 2008 Pino Toscano <pino@kde.org> |
| // Copyright 2008, 2010 Carlos Garcia Campos <carlosgc@gnome.org> |
| // Copyright 2008, 2010, 2011, 2017-2019 Albert Astals Cid <aacid@kde.org> |
| // Copyright 2008 Mark Kaplan <mkaplan@finjan.com> |
| // Copyright 2018 Adam Reichold <adam.reichold@t-online.de> |
| // Copyright 2019 Oliver Sander <oliver.sander@tu-dresden.de> |
| // |
| // Released under the GPL (version 2, or later, at your option) |
| // |
| //======================================================================== |
| |
| #include <config.h> |
| |
| #include "goo/gmem.h" |
| #include "goo/GooString.h" |
| #include "Error.h" |
| #include "OptionalContent.h" |
| |
| // Max depth of nested visibility expressions. This is used to catch |
| // infinite loops in the visibility expression object structure. |
| #define visibilityExprRecursionLimit 50 |
| |
| // Max depth of nested display nodes. This is used to catch infinite |
| // loops in the "Order" object structure. |
| #define displayNodeRecursionLimit 50 |
| |
| //------------------------------------------------------------------------ |
| |
| OCGs::OCGs(Object *ocgObject, XRef *xref) : m_xref(xref) |
| { |
| // we need to parse the dictionary here, and build optionalContentGroups |
| ok = true; |
| |
| Object ocgList = ocgObject->dictLookup("OCGs"); |
| if (!ocgList.isArray()) { |
| error(errSyntaxError, -1, "Expected the optional content group list, but wasn't able to find it, or it isn't an Array"); |
| ok = false; |
| return; |
| } |
| |
| // we now enumerate over the ocgList, and build up the optionalContentGroups list. |
| for (int i = 0; i < ocgList.arrayGetLength(); ++i) { |
| Object ocgDict = ocgList.arrayGet(i); |
| if (!ocgDict.isDict()) { |
| break; |
| } |
| auto thisOptionalContentGroup = std::make_unique<OptionalContentGroup>(ocgDict.getDict()); |
| const Object &ocgRef = ocgList.arrayGetNF(i); |
| if (!ocgRef.isRef()) { |
| break; |
| } |
| thisOptionalContentGroup->setRef(ocgRef.getRef()); |
| // the default is ON - we change state later, depending on BaseState, ON and OFF |
| thisOptionalContentGroup->setState(OptionalContentGroup::On); |
| optionalContentGroups.emplace(ocgRef.getRef(), std::move(thisOptionalContentGroup)); |
| } |
| |
| Object defaultOcgConfig = ocgObject->dictLookup("D"); |
| if (!defaultOcgConfig.isDict()) { |
| error(errSyntaxError, -1, "Expected the default config, but wasn't able to find it, or it isn't a Dictionary"); |
| ok = false; |
| return; |
| } |
| |
| Object baseState = defaultOcgConfig.dictLookup("BaseState"); |
| if (baseState.isName("OFF")) { |
| for (auto &group : optionalContentGroups) { |
| group.second->setState(OptionalContentGroup::Off); |
| } |
| } |
| |
| Object on = defaultOcgConfig.dictLookup("ON"); |
| if (on.isArray()) { |
| // ON is an optional element |
| for (int i = 0; i < on.arrayGetLength(); ++i) { |
| const Object &reference = on.arrayGetNF(i); |
| if (!reference.isRef()) { |
| // there can be null entries |
| break; |
| } |
| OptionalContentGroup *group = findOcgByRef(reference.getRef()); |
| if (!group) { |
| error(errSyntaxWarning, -1, "Couldn't find group for reference"); |
| break; |
| } |
| group->setState(OptionalContentGroup::On); |
| } |
| } |
| |
| Object off = defaultOcgConfig.dictLookup("OFF"); |
| if (off.isArray()) { |
| // OFF is an optional element |
| for (int i = 0; i < off.arrayGetLength(); ++i) { |
| const Object &reference = off.arrayGetNF(i); |
| if (!reference.isRef()) { |
| // there can be null entries |
| break; |
| } |
| OptionalContentGroup *group = findOcgByRef(reference.getRef()); |
| if (!group) { |
| error(errSyntaxWarning, -1, "Couldn't find group for reference to set OFF"); |
| break; |
| } |
| group->setState(OptionalContentGroup::Off); |
| } |
| } |
| |
| order = defaultOcgConfig.dictLookup("Order"); |
| rbgroups = defaultOcgConfig.dictLookup("RBGroups"); |
| } |
| |
| bool OCGs::hasOCGs() const |
| { |
| return !(optionalContentGroups.empty()); |
| } |
| |
| OptionalContentGroup *OCGs::findOcgByRef(const Ref ref) |
| { |
| const auto ocg = optionalContentGroups.find(ref); |
| return ocg != optionalContentGroups.end() ? ocg->second.get() : nullptr; |
| } |
| |
| bool OCGs::optContentIsVisible(const Object *dictRef) |
| { |
| Dict *dict; |
| bool result = true; |
| |
| if (dictRef->isNull()) { |
| return result; |
| } |
| |
| if (dictRef->isRef()) { |
| OptionalContentGroup *oc = findOcgByRef(dictRef->getRef()); |
| if (oc) { |
| return oc->getState() == OptionalContentGroup::On; |
| } |
| } |
| |
| Object dictObj = dictRef->fetch(m_xref); |
| if (!dictObj.isDict()) { |
| error(errSyntaxWarning, -1, "Unexpected oc reference target: {0:d}", dictObj.getType()); |
| return result; |
| } |
| dict = dictObj.getDict(); |
| Object dictType = dict->lookup("Type"); |
| if (dictType.isName("OCMD")) { |
| Object ve = dict->lookup("VE"); |
| if (ve.isArray()) { |
| result = evalOCVisibilityExpr(&ve, 0); |
| } else { |
| const Object &ocg = dict->lookupNF("OCGs"); |
| if (ocg.isArray()) { |
| Object policy = dict->lookup("P"); |
| if (policy.isName("AllOn")) { |
| result = allOn(ocg.getArray()); |
| } else if (policy.isName("AllOff")) { |
| result = allOff(ocg.getArray()); |
| } else if (policy.isName("AnyOff")) { |
| result = anyOff(ocg.getArray()); |
| } else if ((!policy.isName()) || (policy.isName("AnyOn"))) { |
| // this is the default |
| result = anyOn(ocg.getArray()); |
| } |
| } else if (ocg.isRef()) { |
| OptionalContentGroup *oc = findOcgByRef(ocg.getRef()); |
| if (oc && oc->getState() == OptionalContentGroup::Off) { |
| result = false; |
| } else { |
| result = true; |
| } |
| } |
| } |
| } else if (dictType.isName("OCG") && dictRef->isRef()) { |
| OptionalContentGroup *oc = findOcgByRef(dictRef->getRef()); |
| if (oc && oc->getState() == OptionalContentGroup::Off) { |
| result = false; |
| } |
| } |
| return result; |
| } |
| |
| bool OCGs::evalOCVisibilityExpr(const Object *expr, int recursion) |
| { |
| OptionalContentGroup *ocg; |
| bool ret; |
| |
| if (recursion > visibilityExprRecursionLimit) { |
| error(errSyntaxError, -1, "Loop detected in optional content visibility expression"); |
| return true; |
| } |
| if (expr->isRef()) { |
| if ((ocg = findOcgByRef(expr->getRef()))) { |
| return ocg->getState() == OptionalContentGroup::On; |
| } |
| } |
| Object expr2 = expr->fetch(m_xref); |
| if (!expr2.isArray() || expr2.arrayGetLength() < 1) { |
| error(errSyntaxError, -1, "Invalid optional content visibility expression"); |
| return true; |
| } |
| Object op = expr2.arrayGet(0); |
| if (op.isName("Not")) { |
| if (expr2.arrayGetLength() == 2) { |
| const Object &obj = expr2.arrayGetNF(1); |
| ret = !evalOCVisibilityExpr(&obj, recursion + 1); |
| } else { |
| error(errSyntaxError, -1, "Invalid optional content visibility expression"); |
| ret = true; |
| } |
| } else if (op.isName("And")) { |
| ret = true; |
| for (int i = 1; i < expr2.arrayGetLength() && ret; ++i) { |
| const Object &obj = expr2.arrayGetNF(i); |
| ret = evalOCVisibilityExpr(&obj, recursion + 1); |
| } |
| } else if (op.isName("Or")) { |
| ret = false; |
| for (int i = 1; i < expr2.arrayGetLength() && !ret; ++i) { |
| const Object &obj = expr2.arrayGetNF(i); |
| ret = evalOCVisibilityExpr(&obj, recursion + 1); |
| } |
| } else { |
| error(errSyntaxError, -1, "Invalid optional content visibility expression"); |
| ret = true; |
| } |
| return ret; |
| } |
| |
| bool OCGs::allOn(Array *ocgArray) |
| { |
| for (int i = 0; i < ocgArray->getLength(); ++i) { |
| const Object &ocgItem = ocgArray->getNF(i); |
| if (ocgItem.isRef()) { |
| OptionalContentGroup *oc = findOcgByRef(ocgItem.getRef()); |
| if (oc && oc->getState() == OptionalContentGroup::Off) { |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| |
| bool OCGs::allOff(Array *ocgArray) |
| { |
| for (int i = 0; i < ocgArray->getLength(); ++i) { |
| const Object &ocgItem = ocgArray->getNF(i); |
| if (ocgItem.isRef()) { |
| OptionalContentGroup *oc = findOcgByRef(ocgItem.getRef()); |
| if (oc && oc->getState() == OptionalContentGroup::On) { |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| |
| bool OCGs::anyOn(Array *ocgArray) |
| { |
| for (int i = 0; i < ocgArray->getLength(); ++i) { |
| const Object &ocgItem = ocgArray->getNF(i); |
| if (ocgItem.isRef()) { |
| OptionalContentGroup *oc = findOcgByRef(ocgItem.getRef()); |
| if (oc && oc->getState() == OptionalContentGroup::On) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| bool OCGs::anyOff(Array *ocgArray) |
| { |
| for (int i = 0; i < ocgArray->getLength(); ++i) { |
| const Object &ocgItem = ocgArray->getNF(i); |
| if (ocgItem.isRef()) { |
| OptionalContentGroup *oc = findOcgByRef(ocgItem.getRef()); |
| if (oc && oc->getState() == OptionalContentGroup::Off) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| OptionalContentGroup::OptionalContentGroup(Dict *ocgDict) : m_name(nullptr) |
| { |
| Object ocgName = ocgDict->lookup("Name"); |
| if (!ocgName.isString()) { |
| error(errSyntaxWarning, -1, "Expected the name of the OCG, but wasn't able to find it, or it isn't a String"); |
| } else { |
| m_name = new GooString(ocgName.getString()); |
| } |
| |
| viewState = printState = ocUsageUnset; |
| Object obj1 = ocgDict->lookup("Usage"); |
| if (obj1.isDict()) { |
| Object obj2 = obj1.dictLookup("View"); |
| if (obj2.isDict()) { |
| Object obj3 = obj2.dictLookup("ViewState"); |
| if (obj3.isName()) { |
| if (obj3.isName("ON")) { |
| viewState = ocUsageOn; |
| } else { |
| viewState = ocUsageOff; |
| } |
| } |
| } |
| obj2 = obj1.dictLookup("Print"); |
| if (obj2.isDict()) { |
| Object obj3 = obj2.dictLookup("PrintState"); |
| if (obj3.isName()) { |
| if (obj3.isName("ON")) { |
| printState = ocUsageOn; |
| } else { |
| printState = ocUsageOff; |
| } |
| } |
| } |
| } |
| } |
| |
| OptionalContentGroup::OptionalContentGroup(GooString *label) |
| { |
| m_name = label; |
| m_state = On; |
| } |
| |
| const GooString *OptionalContentGroup::getName() const |
| { |
| return m_name; |
| } |
| |
| void OptionalContentGroup::setRef(const Ref ref) |
| { |
| m_ref = ref; |
| } |
| |
| Ref OptionalContentGroup::getRef() const |
| { |
| return m_ref; |
| } |
| |
| OptionalContentGroup::~OptionalContentGroup() |
| { |
| delete m_name; |
| } |
