/* 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_IMagickManipulationNode_HPP
#define NMM_IMagickManipulationNode_HPP

#include "nmm/nmm_prefix.hpp"

#include "nmm/comm/Interface.hpp"
#include "nmm/comm/messaging/Event.hpp"
#include "nmm/comm/messaging/IllegalStateException.hpp"
#include <memory>


#include "visibility.hpp"

namespace NMM
{

  class DLLEXPORT IMagickManipulationNode : virtual public NMM::Interface { 
  public:
    IMagickManipulationNode() : NMM::Interface(IMagickManipulationNode::IMagickManipulationNode_type, "NMM") { };

    IMagickManipulationNode(NMM::NMMObject& parent) : NMM::Interface (parent, IMagickManipulationNode::IMagickManipulationNode_type, "NMM") { };

    virtual ~IMagickManipulationNode() {};

    static const char* IMagickManipulationNode_type;

    virtual  string getInterfaceType() const { return IMagickManipulationNode_type; }

    NMM::Interface* copy() const { return new IMagickManipulationNode(*this); }
    static void used(); 
    static const char* setBorderColor_event;
    static const char* clearManipulators_event;
    static const char* adaptiveThreshold_event;
    static const char* addNoise_event;
    static const char* annotate_event;
    static const char* blur_event;
    static const char* border_event;
    static const char* channel_event;
    static const char* charcoal_event;
    static const char* chop_event;
    static const char* colorize_event;
    static const char* comment_event;
    static const char* contrast_event;
    static const char* crop_event;
    static const char* cycleColormap_event;
    static const char* despeckle_event;
    static const char* edge_event;
    static const char* emboss_event;
    static const char* enhance_event;
    static const char* equalize_event;
    static const char* erase_event;
    static const char* flip_event;
    static const char* floodFillColor_event;
    static const char* floodFillOpacity_event;
    static const char* flop_event;
    static const char* frame_event;
    static const char* gamma_event;
    static const char* gaussianBlur_event;
    static const char* implode_event;
    static const char* label_event;
    static const char* magnify_event;
    static const char* matteFloodfill_event;
    static const char* medianFilter_event;
    static const char* minify_event;
    static const char* modulate_event;
    static const char* negate_event;
    static const char* normalize_event;
    static const char* oilPaint_event;
    static const char* opacity_event;
    static const char* opaque_event;
    static const char* quantize_event;
    static const char* raise_event;
    static const char* reduceNoise_event;
    static const char* roll_event;
    static const char* rotate_event;
    static const char* sample_event;
    static const char* scale_event;
    static const char* segment_event;
    static const char* shade_event;
    static const char* sharpen_event;
    static const char* shave_event;
    static const char* shear_event;
    static const char* solarize_event;
    static const char* spread_event;
    static const char* swirl_event;
    static const char* threshold_event;
    static const char* transform_event;
    static const char* transparent_event;
    static const char* trim_event;
    static const char* unsharpmask_event;
    static const char* wave_event;
    static const char* zoom_event;

    virtual void setBorderColor(const nmm_double& r, const nmm_double& g, const nmm_double& b)
      throw(const NMM::SerializedException&);

    virtual void clearManipulators()
      throw(const NMM::SerializedException&);

    virtual void adaptiveThreshold(const nmm_uint32& width, const nmm_uint32& height, const nmm_uint32& offset = 0)
      throw(const NMM::SerializedException&);

    virtual void addNoise(const string& noise_type)
      throw(const NMM::SerializedException&);

    virtual void annotate(const string& text, const string& bounding_area, const string& gravity, const nmm_double& degrees)
      throw(const NMM::SerializedException&);

    virtual void blur(const nmm_double& radius = 1, const nmm_double& sigma = 0.5)
      throw(const NMM::SerializedException&);

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

    virtual void channel(const string& layer)
      throw(const NMM::SerializedException&);

    virtual void charcoal(const nmm_double& radius = 1, const nmm_double& sigma = 0.5)
      throw(const NMM::SerializedException&);

    virtual void chop(const string& geometry)
      throw(const NMM::SerializedException&);

    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)
      throw(const NMM::SerializedException&);

    virtual void comment(const string& comment)
      throw(const NMM::SerializedException&);

    virtual void contrast(const nmm_uint32& sharpen)
      throw(const NMM::SerializedException&);

    virtual void crop(const string& geometry)
      throw(const NMM::SerializedException&);

    virtual void cycleColormap(const nmm_int32& amount)
      throw(const NMM::SerializedException&);

    virtual void despeckle()
      throw(const NMM::SerializedException&);

    virtual void edge(const nmm_uint32& radius = 0.0)
      throw(const NMM::SerializedException&);

    virtual void emboss(const nmm_double& radius = 1, const nmm_double& sigma = 0.5)
      throw(const NMM::SerializedException&);

    virtual void enhance()
      throw(const NMM::SerializedException&);

    virtual void equalize()
      throw(const NMM::SerializedException&);

    virtual void erase()
      throw(const NMM::SerializedException&);

    virtual void flip()
      throw(const NMM::SerializedException&);

    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)
      throw(const NMM::SerializedException&);

    virtual void floodFillOpacity(const nmm_int64& x, const nmm_int64& y, const nmm_uint32& opacity, const string& method)
      throw(const NMM::SerializedException&);

    virtual void flop()
      throw(const NMM::SerializedException&);

    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)
      throw(const NMM::SerializedException&);

    virtual void gamma(const nmm_double& gamma_red, const nmm_double& gamma_green, const nmm_double& gamma_blue)
      throw(const NMM::SerializedException&);

    virtual void gaussianBlur(const nmm_double& width, const nmm_double& sigma)
      throw(const NMM::SerializedException&);

    virtual void implode(const nmm_double& factor)
      throw(const NMM::SerializedException&);

    virtual void label(const string& name)
      throw(const NMM::SerializedException&);

    virtual void magnify()
      throw(const NMM::SerializedException&);

    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)
      throw(const NMM::SerializedException&);

    virtual void medianFilter(const nmm_double& radius = 0.0)
      throw(const NMM::SerializedException&);

    virtual void minify()
      throw(const NMM::SerializedException&);

    virtual void modulate(const nmm_double& brightness, const nmm_double& saturation, const nmm_double& hue)
      throw(const NMM::SerializedException&);

    virtual void negate()
      throw(const NMM::SerializedException&);

    virtual void normalize()
      throw(const NMM::SerializedException&);

    virtual void oilPaint(const nmm_uint32& radius = 3)
      throw(const NMM::SerializedException&);

    virtual void opacity(const nmm_uint32& opacity)
      throw(const NMM::SerializedException&);

    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)
      throw(const NMM::SerializedException&);

    virtual void quantize(const nmm_bool& measureError = false)
      throw(const NMM::SerializedException&);

    virtual void raise(const string& geometry, const nmm_bool& raisedFlag = false)
      throw(const NMM::SerializedException&);

    virtual void reduceNoise(const nmm_uint32& order)
      throw(const NMM::SerializedException&);

    virtual void roll(const nmm_int32& columns, const nmm_int32& rows)
      throw(const NMM::SerializedException&);

    virtual void rotate(const nmm_double& degrees)
      throw(const NMM::SerializedException&);

    virtual void sample(const string& geometry)
      throw(const NMM::SerializedException&);

    virtual void scale(const string& geometry)
      throw(const NMM::SerializedException&);

    virtual void segment(const nmm_double& cluster_threshold = 1.0, const nmm_double& smoothing_threshold = 1.5)
      throw(const NMM::SerializedException&);

    virtual void shade(const nmm_double& azimuth = 30, const nmm_double& elevation = 30, const nmm_bool& color_shading = false)
      throw(const NMM::SerializedException&);

    virtual void sharpen(const nmm_double& radius = 1, const nmm_double& sigma = 0.5)
      throw(const NMM::SerializedException&);

    virtual void shave(const string& geometry)
      throw(const NMM::SerializedException&);

    virtual void shear(const nmm_double& x_shear_angle, const nmm_double& y_shear_angle)
      throw(const NMM::SerializedException&);

    virtual void solarize(const nmm_double& factor = 50.0)
      throw(const NMM::SerializedException&);

    virtual void spread(const nmm_uint32& amount = 3)
      throw(const NMM::SerializedException&);

    virtual void swirl(const nmm_double& degrees)
      throw(const NMM::SerializedException&);

    virtual void threshold(const nmm_double& threshold)
      throw(const NMM::SerializedException&);

    virtual void transform(const string& image_geometry, const string& crop_geometry)
      throw(const NMM::SerializedException&);

    virtual void transparent(const nmm_double& color_r, const nmm_double& color_g, const nmm_double& color_b)
      throw(const NMM::SerializedException&);

    virtual void trim()
      throw(const NMM::SerializedException&);

    virtual void unsharpmask(const nmm_double& radius, const nmm_double& sigma, const nmm_double& amount, const nmm_double& threshold)
      throw(const NMM::SerializedException&);

    virtual void wave(const nmm_double& amplitude = 25.0, const nmm_double& wavelength = 150.0)
      throw(const NMM::SerializedException&);

    virtual void zoom(const string& geometry)
      throw(const NMM::SerializedException&);


  };

  typedef auto_ptr<IMagickManipulationNode> IMagickManipulationNode_var;




}

#include "nmm/nmm_suffix.hpp"

#endif
