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


// TipView.cpp

#include "TipView.h"

#include <Debug.h>
#include <Window.h>
#include <cmath>
#include <cstring>

using namespace std;

__USE_CORTEX_NAMESPACE

// -------------------------------------------------------- //
// constants
// -------------------------------------------------------- //

const float TipView::s_xPad = 5.0;
const float TipView::s_yPad = 2.0;

// -------------------------------------------------------- //
// *** dtor/ctors
// -------------------------------------------------------- //

TipView::~TipView() {}
TipView::TipView() :
	BView(
		BRect(0,0,0,0),
		"TipView",
		B_FOLLOW_NONE,
		B_WILL_DRAW|B_FRAME_EVENTS),
	m_font(be_plain_font) {
	
	_initColors();
	_initFont();
}

// -------------------------------------------------------- //
// *** operations
// -------------------------------------------------------- //

void TipView::setText(
	const char*							text) {

	_setText(text);
}
		
// -------------------------------------------------------- //
// *** BView
// -------------------------------------------------------- //

// Adapted from c.lenz' ToolTipView::Draw()
void TipView::Draw(
	BRect										updateRect) {

	BRect r = Bounds();

	// Draw border and fill
	SetDrawingMode(B_OP_ALPHA);
	SetHighColor(m_borderLoColor);
	StrokeLine(r.LeftBottom(), r.RightBottom());
	StrokeLine(r.RightTop(), r.RightBottom());
	SetHighColor(m_borderHiColor);
	StrokeLine(r.LeftTop(), r.RightTop());
	StrokeLine(r.LeftTop(), r.LeftBottom());
	SetHighColor(m_viewColor);
	SetDrawingMode(B_OP_ALPHA);
	r.InsetBy(1.0, 1.0);
	FillRect(r);

	// Draw text
	SetDrawingMode(B_OP_OVER);
	SetHighColor(m_textColor);
	
	BPoint p = m_offset;
	for(uint32 n = 0; n < m_lineSet.size(); ++n) {
		
		uint32 from = m_lineSet[n];
		uint32 to = (n < m_lineSet.size()-1) ? m_lineSet[n+1]-1 :
			m_text.Length();
		
		if(to > from)
			DrawString(
				m_text.String() + from,
				to - from,
				p);
			
		p.y += (m_fontHeight.ascent + m_fontHeight.descent + m_fontHeight.leading);
	}
}

void TipView::FrameResized(
	float										width,
	float										height) {
	
	_inherited::FrameResized(width, height);
	_updateLayout(width, height);
	Invalidate();
}
		
void TipView::GetPreferredSize(
	float*									outWidth,
	float*									outHeight) {

//	*outWidth = ceil(m_font.StringWidth(m_text.String()) + s_xPad*2);
	*outWidth = ceil(_maxTextWidth() + s_xPad*2);
	*outHeight = ceil(_textHeight() + s_yPad*2);
}

// -------------------------------------------------------- //
// implementation
// -------------------------------------------------------- //
	
void _make_color(
	rgb_color*							outColor,
	uint8										red,
	uint8										green,
	uint8										blue,
	uint8										alpha=255);
void _make_color(
	rgb_color*							outColor,
	uint8										red,
	uint8										green,
	uint8										blue,
	uint8										alpha) {
	outColor->red = red;
	outColor->green = green;
	outColor->blue = blue;
	outColor->alpha = alpha;
}
	
void TipView::_initColors() {

	SetViewColor(B_TRANSPARENT_COLOR);

	_make_color(&m_textColor, 0, 0, 0, 255);
	_make_color(&m_borderHiColor, 0, 0, 0, 255 /*196*/);
	_make_color(&m_borderLoColor, 0, 0, 0, 255 /*196*/);
	_make_color(&m_viewColor, 255, 255, 240, 255 /*216*/);
}

void TipView::_initFont() {

	SetFont(&m_font);
	m_font.GetHeight(&m_fontHeight);
}

void TipView::_updateLayout(
	float										width,
	float										height) {

	// center text
	m_offset.x = (width - _maxTextWidth()) / 2;

	m_offset.y = (height - _textHeight()) / 2;
	m_offset.y += m_fontHeight.ascent;
}

void TipView::_setText(
	const char*							text) {

	ASSERT(text);
	
	m_lineSet.clear();
	m_text = text;
	
	// skip leading newlines
	int32 n = 0;
	while(n < m_text.Length() && m_text[n] == '\n')
		++n;
	
	// mark first line
	m_lineSet.push_back(n);
	
	// break following lines
	while(n < m_text.Length()) {
		int32 nextBreak = m_text.FindFirst('\n', n);
		// no more line breaks?
		if(nextBreak < n)
			break;
		n = nextBreak + 1;
		m_lineSet.push_back(n);
	}
}

float TipView::_maxTextWidth() {
	float max = 0.0;
	for(uint32 n = 0; n < m_lineSet.size(); ++n) {
		uint32 from = m_lineSet[n];
		uint32 to = (n < m_lineSet.size()-1) ? m_lineSet[n+1]-1 :
			m_text.Length();
		float lineWidth = m_font.StringWidth(
			m_text.String() + from,
			to - from);
		if(lineWidth > max)
			max = lineWidth;
	}
	return max;
}

float TipView::_textHeight() {
	float height = m_fontHeight.ascent + m_fontHeight.descent;
	if(m_lineSet.size() > 1)
		height += (m_lineSet.size()-1) *
			(m_fontHeight.ascent + m_fontHeight.descent + m_fontHeight.leading);
	
	return height;
}

// END -- TipView.cpp --