IIndexingHeaderSetMaster.h

//========================================================================================
// 
// $File$
// 
// Owner: mvogel
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
// 
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance 
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or 
// distribution of it requires the prior written permission of Adobe.
// 
//========================================================================================

#ifndef __IIndexingHeaderSetMaster__
#define __IIndexingHeaderSetMaster__

#include "IPMUnknown.h"
#include "IndexingID.h"
#include <vector>
#include "IndexHeaderGroup.h"

class IIndexHeaderSet;
class PMString;

class HeaderRangeTypes
{
public:
 typedef object_type data_type;

 HeaderRangeTypes() : fInclude(kFalse), fSelection(0) {}

 HeaderRangeTypes(
 const PMString& headerRangeName,
 const bool16& include,
 const int32& selection,
 const std::vector<IndexHeaderGroup> groupList):
 fHeaderRangeName(headerRangeName),
 fInclude(include),
 fSelection(selection),
 fGroupList(groupList) {}

 bool16 operator==(const HeaderRangeTypes& other) const
 {
 return ( (fHeaderRangeName == other.fHeaderRangeName) &&
 (fInclude == other.fInclude) &&
 (fSelection == other.fSelection) &&
 (fGroupList == other.fGroupList) );
 }

 void ReadWrite(IPMStream *s)
 {
 fHeaderRangeName.ReadWrite(s);
 s->XferBool(fInclude);
 s->XferInt32(fSelection);

 int32 numGroup = static_cast<int32>(fGroupList.size());

 s->XferInt32(numGroup);
 if (s->IsReading())
 {
 fGroupList.clear();
 fGroupList.reserve(numGroup);

 int32 i;
 for (i = 0; i < numGroup; i++)
 {
 IndexHeaderGroup topicHeaderGroup;

 topicHeaderGroup.ReadWrite(s);

 fGroupList.push_back(topicHeaderGroup);
 }
 }
 else
 {
 int32 i;
 for (i = 0; i < numGroup; i++)
 fGroupList[i].ReadWrite(s);
 }

 }

 PMString fHeaderRangeName;
 bool16 fInclude;
 int32 fSelection;
 std::vector<IndexHeaderGroup> fGroupList;
};

class IIndexingHeaderSetMaster : public IPMUnknown
{
public:
 enum { kDefaultIID = IID_IINDEXINGHEADERSETMASTER };

 virtual int32 GetNumGroups() const = 0;

 virtual const PMString& GetNthGroupName(int32 nth) const = 0;

 virtual std::vector<PMString> GetNthGroupTypes(int32 nth) const = 0;

 virtual int32 GetNthGroupSelection(int32 nth) const = 0;

 virtual void SetNthGroupSelection(int32 nth, int32 selection) = 0;

 virtual bool16 GetNthInclude(int32 nth) const = 0;

 virtual void SetNthInclude(int32 nth, bool16 include) = 0;

 virtual void Move(int32 oldPos, int32 newPos) = 0;

 virtual void AddGroup(const IndexHeaderGroup &headerGroup, bool16 include = kTrue) = 0;

 virtual void BuildHeaderSet(IIndexHeaderSet* headerSet) const = 0;

 virtual void SetAllGroupInfo(const std::vector<HeaderRangeTypes>& headerRangeList) = 0;

 virtual void CopyData(IIndexingHeaderSetMaster *iTarget ) const = 0;


 enum GroupOrder
 {
 kDefault = -1,
 kSymbolLatin,
 kSymbolNumbersLatinKana,
 kKanaLatinNumbersSymbol,
 kLatinNumbersSymbol,
 kSymbolNumbersLatinKorean,
 kSymbolNumbersPinYin,
 kSymbolNumbersLatinHanziStrokes
 ,kSymbolNumbersLatinME
 ,kSymbolNumbersLatin /*WR_SymbolNumericAlphabet*/
 ,kSymbolArabic /*WR_SymbolArabic*/
 ,kSymbolNumbersArabic /*WR_SymbolNumericArabic*/
 ,kSymbolNumbersArabicLatin /*WR_SymbolNumericArabicAlphabet*/
 ,kSymbolNumbersLatinArabic /*WR_SymbolNumericAlphabetArabic*/
 ,kSymbolHebrew /*WR_SymbolHebrew*/
 ,kSymbolNumbersHebrew /*WR_SymbolNumericHebrew*/
 ,kSymbolNumbersHebrewLatin /*WR_SymbolNumericHebrewAlphabet*/
 ,kSymbolNumbersLatinHebrew /*WR_SymbolNumericAlphabetHebrew*/
 };
 virtual void SetDefault(GroupOrder order = kDefault) = 0;
};

#endif // __IIndexingHeaderSetMaster__