diff options
Diffstat (limited to 'editors/pdfedit/files')
48 files changed, 3524 insertions, 0 deletions
diff --git a/editors/pdfedit/files/patch-Makefile b/editors/pdfedit/files/patch-Makefile new file mode 100644 index 000000000000..1b970ecce06f --- /dev/null +++ b/editors/pdfedit/files/patch-Makefile @@ -0,0 +1,12 @@ +--- Makefile.orig 2008-11-13 23:11:39.000000000 +0900 ++++ Makefile 2016-06-12 05:32:04.209014000 +0900 +@@ -44,6 +44,9 @@ + cd $(KERNELROOT) && $(MAKE) install-dev + cd $(OSROOT) && $(MAKE) install-dev + ++install-tools: ++ cd $(TOOLSROOT) && $(MAKE) install ++ + + # Common uninstall target. It depends on configuration which specific + # uninstallation target will be used diff --git a/editors/pdfedit/files/patch-Makefile.flags.in b/editors/pdfedit/files/patch-Makefile.flags.in new file mode 100644 index 000000000000..e02b249e3d3d --- /dev/null +++ b/editors/pdfedit/files/patch-Makefile.flags.in @@ -0,0 +1,30 @@ +--- Makefile.flags.in.bak 2010-02-24 03:28:09.000000000 +0900 ++++ Makefile.flags.in 2016-06-12 05:13:20.961050000 +0900 +@@ -131,20 +131,20 @@ + # from autoconf --enable-observer-debug + OBSERVER_CXXFLAGS = @OBSERVER_CXXFLAGS@ + +-EXTRA_UTILS_CXXFLAGS = @EXTRA_UTILS_CXXFLAGS@ -pedantic +-EXTRA_KERNEL_CXXFLAGS = @EXTRA_KERNEL_CXXFLAGS@ -pedantic ++EXTRA_UTILS_CXXFLAGS = @EXTRA_UTILS_CXXFLAGS@ ++EXTRA_KERNEL_CXXFLAGS = @EXTRA_KERNEL_CXXFLAGS@ + EXTRA_TESTS_CXXFLAGS = @EXTRA_TESTS_CXXFLAGS@ + EXTRA_GUI_CXXFLAGS = @EXTRA_GUI_CXXFLAGS@ -D CONFIG_DATA_PATH="$(DATA_PATH)" +-EXTRA_XPDF_CXXFLAGS = @EXTRA_XPDF_CXXFLAGS@ -pedantic ++EXTRA_XPDF_CXXFLAGS = @EXTRA_XPDF_CXXFLAGS@ + + # same like for compiler stuff we also define 2 levels + # CONFIG_{NAME} can be used for qmake direct {NAME} can be used + # for compilation +-CONFIG_CFLAGS = $(DEBUG) $(OPTIM) $(ARCH) $(WARN) $(C_EXTRA) @STACK_PROTECTOR_FLAGS@ -pipe -posix -ansi -std=c99 -pedantic +-CONFIG_CXXFLAGS = $(DEBUG) $(OPTIM) $(ARCH) $(WARN) $(CXX_EXTRA) $(OBSERVER_CXXFLAGS) @STACK_PROTECTOR_FLAGS@ -pipe -posix -ansi -std=c++98 ++CONFIG_CFLAGS = $(DEBUG) $(WARN) $(C_EXTRA) @STACK_PROTECTOR_FLAGS@ ++CONFIG_CXXFLAGS = $(DEBUG) $(WARN) $(CXX_EXTRA) $(OBSERVER_CXXFLAGS) @STACK_PROTECTOR_FLAGS@ + +-CFLAGS = $(CONFIG_CFLAGS) +-CXXFLAGS = $(CONFIG_CXXFLAGS) ++CFLAGS += $(CONFIG_CFLAGS) ++CXXFLAGS += $(CONFIG_CXXFLAGS) + + ####################################### + # Absolute paths for all components diff --git a/editors/pdfedit/files/patch-doc__Makefile b/editors/pdfedit/files/patch-doc__Makefile new file mode 100644 index 000000000000..915269137241 --- /dev/null +++ b/editors/pdfedit/files/patch-doc__Makefile @@ -0,0 +1,12 @@ +--- doc/Makefile.orig 2008-12-03 09:16:03.000000000 +0900 ++++ doc/Makefile 2011-03-21 20:34:48.000000000 +0900 +@@ -18,9 +18,6 @@ + $(USER_MANUAL_INSTALL_TARGET) \ + $(DOXYGEN_INSTALL_TARGET) \ + $(ADVANCED_DOC_INSTALL_TARGET) +- $(MKDIR) $(INSTALL_ROOT)$(DOC_PATH)/; +- $(COPY_FILE) LICENSE.GPL ../README ../Changelog AUTHORS README-* \ +- README.cygwin $(INSTALL_ROOT)$(DOC_PATH) + + # TODO maybe we should be less brutal here and delete only our files However we + # have no list of installed doc files. This list is probably too much effort diff --git a/editors/pdfedit/files/patch-src-kernel-cannotation.cc b/editors/pdfedit/files/patch-src-kernel-cannotation.cc new file mode 100644 index 000000000000..9097a4d267a0 --- /dev/null +++ b/editors/pdfedit/files/patch-src-kernel-cannotation.cc @@ -0,0 +1,96 @@ +--- src/kernel/cannotation.cc.orig 2009-07-27 17:18:10.000000000 +0900 ++++ src/kernel/cannotation.cc 2016-06-11 05:49:08.538858000 +0900 +@@ -114,13 +114,13 @@ + AnnotList::const_iterator implElem; + if((implElem=implList.find(annotType))==implList.end()) + return false; +- shared_ptr<IAnnotInitializator> impl=implElem->second; ++ boost::shared_ptr<IAnnotInitializator> impl=implElem->second; + + // use registerd implementator + return (*impl)(annotDict, annotType); + } + +-bool UniversalAnnotInitializer::registerInitializer(std::string annotType, shared_ptr<IAnnotInitializator> impl, bool forceNew) ++bool UniversalAnnotInitializer::registerInitializer(std::string annotType, boost::shared_ptr<IAnnotInitializator> impl, bool forceNew) + { + AnnotList::iterator elem=implList.find(annotType); + if(elem!=implList.end()) +@@ -229,10 +229,10 @@ + } // namespace utils + + // initialization of static +-shared_ptr<utils::IAnnotInitializator> +-CAnnotation::annotInit=shared_ptr<utils::IAnnotInitializator>(new utils::UniversalAnnotInitializer()); ++boost::shared_ptr<utils::IAnnotInitializator> ++CAnnotation::annotInit=boost::shared_ptr<utils::IAnnotInitializator>(new utils::UniversalAnnotInitializer()); + +-shared_ptr<CAnnotation> CAnnotation::createAnnotation(libs::Rectangle rect, string annotType) ++boost::shared_ptr<CAnnotation> CAnnotation::createAnnotation(libs::Rectangle rect, string annotType) + { + using namespace debug; + using namespace utils; +@@ -240,7 +240,7 @@ + kernelPrintDbg(DBG_DBG, ""); + + // creates new empty dictionary for annotation +- shared_ptr<CDict> annotDictionary(CDictFactory::getInstance()); ++ boost::shared_ptr<CDict> annotDictionary(CDictFactory::getInstance()); + + // initializes annotation dictionary maintaining information: + // Type of annotation dictionary has to be Annot (this is not strongly +@@ -249,7 +249,7 @@ + checkAndReplace(annotDictionary, "Type", *typeField); + + // Rectangle of annotation is constructed from given parameter +- shared_ptr<IProperty> rectField(getIPropertyFromRectangle(rect)); ++ boost::shared_ptr<IProperty> rectField(getIPropertyFromRectangle(rect)); + checkAndReplace(annotDictionary, "Rect", *rectField); + + // last modified date field (M) is initialized to current local time +@@ -257,7 +257,7 @@ + time(&currTime); + struct tm currLocalTime; + localtime_r(&currTime, &currLocalTime); +- shared_ptr<IProperty> mField=getIPropertyFromDate(&currLocalTime); ++ boost::shared_ptr<IProperty> mField=getIPropertyFromDate(&currLocalTime); + checkAndReplace(annotDictionary, "M", *mField); + + // initializes annotation dictionary according desired type - at least Type +@@ -270,7 +270,7 @@ + if(!initialized) + kernelPrintDbg(DBG_WARN, "Unable to initialize annotation dictionary with type="<<annotType); + +- return shared_ptr<CAnnotation>(new CAnnotation(annotDictionary)); ++ return boost::shared_ptr<CAnnotation>(new CAnnotation(annotDictionary)); + } + + void CAnnotation::invalidate() +@@ -285,8 +285,8 @@ + // Uses this instance as newValue, but uses EmptyDeallocator to keep + // instance alive when shared_ptr tries to destroy its content. + // context is empty +- shared_ptr<CAnnotation> current(this, EmptyDeallocator<CAnnotation>()); +- notifyObservers(current, shared_ptr<ChangeContext>()); ++ boost::shared_ptr<CAnnotation> current(this, EmptyDeallocator<CAnnotation>()); ++ notifyObservers(current, boost::shared_ptr<ChangeContext>()); + } + + CAnnotation::AnnotType CAnnotation::getType()const +@@ -295,14 +295,14 @@ + + try + { +- shared_ptr<IProperty> subTypeProp=annotDictionary->getProperty("Subtype"); ++ boost::shared_ptr<IProperty> subTypeProp=annotDictionary->getProperty("Subtype"); + if(!isName(subTypeProp)) + { + // TODO may be problem if value is indirect (what is not very usual) + kernelPrintDbg(DBG_WARN, "Subtype is not Name. Type="<<subTypeProp->getType()); + return Unknown; + } +- shared_ptr<CName> subTypeName=IProperty::getSmartCObjectPtr<CName>(subTypeProp); ++ boost::shared_ptr<CName> subTypeName=IProperty::getSmartCObjectPtr<CName>(subTypeProp); + string typeName; + subTypeName->getValue(typeName); + return utils::annotTypeMapping(typeName); diff --git a/editors/pdfedit/files/patch-src-kernel-carray.cc b/editors/pdfedit/files/patch-src-kernel-carray.cc new file mode 100644 index 000000000000..765bd23e503a --- /dev/null +++ b/editors/pdfedit/files/patch-src-kernel-carray.cc @@ -0,0 +1,118 @@ +--- src/kernel/carray.cc.orig 2009-09-11 21:02:56.000000000 +0900 ++++ src/kernel/carray.cc 2016-06-11 05:52:59.028080000 +0900 +@@ -80,7 +80,7 @@ + // + // + // +-shared_ptr<IProperty> ++boost::shared_ptr<IProperty> + CArray::getProperty (PropertyId id) const + { + //kernelPrintDbg (debug::DBG_DBG,"getProperty() " << id); +@@ -88,7 +88,7 @@ + if (id >= value.size()) + throw OutOfRange (); + +- shared_ptr<IProperty> ip = value[id]; ++ boost::shared_ptr<IProperty> ip = value[id]; + // Set mode only if pdf is valid + _setMode (ip,id); + +@@ -146,7 +146,7 @@ + // Check whether we can make the change + this->canChange(); + +- shared_ptr<IProperty> oldip = value[id]; ++ boost::shared_ptr<IProperty> oldip = value[id]; + + // Delete that item + value.erase (remove (value.begin(), value.end(), oldip)); +@@ -156,11 +156,11 @@ + assert (hasValidRef (this)); + + // Create contest +- shared_ptr<ObserverContext> context (_createContext (oldip,id)); ++ boost::shared_ptr<ObserverContext> context (_createContext (oldip,id)); + + try { + // notify observers and dispatch the change +- _objectChanged (shared_ptr<IProperty> (new CNull), context); ++ _objectChanged (boost::shared_ptr<IProperty> (new CNull), context); + + }catch (PdfException&) + { +@@ -181,7 +181,7 @@ + // + // Correctly to add an object (without name) can be done only to Array object + // +-shared_ptr<IProperty> ++boost::shared_ptr<IProperty> + CArray::addProperty (const IProperty& newIp) + { + //kernelPrintDbg (debug::DBG_DBG,"addProperty(...)"); +@@ -193,7 +193,7 @@ + // + // REMARK: because of the compiler, we can't put PropertyId here + // +-shared_ptr<IProperty> ++boost::shared_ptr<IProperty> + CArray::addProperty (PropertyId position, const IProperty& newIp) + { + //kernelPrintDbg (debug::DBG_DBG,"addProperty(" << position << ")"); +@@ -208,7 +208,7 @@ + this->canChange(); + + // Clone the added property +- shared_ptr<IProperty> newIpClone = newIp.clone (); ++ boost::shared_ptr<IProperty> newIpClone = newIp.clone (); + assert (newIpClone); + + // Inherit id, gen number and pdf +@@ -230,7 +230,7 @@ + assert (hasValidRef (this)); + + // Create contest +- shared_ptr<ObserverContext> context (_createContext(shared_ptr<IProperty>(new CNull ()), position)); ++ boost::shared_ptr<ObserverContext> context (_createContext(boost::shared_ptr<IProperty>(new CNull ()), position)); + + try { + // notify observers and dispatch the change +@@ -256,7 +256,7 @@ + // + // + // +-shared_ptr<IProperty> ++boost::shared_ptr<IProperty> + CArray::setProperty (PropertyId id, IProperty& newIp) + { + //kernelPrintDbg (debug::DBG_DBG, "setProperty(" << id << ")"); +@@ -269,9 +269,9 @@ + this->canChange(); + + // Save the old one +- shared_ptr<IProperty> oldip = value[id]; ++ boost::shared_ptr<IProperty> oldip = value[id]; + // Clone the added property +- shared_ptr<IProperty> newIpClone = newIp.clone (); ++ boost::shared_ptr<IProperty> newIpClone = newIp.clone (); + assert (newIpClone); + + // Inherit id, gen number and pdf +@@ -289,7 +289,7 @@ + assert (hasValidRef (this)); + + // Create contest +- shared_ptr<ObserverContext> context (_createContext (oldip,id)); ++ boost::shared_ptr<ObserverContext> context (_createContext (oldip,id)); + + try { + // notify observers and dispatch the change +@@ -437,7 +437,7 @@ + // + // + IProperty::ObserverContext* +-CArray::_createContext (shared_ptr<IProperty> changedIp, PropertyId id) ++CArray::_createContext (boost::shared_ptr<IProperty> changedIp, PropertyId id) + { + //kernelPrintDbg (debug::DBG_DBG, ""); + diff --git a/editors/pdfedit/files/patch-src-kernel-ccontentstream.cc b/editors/pdfedit/files/patch-src-kernel-ccontentstream.cc new file mode 100644 index 000000000000..1c0f2377baaa --- /dev/null +++ b/editors/pdfedit/files/patch-src-kernel-ccontentstream.cc @@ -0,0 +1,152 @@ +--- src/kernel/ccontentstream.cc.orig 2010-04-28 03:42:09.000000000 +0900 ++++ src/kernel/ccontentstream.cc 2016-06-11 06:33:26.838638000 +0900 +@@ -68,7 +68,7 @@ + * @param observer Operand observer. + */ + void +- opsSetPdfRefCs (shared_ptr<PdfOperator> first, ++ opsSetPdfRefCs (boost::shared_ptr<PdfOperator> first, + boost::weak_ptr<CPdf> pdf, + IndiRef rf, + CContentStream& cs, +@@ -204,7 +204,7 @@ + }else + {// We have an OPERAND + +- shared_ptr<IProperty> pIp (createObjFromXpdfObj (*o)); ++ boost::shared_ptr<IProperty> pIp (createObjFromXpdfObj (*o)); + operands.push_back (pIp); + } + +@@ -223,14 +223,14 @@ + * @param streamreader CStreams parser from which we get an xpdf object. + * @param operands Operands of operator. They are shared through subcalls. + */ +- shared_ptr<PdfOperator> ++ boost::shared_ptr<PdfOperator> + createOperatorFromStream (CStreamsXpdfReader<CContentStream::CStreams>& streamreader, + PdfOperator::Operands& operands) + { + // Get operands + boost::shared_ptr< ::Object> o(XPdfObjectFactory::getInstance(), xpdf::object_deleter()); + if (!createOperandsFromStream (streamreader, operands, o)) +- return shared_ptr<PdfOperator> (); ++ return boost::shared_ptr<PdfOperator> (); + + // + // SPECIAL CASE for inline image (stream within a text stream) +@@ -246,8 +246,8 @@ + throw ElementBadTypeException ("Content stream operator has incorrect operand type."); + } + +- shared_ptr<CInlineImage> inimg (getInlineImage (streamreader)); +- return shared_ptr<PdfOperator> (new InlineImageCompositePdfOperator (inimg, chcktp->name, chcktp->endTag)); ++ boost::shared_ptr<CInlineImage> inimg (getInlineImage (streamreader)); ++ return boost::shared_ptr<PdfOperator> (new InlineImageCompositePdfOperator (inimg, chcktp->name, chcktp->endTag)); + } + + // factory function for all other operators +@@ -269,11 +269,11 @@ + * + * @return New pdf operator. + */ +- shared_ptr<PdfOperator> ++ boost::shared_ptr<PdfOperator> + parseOp (CStreamsXpdfReader<CContentStream::CStreams>& streamreader, PdfOperator::Operands& operands) + { + // Create operator with its operands +- shared_ptr<PdfOperator> result = createOperatorFromStream (streamreader, operands); ++ boost::shared_ptr<PdfOperator> result = createOperatorFromStream (streamreader, operands); + + if (result && isCompositeOp (result) && !isInlineImageOp (result)) + { +@@ -283,7 +283,7 @@ + bool foundEndTag = false; + + // The same as in (re)parse +- shared_ptr<PdfOperator> newop, previousLast = result; ++ boost::shared_ptr<PdfOperator> newop, previousLast = result; + + // + // Use recursion to get all operators +@@ -348,7 +348,7 @@ + if (!hasValidPdf (*it) || !hasValidRef (*it)) + throw CObjInvalidObject (); + } +- weak_ptr<CPdf> pdf = streams.front()->getPdf (); ++ boost::weak_ptr<CPdf> pdf = streams.front()->getPdf (); + assert (pdf.lock()); + IndiRef rf = streams.front()->getIndiRef (); + +@@ -357,8 +357,8 @@ + streamreader.open (); + + PdfOperator::Operands operands; +- shared_ptr<PdfOperator> topoperator (new UnknownCompositePdfOperator ("","")); +- shared_ptr<PdfOperator> newop, previousLast = topoperator; ++ boost::shared_ptr<PdfOperator> topoperator (new UnknownCompositePdfOperator ("","")); ++ boost::shared_ptr<PdfOperator> newop, previousLast = topoperator; + + // + // Parsing can throw, if so the stream is invalid +@@ -469,10 +469,10 @@ + typedef PdfOperator::BBox BBox; + + // Init resources +- void operator() (shared_ptr<GfxResources>) const {} ++ void operator() (boost::shared_ptr<GfxResources>) const {} + + // Loop through operators +- void operator() (shared_ptr<PdfOperator> op, BBox rc, const GfxState&) const ++ void operator() (boost::shared_ptr<PdfOperator> op, BBox rc, const GfxState&) const + { + // If not initialized, means an error occured (missing font etc..) + if (!BBox::isInitialized (rc)) +@@ -736,7 +736,7 @@ + + // Notify observers + boost::shared_ptr<CContentStream> current (this, EmptyDeallocator<CContentStream> ()); +- this->notifyObservers (current, shared_ptr<const ObserverContext> (new BasicObserverContext (current))); ++ this->notifyObservers (current, boost::shared_ptr<const ObserverContext> (new BasicObserverContext (current))); + } + + +@@ -856,7 +856,7 @@ + // Set correct IndiRef, CPdf and cs to inserted operator + assert (hasValidRef (cstreams.front())); + assert (hasValidPdf (cstreams.front())); +- weak_ptr<CPdf> pdf = cstreams.front()->getPdf(); ++ boost::weak_ptr<CPdf> pdf = cstreams.front()->getPdf(); + assert (pdf.lock()); + IndiRef rf = cstreams.front()->getIndiRef (); + opsSetPdfRefCs (newOper, pdf, rf, *this, operandobserver); +@@ -937,7 +937,7 @@ + // Check whether we can make the change + cstreams.front()->canChange(); + IndiRef rf = cstreams.front()->getIndiRef (); +- weak_ptr<CPdf> pdf = cstreams.front()->getPdf(); ++ boost::weak_ptr<CPdf> pdf = cstreams.front()->getPdf(); + assert (pdf.lock()); + // set accordingly + opsSetPdfRefCs (newoper, pdf, rf, *this, operandobserver); +@@ -949,9 +949,9 @@ + { // Insert into + opsSetPdfRefCs (newoper, pdf, rf, *this, operandobserver); + +- shared_ptr<PdfOperator> secondoper = operators.front(); ++ boost::shared_ptr<PdfOperator> secondoper = operators.front(); + operators.push_front (newoper); +- shared_ptr<PdfOperator> lastofnew = getLastOperator (newoper); ++ boost::shared_ptr<PdfOperator> lastofnew = getLastOperator (newoper); + secondoper->setPrev (lastofnew); + lastofnew->setNext (secondoper); + } +@@ -992,7 +992,7 @@ + // Set correct IndiRef, CPdf and cs to inserted operator + assert (hasValidRef (cstreams.front())); + assert (hasValidPdf (cstreams.front())); +- weak_ptr<CPdf> pdf = cstreams.front()->getPdf(); ++ boost::weak_ptr<CPdf> pdf = cstreams.front()->getPdf(); + assert (pdf.lock()); + IndiRef rf = cstreams.front()->getIndiRef (); + opsSetPdfRefCs (newOper, pdf, rf, *this, operandobserver); diff --git a/editors/pdfedit/files/patch-src-kernel-cdict.cc b/editors/pdfedit/files/patch-src-kernel-cdict.cc new file mode 100644 index 000000000000..3c46524d3582 --- /dev/null +++ b/editors/pdfedit/files/patch-src-kernel-cdict.cc @@ -0,0 +1,149 @@ +--- src/kernel/cdict.cc.orig 2010-04-28 03:42:09.000000000 +0900 ++++ src/kernel/cdict.cc 2016-06-11 06:01:28.994503000 +0900 +@@ -95,7 +95,7 @@ + // + // + // +-shared_ptr<IProperty> ++boost::shared_ptr<IProperty> + CDict::getProperty (PropertyId id) const + { + //kernelPrintDbg (debug::DBG_DBG,"getProperty() " << id); +@@ -111,7 +111,7 @@ + if (it == value.end()) + throw ElementNotFoundException ("", ""); + +- shared_ptr<IProperty> ip = cmp.getIProperty (); ++ boost::shared_ptr<IProperty> ip = cmp.getIProperty (); + + // Set mode only if pdf is valid + _setMode (ip,id); +@@ -188,7 +188,7 @@ + if (oldit == value.end()) + throw ElementNotFoundException ("CDict", "item not found"); + +- shared_ptr<IProperty> oldip = cmp.getIProperty (); ++ boost::shared_ptr<IProperty> oldip = cmp.getIProperty (); + + // Delete that item + value.erase (oldit); +@@ -198,11 +198,11 @@ + assert (hasValidRef (this)); + + // Indicate that this object has changed +- shared_ptr<ObserverContext> context (_createContext (oldip,id)); ++ boost::shared_ptr<ObserverContext> context (_createContext (oldip,id)); + + try { + // notify observers and dispatch the change +- _objectChanged (shared_ptr<IProperty> (new CNull), context); ++ _objectChanged (boost::shared_ptr<IProperty> (new CNull), context); + + }catch (PdfException&) + { +@@ -224,7 +224,7 @@ + // + // Correctly add an object (with name) can be done only to Dict and Stream object + // +-shared_ptr<IProperty> ++boost::shared_ptr<IProperty> + CDict::addProperty (const string& propertyName, const IProperty& newIp) + { + kernelPrintDbg (debug::DBG_DBG,"addProperty( " << propertyName << ",...)"); +@@ -239,7 +239,7 @@ + throw CObjInvalidObject (); + + // Clone the added property +- shared_ptr<IProperty> newIpClone = newIp.clone (); ++ boost::shared_ptr<IProperty> newIpClone = newIp.clone (); + if (newIpClone) + { + // Inherit id, gen number and pdf +@@ -260,7 +260,7 @@ + assert (hasValidRef (this)); + + // notify observers and dispatch change +- shared_ptr<ObserverContext> context (_createContext(shared_ptr<IProperty>(new CNull ()), propertyName)); ++ boost::shared_ptr<ObserverContext> context (_createContext(boost::shared_ptr<IProperty>(new CNull ()), propertyName)); + + try { + // notify observers and dispatch the change +@@ -285,7 +285,7 @@ + // + // + // +-shared_ptr<IProperty> ++boost::shared_ptr<IProperty> + CDict::setProperty (PropertyId id, IProperty& newIp) + { + kernelPrintDbg (debug::DBG_DBG, "setProperty(" << id << ")"); +@@ -308,9 +308,9 @@ + return addProperty (id, newIp); + + // Save the old one +- shared_ptr<IProperty> oldIp = cmp.getIProperty (); ++ boost::shared_ptr<IProperty> oldIp = cmp.getIProperty (); + // Clone the added property +- shared_ptr<IProperty> newIpClone = newIp.clone (); ++ boost::shared_ptr<IProperty> newIpClone = newIp.clone (); + assert (newIpClone); + + // Inherit id, gen number and pdf +@@ -328,7 +328,7 @@ + assert (hasValidRef (this)); + + // Notify observers and dispatch change +- shared_ptr<ObserverContext> context (_createContext (oldIp,id)); ++ boost::shared_ptr<ObserverContext> context (_createContext (oldIp,id)); + + try { + // notify observers and dispatch the change +@@ -382,7 +382,7 @@ + Value::const_iterator it = value.begin(); + for (; it != value.end(); ++it) + { +- shared_ptr<IProperty> prop = it->second; ++ boost::shared_ptr<IProperty> prop = it->second; + Object * propObj = prop->_makeXpdfObject(); + dictObj->dictAdd(copyString((it->first).c_str()), propObj); + gfree(propObj); +@@ -398,7 +398,7 @@ + // + void + CDict::_objectChanged +- (shared_ptr<IProperty> newValue, shared_ptr<const ObserverContext> context) ++ (boost::shared_ptr<IProperty> newValue, boost::shared_ptr<const ObserverContext> context) + { + // Do not notify anything if we are not in a valid pdf + if (!hasValidPdf (this)) +@@ -424,10 +424,10 @@ + // Set mode + // + void +-CDict::_setMode (shared_ptr<IProperty> ip, PropertyId id) const ++CDict::_setMode (boost::shared_ptr<IProperty> ip, PropertyId id) const + { + configuration::ModeController* modecontroller = NULL; +- shared_ptr<CPdf> p = this->getPdf().lock(); ++ boost::shared_ptr<CPdf> p = this->getPdf().lock(); + if ( p && (NULL != (modecontroller=p->getModeController()))) + { + assert (modecontroller); +@@ -451,7 +451,7 @@ + }else + { // We have found a type + string tmp; +- shared_ptr<IProperty> type = cmp.getIProperty (); ++ boost::shared_ptr<IProperty> type = cmp.getIProperty (); + if (isName (type)) + IProperty::getSmartCObjectPtr<CName>(type)->getValue(tmp); + mode = modecontroller->getMode (tmp, id); +@@ -498,7 +498,7 @@ + // + // + IProperty::ObserverContext* +-CDict::_createContext (shared_ptr<IProperty> changedIp, PropertyId id) ++CDict::_createContext (boost::shared_ptr<IProperty> changedIp, PropertyId id) + { + // Create the context + return new CDictComplexObserverContext (changedIp, id); diff --git a/editors/pdfedit/files/patch-src-kernel-cdict.h b/editors/pdfedit/files/patch-src-kernel-cdict.h new file mode 100644 index 000000000000..a804622394e6 --- /dev/null +++ b/editors/pdfedit/files/patch-src-kernel-cdict.h @@ -0,0 +1,20 @@ +--- src/kernel/cdict.h.orig 2016-06-11 05:41:31.261535000 +0900 ++++ src/kernel/cdict.h 2016-06-11 05:44:42.503741000 +0900 +@@ -799,7 +799,7 @@ + } + + // Cast it to dict +- CDict* dict = dynamic_cast<const CDict*> (&ip); ++ const CDict* dict = dynamic_cast<const CDict*> (&ip); + setSimpleValueInDict<Value, ItemType, ItemPType> (*dict, name, val); + } + +@@ -812,7 +812,7 @@ + throw ElementBadTypeException (""); + + // Cast it to dict +- CDict* dict = dynamic_cast<const CDict*> (&ip); ++ const CDict* dict = dynamic_cast<const CDict*> (&ip); + + setSimpleValueInDict<ItemType> (*dict, name, val); + } diff --git a/editors/pdfedit/files/patch-src-kernel-cobject.cc b/editors/pdfedit/files/patch-src-kernel-cobject.cc new file mode 100644 index 000000000000..6e0819c6f56f --- /dev/null +++ b/editors/pdfedit/files/patch-src-kernel-cobject.cc @@ -0,0 +1,11 @@ +--- src/kernel/cobject.cc.orig 2016-06-11 06:02:30.123217000 +0900 ++++ src/kernel/cobject.cc 2016-06-11 06:02:50.095614000 +0900 +@@ -60,7 +60,7 @@ + if (!hasValidPdf (ip)) + throw CObjInvalidOperation (); + +- shared_ptr<CPdf> pdf = ip.getPdf ().lock (); ++ boost::shared_ptr<CPdf> pdf = ip.getPdf ().lock (); + IndiRef ref = ip.getIndiRef(); + if ( &ip == (indiObj=pdf->getIndirectProperty(ref)).get() ) + return false; diff --git a/editors/pdfedit/files/patch-src-kernel-cobject2string.cc b/editors/pdfedit/files/patch-src-kernel-cobject2string.cc new file mode 100644 index 000000000000..615665f4ceda --- /dev/null +++ b/editors/pdfedit/files/patch-src-kernel-cobject2string.cc @@ -0,0 +1,11 @@ +--- src/kernel/cobject2string.cc.orig 2016-06-11 06:20:13.726775000 +0900 ++++ src/kernel/cobject2string.cc 2016-06-11 06:20:28.472463000 +0900 +@@ -81,7 +81,7 @@ + void + simpleValueFromString (const std::string& str, double& val) + { +- shared_ptr<Object> ptrObj (xpdfObjFromString(str), xpdf::object_deleter()); ++ boost::shared_ptr<Object> ptrObj (xpdfObjFromString(str), xpdf::object_deleter()); + + assert (objReal == ptrObj->getType ()); + if (objReal != ptrObj->getType() && objInt != ptrObj->getType()) diff --git a/editors/pdfedit/files/patch-src-kernel-cobject2xpdf.cc b/editors/pdfedit/files/patch-src-kernel-cobject2xpdf.cc new file mode 100644 index 000000000000..95d4d7ce45d9 --- /dev/null +++ b/editors/pdfedit/files/patch-src-kernel-cobject2xpdf.cc @@ -0,0 +1,47 @@ +--- src/kernel/cobject2xpdf.cc.orig 2016-06-11 06:17:18.518993000 +0900 ++++ src/kernel/cobject2xpdf.cc 2016-06-11 06:18:14.021576000 +0900 +@@ -453,16 +453,16 @@ + // Get Object at i-th position + array.arrayGetNF (i, obj.get()); + +- shared_ptr<IProperty> cobj; ++ boost::shared_ptr<IProperty> cobj; + // Create CObject from it + if (isPdfValid(pdf)) + { + hasValidRef (ip); +- cobj = shared_ptr<IProperty> (createObjFromXpdfObj (pdf, *obj, ip.getIndiRef())); ++ cobj = boost::shared_ptr<IProperty> (createObjFromXpdfObj (pdf, *obj, ip.getIndiRef())); + + }else + { +- cobj = shared_ptr<IProperty> (createObjFromXpdfObj (*obj)); ++ cobj = boost::shared_ptr<IProperty> (createObjFromXpdfObj (*obj)); + } + + if (cobj) +@@ -504,12 +504,12 @@ + obj->free (); + dict.dictGetValNF (i,obj.get()); + +- shared_ptr<IProperty> cobj; ++ boost::shared_ptr<IProperty> cobj; + // Create CObject from it + if (isPdfValid (pdf)) +- cobj = shared_ptr<IProperty> (createObjFromXpdfObj (pdf, *obj, ip.getIndiRef())); ++ cobj = boost::shared_ptr<IProperty> (createObjFromXpdfObj (pdf, *obj, ip.getIndiRef())); + else +- cobj = shared_ptr<IProperty> (createObjFromXpdfObj (*obj)); ++ cobj = boost::shared_ptr<IProperty> (createObjFromXpdfObj (*obj)); + + if (cobj) + { +@@ -1021,7 +1021,7 @@ + // for Dict -> String conversion + // initDict increases streamDict's reference thus we need to + // decrease it back by free +- shared_ptr< ::Object> streamDictObj(XPdfObjectFactory::getInstance(), xpdf::object_deleter()); ++ boost::shared_ptr< ::Object> streamDictObj(XPdfObjectFactory::getInstance(), xpdf::object_deleter()); + streamDictObj->initDict((Dict *)streamObject.streamGetDict()); + std::string dict; + xpdfObjToString(*streamDictObj, dict); diff --git a/editors/pdfedit/files/patch-src-kernel-cobjecthelpers.cc b/editors/pdfedit/files/patch-src-kernel-cobjecthelpers.cc new file mode 100644 index 000000000000..e47904472ee3 --- /dev/null +++ b/editors/pdfedit/files/patch-src-kernel-cobjecthelpers.cc @@ -0,0 +1,142 @@ +--- src/kernel/cobjecthelpers.cc.orig 2016-06-11 06:22:02.988983000 +0900 ++++ src/kernel/cobjecthelpers.cc 2016-06-11 06:23:38.529873000 +0900 +@@ -42,14 +42,14 @@ + { + using namespace boost; + +- shared_ptr<IProperty> prop_ptr=dict->getProperty(name); ++ boost::shared_ptr<IProperty> prop_ptr=dict->getProperty(name); + if(prop_ptr->getType() != pInt) + { + // malformed dictionary + throw ElementBadTypeException(name/*, prop_ptr->getType()*/); + } + +- shared_ptr<CInt> int_ptr=IProperty::getSmartCObjectPtr<CInt>(prop_ptr); ++ boost::shared_ptr<CInt> int_ptr=IProperty::getSmartCObjectPtr<CInt>(prop_ptr); + return int_ptr->getValue(); + } + +@@ -57,14 +57,14 @@ + { + using namespace boost; + +- shared_ptr<IProperty> prop_ptr=dict->getProperty(name); ++ boost::shared_ptr<IProperty> prop_ptr=dict->getProperty(name); + if(prop_ptr->getType() != pRef) + { + // malformed dictionary + throw ElementBadTypeException(name/*, prop_ptr->getType()*/); + } + +- shared_ptr<CRef> int_ptr=IProperty::getSmartCObjectPtr<CRef>(prop_ptr); ++ boost::shared_ptr<CRef> int_ptr=IProperty::getSmartCObjectPtr<CRef>(prop_ptr); + return int_ptr->getValue(); + } + +@@ -72,14 +72,14 @@ + { + using namespace boost; + +- shared_ptr<IProperty> prop_ptr=dict->getProperty(name); ++ boost::shared_ptr<IProperty> prop_ptr=dict->getProperty(name); + if(prop_ptr->getType() != pString) + { + // malformed dictionary + throw ElementBadTypeException(name); + } + +- shared_ptr<CString> str_ptr=IProperty::getSmartCObjectPtr<CString>(prop_ptr); ++ boost::shared_ptr<CString> str_ptr=IProperty::getSmartCObjectPtr<CString>(prop_ptr); + return str_ptr->getValue(); + } + +@@ -87,14 +87,14 @@ + { + using namespace boost; + +- shared_ptr<IProperty> prop_ptr=dict->getProperty(name); ++ boost::shared_ptr<IProperty> prop_ptr=dict->getProperty(name); + if(prop_ptr->getType() != pName) + { + // malformed dictionary + throw ElementBadTypeException(name); + } + +- shared_ptr<CName> name_ptr=IProperty::getSmartCObjectPtr<CName>(prop_ptr); ++ boost::shared_ptr<CName> name_ptr=IProperty::getSmartCObjectPtr<CName>(prop_ptr); + std::string value; + name_ptr->getValue(value); + +@@ -125,7 +125,7 @@ + // gets reference value and dereferences indirect object + IndiRef ref; + IProperty::getSmartCObjectPtr<CRef>(refProp)->getValue(ref); +- shared_ptr<CPdf> pdf = refProp->getPdf().lock(); ++ boost::shared_ptr<CPdf> pdf = refProp->getPdf().lock(); + assert(pdf); + boost::shared_ptr<IProperty> indirect_ptr=pdf->getIndirectProperty(ref); + if(indirect_ptr->getType() != pDict) +@@ -237,7 +237,7 @@ + + IndiRef ref; + IProperty::getSmartCObjectPtr<CRef>(ip)->getValue(ref); +- shared_ptr<CPdf> pdf = ip->getPdf().lock(); ++ boost::shared_ptr<CPdf> pdf = ip->getPdf().lock(); + assert(pdf); + return pdf->getIndirectProperty (ref); + +@@ -254,7 +254,7 @@ + + // pdf specification says that two diagonal corners should be used and + // readers has to be prepared to normalize it +- shared_ptr<CArray> array(CArrayFactory::getInstance()); ++ boost::shared_ptr<CArray> array(CArrayFactory::getInstance()); + scoped_ptr<IProperty> llx(CRealFactory::getInstance(rect.xleft)); + scoped_ptr<IProperty> lly(CRealFactory::getInstance(rect.yleft)); + scoped_ptr<IProperty> urx(CRealFactory::getInstance(rect.xright)); +@@ -267,12 +267,12 @@ + return array; + } + +-void getRectangleFromProperty(const shared_ptr<IProperty> prop, libs::Rectangle & rect) ++void getRectangleFromProperty(const boost::shared_ptr<IProperty> prop, libs::Rectangle & rect) + { + if(!isArray(prop)) + throw CObjBadValue(); + +- shared_ptr<CArray> array = IProperty::getSmartCObjectPtr<CArray>(prop); ++ boost::shared_ptr<CArray> array = IProperty::getSmartCObjectPtr<CArray>(prop); + if(array->getPropertyCount() != 4) + throw CObjBadValue(); + +@@ -286,7 +286,7 @@ + { + using namespace boost; + +- shared_ptr<CString> dateString(CStringFactory::getInstance()); ++ boost::shared_ptr<CString> dateString(CStringFactory::getInstance()); + char buffer[30]; + memset(buffer, '\0', sizeof(buffer)); + +@@ -304,7 +304,7 @@ + { + using namespace boost; + +- shared_ptr<IProperty> value; ++ boost::shared_ptr<IProperty> value; + try + { + value=annotDict->getProperty(fieldName); +@@ -323,9 +323,9 @@ + // + // + ::XRef* +-getXRef (shared_ptr<IProperty> ip) ++getXRef (boost::shared_ptr<IProperty> ip) + { +- shared_ptr<CPdf> pdf = ip->getPdf().lock(); ++ boost::shared_ptr<CPdf> pdf = ip->getPdf().lock(); + if(!pdf) + return NULL; + return pdf->getCXref(); diff --git a/editors/pdfedit/files/patch-src-kernel-contentschangetag.cc b/editors/pdfedit/files/patch-src-kernel-contentschangetag.cc new file mode 100644 index 000000000000..8325dfe01201 --- /dev/null +++ b/editors/pdfedit/files/patch-src-kernel-contentschangetag.cc @@ -0,0 +1,25 @@ +--- src/kernel/contentschangetag.cc.orig 2016-06-12 02:53:06.107246000 +0900 ++++ src/kernel/contentschangetag.cc 2016-06-12 02:53:37.952146000 +0900 +@@ -51,11 +51,11 @@ + PdfOperator::Operands opers; + + // Name or our application +- shared_ptr<CName> name (new CName (CHANGE_TAG_ID)); ++ boost::shared_ptr<CName> name (new CName (CHANGE_TAG_ID)); + opers.push_back (name); + + // Dict with our informatio +- shared_ptr<CDict> dict (new CDict ()); ++ boost::shared_ptr<CDict> dict (new CDict ()); + time_t t = time (NULL); + ostringstream oss; + oss << t; +@@ -72,7 +72,7 @@ + // + // + time_t +-ContentsChangeTag::getTime (shared_ptr<PdfOperator> op) ++ContentsChangeTag::getTime (boost::shared_ptr<PdfOperator> op) + { + assert (op); + diff --git a/editors/pdfedit/files/patch-src-kernel-cpage.cc b/editors/pdfedit/files/patch-src-kernel-cpage.cc new file mode 100644 index 000000000000..aad73157d462 --- /dev/null +++ b/editors/pdfedit/files/patch-src-kernel-cpage.cc @@ -0,0 +1,35 @@ +--- src/kernel/cpage.cc.orig 2016-06-11 10:20:24.977833000 +0900 ++++ src/kernel/cpage.cc 2016-06-11 10:21:15.509192000 +0900 +@@ -88,9 +88,9 @@ + // + // Init modules + // +- _contents = shared_ptr<CPageContents> (new CPageContents(this)); ++ _contents = boost::shared_ptr<CPageContents> (new CPageContents(this)); + _modules.push_back (_contents); +- _display = shared_ptr<CPageDisplay> (new CPageDisplay(this)); ++ _display = boost::shared_ptr<CPageDisplay> (new CPageDisplay(this)); + _modules.push_back (_display); + _fonts = boost::shared_ptr<CPageFonts> (new CPageFonts(this)); + _modules.push_back (_fonts); +@@ -252,7 +252,7 @@ + CPage::getPagePosition () const + { + if (hasValidPdf (_dict)) +- return _dict->getPdf().lock()->getPagePosition (shared_ptr<CPage>(const_cast<CPage*>(this),EmptyDeallocator<CPage> ())); ++ return _dict->getPdf().lock()->getPagePosition (boost::shared_ptr<CPage>(const_cast<CPage*>(this),EmptyDeallocator<CPage> ())); + + throw CObjInvalidOperation (); + } +@@ -284,9 +284,9 @@ + + // Notify observers + if (invalid) +- this->notifyObservers (current, shared_ptr<const ObserverContext> ()); ++ this->notifyObservers (current, boost::shared_ptr<const ObserverContext> ()); + else +- this->notifyObservers (current, shared_ptr<const ObserverContext> (new BasicObserverContext (current))); ++ this->notifyObservers (current, boost::shared_ptr<const ObserverContext> (new BasicObserverContext (current))); + } + + diff --git a/editors/pdfedit/files/patch-src-kernel-cpageannots.cc b/editors/pdfedit/files/patch-src-kernel-cpageannots.cc new file mode 100644 index 000000000000..3d7e87d13a98 --- /dev/null +++ b/editors/pdfedit/files/patch-src-kernel-cpageannots.cc @@ -0,0 +1,201 @@ +--- src/kernel/cpageannots.cc.orig 2016-06-12 03:18:12.132253000 +0900 ++++ src/kernel/cpageannots.cc 2016-06-12 03:21:24.901602000 +0900 +@@ -180,24 +180,24 @@ + + typedef struct reg_annots + { +- void operator() (shared_ptr<IProperty> obj, boost::shared_ptr<IPropertyObserver> obs) ++ void operator() (boost::shared_ptr<IProperty> obj, boost::shared_ptr<IPropertyObserver> obs) + { REGISTER_SHAREDPTR_OBSERVER (obj, obs); } + }reg_annots; + + typedef struct unreg_annots + { +- void operator() (shared_ptr<IProperty> obj, boost::shared_ptr<IPropertyObserver> obs) ++ void operator() (boost::shared_ptr<IProperty> obj, boost::shared_ptr<IPropertyObserver> obs) + { UNREGISTER_SHAREDPTR_OBSERVER (obj, obs); } + }unreg_annots; + + // generic {un}register function + template<typename T> +- void egister_annots (shared_ptr<IProperty> annots, ++ void egister_annots (boost::shared_ptr<IProperty> annots, + T egister, + boost::shared_ptr<IPropertyObserver> _prop_wd, + boost::shared_ptr<IPropertyObserver> _array_wd) + { +- shared_ptr<CArray> annotsArray; ++ boost::shared_ptr<CArray> annotsArray; + if(isRef(annots)) + { + egister(annots, _prop_wd); +@@ -237,7 +237,7 @@ + // + // + void +-CPageAnnots::reg_observers(shared_ptr<IProperty> annots) ++CPageAnnots::reg_observers(boost::shared_ptr<IProperty> annots) + { + kernelPrintDbg(DBG_DBG, ""); + +@@ -251,7 +251,7 @@ + REGISTER_SHAREDPTR_OBSERVER(_page->getDictionary(), _prop_wd); + if(_page->getDictionary()->containsProperty(Specification::Page::ANNOTS)) + { +- shared_ptr<IProperty> annotsProp=_page->getDictionary()->getProperty(Specification::Page::ANNOTS); ++ boost::shared_ptr<IProperty> annotsProp=_page->getDictionary()->getProperty(Specification::Page::ANNOTS); + reg_observers(annotsProp); + } + } +@@ -275,7 +275,7 @@ + UNREGISTER_SHAREDPTR_OBSERVER(_page->getDictionary(), _prop_wd); + if(_page->getDictionary()->containsProperty(Specification::Page::ANNOTS)) + { +- shared_ptr<IProperty> annotsProp=_page->getDictionary()->getProperty(Specification::Page::ANNOTS); ++ boost::shared_ptr<IProperty> annotsProp=_page->getDictionary()->getProperty(Specification::Page::ANNOTS); + unreg_observers(annotsProp); + } + } +@@ -299,12 +299,12 @@ + { + try + { +- shared_ptr<CDict> annotDict=getCObjectFromRef<CDict>(oldValue); ++ boost::shared_ptr<CDict> annotDict=getCObjectFromRef<CDict>(oldValue); + Annotations::iterator i; + bool erased = false; + for(i=_annotations.begin(); i!=_annotations.end(); ++i) + { +- shared_ptr<CAnnotation> annot=*i; ++ boost::shared_ptr<CAnnotation> annot=*i; + if(annot->getDictionary()==annotDict) + { + kernelPrintDbg(debug::DBG_DBG, "Annotation maintaining oldValue found and removed. Invalidating annotation"); +@@ -334,11 +334,11 @@ + { + try + { +- shared_ptr<CDict> annotDict=getCObjectFromRef<CDict>(newValue); ++ boost::shared_ptr<CDict> annotDict=getCObjectFromRef<CDict>(newValue); + + // creates CAnnotation instance from dereferenced dictionary + // and adds it to _annotations +- shared_ptr<CAnnotation> annot(new CAnnotation(annotDict)); ++ boost::shared_ptr<CAnnotation> annot(new CAnnotation(annotDict)); + _annotations.push_back(annot); + }catch(ElementBadTypeException & ) + { +@@ -362,7 +362,7 @@ + + // gets Annots array from page dictionary. If no found, creates it. If bad + // typed, throws an exception +- shared_ptr<CArray> annotsArray; ++ boost::shared_ptr<CArray> annotsArray; + try + { + annotsArray=getAnnotsArray(_page->getDictionary()); +@@ -395,7 +395,7 @@ + IndiRef annotRef=pdf->addIndirectProperty(annot->getDictionary()); + + // gets added annotation dictionary +- shared_ptr<CDict> annotDict=IProperty::getSmartCObjectPtr<CDict>( ++ boost::shared_ptr<CDict> annotDict=IProperty::getSmartCObjectPtr<CDict>( + pdf->getIndirectProperty(annotRef) + ); + +@@ -403,7 +403,7 @@ + // updates P field with reference to this page + // This is not explictly required by specification for all annotation types, + // but is not an error to supply this information +- shared_ptr<CRef> pageRef(CRefFactory::getInstance(_page->getDictionary()->getIndiRef())); ++ boost::shared_ptr<CRef> pageRef(CRefFactory::getInstance(_page->getDictionary()->getIndiRef())); + checkAndReplace(annotDict, "P", *pageRef); + + kernelPrintDbg(debug::DBG_INFO, "Adding reference "<<annotRef<<" to annotation dictionary to Annots array"); +@@ -427,7 +427,7 @@ + size_t pos=0; + for(Annotations::iterator i=_annotations.begin(); i!=_annotations.end(); ++i,++pos) + { +- shared_ptr<CAnnotation> element=*i; ++ boost::shared_ptr<CAnnotation> element=*i; + if(annot!=element) + continue; + +@@ -436,7 +436,7 @@ + kernelPrintDbg(debug::DBG_DBG, "Annotation found. Indiref="<<annotRef); + try + { +- shared_ptr<CArray> annotArray=getAnnotsArray(_page->getDictionary()); ++ boost::shared_ptr<CArray> annotArray=getAnnotsArray(_page->getDictionary()); + // deleting of this reference triggers annotsWatchDog observer which + // will synchronize _annotations with current state + annotArray->delProperty(pos); +@@ -476,13 +476,13 @@ + } + + kernelPrintDbg(DBG_DBG, "context type="<<context->getType()); +- shared_ptr<IProperty> oldValue; ++ boost::shared_ptr<IProperty> oldValue; + switch(context->getType()) + { + case BasicChangeContextType: + { + // this means that Annots element reference value has changed +- shared_ptr<const BasicChangeContext<IProperty> > basicContext= ++ boost::shared_ptr<const BasicChangeContext<IProperty> > basicContext= + dynamic_pointer_cast<const BasicChangeContext<IProperty>, const observer::IChangeContext<IProperty> >(context); + oldValue=basicContext->getOriginalValue(); + assert(isRef(newValue)); +@@ -494,7 +494,7 @@ + case ComplexChangeContextType: + { + // Annots array content has changed +- shared_ptr<const CArray::CArrayComplexObserverContext > basicContext= ++ boost::shared_ptr<const CArray::CArrayComplexObserverContext > basicContext= + dynamic_pointer_cast<const CArray::CArrayComplexObserverContext, + const IChangeContext<IProperty> >(context); + if(!context) +@@ -540,14 +540,14 @@ + } + + kernelPrintDbg(DBG_DBG, "context type="<<context->getType()); +- shared_ptr<IProperty> oldValue; ++ boost::shared_ptr<IProperty> oldValue; + switch(context->getType()) + { + case BasicChangeContextType: + { + // This means that Annots property is reference and it has + // changed its reference value +- shared_ptr<const observer::BasicChangeContext<IProperty> > basicContext= ++ boost::shared_ptr<const observer::BasicChangeContext<IProperty> > basicContext= + dynamic_pointer_cast<const observer::BasicChangeContext<IProperty>, const observer::IChangeContext<IProperty> >(context); + oldValue=basicContext->getOriginalValue(); + assert(isRef(newValue)); +@@ -559,7 +559,7 @@ + // page dictionary has changed + // checks identificator of changed property and if it is not + // Annots, immediately returns +- shared_ptr<const CDict::CDictComplexObserverContext > basicContext= ++ boost::shared_ptr<const CDict::CDictComplexObserverContext > basicContext= + dynamic_pointer_cast<const CDict::CDictComplexObserverContext, + const IChangeContext<IProperty> >(context); + if(!basicContext) +@@ -588,7 +588,7 @@ + // gets original annots array and unregisters all observers + // doesn't unregister observer from Annots property, because it is done only + // in case of complex context +- shared_ptr<IProperty> oldArray; ++ boost::shared_ptr<IProperty> oldArray; + if(isRef(oldValue)) + { + try +@@ -618,7 +618,7 @@ + // registers obsevers to newValue annotation array - Annots property doesn't + // need obsever registration for same reason as oldValue doesn't need + // unregistration +- shared_ptr<IProperty> newArray; ++ boost::shared_ptr<IProperty> newArray; + if(isRef(newValue)) + { + try diff --git a/editors/pdfedit/files/patch-src-kernel-cpageattributes.cc b/editors/pdfedit/files/patch-src-kernel-cpageattributes.cc new file mode 100644 index 000000000000..6e3753d5cf5d --- /dev/null +++ b/editors/pdfedit/files/patch-src-kernel-cpageattributes.cc @@ -0,0 +1,88 @@ +--- src/kernel/cpageattributes.cc.orig 2016-06-11 10:28:48.940221000 +0900 ++++ src/kernel/cpageattributes.cc 2016-06-11 10:29:31.800132000 +0900 +@@ -47,7 +47,7 @@ + // + // + void +-CPageAttributes::fillInherited(const shared_ptr<CDict> pageDict, InheritedAttributes& attrs) ++CPageAttributes::fillInherited(const boost::shared_ptr<CDict> pageDict, InheritedAttributes& attrs) + { + int initialized=0; + +@@ -59,7 +59,7 @@ + // attrs.__resources field is not specified yet, so tries this dictionary + if(pageDict->containsProperty(Specification::Page::RESOURCES)) + { +- shared_ptr<IProperty> prop=pageDict->getProperty(Specification::Page::RESOURCES); ++ boost::shared_ptr<IProperty> prop=pageDict->getProperty(Specification::Page::RESOURCES); + if(isRef(prop)) + { + attrs._resources=getCObjectFromRef<CDict>(prop); +@@ -81,7 +81,7 @@ + // attrs._mediaBox field is not specified yet, so tries this array + if(pageDict->containsProperty(Specification::Page::MEDIABOX)) + { +- shared_ptr<IProperty> prop=pageDict->getProperty(Specification::Page::MEDIABOX); ++ boost::shared_ptr<IProperty> prop=pageDict->getProperty(Specification::Page::MEDIABOX); + if(isRef(prop)) + { + attrs._mediaBox=getCObjectFromRef<CArray>(prop); +@@ -102,7 +102,7 @@ + // attrs._cropBox field is not specified yet, so tries this array + if(pageDict->containsProperty(Specification::Page::CROPBOX)) + { +- shared_ptr<IProperty> prop=pageDict->getProperty(Specification::Page::CROPBOX); ++ boost::shared_ptr<IProperty> prop=pageDict->getProperty(Specification::Page::CROPBOX); + if(isRef(prop)) + { + attrs._cropBox=getCObjectFromRef<CArray>(prop); +@@ -123,7 +123,7 @@ + // attrs._rotate field is not specified yet, so tries this array + if(pageDict->containsProperty(Specification::Page::ROTATE)) + { +- shared_ptr<IProperty> prop=pageDict->getProperty(Specification::Page::ROTATE); ++ boost::shared_ptr<IProperty> prop=pageDict->getProperty(Specification::Page::ROTATE); + if(isRef(prop)) + { + attrs._rotate=getCObjectFromRef<CInt>(prop); +@@ -147,19 +147,19 @@ + // stops recursion and initializes values with default + if(pageDict->containsProperty(Specification::Page::PARENT)) + { +- shared_ptr<IProperty> parentRef=pageDict->getProperty(Specification::Page::PARENT); ++ boost::shared_ptr<IProperty> parentRef=pageDict->getProperty(Specification::Page::PARENT); + if(!isRef(parentRef)) + // this should not happen - malformed page tree structure + return; + +- shared_ptr<CDict> parentDict=getCObjectFromRef<CDict>(parentRef); ++ boost::shared_ptr<CDict> parentDict=getCObjectFromRef<CDict>(parentRef); + CPageAttributes::fillInherited(parentDict, attrs); + }else + { + // Resources is required and at least empty dictionary should be + // specified + if(!attrs._resources.get()) +- attrs._resources=shared_ptr<CDict>(CDictFactory::getInstance()); ++ attrs._resources=boost::shared_ptr<CDict>(CDictFactory::getInstance()); + + // default A4 sized box + libs::Rectangle defaultRect( +@@ -191,7 +191,7 @@ + // direct usage of static DEFAULT_ROTATE value caused linkage + // error + int defRot=DisplayParams::DEFAULT_ROTATE; +- attrs._rotate=shared_ptr<CInt>(CIntFactory::getInstance(defRot)); ++ attrs._rotate=boost::shared_ptr<CInt>(CIntFactory::getInstance(defRot)); + } + } + } +@@ -203,7 +203,7 @@ + // + // + void +-CPageAttributes::setInheritable(shared_ptr<CDict>& pageDict) ++CPageAttributes::setInheritable(boost::shared_ptr<CDict>& pageDict) + { + InheritedAttributes attrs; + CPageAttributes::fillInherited(pageDict, attrs); diff --git a/editors/pdfedit/files/patch-src-kernel-cpagechanges.cc b/editors/pdfedit/files/patch-src-kernel-cpagechanges.cc new file mode 100644 index 000000000000..8f7ab04b3a67 --- /dev/null +++ b/editors/pdfedit/files/patch-src-kernel-cpagechanges.cc @@ -0,0 +1,54 @@ +--- src/kernel/cpagechanges.cc.orig 2016-06-11 10:31:04.066936000 +0900 ++++ src/kernel/cpagechanges.cc 2016-06-11 10:31:47.070535000 +0900 +@@ -50,7 +50,7 @@ + CPageChanges::displayChange (::OutputDev& out, const Container& cont) const + { + +- shared_ptr<CDict> fakeDict (IProperty::getSmartCObjectPtr<CDict>(_page->getDictionary()->clone())); ++ boost::shared_ptr<CDict> fakeDict (IProperty::getSmartCObjectPtr<CDict>(_page->getDictionary()->clone())); + assert (fakeDict); + + CPageContents::setContents (fakeDict, cont); +@@ -66,7 +66,7 @@ + // Display page using our dictionary + _page->display()->displayPage (out, fakeDict); + } +-template void CPageChanges::displayChange<vector<shared_ptr<CContentStream> > > (::OutputDev& out, const vector<shared_ptr<CContentStream> >& cont) const; ++template void CPageChanges::displayChange<vector<boost::shared_ptr<CContentStream> > > (::OutputDev& out, const vector<boost::shared_ptr<CContentStream> >& cont) const; + + + // +@@ -87,10 +87,10 @@ + // + // + // +-shared_ptr<CContentStream> ++boost::shared_ptr<CContentStream> + CPageChanges::getChange (size_t nthchange) const + { +- typedef vector<shared_ptr<CContentStream> > CCs; ++ typedef vector<boost::shared_ptr<CContentStream> > CCs; + + CCs ccs; + getChanges (ccs); +@@ -122,9 +122,9 @@ + */ + struct ccs_change_sorter + { +- bool operator() (shared_ptr<CContentStream> frst, shared_ptr<CContentStream> scnd) ++ bool operator() (boost::shared_ptr<CContentStream> frst, boost::shared_ptr<CContentStream> scnd) + { +- typedef vector<shared_ptr<PdfOperator> > Ops; ++ typedef vector<boost::shared_ptr<PdfOperator> > Ops; + static const bool FIRST_IS_OUR_LAST = true; + static const bool SECOND_IS_OUR_LAST = false; + +@@ -163,7 +163,7 @@ + _page->contents()->getContentStreams (ccs); + for (CCs::const_iterator it = ccs.begin(); it != ccs.end(); ++it) + { +- vector<shared_ptr<PdfOperator> > ops; ++ vector<boost::shared_ptr<PdfOperator> > ops; + (*it)->getPdfOperators (ops); + // Empty contentstream is not our change + if (ops.empty()) diff --git a/editors/pdfedit/files/patch-src-kernel-cpdf.cc b/editors/pdfedit/files/patch-src-kernel-cpdf.cc new file mode 100644 index 000000000000..fd00f678381a --- /dev/null +++ b/editors/pdfedit/files/patch-src-kernel-cpdf.cc @@ -0,0 +1,872 @@ +--- src/kernel/cpdf.cc.orig 2016-06-12 03:22:58.998911000 +0900 ++++ src/kernel/cpdf.cc 2016-06-12 03:32:11.057006000 +0900 +@@ -81,13 +81,13 @@ + return stream; + } + +-shared_ptr<CDict> getPageTreeRoot(const boost::shared_ptr<CPdf> &pdf) ++boost::shared_ptr<CDict> getPageTreeRoot(const boost::shared_ptr<CPdf> &pdf) + { +- shared_ptr<CDict> result; ++ boost::shared_ptr<CDict> result; + + try + { +- shared_ptr<IProperty> pagesProp=pdf->getDictionary()->getProperty("Pages"); ++ boost::shared_ptr<IProperty> pagesProp=pdf->getDictionary()->getProperty("Pages"); + if(!isRef(pagesProp)) + // returns null dictionary + return result; +@@ -106,7 +106,7 @@ + PageTreeNodeType nodeType=UnknownNode; + + // checks nodeProp - must be dictionary or reference to dictionary +- shared_ptr<CDict> nodeDict; ++ boost::shared_ptr<CDict> nodeDict; + if(isDict(nodeProp)) + nodeDict=IProperty::getSmartCObjectPtr<CDict>(nodeProp); + else +@@ -126,9 +126,9 @@ + return ErrorNode; + + // checks root node at first +- shared_ptr<CPdf> pdf=nodeProp->getPdf().lock(); ++ boost::shared_ptr<CPdf> pdf=nodeProp->getPdf().lock(); + assert(pdf); +- shared_ptr<CDict> rootDict=getPageTreeRoot(pdf); ++ boost::shared_ptr<CDict> rootDict=getPageTreeRoot(pdf); + if(rootDict==nodeDict) + // root dictionary found and it is same as internode + return RootNode; +@@ -136,7 +136,7 @@ + // given node is not root of page tree, chcecks Type field + if(nodeDict->containsProperty("Type")) + { +- shared_ptr<IProperty> nodeType=nodeDict->getProperty("Type"); ++ boost::shared_ptr<IProperty> nodeType=nodeDict->getProperty("Type"); + try + { + if(isRef(nodeType)) +@@ -159,7 +159,7 @@ + // Internode should contain at least Kids array field + if(nodeDict->containsProperty("Kids")) + { +- shared_ptr<IProperty> kidsProp=nodeDict->getProperty("Kids"); ++ boost::shared_ptr<IProperty> kidsProp=nodeDict->getProperty("Kids"); + if(isArray(kidsProp)) + return InterNode; + if(isRef(kidsProp)) +@@ -189,8 +189,8 @@ + // tries to get Kids array + if(interNodeDict->containsProperty("Kids")) + { +- shared_ptr<IProperty> kidsProp=interNodeDict->getProperty("Kids"); +- shared_ptr<CArray> kidsArray; ++ boost::shared_ptr<IProperty> kidsProp=interNodeDict->getProperty("Kids"); ++ boost::shared_ptr<CArray> kidsArray; + if(isRef(kidsProp)) + { + try +@@ -341,17 +341,17 @@ + if(!withSubTree) + return; + +- shared_ptr<IProperty> nodeProp=pdf->getIndirectProperty(ref); ++ boost::shared_ptr<IProperty> nodeProp=pdf->getIndirectProperty(ref); + if(getNodeType(nodeProp)>=InterNode) + { + ChildrenStorage childs; + assert(isDict(nodeProp)); +- shared_ptr<CDict> nodeDict=IProperty::getSmartCObjectPtr<CDict>(nodeProp); ++ boost::shared_ptr<CDict> nodeDict=IProperty::getSmartCObjectPtr<CDict>(nodeProp); + getKidsFromInterNode(nodeDict, childs); + utilsPrintDbg(DBG_DBG, "discarding all nodes in "<<ref<<" subtree"); + for(ChildrenStorage::iterator i=childs.begin(); i!=childs.end(); ++i) + { +- shared_ptr<IProperty> child=*i; ++ boost::shared_ptr<IProperty> child=*i; + if(!isRef(child)) + // skip array mess + continue; +@@ -373,7 +373,7 @@ + + // gets dictionary from given property. If reference, gets target object. If + // it is not a dictionary, returns with 0 +- shared_ptr<CDict> interNodeDict; ++ boost::shared_ptr<CDict> interNodeDict; + if(isRef(interNodeProp)) + { + try +@@ -409,7 +409,7 @@ + getKidsFromInterNode(interNodeDict, children); + for(ChildrenStorage::const_iterator i=children.begin(); i!=children.end(); ++i) + { +- shared_ptr<IProperty> childProp=*i; ++ boost::shared_ptr<IProperty> childProp=*i; + if(isRef(childProp)) + count+=getKidsCount(childProp, cache); + } +@@ -441,7 +441,7 @@ + // dictionary smart pointer holder + // it is initialized according pagesDict parameter - if it is reference + // it has to be dereferenced +- shared_ptr<CDict> dict_ptr; ++ boost::shared_ptr<CDict> dict_ptr; + + // checks if given parameter is reference and if so, dereference it + // using getIndirectProperty method and casts to dict_ptr +@@ -523,7 +523,7 @@ + size_t min_pos=startPos, index=0; + for(ChildrenStorage::iterator i=children.begin(); i!=children.end(); ++i, ++index) + { +- shared_ptr<IProperty> child=*i; ++ boost::shared_ptr<IProperty> child=*i; + + if(!isRef(child)) + { +@@ -542,7 +542,7 @@ + + // gets child dictionary (everything is checked, so no exception can + // be thrown here) +- shared_ptr<CDict> child_ptr=getCObjectFromRef<CDict>(child); ++ boost::shared_ptr<CDict> child_ptr=getCObjectFromRef<CDict>(child); + + utilsPrintDbg(DBG_DBG, "kid["<<index<<"] node type="<<nodeType); + +@@ -632,9 +632,9 @@ + * superNode. + */ + size_t searchTreeNode( +- shared_ptr<const CPdf> pdf, +- shared_ptr<CDict> superNode, +- shared_ptr<CDict> node, ++ boost::shared_ptr<const CPdf> pdf, ++ boost::shared_ptr<CDict> superNode, ++ boost::shared_ptr<CDict> node, + size_t startValue, + PageTreeNodeCountCache * cache) + { +@@ -673,7 +673,7 @@ + getKidsFromInterNode(superNode, children); + for(i=children.begin(); i!=children.end(); ++i, ++index) + { +- shared_ptr<IProperty> child=*i; ++ boost::shared_ptr<IProperty> child=*i; + + // each element has to be reference + if(!isRef(child)) +@@ -693,7 +693,7 @@ + + // dereference target dictionary - never throws, because we have checked + // node type +- shared_ptr<CDict> elementDict_ptr=getCObjectFromRef<CDict>(child); ++ boost::shared_ptr<CDict> elementDict_ptr=getCObjectFromRef<CDict>(child); + + // compares elementDict_ptr (kid) with node, if they are same, returns + // startValue +@@ -723,7 +723,7 @@ + IndiRef nodeRef=node->getIndiRef(); + for(;i!=children.end(); ++i, ++index) + { +- shared_ptr<IProperty> child=*i; ++ boost::shared_ptr<IProperty> child=*i; + if(isRef(child) && getValueFromSimple<CRef>(child)==nodeRef) + { + utilsPrintDbg(DBG_WARN, "Internode "<<superNode->getIndiRef()<<" is ambiguous. Kids["<<index<<"] duplicates reference to node."); +@@ -735,7 +735,7 @@ + return position; + } + +-size_t getNodePosition(const shared_ptr<CPdf> &pdf, const shared_ptr<IProperty> &node, PageTreeNodeCountCache * cache) ++size_t getNodePosition(const boost::shared_ptr<CPdf> &pdf, const boost::shared_ptr<IProperty> &node, PageTreeNodeCountCache * cache) + { + utilsPrintDbg(DBG_DBG, ""); + // node must be from given pdf +@@ -746,7 +746,7 @@ + } + + // gets page tree root - if not found, then PageNotFoundException is thrown +- shared_ptr<CDict> rootDict_ptr=getPageTreeRoot(pdf); ++ boost::shared_ptr<CDict> rootDict_ptr=getPageTreeRoot(pdf); + if(!rootDict_ptr.get()) + throw PageNotFoundException(0); + +@@ -760,7 +760,7 @@ + utilsPrintDbg(DBG_ERR, "Given node is not reference nor dictionary. type="<<nodeType); + throw ElementBadTypeException("node"); + } +- shared_ptr<CDict> nodeDict_ptr; ++ boost::shared_ptr<CDict> nodeDict_ptr; + if(isRef(node)) + nodeDict_ptr=getCObjectFromRef<CDict>(node); + else +@@ -776,7 +776,7 @@ + throw PageNotFoundException(0); + } + +-bool isNodeDescendant(const boost::shared_ptr<CPdf>& pdf, const IndiRef &parent, const shared_ptr<CDict> &child) ++bool isNodeDescendant(const boost::shared_ptr<CPdf>& pdf, const IndiRef &parent, const boost::shared_ptr<CDict> &child) + { + using namespace utils; + +@@ -787,7 +787,7 @@ + } + + // gets parent property +- shared_ptr<IProperty> parentProp=child->getProperty("Parent"); ++ boost::shared_ptr<IProperty> parentProp=child->getProperty("Parent"); + if(!isRef(parentProp)) + { + // parent is incorect +@@ -804,7 +804,7 @@ + // referencies are not same, so gets parent dictionary and checks its parent + try + { +- shared_ptr<CDict> parentDict=getCObjectFromRef<CDict>(parentProp); ++ boost::shared_ptr<CDict> parentDict=getCObjectFromRef<CDict>(parentProp); + return isNodeDescendant(pdf, parent, parentDict); + }catch(CObjectException & ) + { +@@ -830,7 +830,7 @@ + return; + + // gets dictionary from given property +- shared_ptr<CDict> dict_ptr; ++ boost::shared_ptr<CDict> dict_ptr; + if(isRef(prop)) + { + try +@@ -854,8 +854,8 @@ + if(!dict_ptr->containsProperty("Kids")) + return; + +- shared_ptr<IProperty> kidsProp_ptr=dict_ptr->getProperty("Kids"); +- shared_ptr<CArray> kids_ptr; ++ boost::shared_ptr<IProperty> kidsProp_ptr=dict_ptr->getProperty("Kids"); ++ boost::shared_ptr<CArray> kids_ptr; + if(isRef(kidsProp_ptr)) + { + // Kids property is reference - this is not offten but may occure and +@@ -901,7 +901,7 @@ + kids_ptr->_getAllChildObjects(container); + for(ChildrenStorage::iterator i=container.begin(); i!=container.end(); ++i) + { +- shared_ptr<IProperty> elemProp_ptr=*i; ++ boost::shared_ptr<IProperty> elemProp_ptr=*i; + if(isRef(elemProp_ptr)) + { + REGISTER_SHAREDPTR_OBSERVER(elemProp_ptr, pageTreeKidsObserver); +@@ -922,7 +922,7 @@ + return; + + // gets dictionary from given property +- shared_ptr<CDict> dict_ptr; ++ boost::shared_ptr<CDict> dict_ptr; + if(isRef(prop)) + { + try +@@ -974,8 +974,8 @@ + if(!dict_ptr->containsProperty("Kids")) + return; + +- shared_ptr<IProperty> kidsProp_ptr=dict_ptr->getProperty("Kids"); +- shared_ptr<CArray> kids_ptr; ++ boost::shared_ptr<IProperty> kidsProp_ptr=dict_ptr->getProperty("Kids"); ++ boost::shared_ptr<CArray> kids_ptr; + if(isRef(kidsProp_ptr)) + { + // Kids property is reference - this is not offten but may occure and +@@ -1021,7 +1021,7 @@ + kids_ptr->_getAllChildObjects(container); + for(ChildrenStorage::iterator i=container.begin(); i!=container.end(); ++i) + { +- shared_ptr<IProperty> elemProp_ptr=*i; ++ boost::shared_ptr<IProperty> elemProp_ptr=*i; + if(isRef(elemProp_ptr)) + { + UNREGISTER_SHAREDPTR_OBSERVER(elemProp_ptr, pageTreeKidsObserver); +@@ -1042,7 +1042,7 @@ + using namespace utils; + + assert(isActive()); +- shared_ptr<IProperty> oldValue; ++ boost::shared_ptr<IProperty> oldValue; + if(!context) + { + kernelPrintDbg(DBG_WARN, "No context available. Ignoring calling."); +@@ -1055,7 +1055,7 @@ + case BasicChangeContextType: + { + // Pages reference value has changed +- shared_ptr<const BasicChangeContext<IProperty> > basicContext= ++ boost::shared_ptr<const BasicChangeContext<IProperty> > basicContext= + dynamic_pointer_cast<const BasicChangeContext<IProperty>, const IChangeContext<IProperty> >(context); + oldValue=basicContext->getOriginalValue(); + +@@ -1068,7 +1068,7 @@ + { + // document catalog dictionary has changed. Checks valueId and + // proceede just if Pages property has changed +- shared_ptr<const CDict::CDictComplexObserverContext > complexContex= ++ boost::shared_ptr<const CDict::CDictComplexObserverContext > complexContex= + dynamic_pointer_cast<const CDict::CDictComplexObserverContext, const IChangeContext<IProperty> >(context); + if(!complexContex) + { +@@ -1115,7 +1115,7 @@ + { + try + { +- shared_ptr<IProperty> oldValueDict=getCObjectFromRef<CDict>(oldValue); ++ boost::shared_ptr<IProperty> oldValueDict=getCObjectFromRef<CDict>(oldValue); + kernelPrintDbg(DBG_DBG, "unregistering observers from old page tree."); + pdf->unregisterPageTreeObservers(oldValueDict); + }catch(CObjectException & e) +@@ -1136,7 +1136,7 @@ + kernelPrintDbg(DBG_DBG, "Invalidating pageList with "<<pdf->pageList.size()<<" elements"); + for(PageList::iterator i=pdf->pageList.begin(); i!=pdf->pageList.end(); ++i) + { +- shared_ptr<CPage> page=i->second; ++ boost::shared_ptr<CPage> page=i->second; + page->invalidate(); + } + pdf->pageList.clear(); +@@ -1154,7 +1154,7 @@ + return; + } + IndiRef newValueRef=utils::getValueFromSimple<CRef>(newValue); +- shared_ptr<IProperty> newValueProp=pdf->getIndirectProperty(newValueRef); ++ boost::shared_ptr<IProperty> newValueProp=pdf->getIndirectProperty(newValueRef); + if(!isDict(newValueProp)) + { + kernelPrintDbg(DBG_WARN, "Pages property doesn't refer to dictionary. type="<<newValueProp->getType()); +@@ -1183,7 +1183,7 @@ + kernelPrintDbg(DBG_WARN, "No context available. Ignoring calling."); + return; + } +- shared_ptr<IProperty> oldValue; ++ boost::shared_ptr<IProperty> oldValue; + ChildrenStorage oldValues, newValues; + kernelPrintDbg(DBG_DBG, "context type="<<context->getType()); + switch(context->getType()) +@@ -1193,7 +1193,7 @@ + // this means that node contains Kids array with reference type + // and this reference has changed its value - both oldValue and + // newValue has to be referencies +- shared_ptr<const BasicChangeContext<IProperty> > basicContext= ++ boost::shared_ptr<const BasicChangeContext<IProperty> > basicContext= + dynamic_pointer_cast<const BasicChangeContext<IProperty>, const IChangeContext<IProperty> >(context); + oldValue=basicContext->getOriginalValue(); + assert(isRef(oldValue)); +@@ -1204,7 +1204,7 @@ + { + // this means that inter node dictionary has changed + // if changed property is not Kids, immediatelly returns +- shared_ptr<const CDict::CDictComplexObserverContext > complexContex= ++ boost::shared_ptr<const CDict::CDictComplexObserverContext > complexContex= + dynamic_pointer_cast<const CDict::CDictComplexObserverContext, const IChangeContext<IProperty> >(context); + if(!complexContex) + { +@@ -1245,7 +1245,7 @@ + try + { + // collects all children from array +- shared_ptr<CArray> kidsArray; ++ boost::shared_ptr<CArray> kidsArray; + if(isRef(oldValue)) + kidsArray=utils::getCObjectFromRef<CArray>(oldValue); + else +@@ -1273,7 +1273,7 @@ + try + { + // collects all children from array +- shared_ptr<CArray> kidsArray; ++ boost::shared_ptr<CArray> kidsArray; + if(isRef(newValue)) + kidsArray=utils::getCObjectFromRef<CArray>(newValue); + else +@@ -1299,10 +1299,10 @@ + IndiRef interNodeRef=(!isNull(oldValue))?oldValue->getIndiRef():newValue->getIndiRef(); + try + { +- shared_ptr<IProperty> interNodeProp=pdf->getIndirectProperty(interNodeRef); ++ boost::shared_ptr<IProperty> interNodeProp=pdf->getIndirectProperty(interNodeRef); + if(isDict(interNodeProp)) + { +- shared_ptr<CDict> interNode=IProperty::getSmartCObjectPtr<CDict>(interNodeProp); ++ boost::shared_ptr<CDict> interNode=IProperty::getSmartCObjectPtr<CDict>(interNodeProp); + // if consolidatePageTree hasn't kept page count numbers, total number + // of pages must be invalidated + if(!pdf->consolidatePageTree(interNode, true)) +@@ -1317,12 +1317,12 @@ + } + + // removes all pages from removed array +- shared_ptr<IProperty> null(CNullFactory::getInstance()); ++ boost::shared_ptr<IProperty> null(CNullFactory::getInstance()); + kernelPrintDbg(DBG_DBG, "Consolidating page list by removing oldValues."); + size_t index=0; + for(ChildrenStorage::iterator i=oldValues.begin(); i!=oldValues.end(); ++i, ++index) + { +- shared_ptr<IProperty> child=*i; ++ boost::shared_ptr<IProperty> child=*i; + // consider just referencies, other elements are just mess in array + // unregisters observers and consolidates pageList like this node has + // been removed +@@ -1341,7 +1341,7 @@ + kernelPrintDbg(DBG_DBG, "Consolidating page list by adding newValues."); + for(ChildrenStorage::iterator i=newValues.begin(); i!=newValues.end(); ++i) + { +- shared_ptr<IProperty> child=*i; ++ boost::shared_ptr<IProperty> child=*i; + // consider just referencies, other elements are just mess in array + // registers observers and consolidates pageList like this node has + // been added +@@ -1372,7 +1372,7 @@ + kernelPrintDbg(DBG_DBG, "contextType="<<contextType); + // gets original value from given context. It has to at least + // BasicChangeContext +- shared_ptr<IProperty> oldValue; ++ boost::shared_ptr<IProperty> oldValue; + switch(contextType) + { + // This context means that just simple value has been changed and so +@@ -1381,7 +1381,7 @@ + case BasicChangeContextType: + { + // this means that reference property has changed its value +- shared_ptr<const BasicChangeContext<IProperty> > basicContext= ++ boost::shared_ptr<const BasicChangeContext<IProperty> > basicContext= + dynamic_pointer_cast<const BasicChangeContext<IProperty>, const IChangeContext<IProperty> >(context); + oldValue=basicContext->getOriginalValue(); + +@@ -1393,7 +1393,7 @@ + case ComplexChangeContextType: + { + // this means that array content has changed +- shared_ptr<const CArray::CArrayComplexObserverContext > complexContex= ++ boost::shared_ptr<const CArray::CArrayComplexObserverContext > complexContex= + dynamic_pointer_cast<const CArray::CArrayComplexObserverContext, const IChangeContext<IProperty> >(context); + if(!complexContex) + { +@@ -1455,7 +1455,7 @@ + { + try + { +- shared_ptr<IProperty> oldValueDict=getCObjectFromRef<CDict>(oldValue); ++ boost::shared_ptr<IProperty> oldValueDict=getCObjectFromRef<CDict>(oldValue); + pdf->unregisterPageTreeObservers(oldValueDict); + }catch(CObjectException & e) + { +@@ -1482,7 +1482,7 @@ + IndiRef parentRef=ref; + if(getCachedValue(ref, parentRef, pdf->pageTreeKidsParentCache)) + kernelPrintDbg(DBG_DBG, "Uses pageTreeKidsParentCache with mapping from"<<ref<<" to "<<parentRef); +- shared_ptr<IProperty> parentProp_ptr=pdf->getIndirectProperty(parentRef); ++ boost::shared_ptr<IProperty> parentProp_ptr=pdf->getIndirectProperty(parentRef); + if(parentProp_ptr->getType()!=pDict) + { + // target of the parent reference is not dictionary, +@@ -1492,7 +1492,7 @@ + } + + // starts consolidation from parent intermediate node +- shared_ptr<CDict> parentDict_ptr=IProperty::getSmartCObjectPtr<CDict>(parentProp_ptr); ++ boost::shared_ptr<CDict> parentDict_ptr=IProperty::getSmartCObjectPtr<CDict>(parentProp_ptr); + try + { + // if consolidatePageTree hasn't kept page count numbers, total number +@@ -1530,7 +1530,7 @@ + { + try + { +- shared_ptr<IProperty> newValueDict=getCObjectFromRef<CDict>(newValue); ++ boost::shared_ptr<IProperty> newValueDict=getCObjectFromRef<CDict>(newValue); + pdf->registerPageTreeObservers(newValueDict); + }catch(CObjectException & e) + { +@@ -1559,11 +1559,11 @@ + } + if(docCatalog->containsProperty("Pages")) + { +- shared_ptr<IProperty> pagesProp=docCatalog->getProperty("Pages"); ++ boost::shared_ptr<IProperty> pagesProp=docCatalog->getProperty("Pages"); + if(isRef(pagesProp)) + { + UNREGISTER_SHAREDPTR_OBSERVER(pagesProp, pageTreeRootObserver); +- shared_ptr<IProperty> pageTreeRoot=getPageTreeRoot(_this.lock()); ++ boost::shared_ptr<IProperty> pageTreeRoot=getPageTreeRoot(_this.lock()); + if(pageTreeRoot.get()) + { + try +@@ -1623,7 +1623,7 @@ + for(IndirectMapping::iterator i=indMap.begin(); i!=indMap.end(); ++i) + { + IndiRef ref=i->first; +- shared_ptr<IProperty> value=i->second; ++ boost::shared_ptr<IProperty> value=i->second; + if(!value.unique()) + kernelPrintDbg(debug::DBG_WARN, "Somebody still holds property with with "<<ref); + } +@@ -1654,7 +1654,7 @@ + // is thrown + kernelPrintDbg(debug::DBG_DBG, "Getting Root field - document catalog"); + IndiRef rootRef(xref->getRootNum(), xref->getRootGen()); +- shared_ptr<IProperty> prop_ptr=getIndirectProperty(rootRef); ++ boost::shared_ptr<IProperty> prop_ptr=getIndirectProperty(rootRef); + if(prop_ptr->getType()!=pDict) + { + kernelPrintDbg(debug::DBG_ERR, "Trailer dictionary doesn't point to correct document catalog " +@@ -1670,7 +1670,7 @@ + REGISTER_SHAREDPTR_OBSERVER(docCatalog, pageTreeRootObserver); + if(docCatalog->containsProperty("Pages")) + { +- shared_ptr<IProperty> pagesProp=docCatalog->getProperty("Pages"); ++ boost::shared_ptr<IProperty> pagesProp=docCatalog->getProperty("Pages"); + if(isRef(pagesProp)) + REGISTER_SHAREDPTR_OBSERVER(pagesProp, pageTreeRootObserver); + else +@@ -1680,7 +1680,7 @@ + + // registers pageTreeNodeObserver and pageTreeKidsObserver to page tree root + // dictionary which registers these observers to whole page tree structure +- shared_ptr<IProperty> pageTreeRoot=utils::getPageTreeRoot(_this.lock()); ++ boost::shared_ptr<IProperty> pageTreeRoot=utils::getPageTreeRoot(_this.lock()); + if(pageTreeRoot.get()) + registerPageTreeObservers(pageTreeRoot); + } +@@ -1870,7 +1870,7 @@ + + // mapping doesn't exist yet, so tries to create one + // fetches object according reference +- shared_ptr< ::Object> obj(XPdfObjectFactory::getInstance(), xpdf::object_deleter()); ++ boost::shared_ptr< ::Object> obj(XPdfObjectFactory::getInstance(), xpdf::object_deleter()); + assert(xref); + xref->fetch(ref.num, ref.gen, obj.get()); + +@@ -1883,13 +1883,13 @@ + if(obj->getType()!=objNull) + { + IProperty * prop=utils::createObjFromXpdfObj(_this.lock(), *obj, ref); +- prop_ptr=shared_ptr<IProperty>(prop); ++ prop_ptr=boost::shared_ptr<IProperty>(prop); + indMap.insert(IndirectMapping::value_type(ref, prop_ptr)); + kernelPrintDbg(DBG_DBG, "Mapping created for "<<ref); + }else + { + kernelPrintDbg(DBG_DBG, ref<<" not available or points to objNull"); +- prop_ptr=shared_ptr<CNull>(CNullFactory::getInstance()); ++ prop_ptr=boost::shared_ptr<CNull>(CNullFactory::getInstance()); + } + + return prop_ptr; +@@ -1913,7 +1913,7 @@ + // so no type check fails). We have to set this pdf temporarily, because + // _makeXpdfObject function sets xref to created Object from ip->getPdf(). + // Finally restores original pdf value +- shared_ptr<CPdf> original=ip->getPdf().lock(); ++ boost::shared_ptr<CPdf> original=ip->getPdf().lock(); + ip->setPdf(_this); + ::Object * obj=ip->_makeXpdfObject(); + ip->setPdf(original); +@@ -1940,7 +1940,7 @@ + // ip is not from same pdf - may be in different one or stand alone object + // toSubstitute is deep copy of ip to prevent changes in original data. + // Also sets same pdf as orignal to cloned to enable dereferencing +- shared_ptr<IProperty> toSubstitute=ip->clone(); ++ boost::shared_ptr<IProperty> toSubstitute=ip->clone(); + if(hasValidPdf(ip)) + { + // locks cloned object to prevent making changes (kind of workaround) +@@ -2060,8 +2060,8 @@ + <<refEntry->first); + // ip is from read pdf and so dereferences target value + // FIXME check for valid pdf +- shared_ptr<CPdf> pdf = ip->getPdf().lock(); +- shared_ptr<IProperty> followedIp=pdf->getIndirectProperty(ipRef); ++ boost::shared_ptr<CPdf> pdf = ip->getPdf().lock(); ++ boost::shared_ptr<IProperty> followedIp=pdf->getIndirectProperty(ipRef); + + // adds dereferenced value using addProperty with collected + // container. Current mapping is set to resolving state to +@@ -2097,7 +2097,7 @@ + ChildrenStorage::iterator i; + for(i=childrenStorage.begin(); i!=childrenStorage.end(); ++i) + { +- shared_ptr<IProperty> child=*i; ++ boost::shared_ptr<IProperty> child=*i; + if(!isRef(*child) && !isDict(*child) && !isArray(*child) && !isStream(*child)) + { + // child is none of interesting type which may hold reference +@@ -2146,7 +2146,7 @@ + } + + // checks whether given ip is from same pdf +- shared_ptr<CPdf> ipPdf = ip->getPdf().lock(); ++ boost::shared_ptr<CPdf> ipPdf = ip->getPdf().lock(); + if(ipPdf.get()==this) + { + // ip is from same pdf and so all possible referencies are already in +@@ -2245,7 +2245,7 @@ + throw ReadOnlyDocumentException("Document is in read-only mode."); + } + +- shared_ptr<CPdf> _thisP = _this.lock(); ++ boost::shared_ptr<CPdf> _thisP = _this.lock(); + if(utils::isEncrypted(_thisP)) + { + kernelPrintDbg(DBG_WARN, "Changing properties for encrypted documents si not implemented"); +@@ -2272,7 +2272,7 @@ + // changeObject may throw if we are in read only mode or if xrefwriter is + // in paranoid mode and type check fails - to make it easier for such a case + // we are using shared_ptr which handles propObject cleanup correctly +- shared_ptr<Object> propObject(prop->_makeXpdfObject(), xpdf::object_deleter()); ++ boost::shared_ptr<Object> propObject(prop->_makeXpdfObject(), xpdf::object_deleter()); + kernelPrintDbg(DBG_DBG, "Registering change to the XRefWriter"); + xref->changeObject(indiRef.num, indiRef.gen, propObject.get()); + +@@ -2359,10 +2359,10 @@ + kernelPrintDbg(debug::DBG_DBG,"File stream created"); + + // stream is ready, creates CPdf instance +- shared_ptr<CPdf> instance; ++ boost::shared_ptr<CPdf> instance; + try + { +- instance = shared_ptr<CPdf>(new CPdf(stream, mode), PdfFileDeleter(file)); ++ instance = boost::shared_ptr<CPdf>(new CPdf(stream, mode), PdfFileDeleter(file)); + instance->_this = instance; + + // initializes revision specific data for the newest revision +@@ -2423,14 +2423,14 @@ + // page is not available in pageList, searching has to be done + // find throws an exception if any problem found, otherwise pageDict_ptr + // contians Page dictionary at specified position. +- shared_ptr<CDict> rootPages_ptr=getPageTreeRoot(_this.lock()); ++ boost::shared_ptr<CDict> rootPages_ptr=getPageTreeRoot(_this.lock()); + if(!rootPages_ptr.get()) + throw PageNotFoundException(pos); +- shared_ptr<CDict> pageDict_ptr=findPageDict(_this.lock(), rootPages_ptr, 1, pos, &nodeCountCache); ++ boost::shared_ptr<CDict> pageDict_ptr=findPageDict(_this.lock(), rootPages_ptr, 1, pos, &nodeCountCache); + + // creates CPage instance from page dictionary and stores it to the pageList + CPage * page=CPageFactory::getInstance(pageDict_ptr); +- shared_ptr<CPage> page_ptr(page); ++ boost::shared_ptr<CPage> page_ptr(page); + pageList.insert(PageList::value_type(pos, page_ptr)); + kernelPrintDbg(DBG_DBG, "New page added to the pageList size="<<pageList.size()); + +@@ -2452,7 +2452,7 @@ + return pageCount; + } + +- shared_ptr<CDict> rootDict=getPageTreeRoot(_this.lock()); ++ boost::shared_ptr<CDict> rootDict=getPageTreeRoot(_this.lock()); + if(!rootDict.get()) + return 0; + pageCount=getKidsCount(rootDict, &nodeCountCache); +@@ -2531,7 +2531,7 @@ + } + + +-void CPdf::consolidatePageList(const shared_ptr<IProperty> & oldValue, const shared_ptr<IProperty> & newValue) ++void CPdf::consolidatePageList(const boost::shared_ptr<IProperty> & oldValue, const boost::shared_ptr<IProperty> & newValue) + { + using namespace utils; + +@@ -2562,12 +2562,12 @@ + { + kernelPrintDbg(DBG_DBG, "oldValue was simple page dictionary"); + difference = -1; +- shared_ptr<CDict> oldDict_ptr=getCObjectFromRef<CDict>(oldValue); ++ boost::shared_ptr<CDict> oldDict_ptr=getCObjectFromRef<CDict>(oldValue); + + for(PageList::iterator i=pageList.begin(); i!=pageList.end(); ++i) + { + // checks page's dictionary with old one +- shared_ptr<CPage> page=i->second; ++ boost::shared_ptr<CPage> page=i->second; + if(page->getDictionary() == oldDict_ptr) + { + i->second->invalidate(); +@@ -2598,7 +2598,7 @@ + bool found=false; + for(PageList::iterator i=pageList.begin(); i!=pageList.end();) + { +- shared_ptr<CPage> page=i->second; ++ boost::shared_ptr<CPage> page=i->second; + // checks page's dictionary whether it is in oldDict_ptr sub + // tree and if so removes it from pageList + if(isNodeDescendant(_this.lock(), ref, page->getDictionary())) +@@ -2698,7 +2698,7 @@ + for(i=pageList.begin(); i!=pageList.end();) + { + size_t pos=i->first; +- shared_ptr<CPage> page=i->second; ++ boost::shared_ptr<CPage> page=i->second; + + if(pos>=minPos) + { +@@ -2782,8 +2782,8 @@ + bool countChanged=false; + if(interNode->containsProperty("Count")) + { +- shared_ptr<IProperty> countProp=interNode->getProperty("Count"); +- shared_ptr<CInt> countInt; ++ boost::shared_ptr<IProperty> countProp=interNode->getProperty("Count"); ++ boost::shared_ptr<CInt> countInt; + if(isRef(countProp)) + { + try +@@ -2803,7 +2803,7 @@ + interNode->delProperty("Count"); + + // adds new Count property with correct value +- countInt=shared_ptr<CInt>(CIntFactory::getInstance((int)count)); ++ countInt=boost::shared_ptr<CInt>(CIntFactory::getInstance((int)count)); + kernelPrintDbg(DBG_DBG, "replacing old Count property with new property value="<<count); + interNode->addProperty("Count", *countInt); + countChanged=true; +@@ -2842,7 +2842,7 @@ + size_t index=0; + for(i=kids.begin(); i!=kids.end(); ++i, ++index) + { +- shared_ptr<IProperty> child=*i; ++ boost::shared_ptr<IProperty> child=*i; + if(!isRef(child)) + { + // element is not reference, so we print warning and skip it +@@ -2861,16 +2861,16 @@ + + // gets target dictionary to check and consolidate - this doesn't throw + // because it is leaf or intermediate node +- shared_ptr<CDict> childDict=getCObjectFromRef<CDict>(child); ++ boost::shared_ptr<CDict> childDict=getCObjectFromRef<CDict>(child); + + // each leaf and inter node has to have Parent property with refernce to + // this node (which is indirect object and so we can use its + // NOTE that change in Parent property doesn't require also interNode + // parent consolidation +- shared_ptr<CRef> parentRef; ++ boost::shared_ptr<CRef> parentRef; + if(childDict->containsProperty("Parent")) + { +- shared_ptr<IProperty> parentProp=childDict->getProperty("Parent"); ++ boost::shared_ptr<IProperty> parentProp=childDict->getProperty("Parent"); + if(isRef(parentProp)) + parentRef=IProperty::getSmartCObjectPtr<CRef>(parentProp); + +@@ -2881,7 +2881,7 @@ + childDict->delProperty("Parent"); + + // adds new Parent property with correct value +- parentRef=shared_ptr<CRef>(CRefFactory::getInstance(interNodeRef)); ++ parentRef=boost::shared_ptr<CRef>(CRefFactory::getInstance(interNodeRef)); + kernelPrintDbg(DBG_DBG, "replacing old Parent property with new"); + childDict->addProperty("Parent", *parentRef); + }else +@@ -2920,12 +2920,12 @@ + // just prints warning messages and stops recursion + if(interNode->containsProperty("Parent")) + { +- shared_ptr<IProperty> parentProp=interNode->getProperty("Parent"); ++ boost::shared_ptr<IProperty> parentProp=interNode->getProperty("Parent"); + if(isRef(parentProp)) + { + try + { +- shared_ptr<CDict> parentDict=getCObjectFromRef<CDict>(parentProp); ++ boost::shared_ptr<CDict> parentDict=getCObjectFromRef<CDict>(parentProp); + return consolidatePageTree(parentDict, true); + }catch(CObjectException & e) + { +@@ -2977,8 +2977,8 @@ + // gets intermediate node where to insert new page + // in degenerated case, when there are no pages in the tree, we have to + // handle it special way +- shared_ptr<CDict> interNode_ptr; +- shared_ptr<CRef> currRef; ++ boost::shared_ptr<CDict> interNode_ptr; ++ boost::shared_ptr<CRef> currRef; + // by default it is root of page tree + interNode_ptr=getPageTreeRoot(_this.lock()); + if(!interNode_ptr.get()) +@@ -2993,23 +2993,23 @@ + // searches for page at storePosition and gets its reference + // page dictionary has to be an indirect object, so getIndiRef returns + // dictionary reference +- shared_ptr<CDict> currentPage_ptr=findPageDict(_this.lock(), interNode_ptr, 1, storePostion, &nodeCountCache); +- currRef=shared_ptr<CRef>(CRefFactory::getInstance(currentPage_ptr->getIndiRef())); ++ boost::shared_ptr<CDict> currentPage_ptr=findPageDict(_this.lock(), interNode_ptr, 1, storePostion, &nodeCountCache); ++ currRef=boost::shared_ptr<CRef>(CRefFactory::getInstance(currentPage_ptr->getIndiRef())); + + // gets parent of found dictionary which maintains +- shared_ptr<IProperty> parentRef_ptr=currentPage_ptr->getProperty("Parent"); ++ boost::shared_ptr<IProperty> parentRef_ptr=currentPage_ptr->getProperty("Parent"); + interNode_ptr=getCObjectFromRef<CDict>(parentRef_ptr); + } + + // gets Kids array where to insert new page dictionary +- shared_ptr<IProperty> kidsProp_ptr=interNode_ptr->getProperty("Kids"); ++ boost::shared_ptr<IProperty> kidsProp_ptr=interNode_ptr->getProperty("Kids"); + if(kidsProp_ptr->getType()!=pArray) + { + kernelPrintDbg(DBG_ERR, "Pages Kids field is not an array type="<<kidsProp_ptr->getType()); + // Kids is not array - malformed intermediate node + throw MalformedFormatExeption("Intermediate node Kids field is not an array."); + } +- shared_ptr<CArray> kids_ptr=IProperty::getSmartCObjectPtr<CArray>(kidsProp_ptr); ++ boost::shared_ptr<CArray> kids_ptr=IProperty::getSmartCObjectPtr<CArray>(kidsProp_ptr); + + // gets index in Kids array where to store. + // by default insert at 1st position (index is 0) +@@ -3032,8 +3032,8 @@ + + // Now it is safe to add indirect object, because there is nothing that can + // fail +- shared_ptr<CDict> pageDict=page->getDictionary(); +- shared_ptr<CPdf> pageDictPdf = pageDict->getPdf().lock(); ++ boost::shared_ptr<CDict> pageDict=page->getDictionary(); ++ boost::shared_ptr<CPdf> pageDictPdf = pageDict->getPdf().lock(); + if(pageDictPdf && pageDictPdf !=_this.lock()) + { + // page comes from different valid pdf - we have to create clone and +@@ -3085,8 +3085,8 @@ + // page dictionary is stored in the tree, consolidation is also done at this + // moment + // CPage can be created and inserted to the pageList +- shared_ptr<CDict> newPageDict_ptr=IProperty::getSmartCObjectPtr<CDict>(getIndirectProperty(pageRef)); +- shared_ptr<CPage> newPage_ptr(CPageFactory::getInstance(newPageDict_ptr)); ++ boost::shared_ptr<CDict> newPageDict_ptr=IProperty::getSmartCObjectPtr<CDict>(getIndirectProperty(pageRef)); ++ boost::shared_ptr<CPage> newPage_ptr(CPageFactory::getInstance(newPageDict_ptr)); + pageList.insert(PageList::value_type(storePostion+append, newPage_ptr)); + kernelPrintDbg(DBG_DBG, "New page added to the pageList size="<<pageList.size()); + return newPage_ptr; +@@ -3113,21 +3113,21 @@ + // Searches for page dictionary at given pos and gets its reference. + // getPageTreeRoot doesn't fail, because we are in page range and so it has + // to exist +- shared_ptr<CDict> rootDict=getPageTreeRoot(_this.lock()); +- shared_ptr<CDict> currentPage_ptr=findPageDict(_this.lock(), rootDict, 1, pos, &nodeCountCache); +- shared_ptr<CRef> currRef(CRefFactory::getInstance(currentPage_ptr->getIndiRef())); ++ boost::shared_ptr<CDict> rootDict=getPageTreeRoot(_this.lock()); ++ boost::shared_ptr<CDict> currentPage_ptr=findPageDict(_this.lock(), rootDict, 1, pos, &nodeCountCache); ++ boost::shared_ptr<CRef> currRef(CRefFactory::getInstance(currentPage_ptr->getIndiRef())); + + // Gets parent field from found page dictionary and gets its Kids array +- shared_ptr<IProperty> parentRef_ptr=currentPage_ptr->getProperty("Parent"); +- shared_ptr<CDict> interNode_ptr=getCObjectFromRef<CDict>(parentRef_ptr); +- shared_ptr<IProperty> kidsProp_ptr=interNode_ptr->getProperty("Kids"); ++ boost::shared_ptr<IProperty> parentRef_ptr=currentPage_ptr->getProperty("Parent"); ++ boost::shared_ptr<CDict> interNode_ptr=getCObjectFromRef<CDict>(parentRef_ptr); ++ boost::shared_ptr<IProperty> kidsProp_ptr=interNode_ptr->getProperty("Kids"); + if(kidsProp_ptr->getType()!=pArray) + { + kernelPrintDbg(DBG_ERR, "Pages Kids field is not an array type="<<kidsProp_ptr->getType()); + // Kids is not array - malformed intermediate node + throw MalformedFormatExeption("Intermediate node Kids field is not an array."); + } +- shared_ptr<CArray> kids_ptr=IProperty::getSmartCObjectPtr<CArray>(kidsProp_ptr); ++ boost::shared_ptr<CArray> kids_ptr=IProperty::getSmartCObjectPtr<CArray>(kidsProp_ptr); + + // gets index of searched node in Kids array and removes element from found + // position - if position can't be determined unambiguously (getPropertyId diff --git a/editors/pdfedit/files/patch-src-kernel-cstream.c b/editors/pdfedit/files/patch-src-kernel-cstream.c new file mode 100644 index 000000000000..4d76e0ec1dc2 --- /dev/null +++ b/editors/pdfedit/files/patch-src-kernel-cstream.c @@ -0,0 +1,65 @@ +--- ./src/kernel/cstream.cc.orig 2015-08-23 03:19:33.639621000 +0900 ++++ ./src/kernel/cstream.cc 2015-08-23 03:20:30.110651000 +0900 +@@ -123,7 +123,7 @@ + CStream::createReqEntries () + { + // Add one required entry in the stream dictionary (according to pdf specification) +- shared_ptr<CInt> len (new CInt (0)); ++ boost::shared_ptr<CInt> len (new CInt (0)); + assert (len); + dictionary.addProperty ("Length", *len); + } +@@ -152,7 +152,7 @@ + CDict::Value::const_iterator it = dictionary.value.begin (); + for (; it != dictionary.value.end (); ++it) + { +- shared_ptr<IProperty> newIp = ((*it).second)->clone (); ++ boost::shared_ptr<IProperty> newIp = ((*it).second)->clone (); + assert (newIp); + CDict::Value::value_type item = make_pair ((*it).first, newIp); + clone_->dictionary.value.push_back (item); +@@ -204,7 +204,7 @@ + this->canChange(); + + // Create context +- shared_ptr<ObserverContext> context (this->_createContext()); ++ boost::shared_ptr<ObserverContext> context (this->_createContext()); + + // Copy buf to buffer + buffer.clear (); +@@ -324,7 +324,7 @@ + size_t + CStream::getLength () const + { +- shared_ptr<IProperty> len = utils::getReferencedObject (dictionary.getProperty("Length")); ++ boost::shared_ptr<IProperty> len = utils::getReferencedObject (dictionary.getProperty("Length")); + if (isInt (len)) + { + int length; +@@ -345,7 +345,7 @@ + IProperty::ObserverContext* + CStream::_createContext () const + { +- return new BasicObserverContext (shared_ptr<IProperty> (new CNull ())); ++ return new BasicObserverContext (boost::shared_ptr<IProperty> (new CNull ())); + } + + +@@ -353,7 +353,7 @@ + // + // + void +-CStream::_objectChanged (shared_ptr<const ObserverContext> context) ++CStream::_objectChanged (boost::shared_ptr<const ObserverContext> context) + { + // Do not notify anything if we are not in a valid pdf + if (!hasValidPdf (this)) +@@ -380,7 +380,7 @@ + // doesn't clone but rather wrap this with shared pointer + // and empty deallocator to prevent from this instance + // deallocation +- shared_ptr<IProperty> newValue(this, EmptyDeallocator<IProperty>()); ++ boost::shared_ptr<IProperty> newValue(this, EmptyDeallocator<IProperty>()); + // Fill it with correct values + newValue->setPdf (this->getPdf()); + newValue->setIndiRef (this->getIndiRef()); diff --git a/editors/pdfedit/files/patch-src-kernel-pdfoperators.cc b/editors/pdfedit/files/patch-src-kernel-pdfoperators.cc new file mode 100644 index 000000000000..e7ec39610046 --- /dev/null +++ b/editors/pdfedit/files/patch-src-kernel-pdfoperators.cc @@ -0,0 +1,120 @@ +--- src/kernel/pdfoperators.cc.orig 2016-06-11 06:39:28.304555000 +0900 ++++ src/kernel/pdfoperators.cc 2016-06-11 06:42:54.331017000 +0900 +@@ -129,7 +129,7 @@ + // + // + // +-shared_ptr<PdfOperator> ++boost::shared_ptr<PdfOperator> + SimpleGenericOperator::clone () + { + // Clone operands +@@ -144,7 +144,7 @@ + + + void +-SimpleGenericOperator::init_operands (shared_ptr<observer::IObserver<IProperty> > observer, ++SimpleGenericOperator::init_operands (boost::shared_ptr<observer::IObserver<IProperty> > observer, + boost::weak_ptr<CPdf> pdf, + IndiRef* rf) + { +@@ -204,20 +204,20 @@ + } + else if (name == "TJ") + { +- shared_ptr<IProperty> op = ops[0]; ++ boost::shared_ptr<IProperty> op = ops[0]; + if (!isArray(op) || ops.size() != 1) + { + utilsPrintDbg(debug::DBG_WARN, "Bad operands for TJ operator: ops[type=" + << op->getType() <<" size="<<ops.size()<<"]"); + return; + } +- shared_ptr<CArray> opArray = IProperty::getSmartCObjectPtr<CArray>(op); +- std::vector<shared_ptr<IProperty> > props; ++ boost::shared_ptr<CArray> opArray = IProperty::getSmartCObjectPtr<CArray>(op); ++ std::vector<boost::shared_ptr<IProperty> > props; + opArray->_getAllChildObjects(props); +- std::vector<shared_ptr<IProperty> >::iterator i; ++ std::vector<boost::shared_ptr<IProperty> >::iterator i; + for(i=props.begin(); i!=props.end(); ++i) + { +- shared_ptr<IProperty> p = *i; ++ boost::shared_ptr<IProperty> p = *i; + + // TODO consider spacing coming from values + if(!(isString(p))) +@@ -264,7 +264,7 @@ + } + else if (name == "TJ") + { +- shared_ptr<IProperty> op = ops[0]; ++ boost::shared_ptr<IProperty> op = ops[0]; + if (!isArray(op) || ops.size() != 1) + { + utilsPrintDbg(debug::DBG_WARN, "Bad operands for TJ operator: ops[type="<< op->getType() <<" size="<<ops.size()<<"]"); +@@ -311,7 +311,7 @@ + { + assert(fontData); + const char* tag = fontData->getFontTag(); +- shared_ptr<GfxResources> res = getContentStream()->getResources(); ++ boost::shared_ptr<GfxResources> res = getContentStream()->getResources(); + GfxFont* font = res->lookupFont(tag); + if(!font) + utilsPrintDbg(debug::DBG_ERR, "Unable to get font(name=" +@@ -407,10 +407,10 @@ + // + // + // +-shared_ptr<PdfOperator> ++boost::shared_ptr<PdfOperator> + UnknownCompositePdfOperator::clone () + { +- shared_ptr<UnknownCompositePdfOperator> clone (new UnknownCompositePdfOperator(_opBegin,_opEnd)); ++ boost::shared_ptr<UnknownCompositePdfOperator> clone (new UnknownCompositePdfOperator(_opBegin,_opEnd)); + + for (PdfOperators::iterator it = _children.begin(); it != _children.end(); ++it) + clone->push_back ((*it)->clone(),getLastOperator(clone)); +@@ -482,13 +482,13 @@ + // + // + // +-shared_ptr<PdfOperator> ++boost::shared_ptr<PdfOperator> + InlineImageCompositePdfOperator::clone () + { + // Clone operands +- shared_ptr<CInlineImage> imgclone = IProperty::getSmartCObjectPtr<CInlineImage> (_inlineimage->clone()); ++ boost::shared_ptr<CInlineImage> imgclone = IProperty::getSmartCObjectPtr<CInlineImage> (_inlineimage->clone()); + // Create clone +- return shared_ptr<PdfOperator> (new InlineImageCompositePdfOperator (imgclone, _opBegin, _opEnd)); ++ return boost::shared_ptr<PdfOperator> (new InlineImageCompositePdfOperator (imgclone, _opBegin, _opEnd)); + } + + +@@ -505,7 +505,7 @@ + const StateUpdater::CheckTypes* chcktp = StateUpdater::findOp (name.c_str()); + // Operator not found, create unknown operator + if (NULL == chcktp) +- return shared_ptr<PdfOperator> (new SimpleGenericOperator (name ,operands)); ++ return boost::shared_ptr<PdfOperator> (new SimpleGenericOperator (name ,operands)); + + assert (chcktp); + utilsPrintDbg (DBG_DBG, "Operator found. " << chcktp->name); +@@ -524,13 +524,13 @@ + // If endTag is "" it is a simple operator, composite otherwise + // + if (isTextOp(*chcktp)) +- return shared_ptr<PdfOperator> (new TextSimpleOperator(chcktp->name, argNum, operands)); ++ return boost::shared_ptr<PdfOperator> (new TextSimpleOperator(chcktp->name, argNum, operands)); + + if (isSimpleOp(*chcktp)) +- return shared_ptr<PdfOperator> (new SimpleGenericOperator (chcktp->name, argNum, operands)); ++ return boost::shared_ptr<PdfOperator> (new SimpleGenericOperator (chcktp->name, argNum, operands)); + + // Composite operator +- return shared_ptr<PdfOperator> (new UnknownCompositePdfOperator (chcktp->name, chcktp->endTag)); ++ return boost::shared_ptr<PdfOperator> (new UnknownCompositePdfOperator (chcktp->name, chcktp->endTag)); + + } + diff --git a/editors/pdfedit/files/patch-src-kernel-pdfoperatorsbase.cc b/editors/pdfedit/files/patch-src-kernel-pdfoperatorsbase.cc new file mode 100644 index 000000000000..f1ef59f96cfe --- /dev/null +++ b/editors/pdfedit/files/patch-src-kernel-pdfoperatorsbase.cc @@ -0,0 +1,78 @@ +--- src/kernel/pdfoperatorsbase.cc.orig 2016-06-11 06:35:15.369169000 +0900 ++++ src/kernel/pdfoperatorsbase.cc 2016-06-11 06:36:00.937632000 +0900 +@@ -48,7 +48,7 @@ + // + // + // +-shared_ptr<CContentStream> ++boost::shared_ptr<CContentStream> + PdfOperator::getContentStream () const + { + assert (_contentstream); +@@ -57,7 +57,7 @@ + } + + void +-PdfOperator::putBehind (shared_ptr<PdfOperator> behindWhich, shared_ptr<PdfOperator> which) ++PdfOperator::putBehind (boost::shared_ptr<PdfOperator> behindWhich, boost::shared_ptr<PdfOperator> which) + { + if (behindWhich && which) + { +@@ -92,7 +92,7 @@ + // + // + void +-CompositePdfOperator::push_back (const shared_ptr<PdfOperator> oper, shared_ptr<PdfOperator> prev) ++CompositePdfOperator::push_back (const boost::shared_ptr<PdfOperator> oper, boost::shared_ptr<PdfOperator> prev) + { + assert (oper); + kernelPrintDbg (debug::DBG_DBG, ""); +@@ -136,7 +136,7 @@ + // + // + void +-CompositePdfOperator::remove (shared_ptr<PdfOperator> op) ++CompositePdfOperator::remove (boost::shared_ptr<PdfOperator> op) + { + PdfOperators::iterator it = find (_children.begin(), _children.end(), op); + assert (it != _children.end()); +@@ -160,8 +160,8 @@ + // + // + void +-CompositePdfOperator::insert_after (const shared_ptr<PdfOperator> oper, +- shared_ptr<PdfOperator> newOper) ++CompositePdfOperator::insert_after (const boost::shared_ptr<PdfOperator> oper, ++ boost::shared_ptr<PdfOperator> newOper) + { + PdfOperators::iterator it = std::find (_children.begin(), _children.end(), oper); + _children.insert (++it, newOper); +@@ -189,7 +189,7 @@ + } + + void +-CompositePdfOperator::init_operands (shared_ptr<observer::IObserver<IProperty> > observer, boost::weak_ptr<CPdf> pdf, IndiRef* rf) ++CompositePdfOperator::init_operands (boost::shared_ptr<observer::IObserver<IProperty> > observer, boost::weak_ptr<CPdf> pdf, IndiRef* rf) + { + for (PdfOperators::iterator it = _children.begin (); it != _children.end(); ++it) + (*it)->init_operands (observer, pdf, rf); +@@ -204,8 +204,8 @@ + // + // + // +-shared_ptr<PdfOperator> +-getLastOperator (shared_ptr<PdfOperator> oper) ++boost::shared_ptr<PdfOperator> ++getLastOperator (boost::shared_ptr<PdfOperator> oper) + { + if (!isCompositeOp (oper) || 0 == oper->getChildrenCount()) + return oper; +@@ -213,7 +213,7 @@ + PdfOperator::PdfOperators opers; + oper->getChildren (opers); + assert (!opers.empty()); +- shared_ptr<PdfOperator> tmpop = opers.back(); ++ boost::shared_ptr<PdfOperator> tmpop = opers.back(); + while (isCompositeOp (tmpop)) + { + opers.back()->getChildren (opers); diff --git a/editors/pdfedit/files/patch-src-kernel-pdfwriter.cc b/editors/pdfedit/files/patch-src-kernel-pdfwriter.cc new file mode 100644 index 000000000000..5a7b9b480c93 --- /dev/null +++ b/editors/pdfedit/files/patch-src-kernel-pdfwriter.cc @@ -0,0 +1,57 @@ +--- src/kernel/pdfwriter.cc.orig 2016-06-11 06:46:45.675949000 +0900 ++++ src/kernel/pdfwriter.cc 2016-06-11 06:47:46.394754000 +0900 +@@ -110,7 +110,7 @@ + printf("Unsupported context.\n"); + return; + } +- shared_ptr<const IPdfWriter::ChangeContext> progressContext= ++ boost::shared_ptr<const IPdfWriter::ChangeContext> progressContext= + dynamic_pointer_cast<const IPdfWriter::ChangeContext>(context); + size_t total=progressContext->getScope()->total; + if(!started) +@@ -427,7 +427,7 @@ + // contain binary data + if(obj.isStream()) + { +- shared_ptr<FilterStreamWriter> filter = FilterStreamWriter::getInstance(obj); ++ boost::shared_ptr<FilterStreamWriter> filter = FilterStreamWriter::getInstance(obj); + assert(filter->supportObject(obj)); + filter->compress(obj, ref, stream); + }else +@@ -502,11 +502,11 @@ + size_t index=0; + + // creates context for observers +- shared_ptr<OperationScope> scope(new OperationScope()); ++ boost::shared_ptr<OperationScope> scope(new OperationScope()); + scope->total=objectList.size(); + scope->task=CONTENT; +- shared_ptr<ChangeContext> context(new ChangeContext(scope)); +- shared_ptr<OperationStep> newValue(new OperationStep()); ++ boost::shared_ptr<ChangeContext> context(new ChangeContext(scope)); ++ boost::shared_ptr<OperationStep> newValue(new OperationStep()); + + // prepares offTable and writes objects + for(i=objectList.begin(); i!=objectList.end(); i++, index++) +@@ -659,10 +659,10 @@ + utilsPrintDbg(DBG_DBG, "Writing "<<subSectionTable.size()<<" subsections"); + + // creates context for observers +- shared_ptr<OperationScope> scope(new OperationScope()); ++ boost::shared_ptr<OperationScope> scope(new OperationScope()); + scope->total=subSectionTable.size(); + scope->task=TRAILER; +- shared_ptr<ChangeContext> context(new ChangeContext(scope)); ++ boost::shared_ptr<ChangeContext> context(new ChangeContext(scope)); + + // writes all subsection + size_t index=1; +@@ -704,7 +704,7 @@ + } + + // notifies observers +- shared_ptr<OperationStep> newValue(new OperationStep()); ++ boost::shared_ptr<OperationStep> newValue(new OperationStep()); + newValue->currStep=index; + notifyObservers(newValue, context); + } diff --git a/editors/pdfedit/files/patch-src-kernel-stateupdater.cc b/editors/pdfedit/files/patch-src-kernel-stateupdater.cc new file mode 100644 index 000000000000..05006bbabf3c --- /dev/null +++ b/editors/pdfedit/files/patch-src-kernel-stateupdater.cc @@ -0,0 +1,11 @@ +--- src/kernel/stateupdater.cc.orig 2016-06-11 06:44:12.114485000 +0900 ++++ src/kernel/stateupdater.cc 2016-06-11 06:45:25.066472000 +0900 +@@ -1227,7 +1227,7 @@ + { // Convert it to real + double dval = 0.0; + dval = IProperty::getSmartCObjectPtr<CInt>(*it)->getValue(); +- shared_ptr<IProperty> pIp (new CReal (dval)); ++ boost::shared_ptr<IProperty> pIp (new CReal (dval)); + std::replace (operands.begin(), operands.end(), *it, pIp); + } + } diff --git a/editors/pdfedit/files/patch-src-kernel-textoutputengines.cc b/editors/pdfedit/files/patch-src-kernel-textoutputengines.cc new file mode 100644 index 000000000000..cef8512fc606 --- /dev/null +++ b/editors/pdfedit/files/patch-src-kernel-textoutputengines.cc @@ -0,0 +1,29 @@ +--- src/kernel/textoutputengines.cc.orig 2016-06-12 03:44:13.431031000 +0900 ++++ src/kernel/textoutputengines.cc 2016-06-12 03:44:31.197856000 +0900 +@@ -232,13 +232,13 @@ + PdfOperator::Operands ops; + op->getParameters (ops); + assert (1 == ops.size()); +- shared_ptr<CArray> array = IProperty::getSmartCObjectPtr<CArray> (ops.front()); ++ boost::shared_ptr<CArray> array = IProperty::getSmartCObjectPtr<CArray> (ops.front()); + // + // Loop through TJ operands either strings or nums + // + for (size_t i = 0; i < array->getPropertyCount(); ++i) + { +- shared_ptr<IProperty> ip = array->getProperty (i); ++ boost::shared_ptr<IProperty> ip = array->getProperty (i); + if (isNumber (ip)) + { + int wMode = s->getFont()->getWMode(); +@@ -253,8 +253,8 @@ + // Create Tj with text and add it to output + string txt = getStringFromIProperty (ip); + PdfOperator::Operands opers; +- opers.push_back (shared_ptr<CString> (new CString (txt))); +- shared_ptr<PdfOperator> newop = createOperator ("Tj", opers); ++ opers.push_back (boost::shared_ptr<CString> (new CString (txt))); ++ boost::shared_ptr<PdfOperator> newop = createOperator ("Tj", opers); + // Set bbox + BBox bbox; + StateUpdater::printTextUpdate (s.get(), txt, &bbox); diff --git a/editors/pdfedit/files/patch-src-tools-Makfile b/editors/pdfedit/files/patch-src-tools-Makfile new file mode 100644 index 000000000000..7c018ad3d519 --- /dev/null +++ b/editors/pdfedit/files/patch-src-tools-Makfile @@ -0,0 +1,13 @@ +--- src/tools/Makefile.orig 2016-06-12 05:05:10.782469000 +0900 ++++ src/tools/Makefile 2016-06-12 05:06:44.155717000 +0900 +@@ -25,6 +25,10 @@ + .PHONY: all clean + all: $(TARGET) + ++install: $(TARGET) ++ $(MKDIR) $(INSTALL_ROOT)$(bindir) ++ $(BSD_INSTALL_PROGRAM) $(TARGET) $(INSTALL_ROOT)$(bindir) ++ + displaycs: displaycs.o + $(LINK) $(LDFLAGS) -o displaycs displaycs.o $(TOOLS_LIBS) + diff --git a/editors/pdfedit/files/patch-src-tools-add_image.cc b/editors/pdfedit/files/patch-src-tools-add_image.cc new file mode 100644 index 000000000000..36ac50fe1757 --- /dev/null +++ b/editors/pdfedit/files/patch-src-tools-add_image.cc @@ -0,0 +1,69 @@ +--- src/tools/add_image.cc.orig 2010-04-30 18:32:18.000000000 +0900 ++++ src/tools/add_image.cc 2016-06-12 04:11:42.137365000 +0900 +@@ -104,10 +104,10 @@ + + png_read_info(png_ptr, info_ptr); + +- size.x = info_ptr->width; +- size.y = info_ptr->height; +- color_type = info_ptr->color_type; +- bit_depth = info_ptr->bit_depth; ++ size.x = png_get_image_width(png_ptr, info_ptr); ++ size.y = png_get_image_height(png_ptr, info_ptr); ++ bit_depth = png_get_bit_depth(png_ptr, info_ptr); ++ color_type = png_get_color_type(png_ptr, info_ptr); + + number_of_passes = png_set_interlace_handling(png_ptr); + png_read_update_info(png_ptr, info_ptr); +@@ -116,13 +116,13 @@ + if (setjmp(png_jmpbuf(png_ptr))) + return; + +- scoped_array<png_byte> raw_buf (new png_byte [info_ptr->rowbytes]); +- for (size_t y = 0; y < info_ptr->height; y++) ++ scoped_array<png_byte> raw_buf (new png_byte [png_get_rowbytes(png_ptr, info_ptr)]); ++ for (size_t y = 0; y < png_get_image_height(png_ptr, info_ptr); y++) + { + png_bytep bufp = raw_buf.get(); + png_bytepp bufpp = &bufp; + png_read_rows (png_ptr, bufpp, NULL, 1); +- std::copy (&raw_buf[0], &raw_buf[info_ptr->rowbytes], std::back_inserter (buf)); ++ std::copy (&raw_buf[0], &raw_buf[png_get_rowbytes(png_ptr, info_ptr)], std::back_inserter (buf)); + } + + fclose(fp); +@@ -132,7 +132,7 @@ + }; + + struct _add { +- void operator () (shared_ptr<CPage> page, ++ void operator () (boost::shared_ptr<CPage> page, + const Position& where, + Point image_dim, + size_t bit_depth, +@@ -191,14 +191,14 @@ + return 1; + + // open pdf +- shared_ptr<CPdf> pdf = CPdf::getInstance (file.c_str(), CPdf::ReadWrite); ++ boost::shared_ptr<CPdf> pdf = CPdf::getInstance (file.c_str(), CPdf::ReadWrite); + + if (pdf->isLinearized()) + { + pdf.reset (); + string out (file+"-delinearised.pdf"); + { +- shared_ptr<Delinearizator> del (Delinearizator::getInstance(file.c_str(), new OldStylePdfWriter)); ++ boost::shared_ptr<Delinearizator> del (Delinearizator::getInstance(file.c_str(), new OldStylePdfWriter)); + if (!del) return -1; + del->delinearize(out.c_str()); + } +@@ -226,7 +226,7 @@ + continue; + } + +- shared_ptr<CPage> page = pdf->getPage(*it); ++ boost::shared_ptr<CPage> page = pdf->getPage(*it); + _add()(page, pos, _png.size, _png.bit_depth, _png.buf); + + #ifdef WIN32 diff --git a/editors/pdfedit/files/patch-src-tools-add_text.cc b/editors/pdfedit/files/patch-src-tools-add_text.cc new file mode 100644 index 000000000000..c2ee9e471d6c --- /dev/null +++ b/editors/pdfedit/files/patch-src-tools-add_text.cc @@ -0,0 +1,37 @@ +--- src/tools/add_text.cc.orig 2016-06-12 03:53:24.278803000 +0900 ++++ src/tools/add_text.cc 2016-06-12 03:53:43.440512000 +0900 +@@ -54,7 +54,7 @@ + }; + + struct _add { +- void operator () (shared_ptr<CPage> page, ++ void operator () (boost::shared_ptr<CPage> page, + const string& what, + const Position& where, + std::string font_id) +@@ -126,14 +126,14 @@ + return 1; + + // open pdf +- shared_ptr<CPdf> pdf = CPdf::getInstance (file.c_str(), CPdf::ReadWrite); ++ boost::shared_ptr<CPdf> pdf = CPdf::getInstance (file.c_str(), CPdf::ReadWrite); + + if (pdf->isLinearized()) + { + pdf.reset (); + string out (file+"-delinearised.pdf"); + { +- shared_ptr<Delinearizator> del (Delinearizator::getInstance(file.c_str(), new OldStylePdfWriter)); ++ boost::shared_ptr<Delinearizator> del (Delinearizator::getInstance(file.c_str(), new OldStylePdfWriter)); + if (!del) return -1; + del->delinearize(out.c_str()); + } +@@ -154,7 +154,7 @@ + continue; + } + +- shared_ptr<CPage> page = pdf->getPage(*it); ++ boost::shared_ptr<CPage> page = pdf->getPage(*it); + _add()(page, what, pos, font_id); + + #ifdef WIN32 diff --git a/editors/pdfedit/files/patch-src-tools-displaycs.cc b/editors/pdfedit/files/patch-src-tools-displaycs.cc new file mode 100644 index 000000000000..a45ea49eb111 --- /dev/null +++ b/editors/pdfedit/files/patch-src-tools-displaycs.cc @@ -0,0 +1,22 @@ +--- src/tools/displaycs.cc.orig 2016-06-12 03:46:15.039573000 +0900 ++++ src/tools/displaycs.cc 2016-06-12 03:46:33.669788000 +0900 +@@ -74,7 +74,7 @@ + size_t from = vm["from"].as<size_t>(); + + // open pdf +- shared_ptr<CPdf> pdf = CPdf::getInstance (file.c_str(), CPdf::ReadWrite); ++ boost::shared_ptr<CPdf> pdf = CPdf::getInstance (file.c_str(), CPdf::ReadWrite); + + // sane values + size_t to = pdf->getPageCount()+1; +@@ -90,8 +90,8 @@ + { + std::cout << "=====================" << endl; + std::cout << "PAGE NUMBER " << i << endl; +- shared_ptr<CPage> page = pdf->getPage(i); +- typedef vector<shared_ptr<CContentStream> > CCs; ++ boost::shared_ptr<CPage> page = pdf->getPage(i); ++ typedef vector<boost::shared_ptr<CContentStream> > CCs; + CCs ccs; + page->getContentStreams (ccs); + std::cout << "- parsed" << endl; diff --git a/editors/pdfedit/files/patch-src-tools-pagemetrics.cc b/editors/pdfedit/files/patch-src-tools-pagemetrics.cc new file mode 100644 index 000000000000..bc5c3f496d7b --- /dev/null +++ b/editors/pdfedit/files/patch-src-tools-pagemetrics.cc @@ -0,0 +1,47 @@ +--- src/tools/pagemetrics.cc.orig 2016-06-12 03:48:34.337781000 +0900 ++++ src/tools/pagemetrics.cc 2016-06-12 03:48:53.651846000 +0900 +@@ -48,7 +48,7 @@ + + struct stm { + static const string name; +- void operator () (shared_ptr<CPage> page, P& p) ++ void operator () (boost::shared_ptr<CPage> page, P& p) + { + if (p.size() < 6) throw std::runtime_error ("too few p params"); + page->setTransformMatrix (&p[0]); +@@ -58,7 +58,7 @@ + + struct sr { + static const string name; +- void operator () (shared_ptr<CPage> page, P& p) ++ void operator () (boost::shared_ptr<CPage> page, P& p) + { + if (p.size() < 1) throw std::runtime_error ("too few p params"); + page->setRotation ((int)(p[0])); +@@ -68,7 +68,7 @@ + + struct smb { + static const string name; +- void operator () (shared_ptr<CPage> page, const P& p) ++ void operator () (boost::shared_ptr<CPage> page, const P& p) + { + if (p.size() < 4) throw std::runtime_error ("too few p params"); + page->setMediabox (libs::Rectangle (p[0], p[1], p[2], p[3])); +@@ -131,7 +131,7 @@ + return 1; + + // open pdf +- shared_ptr<CPdf> pdf = CPdf::getInstance (file.c_str(), CPdf::ReadWrite); ++ boost::shared_ptr<CPdf> pdf = CPdf::getInstance (file.c_str(), CPdf::ReadWrite); + + // sane values + to = std::min(to, pdf->getPageCount()+1); +@@ -139,7 +139,7 @@ + // now the hard stuff comes + for (unsigned int i = from; i < to; ++i) + { +- shared_ptr<CPage> page = pdf->getPage(i); ++ boost::shared_ptr<CPage> page = pdf->getPage(i); + if (alg == stm::name) + stm()(page,p); + else if (alg == sr::name) diff --git a/editors/pdfedit/files/patch-src-tools-pdf_images.cc b/editors/pdfedit/files/patch-src-tools-pdf_images.cc new file mode 100644 index 000000000000..435318f3bf2b --- /dev/null +++ b/editors/pdfedit/files/patch-src-tools-pdf_images.cc @@ -0,0 +1,38 @@ +--- src/tools/pdf_images.cc.orig 2016-06-12 04:13:54.045270000 +0900 ++++ src/tools/pdf_images.cc 2016-06-12 04:14:32.874579000 +0900 +@@ -51,7 +51,7 @@ + }; + // what to do with a page + struct _extract_images { +- void operator () (shared_ptr<CPage> page, ImageOutputDev& img_out, pdfobjects::DisplayParams& displayparams) ++ void operator () (boost::shared_ptr<CPage> page, ImageOutputDev& img_out, pdfobjects::DisplayParams& displayparams) + { + page->displayPage (img_out, displayparams); + } +@@ -107,7 +107,7 @@ + return 1; + + // open pdf +- shared_ptr<CPdf> pdf = CPdf::getInstance (file.c_str(), CPdf::ReadWrite); ++ boost::shared_ptr<CPdf> pdf = CPdf::getInstance (file.c_str(), CPdf::ReadWrite); + ImageOutputDev img_out (const_cast<char*> (dir.c_str()), gTrue); + + // alter display params +@@ -119,7 +119,7 @@ + { + for (size_t i = 1; i <= pdf->getPageCount(); ++i) + { +- shared_ptr<CPage> page = pdf->getPage(i); ++ boost::shared_ptr<CPage> page = pdf->getPage(i); + std::cout << "\nPage " << i << ":"; + _extract_images()(page, img_out, displayparams); + } +@@ -134,7 +134,7 @@ + continue; + } + +- shared_ptr<CPage> page = pdf->getPage(*it); ++ boost::shared_ptr<CPage> page = pdf->getPage(*it); + std::cout << "\nPage " << *it << ":"; + _extract_images()(page, img_out, displayparams); + } diff --git a/editors/pdfedit/files/patch-src-tools-replace_text.cc b/editors/pdfedit/files/patch-src-tools-replace_text.cc new file mode 100644 index 000000000000..69dfb5839d23 --- /dev/null +++ b/editors/pdfedit/files/patch-src-tools-replace_text.cc @@ -0,0 +1,54 @@ +--- src/tools/replace_text.cc.orig 2010-02-24 03:28:09.000000000 +0900 ++++ src/tools/replace_text.cc 2016-06-12 04:26:38.191487000 +0900 +@@ -22,6 +22,7 @@ + * Project is hosted on http://sourceforge.net/projects/pdfedit + */ + #include <sstream> ++#include <algorithm> + #include <kernel/pdfedit-core-dev.h> + #include <kernel/cpdf.h> + #include <kernel/cpage.h> +@@ -59,7 +60,7 @@ + + struct _replace { + static const string name; +- void operator () (shared_ptr<CPage> page, const string& what, const string& with) ++ void operator () (boost::shared_ptr<CPage> page, const string& what, const string& with) + { + page->replaceText (what, with); + } +@@ -121,14 +122,14 @@ + return 1; + + // open pdf +- shared_ptr<CPdf> pdf = CPdf::getInstance (file.c_str(), CPdf::ReadWrite); ++ boost::shared_ptr<CPdf> pdf = CPdf::getInstance (file.c_str(), CPdf::ReadWrite); + + if (pdf->isLinearized()) + { + pdf.reset (); + string out (file+"-delinearised.pdf"); + { +- shared_ptr<Delinearizator> del (Delinearizator::getInstance(file.c_str(), new OldStylePdfWriter)); ++ boost::shared_ptr<Delinearizator> del (Delinearizator::getInstance(file.c_str(), new OldStylePdfWriter)); + if (!del) return -1; + del->delinearize(out.c_str()); + } +@@ -137,7 +138,7 @@ + + + // sane values +- to = std::min(to, pdf->getPageCount()+1); ++ to = std::min(to, (unsigned long)(pdf->getPageCount()+1)); + + // now the hard stuff comes - do this crazy loops intentionally + for (size_t things_to_replace = 0; things_to_replace < withs.size(); ++things_to_replace) +@@ -150,7 +151,7 @@ + string with = withs[things_to_replace]; + for (size_t i = from; i < to; ++i) + { +- shared_ptr<CPage> page = pdf->getPage(i); ++ boost::shared_ptr<CPage> page = pdf->getPage(i); + _replace()(page, what, with); + } + #ifdef WIN32 diff --git a/editors/pdfedit/files/patch-src-utils-algorithms.h b/editors/pdfedit/files/patch-src-utils-algorithms.h new file mode 100644 index 000000000000..35fa6913c72c --- /dev/null +++ b/editors/pdfedit/files/patch-src-utils-algorithms.h @@ -0,0 +1,18 @@ +--- src/utils/algorithms.h.orig 2016-06-11 10:27:29.196801000 +0900 ++++ src/utils/algorithms.h 2016-06-11 10:27:51.958626000 +0900 +@@ -22,7 +22,7 @@ + * Project is hosted on http://sourceforge.net/projects/pdfedit + */ + #ifndef _ALGORTIHMS_H_ +-#define _ALGORTIHMS_H__ ++#define _ALGORTIHMS_H_ + + //============================================ + // Basic includes +@@ -31,5 +31,5 @@ + #include <utils/algorithms/basic_algos.h> + + +-#endif //_ALGORTIHMS_H__ ++#endif //_ALGORTIHMS_H_ + diff --git a/editors/pdfedit/files/patch-src-xpdf-fofi-FoFiEncodings.cc b/editors/pdfedit/files/patch-src-xpdf-fofi-FoFiEncodings.cc new file mode 100644 index 000000000000..066fd304f606 --- /dev/null +++ b/editors/pdfedit/files/patch-src-xpdf-fofi-FoFiEncodings.cc @@ -0,0 +1,29 @@ +--- src/xpdf/fofi/FoFiEncodings.cc.orig 2016-06-11 10:34:02.955763000 +0900 ++++ src/xpdf/fofi/FoFiEncodings.cc 2016-06-11 10:34:35.315168000 +0900 +@@ -19,7 +19,7 @@ + // Type 1 and 1C font data + //------------------------------------------------------------------------ + +-char *fofiType1StandardEncoding[256] = { ++const char *fofiType1StandardEncoding[256] = { + NULL, + NULL, + NULL, +@@ -278,7 +278,7 @@ + NULL + }; + +-char *fofiType1ExpertEncoding[256] = { ++const char *fofiType1ExpertEncoding[256] = { + NULL, + NULL, + NULL, +@@ -541,7 +541,7 @@ + // Type 1C font data + //------------------------------------------------------------------------ + +-char *fofiType1CStdStrings[391] = { ++const char *fofiType1CStdStrings[391] = { + ".notdef", + "space", + "exclam", diff --git a/editors/pdfedit/files/patch-src-xpdf-fofi-FoFiEncodings.h b/editors/pdfedit/files/patch-src-xpdf-fofi-FoFiEncodings.h new file mode 100644 index 000000000000..7833994f8978 --- /dev/null +++ b/editors/pdfedit/files/patch-src-xpdf-fofi-FoFiEncodings.h @@ -0,0 +1,20 @@ +--- src/xpdf/fofi/FoFiEncodings.h.orig 2016-06-11 10:35:39.548372000 +0900 ++++ src/xpdf/fofi/FoFiEncodings.h 2016-06-11 10:36:01.939673000 +0900 +@@ -21,14 +21,14 @@ + // Type 1 and 1C font data + //------------------------------------------------------------------------ + +-extern char *fofiType1StandardEncoding[256]; +-extern char *fofiType1ExpertEncoding[256]; ++extern const char *fofiType1StandardEncoding[256]; ++extern const char *fofiType1ExpertEncoding[256]; + + //------------------------------------------------------------------------ + // Type 1C font data + //------------------------------------------------------------------------ + +-extern char *fofiType1CStdStrings[391]; ++extern const char *fofiType1CStdStrings[391]; + extern Gushort fofiType1CISOAdobeCharset[229]; + extern Gushort fofiType1CExpertCharset[166]; + extern Gushort fofiType1CExpertSubsetCharset[87]; diff --git a/editors/pdfedit/files/patch-src-xpdf-fofi-FoFiTrueType.cc b/editors/pdfedit/files/patch-src-xpdf-fofi-FoFiTrueType.cc new file mode 100644 index 000000000000..aff1841b1e56 --- /dev/null +++ b/editors/pdfedit/files/patch-src-xpdf-fofi-FoFiTrueType.cc @@ -0,0 +1,29 @@ +--- src/xpdf/fofi/FoFiTrueType.cc.orig 2016-06-11 10:37:17.000155000 +0900 ++++ src/xpdf/fofi/FoFiTrueType.cc 2016-06-11 10:40:14.853257000 +0900 +@@ -143,7 +143,7 @@ + //------------------------------------------------------------------------ + + struct T42Table { +- char *tag; // 4-byte tag ++ const char *tag; // 4-byte tag + GBool required; // required by the TrueType spec? + }; + +@@ -173,7 +173,7 @@ + + // Glyph names in some arbitrary standard order that Apple uses for + // their TrueType fonts. +-static char *macGlyphNames[258] = { ++static const char *macGlyphNames[258] = { + ".notdef", "null", "CR", "space", + "exclam", "quotedbl", "numbersign", "dollar", + "percent", "ampersand", "quotesingle", "parenleft", +@@ -2011,7 +2011,7 @@ + } + } + +-int FoFiTrueType::seekTable(char *tag) { ++int FoFiTrueType::seekTable(const char *tag) { + Guint tagI; + int i; + diff --git a/editors/pdfedit/files/patch-src-xpdf-fofi-FoFiTrueType.h b/editors/pdfedit/files/patch-src-xpdf-fofi-FoFiTrueType.h new file mode 100644 index 000000000000..b1d9ddd8a842 --- /dev/null +++ b/editors/pdfedit/files/patch-src-xpdf-fofi-FoFiTrueType.h @@ -0,0 +1,11 @@ +--- src/xpdf/fofi/FoFiTrueType.h.orig 2016-06-11 10:41:33.311317000 +0900 ++++ src/xpdf/fofi/FoFiTrueType.h 2016-06-11 10:41:43.645672000 +0900 +@@ -156,7 +156,7 @@ + Guint computeTableChecksum(Guchar *data, int length); + void parse(); + void readPostTable(); +- int seekTable(char *tag); ++ int seekTable(const char *tag); + + TrueTypeTable *tables; + int nTables; diff --git a/editors/pdfedit/files/patch-src-xpdf-fofi-FoFiType1.cc b/editors/pdfedit/files/patch-src-xpdf-fofi-FoFiType1.cc new file mode 100644 index 000000000000..0f9ab9982453 --- /dev/null +++ b/editors/pdfedit/files/patch-src-xpdf-fofi-FoFiType1.cc @@ -0,0 +1,11 @@ +--- src/xpdf/fofi/FoFiType1.cc.orig 2016-06-11 10:43:43.363657000 +0900 ++++ src/xpdf/fofi/FoFiType1.cc 2016-06-11 10:44:21.857241000 +0900 +@@ -194,7 +194,7 @@ + // get encoding + } else if (!encoding && + !strncmp(line, "/Encoding StandardEncoding def", 30)) { +- encoding = fofiType1StandardEncoding; ++ encoding = (char **)fofiType1StandardEncoding; + } else if (!encoding && + !strncmp(line, "/Encoding 256 array", 19)) { + encoding = (char **)gmallocn(256, sizeof(char *)); diff --git a/editors/pdfedit/files/patch-src-xpdf-fofi-FoFiType1C.cc b/editors/pdfedit/files/patch-src-xpdf-fofi-FoFiType1C.cc new file mode 100644 index 000000000000..a7f31738f870 --- /dev/null +++ b/editors/pdfedit/files/patch-src-xpdf-fofi-FoFiType1C.cc @@ -0,0 +1,15 @@ +--- src/xpdf/fofi/FoFiType1C.cc.orig 2016-06-11 10:45:36.260108000 +0900 ++++ src/xpdf/fofi/FoFiType1C.cc 2016-06-11 10:46:10.103508000 +0900 +@@ -2261,10 +2261,10 @@ + int pos, c, sid, nLeft, nSups, i, j; + + if (topDict.encodingOffset == 0) { +- encoding = fofiType1StandardEncoding; ++ encoding = (char **)fofiType1StandardEncoding; + + } else if (topDict.encodingOffset == 1) { +- encoding = fofiType1ExpertEncoding; ++ encoding = (char **)fofiType1ExpertEncoding; + + } else { + encoding = (char **)gmallocn(256, sizeof(char *)); diff --git a/editors/pdfedit/files/patch-src-xpdf-goo-GString.cc b/editors/pdfedit/files/patch-src-xpdf-goo-GString.cc new file mode 100644 index 000000000000..1108fd3052bc --- /dev/null +++ b/editors/pdfedit/files/patch-src-xpdf-goo-GString.cc @@ -0,0 +1,91 @@ +--- src/xpdf/goo/GString.cc.orig 2009-09-11 21:02:56.000000000 +0900 ++++ src/xpdf/goo/GString.cc 2016-06-12 03:02:35.310062000 +0900 +@@ -60,7 +60,7 @@ + fmtSpace + }; + +-static char *formatStrings[] = { ++static const char *formatStrings[] = { + "d", "x", "o", "b", "ud", "ux", "uo", "ub", + "ld", "lx", "lo", "lb", "uld", "ulx", "ulo", "ulb", + "f", "g", +@@ -144,14 +144,14 @@ + + GString *GString::fromInt(int x) { + char buf[24]; // enough space for 64-bit ints plus a little extra +- char *p; ++ const char *p; + int len; + + formatInt(x, buf, sizeof(buf), gFalse, 0, 10, &p, &len); + return new GString(p, len); + } + +-GString *GString::format(char *fmt, ...) { ++GString *GString::format(const char *fmt, ...) { + va_list argList; + GString *s; + +@@ -162,7 +162,7 @@ + return s; + } + +-GString *GString::formatv(char *fmt, va_list argList) { ++GString *GString::formatv(const char *fmt, va_list argList) { + GString *s; + + s = new GString(); +@@ -213,7 +213,7 @@ + return this; + } + +-GString *GString::appendf(char *fmt, ...) { ++GString *GString::appendf(const char *fmt, ...) { + va_list argList; + + va_start(argList, fmt); +@@ -222,7 +222,7 @@ + return this; + } + +-GString *GString::appendfv(char *fmt, va_list argList) { ++GString *GString::appendfv(const char *fmt, va_list argList) { + GStringFormatArg *args; + int argsLen, argsSize; + GStringFormatArg arg; +@@ -231,7 +231,7 @@ + GStringFormatType ft; + char buf[65]; + int len, i; +- char *p0, *p1, *str; ++ const char *p0, *p1, *str; + + argsLen = 0; + argsSize = 8; +@@ -465,7 +465,7 @@ + + void GString::formatInt(long x, char *buf, int bufSize, + GBool zeroFill, int width, int base, +- char **p, int *len) { ++ const char **p, int *len) { + static char vals[17] = "0123456789abcdef"; + GBool neg; + int start, i, j; +@@ -497,7 +497,7 @@ + + void GString::formatUInt(Gulong x, char *buf, int bufSize, + GBool zeroFill, int width, int base, +- char **p, int *len) { ++ const char **p, int *len) { + static char vals[17] = "0123456789abcdef"; + int i, j; + +@@ -520,7 +520,7 @@ + } + + void GString::formatDouble(double x, char *buf, int bufSize, int prec, +- GBool trim, char **p, int *len) { ++ GBool trim, const char **p, int *len) { + GBool neg, started; + double x2; + int d, i, j; diff --git a/editors/pdfedit/files/patch-src-xpdf-goo-GString.h b/editors/pdfedit/files/patch-src-xpdf-goo-GString.h new file mode 100644 index 000000000000..cbaba6d991ee --- /dev/null +++ b/editors/pdfedit/files/patch-src-xpdf-goo-GString.h @@ -0,0 +1,40 @@ +--- src/xpdf/goo/GString.h.orig 2009-09-11 21:02:56.000000000 +0900 ++++ src/xpdf/goo/GString.h 2016-06-12 03:01:27.367470000 +0900 +@@ -67,8 +67,8 @@ + // t -- GString * + // w -- blank space; arg determines width + // To get literal curly braces, use {{ or }}. +- static GString *format(char *fmt, ...); +- static GString *formatv(char *fmt, va_list argList); ++ static GString *format(const char *fmt, ...); ++ static GString *formatv(const char *fmt, va_list argList); + + // Destructor. + ~GString(); +@@ -95,8 +95,8 @@ + GString *append(const char *str, int lengthA); + + // Append a formatted string. +- GString *appendf(char *fmt, ...); +- GString *appendfv(char *fmt, va_list argList); ++ GString *appendf(const char *fmt, ...); ++ GString *appendfv(const char *fmt, va_list argList); + + // Insert a character or string. + GString *insert(int i, char c); +@@ -125,12 +125,12 @@ + void resize(int length1); + static void formatInt(long x, char *buf, int bufSize, + GBool zeroFill, int width, int base, +- char **p, int *len); ++ const char **p, int *len); + static void formatUInt(Gulong x, char *buf, int bufSize, + GBool zeroFill, int width, int base, +- char **p, int *len); ++ const char **p, int *len); + static void formatDouble(double x, char *buf, int bufSize, int prec, +- GBool trim, char **p, int *len); ++ GBool trim, const char **p, int *len); + }; + + #if defined(WIN32) || defined(UNDER_CE) diff --git a/editors/pdfedit/files/patch-src-xpdf-xpdf-BuiltinFont.cc b/editors/pdfedit/files/patch-src-xpdf-xpdf-BuiltinFont.cc new file mode 100644 index 000000000000..b04960635217 --- /dev/null +++ b/editors/pdfedit/files/patch-src-xpdf-xpdf-BuiltinFont.cc @@ -0,0 +1,22 @@ +--- src/xpdf/xpdf/BuiltinFont.cc.orig 2016-06-12 03:09:00.143158000 +0900 ++++ src/xpdf/xpdf/BuiltinFont.cc 2016-06-12 03:09:30.242137000 +0900 +@@ -39,7 +39,7 @@ + gfree(tab); + } + +-GBool BuiltinFontWidths::getWidth(char *name, Gushort *width) { ++GBool BuiltinFontWidths::getWidth(const char *name, Gushort *width) { + int h; + BuiltinFontWidth *p; + +@@ -53,8 +53,8 @@ + return gFalse; + } + +-int BuiltinFontWidths::hash(char *name) { +- char *p; ++int BuiltinFontWidths::hash(const char *name) { ++ const char *p; + unsigned int h; + + h = 0; diff --git a/editors/pdfedit/files/patch-src-xpdf-xpdf-BuiltinFont.h b/editors/pdfedit/files/patch-src-xpdf-xpdf-BuiltinFont.h new file mode 100644 index 000000000000..15b2fdcbf946 --- /dev/null +++ b/editors/pdfedit/files/patch-src-xpdf-xpdf-BuiltinFont.h @@ -0,0 +1,34 @@ +--- src/xpdf/xpdf/BuiltinFont.h.orig 2016-06-12 03:07:21.081040000 +0900 ++++ src/xpdf/xpdf/BuiltinFont.h 2016-06-12 03:08:04.015283000 +0900 +@@ -23,7 +23,7 @@ + //------------------------------------------------------------------------ + + struct BuiltinFont { +- char *name; ++ const char *name; + char **defaultBaseEnc; + short ascent; + short descent; +@@ -34,7 +34,7 @@ + //------------------------------------------------------------------------ + + struct BuiltinFontWidth { +- char *name; ++ const char *name; + Gushort width; + BuiltinFontWidth *next; + }; +@@ -44,11 +44,11 @@ + + BuiltinFontWidths(BuiltinFontWidth *widths, int sizeA); + ~BuiltinFontWidths(); +- GBool getWidth(char *name, Gushort *width); ++ GBool getWidth(const char *name, Gushort *width); + + private: + +- int hash(char *name); ++ int hash(const char *name); + + BuiltinFontWidth **tab; + int size; diff --git a/editors/pdfedit/files/patch-src-xpdf-xpdf-NameToUnicodeTable.h b/editors/pdfedit/files/patch-src-xpdf-xpdf-NameToUnicodeTable.h new file mode 100644 index 000000000000..1d6a86ecb4b2 --- /dev/null +++ b/editors/pdfedit/files/patch-src-xpdf-xpdf-NameToUnicodeTable.h @@ -0,0 +1,11 @@ +--- src/xpdf/xpdf/NameToUnicodeTable.h.orig 2016-06-12 03:03:36.755295000 +0900 ++++ src/xpdf/xpdf/NameToUnicodeTable.h 2016-06-12 03:03:51.495599000 +0900 +@@ -8,7 +8,7 @@ + + static struct { + Unicode u; +- char *name; ++ const char *name; + } nameToUnicodeTab[] = { + {0x0021, "!"}, + {0x0023, "#"}, diff --git a/editors/pdfedit/files/patch-src-xpdf-xpdf-Object.h b/editors/pdfedit/files/patch-src-xpdf-xpdf-Object.h new file mode 100644 index 000000000000..bda39d4fa157 --- /dev/null +++ b/editors/pdfedit/files/patch-src-xpdf-xpdf-Object.h @@ -0,0 +1,11 @@ +--- src/xpdf/xpdf/Object.h.orig 2015-08-23 03:17:00.826883000 +0900 ++++ src/xpdf/xpdf/Object.h 2015-08-23 03:17:15.658920000 +0900 +@@ -206,7 +206,7 @@ + private: + + ObjType type; // object type +- mutable union { // value for each type: ++ union { // value for each type: + GBool booln; // boolean + int intg; // integer + double real; // real diff --git a/editors/pdfedit/files/patch-src__gui__base.cc b/editors/pdfedit/files/patch-src__gui__base.cc new file mode 100644 index 000000000000..491b562bf508 --- /dev/null +++ b/editors/pdfedit/files/patch-src__gui__base.cc @@ -0,0 +1,24 @@ +--- src/gui/base.cc.orig 2010-02-22 10:17:40.000000000 +0900 ++++ src/gui/base.cc 2011-03-21 20:36:57.000000000 +0900 +@@ -688,7 +688,20 @@ + if (openMode=="readonly") mode=CPdf::ReadOnly; + if (openMode=="readwrite") mode=CPdf::ReadWrite; + //Basic mode without asking a password (we do not know how) +- return CPdf::getInstance(util::convertFromUnicode(filename,util::NAME).c_str(),mode); ++ boost::shared_ptr<pdfobjects::CPdf> pdf; ++ do { ++ try { ++ pdf = CPdf::getInstance(util::convertFromUnicode(filename,util::NAME).c_str(),mode); ++ }catch(PdfOpenException &e) { ++ // try to fallback to readonly mode ++ if (mode >= CPdf::ReadWrite) { ++ mode = CPdf::ReadOnly; ++ continue; ++ } ++ throw e; ++ } ++ }while(!pdf); ++ return pdf; + } + + /** \copydoc loadFromFile */ diff --git a/editors/pdfedit/files/patch-src__gui__pdfutil.cc b/editors/pdfedit/files/patch-src__gui__pdfutil.cc new file mode 100644 index 000000000000..21830bf30e08 --- /dev/null +++ b/editors/pdfedit/files/patch-src__gui__pdfutil.cc @@ -0,0 +1,24 @@ +--- src/gui/pdfutil.cc.orig 2009-04-07 00:24:47.000000000 +0900 ++++ src/gui/pdfutil.cc 2011-03-21 20:36:57.000000000 +0900 +@@ -451,7 +451,20 @@ + @param askPassword If true, password will be asked for if necessary + */ + boost::shared_ptr<CPdf> getPdfInstance(QWidget *parent, const QString &filename, CPdf::OpenMode mode, bool askPassword) { +- boost::shared_ptr<CPdf> pdf=CPdf::getInstance(util::convertFromUnicode(filename,util::NAME).c_str(), mode); ++ boost::shared_ptr<pdfobjects::CPdf> pdf; ++ do { ++ try { ++ pdf = CPdf::getInstance(util::convertFromUnicode(filename,util::NAME).c_str(),mode); ++ }catch(PdfOpenException &e) { ++ // try to fallback to readonly mode ++ if (mode >= CPdf::ReadWrite) { ++ mode = CPdf::ReadOnly; ++ continue; ++ } ++ throw e; ++ } ++ }while(!pdf); ++ + if (askPassword && pdf->needsCredentials()) { + for(;;) { + //Ask for password until we either get the right one or user gets bored with retrying diff --git a/editors/pdfedit/files/patch-src__kernel__cpagecontents.cc b/editors/pdfedit/files/patch-src__kernel__cpagecontents.cc new file mode 100644 index 000000000000..dd3825a041f4 --- /dev/null +++ b/editors/pdfedit/files/patch-src__kernel__cpagecontents.cc @@ -0,0 +1,374 @@ +--- src/kernel/cpagecontents.cc.orig 2010-04-30 21:44:30.000000000 +0900 ++++ src/kernel/cpagecontents.cc 2016-06-11 10:25:06.981679000 +0900 +@@ -55,8 +55,8 @@ + // + // + void +-CPageContents::ContentsWatchDog::notify (shared_ptr<IProperty> newValue, +- shared_ptr<const IProperty::ObserverContext> context) const throw() ++CPageContents::ContentsWatchDog::notify (boost::shared_ptr<IProperty> newValue, ++ boost::shared_ptr<const IProperty::ObserverContext> context) const throw() + { + kernelPrintDbg (debug::DBG_DBG, "context type=" << context->getType()); + +@@ -84,7 +84,7 @@ + case ComplexChangeContextType: + { + // Is it a dictionary Page dictionary +- shared_ptr<const CDict::CDictComplexObserverContext> ctxtdict = ++ boost::shared_ptr<const CDict::CDictComplexObserverContext> ctxtdict = + dynamic_pointer_cast<const CDict::CDictComplexObserverContext, + const IChangeContext<IProperty> > (context); + if (ctxtdict) +@@ -102,7 +102,7 @@ + // 1.2 Contents entry was removed + if (isNull(newValue)) + { +- shared_ptr<IProperty> oldValue = ctxtdict->getOriginalValue(); ++ boost::shared_ptr<IProperty> oldValue = ctxtdict->getOriginalValue(); + // Unregister observer + _cnt->unreg_observer (oldValue); + +@@ -116,7 +116,7 @@ + } + + // Is it an array (Contents) -- do nothing just reparse +- shared_ptr<const CArray::CArrayComplexObserverContext> ctxtarray = ++ boost::shared_ptr<const CArray::CArrayComplexObserverContext> ctxtarray = + dynamic_pointer_cast<const CArray::CArrayComplexObserverContext, + const IChangeContext<IProperty> > (context); + if (ctxtarray) +@@ -162,7 +162,7 @@ + createStreamFromObjects (const Container& cont, boost::weak_ptr<CPdf> pdf) + { + // Create stream with one default property Length +- shared_ptr<CStream> newstr (new CStream()); ++ boost::shared_ptr<CStream> newstr (new CStream()); + + // Insert our change tag + std::string str; +@@ -234,7 +234,7 @@ + } + + +-shared_ptr<CContentStream> ++boost::shared_ptr<CContentStream> + CPageContents::getContentStream (CContentStream* cc) + { + init(); +@@ -247,7 +247,7 @@ + } + + +-shared_ptr<CContentStream> ++boost::shared_ptr<CContentStream> + CPageContents::getContentStream (size_t pos) + { + init(); +@@ -265,7 +265,7 @@ + CPageContents::addToFront (const Container& cont) + { + // Create cstream from container of pdf operators +- shared_ptr<CStream> stream = createStreamFromObjects (cont, _dict->getPdf()); ++ boost::shared_ptr<CStream> stream = createStreamFromObjects (cont, _dict->getPdf()); + assert (hasValidRef (stream)); assert (hasValidPdf (stream)); + if (!hasValidPdf(stream) || !hasValidPdf(stream)) + throw CObjInvalidObject (); +@@ -294,8 +294,8 @@ + // Indicate change + change (); + } +-template void CPageContents::addToFront<vector<shared_ptr<PdfOperator> > > (const vector<shared_ptr<PdfOperator> >& cont); +-template void CPageContents::addToFront<deque<shared_ptr<PdfOperator> > > (const deque<shared_ptr<PdfOperator> >& cont); ++template void CPageContents::addToFront<vector<boost::shared_ptr<PdfOperator> > > (const vector<boost::shared_ptr<PdfOperator> >& cont); ++template void CPageContents::addToFront<deque<boost::shared_ptr<PdfOperator> > > (const deque<boost::shared_ptr<PdfOperator> >& cont); + + // + // +@@ -307,7 +307,7 @@ + // Create cstream from container of pdf operators + if (!hasValidPdf(_dict)) + throw CObjInvalidObject (); +- shared_ptr<CStream> stream = createStreamFromObjects (cont, _dict->getPdf()); ++ boost::shared_ptr<CStream> stream = createStreamFromObjects (cont, _dict->getPdf()); + assert (hasValidRef (stream)); assert (hasValidPdf (stream)); + if (!hasValidPdf(stream) || !hasValidPdf(stream)) + throw CObjInvalidObject (); +@@ -332,8 +332,8 @@ + // Indicate change + change (); + } +-template void CPageContents::addToBack<vector<shared_ptr<PdfOperator> > > (const vector<shared_ptr<PdfOperator> >& cont); +-template void CPageContents::addToBack<deque<shared_ptr<PdfOperator> > > (const deque<shared_ptr<PdfOperator> >& cont); ++template void CPageContents::addToBack<vector<boost::shared_ptr<PdfOperator> > > (const vector<boost::shared_ptr<PdfOperator> >& cont); ++template void CPageContents::addToBack<deque<boost::shared_ptr<PdfOperator> > > (const deque<boost::shared_ptr<PdfOperator> >& cont); + + + // +@@ -379,6 +379,12 @@ + + // Get the text + libs::Rectangle rec = (rc)? *rc : _page->display()->getPageRect(); ++ // if we use rotation 90,270 then we must change the rectangle from which we want the text ++ // accordingly (TODO - verify for all rotations) ++ int rot = _page->getRotation (); ++ if (90 == rot || 270 == rot) ++ std::swap (rec.xright, rec.yright); ++ + scoped_ptr<GString> gtxt (textDev->getText(rec.xleft, rec.yleft, rec.xright, rec.yright)); + text = gtxt->getCString(); + } +@@ -484,11 +490,11 @@ + if (fontName.empty()) + fontName = "PDFEDIT_F1"; + double fontSize = 15.0; +- shared_ptr<UnknownCompositePdfOperator> q(new UnknownCompositePdfOperator("q", "Q")); +- shared_ptr<UnknownCompositePdfOperator> BT(new UnknownCompositePdfOperator("BT", "ET")); ++ boost::shared_ptr<UnknownCompositePdfOperator> q(new UnknownCompositePdfOperator("q", "Q")); ++ boost::shared_ptr<UnknownCompositePdfOperator> BT(new UnknownCompositePdfOperator("BT", "ET")); + PdfOperator::Operands fontOperands; +- fontOperands.push_back(shared_ptr<IProperty>(new CName (fontName)) ); +- fontOperands.push_back(shared_ptr<IProperty>(new CReal (fontSize))); ++ fontOperands.push_back(boost::shared_ptr<IProperty>(new CName (fontName)) ); ++ fontOperands.push_back(boost::shared_ptr<IProperty>(new CReal (fontSize))); + q->push_back(BT,q); + BT->push_back(createOperator("Tf", fontOperands), getLastOperator(BT)); + +@@ -497,13 +503,13 @@ + BT->push_back(createOperator("Tm", posOperands), getLastOperator(BT)); + + PdfOperator::Operands textOperands; +- textOperands.push_back(shared_ptr<IProperty>(new CString (what))); ++ textOperands.push_back(boost::shared_ptr<IProperty>(new CString (what))); + BT->push_back(createOperator("Tj", textOperands), getLastOperator(BT)); + PdfOperator::Operands emptyOperands; + BT->push_back(createOperator("ET", emptyOperands), getLastOperator(BT)); + q->push_back(createOperator("Q", emptyOperands), getLastOperator(q)); + +- std::vector<shared_ptr<PdfOperator> > contents; ++ std::vector<boost::shared_ptr<PdfOperator> > contents; + contents.push_back(q); + + addToBack (contents); +@@ -531,7 +537,7 @@ + // EI + // Q + // +- shared_ptr<UnknownCompositePdfOperator> q(new UnknownCompositePdfOperator("q", "Q")); ++ boost::shared_ptr<UnknownCompositePdfOperator> q(new UnknownCompositePdfOperator("q", "Q")); + + // translate + q->push_back(createOperatorTranslation(where.x, where.y), getLastOperator(q)); +@@ -540,19 +546,23 @@ + + + CDict image_dict; +- image_dict.addProperty ("W", CInt (image_size.x)); +- image_dict.addProperty ("H", CInt (image_size.y)); +- image_dict.addProperty ("CS", CName ("RGB")); +- image_dict.addProperty ("BPC", CInt (8)); ++ CInt x (image_size.x); ++ image_dict.addProperty ("W", x); ++ CInt y (image_size.y); ++ image_dict.addProperty ("H", y); ++ CName n ("RGB"); ++ image_dict.addProperty ("CS", n); ++ CInt i (8); ++ image_dict.addProperty ("BPC", i); + CInlineImage img (image_dict, what); +- shared_ptr<CInlineImage> inline_image (new CInlineImage (image_dict, what)); +- shared_ptr<InlineImageCompositePdfOperator> BI(new InlineImageCompositePdfOperator (inline_image)); ++ boost::shared_ptr<CInlineImage> inline_image (new CInlineImage (image_dict, what)); ++ boost::shared_ptr<InlineImageCompositePdfOperator> BI(new InlineImageCompositePdfOperator (inline_image)); + + q->push_back(BI,getLastOperator(q)); + PdfOperator::Operands o; + q->push_back(createOperator("Q", o), getLastOperator(q)); + +- std::vector<shared_ptr<PdfOperator> > contents; ++ std::vector<boost::shared_ptr<PdfOperator> > contents; + contents.push_back(q); + + addToBack (contents); +@@ -595,7 +605,7 @@ + // addSomewhere + template<OPERWHERE WHERE> + void +- cc_add (shared_ptr<CDict> _dict, CRef& ref) ++ cc_add (boost::shared_ptr<CDict> _dict, CRef& ref) + { + // contents not present + if (!_dict->containsProperty (Specification::Page::CONTENTS)) +@@ -607,8 +617,8 @@ + // contents present + }else + { +- shared_ptr<IProperty> content = _dict->getProperty (Specification::Page::CONTENTS); +- shared_ptr<IProperty> realcontent = getReferencedObject(content); ++ boost::shared_ptr<IProperty> content = _dict->getProperty (Specification::Page::CONTENTS); ++ boost::shared_ptr<IProperty> realcontent = getReferencedObject(content); + assert (content); + // Contents can be either stream or an array of streams + if (isStream (realcontent)) +@@ -620,7 +630,7 @@ + }else if (isArray (realcontent)) + { + // We can be sure that streams are indirect objects (pdf spec) +- shared_ptr<CArray> array = IProperty::getSmartCObjectPtr<CArray> (realcontent); ++ boost::shared_ptr<CArray> array = IProperty::getSmartCObjectPtr<CArray> (realcontent); + OpTrait<WHERE>::Oper::add (*array, ref); + + }else // Neither stream nor array +@@ -672,7 +682,7 @@ + * Indicats that the page changed. + */ + template<typename Cont> +-void CPageContents::setContents (shared_ptr<CDict> dict, const Cont& cont) ++void CPageContents::setContents (boost::shared_ptr<CDict> dict, const Cont& cont) + { + + if (dict->containsProperty (Specification::Page::CONTENTS)) +@@ -682,7 +692,7 @@ + // Loop throug all content streams and add all cstreams from each + // content streams to Contents entry of page dictionary + // +- typedef vector<shared_ptr<CStream> > Css; ++ typedef vector<boost::shared_ptr<CStream> > Css; + Css css; + getAllCStreams (cont, css); + +@@ -698,14 +708,14 @@ + } + } + // Explicit instantiation +-template void CPageContents::setContents<vector<shared_ptr<CContentStream> > > +- (shared_ptr<CDict> dict, const vector<shared_ptr<CContentStream> >& cont); ++template void CPageContents::setContents<vector<boost::shared_ptr<CContentStream> > > ++ (boost::shared_ptr<CDict> dict, const vector<boost::shared_ptr<CContentStream> >& cont); + + // + // + // + void +-CPageContents::remove (shared_ptr<const CContentStream> cs) ++CPageContents::remove (boost::shared_ptr<const CContentStream> cs) + { + if (!_dict->containsProperty (Specification::Page::CONTENTS)) + throw CObjInvalidOperation (); +@@ -717,7 +727,7 @@ + // Loop throug all content streams and add all cstreams from each + // content streams to Contents entry of page dictionary + // +- typedef vector<shared_ptr<CStream> > Css; ++ typedef vector<boost::shared_ptr<CStream> > Css; + Css css; + cs->getCStreams (css); + +@@ -743,8 +753,8 @@ + void + CPageContents::remove (const IndiRef& rf) + { +- shared_ptr<IProperty> content = _dict->getProperty (Specification::Page::CONTENTS); +- shared_ptr<IProperty> realcontent = getReferencedObject (content); ++ boost::shared_ptr<IProperty> content = _dict->getProperty (Specification::Page::CONTENTS); ++ boost::shared_ptr<IProperty> realcontent = getReferencedObject (content); + assert (content); + // Contents can be either stream or an array of streams + if (isStream (realcontent)) +@@ -756,7 +766,7 @@ + }else if (isArray (realcontent)) + { + // We can be sure that streams are indirect objects (pdf spec) +- shared_ptr<CArray> array = IProperty::getSmartCObjectPtr<CArray> (realcontent); ++ boost::shared_ptr<CArray> array = IProperty::getSmartCObjectPtr<CArray> (realcontent); + for (size_t i = 0; i < array->getPropertyCount(); ++i) + { + IndiRef _rf = getRefFromArray (array,i); +@@ -821,7 +831,7 @@ + // + if (!_dict->containsProperty (Specification::Page::CONTENTS)) + return true; +- shared_ptr<IProperty> contents = getReferencedObject (_dict->getProperty (Specification::Page::CONTENTS)); ++ boost::shared_ptr<IProperty> contents = getReferencedObject (_dict->getProperty (Specification::Page::CONTENTS)); + assert (contents); + + CContentStream::CStreams streams; +@@ -831,13 +841,13 @@ + // + if (isStream (contents)) + { +- shared_ptr<CStream> stream = IProperty::getSmartCObjectPtr<CStream> (contents); ++ boost::shared_ptr<CStream> stream = IProperty::getSmartCObjectPtr<CStream> (contents); + streams.push_back (stream); + + }else if (isArray (contents)) + { + // We can be sure that streams are indirect objects (pdf spec) +- shared_ptr<CArray> array = IProperty::getSmartCObjectPtr<CArray> (contents); ++ boost::shared_ptr<CArray> array = IProperty::getSmartCObjectPtr<CArray> (contents); + for (size_t i = 0; i < array->getPropertyCount(); ++i) + streams.push_back (getCStreamFromArray(array,i)); + +@@ -854,7 +864,7 @@ + // True if Contents is not [ ] + while (!streams.empty()) + { +- shared_ptr<CContentStream> cc (new CContentStream(streams,state,res)); ++ boost::shared_ptr<CContentStream> cc (new CContentStream(streams,state,res)); + // Save smart pointer of the content stream so pdfoperators can return it + cc->setSmartPointer (cc); + _ccs.push_back (cc); +@@ -911,7 +921,7 @@ + // If it contains Contents register observer on it too + if (_dict->containsProperty(Specification::Page::CONTENTS)) + { +- shared_ptr<IProperty> prop = _dict->getProperty(Specification::Page::CONTENTS); ++ boost::shared_ptr<IProperty> prop = _dict->getProperty(Specification::Page::CONTENTS); + REGISTER_SHAREDPTR_OBSERVER(prop, _wd); + } + } +@@ -933,7 +943,7 @@ + // Unregister contents observer + if (_dict->containsProperty(Specification::Page::CONTENTS)) + { +- shared_ptr<IProperty> prop = _dict->getProperty(Specification::Page::CONTENTS); ++ boost::shared_ptr<IProperty> prop = _dict->getProperty(Specification::Page::CONTENTS); + UNREGISTER_SHAREDPTR_OBSERVER(prop, _wd); + } + } +@@ -963,7 +973,7 @@ + // + // + void +-CPageContents::moveAbove (shared_ptr<const CContentStream> ct) ++CPageContents::moveAbove (boost::shared_ptr<const CContentStream> ct) + { + // Get the next item + init(); +@@ -975,7 +985,7 @@ + throw OutOfRange (); + + // Delete next item but store it +- shared_ptr<CContentStream> tmp = *itNext; ++ boost::shared_ptr<CContentStream> tmp = *itNext; + _ccs.erase (itNext, itNext + 1); + // Insert stored item before supplied (simply swap ct with the next item) + _ccs.insert (find (_ccs.begin(), _ccs.end(), ct), tmp); +@@ -993,7 +1003,7 @@ + // + // + void +-CPageContents::moveBelow (shared_ptr<const CContentStream> ct) ++CPageContents::moveBelow (boost::shared_ptr<const CContentStream> ct) + { + // Get the item index + unsigned int pos = 0; +@@ -1007,7 +1017,7 @@ + throw CObjInvalidOperation (); + + // Swap +- shared_ptr<CContentStream> tmp = _ccs[pos]; ++ boost::shared_ptr<CContentStream> tmp = _ccs[pos]; + _ccs[pos] = _ccs[pos - 1]; + _ccs[pos - 1] = tmp; + diff --git a/editors/pdfedit/files/patch-src__tools__pdf_to_text.cc b/editors/pdfedit/files/patch-src__tools__pdf_to_text.cc new file mode 100644 index 000000000000..a7d1097d5150 --- /dev/null +++ b/editors/pdfedit/files/patch-src__tools__pdf_to_text.cc @@ -0,0 +1,45 @@ +--- src/tools/pdf_to_text.cc.orig 2010-04-23 15:58:36.000000000 +0900 ++++ src/tools/pdf_to_text.cc 2016-06-12 03:51:28.186690000 +0900 +@@ -45,8 +45,16 @@ + }; + // what to do with a page + struct _textify { +- string operator () (shared_ptr<CPage> page) ++ string operator () (boost::shared_ptr<CPage> page) + { ++ // Update display params to use media box not default page rect (DEFAULT_PAGE_RX, DEFAULT_PAGE_RY) ++ // TODO upsidedown? get/set ++ DisplayParams dp; ++ dp.useMediaBox = gTrue; ++ dp.crop = gFalse; ++ dp.rotate = page->getRotation (); ++ page->setDisplayParams (dp); ++ + string text; + static const std::string encoding="UTF-8"; + page->getText (text, &encoding); +@@ -97,13 +105,13 @@ + return 1; + + // open pdf +- shared_ptr<CPdf> pdf = CPdf::getInstance (file.c_str(), CPdf::ReadWrite); ++ boost::shared_ptr<CPdf> pdf = CPdf::getInstance (file.c_str(), CPdf::ReadWrite); + + if (pages.empty()) + { + for (size_t i = 1; i <= pdf->getPageCount(); ++i) + { +- shared_ptr<CPage> page = pdf->getPage(i); ++ boost::shared_ptr<CPage> page = pdf->getPage(i); + std::cout << "\nPage " << i << ":\n" << _textify()(page); + } + } +@@ -117,7 +125,7 @@ + continue; + } + +- shared_ptr<CPage> page = pdf->getPage(*it); ++ boost::shared_ptr<CPage> page = pdf->getPage(*it); + std::cout << "\nPage " << *it << ":\n" << _textify()(page); + } + |