notepad_thumbnail.cpp

Go to the documentation of this file.

/*
 * File Name: notepad_filestore.cpp
 */

/*
 * This file is part of notepad.
 *
 * notepad 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, either version 2 of the License, or
 * (at your option) any later version.
 *
 * notepad 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. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * Copyright (C) 2010 IREX Technologies B.V.
 * All rights reserved.
 */

#include "config.h"
#include <gtk/gtk.h>
#include <libermetadb/ermetadb.h>

#include "log.h"
#include "notepad_utils.h"
#include "notepad_thumbnail.h"

#include "notepad_filestore.h"
#include "notepad_doc.h"
#include "notepad_ipc.h"

#include "notepad_pages.h" // TODO elimitate


namespace notepad
{

    // Columns in database table thumbnails.
    static const char* THUMBNAIL_COLUMNS[CThumbnail::THUMBNAIL_COUNT] =
    {
        "thumb_data_mini", // not used
        "thumb_data_small",
        "thumb_data_medium",
        "thumb_data_large" // not used
    };


    // store thumbnails in globaldb
    void CThumbnail::storeThumbnail(CFileStore& filestore, CNotepadPages& pages, gint margin)
    {
        LOGPRINTF("entry");

        // Create table.
        metadata_table* values = metadata_table_new();
        int             values_index = -1;
        if (values == NULL)
        {
            WARNPRINTF("exit failed metadata_table");
            return;
        }

        // convert pixmap to pixbuf
        GdkImage* cover = pages.get_page(1);
        
        if (cover == 0 || cover->width == 0 || cover->height == 0)
        {
            WARNPRINTF("trying to thumbnail an uninitialized page");
            return;
        }

        GdkPixbuf* raw_bmp = gdk_pixbuf_get_from_image(NULL,
                                                       cover,
                                                       gdk_colormap_get_system(),
                                                       margin, margin,
                                                       0, 0,
#if MACHINE_IS_DR1000S || MACHINE_IS_DR1000SW
                                                       cover->width - margin,
#endif
#if MACHINE_IS_DR800S || MACHINE_IS_DR800SG || MACHINE_IS_DR800SW
                                                       cover->width - 2*margin, 
#endif
                                                       cover->height - margin);

        if (raw_bmp == NULL)
        {
            WARNPRINTF("Error creating pixbuf.");
            return;
        }

        // rotate if in landscape
        np_rotation rotation = ipc_get_rotation();
        GdkPixbuf* rotated_bmp = 0;
        switch (rotation) 
        {
            case NP_CLOCKWISE:
                rotated_bmp = gdk_pixbuf_rotate_simple(raw_bmp, GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE);
                g_object_unref(raw_bmp);
                raw_bmp = rotated_bmp;
                break;
            case NP_ANTICLOCKWISE:
                rotated_bmp = gdk_pixbuf_rotate_simple(raw_bmp, GDK_PIXBUF_ROTATE_CLOCKWISE);
                g_object_unref(raw_bmp);
                raw_bmp = rotated_bmp;
                break;
            case NP_PORTRAIT:
            default:
                break;
        }

        // From pixbuf to blobs. 
        for (int size = 0; size <= THUMBNAIL_COUNT; size++)
        {
            if (size != THUMBNAIL_SMALL && size != THUMBNAIL_MEDIUM)
            {
                continue; // pass the unused sizes
            }

            // Calculate thumbnail size, conserve aspect ratio.
            int w = getWidth(static_cast<ThumbnailSize>(size));
            int h = getHeight(static_cast<ThumbnailSize>(size));
            int raw_w = gdk_pixbuf_get_width(raw_bmp);
            int raw_h = gdk_pixbuf_get_height(raw_bmp);
            float zoom_w = ((float)w) / ((float)raw_w);
            float zoom_h = ((float)h) / ((float)raw_h);
            if (zoom_w < zoom_h)
            {
                h = static_cast<int> (( ((float)raw_h) * zoom_w) + 0.5);
            }
            else
            {
                w = static_cast<int> (( ((float)raw_w) * zoom_h) + 0.5);
            }

            // Scale down the rendered bitmap.
            GdkPixbuf* scaled_bmp = gdk_pixbuf_scale_simple(raw_bmp, w, h, GDK_INTERP_BILINEAR);

            // Enforce thin lines to clip to black
            enhance(scaled_bmp, w, h);

            // Draw rectangle around the pixbuf.
            drawRectangle(scaled_bmp, w, h);

            gchar* blob = NULL;
            gsize  blob_size = 0;

            // Add column according to the size.
            if (gdk_pixbuf_save_to_buffer(scaled_bmp, &blob, &blob_size, "png", NULL, NULL))
            {
                metadata_table_add_column(values, THUMBNAIL_COLUMNS[size]);
                values_index++;

                metadata_table_set_blob(values, values_index, blob, blob_size);
            }

            g_object_unref(scaled_bmp);
        }

        // write thumbnails to global database
        const char* mountpoint = ipc_get_mountpoint();
        erMetadb global_db = ermetadb_global_open(mountpoint, FALSE);
        if (global_db == 0) 
        {
            WARNPRINTF("open globaldb for writing thumbnail failed.");
            return;
        }
        gchar* dir  = filestore.getFileNameDirPart();
        gchar* file = filestore.getFileNameFilePart();

        int rc = ermetadb_global_change_file(global_db, dir, file, values);
        if (rc != ER_OK) 
        {
            WARNPRINTF("cannot update global db");
        }
        ermetadb_close(global_db);
        g_free(dir);
        g_free(file);

        // Clean up.
        if (raw_bmp)
        {
            g_object_unref(raw_bmp);
        }
        metadata_table_free(values);

        LOGPRINTF("exit");
        return;
    }


    // functions for drawing the rectangle around the thumbnail
    void CThumbnail::putPixel(GdkPixbuf* pixbuf, gint x, gint y)
    {
        gint channel    = gdk_pixbuf_get_n_channels(pixbuf);
        gint rowstride  = gdk_pixbuf_get_rowstride(pixbuf);
        guchar* pixel   = gdk_pixbuf_get_pixels(pixbuf);
        guchar* p       = pixel + y * rowstride + x * channel;
        p[0] = 0; //r
        p[1] = 0; //g
        p[2] = 0; //b
    }

    void CThumbnail::enhance(GdkPixbuf* pixbuf, gint width, gint height)
    {
        gint channel    = gdk_pixbuf_get_n_channels(pixbuf);
        gint rowstride  = gdk_pixbuf_get_rowstride(pixbuf);
        guchar* pixel   = gdk_pixbuf_get_pixels(pixbuf);

        for (gint x = 0; x < width; x++)
        {
            for (gint y = 0; y < height; y++)
            {
                guchar* p = pixel + y * rowstride + x * channel;

                // Set not-white to black
                if (p[0] + p[1] + p[2] < 3*0xFF) 
                {
                    p[0] = 0; //r
                    p[1] = 0; //g
                    p[2] = 0; //b
                }
            }
        }
    }

    void CThumbnail::drawRectangle(GdkPixbuf* pixbuf, gint width, gint height) 
    { 
        g_assert(pixbuf != 0);
        gint w = width -1; // right line 1px before to fit width
        gint h = height -1; // lower line 1px before to fit height
        for (gint x = 0; x < width; x++)
        {
            putPixel(pixbuf, x, 0);
            putPixel(pixbuf, x, h);
        }
        for (gint y = 0; y < height; y++)
        {
            putPixel(pixbuf, 0, y);
            putPixel(pixbuf, w, y);
        }
    }

    gint CThumbnail::getWidth(const ThumbnailSize size)
    {
        switch (size)
        {
            case THUMBNAIL_SMALL:
                return 60;
            case THUMBNAIL_MEDIUM:
                return 120;
            case THUMBNAIL_LARGE: // not used
                return 300;
            default:
                return 300;
        }
    }

    gint CThumbnail::getHeight(const ThumbnailSize size)
    {
        switch (size)
        {
            case THUMBNAIL_SMALL:
                return 60;
            case THUMBNAIL_MEDIUM:
                return 120;
            case THUMBNAIL_LARGE: // not used
                return 300;
            default:
                return 300;
        }
    }

}