﻿<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5">
  <PropertyGroup>
    <!-- The configuration and platform will be used to determine which
         assemblies to include from solution and project documentation
         sources -->
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
    <SchemaVersion>2.0</SchemaVersion>
    <ProjectGuid>{9cf9e0ef-9201-4fd3-a89f-bd03e481c4e5}</ProjectGuid>
    <SHFBSchemaVersion>1.9.0.0</SHFBSchemaVersion>
    <!-- AssemblyName, Name, and RootNamespace are not used by SHFB but Visual
         Studio adds them anyway -->
    <AssemblyName>Documentation</AssemblyName>
    <RootNamespace>Documentation</RootNamespace>
    <Name>Documentation</Name>
    <!-- SHFB properties -->
    <OutputPath>.\doc\</OutputPath>
    <HtmlHelpName>DotCMISDoc</HtmlHelpName>
    <Language>en-US</Language>
    <DocumentationSources>
      <DocumentationSource sourceFile="DotCMIS.csproj" xmlns="" />
    </DocumentationSources>
    <HelpTitle>Apache Chemistry DotCMIS</HelpTitle>
    <HelpFileFormat>HtmlHelp1</HelpFileFormat>
    <NamingMethod>MemberName</NamingMethod>
    <PresentationStyle>vs2005</PresentationStyle>
    <MissingTags>Summary, Parameter, Returns, TypeParameter</MissingTags>
    <ApiFilter>
      <Filter entryType="Namespace" fullName="DotCMIS.Client.Impl" isExposed="False" />
      <Filter entryType="Namespace" fullName="DotCMIS.Client.Impl.Cache" isExposed="False" />
      <Filter entryType="Namespace" fullName="DotCMIS.CMISWebServicesReference" isExposed="False" />
      <Filter entryType="Namespace" fullName="DotCMIS.Data.Extensions" isExposed="True">
        <Filter entryType="Class" fullName="DotCMIS.Data.Extensions.CmisExtensionElement" filterName="CmisExtensionElement" isExposed="False" />
        <Filter entryType="Class" fullName="DotCMIS.Data.Extensions.ExtensionsData" filterName="ExtensionsData" isExposed="False" />
      </Filter>
      <Filter entryType="Namespace" fullName="DotCMIS.Data.Impl" isExposed="False">
        <Filter entryType="Class" fullName="DotCMIS.Data.Impl.Ace" filterName="Ace" isExposed="True" />
        <Filter entryType="Class" fullName="DotCMIS.Data.Impl.Principal" filterName="Principal" isExposed="True" />
        <Filter entryType="Class" fullName="DotCMIS.Data.Impl.ContentStream" filterName="ContentStream" isExposed="True" />
      </Filter>
      <Filter entryType="Namespace" fullName="DotCMIS.Enums" isExposed="True">
        <Filter entryType="Class" fullName="DotCMIS.Enums.CmisValue" filterName="CmisValue" isExposed="False" />
        <Filter entryType="Class" fullName="DotCMIS.Enums.CmisValueAttribute" filterName="CmisValueAttribute" isExposed="False" />
      </Filter>
    </ApiFilter>
    <SelfBranded>True</SelfBranded>
    <FeedbackEMailLinkText>Apache Chemistry developer mailing list</FeedbackEMailLinkText>
    <FeedbackEMailAddress>dev%40chemistry.apache.org</FeedbackEMailAddress>
    <CopyrightText>Apache Software Foundation</CopyrightText>
    <CopyrightHref>http://www.apache.org</CopyrightHref>
    <BinaryTOC>True</BinaryTOC>
    <KeepLogFile>False</KeepLogFile>
    <CleanIntermediates>True</CleanIntermediates>
  </PropertyGroup>
  <!-- There are no properties for these groups.  AnyCPU needs to appear in
       order for Visual Studio to perform the build.  The others are optional
       common platform types that may appear. -->
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|Win32' ">
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|Win32' ">
  </PropertyGroup>
  <!-- Import the SHFB build targets -->
  <Import Project="$(SHFBROOT)\SandcastleHelpFileBuilder.targets" />
</Project>