/*
 * Copyright (c) 1999-2000, Eric Moon.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions, and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


// ValControl.h
// +++++ cortex integration 23aug99:
//       - way too many protected members
//       - config'able font
//       - implement GetPreferredSize() (should work before the view is attached
//         to a window -- doable?)
//       - keyboard entry (pop-up text field)
//       - 'spin' mode: value changes based on vertical distance of pointer
//         (configurable; set buttons/modifiers to activate either mode?)
//
//       - should parameter binding happen at this level?
//       +++++ how about a ValControlFactory?  give it a BParameter, get back a
//             ValControl subclass... +++++
//
// e.moon 16jan99
//
// ABSTRACT CLASS: ValControl
// An abstract base class for 'value controls' -- interface
// components that display a value that may be modified via
// click-drag.  Other editing methods (such as 'click, then
// type') may be supported by subclasses.
//
// IMPLEMENT
//   getValue() and setValue(), for raw (BParameter-style) value access
//   MessageReceived(), to handle:
//     M_SET_VALUE
//     M_GET_VALUE
//     M_OFFSET_VALUE		(May be sent by segments during mouse action,
//                       +++++ is a faster method needed?)
//
// NOTES
// The control view consists of:
//
// - One or more segments.  Each segment is individually
//   draggable.  Subclasses may mix segment types, or Add
//   and remove segments dynamically.
//
// - A manipulator region, to which subcontrols (such as 'spin
//   arrows') may be added.
//
// Views/segments may be aligned flush left or flush right.  The
// side towards which views are aligned may be referred to as
// the 'anchor' side.
//
// Quickie interface guidelines:
//
// - Value controls are always underlined, indicating that the
//   value is editable.  (+++++ possible extension: dotted-underline
//   for continuous variation, and solid for discrete/step variation)
//
// - When a value control's 'click action' is to pop down a menu of
//   available choices (or pop up any sort of non-typable display)
//   this should be indicated by a small right triangle in the
//   manipulator area.
//   +++++ this may need some clarification; pop-down sliders, for example?
//
// * HISTORY
//   e.moon		19sep99		Cleanup
//   e.moon		23aug99		begun Cortex integration
//   e.moon		17jan99		started
#ifndef VAL_CONTROL_H
#define VAL_CONTROL_H


#include "cortex_defs.h"

#include "ValCtrlLayoutEntry.h"

#include <Bitmap.h>
#include <Control.h>
#include <Font.h>
#include <Message.h>
#include <View.h>

#include <vector>

__BEGIN_CORTEX_NAMESPACE

class ValControlSegment;


/* abstract */
class ValControl : public BControl {
	public:
		typedef BControl _Inherited;

	public:													// types & constants
		// child-view alignment options:
		enum align_mode {
			ALIGN_FLUSH_LEFT,
			ALIGN_FLUSH_RIGHT
		};
	
		// alignment flags +++++ 23aug99: not implemented -- should they be?
		enum align_flags {
			ALIGN_NONE = 0,
			ALIGN_GROW = 1
		};
	
		// should value update messages be sent asynchronously (during
		// a mouse operation) or synchronously (after the mouse is
		// released)?
		enum update_mode {
			UPDATE_ASYNC,
			UPDATE_SYNC
		};
	
		enum entry_location {
			LEFT_MOST = 0,
			FROM_LEFT = 0,
			RIGHT_MOST = 1,
			FROM_RIGHT = 1
		};

		// layout system state +++++

	public:													// types

	public:	// messages (all ValControl-related messages go here!)
		enum message_t {

			// Set value of a control or segment:
			// [your value field(s)] or "_value" (string)
			M_SET_VALUE					= ValControl_message_base,

			// Request for value of control/segment:		
			// [your value field(s)]
			M_GET_VALUE,

			// ... reply to M_GET_VALUE with this:
			// [your value field(s)]
			M_VALUE
		};

	public: // hooks
	
		// * parameter-mode value access

		// called to set the control's value from raw BParameter data
		virtual void setValue(const void* data, size_t size) = 0;

		// called to request the control's value in raw form
		virtual void getValue(void* data, size_t* ioSize) = 0;

		// * string value access

		virtual status_t setValueFrom(const char* text) = 0;

		virtual status_t getString(BString& buffer) = 0;

		// called when a child view's preferred size has changed;
		// it's up to the ValControl to grant the resize request.
		// Return true to notify the child that the request has
		// been granted, or false if denied (the default.)

		virtual bool childResizeRequest(BView* child) { return false; }

	public:													// ctor/dtor/accessors
		virtual ~ValControl();
	
		// value-access methods are left up to the subclasses,
		//   since they'll take varying types of arguments.
		//  (M_SET_VALUE and M_GET_VALUE should always behave
		//   as you'd expect, with a 'value' field of the appropriate
		//   type replacing or returning the current value.) +++++ decrepit
		//
		// Note that all implementations offering pop-up keyboard entry
		// must accept an M_SET_VALUE with a value of B_STRING_TYPE.

		// get/set update mode (determines whether value updates are
		// sent to the target during mouse operations, or only on
		// mouse-up)
		update_mode updateMode() const;
		void setUpdateMode(update_mode mode);

		// +++++ get/set font used by segments
		// (would separate 'value' and 'label' fonts be a good move?)
		//	const BFont* font() const;

		const BFont* labelFont() const; //nyi
		void setLabelFont(const BFont* labelFont); //nyi

		const BFont* valueFont() const; //nyi
		void setValueFont(const BFont* valueFont); //nyi

		// get baseline y offset: this is measured relative to the top of the
		// view
		float baselineOffset() const;

		// segment padding: this amount of padding is added to the
		// right of each segment bounds-rectangle
		float segmentPadding() const;

		// fast drag rate: returns ratio of pixels:units for fast
		// (left-button) dragging
		float fastDragRate() const; //nyi

		// slow drag rate: returns ratio for precise (both/middle-button)
		// dragging
		float slowDragRate() const; //nyi

		// fetch back-buffer
		BView* backBufferView() const; //nyi
		BBitmap* backBuffer() const; //nyi

		// pop up keyboard input field
		// +++++ should this turn into a message?
		virtual void showEditField();

	public: // debugging [23aug99]
		virtual void dump();

	public: // BControl impl.
		// SetValue(), Value() aren't defined, since they only support
		//   32-bit integer values.  TextControl provides a precedent for
		//   this kind of naughtiness.

		// empty implementation (hands off to BControl)
		virtual void SetEnabled(bool enabled);

	public: // BView impl.

		// handle initial layout stuff:
		virtual void AttachedToWindow();
		virtual void AllAttached();

		// paint decorations (& decimal point)
		virtual void Draw(BRect updateRect);

		virtual void drawDecimalPoint(ValCtrlLayoutEntry& entry);

		// handle frame resize (grow backbuffer if need be)
		virtual void FrameResized(float width, float height);

		// calculate minimum size
		virtual void GetPreferredSize(float* outWidth, float* outHeight);
		
		virtual void MakeFocus(bool focused = true);
		
		virtual void MouseDown(BPoint where);

	public:
		virtual void MessageReceived(BMessage* message);

	public:						// archiving/instantiation
		ValControl(BMessage* archive);

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

	protected: // internal ctor/operations
		ValControl(BRect frame, const char* name, const char* label, 
			BMessage* message, align_mode alignMode, align_flags alignFlags,
			update_mode updateMode = UPDATE_ASYNC, bool backBuffer = true);

		// Add segment view (which is responsible for generating its
		// own ValCtrlLayoutEntry)
		void _Add(ValControlSegment* segment, entry_location from,
			uint16 distance = 0);

		// Add general view (manipulator, label, etc.)
		// (the entry's frame rectangle will be filled in)
		// covers ValCtrlLayoutEntry ctor:
		void _Add(ValCtrlLayoutEntry& entry, entry_location from);

		// access child-view ValCtrlLayoutEntry
		// (_IndexOf returns index from left)
		const ValCtrlLayoutEntry& _EntryAt(uint16 offset) const;

		const ValCtrlLayoutEntry& _EntryAt(entry_location from,
			uint16 distance = 0) const;

		uint16 _IndexOf(BView* child) const;

		uint16 CountEntries() const;

	private: // steaming entrails
		// (re-)initialize the backbuffer
		void _AllocBackBuffer(float width, float height);

		// insert a layout entry in ordered position (doesn't call
		// AddChild())
		void _InsertEntry(ValCtrlLayoutEntry& entry, uint16 index);

		// move given entry horizontally (update child view's position
		// and size as well, if any)
		void _SlideEntry(int index, float delta);
	
		// turn entry_location/offset into an index:
		uint16 _LocationToIndex(entry_location from, uint16 distance = 0) const;

		void _GetDefaultEntrySize(ValCtrlLayoutEntry::entry_type type,
			float* outWidth, float* outHeight);

		void _InvalidateAll();
	
	private:
		// the set of visible segments and other child views,
		// in left-to-right. top-to-bottom order
		typedef std::vector<ValCtrlLayoutEntry>		layout_set;
		layout_set			fLayoutSet;

		// true if value has been changed since last request
		// (allows caching of value)
		bool				fDirty;

		// when should messages be sent to the target?
		update_mode			fUpdateMode;

		BFont				fLabelFont;
		BFont				fValueFont;

		align_mode			fAlignMode;
		align_flags			fAlignFlags;

		// the bounds rectangle requested upon construction.
		// if the ALIGN_GROW flag is set, the real bounds
		// rectangle may be wider
		BRect				fOrigBounds;

		// backbuffer (made available to segments for flicker-free
		// drawing)
		bool				fHaveBackBuffer;
		BBitmap*			fBackBuffer;
		BView*				fBackBufferView;

		static const float	fSegmentPadding;

		static const float	fDecimalPointWidth;
		static const float	fDecimalPointHeight;

	private:
		class fnInitChild;
};

__END_CORTEX_NAMESPACE
#endif	// VAL_CONTROL_H