cpagecontents.h

Go to the documentation of this file.

/*
 * PDFedit - free program for PDF document manipulation.
 * Copyright (C) 2006-2009  PDFedit team: Michal Hocko,
 *                                        Jozef Misutka,
 *                                        Martin Petricek
 *                   Former team members: Miroslav Jahoda
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program (in doc/LICENSE.GPL); if not, write to the 
 * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, 
 * MA  02111-1307  USA
 *
 * Project is hosted on http://sourceforge.net/projects/pdfedit
 */
// vim:tabstop=4:shiftwidth=4:noexpandtab:textwidth=80

#ifndef _CPAGECONTENTS_H_
#define _CPAGECONTENTS_H_

// static includes
#include "kernel/static.h"
#include "kernel/cpagemodule.h"

#include "kernel/iproperty.h"
#include "kernel/ccontentstream.h"
#include "kernel/cstream.h"
#include "kernel/textoutput.h"
#include "kernel/textsearchparams.h"
#include "kernel/stateupdater.h"
#include "kernel/cobjectsimple.h"


//==========================================================
namespace pdfobjects {
//==========================================================

// Forward declaration
class CPage;
class CDict;


//==========================================================
// CPageContents
//==========================================================

class CPageContents : public ICPageModule
{

    //==========================================================
    // Contents observer
    //==========================================================
private:

    class ContentsWatchDog: public IPropertyObserver
    {
    private:
        CPageContents* _cnt;
    public:
        ContentsWatchDog (CPageContents* cnt) : _cnt(cnt) { assert(_cnt); }
        virtual ~ContentsWatchDog() throw() {}
        // IPropertyObserver Interface
        virtual void notify (boost::shared_ptr<IProperty>, boost::shared_ptr<const IProperty::ObserverContext>) const throw();
        virtual priority_t getPriority() const throw() 
            { return 0; }
    
    };  // class ContentsWatchDog

    //==========================================================

    struct Tm 
    {
        Tm () 
        {
            std::fill (_tm, _tm+6, 0); _tm[0] = _tm[3] = 1; 
        }
        void operator= (const PdfOperator::Operands& ops) 
        { 
                if (ops.size() !=  6)
                    return;
            for (size_t i = 0; i < 6; ++i)
                _tm[i] = utils::getDoubleFromIProperty(ops[i]);
        }
        void set_position (const libs::Point& p) 
            { _tm[4] = p.x; _tm[5] = p.y; }
        operator PdfOperator::Operands () 
        {
            PdfOperator::Operands _opers;
            for (const double* it = &_tm[0]; it != &_tm[6]; ++it)
                _opers.push_back (boost::shared_ptr<IProperty>(new CReal (*it)));
            return  _opers;
        }
        double _tm [6];
    };


    // Typedefs
private:
    typedef std::vector<boost::shared_ptr<CContentStream> > CCs;

    // Variables
private:
    CCs _ccs;       // content streams
    CPage* _page;   // pages
    boost::shared_ptr<CDict> _dict; // pages
    boost::shared_ptr<ContentsWatchDog> _wd;
    Tm _likely_tm;


    // Ctor & Dtor
public:
    CPageContents (CPage* page);
    ~CPageContents ();

    //
    // ICPageModule interface
    //
public:
    virtual void reset ();


    //
    // Methods
    //
public:

    void reparse ();

    template<typename Container>
    void addToFront (const Container& cont);

    template<typename Container> 
    void addToBack (const Container& cont);

    void remove (size_t csnum);

     template<typename RectangleContainer>
     size_t findText (std::string text, 
                      RectangleContainer& recs, 
                      const TextSearchParams& params = TextSearchParams()) const;

    void replaceText (const std::string& what, const std::string& with);

    void addText (const std::string& what, 
                  const libs::Point& where,
                  const std::string& font_id);

    void addInlineImage (const CStream::Buffer& what,
                         const libs::Point& image_size,
                         const libs::Point& where);

    template<typename WordEngine, 
             typename LineEngine, 
             typename ColumnEngine>
    void convert (textoutput::OutputBuilder& out)
    {
            kernelPrintDbg (debug::DBG_INFO, ""); 

        typedef textoutput::PageTextSource<WordEngine, LineEngine, ColumnEngine> TextSource;

        // Create gfx resource and state
        boost::shared_ptr<GfxResources> gfxres;
        boost::shared_ptr<GfxState> gfxstate;
        _xpdf_display_params (gfxres, gfxstate);
            assert (gfxres && gfxstate);

        // Create page text class with parametrized parts
        TextSource text_source;

        // Get text from all content streams
        init();
        for (CCs::iterator it = _ccs.begin(); it != _ccs.end(); ++it)
        {
            // Get operators and build text representation if not empty
            CContentStream::Operators ops;
            (*it)->getPdfOperators (ops);
            if (!ops.empty())
            {
                PdfOperator::Iterator itt = PdfOperator::getIterator (ops.front());
                StateUpdater::updatePdfOperators<TextSource&> (itt, gfxres, *gfxstate, text_source);
            }
        }

        // Create lines, columns...
        text_source.format ();
        // Build the output
        if (hasValidPdf(_dict))
            text_source.output (out, _page_pos());
        else
            text_source.output (out, 0);
    }

    //
    // Getters & Setters
    //
public:

    template<typename OpContainer, typename PositionComparator>
    void getObjectsAtPosition (OpContainer& opContainer, PositionComparator cmp)
    {   
        init();
        // Get the objects with specific comparator
        for (CCs::iterator it = _ccs.begin (); it != _ccs.end(); ++it)
            (*it)->getOperatorsAtPosition (opContainer, cmp);
    }

    boost::shared_ptr<CContentStream> getContentStream (CContentStream* cc); 

    boost::shared_ptr<CContentStream> getContentStream (size_t pos); 

    template<typename Container> 
    void getContentStreams (Container& container)
    {
        init();
        container.clear();
        std::copy (_ccs.begin(), _ccs.end(), std::back_inserter(container));
    }

    void getText (std::string& text, 
                  const std::string* encoding = NULL, 
                  const libs::Rectangle* rc = NULL) const;
 
    void moveAbove (boost::shared_ptr<const CContentStream> ct);
    void moveAbove (size_t pos);

    void moveBelow (boost::shared_ptr<const CContentStream> ct);
    void moveBelow (size_t pos);



    //
    // CCs methods
    //
public:

    template<typename Cont> 
    static void setContents (boost::shared_ptr<CDict> dict, const Cont& cont);

    //
    // CCs helper methods
    //
private:
    void toFront (CRef& ref);
    void toBack (CRef& ref);

    void remove (boost::shared_ptr<const CContentStream> cs);
    void remove (const IndiRef& rf);

    bool parse ();

    //
    // Helper methods
    //
private:

    inline void init ()
    {
        if (_ccs.empty())
            parse ();       
    }

    inline void change (bool invalid = false);

    //
    // Helper methods because of cpage not included in headers
    //
private:
    void _xpdf_display_params (boost::shared_ptr<GfxResources>& res, 
                               boost::shared_ptr<GfxState>& state);
    size_t _page_pos () const;


    //
    // Helper methods because of cpage not included in headers
    //
private:

    void reg_observer (boost::shared_ptr<IProperty> ip = boost::shared_ptr<IProperty>()) const;

    void unreg_observer (boost::shared_ptr<IProperty> ip = boost::shared_ptr<IProperty>()) const;


    struct ContentsObserverFreeSection
    {
        CPageContents* _cnt;
        ContentsObserverFreeSection (CPageContents* cnt) : _cnt (cnt)
            { _cnt->unreg_observer(); }
        ~ContentsObserverFreeSection () 
            { _cnt->reg_observer();}
    };

}; // class CPageContents

//==========================================================
} // namespace pdfobjects
//==========================================================


#endif // _CPAGECONTENTS_H_