/* 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_IVISCACamera_HPP
#define NMM_IVISCACamera_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 IVISCACamera : virtual public NMM::Interface { 
  public:
    IVISCACamera() : NMM::Interface(IVISCACamera::IVISCACamera_type, "NMM") { };

    IVISCACamera(NMM::NMMObject& parent) : NMM::Interface (parent, IVISCACamera::IVISCACamera_type, "NMM") { };

    virtual ~IVISCACamera() {};

    static const char* IVISCACamera_type;

    virtual  string getInterfaceType() const { return IVISCACamera_type; }

    NMM::Interface* copy() const { return new IVISCACamera(*this); }
    static void used(); 
    static const char* IF_Clear_event;
    static const char* AddressSet_event;
    static const char* getNumberOfCameras_event;
    static const char* CommandCancel_event;
    static const char* PowerOn_event;
    static const char* PowerOff_event;
    static const char* AutoPowerOff_event;
    static const char* ZoomStop_event;
    static const char* ZoomTeleStd_event;
    static const char* ZoomWideStd_event;
    static const char* ZoomTeleVar_event;
    static const char* ZoomWideVar_event;
    static const char* ZoomDirect_event;
    static const char* ZoomDigitalZoomOnOff_event;
    static const char* FocusStop_event;
    static const char* FocusFarStd_event;
    static const char* FocusNearStd_event;
    static const char* FocusFarVar_event;
    static const char* FocusNearVar_event;
    static const char* FocusDirect_event;
    static const char* FocusAutoFocus_event;
    static const char* FocusManualFocus_event;
    static const char* FocusAutoManual_event;
    static const char* FocusOnePushTrigger_event;
    static const char* FocusInfinity_event;
    static const char* FocusAFSensHigh_event;
    static const char* FocusAFSensLow_event;
    static const char* FocusNearLimit_event;
    static const char* WhiteBalance_event;
    static const char* WhiteBalanceAuto_event;
    static const char* WhiteBalanceIndoor_event;
    static const char* WhiteBalanceOutdoor_event;
    static const char* WhiteBalanceOnePush_event;
    static const char* WhiteBalanceAT_event;
    static const char* WhiteBalanceManual_event;
    static const char* WhiteBalanceOnePushTrigger_event;
    static const char* RGainReset_event;
    static const char* RGainUp_event;
    static const char* RGainDown_event;
    static const char* RGainDirect_event;
    static const char* BGainReset_event;
    static const char* BGainUp_event;
    static const char* BGainDown_event;
    static const char* BGainDirect_event;
    static const char* AutomaticExposureFull_event;
    static const char* AutomaticExposureManual_event;
    static const char* AutomaticExposureShutterPriority_event;
    static const char* AutomaticExposureIrisPriority_event;
    static const char* AutomaticExposureGainPriority_event;
    static const char* AutomaticExposureBright_event;
    static const char* AutomaticExposureShutterAuto_event;
    static const char* AutomaticExposureIrisAuto_event;
    static const char* AutomaticExposureGainAuto_event;
    static const char* SlowShutter_event;
    static const char* ShutterReset_event;
    static const char* ShutterUp_event;
    static const char* ShutterDown_event;
    static const char* ShutterDirect_event;
    static const char* IrisReset_event;
    static const char* IrisUp_event;
    static const char* IrisDown_event;
    static const char* IrisDirect_event;
    static const char* GainReset_event;
    static const char* GainUp_event;
    static const char* GainDown_event;
    static const char* GainDirect_event;
    static const char* BrightReset_event;
    static const char* BrightUp_event;
    static const char* BrightDown_event;
    static const char* BrightDirect_event;
    static const char* ExposureCompensationOnOff_event;
    static const char* ExposureCompensationReset_event;
    static const char* ExposureCompensationUp_event;
    static const char* ExposureCompensationDown_event;
    static const char* ExposureCompensationDirect_event;
    static const char* BackLightOnOff_event;
    static const char* ApertureReset_event;
    static const char* ApertureUp_event;
    static const char* ApertureDown_event;
    static const char* ApertureDirect_event;
    static const char* WideModeOff_event;
    static const char* WideModeCinema_event;
    static const char* WideMode16to9Full_event;
    static const char* LR_Reverse_event;
    static const char* Freeze_event;
    static const char* PictureEffectOff_event;
    static const char* PictureEffectPastel_event;
    static const char* PictureEffectNegArt_event;
    static const char* PictureEffectSepia_event;
    static const char* PictureEffectBW_event;
    static const char* PictureEffectSolarize_event;
    static const char* PictureEffectMosaic_event;
    static const char* PictureEffectSlim_event;
    static const char* PictureEffectStretch_event;
    static const char* DigitalEffectOff_event;
    static const char* DigitalEffectStill_event;
    static const char* DigitalEffectFlash_event;
    static const char* DigitalEffectLumi_event;
    static const char* DigitalEffectTrail_event;
    static const char* DigitalEffectLevel_event;
    static const char* Memory_event;
    static const char* MemoryReset_event;
    static const char* MemorySet_event;
    static const char* MemoryRecall_event;
    static const char* DataScreenOnOff_event;
    static const char* IRReceiveOnOff_event;
    static const char* IRReceiveReturn_event;
    static const char* PanTiltDriveMotion_event;
    static const char* PanTiltDriveUp_event;
    static const char* PanTiltDriveDown_event;
    static const char* PanTiltDriveLeft_event;
    static const char* PanTiltDriveRight_event;
    static const char* PanTiltDriveUpLeft_event;
    static const char* PanTiltDriveUpRight_event;
    static const char* PanTiltDriveDownLeft_event;
    static const char* PanTiltDriveDownRight_event;
    static const char* PanTiltDriveStop_event;
    static const char* PanTiltDrivePosition_event;
    static const char* PanTiltDriveAbsolute_event;
    static const char* PanTiltDriveRelative_event;
    static const char* PanTiltDriveAbsoluteDeg_event;
    static const char* PanTiltDriveRelativeDeg_event;
    static const char* PanTiltDriveHome_event;
    static const char* PanTiltDriveReset_event;
    static const char* PanTiltLimitSet_event;
    static const char* PanTiltLimitClear_event;
    static const char* PowerInq_event;
    static const char* AutoPowerOffInq_event;
    static const char* DZoomModeInq_event;
    static const char* ZoomPosInq_event;
    static const char* FocusModeInq_event;
    static const char* FocusPosInq_event;
    static const char* AFModeInq_event;
    static const char* FocusNearLimitInq_event;
    static const char* WhiteBalanceModeInq_event;
    static const char* RGainInq_event;
    static const char* BGainInq_event;
    static const char* AutoExposureModeInq_event;
    static const char* SlowShutterModeInq_event;
    static const char* ShutterPosInq_event;
    static const char* IrisPosInq_event;
    static const char* GainPosInq_event;
    static const char* BrightPosInq_event;
    static const char* ExposureCompensationModeInq_event;
    static const char* ExposureCompensationPosInq_event;
    static const char* BackLightModeInq_event;
    static const char* ApertureInq_event;
    static const char* WideModeInq_event;
    static const char* LR_ReverseModeInq_event;
    static const char* FreezeModeInq_event;
    static const char* PictureEffectModeInq_event;
    static const char* DigitalEffectModeInq_event;
    static const char* DigitalEffectLevelInq_event;
    static const char* MemoryInq_event;
    static const char* DatascreenInq_event;
    static const char* PanTiltModeInq_event;
    static const char* PanTiltMaxSpeedInq_event;
    static const char* PanTiltPosInq_event;
    static const char* VideoSystemInq_event;
    static const char* DeviceTypeInq_event;
    static const char* verbose_event;
    static const char* islocked_event;
    /**
     * IF_Clear 
     * 
     * Clears the command buffers in the camera and 
     * cancels the command currently beeing executed.
     *
     * this function will be called automaticly by the init
     * function 
     *
     * input  : the number of the camera [1;7,8]
     *          camera_id 8 means broadcast, all 
     *          cameras will clear their command
     *          buffers
     * output : SUCCESS when success, else FAILURE
     */

    virtual Result IF_Clear(const nmm_uchar& value)
      throw(const NMM::SerializedException&);
    /**
     * AddressSet
     *
     * Scan all cameras connected to the VISCA-bus 
     * and dispatch one VISCA-address for each camera found.
     *
     * This function will be called automaticly by the 
     * init function
     *
     * input  : none
     * output : SUCCESS when success, else FAILURE
     */

    virtual Result AddressSet()
      throw(const NMM::SerializedException&);
    /**
     * getNumberOfCameras
     *
     * Returns the number of cameras connected to the VISCA-bus
     *
     * input  : none
     * output : number of cameras found
     */

    virtual Result getNumberOfCameras(nmm_uchar& value)
      throw(const NMM::SerializedException&);
    /**
     * CommandCancel
     * 
     * Cancel the command currently executed by the camera
     * with the address <camera identificator> and the socket
     * number <socket id>.
     *
     * input  : camera identificator and socket id
     * output : SUCCESS, if the command is canceled
     *          FAILURE, if not
     */

    virtual Result CommandCancel(const nmm_uchar& value1, const nmm_uchar& value2)
      throw(const NMM::SerializedException&);
    /**
     * Power functions
     *
     * The following functions controlls the powerstate 
     * of the cameras. Each camera can be controlled seperatly,
     * selectecd by the <camera id>. The AutoPowerOff-function sets 
     * the timer after the camera goes in standby-mode, when no 
     * VISCA-cammand arrived 
     *
     * input  : camera id
     * output : SUCCESS if success, else FAILURE
     */

    virtual Result PowerOn(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result PowerOff(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result AutoPowerOff(const nmm_uchar& value1, const nmm_int32& value2)
      throw(const NMM::SerializedException&);
    /**
     * Zoom functions
     *
     * The following functions controls the zoom of the camera. 
     * All that functions expect the <camera_id> as parameter.
     * Some of them allow additional speed settings 
     *
     * - The Range for the Zoom:
     *   optical zoom : [    0;16384]
     *   digital zoom : [16384;28672]
     * - ZoomDZoom(On|Off) turn the DigitalZoom On or Off.
     */

    virtual Result ZoomStop(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result ZoomTeleStd(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result ZoomWideStd(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result ZoomTeleVar(const nmm_uchar& value1, const nmm_uchar& value2)
      throw(const NMM::SerializedException&);

    virtual Result ZoomWideVar(const nmm_uchar& value1, const nmm_uchar& value2)
      throw(const NMM::SerializedException&);

    virtual Result ZoomDirect(const nmm_uchar& value1, const nmm_int32& value2)
      throw(const NMM::SerializedException&);

    virtual Result ZoomDigitalZoomOnOff(const nmm_uchar& value1, const nmm_bool& value2)
      throw(const NMM::SerializedException&);
    /**
     * Focus functions
     * 
     * the Focus* functions are controling the settings of te
     * camera's focus. All functions expect the <camera_id> 
     * as first parameter, some an additional parameter
     */

    virtual Result FocusStop(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result FocusFarStd(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result FocusNearStd(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result FocusFarVar(const nmm_uchar& value1, const nmm_uchar& value2)
      throw(const NMM::SerializedException&);

    virtual Result FocusNearVar(const nmm_uchar& value1, const nmm_uchar& value2)
      throw(const NMM::SerializedException&);

    virtual Result FocusDirect(const nmm_uchar& value1, const nmm_uint16& value2)
      throw(const NMM::SerializedException&);

    virtual Result FocusAutoFocus(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result FocusManualFocus(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result FocusAutoManual(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result FocusOnePushTrigger(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result FocusInfinity(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result FocusAFSensHigh(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result FocusAFSensLow(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result FocusNearLimit(const nmm_uchar& value1, const nmm_uint16& value2)
      throw(const NMM::SerializedException&);
    /**
     * WhiteBalance
     */

    virtual Result WhiteBalance(const nmm_uchar& value1, const nmm_uchar& value2, const nmm_uchar& value3)
      throw(const NMM::SerializedException&);

    virtual Result WhiteBalanceAuto(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result WhiteBalanceIndoor(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result WhiteBalanceOutdoor(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result WhiteBalanceOnePush(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result WhiteBalanceAT(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result WhiteBalanceManual(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result WhiteBalanceOnePushTrigger(const nmm_uchar& value)
      throw(const NMM::SerializedException&);
    /**
     * RGain
     */

    virtual Result RGainReset(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result RGainUp(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result RGainDown(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result RGainDirect(const nmm_uchar& value1, const nmm_uint16& value2)
      throw(const NMM::SerializedException&);
    /**
     * BGain
     */

    virtual Result BGainReset(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result BGainUp(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result BGainDown(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result BGainDirect(const nmm_uchar& value1, const nmm_uint16& value2)
      throw(const NMM::SerializedException&);
    /**
     * Automatic Exposure 
     */

    virtual Result AutomaticExposureFull(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result AutomaticExposureManual(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result AutomaticExposureShutterPriority(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result AutomaticExposureIrisPriority(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result AutomaticExposureGainPriority(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result AutomaticExposureBright(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result AutomaticExposureShutterAuto(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result AutomaticExposureIrisAuto(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result AutomaticExposureGainAuto(const nmm_uchar& value)
      throw(const NMM::SerializedException&);
    /**
     * Slow Shutter
     */

    virtual Result SlowShutter(const nmm_uchar& value1, const nmm_bool& value2)
      throw(const NMM::SerializedException&);
    /**
     * Shutter
     */

    virtual Result ShutterReset(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result ShutterUp(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result ShutterDown(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result ShutterDirect(const nmm_uchar& value1, const nmm_uint16& value2)
      throw(const NMM::SerializedException&);
    /**
     * Iris
     */

    virtual Result IrisReset(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result IrisUp(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result IrisDown(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result IrisDirect(const nmm_uchar& value1, const nmm_uint16& value2)
      throw(const NMM::SerializedException&);
    /**
     * Gain
     */

    virtual Result GainReset(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result GainUp(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result GainDown(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result GainDirect(const nmm_uchar& value1, const nmm_uint16& value2)
      throw(const NMM::SerializedException&);
    /**
     * Bright
     */

    virtual Result BrightReset(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result BrightUp(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result BrightDown(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result BrightDirect(const nmm_uchar& value1, const nmm_uint16& value2)
      throw(const NMM::SerializedException&);
    /**
     * Exposure Compensation
     */

    virtual Result ExposureCompensationOnOff(const nmm_uchar& value1, const nmm_bool& value2)
      throw(const NMM::SerializedException&);

    virtual Result ExposureCompensationReset(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result ExposureCompensationUp(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result ExposureCompensationDown(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result ExposureCompensationDirect(const nmm_uchar& value1, const nmm_uint16& value2)
      throw(const NMM::SerializedException&);
    /** 
     * BackLight
     */

    virtual Result BackLightOnOff(const nmm_uchar& value1, const nmm_bool& value2)
      throw(const NMM::SerializedException&);
    /**
     * Aperture
     */

    virtual Result ApertureReset(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result ApertureUp(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result ApertureDown(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result ApertureDirect(const nmm_uchar& value1, const nmm_uint16& value2)
      throw(const NMM::SerializedException&);
    /**
     * Wide Mode
     */

    virtual Result WideModeOff(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result WideModeCinema(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result WideMode16to9Full(const nmm_uchar& value)
      throw(const NMM::SerializedException&);
    /**
     *  Mirror image on or off
     */

    virtual Result LR_Reverse(const nmm_uchar& value1, const nmm_bool& value2)
      throw(const NMM::SerializedException&);
    /**
     *  Freeze image on or off
     */

    virtual Result Freeze(const nmm_uchar& value1, const nmm_bool& value2)
      throw(const NMM::SerializedException&);
    /**
     * Picture Effects
     *
     * These functions allows to turn internal effects on or off. 
     * They expect as parameter the <camera_id>.
     */

    virtual Result PictureEffectOff(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result PictureEffectPastel(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result PictureEffectNegArt(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result PictureEffectSepia(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result PictureEffectBW(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result PictureEffectSolarize(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result PictureEffectMosaic(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result PictureEffectSlim(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result PictureEffectStretch(const nmm_uchar& value)
      throw(const NMM::SerializedException&);
    /**
     * Digital Effects
     *
     * These functions allows to turn internal digital effects 
     * on or off. They expect as parameter the <camera_id>.
     *
     * Please don't call DigitalEffect( in nmm_uchar value1, in nmm_uchar ), its a parent
     * functions for all the other effect functions  
     */

    virtual Result DigitalEffectOff(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result DigitalEffectStill(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result DigitalEffectFlash(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result DigitalEffectLumi(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result DigitalEffectTrail(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result DigitalEffectLevel(const nmm_uchar& value1, const nmm_uchar& value2, const nmm_uchar& value3)
      throw(const NMM::SerializedException&);
    /**
     * Memory (user defined presets)
     */

    virtual Result Memory(const nmm_uchar& value1, const nmm_uchar& value2, const nmm_uchar& value3)
      throw(const NMM::SerializedException&);

    virtual Result MemoryReset(const nmm_uchar& value1, const nmm_uchar& value2)
      throw(const NMM::SerializedException&);

    virtual Result MemorySet(const nmm_uchar& value1, const nmm_uchar& value2)
      throw(const NMM::SerializedException&);

    virtual Result MemoryRecall(const nmm_uchar& value1, const nmm_uchar& value2)
      throw(const NMM::SerializedException&);
    /**
     * DataScreen (OSD)
     */

    virtual Result DataScreenOnOff(const nmm_uchar& value1, const nmm_bool& value2)
      throw(const NMM::SerializedException&);
    /**
     * IR (remote controller)
     */

    virtual Result IRReceiveOnOff(const nmm_uchar& value1, const nmm_bool& value2)
      throw(const NMM::SerializedException&);

    virtual Result IRReceiveReturn(const nmm_uchar& value1, const nmm_bool& value2)
      throw(const NMM::SerializedException&);
    /** 
     * PanTiltDriveMotion
     *
     * input  : camera-identifier value1,
     *          motion x-direction, motion y-direction, 
     *          speed x-direction, speed y-direction
     * output : SUCCESS, if command send with success
     *          FAILURE, if an error occured
     * 
     * used for PanTiltDrive-motion functions
     */

    virtual Result PanTiltDriveMotion(const nmm_uchar& value1, const nmm_uchar& value2, const nmm_uchar& value3, const nmm_uchar& value4, const nmm_uchar& value5)
      throw(const NMM::SerializedException&);

    virtual Result PanTiltDriveUp(const nmm_uchar& value1, const nmm_uchar& value2, const nmm_uchar& value3)
      throw(const NMM::SerializedException&);

    virtual Result PanTiltDriveDown(const nmm_uchar& value1, const nmm_uchar& value2, const nmm_uchar& value3)
      throw(const NMM::SerializedException&);

    virtual Result PanTiltDriveLeft(const nmm_uchar& value1, const nmm_uchar& value2, const nmm_uchar& value3)
      throw(const NMM::SerializedException&);

    virtual Result PanTiltDriveRight(const nmm_uchar& value1, const nmm_uchar& value2, const nmm_uchar& value3)
      throw(const NMM::SerializedException&);

    virtual Result PanTiltDriveUpLeft(const nmm_uchar& value1, const nmm_uchar& value2, const nmm_uchar& value3)
      throw(const NMM::SerializedException&);

    virtual Result PanTiltDriveUpRight(const nmm_uchar& value1, const nmm_uchar& value2, const nmm_uchar& value3)
      throw(const NMM::SerializedException&);

    virtual Result PanTiltDriveDownLeft(const nmm_uchar& value1, const nmm_uchar& value2, const nmm_uchar& value3)
      throw(const NMM::SerializedException&);

    virtual Result PanTiltDriveDownRight(const nmm_uchar& value1, const nmm_uchar& value2, const nmm_uchar& value3)
      throw(const NMM::SerializedException&);

    virtual Result PanTiltDriveStop(const nmm_uchar& value1, const nmm_uchar& value2, const nmm_uchar& value3)
      throw(const NMM::SerializedException&);
    /** 
     * PanTiltDrivePosition
     *
     * input  : camera-identifier,
     *          position-mode (relative or absolute)
     *          motion x-direction in coordinates
     *          morion y-direction in coordinates
     *          speed x-direction, speed y-direction
     * output : SUCCESS, if command send with success
     *          FAILURE, if an error occured
     * 
     * used for PanTiltDrive-position functions
     */

    virtual Result PanTiltDrivePosition(const nmm_uchar& value1, const nmm_uchar& value2, const nmm_int32& value3, const nmm_int32& value4, const nmm_uchar& value5, const nmm_uchar& value6)
      throw(const NMM::SerializedException&);

    virtual Result PanTiltDriveAbsolute(const nmm_uchar& value1, const nmm_int32& value2, const nmm_int32& value3, const nmm_uchar& value4, const nmm_uchar& value5)
      throw(const NMM::SerializedException&);

    virtual Result PanTiltDriveRelative(const nmm_uchar& value1, const nmm_int32& value2, const nmm_int32& value3, const nmm_uchar& value4, const nmm_uchar& value5)
      throw(const NMM::SerializedException&);

    virtual Result PanTiltDriveAbsoluteDeg(const nmm_uchar& value1, const nmm_int32& value2, const nmm_int32& value3, const nmm_uchar& value4, const nmm_uchar& value5)
      throw(const NMM::SerializedException&);

    virtual Result PanTiltDriveRelativeDeg(const nmm_uchar& value1, const nmm_int32& value2, const nmm_int32& value3, const nmm_uchar& value4, const nmm_uchar& value5)
      throw(const NMM::SerializedException&);

    virtual Result PanTiltDriveHome(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result PanTiltDriveReset(const nmm_uchar& value)
      throw(const NMM::SerializedException&);

    virtual Result PanTiltLimitSet(const nmm_uchar& value1, const nmm_uchar& value2, const nmm_int32& value3, const nmm_int32& value4)
      throw(const NMM::SerializedException&);

    virtual Result PanTiltLimitClear(const nmm_uchar& value1, const nmm_uchar& value2)
      throw(const NMM::SerializedException&);
    /**
     * Inquiry Command List 
     */
    /**
     * PowerInq
     *
     * input : The camera ID
     * ouput : The status of the Camera
     *          true = On
     *          false =Off(Standby)
     */

    virtual Result PowerInq(const nmm_uchar& value1, nmm_bool& value2)
      throw(const NMM::SerializedException&);

    virtual Result AutoPowerOffInq(const nmm_uchar& value1, nmm_uint16& value2)
      throw(const NMM::SerializedException&);

    virtual Result DZoomModeInq(const nmm_uchar& value1, nmm_bool& value2)
      throw(const NMM::SerializedException&);

    virtual Result ZoomPosInq(const nmm_uchar& value1, nmm_uint16& value2)
      throw(const NMM::SerializedException&);

    virtual Result FocusModeInq(const nmm_uchar& value1, nmm_bool& value2)
      throw(const NMM::SerializedException&);

    virtual Result FocusPosInq(const nmm_uchar& value1, nmm_uint16& value2)
      throw(const NMM::SerializedException&);

    virtual Result AFModeInq(const nmm_uchar& value1, nmm_bool& value2)
      throw(const NMM::SerializedException&);

    virtual Result FocusNearLimitInq(const nmm_uchar& value1, nmm_uint16& value2)
      throw(const NMM::SerializedException&);

    virtual Result WhiteBalanceModeInq(const nmm_uchar& value1, nmm_uchar& value2)
      throw(const NMM::SerializedException&);

    virtual Result RGainInq(const nmm_uchar& value1, nmm_uchar& value2)
      throw(const NMM::SerializedException&);

    virtual Result BGainInq(const nmm_uchar& value1, nmm_uint16& value2)
      throw(const NMM::SerializedException&);

    virtual Result AutoExposureModeInq(const nmm_uchar& value1, nmm_uchar& value2)
      throw(const NMM::SerializedException&);

    virtual Result SlowShutterModeInq(const nmm_uchar& value1, nmm_bool& value2)
      throw(const NMM::SerializedException&);

    virtual Result ShutterPosInq(const nmm_uchar& value1, nmm_uint16& value2)
      throw(const NMM::SerializedException&);

    virtual Result IrisPosInq(const nmm_uchar& value1, nmm_uint16& value2)
      throw(const NMM::SerializedException&);

    virtual Result GainPosInq(const nmm_uchar& value1, nmm_uint16& value2)
      throw(const NMM::SerializedException&);

    virtual Result BrightPosInq(const nmm_uchar& value1, nmm_uint16& value2)
      throw(const NMM::SerializedException&);

    virtual Result ExposureCompensationModeInq(const nmm_uchar& value1, nmm_bool& value2)
      throw(const NMM::SerializedException&);

    virtual Result ExposureCompensationPosInq(const nmm_uchar& value1, nmm_uint16& value2)
      throw(const NMM::SerializedException&);

    virtual Result BackLightModeInq(const nmm_uchar& value1, nmm_bool& value2)
      throw(const NMM::SerializedException&);

    virtual Result ApertureInq(const nmm_uchar& value1, nmm_uint16& value2)
      throw(const NMM::SerializedException&);

    virtual Result WideModeInq(const nmm_uchar& value1, nmm_uchar& value2)
      throw(const NMM::SerializedException&);

    virtual Result LR_ReverseModeInq(const nmm_uchar& value1, nmm_bool& value2)
      throw(const NMM::SerializedException&);

    virtual Result FreezeModeInq(const nmm_uchar& value1, nmm_bool& value2)
      throw(const NMM::SerializedException&);

    virtual Result PictureEffectModeInq(const nmm_uchar& value1, nmm_uchar& value2)
      throw(const NMM::SerializedException&);

    virtual Result DigitalEffectModeInq(const nmm_uchar& value1, nmm_uchar& value2)
      throw(const NMM::SerializedException&);

    virtual Result DigitalEffectLevelInq(const nmm_uchar& value1, nmm_uchar& value2)
      throw(const NMM::SerializedException&);

    virtual Result MemoryInq(const nmm_uchar& value1, nmm_uchar& value2)
      throw(const NMM::SerializedException&);

    virtual Result DatascreenInq(const nmm_uchar& value1, nmm_bool& value2)
      throw(const NMM::SerializedException&);

    virtual Result PanTiltModeInq(const nmm_uchar& value1, nmm_uint16& value2)
      throw(const NMM::SerializedException&);

    virtual Result PanTiltMaxSpeedInq(const nmm_uchar& value1, nmm_uchar& value2, nmm_uchar& value3)
      throw(const NMM::SerializedException&);

    virtual Result PanTiltPosInq(const nmm_uchar& value1, nmm_int32& value2, nmm_int32& value3)
      throw(const NMM::SerializedException&);

    virtual Result VideoSystemInq(const nmm_uchar& value1, nmm_uchar& value2)
      throw(const NMM::SerializedException&);

    virtual Result DeviceTypeInq(const nmm_uchar& value1, nmm_uint16& value2, nmm_uint16& value3, nmm_uint16& value4, nmm_uchar& value5)
      throw(const NMM::SerializedException&);
    /**
     * misc stuff
     */

    virtual void verbose(const string& value1, const string& value2)
      throw(const NMM::SerializedException&);

    virtual nmm_bool islocked(const nmm_uchar& value)
      throw(const NMM::SerializedException&);


  };

  typedef auto_ptr<IVISCACamera> IVISCACamera_var;




}

#include "nmm/nmm_suffix.hpp"

#endif
