haiku.git

/*
 * 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.
 */


// ValControlDigitSegment.cpp

#include "ValControlDigitSegment.h"
#include "ValControl.h"

#include "NumericValControl.h"

#include <Debug.h>

#include <math.h>
#include <stdlib.h>
#include <cstdio>

__USE_CORTEX_NAMESPACE

// -------------------------------------------------------- //
// constants/static stuff
// -------------------------------------------------------- //

const float ValControlDigitSegment::s_widthTrim			= -2;

const BFont* ValControlDigitSegment::s_cachedFont 	= 0;
float ValControlDigitSegment::s_cachedDigitWidth 		= 0.0;

// -------------------------------------------------------- //
// ctor/dtor/accessors
// -------------------------------------------------------- //

ValControlDigitSegment::ValControlDigitSegment(
	uint16											digitCount,
	int16												scaleFactor,
	bool												negativeVisible,
	display_flags								flags) :

	ValControlSegment(SOLID_UNDERLINE),

	m_digitCount(digitCount),
	m_value(0),
	m_negative(false),
	m_scaleFactor(scaleFactor),
	m_font(0),
	m_yOffset(0.0),
	m_minusSignWidth(0.0),
	m_digitPadding(0.0),
	m_flags(flags),
	m_negativeVisible(negativeVisible) {}

ValControlDigitSegment::~ValControlDigitSegment() {}

uint16 ValControlDigitSegment::digitCount() const {
	return m_digitCount;
}

int16 ValControlDigitSegment::scaleFactor() const {
	return m_scaleFactor;
}

int64 ValControlDigitSegment::value() const {
	return m_value;
}

// -------------------------------------------------------- //
// operations
// -------------------------------------------------------- //

// revised setValue() 18sep99: now sets the
// value of the displayed digits ONLY.
//
// a tad simpler. the old setValue() is provided for giggles.
//
void ValControlDigitSegment::setValue(
	int64												value,
	bool												negative) {

	if(
		value == m_value &&
		m_negative == negative)
		return;

	m_value = value;
	m_negative = negative;
	Invalidate();
}

//// +++++
//void ValControlDigitSegment::setValue(double dfValue) {
//
//	printf("seg[%d]::setValue(%.12f)\n", m_digitCount, dfValue);
//
//	// convert possibly-negative value into absolute value and
//	// negative flag
//	bool m_bWasNegative = m_negative;
//	m_negative = (m_negativeVisible && dfValue < 0.0);
//	dfValue = fabs(dfValue);
//
//	// prepare to scale the value to fit the digits this segment
//	// represents
//	bool bMult = m_scaleFactor < 0;
//	int64 nLowPow = m_scaleFactor ? (int64)pow(10.0, abs(m_scaleFactor)) : 1;
//	int64 nHighPow = (int64)pow(10.0, m_digitCount);
//
////	printf("  lowPow %lld, highPow %lld\n", nLowPow, nHighPow);
//
//	double dfTemp = bMult ? dfValue * nLowPow : dfValue / nLowPow;
////	printf("  -> %.8lf\n", dfTemp);
//
//	int64 nLocal;
//	if(m_scaleFactor < 0) {
//		// really ugly rounding business: there must be a cleaner
//		// way to do this...
//		double dfC = ceil(dfTemp);
//		double dfCDelta = dfC-dfTemp;
//		double dfF = floor(dfTemp);
//		double dfFDelta = dfTemp - dfF;
//
//		nLocal = (int64)((dfCDelta < dfFDelta) ? dfC : dfF);
//	}
//	else
//		nLocal = (int64)dfTemp;
//
////	printf("  -> %lld\n", nLocal);
//	nLocal %= nHighPow;
////	printf("  -> %lld\n", nLocal);
//
//	if(nLocal != m_value || m_negative != m_bWasNegative) {
//		m_value = nLocal;
//		Invalidate();
//	}
//}

// -------------------------------------------------------- //
// ValControlSegment impl.
// -------------------------------------------------------- //

ValCtrlLayoutEntry ValControlDigitSegment::makeLayoutEntry() {
	return ValCtrlLayoutEntry(this, ValCtrlLayoutEntry::SEGMENT_ENTRY);
}

float ValControlDigitSegment::handleDragUpdate(
		float												distance) {

	int64 units = (int64)(distance / dragScaleFactor());
	float remaining = distance;

	if(units) {
		remaining = fmod(distance, dragScaleFactor());

		// +++++ echk [23aug99] -- is this the only way?
		NumericValControl* numericParent = dynamic_cast<NumericValControl*>(parent());
		ASSERT(numericParent);

		// adjust value for parent:
//		dfUnits = floor(dfUnits);
//		dfUnits *= pow(10.0, m_scaleFactor);
//
//		// ++++++ 17sep99
//		PRINT((
//			"offset: %.8f\n", dfUnits));
//
//		numericParent->offsetValue(dfUnits);

		numericParent->offsetSegmentValue(this, units);
	}

	// return 'unused pixels'
	return remaining;
}

void ValControlDigitSegment::mouseReleased() {
	// +++++
}

// -------------------------------------------------------- //
// BView impl.
// -------------------------------------------------------- //

void ValControlDigitSegment::Draw(BRect updateRect) {

//	PRINT((
//		"### ValControlDigitSegment::Draw()\n"));
//

	ASSERT(m_font);

	BBitmap* pBufferBitmap = parent()->backBuffer();
	BView* pView = pBufferBitmap ? parent()->backBufferView() : this;
	if(pBufferBitmap)
		pBufferBitmap->Lock();

//	rgb_color white = {255,255,255,255};
	rgb_color black = {0,0,0,255};
	rgb_color disabled = tint_color(black, B_LIGHTEN_2_TINT);
	rgb_color viewColor = ViewColor();

	// +++++

	BRect b = Bounds();
//	PRINT((
//		"# ValControlDigitSegment::Draw(%.1f,%.1f,%.1f,%.1f) %s\n"
//		"  frame(%.1f,%.1f,%.1f,%.1f)\n\n",
//		updateRect.left, updateRect.top, updateRect.right, updateRect.bottom,
//		pBufferBitmap ? "(BUFFERED)" : "(DIRECT)",
//		Frame().left, Frame().top, Frame().right, Frame().bottom));

	float digitWidth = MaxDigitWidth(m_font);
	BPoint p;
	p.x = b.right - digitWidth;
	p.y = m_yOffset;

//	// clear background
//	pView->SetHighColor(white);
//	pView->FillRect(b);

	// draw a digit at a time, right to left (low->high)
	pView->SetFont(m_font);
	if(parent()->IsEnabled()) {

		pView->SetHighColor(black);
	} else {

		pView->SetHighColor(disabled);
	}

	pView->SetLowColor(viewColor);
	int16 digit;
	int64 cur = abs(m_value);

	for(digit = 0;
		digit < m_digitCount;
		digit++, cur /= 10, p.x -= (digitWidth+m_digitPadding)) {

		uint8 digitValue = (uint8)(cur % 10);
		if(digit && !(m_flags & ZERO_FILL) && !cur)
			break;
		pView->DrawChar('0' + digitValue, p);
//		PRINT(("ch(%.1f,%.1f): %c\n", p.x, p.y, '0' + digitValue));
	}

	if(m_negative) {
		// draw minus sign
		p.x += (digitWidth-m_minusSignWidth);
		pView->DrawChar('-', p);
	}

	// paint buffer?
	if(pBufferBitmap) {
		pView->Sync();
		DrawBitmap(parent()->backBuffer(), b, b);
		pBufferBitmap->Unlock();
	}

	_inherited::Draw(updateRect);
}

// must have parent at this point +++++
void ValControlDigitSegment::GetPreferredSize(float* pWidth, float* pHeight) {

//	// font initialized?
//	if(!m_font) {
//		initFont();
//	}

	*pWidth = prefWidth();
	*pHeight = prefHeight();
}

// +++++ need a way to return an overlap amount?
//       -> underline should extend a pixel to the right.
float ValControlDigitSegment::prefWidth() const {
	ASSERT(m_font);

	float width = (m_digitCount*MaxDigitWidth(m_font)) +
		((m_digitCount - 1)*m_digitPadding);
	if(m_negativeVisible)
		width += (m_minusSignWidth + m_digitPadding);

	return width;
}

float ValControlDigitSegment::prefHeight() const {
	ASSERT(m_font);
	return m_fontHeight.ascent + m_fontHeight.descent + m_fontHeight.leading;
}

// do any font-related layout work
void ValControlDigitSegment::fontChanged(
	const BFont*								font) {
//	PRINT((
//		"* ValControlDigitSegment::fontChanged()\n"));

	m_font = font;

	m_font->GetHeight(&m_fontHeight);

	ASSERT(parent());
	m_yOffset = parent()->baselineOffset();
	char c = '-';
	m_minusSignWidth = m_font->StringWidth(&c, 1) + s_widthTrim;

	// space between digits should be the same as space between
	// segments, for consistent look:
	m_digitPadding = parent()->segmentPadding();
}

// -------------------------------------------------------- //
// BHandler impl.
// -------------------------------------------------------- //

void ValControlDigitSegment::MessageReceived(BMessage* pMsg) {

	double fVal;

	switch(pMsg->what) {

		case ValControl::M_SET_VALUE:
			pMsg->FindDouble("value", &fVal);
			setValue((int64)fVal, fVal < 0);
			break;

		case ValControl::M_GET_VALUE: {
			BMessage reply(ValControl::M_VALUE);
			reply.AddDouble("value", value());
			pMsg->SendReply(&reply);
			break;
		}
	}
}

// -------------------------------------------------------- //
// archiving/instantiation
// -------------------------------------------------------- //

ValControlDigitSegment::ValControlDigitSegment(BMessage* pArchive) :
	ValControlSegment(pArchive),
	m_font(0),
	m_digitPadding(0.0) {

	// #/digits
	status_t err __attribute__((unused)) = pArchive->FindInt16("digits", (int16*)&m_digitCount);
	ASSERT(err == B_OK);

	// current value
	err = pArchive->FindInt64("value", &m_value);
	ASSERT(err == B_OK);

	// scaling
	err = pArchive->FindInt16("scaleFactor", &m_scaleFactor);
	ASSERT(err == B_OK);
}

status_t ValControlDigitSegment::Archive(BMessage* pArchive, bool bDeep) const{
	_inherited::Archive(pArchive, bDeep);

	pArchive->AddInt16("digits", m_digitCount);
	pArchive->AddInt64("value", m_value);
	pArchive->AddInt16("scaleFactor", m_scaleFactor);

	return B_OK;
}

/* static */
BArchivable* ValControlDigitSegment::Instantiate(BMessage* pArchive) {
	if(validate_instantiation(pArchive, "ValControlDigitSegment"))
		return new ValControlDigitSegment(pArchive);
	else
		return 0;
}

// -------------------------------------------------------- //
// helpers
// -------------------------------------------------------- //

/*static*/
float ValControlDigitSegment::MaxDigitWidth(const BFont* pFont) {
	ASSERT(pFont);
	if(s_cachedFont == pFont)
		return s_cachedDigitWidth;

	s_cachedFont = pFont;
	float fMax = 0.0;
	for(char c = '0'; c <= '9'; c++) {
		float fWidth = pFont->StringWidth(&c, 1);
		if(fWidth > fMax)
			fMax = fWidth;
	}

	s_cachedDigitWidth = ceil(fMax + s_widthTrim);
	return s_cachedDigitWidth;
}

// END -- ValControlDigitSegment.cpp --