/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



#ifndef _BGFX_RANGE_B3IRANGE_HXX
#define _BGFX_RANGE_B3IRANGE_HXX

#include <basegfx/point/b3ipoint.hxx>
#include <basegfx/point/b3dpoint.hxx>
#include <basegfx/tuple/b3ituple.hxx>
#include <basegfx/tuple/b3i64tuple.hxx>
#include <basegfx/range/basicrange.hxx>
#include <basegfx/basegfxdllapi.h>

namespace basegfx
{
	class BASEGFX_DLLPUBLIC B3IRange
	{
        typedef ::basegfx::BasicRange< sal_Int32, Int32Traits >	MyBasicRange;

		MyBasicRange			maRangeX;
		MyBasicRange			maRangeY;
		MyBasicRange			maRangeZ;

	public:
		B3IRange()
		{
		}

		explicit B3IRange(const B3ITuple& rTuple)
		:	maRangeX(rTuple.getX()),
			maRangeY(rTuple.getY()),
			maRangeZ(rTuple.getZ())
		{
		}

		B3IRange(sal_Int32 x1,
                 sal_Int32 y1,
                 sal_Int32 z1,
                 sal_Int32 x2,
                 sal_Int32 y2,
                 sal_Int32 z2)
		:	maRangeX(x1),
			maRangeY(y1),
			maRangeZ(z1)
		{
			maRangeX.expand(x2);
			maRangeY.expand(y2);
			maRangeZ.expand(z2);
		}

		B3IRange(const B3ITuple& rTuple1,
                 const B3ITuple& rTuple2)
		:	maRangeX(rTuple1.getX()),
			maRangeY(rTuple1.getY()),
			maRangeZ(rTuple1.getZ())
		{
            expand(rTuple2);
		}

		B3IRange(const B3IRange& rRange)
		:	maRangeX(rRange.maRangeX),
			maRangeY(rRange.maRangeY),
			maRangeZ(rRange.maRangeZ)
		{
		}

		bool isEmpty() const
		{
			return maRangeX.isEmpty() || maRangeY.isEmpty() || maRangeZ.isEmpty();
		}

		void reset()
		{
			maRangeX.reset();
			maRangeY.reset();
			maRangeZ.reset();
		}

		bool operator==( const B3IRange& rRange ) const
		{
			return (maRangeX == rRange.maRangeX
				&& maRangeY == rRange.maRangeY
				&& maRangeZ == rRange.maRangeZ);
		}

		bool operator!=( const B3IRange& rRange ) const
		{
			return (maRangeX != rRange.maRangeX
				|| maRangeY != rRange.maRangeY
				|| maRangeZ != rRange.maRangeZ);
		}

		B3IRange& operator=(const B3IRange& rRange)
		{
			maRangeX = rRange.maRangeX;
			maRangeY = rRange.maRangeY;
			maRangeZ = rRange.maRangeZ;
			return *this;
		}

        sal_Int32 getMinX() const
        {
            return maRangeX.getMinimum();
        }

        sal_Int32 getMinY() const
        {
            return maRangeY.getMinimum();
        }

        sal_Int32 getMinZ() const
        {
            return maRangeZ.getMinimum();
        }

        sal_Int32 getMaxX() const
        {
            return maRangeX.getMaximum();
        }

        sal_Int32 getMaxY() const
        {
            return maRangeY.getMaximum();
        }

        sal_Int32 getMaxZ() const
        {
            return maRangeZ.getMaximum();
        }

        sal_Int64 getWidth() const
        {
            return maRangeX.getRange();
        }

        sal_Int64 getHeight() const
        {
            return maRangeY.getRange();
        }

        sal_Int64 getDepth() const
        {
            return maRangeZ.getRange();
        }

		B3IPoint getMinimum() const
		{
			return B3IPoint(
				maRangeX.getMinimum(),
				maRangeY.getMinimum(),
				maRangeZ.getMinimum()
				);
		}

		B3IPoint getMaximum() const
		{
			return B3IPoint(
				maRangeX.getMaximum(),
				maRangeY.getMaximum(),
				maRangeZ.getMaximum()
				);
		}

		B3I64Tuple getRange() const
		{
			return B3I64Tuple(
				maRangeX.getRange(),
				maRangeY.getRange(),
				maRangeZ.getRange()
				);
		}

		B3DPoint getCenter() const
		{
			return B3DPoint(
				maRangeX.getCenter(),
				maRangeY.getCenter(),
				maRangeZ.getCenter()
				);
		}

		bool isInside(const B3ITuple& rTuple) const
		{
			return (
				maRangeX.isInside(rTuple.getX())
				&& maRangeY.isInside(rTuple.getY())
				&& maRangeZ.isInside(rTuple.getZ())
				);
		}

		bool isInside(const B3IRange& rRange) const
		{
			return (
				maRangeX.isInside(rRange.maRangeX)
				&& maRangeY.isInside(rRange.maRangeY)
				&& maRangeZ.isInside(rRange.maRangeZ)
				);
		}

		bool overlaps(const B3IRange& rRange) const
		{
			return (
				maRangeX.overlaps(rRange.maRangeX)
				&& maRangeY.overlaps(rRange.maRangeY)
				&& maRangeZ.overlaps(rRange.maRangeZ)
				);
		}

		void expand(const B3ITuple& rTuple)
		{
			maRangeX.expand(rTuple.getX());
			maRangeY.expand(rTuple.getY());
			maRangeZ.expand(rTuple.getZ());
		}

		void expand(const B3IRange& rRange)
		{
			maRangeX.expand(rRange.maRangeX);
			maRangeY.expand(rRange.maRangeY);
			maRangeZ.expand(rRange.maRangeZ);
		}

		void intersect(const B3IRange& rRange)
		{
			maRangeX.intersect(rRange.maRangeX);
			maRangeY.intersect(rRange.maRangeY);
			maRangeZ.intersect(rRange.maRangeZ);
		}

		void grow(sal_Int32 nValue)
		{
			maRangeX.grow(nValue);
			maRangeY.grow(nValue);
			maRangeZ.grow(nValue);
		}
	};
} // end of namespace basegfx

#endif /* _BGFX_RANGE_B3IRANGE_HXX */