/* Network-Integrated Multimedia Middleware (NMM)
 * http://www.motama.com/nmm.html
 *
 * Copyright (C) 2006-2007
 * Motama GmbH, Saarbruecken, Germany
 * http://www.motama.com
 *
 * This file is part of NMM. 
 * 
 * NMM 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; only version 2 of the License.      
 * 
 * NMM 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 NMM; if not, write to the Free Software Foundation,    
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 */

#ifndef NMM_IMagickManipulationNodeImpl_HPP
#define NMM_IMagickManipulationNodeImpl_HPP

#include "nmm/nmm_prefix.hpp"

#include "nmm/comm/NMMObject.hpp"
#include "IMagickManipulationNode.hpp"


#include "visibility.hpp"

namespace NMM
{

  class DLLEXPORT IMagickManipulationNodeImpl  : public virtual NMM::NMMObject { 
  public:
    IMagickManipulationNodeImpl() { addInterface(new IMagickManipulationNode(*this)); registerEvents(); };

    virtual ~IMagickManipulationNodeImpl() {};

  protected:

    virtual void setBorderColor(const nmm_double& r, const nmm_double& g, const nmm_double& b) = 0;

    virtual void clearManipulators() = 0;

    virtual void adaptiveThreshold(const nmm_uint32& width, const nmm_uint32& height, const nmm_uint32& offset = 0) = 0;

    virtual void addNoise(const string& noise_type) = 0;

    virtual void annotate(const string& text, const string& bounding_area, const string& gravity, const nmm_double& degrees) = 0;

    virtual void blur(const nmm_double& radius = 1, const nmm_double& sigma = 0.5) = 0;

    virtual void border(const string& geometry = "6x6+0+0") = 0;

    virtual void channel(const string& layer) = 0;

    virtual void charcoal(const nmm_double& radius = 1, const nmm_double& sigma = 0.5) = 0;

    virtual void chop(const string& geometry) = 0;

    virtual void colorize(const nmm_uint32& opacity_red, const nmm_uint32& opacity_green, const nmm_uint32& opacity_blue, const nmm_double& pen_color_r, const nmm_double& pen_color_g, const nmm_double& pen_color_b) = 0;

    virtual void comment(const string& comment) = 0;

    virtual void contrast(const nmm_uint32& sharpen) = 0;

    virtual void crop(const string& geometry) = 0;

    virtual void cycleColormap(const nmm_int32& amount) = 0;

    virtual void despeckle() = 0;

    virtual void edge(const nmm_uint32& radius = 0.0) = 0;

    virtual void emboss(const nmm_double& radius = 1, const nmm_double& sigma = 0.5) = 0;

    virtual void enhance() = 0;

    virtual void equalize() = 0;

    virtual void erase() = 0;

    virtual void flip() = 0;

    virtual void floodFillColor(const nmm_uint32& x, const nmm_uint32& y, const nmm_double& fill_color_r, const nmm_double& fill_color_g, const nmm_double& fill_color_b) = 0;

    virtual void floodFillOpacity(const nmm_int64& x, const nmm_int64& y, const nmm_uint32& opacity, const string& method) = 0;

    virtual void flop() = 0;

    virtual void frame(const nmm_uint32& width, const nmm_uint32& height, const nmm_int32& x, const nmm_int32& y, const nmm_int32& inner_bevel = 0, const nmm_int32& outer_bevel = 0) = 0;

    virtual void gamma(const nmm_double& gamma_red, const nmm_double& gamma_green, const nmm_double& gamma_blue) = 0;

    virtual void gaussianBlur(const nmm_double& width, const nmm_double& sigma) = 0;

    virtual void implode(const nmm_double& factor) = 0;

    virtual void label(const string& name) = 0;

    virtual void magnify() = 0;

    virtual void matteFloodfill(const nmm_double& target_r, const nmm_double& target_g, const nmm_double& target_b, const nmm_uint32& opacity, const nmm_int32& x, const nmm_int32& y, const string& method) = 0;

    virtual void medianFilter(const nmm_double& radius = 0.0) = 0;

    virtual void minify() = 0;

    virtual void modulate(const nmm_double& brightness, const nmm_double& saturation, const nmm_double& hue) = 0;

    virtual void negate() = 0;

    virtual void normalize() = 0;

    virtual void oilPaint(const nmm_uint32& radius = 3) = 0;

    virtual void opacity(const nmm_uint32& opacity) = 0;

    virtual void opaque(const nmm_double& opaque_color_r, const nmm_double& opaque_color_g, const nmm_double& opaque_color_b, const nmm_double& pen_color_r, const nmm_double& pen_color_g, const nmm_double& pen_color_b) = 0;

    virtual void quantize(const nmm_bool& measureError = false) = 0;

    virtual void raise(const string& geometry, const nmm_bool& raisedFlag = false) = 0;

    virtual void reduceNoise(const nmm_uint32& order) = 0;

    virtual void roll(const nmm_int32& columns, const nmm_int32& rows) = 0;

    virtual void rotate(const nmm_double& degrees) = 0;

    virtual void sample(const string& geometry) = 0;

    virtual void scale(const string& geometry) = 0;

    virtual void segment(const nmm_double& cluster_threshold = 1.0, const nmm_double& smoothing_threshold = 1.5) = 0;

    virtual void shade(const nmm_double& azimuth = 30, const nmm_double& elevation = 30, const nmm_bool& color_shading = false) = 0;

    virtual void sharpen(const nmm_double& radius = 1, const nmm_double& sigma = 0.5) = 0;

    virtual void shave(const string& geometry) = 0;

    virtual void shear(const nmm_double& x_shear_angle, const nmm_double& y_shear_angle) = 0;

    virtual void solarize(const nmm_double& factor = 50.0) = 0;

    virtual void spread(const nmm_uint32& amount = 3) = 0;

    virtual void swirl(const nmm_double& degrees) = 0;

    virtual void threshold(const nmm_double& threshold) = 0;

    virtual void transform(const string& image_geometry, const string& crop_geometry) = 0;

    virtual void transparent(const nmm_double& color_r, const nmm_double& color_g, const nmm_double& color_b) = 0;

    virtual void trim() = 0;

    virtual void unsharpmask(const nmm_double& radius, const nmm_double& sigma, const nmm_double& amount, const nmm_double& threshold) = 0;

    virtual void wave(const nmm_double& amplitude = 25.0, const nmm_double& wavelength = 150.0) = 0;

    virtual void zoom(const string& geometry) = 0;


  private:
    void registerEvents();
  };

}

#include "nmm/nmm_suffix.hpp"

#endif
