/*
 * Copyright 2008-2015, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */
#ifndef _CHANNEL_CONTROL_H
#define _CHANNEL_CONTROL_H


//! BChannelControl is the base class for controls that have several
// independent values, with minima and maxima.

#include <Control.h>
#include <String.h>


class BChannelControl : public BControl {
public:
                                                                BChannelControl(BRect frame, const char* name,
                                                                        const char* label, BMessage* model,
                                                                        int32 channelCount = 1,
                                                                        uint32 resizingMode = B_FOLLOW_LEFT_TOP,
                                                                        uint32 flags = B_WILL_DRAW);
                                                                BChannelControl(const char* name,
                                                                        const char* label, BMessage* model,
                                                                        int32 channelCount = 1,
                                                                        uint32 flags = B_WILL_DRAW);
                                                                BChannelControl(BMessage* archive);
        virtual                                         ~BChannelControl();

        virtual status_t                        Archive(BMessage* data, bool deep = true) const;

        virtual void                            Draw(BRect updateRect) = 0;
        virtual void                            MouseDown(BPoint where) = 0;
        virtual void                            KeyDown(const char* bytes, int32 numBytes) = 0;

        virtual void                            FrameResized(float newWidth, float newHeight);
        virtual void                            SetFont(const BFont* font,
                                                                        uint32 mask = B_FONT_ALL);

        virtual void                            AttachedToWindow();
        virtual void                            DetachedFromWindow();
        virtual void                            ResizeToPreferred();
        virtual void                            GetPreferredSize(float* width,
                                                                        float* height) = 0;

        virtual void                            MessageReceived(BMessage* message);

        virtual BHandler*                       ResolveSpecifier(BMessage* message, int32 index,
                                                                        BMessage* specifier, int32 what,
                                                                        const char* property);
        virtual status_t                        GetSupportedSuites(BMessage* data);

        virtual void                            SetModificationMessage(BMessage* message);
                        BMessage*                       ModificationMessage() const;

        virtual status_t                        Invoke(BMessage* message = NULL);

        //! These methods are similar to Invoke() Invoke() and InvokeNotify(), but
        // include additional information about all of the channels in the control.
        virtual status_t                        InvokeChannel(BMessage* message = NULL,
                                                                        int32 fromChannel = 0,
                                                                        int32 channelCount = -1,
                                                                        const bool* _mask = NULL);
                        status_t                        InvokeNotifyChannel(BMessage* message = NULL,
                                                                        uint32 kind = B_CONTROL_INVOKED,
                                                                        int32 fromChannel = 0,
                                                                        int32 channelCount = -1,
                                                                        const bool* _mask = NULL);

        virtual void                            SetValue(int32 value);
                // SetCurrentChannel() determines which channel
        virtual status_t                        SetCurrentChannel(int32 index);
                        int32                           CurrentChannel() const;

        virtual int32                           CountChannels() const;
        virtual int32                           MaxChannelCount() const = 0;
        virtual status_t                        SetChannelCount(int32 count);
                        int32                           ValueFor(int32 channel) const;
        virtual int32                           GetValue(int32* _values, int32 fromChannel,
                                                                        int32 channelCount) const;
                        status_t                        SetValueFor(int32 channel, int32 value);
        virtual status_t                        SetValue(int32 fromChannel, int32 channelCount,
                                                                        const int32* values);
                        status_t                        SetAllValue(int32 values);
                        status_t                        SetLimitsFor(int32 channel, int32 minimum,
                                                                        int32 maximum);
                        status_t                        GetLimitsFor(int32 channel, int32* _minimum,
                                                                        int32* _maximum) const ;
        virtual status_t                        SetLimitsFor(int32 fromChannel,
                                                                        int32 channelCount, const int32* minima,
                                                                        const int32* maxima);
        virtual status_t                        GetLimitsFor(int32 fromChannel,
                                                                        int32 channelCount, int32* minima,
                                                                        int32* maxima) const;
                        status_t                        SetLimits(int32 minimum, int32 maximum);
                        status_t                        GetLimits(int32* _minimum,
                                                                        int32* _maximum) const;

        virtual bool                            SupportsIndividualLimits() const = 0;
        virtual status_t                        SetLimitLabels(const char* minLabel,
                                                                        const char* maxLabel);
                        const char*             MinLimitLabel() const;
                        const char*             MaxLimitLabel() const;
        virtual status_t                        SetLimitLabelsFor(int32 channel,
                                                                        const char* minLabel, const char* maxLabel);
        virtual status_t                        SetLimitLabelsFor(int32 fromChannel,
                                                                        int32 channelCount, const char* minLabel,
                                                                        const char* maxLabel);
                        const char*                     MinLimitLabelFor(int32 channel) const;
                        const char*                     MaxLimitLabelFor(int32 channel) const;
private:
        // Forbidden (and unimplemented)
                                                                BChannelControl(const BChannelControl& other);
                        BChannelControl&        operator=(const BChannelControl& other);

        virtual void                            _Reserverd_ChannelControl_0(void*, ...);
        virtual void                            _Reserverd_ChannelControl_1(void*, ...);
        virtual void                            _Reserverd_ChannelControl_2(void*, ...);
        virtual void                            _Reserverd_ChannelControl_3(void*, ...);
        virtual void                            _Reserverd_ChannelControl_4(void*, ...);
        virtual void                            _Reserverd_ChannelControl_5(void*, ...);
        virtual void                            _Reserverd_ChannelControl_6(void*, ...);
        virtual void                            _Reserverd_ChannelControl_7(void*, ...);
        virtual void                            _Reserverd_ChannelControl_8(void*, ...);
        virtual void                            _Reserverd_ChannelControl_9(void*, ...);
        virtual void                            _Reserverd_ChannelControl_10(void*, ...);
        virtual void                            _Reserverd_ChannelControl_11(void*, ...);

protected:
        inline  int32* const&           MinLimitList() const;
        inline  int32* const&           MaxLimitList() const;
        inline  int32* const&           ValueList() const;

private:
                        int32                           fChannelCount;
                        int32                           fCurrentChannel;
                        int32*                          fChannelMin;
                        int32*                          fChannelMax;
                        int32*                          fChannelValues;

                        BString                         fMinLabel;
                        BString                         fMaxLabel;

                        void*                           fMultiLabels;

                        BMessage*                       fModificationMsg;

                        uint32                          _reserved_[15];

                        status_t                        StuffValues(int32 fromChannel,
                                                                        int32 channelCount, const int32* values);
};


inline int32* const&
BChannelControl::MinLimitList() const
{
        return fChannelMin;
}


inline int32* const&
BChannelControl::MaxLimitList() const
{
        return fChannelMax;
}


inline int32* const&
BChannelControl::ValueList() const
{
        return fChannelValues;
}


#endif // _CHANNEL_CONTROL_H