haiku.git

/*
 * Copyright 2003-2011, Haiku, Inc. All Rights Reserved.
 * Copyright 2004-2005 yellowTAB GmbH. All Rights Reserverd.
 * Copyright 2006 Bernd Korz. All Rights Reserved
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Fernando Francisco de Oliveira
 *		Michael Wilber
 *		Michael Pfeiffer
 *		yellowTAB GmbH
 *		Bernd Korz
 */
#ifndef SHOW_IMAGE_VIEW_H
#define SHOW_IMAGE_VIEW_H


#include <Bitmap.h>
#include <Entry.h>
#include <NodeInfo.h>
#include <String.h>
#include <TranslatorRoster.h>
#include <View.h>

#include "Filter.h"
#include "SelectionBox.h"


class BitmapOwner;


class ShowImageView : public BView {
public:
								ShowImageView(const char* name, uint32 flags);
	virtual						~ShowImageView();

	virtual	void				AttachedToWindow();
	virtual void				FrameResized(float width, float height);
	virtual	void				Draw(BRect updateRect);
	virtual	void				MouseDown(BPoint point);
	virtual	void				MouseMoved(BPoint point, uint32 state,
									const BMessage* dragMessage);
	virtual	void				MouseUp(BPoint point);
	virtual	void				KeyDown(const char* bytes, int32 numBytes);
	virtual	void				Pulse();

	virtual void				MessageReceived(BMessage* message);
	virtual void				WindowActivated(bool active);

			void				SetTrackerMessenger(
									const BMessenger& trackerMessenger);
			status_t			SetImage(const BMessage* message);
			status_t			SetImage(const entry_ref* ref, BBitmap* bitmap,
									BitmapOwner* bitmapOwner);
			const entry_ref*	Image() const { return &fCurrentRef; }
			BBitmap*			Bitmap();

			BPoint				ImageToView(BPoint p) const;
			BPoint				ViewToImage(BPoint p) const;
			BRect				ImageToView(BRect r) const;
			void				ConstrainToImage(BPoint& point) const;
			void				ConstrainToImage(BRect& rect) const;

			void				SaveToFile(BDirectory* dir, const char* name,
									BBitmap* bitmap,
									const translation_format* format);

			void				SetScaleBilinear(bool b);
			bool				ScaleBilinear() { return fScaleBilinear; }
			void				SetShowCaption(bool show);
			void				SetStretchToBounds(bool enable);
			bool				StretchesToBounds() const
									{ return fStretchToBounds; }
			void				SetHideIdlingCursor(bool hide);

			void				FixupScrollBar(enum orientation orientation,
									float bitmapLength, float viewLength);
			void				FixupScrollBars();

			void				SetSelectionMode(bool selectionMode);
			bool				IsSelectionModeEnabled() const
									{ return fSelectionMode; }
			void				SelectAll();
			void				ClearSelection();

			void				CopySelectionToClipboard();

			void				FitToBounds();
			void				ForceOriginalSize(bool force)
									{ fForceOriginalSize = force; }
			void				SetZoom(float zoom,
									BPoint where = BPoint(-1, -1));
			float				Zoom() const
									{ return fZoom; }
			void				ZoomIn(BPoint where = BPoint(-1, -1));
			void				ZoomOut(BPoint where = BPoint(-1, -1));

			// Image manipulation
			void				Rotate(int degree); // 90 and 270 only
			void				Flip(bool vertical);
			void				ResizeImage(int width, int height);

			void				SetIcon(bool clear);

private:
			enum image_orientation {
				k0,		// 0
				k90,	// 1
				k180,	// 2
				k270,	// 3
				k0V,	// 4
				k90V,	// 5
				k0H,	// 6
				k270V,	// 7
				kNumberOfOrientations,
			};

			void				_SetHasSelection(bool bHasSelection);
			void				_AnimateSelection(bool a);
			void				_SendMessageToWindow(BMessage* message);
			void				_SendMessageToWindow(uint32 code);
			void				_Notify();
			void				_UpdateStatusText();
			void				_GetMergeRects(BBitmap* merge,
									BRect selection, BRect& srcRect,
									BRect& dstRect);
			void				_GetSelectionMergeRects(BRect& srcRect,
									BRect& dstRect);
			status_t			_SetSelection(const entry_ref* ref,
									BPoint point);
			void				_MergeWithBitmap(BBitmap* merge,
									BRect selection);
			void				_MergeSelection();
			void				_DeleteScaler();
			void				_DeleteBitmap();
			void				_DeleteSelectionBitmap();

			void				_DoImageOperation(
									enum ImageProcessor::operation op,
									bool quiet = false);
			void				_UserDoImageOperation(
									enum ImageProcessor::operation op,
									bool quiet = false);
			bool				_ShouldStretch() const;
			float				_FitToBoundsZoom() const;
			BRect				_AlignBitmap();
			BBitmap*			_CopySelection(uchar alpha = 255,
									bool imageSize = true);
			bool				_AddSupportedTypes(BMessage* message,
									BBitmap* bitmap);
			void				_BeginDrag(BPoint sourcePoint);
			void				_SendInMessage(BMessage* message,
									BBitmap* bitmap,
									translation_format* format);
			bool				_OutputFormatForType(BBitmap* bitmap,
									const char* type,
									translation_format* format);
			void				_HandleDrop(BMessage* message);
			void				_ScrollBitmap(BPoint point);
			void				_UpdateSelectionRect(BPoint point, bool final);
			void				_DrawBackground(BRect aroundFrame);
			void				_LayoutCaption(BFont& font, BPoint& textPos,
									BRect& background);
			void				_DrawCaption();
			void				_UpdateCaption();

			void				_DrawImage(BRect rect);
			float				_LimitToRange(float v, orientation o,
									bool absolute);
			void				_ScrollRestricted(float x, float y,
									bool absolute);
			void				_ScrollRestrictedTo(float x, float y);
			void				_ScrollRestrictedBy(float x, float y);
			void				_MouseWheelChanged(BMessage* message);
			void				_ShowPopUpMenu(BPoint screen);
			void				_SettingsSetBool(const char* name, bool value);
			void				_SetIcon(bool clear, icon_size which);
			void				_ToggleSlideShow();
			void				_StopSlideShow();
			void				_ExitFullScreen();
			void				_ShowToolBarIfEnabled(bool show);

private:
			entry_ref			fCurrentRef;

			BitmapOwner*		fBitmapOwner;
			BBitmap*			fBitmap;
			BBitmap*			fDisplayBitmap;
			BBitmap*			fSelectionBitmap;

			float				fZoom;

			bool				fScaleBilinear;

			BPoint				fBitmapLocationInView;

			bool				fStretchToBounds;
			bool				fForceOriginalSize;
			bool				fHideCursor;
			bool				fScrollingBitmap;
			bool				fCreatingSelection;
			BPoint				fFirstPoint;
				// first point in image space of selection
			bool				fSelectionMode;
			bool				fAnimateSelection;
			bool				fHasSelection;
			SelectionBox		fSelectionBox;
			BRect				fCopyFromRect;
				// the portion of the background bitmap the selection is made
				// from

			bool				fShowCaption;
			BString				fCaption;

			BString				fFormatDescription;
			BString				fMimeType;

			bool				fShowingPopUpMenu;

			int					fHideCursorCountDown;
				// Hides the cursor when it reaches zero
			int 				fStickyZoomCountDown;
				// Make the zoom sticky at 1.0 when zoomed with the mousewheel

			bool				fIsActiveWin;
				// Is the parent window the active window?

			BCursor*			fDefaultCursor;
			BCursor*			fGrabCursor;

			image_orientation	fImageOrientation;
	static	image_orientation	fTransformation[
									ImageProcessor
										::kNumberOfAffineTransformations]
									[kNumberOfOrientations];
};

#endif	// SHOW_IMAGE_VIEW_H