tiledbitmapinterface.hh

Go to the documentation of this file.

/*
 * Scroom - Generic viewer for 2D data
 * Copyright (C) 2009-2022 Kees-Jan Dijkzeul
 *
 * SPDX-License-Identifier: LGPL-2.1
 */
 
#pragma once
 
#include <vector>
 
#include <boost/shared_ptr.hpp>
 
#include <gdk/gdk.h>
#include <gtk/gtk.h>
 
#include <cairo.h>
 
#include <scroom/interface.hh>
#include <scroom/presentationinterface.hh>
#include <scroom/rectangle.hh>
#include <scroom/scroominterface.hh>
#include <scroom/stuff.hh>
#include <scroom/tile.hh>
#include <scroom/unused.hh>
#include <scroom/viewinterface.hh>
 
enum TileState
{
  TILE_UNINITIALIZED, 
  TILE_UNLOADED,      
  TILE_LOADED,        
  TILE_OUT_OF_BOUNDS  
};
 
class LayerOperations : private Interface
{
public:
  using Ptr = boost::shared_ptr<LayerOperations>;
 
public:
  virtual int getBpp() = 0;
 
  virtual void initializeCairo(cairo_t* cr) = 0;
 
  virtual void draw(cairo_t*                         cr,
                    const ConstTile::Ptr&            tile,
                    Scroom::Utils::Rectangle<double> tileArea,
                    Scroom::Utils::Rectangle<double> viewArea,
                    int                              zoom,
                    Scroom::Utils::Stuff             cache) = 0;
 
  virtual void drawState(cairo_t* cr, TileState s, Scroom::Utils::Rectangle<double> viewArea) = 0;
 
  virtual Scroom::Utils::Stuff cache(const ConstTile::Ptr& tile)
  {
    UNUSED(tile);
    return {};
  }
 
  virtual Scroom::Utils::Stuff cacheZoom(const ConstTile::Ptr& tile, int zoom, Scroom::Utils::Stuff& cache)
  {
    UNUSED(tile);
    UNUSED(zoom);
    UNUSED(cache);
    return {};
  }
 
  virtual void reduce(Tile::Ptr target, ConstTile::Ptr source, int x, int y) = 0;
};
 
using LayerSpec = std::vector<LayerOperations::Ptr>;
 
class SourcePresentation : private Interface
{
public:
  using Ptr = boost::shared_ptr<SourcePresentation>;
 
public:
  virtual void fillTiles(int startLine, int lineCount, int tileWidth, int firstTile, std::vector<Tile::Ptr>& tiles) = 0;
 
  virtual void done() = 0;
 
  virtual std::string getName() = 0;
};
 
class Layer;
 
class TiledBitmapInterface : public Viewable
{
public:
  using Ptr = boost::shared_ptr<TiledBitmapInterface>;
 
  virtual void setSource(SourcePresentation::Ptr sp) = 0;
 
  virtual boost::shared_ptr<Layer> getBottomLayer() = 0;
 
  virtual void
    redraw(ViewInterface::Ptr const& vi, cairo_t* cr, const Scroom::Utils::Rectangle<double>& presentationArea, int zoom) = 0;
 
  virtual void clearCaches(ViewInterface::Ptr vi) = 0;
};
 
TiledBitmapInterface::Ptr createTiledBitmap(int bitmapWidth, int bitmapHeight, LayerSpec const& ls);