xref: /aoo42x/main/svx/inc/svx/svdmark.hxx (revision 3334a7e6)

/**************************************************************
 *
 * 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 _SVDMARK_HXX
#define _SVDMARK_HXX

#include <tools/contnr.hxx>
#include <tools/string.hxx>
#include <tools/list.hxx>
#include "svx/svxdllapi.h"
#include <svx/sdrobjectuser.hxx>

#include <set>

class Rectangle;
class SdrPage;
class SdrObjList;
class SdrObject;
class SdrPageView;

// Ein Container fuer USHORTs (im Prinzip ein dynamisches Array)
class SVX_DLLPUBLIC SdrUShortCont
{
	Container											maArray;
	sal_Bool											mbSorted;

private:
	void CheckSort(sal_uLong nPos);

public:
	SdrUShortCont(sal_uInt16 nBlock, sal_uInt16 nInit, sal_uInt16 nResize)
	:	maArray(nBlock, nInit, nResize),
	mbSorted(sal_True)
	{}

	SdrUShortCont(const SdrUShortCont& rCont)
	:	maArray(rCont.maArray),
		mbSorted(rCont.mbSorted)
	{}

	/** helper to migrate to stl containers */
	std::set< sal_uInt16 > getContainer();

	SdrUShortCont& operator=(const SdrUShortCont& rCont)
	{
		maArray = rCont.maArray;
		mbSorted = rCont.mbSorted;
		return *this;
	}

	sal_Bool operator==(const SdrUShortCont& rCont) const
	{
		return maArray == rCont.maArray;
	}

	sal_Bool operator!=(const SdrUShortCont& rCont) const
	{
		return maArray != rCont.maArray;
	}

	void Clear()
	{
		maArray.Clear();
		mbSorted = sal_True;
	}

	void Sort() const;

	void ForceSort() const
	{
		if(!mbSorted)
		{
			Sort();
		}
	}

	void Insert(sal_uInt16 nElem, sal_uLong nPos = CONTAINER_APPEND)
	{
		maArray.Insert((void*)sal_uLong(nElem),nPos);

		if(mbSorted)
		{
			CheckSort(nPos);
		}
	}

	void Remove(sal_uLong nPos)
	{
		maArray.Remove(nPos);
	}

	void Replace(sal_uInt16 nElem, sal_uLong nPos)
	{
		maArray.Replace((void*)sal_uLong(nElem), nPos);

		if(mbSorted)
		{
			CheckSort(nPos);
		}
	}

	sal_uInt16 GetObject(sal_uLong nPos) const
	{
		return sal_uInt16(sal_uIntPtr(maArray.GetObject(nPos)));
	}

	sal_uLong GetPos(sal_uInt16 nElem) const
	{
		return maArray.GetPos((void*)(sal_uLong)nElem);
	}

	sal_uLong GetCount() const
	{
		return maArray.Count();
	}

	sal_Bool Exist(sal_uInt16 nElem) const
	{
		return (CONTAINER_ENTRY_NOTFOUND != maArray.GetPos((void*)(sal_uLong)nElem));
	}
};

// Alles was eine View ueber ein markiertes Objekt wissen muss
class SVX_DLLPUBLIC SdrMark : public sdr::ObjectUser
{
protected:
	SdrObject*											mpSelectedSdrObject;	// the seleceted object
	SdrPageView*										mpPageView;
	SdrUShortCont*										mpPoints;     // Markierte Punkte
	SdrUShortCont*										mpLines;      // Markierte Linienabschnitte
	SdrUShortCont*										mpGluePoints; // Markierte Klebepunkte (deren Id's)
	sal_Bool											mbCon1;       // fuer Connectoren
	sal_Bool											mbCon2;       // fuer Connectoren
	sal_uInt16											mnUser;       // z.B. fuer CopyObjects, mitkopieren von Edges

public:
	SdrMark(SdrObject* pNewObj = 0L, SdrPageView* pNewPageView = 0L);
	SdrMark(const SdrMark& rMark);
	virtual ~SdrMark();

	// derived from ObjectUser
	virtual void ObjectInDestruction(const SdrObject& rObject);

	SdrMark& operator=(const SdrMark& rMark);
	sal_Bool operator==(const SdrMark& rMark) const;
	sal_Bool operator!=(const SdrMark& rMark) const
	{
		return !(operator==(rMark));
	}

	void SetMarkedSdrObj(SdrObject* pNewObj);
	SdrObject* GetMarkedSdrObj() const;

	SdrPage* GetPage() const;
	SdrObjList* GetObjList() const;
	SdrPageView* GetPageView() const
	{
		return mpPageView;
	}

	void SetPageView(SdrPageView* pNewPageView)
	{
		mpPageView = pNewPageView;
	}

	void SetCon1(sal_Bool bOn)
	{
		mbCon1 = bOn;
	}

	sal_Bool IsCon1() const
	{
		return mbCon1;
	}

	void SetCon2(sal_Bool bOn)
	{
		mbCon2 = bOn;
	}

	sal_Bool IsCon2() const
	{
		return mbCon2;
	}

	void SetUser(sal_uInt16 nVal)
	{
		mnUser = nVal;
	}

	sal_uInt16 GetUser() const
	{
		return mnUser;
	}

	const SdrUShortCont* GetMarkedPoints() const
	{
		return mpPoints;
	}

	const SdrUShortCont* GetMarkedLines() const
	{
		return mpLines;
	}

	const SdrUShortCont* GetMarkedGluePoints() const
	{
		return mpGluePoints;
	}

	SdrUShortCont* GetMarkedPoints()
	{
		return mpPoints;
	}

	SdrUShortCont* GetMarkedLines()
	{
		return mpLines;
	}

	SdrUShortCont* GetMarkedGluePoints()
	{
		return mpGluePoints;
	}

	SdrUShortCont* ForceMarkedPoints()
	{
		if(!mpPoints)
			mpPoints = new SdrUShortCont(1024, 32, 32);

		return mpPoints;
	}

	SdrUShortCont* ForceMarkedLines()
	{
		if(!mpLines)
			mpLines = new SdrUShortCont(1024, 32, 32);

		return mpLines;
	}

	SdrUShortCont* ForceMarkedGluePoints()
	{
		if(!mpGluePoints)
			mpGluePoints = new SdrUShortCont(1024, 32, 32);

		return mpGluePoints;
	}
};

class SVX_DLLPUBLIC SdrMarkList
{
protected:
	Container											maList;

	String												maMarkName;
	String												maPointName;
	String												maGluePointName;

	sal_Bool											mbPointNameOk;
	sal_Bool											mbGluePointNameOk;
	sal_Bool											mbNameOk;
	sal_Bool											mbSorted;

private:
	SVX_DLLPRIVATE sal_Bool operator==(const SdrMarkList& rCmpMarkList) const;
	SVX_DLLPRIVATE void ImpForceSort();

private:
	SVX_DLLPRIVATE const XubString& GetPointMarkDescription(sal_Bool bGlue) const;

public:
	SdrMarkList()
	:	maList(1024, 64, 64),
		mbPointNameOk(sal_False),
		mbGluePointNameOk(sal_False),
		mbNameOk(sal_False),
		mbSorted(sal_True)
	{
	}

	SdrMarkList(const SdrMarkList& rLst)
	:	maList(1024, 64, 64)
	{
		*this = rLst;
	}

	~SdrMarkList()
	{
		Clear();
	}

	void Clear();
	void ForceSort() const;
	void SetUnsorted()
	{
		mbSorted = sal_False;
	}

	sal_uLong GetMarkCount() const
	{
		return maList.Count();
	}

	SdrMark* GetMark(sal_uLong nNum) const
	{
		return (SdrMark*)(maList.GetObject(nNum));
	}

	sal_uLong FindObject(const SdrObject* pObj) const;
	void InsertEntry(const SdrMark& rMark, sal_Bool bChkSort = sal_True);
	void DeleteMark(sal_uLong nNum);
	void ReplaceMark(const SdrMark& rNewMark, sal_uLong nNum);
	void Merge(const SdrMarkList& rSrcList, sal_Bool bReverse = sal_False);
	sal_Bool DeletePageView(const SdrPageView& rPV);
	sal_Bool InsertPageView(const SdrPageView& rPV);

	void SetNameDirty()
	{
		mbNameOk = sal_False;
		mbPointNameOk = sal_False;
		mbGluePointNameOk = sal_False;
	}

	// Eine verbale Beschreibung der markierten Objekte z.B.:
	// "27 Linien", "12 Objekte", "Polygon" oder auch "Kein Objekt"
	const String& GetMarkDescription() const;
	const String& GetPointMarkDescription() const
	{
		return GetPointMarkDescription(sal_False);
	}

	const String& GetGluePointMarkDescription() const
	{
		return GetPointMarkDescription(sal_True);
	}

	// pPage=0L: Die Markierungen aller! Seiten beruecksichtigen
	sal_Bool TakeBoundRect(SdrPageView* pPageView, Rectangle& rRect) const;
	sal_Bool TakeSnapRect(SdrPageView* pPageView, Rectangle& rRect) const;

	// Es werden saemtliche Entries kopiert!
	void operator=(const SdrMarkList& rLst);
};

////////////////////////////////////////////////////////////////////////////////////////////////////
// migrate selections

namespace sdr
{
	class SVX_DLLPUBLIC ViewSelection
	{
		SdrMarkList					maMarkedObjectList;
		SdrMarkList					maEdgesOfMarkedNodes;
		SdrMarkList					maMarkedEdgesOfMarkedNodes;
		List						maAllMarkedObjects;

		// bitfield
		unsigned					mbEdgesOfMarkedNodesDirty : 1;

		SVX_DLLPRIVATE void ImpForceEdgesOfMarkedNodes();
		SVX_DLLPRIVATE void ImplCollectCompleteSelection(SdrObject* pObj);

	public:
		ViewSelection();

		void SetEdgesOfMarkedNodesDirty();

		const SdrMarkList& GetMarkedObjectList() const
		{
			return maMarkedObjectList;
		}

		const SdrMarkList& GetEdgesOfMarkedNodes() const;
		const SdrMarkList& GetMarkedEdgesOfMarkedNodes() const;
		const List& GetAllMarkedObjects() const;

		SdrMarkList& GetMarkedObjectListWriteAccess()
		{
			return maMarkedObjectList;
		}
	};
} // end of namespace sdr

////////////////////////////////////////////////////////////////////////////////////////////////////

#endif //_SVDMARK_HXX
// eof