pdf::PDFRenderer Class Reference

The document renderer class. More...

#include <pdf_renderer.h>

Collaboration diagram for pdf::PDFRenderer:

[legend]

Public Member Functions
	PDFRenderer ()
virtual	~PDFRenderer (void)
bool	initialize (PDFController *doc)
	Initialize the pdf renderer.
void	destroy ()
	Destroy the renderer.
void	post_render_task (int page_num, const PDFRenderAttributes &render_attr, PluginRenderResultImpl *render_res, const unsigned int ref_id=PRERENDER_REF_ID)
	Post the render task into the task list of thread.
void	handle_page_ready (RenderResultPtr render_res, PagePtr page, RenderStatus stat)
PDFViewAttributes &	get_view_attr ()
	Get the view attributes.
const PDFRenderAttributes &	get_render_attr ()
	Get the current render attributes.
PagePtr	gen_page (int page_num, const PDFRenderAttributes &attr)
	Generate a page by input context.
PagePtr	gen_page (int page_num)
	Generate a page by default context.
Mutex &	get_render_mutex ()
	Get the mutex of rendering.
bool	render_cover_page (const int width, const int height, PluginBitmapAttributes *output)
	Render the cover page for UDS.
Static Public Attributes
static SplashColor	background_color = {255, 255, 255, 0}
Friends
class	PDFRenderTask
class	PDFPage

---

Detailed Description

The document renderer class.

Definition at line 129 of file pdf_renderer.h.

---

Constructor & Destructor Documentation

pdf::PDFRenderer::PDFRenderer

(

)

Definition at line 39 of file pdf_renderer.cpp.

: doc_controller(0)
, splash_output_dev(0)
, text_output_dev(0)
, thumbnail_output_dev(0)
, view_attr()
, cur_render_attr()
, render_mutex()
{
}

pdf::PDFRenderer::~PDFRenderer

(

void

)

[virtual]

Definition at line 50 of file pdf_renderer.cpp.

References destroy().

{
    destroy();
}

Here is the call graph for this function:

---

Member Function Documentation

void pdf::PDFRenderer::destroy

(

)

Destroy the renderer.

Definition at line 105 of file pdf_renderer.cpp.

Referenced by pdf::PDFController::close(), initialize(), and ~PDFRenderer().

{
    delete splash_output_dev;
    splash_output_dev = 0;

    delete text_output_dev;
    text_output_dev = 0;

    delete thumbnail_output_dev;
    thumbnail_output_dev = 0;
}

Here is the caller graph for this function:

PagePtr pdf::PDFRenderer::gen_page

(

int

page_num

)

Generate a page by default context.

Definition at line 543 of file pdf_renderer.cpp.

References pdf::PagesCache::add_page(), PDFPage, and pdf::PDFPage::set_doc_controller().

{
    // construct a default page
    PagePtr page = new PDFPage(page_num, cur_render_attr);
    page->set_doc_controller(doc_controller);

    // put the page into cache
    doc_controller->pages_cache.add_page(page);

    return page;
}

Here is the call graph for this function:

PagePtr pdf::PDFRenderer::gen_page	(	int	page_num,
		const PDFRenderAttributes &	attr
	)

Generate a page by input context.

Definition at line 532 of file pdf_renderer.cpp.

References pdf::PagesCache::add_page(), PDFPage, and pdf::PDFPage::set_doc_controller().

Referenced by pdf::PDFRenderTask::execute().

{
    PagePtr page = new PDFPage(page_num, attr);
    page->set_doc_controller(doc_controller);

    // put the page into cache
    doc_controller->pages_cache.add_page(page);

    return page;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const PDFRenderAttributes& pdf::PDFRenderer::get_render_attr

(

)

[inline]

Get the current render attributes.

Definition at line 161 of file pdf_renderer.h.

{ return cur_render_attr; }

Mutex& pdf::PDFRenderer::get_render_mutex

(

)

[inline]

Get the mutex of rendering.

Definition at line 170 of file pdf_renderer.h.

Referenced by pdf::PDFPage::get_content_area(), pdf::PDFPage::render_splash_map(), and pdf::PDFPage::render_text().

{ return render_mutex; }

Here is the caller graph for this function:

PDFViewAttributes& pdf::PDFRenderer::get_view_attr

(

)

[inline]

Get the view attributes.

Definition at line 158 of file pdf_renderer.h.

Referenced by pdf::PDFPage::get_content_area(), pdf::PDFController::get_page_crop_height(), pdf::PDFController::get_page_crop_width(), render_cover_page(), pdf::PDFPage::render_splash_map(), and pdf::PDFPage::render_text().

{ return view_attr; }

Here is the caller graph for this function:

void pdf::PDFRenderer::handle_page_ready	(	RenderResultPtr	render_res,
		PagePtr	page,
		RenderStatus	stat
	)

Handle the page ready event if param page is not null, it means the page has been successfully rendered. If reference number of the page is invalid(-1), it means this page is rendered by prerendering. We don't have to notify UDS. if param page is null, it means the page has not been successfully rendered (caused by out of memory).

Referenced by pdf::PDFRenderTask::execute(), and post_render_task().

Here is the caller graph for this function:

bool pdf::PDFRenderer::initialize

(

PDFController *

doc

)

Initialize the pdf renderer.

Definition at line 55 of file pdf_renderer.cpp.

References background_color, destroy(), ERRORPRINTF, and pdf::PDFController::get_pdf_doc().

Referenced by pdf::PDFController::open().

{
    //Destroy the pre-built renderer.
    destroy();

    doc_controller = doc;
    //assert(doc_controller);
    if (doc_controller == 0)
    {
        ERRORPRINTF("Null Document Controller");
        return false;
    }

    SplashColorMode mode = splashModeMono8;

    // Create splash output device
    splash_output_dev = new SplashOutputDev(mode, 4, gFalse, PDFRenderer::background_color);
    if (splash_output_dev == 0)
    {
        ERRORPRINTF("Cannot Open Splash Output Device");
        return false;
    }

    // Start output device with the document
    splash_output_dev->startDoc(doc_controller->get_pdf_doc()->getXRef());
    
    // Create text output device
    text_output_dev = new TextOutputDev(NULL, gTrue, gFalse, gFalse);
    if (text_output_dev == 0)
    {
        ERRORPRINTF("Cannot Open Text Output Device");
        return false;
    }

    // Create thumbnail output device
    thumbnail_output_dev = new SplashOutputDev(mode, 4, gFalse, PDFRenderer::background_color);
    if (thumbnail_output_dev == 0)
    {
        ERRORPRINTF("Cannot Open Thumbnail Output Device");
        return false;
    }

    thumbnail_output_dev->startDoc(doc_controller->get_pdf_doc()->getXRef());

    init_pages_index_table();

    return true;

}

Here is the call graph for this function:

Here is the caller graph for this function:

void pdf::PDFRenderer::post_render_task	(	int	page_num,
		const PDFRenderAttributes &	render_attr,
		PluginRenderResultImpl *	render_res,
		const unsigned int	ref_id = PRERENDER_REF_ID
	)

Post the render task into the task list of thread.

Definition at line 358 of file pdf_renderer.cpp.

References pdf::PDFPrerenderPolicy::generate_requests_list(), pdf::PDFController::get_cur_page_num(), pdf::PagesCache::get_mutex(), pdf::PDFController::get_page(), pdf::PDFController::get_prerender_policy(), pdf::PDFPage::get_render_attr(), pdf::PDFPage::get_render_status(), pdf::PDFRenderTask::get_user_data(), pdf::PDFRenderAttributes::get_zoom_setting(), handle_page_ready(), pdf::PDFLibrary::instance(), LOGPRINTF, pdf::PDFController::page_count(), pdf::PDFPage::RENDER_DONE, pdf::PDFPage::RENDER_RUNNING, pdf::PluginRenderResultImpl::set_page(), pdf::PDFPage::set_ref_id(), pdf::TASK_RENDER_DONE, pdf::TASK_RENDER_INVALID_PAGE, pdf::PDFLibrary::thread_add_render_task(), and pdf::PDFLibrary::thread_cancel_render_tasks().

{
    if (page_num <= 0 || page_num > static_cast<int>(doc_controller->page_count()))
    {
        handle_page_ready(render_res, 0, TASK_RENDER_INVALID_PAGE);
        return;
    }

    // set the current displaying page
    int last_page = doc_controller->get_cur_page_num();
    doc_controller->set_cur_page_num(page_num);

    PDFRenderAttributes real_attr;
    calc_real_zoom(page_num, render_attr, real_attr);
    // update global render setting
    cur_render_attr = real_attr;

    // generate request queue of rendering based on current page and last page
    // at this moment, the previous request queue would be cleared.
    std::vector<size_t> requests;
    doc_controller->get_prerender_policy()->generate_requests_list(page_num,
                                                                   last_page,
                                                                   doc_controller->page_count(),
                                                                   requests);

    // estimate whether the requested page is cached
    PagePtr page = doc_controller->get_page(page_num);
    PDFRenderTask* render_task = 0;
    bool abort_current_task = true;
    if (page)
    {
        {
            ScopeMutex m(&(doc_controller->get_pages_cache().get_mutex()));
            if (page->get_render_attr() == cur_render_attr)
            {
                if (page->get_render_status() == PDFPage::RENDER_DONE &&
                    render_res != 0)
                {
                    // update the reference to this page, make it ready to display
                    // need NOT generate a new render task
                    page->set_ref_id(ref_id);
                    render_res->set_page(page);
                }
                else
                {
                    // create a new render task
                    render_task = gen_render_task(page,
                                                  real_attr,
                                                  render_res,
                                                  ref_id);
                    if (page->get_render_status() == PDFPage::RENDER_RUNNING)
                    {
                        abort_current_task = false;
                    }
                }
            }
            else
            {
                render_task = gen_render_task(page,
                                              real_attr,
                                              render_res,
                                              ref_id);
            }
        }
    }
    else
    {
        // the page is not cached, create a new Render task
        render_task = gen_render_task(page_num,
                                      real_attr,
                                      render_res,
                                      ref_id);
    }

    if (render_task != 0)
    {
        LOGPRINTF("PDF tries to render page:%d zoom:%f\n\n",
                  page_num,
                  real_attr.get_zoom_setting());

        // cancel all of the render tasks in the queue
        PDFLibrary::instance().thread_cancel_render_tasks(render_task->get_user_data());

        // add task for normally rendering
        PDFLibrary::instance().thread_add_render_task(render_task,
                                                      false,
                                                      abort_current_task);
    }
    else if (page != 0 && render_res != 0 &&
             page->get_render_status() == PDFPage::RENDER_DONE)
    {
        // if the page is ready, return it to UDS
        handle_page_ready(render_res, page, TASK_RENDER_DONE);
    }

    // prerender the pages, start from 1 in the requests list because
    // the normal rendering page is always located at 0.
    for (size_t idx = 1; idx < requests.size(); ++idx)
    {
        int dst_page = requests.at(idx);
        post_prerender_task(dst_page, render_attr);
    }
}

Here is the call graph for this function:

bool pdf::PDFRenderer::render_cover_page	(	const int	width,
		const int	height,
		PluginBitmapAttributes *	output
	)

Render the cover page for UDS.

Definition at line 214 of file pdf_renderer.cpp.

References PluginBitmapAttributes::data, ERRORPRINTF, pdf::PDFController::get_page_crop_height(), pdf::PDFController::get_page_crop_width(), pdf::PDFController::get_pdf_doc(), get_view_attr(), and pdf::PDFController::page_count().

{
    if (doc_controller->page_count() < 1)
    {
        // return false if it is an empty document
        return false;
    }

    int cover_num = 1;
    // 1. calculate the zoom, fit for best
    double crop_width = doc_controller->get_page_crop_width(cover_num);
    double crop_height = doc_controller->get_page_crop_height(cover_num);

    double zoom = min(static_cast<double>(width) / crop_width,
        static_cast<double>(height) / crop_height);

    // 2. render the splash bitmap of cover
    // lock when rendering
    ScopeMutex m(&render_mutex);

    RenderRet ret = doc_controller->get_pdf_doc()->displayPage(
        get_thumbnail_output_dev()
        , cover_num
        , zoom * get_view_attr().get_device_dpi_h()
        , zoom * get_view_attr().get_device_dpi_v()
        , 0
        , gFalse //useMediaBox, TODO.
        , gFalse  //crop, TODO.
        , gFalse  //doLinks, TODO.
    );

    if (ret == Render_Error || ret == Render_Invalid)
    {
        ERRORPRINTF("Error in rendering cover page:%d\n", cover_num);
        return false;
    }

    SplashBitmap *cover_map = get_thumbnail_output_dev()->takeBitmap();
    if (cover_map != 0)
    {
        memcpy((void*)output->data, cover_map->getDataPtr(),
            cover_map->getRowSize() * cover_map->getHeight());
        delete cover_map;
        return true;
    }

    return false;
}

Here is the call graph for this function:

---

Friends And Related Function Documentation

friend class PDFPage [friend]

Definition at line 238 of file pdf_renderer.h.

Referenced by gen_page().

friend class PDFRenderTask [friend]

Definition at line 237 of file pdf_renderer.h.

---

Field Documentation

SplashColor pdf::PDFRenderer::background_color = {255, 255, 255, 0} [static]

Definition at line 177 of file pdf_renderer.h.

Referenced by initialize().

---

The documentation for this class was generated from the following files:

• pdf_renderer.h
• pdf_renderer.cpp