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


// DiagramBox.cpp

/*! \class DiagramBox
	DiagramItem subclass providing a basic framework for
	boxes in diagrams, i.e. objects that can contain various
	endpoints
*/

#include "DiagramBox.h"
#include "DiagramDefs.h"
#include "DiagramEndPoint.h"
#include "DiagramView.h"

#include <Message.h>
#include <Messenger.h>

__USE_CORTEX_NAMESPACE

#include <Debug.h>
#define D_METHOD(x) //PRINT (x)
#define D_MESSAGE(x) //PRINT (x)
#define D_MOUSE(x) //PRINT (x)
#define D_DRAW(x) //PRINT (x)


//	#pragma mark -


DiagramBox::DiagramBox(BRect frame, uint32 flags)
	: DiagramItem(DiagramItem::M_BOX),
	DiagramItemGroup(DiagramItem::M_ENDPOINT),
	fFrame(frame),
	fFlags(flags)
{
	D_METHOD(("DiagramBox::DiagramBox()\n"));
	makeDraggable(true);
}


DiagramBox::~DiagramBox()
{
	D_METHOD(("DiagramBox::~DiagramBox()\n"));
}


//	#pragma mark -  derived from DiagramItemGroup (public)


/*! Extends the DiagramItemGroup implementation by setting
	the items owner and calling the attachedToDiagram() hook
	on it
*/
bool
DiagramBox::AddItem(DiagramItem *item)
{
	D_METHOD(("DiagramBox::AddItem()\n"));
	if (item) {
		if (DiagramItemGroup::AddItem(item)) {
			if (m_view) {
				item->_SetOwner(m_view);
				item->attachedToDiagram();
			}
			return true;
		}
	}
	return false;
}


/*! Extends the DiagramItemGroup implementation by calling 
	the detachedToDiagram() hook on the \a item
*/
bool
DiagramBox::RemoveItem(DiagramItem *item)
{
	D_METHOD(("DiagramBox::RemoveItem()\n"));
	if (item) {
		item->detachedFromDiagram();
		if (DiagramItemGroup::RemoveItem(item)) {
			item->_SetOwner(0);
			return true;
		}
	}
	return false;
}


//	#pragma mark -   derived from DiagramItem (public)


/*! Prepares the drawing stack and clipping region, then
	calls drawBox
*/
void
DiagramBox::Draw(BRect updateRect)
{
	D_DRAW(("DiagramBox::Draw()\n"));
	if (view()) {
		view()->PushState();
		{
			if (fFlags & M_DRAW_UNDER_ENDPOINTS) {
				BRegion region, clipping;
				region.Include(Frame());
				if (group()->GetClippingAbove(this, &clipping))
					region.Exclude(&clipping);
				view()->ConstrainClippingRegion(&region);
				DrawBox();
				for (uint32 i = 0; i < CountItems(); i++) {
					DiagramItem *item = ItemAt(i);
					if (region.Intersects(item->Frame()))
						item->Draw(item->Frame());
				}
			} else {
				BRegion region, clipping;
				region.Include(Frame());
				if (view()->GetClippingAbove(this, &clipping))
					region.Exclude(&clipping);
				for (uint32 i = 0; i < CountItems(); i++) {
					DiagramItem *item = ItemAt(i);
					BRect r;
					if (region.Intersects(r = item->Frame())) {
						item->Draw(r);
						region.Exclude(r);
					}
				}
				view()->ConstrainClippingRegion(&region);
				DrawBox();
			}
		}
		view()->PopState();
	}
}


/*! Is called from the parent DiagramViews MouseDown() implementation 
	if the Box was hit; this version initiates selection and dragging
*/
void
DiagramBox::MouseDown(BPoint point, uint32 buttons, uint32 clicks)
{
	D_MOUSE(("DiagramBox::MouseDown()\n"));
	DiagramItem *item = ItemUnder(point);
	if (item)
		item->MouseDown(point, buttons, clicks);
	else if (clicks == 1) {
		if (isSelectable()) {
			BMessage selectMsg(M_SELECTION_CHANGED);
			if (modifiers() & B_SHIFT_KEY)
				selectMsg.AddBool("replace", false);
			else
				selectMsg.AddBool("replace", true);
			selectMsg.AddPointer("item", reinterpret_cast<void *>(this));
			DiagramView* v = view();
			BMessenger(v).SendMessage(&selectMsg);
		}
		if (isDraggable() && (buttons == B_PRIMARY_MOUSE_BUTTON)) {
			BMessage dragMsg(M_BOX_DRAGGED);
			dragMsg.AddPointer("item", static_cast<void *>(this));
			dragMsg.AddPoint("offset", point - Frame().LeftTop());
			view()->DragMessage(&dragMsg, BRect(0.0, 0.0, -1.0, -1.0), view());
		}
	}
}



/*!	Is called from the DiagramViews MouseMoved() when no message is being 
	dragged, but the mouse has moved above the box
*/
void
DiagramBox::MouseOver(BPoint point, uint32 transit)
{
	D_MOUSE(("DiagramBox::MouseOver()\n"));
	DiagramItem *last = _LastItemUnder();
	if (last && (transit == B_EXITED_VIEW)) {
		last->MouseOver(point, B_EXITED_VIEW);
		_ResetItemUnder();
	} else {
		DiagramItem *item = ItemUnder(point);
		if (item) {
			if (item != last) {
				if (last)
					last->MouseOver(point, B_EXITED_VIEW);
				item->MouseOver(point, B_ENTERED_VIEW);
			} else
				item->MouseOver(point, B_INSIDE_VIEW);
		}
		else if (last)
			last->MouseOver(point, B_EXITED_VIEW);
	}
}


/*!	Is called from the DiagramViews MouseMoved() when a message is being 
	dragged over the DiagramBox
*/
void
DiagramBox::MessageDragged(BPoint point, uint32 transit, const BMessage *message)
{
	D_MOUSE(("DiagramBox::MessageDragged()\n"));
	DiagramItem *last = _LastItemUnder();
	if (last && (transit == B_EXITED_VIEW)) {
		last->MessageDragged(point, B_EXITED_VIEW, message);
		_ResetItemUnder();
	} else {
		DiagramItem *item = ItemUnder(point);
		if (item) {
			if (item != last) {
				if (last)
					last->MessageDragged(point, B_EXITED_VIEW, message);
				item->MessageDragged(point, B_ENTERED_VIEW, message);
			} else
				item->MessageDragged(point, B_INSIDE_VIEW, message);
			return;
		} else if (last)
			last->MessageDragged(point, B_EXITED_VIEW, message);
		if (message->what == M_WIRE_DRAGGED)
			view()->trackWire(point);
	}
}


/*!	Is called from the DiagramViews MessageReceived() function when a 
	message has been dropped on the DiagramBox
*/
void
DiagramBox::MessageDropped(BPoint point, BMessage *message)
{
	D_METHOD(("DiagramBox::MessageDropped()\n"));
	DiagramItem *item = ItemUnder(point);
	if (item) {
		item->MessageDropped(point, message);
		return;
	}
}


//	#pragma mark - operations (public)


/*!	Moves the box by a given amount, and returns in updateRegion the
	frames of wires impacted by the move
*/
void
DiagramBox::MoveBy(float x, float y, BRegion *wireRegion)
{
	D_METHOD(("DiagramBox::MoveBy()\n"));
	if (view()) {
		view()->PushState();
		{
			for (uint32 i = 0; i < CountItems(); i++) {
				DiagramEndPoint *endPoint = dynamic_cast<DiagramEndPoint *>(ItemAt(i));
				if (endPoint)
					endPoint->MoveBy(x, y, wireRegion);
			}
			if (wireRegion) {
				wireRegion->Include(fFrame);
				fFrame.OffsetBy(x, y);
				wireRegion->Include(fFrame);
			}
			else
				fFrame.OffsetBy(x, y);
		}
		view()->PopState();
	}
}


//! Resizes the boxes frame without doing any updating
void
DiagramBox::ResizeBy(float horizontal, float vertical)
{
	D_METHOD(("DiagramBox::ResizeBy()\n"));
	fFrame.right += horizontal;
	fFrame.bottom += vertical;
}


//	#pragma mark - internal operations (private)


//!	Is called by the DiagramView when added
void
DiagramBox::_SetOwner(DiagramView *owner)
{
	D_METHOD(("DiagramBox::_SetOwner()\n"));
	m_view = owner;
	for (uint32 i = 0; i < CountItems(DiagramItem::M_ENDPOINT); i++) {
		DiagramItem *item = ItemAt(i);
		item->_SetOwner(m_view);
		if (m_view)
			item->attachedToDiagram();
	}
}