mirror of
https://github.com/reactos/reactos.git
synced 2024-08-28 22:28:36 +00:00
202 lines
5.2 KiB
C#
202 lines
5.2 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.IO;
|
|
|
|
using HtmlHelp.ChmDecoding;
|
|
|
|
namespace HtmlHelp
|
|
{
|
|
/// <summary>
|
|
/// The class <c>Category</c> implements methods/properties for handling an information category
|
|
/// </summary>
|
|
/// <remarks>Note: Information types and categories allow users to filter help contents.
|
|
/// They are only supported if using sitemap TOC and/or sitemap Index.</remarks>
|
|
public class Category
|
|
{
|
|
private string _name = "";
|
|
private string _description = "";
|
|
private ArrayList _infoTypes = null;
|
|
private int _referenceCount = 1;
|
|
|
|
/// <summary>
|
|
/// Standard constructor
|
|
/// </summary>
|
|
public Category() : this("","")
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Standard constructor
|
|
/// </summary>
|
|
/// <param name="name">name of the category</param>
|
|
/// <param name="description">description</param>
|
|
public Category(string name, string description) : this(name, description, new ArrayList())
|
|
{
|
|
}
|
|
/// <summary>
|
|
/// Standard constructor
|
|
/// </summary>
|
|
/// <param name="name">name of the category</param>
|
|
/// <param name="description">description</param>
|
|
/// <param name="linkedInformationTypes">Arraylist of InformationType instances which applies to this category</param>
|
|
public Category(string name, string description, ArrayList linkedInformationTypes)
|
|
{
|
|
_name = name;
|
|
_description = description;
|
|
_infoTypes = linkedInformationTypes;
|
|
}
|
|
|
|
#region Data dumping
|
|
/// <summary>
|
|
/// Dump the class data to a binary writer
|
|
/// </summary>
|
|
/// <param name="writer">writer to write the data</param>
|
|
internal void Dump(ref BinaryWriter writer)
|
|
{
|
|
writer.Write( _name );
|
|
writer.Write( _description );
|
|
|
|
writer.Write( _infoTypes.Count );
|
|
|
|
for(int i=0; i<_infoTypes.Count;i++)
|
|
{
|
|
InformationType curType = _infoTypes[i] as InformationType;
|
|
writer.Write( curType.Name );
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads the object data from a dump store
|
|
/// </summary>
|
|
/// <param name="reader">reader to read the data</param>
|
|
/// <param name="chmFile">current CHMFile instance which reads from dump</param>
|
|
internal void ReadDump(ref BinaryReader reader, CHMFile chmFile)
|
|
{
|
|
_name = reader.ReadString();
|
|
_description = reader.ReadString();
|
|
|
|
int nCnt = reader.ReadInt32();
|
|
|
|
for(int i=0; i<nCnt; i++)
|
|
{
|
|
string sITName = reader.ReadString();
|
|
|
|
InformationType linkedType = chmFile.GetInformationType( sITName );
|
|
|
|
if(linkedType != null)
|
|
{
|
|
linkedType.SetCategoryFlag(true);
|
|
_infoTypes.Add(linkedType);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Merges the lineked information types from cat into this instance
|
|
/// </summary>
|
|
/// <param name="cat">category instance</param>
|
|
internal void MergeInfoTypes(Category cat)
|
|
{
|
|
if(cat!=null)
|
|
{
|
|
if(cat.InformationTypes.Count > 0)
|
|
{
|
|
for(int i=0;i<cat.InformationTypes.Count;i++)
|
|
{
|
|
InformationType curType = cat.InformationTypes[i] as InformationType;
|
|
|
|
if(!ContainsInformationType(curType.Name))
|
|
{
|
|
curType.SetCategoryFlag(true);
|
|
_infoTypes.Add(curType);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets/Sets the reference count of this information type instance
|
|
/// </summary>
|
|
internal int ReferenceCount
|
|
{
|
|
get { return _referenceCount; }
|
|
set { _referenceCount = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets/Sets the name of the information type
|
|
/// </summary>
|
|
public string Name
|
|
{
|
|
get { return _name; }
|
|
set { _name = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets/Sets the description of the information type
|
|
/// </summary>
|
|
public string Description
|
|
{
|
|
get { return _description; }
|
|
set { _name = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets an ArrayList with the linked Information types
|
|
/// </summary>
|
|
public ArrayList InformationTypes
|
|
{
|
|
get { return _infoTypes; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a new information type to the category
|
|
/// </summary>
|
|
/// <param name="type"></param>
|
|
public void AddInformationType(InformationType type)
|
|
{
|
|
_infoTypes.Add(type);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes an information type from the category
|
|
/// </summary>
|
|
/// <param name="type"></param>
|
|
public void RemoveInformationType(InformationType type)
|
|
{
|
|
_infoTypes.Remove(type);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if the category contains an information type
|
|
/// </summary>
|
|
/// <param name="type">information type instance to check</param>
|
|
/// <returns>Return true if the information type is part of this category</returns>
|
|
public bool ContainsInformationType(InformationType type)
|
|
{
|
|
return _infoTypes.Contains(type);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if the category contains an information type
|
|
/// </summary>
|
|
/// <param name="name">name of the information type</param>
|
|
/// <returns>Return true if the information type is part of this category</returns>
|
|
public bool ContainsInformationType(string name)
|
|
{
|
|
for(int i=0;i<_infoTypes.Count;i++)
|
|
{
|
|
InformationType curType = _infoTypes[i] as InformationType;
|
|
|
|
if(curType.Name == name)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
}
|