PublishingWeb.xml

<Type Name="PublishingWeb" FullName="Microsoft.SharePoint.Publishing.PublishingWeb">
  <TypeSignature Language="C#" Value="public sealed class PublishingWeb" />
  <TypeSignature Language="ILAsm" Value=".class public auto ansi sealed beforefieldinit PublishingWeb extends System.Object" />
  <TypeSignature Language="DocId" Value="T:Microsoft.SharePoint.Publishing.PublishingWeb" />
  <TypeSignature Language="VB.NET" Value="Public NotInheritable Class PublishingWeb" />
  <TypeSignature Language="C++ CLI" Value="public ref class PublishingWeb sealed" />
  <TypeSignature Language="F#" Value="type PublishingWeb = class" />
  <AssemblyInfo>
    <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
    <AssemblyVersion>15.0.0.0</AssemblyVersion>
  </AssemblyInfo>
  <Base>
    <BaseTypeName>System.Object</BaseTypeName>
  </Base>
  <Interfaces />
  <Attributes>
    <Attribute>
      <AttributeName>Microsoft.SharePoint.Client.ClientCallableType(ClientLibraryTargets=Microsoft.SharePoint.Client.ClientLibraryTargets.NonRESTful, FactoryType=typeof(Microsoft.SharePoint.Publishing.Internal.PublishingClientObjectFactory), ObjectIdentityPropertyName="CanonicalId", ServerTypeId="55927360-235B-4ace-9DCF-C574D6E517EA")</AttributeName>
    </Attribute>
  </Attributes>
  <Docs>
    <summary>Provides publishing behavior for an <see cref="T:Microsoft.SharePoint.SPWeb" /> instance that supports publishing. </summary>
    <remarks>
      <para>The <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> class provides publishing-specific behavior for an <see cref="T:Microsoft.SharePoint.SPWeb" /> that supports publishing, including access to child <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> and <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> instances, variations support, navigation settings, <see cref="T:Microsoft.SharePoint.Publishing.PageLayout" /> and Web template restrictions, and Welcome page settings. This class wraps an <see cref="T:Microsoft.SharePoint.SPWeb" /> instance that has the publishing feature activated.</para>
      <para>Instantiate this class by using the static <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetPublishingWeb(Microsoft.SharePoint.SPWeb)" /> method or by retrieving it from a <see cref="T:Microsoft.SharePoint.Publishing.PublishingWebCollection" /> collection.</para>
      <para>The <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> class wraps the <see cref="T:Microsoft.SharePoint.SPWeb" /> class. It also directly exposes the underlying <see cref="T:Microsoft.SharePoint.SPWeb" /> through the <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.Web" /> property so that additional <see cref="T:Microsoft.SharePoint.SPWeb" /> functionality can be easily accessed.</para>
      <para>The members exposed by this class are optimized for the current <see cref="T:Microsoft.SharePoint.SPSite" /> context. Trying to use methods in the <b>PublishingWeb</b> class to return objects from a different site collection can result in unexpected behaviors, and doing so is not supported.</para>
      <para />
    </remarks>
    <example>
      <code>using System;
using System.IO;
using System.Web;
using Microsoft.SharePoint;
using Microsoft.SharePoint.Publishing;

namespace Microsoft.SDK.SharePoint.Samples.PublishingWebSample
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("--------------------------------------");
            Console.WriteLine("Starting sample tests execution...");

            #region  PublishingWeb example

            //
            // ---------------------------------------------------------------------------------------
            // PublishingWeb example
            // ---------------------------------------------------------------------------------------
            // Passing the full url of a PublishingWeb.
            //
            // To compile add additional references to 
            // - System.Web.dll
            // - Microsoft.SharePoint.dll
            // - Microsoft.SharePoint.Publishing.dll
            //

            //
            // You need to pass one parameter which is the full url of a PublishingWeb.
            //
            if (args.Length &amp;lt; 1)
            {
                Console.WriteLine("--------------------------------------");
                Console.WriteLine("You need to pass the full url of a PublishingWeb.");
                FinishSampleTest();
                return;
            }

            string url = args[0];

            //
            // The url must be in the correct format.
            //
            Uri webUri = null;
            if (!Uri.TryCreate(url, UriKind.Absolute, out webUri))
            {
                Console.WriteLine("--------------------------------------");
                Console.WriteLine("The url is not in correct format.");
                FinishSampleTest();
                return;
            }

            SPSite site = null;
            try
            {
                site = new SPSite(url);
            }
            catch (FileNotFoundException)
            {
                Console.WriteLine("--------------------------------------");
                Console.WriteLine("The url is not a valid PublishingWeb.");
                FinishSampleTest();
                return;
            }

            using (SPWeb web = site.OpenWeb(HttpUtility.UrlDecode(webUri.AbsolutePath)))
            {
                PublishingWeb area = null;

                //
                // The url must be the full url of a PublishingWeb.
                //
                if (!web.Exists || !PublishingWeb.IsPublishingWeb(web))
                {
                    Console.WriteLine("--------------------------------------");
                    Console.WriteLine("The url is not a valid PublishingWeb.");
                    FinishSampleTest();
                    return;
                }

                area = PublishingWeb.GetPublishingWeb(web);
                Console.WriteLine("--------------------------------------");
                Console.WriteLine("Print out some properties of the current PublishingWeb:");
                PrintPublishingWebProperty(area);


                //
                // Create a PublishingPage examples: 
                //

                Console.WriteLine("--------------------------------------");
                Console.WriteLine("Adding the 1st PublishingPage...");

                //
                // Create a new PublishingPage using default PageLayout.
                // 
                PublishingPage page1 = area.AddPublishingPage();
                Console.WriteLine("Sucessfully added the 1st PublishingPage.");

                // 
                // Check in the 1st PublishingPage.
                //
                if (page1.ListItem.File.CheckOutType != SPFile.SPCheckOutType.None)
                {
                    Console.WriteLine("Check-in the 1st PublishingPage...");
                    page1.CheckIn("The PublishingPage page1 1st check in.");
                    Console.WriteLine("Successfully checked-in the 1st PublishingPage.");
                }

                Console.WriteLine("--------------------------------------");
                Console.WriteLine("Try to add the 2nd PublishingPage using the default PageLayout of the PublishingWeb...");
                PageLayout defaultPageLayout = area.DefaultPageLayout;
                PublishingPage page2 = null;

                string page2Url = area.Web.Url + "/Pages/Page2.aspx";

                // 
                //  Get a PublishingPage by its url.
                // 
                Console.WriteLine("--------------------------------------");
                Console.WriteLine("First try to see whether the PublisingPage with the same Url already exists:");
                page2 = area.GetPublishingPage(page2Url);
                Console.WriteLine("The Url of the PublishingPage is :" + page2Url);

                if (page2 != null)
                {
                    Console.WriteLine("The PublishingPage with Url {0} already exists.", page2Url);
                }
                else
                {
                    Console.WriteLine("The PublishingPage with Url {0} does not exist.", page2Url);
                    Console.WriteLine("Adding the 2nd PublishingPage...");
                    page2 = area.AddPublishingPage("Page2.aspx", defaultPageLayout);
                    Console.WriteLine("Sucessfully added the 2nd PublishingPage.");

                    // 
                    // Check in the 2nd PublishingPage.
                    //
                    if (page2.ListItem.File.CheckOutType != SPFile.SPCheckOutType.None)
                    {
                        Console.WriteLine("Check-in the 2nd PublishingPage...");
                        page2.CheckIn("The PublishingPage page2 1st check in.");
                        Console.WriteLine("Successfully checked-in the 2nd PublishingPage.");
                    }
                }

                //
                // Get a PublishingPage examples: 
                //

                // 
                // Get a PublishingPage by its ID.
                // 
                Console.WriteLine("--------------------------------------");
                Console.WriteLine("Try to retrieve the PublisingPage by its ID:");
                int page1ID = page1.ListItem.ID;
                Console.WriteLine("The ID of the PublishingPage is :" + page1ID);
                PublishingPage page3 = area.GetPublishingPage(page1ID);

                // 
                //  Check out the PublishingPage, and edit its properties, then check it in.
                //
                if (page3 != null)
                {
                    Console.WriteLine("The PublishingPage with ID {0} is found.", page1ID);

                    if (page3.ListItem.File.CheckOutType == SPFile.SPCheckOutType.None)
                    {
                        Console.WriteLine("Check-out the PublishingPage...");
                        page3.CheckOut();
                        Console.WriteLine("Successfully checked-out the PublishingPage.");
                    }

                    Console.WriteLine("Updating the title of the PublishingPage to be 'Page3'...");
                    page3.Title = "Page3";
                    page3.Update();
                    Console.WriteLine("Successfully updated the PublishingPage.");

                    if (page3.ListItem.File.CheckOutType != SPFile.SPCheckOutType.None)
                    {
                        Console.WriteLine("Check-in the PublishingPage...");
                        page3.CheckIn("Update the title to be Page3.");
                        Console.WriteLine("Successfully checked-in the PublishingPage.");
                    }
                }

                //
                // Iterate the whole PublishingPage List.
                //
                Console.WriteLine("--------------------------------------");
                Console.WriteLine("Iterate through the Pages library:");
                area.IterateOverAllPages(
                 delegate(PublishingPage page)
                 {
                     PrintPageUrl(page);
                 });
            }

            if (site != null)
            {
                site.Close();
            }

            #endregion

            Console.WriteLine("--------------------------------------");
            Console.WriteLine("Sample tests completed.");

            FinishSampleTest();
        }

        static void PrintPublishingWebProperty(PublishingWeb area)
        {
            PrintPublishingWebProperty(area, "ImagesLibrary", area.ImagesLibrary.Title);
            PrintPublishingWebProperty(area, "DocumentsLibrary", area.DocumentsLibrary.Title);
        }

        static void PrintPublishingWebProperty(PublishingWeb area, string propertyName, string propertyValue)
        {
            Console.WriteLine("The property {0} of PublishingWeb {1} is: {2}.", propertyName, area.Name, propertyValue);
        }

        static void PrintPageUrl(PublishingPage page)
        {
            Console.WriteLine("The Url of PublishingPage " + page.Name + " is " + page.Url + ".");
        }

        static void FinishSampleTest()
        {
            Console.WriteLine("--------------------------------------");
            Console.WriteLine("Press any key to continue...");
            Console.ReadKey();
        }
    }
}</code>
      <code>// Access the Pages list information without creating a PublishingWeb
// object.
using (SPSite site = new SPSite("http://myteam/team/"))
{
    using (SPWeb web = site.OpenWeb())
    {
        if (PublishingWeb.IsPublishingWeb(web))
        {
// Get the ID for the Pages list if we 
// know that Web is a PublishingWeb.
Guid pagesListId = PublishingWeb.GetPagesListId(web);

// Get the list by way of the ID.
SPList pagesList = web.Lists[pagesListId];

// Get the Pages list URL. Note:
// PublishingWeb.GetPagesListName(web)
// is equivalent to pagesList.RootFolder.Url.
string pagesListUrl = PublishingWeb.GetPagesListName(web);
        }
        else
        {
// If the SPWeb is not a PublishingWeb, 
// then GetPagesListName returns the URL
// that would be used by the Pages list 
// if the Publishing feature were to be
// activated.
string pagesListName = PublishingWeb.GetPagesListName(web);
        }
    }
}

// You can also create a PublishingWeb and access
// the properties from it.
using (SPSite site = new SPSite("http://myteam/"))
{
    using (SPWeb web = site.OpenWeb())
    {
        PublishingWeb publishingWeb = PublishingWeb.GetPublishingWeb(web);

        // Get the ID for the Pages list.
        Guid pagesListId = publishingWeb.PagesListId;

        SPList pagesList = publishingWeb.PagesList;

        // The PublishingWeb.PagesListName is equivalent 
        // to PublishingWeb.PagesList.RootFolder.Url.
        string pagesListUrl = publishingWeb.PagesListName;
    }
}</code>
      <code>' Access the Pages list information without creating a PublishingWeb
' object.
Using site As New SPSite("http://myteam/team/")
    Using web As SPWeb = site.OpenWeb()
        If PublishingWeb.IsPublishingWeb(web) Then
' Get the ID for the Pages list if we 
' know that Web is a PublishingWeb.
Dim pagesListId As Guid = PublishingWeb.GetPagesListId(web)

' Get the list by way of the ID.
Dim pagesList As SPList = web.Lists(pagesListId)

' Get the Pages list URL. Note:
' PublishingWeb.GetPagesListName(web)
' is equivalent to pagesList.RootFolder.Url.
Dim pagesListUrl As String = PublishingWeb.GetPagesListName(web)
        Else
' If the SPWeb is not a PublishingWeb, 
' then GetPagesListName returns the URL
' that would be used by the Pages list 
' if the Publishing feature were to be
' activated.
Dim pagesListName As String = PublishingWeb.GetPagesListName(web)
        End If
    End Using
End Using

' You can also create a PublishingWeb and access
' the properties from it.
Using site As New SPSite("http://myteam/")
    Using web As SPWeb = site.OpenWeb()
        Dim publishingWeb As PublishingWeb = PublishingWeb.GetPublishingWeb(web)

        ' Get the ID for the Pages list.
        Dim pagesListId As Guid = publishingWeb.PagesListId

        Dim pagesList As SPList = publishingWeb.PagesList

        ' The PublishingWeb.PagesListName is equivalent 
        ' to PublishingWeb.PagesList.RootFolder.Url.
        Dim pagesListUrl As String = publishingWeb.PagesListName
    End Using
End Using</code>
    </example>
  </Docs>
  <Members>
    <Member MemberName="AddPublishingPage">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.PublishingPage AddPublishingPage ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.SharePoint.Publishing.PublishingPage AddPublishingPage() cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.AddPublishingPage" />
      <MemberSignature Language="VB.NET" Value="Public Function AddPublishingPage () As PublishingPage" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; Microsoft::SharePoint::Publishing::PublishingPage ^ AddPublishingPage();" />
      <MemberSignature Language="F#" Value="member this.AddPublishingPage : unit -&gt; Microsoft.SharePoint.Publishing.PublishingPage" Usage="publishingWeb.AddPublishingPage " />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PublishingPage</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Creates a new <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> object in the <b>PublishingWeb</b>.</summary>
        <returns>Returns <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" />.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="AddPublishingPage">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.PublishingPage AddPublishingPage (string name, Microsoft.SharePoint.Publishing.PageLayout layout);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.SharePoint.Publishing.PublishingPage AddPublishingPage(string name, class Microsoft.SharePoint.Publishing.PageLayout layout) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.AddPublishingPage(System.String,Microsoft.SharePoint.Publishing.PageLayout)" />
      <MemberSignature Language="VB.NET" Value="Public Function AddPublishingPage (name As String, layout As PageLayout) As PublishingPage" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; Microsoft::SharePoint::Publishing::PublishingPage ^ AddPublishingPage(System::String ^ name, Microsoft::SharePoint::Publishing::PageLayout ^ layout);" />
      <MemberSignature Language="F#" Value="member this.AddPublishingPage : string * Microsoft.SharePoint.Publishing.PageLayout -&gt; Microsoft.SharePoint.Publishing.PublishingPage" Usage="publishingWeb.AddPublishingPage (name, layout)" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PublishingPage</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="name" Type="System.String" />
        <Parameter Name="layout" Type="Microsoft.SharePoint.Publishing.PageLayout" />
      </Parameters>
      <Docs>
        <param name="name">The name of the new <b>PublishingPage</b> object.</param>
        <param name="layout">The layout template (<see cref="T:Microsoft.SharePoint.SPFile" />) used to render the new <b>PublishingPage</b> object.</param>
        <summary>Creates a new <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> object in the <b>PublishingWeb</b>.</summary>
        <returns>Returns <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" />.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="AddPublishingPage">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.PublishingPage AddPublishingPage (string name, Microsoft.SharePoint.Publishing.PageLayout layout, Microsoft.SharePoint.SPFolder folder);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.SharePoint.Publishing.PublishingPage AddPublishingPage(string name, class Microsoft.SharePoint.Publishing.PageLayout layout, class Microsoft.SharePoint.SPFolder folder) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.AddPublishingPage(System.String,Microsoft.SharePoint.Publishing.PageLayout,Microsoft.SharePoint.SPFolder)" />
      <MemberSignature Language="VB.NET" Value="Public Function AddPublishingPage (name As String, layout As PageLayout, folder As SPFolder) As PublishingPage" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; Microsoft::SharePoint::Publishing::PublishingPage ^ AddPublishingPage(System::String ^ name, Microsoft::SharePoint::Publishing::PageLayout ^ layout, Microsoft::SharePoint::SPFolder ^ folder);" />
      <MemberSignature Language="F#" Value="member this.AddPublishingPage : string * Microsoft.SharePoint.Publishing.PageLayout * Microsoft.SharePoint.SPFolder -&gt; Microsoft.SharePoint.Publishing.PublishingPage" Usage="publishingWeb.AddPublishingPage (name, layout, folder)" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PublishingPage</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="name" Type="System.String" />
        <Parameter Name="layout" Type="Microsoft.SharePoint.Publishing.PageLayout" />
        <Parameter Name="folder" Type="Microsoft.SharePoint.SPFolder" />
      </Parameters>
      <Docs>
        <param name="name">The name of the new <b>PublishingPage</b> object.</param>
        <param name="layout">The layout template (<see cref="T:Microsoft.SharePoint.SPFile" />) used to render the new <b>PublishingPage</b> object.</param>
        <param name="folder">The layout folder (<see cref="T:Microsoft.SharePoint.SPFolder" />) object that is used to store the new <b>PublishingPage</b> object.</param>
        <summary>Creates a new <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> object in the <b>PublishingWeb</b>.</summary>
        <returns>Returns <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" />.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="AddPublishingPage">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.PublishingPage AddPublishingPage (string newPageName, Microsoft.SharePoint.SPFile fileToConvert, Guid transformerId, Microsoft.SharePoint.Publishing.PageConversionPriority priority);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.SharePoint.Publishing.PublishingPage AddPublishingPage(string newPageName, class Microsoft.SharePoint.SPFile fileToConvert, valuetype System.Guid transformerId, valuetype Microsoft.SharePoint.Publishing.PageConversionPriority priority) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.AddPublishingPage(System.String,Microsoft.SharePoint.SPFile,System.Guid,Microsoft.SharePoint.Publishing.PageConversionPriority)" />
      <MemberSignature Language="VB.NET" Value="Public Function AddPublishingPage (newPageName As String, fileToConvert As SPFile, transformerId As Guid, priority As PageConversionPriority) As PublishingPage" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; Microsoft::SharePoint::Publishing::PublishingPage ^ AddPublishingPage(System::String ^ newPageName, Microsoft::SharePoint::SPFile ^ fileToConvert, Guid transformerId, Microsoft::SharePoint::Publishing::PageConversionPriority priority);" />
      <MemberSignature Language="F#" Value="member this.AddPublishingPage : string * Microsoft.SharePoint.SPFile * Guid * Microsoft.SharePoint.Publishing.PageConversionPriority -&gt; Microsoft.SharePoint.Publishing.PublishingPage" Usage="publishingWeb.AddPublishingPage (newPageName, fileToConvert, transformerId, priority)" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.Obsolete("This member is obsolete - use the specialized Office services instead for conversions", false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PublishingPage</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="newPageName" Type="System.String" />
        <Parameter Name="fileToConvert" Type="Microsoft.SharePoint.SPFile" />
        <Parameter Name="transformerId" Type="System.Guid" />
        <Parameter Name="priority" Type="Microsoft.SharePoint.Publishing.PageConversionPriority" />
      </Parameters>
      <Docs>
        <param name="newPageName">The name for the new <b>PublishingPage</b> object.</param>
        <param name="fileToConvert">The file to convert to get the page content.</param>
        <param name="transformerId">The document transformer ID to use for the conversion.</param>
        <param name="priority">Priority level for the conversion.</param>
        <summary>Creates a new <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> object in the <b>PublishingWeb</b>.</summary>
        <returns>Returns <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" />.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="AddPublishingPage">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.PublishingPage AddPublishingPage (string newPageName, Microsoft.SharePoint.SPFile fileToConvert, Guid transformerId, Microsoft.SharePoint.Publishing.PageConversionPriority priority, Microsoft.SharePoint.SPFolder folder);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.SharePoint.Publishing.PublishingPage AddPublishingPage(string newPageName, class Microsoft.SharePoint.SPFile fileToConvert, valuetype System.Guid transformerId, valuetype Microsoft.SharePoint.Publishing.PageConversionPriority priority, class Microsoft.SharePoint.SPFolder folder) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.AddPublishingPage(System.String,Microsoft.SharePoint.SPFile,System.Guid,Microsoft.SharePoint.Publishing.PageConversionPriority,Microsoft.SharePoint.SPFolder)" />
      <MemberSignature Language="VB.NET" Value="Public Function AddPublishingPage (newPageName As String, fileToConvert As SPFile, transformerId As Guid, priority As PageConversionPriority, folder As SPFolder) As PublishingPage" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; Microsoft::SharePoint::Publishing::PublishingPage ^ AddPublishingPage(System::String ^ newPageName, Microsoft::SharePoint::SPFile ^ fileToConvert, Guid transformerId, Microsoft::SharePoint::Publishing::PageConversionPriority priority, Microsoft::SharePoint::SPFolder ^ folder);" />
      <MemberSignature Language="F#" Value="member this.AddPublishingPage : string * Microsoft.SharePoint.SPFile * Guid * Microsoft.SharePoint.Publishing.PageConversionPriority * Microsoft.SharePoint.SPFolder -&gt; Microsoft.SharePoint.Publishing.PublishingPage" Usage="publishingWeb.AddPublishingPage (newPageName, fileToConvert, transformerId, priority, folder)" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.Obsolete("This member is obsolete - use the specialized Office services instead for conversions", false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PublishingPage</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="newPageName" Type="System.String" />
        <Parameter Name="fileToConvert" Type="Microsoft.SharePoint.SPFile" />
        <Parameter Name="transformerId" Type="System.Guid" />
        <Parameter Name="priority" Type="Microsoft.SharePoint.Publishing.PageConversionPriority" />
        <Parameter Name="folder" Type="Microsoft.SharePoint.SPFolder" />
      </Parameters>
      <Docs>
        <param name="newPageName">The name for the new <b>PublishingPage</b> object.</param>
        <param name="fileToConvert">The name of the file to convert to get the page content.</param>
        <param name="transformerId">The document transformer ID to use for the document conversion.</param>
        <param name="priority">The priority level of the conversion.</param>
        <param name="folder">The folder that contains this new <b>PublishingPage</b> object.</param>
        <summary>Creates a new <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> object in the <b>PublishingWeb</b>.</summary>
        <returns>Returns <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" />.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="AddPublishingPage">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.PublishingPage AddPublishingPage (string newPageName, Microsoft.SharePoint.SPFile fileToConvert, Guid transformerId, string configXml, Microsoft.SharePoint.Publishing.PageConversionPriority priority);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.SharePoint.Publishing.PublishingPage AddPublishingPage(string newPageName, class Microsoft.SharePoint.SPFile fileToConvert, valuetype System.Guid transformerId, string configXml, valuetype Microsoft.SharePoint.Publishing.PageConversionPriority priority) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.AddPublishingPage(System.String,Microsoft.SharePoint.SPFile,System.Guid,System.String,Microsoft.SharePoint.Publishing.PageConversionPriority)" />
      <MemberSignature Language="VB.NET" Value="Public Function AddPublishingPage (newPageName As String, fileToConvert As SPFile, transformerId As Guid, configXml As String, priority As PageConversionPriority) As PublishingPage" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; Microsoft::SharePoint::Publishing::PublishingPage ^ AddPublishingPage(System::String ^ newPageName, Microsoft::SharePoint::SPFile ^ fileToConvert, Guid transformerId, System::String ^ configXml, Microsoft::SharePoint::Publishing::PageConversionPriority priority);" />
      <MemberSignature Language="F#" Value="member this.AddPublishingPage : string * Microsoft.SharePoint.SPFile * Guid * string * Microsoft.SharePoint.Publishing.PageConversionPriority -&gt; Microsoft.SharePoint.Publishing.PublishingPage" Usage="publishingWeb.AddPublishingPage (newPageName, fileToConvert, transformerId, configXml, priority)" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PublishingPage</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="newPageName" Type="System.String" />
        <Parameter Name="fileToConvert" Type="Microsoft.SharePoint.SPFile" />
        <Parameter Name="transformerId" Type="System.Guid" />
        <Parameter Name="configXml" Type="System.String" />
        <Parameter Name="priority" Type="Microsoft.SharePoint.Publishing.PageConversionPriority" />
      </Parameters>
      <Docs>
        <param name="newPageName">The name for the new <b>PublishingPage</b> object.</param>
        <param name="fileToConvert">The name of the file to convert to get the page content.</param>
        <param name="transformerId">The document transformer ID to use for the document conversion.</param>
        <param name="configXml">The settings to use for the conversion.</param>
        <param name="priority">The priority level of the conversion.</param>
        <summary>Creates a new <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> object in the <b>PublishingWeb</b>.</summary>
        <returns>Returns <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" />.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="AddPublishingPage">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.PublishingPage AddPublishingPage (string newPageName, Microsoft.SharePoint.SPFile fileToConvert, Guid transformerId, string configXml, Microsoft.SharePoint.Publishing.PageConversionPriority priority, Microsoft.SharePoint.SPFolder folder);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.SharePoint.Publishing.PublishingPage AddPublishingPage(string newPageName, class Microsoft.SharePoint.SPFile fileToConvert, valuetype System.Guid transformerId, string configXml, valuetype Microsoft.SharePoint.Publishing.PageConversionPriority priority, class Microsoft.SharePoint.SPFolder folder) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.AddPublishingPage(System.String,Microsoft.SharePoint.SPFile,System.Guid,System.String,Microsoft.SharePoint.Publishing.PageConversionPriority,Microsoft.SharePoint.SPFolder)" />
      <MemberSignature Language="VB.NET" Value="Public Function AddPublishingPage (newPageName As String, fileToConvert As SPFile, transformerId As Guid, configXml As String, priority As PageConversionPriority, folder As SPFolder) As PublishingPage" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; Microsoft::SharePoint::Publishing::PublishingPage ^ AddPublishingPage(System::String ^ newPageName, Microsoft::SharePoint::SPFile ^ fileToConvert, Guid transformerId, System::String ^ configXml, Microsoft::SharePoint::Publishing::PageConversionPriority priority, Microsoft::SharePoint::SPFolder ^ folder);" />
      <MemberSignature Language="F#" Value="member this.AddPublishingPage : string * Microsoft.SharePoint.SPFile * Guid * string * Microsoft.SharePoint.Publishing.PageConversionPriority * Microsoft.SharePoint.SPFolder -&gt; Microsoft.SharePoint.Publishing.PublishingPage" Usage="publishingWeb.AddPublishingPage (newPageName, fileToConvert, transformerId, configXml, priority, folder)" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PublishingPage</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="newPageName" Type="System.String" />
        <Parameter Name="fileToConvert" Type="Microsoft.SharePoint.SPFile" />
        <Parameter Name="transformerId" Type="System.Guid" />
        <Parameter Name="configXml" Type="System.String" />
        <Parameter Name="priority" Type="Microsoft.SharePoint.Publishing.PageConversionPriority" />
        <Parameter Name="folder" Type="Microsoft.SharePoint.SPFolder" />
      </Parameters>
      <Docs>
        <param name="newPageName">The name for the new <b>PublishingPage</b> object.</param>
        <param name="fileToConvert">The name of the file to convert to get the page content.</param>
        <param name="transformerId">The document transformer ID to use for the document conversion.</param>
        <param name="configXml">The settings to use for the conversion.</param>
        <param name="priority">The priority level of the conversion.</param>
        <param name="folder">The folder that contains this new <b>PublishingPage</b> object.</param>
        <summary>Creates a new <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> object in the <b>PublishingWeb</b>.</summary>
        <returns>Returns <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" />.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="AllowAllPageLayouts">
      <MemberSignature Language="C#" Value="public void AllowAllPageLayouts (bool resetAllSubsitesToInherit);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void AllowAllPageLayouts(bool resetAllSubsitesToInherit) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.AllowAllPageLayouts(System.Boolean)" />
      <MemberSignature Language="VB.NET" Value="Public Sub AllowAllPageLayouts (resetAllSubsitesToInherit As Boolean)" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; void AllowAllPageLayouts(bool resetAllSubsitesToInherit);" />
      <MemberSignature Language="F#" Value="member this.AllowAllPageLayouts : bool -&gt; unit" Usage="publishingWeb.AllowAllPageLayouts resetAllSubsitesToInherit" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="resetAllSubsitesToInherit" Type="System.Boolean" />
      </Parameters>
      <Docs>
        <param name="resetAllSubsitesToInherit">This Boolean parameter indicates whether the available <see cref="T:Microsoft.SharePoint.Publishing.PageLayout" /> objects are pushed down to all subsites.</param>
        <summary>Resets the available <see cref="T:Microsoft.SharePoint.Publishing.PageLayout" /> objects on this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> to the complete set of layouts.</summary>
        <remarks>
          <para>After calling this method, the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetAvailablePageLayouts" /> method returns the complete set of <see cref="T:Microsoft.SharePoint.Publishing.PageLayout" /> objects. The <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.IsInheritingAvailablePageLayouts" /> property is set to <b>false</b>. The <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.IsAllowingAllPageLayouts" /> property is set to True.</para>
          <para>After calling this method, you should call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method to save the changes.</para>
          <para>
            <b>Note</b>: This operation is synchronous.</para>
          <para />
        </remarks>
        <exception cref="System.UnauthorizedAccessException">The current user does not have sufficient permissions to perform this action.</exception>
      </Docs>
    </Member>
    <Member MemberName="AllowAllWebTemplates">
      <MemberSignature Language="C#" Value="public void AllowAllWebTemplates (bool resetAllSubsitesToInherit);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void AllowAllWebTemplates(bool resetAllSubsitesToInherit) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.AllowAllWebTemplates(System.Boolean)" />
      <MemberSignature Language="VB.NET" Value="Public Sub AllowAllWebTemplates (resetAllSubsitesToInherit As Boolean)" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; void AllowAllWebTemplates(bool resetAllSubsitesToInherit);" />
      <MemberSignature Language="F#" Value="member this.AllowAllWebTemplates : bool -&gt; unit" Usage="publishingWeb.AllowAllWebTemplates resetAllSubsitesToInherit" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="resetAllSubsitesToInherit" Type="System.Boolean" />
      </Parameters>
      <Docs>
        <param name="resetAllSubsitesToInherit">This Boolean parameter indicates whether the available Web templates should be pushed down to all subsites.</param>
        <summary>Resets the available Web templates on this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object to the complete set of Web templates.</summary>
        <remarks>
          <para>After calling this method, the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetAvailableWebTemplates(System.UInt32)" /> method returns the complete set of Web templates for a given language. The <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.IsInheritingAvailableWebTemplates" /> property is set to <b>false</b>. The <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.IsAllowingAllWebTemplates" /> property is set to True.</para>
          <para>After calling this method, you should call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method to save changes. </para>
          <para>
            <b>Note</b>: This operation is synchronous.</para>
          <para />
        </remarks>
        <exception cref="Microsoft.SharePoint.SPException">The available Web template property pushdown failed for some Web sites.</exception>
        <exception cref="System.UnauthorizedAccessException">The current user does not have sufficient permissions to perform this action.</exception>
      </Docs>
    </Member>
    <Member MemberName="AlternateCssUrl">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.InheritableStringProperty AlternateCssUrl { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.SharePoint.Publishing.InheritableStringProperty AlternateCssUrl" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.AlternateCssUrl" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property AlternateCssUrl As InheritableStringProperty" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property Microsoft::SharePoint::Publishing::InheritableStringProperty ^ AlternateCssUrl { Microsoft::SharePoint::Publishing::InheritableStringProperty ^ get(); };" />
      <MemberSignature Language="F#" Value="member this.AlternateCssUrl : Microsoft.SharePoint.Publishing.InheritableStringProperty" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.AlternateCssUrl" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.InheritableStringProperty</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets the URL that points to the alternate cascading style sheets (CSS) file for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>The URL that points to the alternate CSS file associated with this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="AnonymousPageCacheProfileId">
      <MemberSignature Language="C#" Value="public int AnonymousPageCacheProfileId { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance int32 AnonymousPageCacheProfileId" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.AnonymousPageCacheProfileId" />
      <MemberSignature Language="VB.NET" Value="Public Property AnonymousPageCacheProfileId As Integer" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property int AnonymousPageCacheProfileId { int get(); void set(int value); };" />
      <MemberSignature Language="F#" Value="member this.AnonymousPageCacheProfileId : int with get, set" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.AnonymousPageCacheProfileId" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets or sets the identifier (ID) of the ASP.NET output cache profile for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>An integer representing the <paramref name="ID" /> of the cache profile. A value of <paramref name="-1" /> indicates that the profile should be inherited from a parent <b>PublishingWeb</b> object if possible.</value>
        <remarks>
          <para>Use this property to determine if and how <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects that are contained by the <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> class should be cached in the ASP.NET output cache.</para>
          <para>To save changes after setting this property, call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="Audience">
      <MemberSignature Language="C#" Value="public string Audience { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance string Audience" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.Audience" />
      <MemberSignature Language="VB.NET" Value="Public Property Audience As String" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property System::String ^ Audience { System::String ^ get(); void set(System::String ^ value); };" />
      <MemberSignature Language="F#" Value="member this.Audience : string with get, set" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.Audience" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets or sets a string representing the audience whom this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> targets.</summary>
        <value>A string representing the audience whom this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> targets.To save changes after setting this property, call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="AuthenticatedPageCacheProfileId">
      <MemberSignature Language="C#" Value="public int AuthenticatedPageCacheProfileId { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance int32 AuthenticatedPageCacheProfileId" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.AuthenticatedPageCacheProfileId" />
      <MemberSignature Language="VB.NET" Value="Public Property AuthenticatedPageCacheProfileId As Integer" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property int AuthenticatedPageCacheProfileId { int get(); void set(int value); };" />
      <MemberSignature Language="F#" Value="member this.AuthenticatedPageCacheProfileId : int with get, set" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.AuthenticatedPageCacheProfileId" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets or sets the identifier (ID) of the authenticated page output cache profile for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>An integer representing the ID of the cache profile. A value of <paramref name="-1" /> indicates that the profile should be inherited from a parent <b>PublishingWeb</b> object if possible.</value>
        <remarks>
          <para>Use this property to determine if and how <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects that are contained by the <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object should be cached in the ASP.NET output cache for authenticated users.</para>
          <para>To save changes after setting this property, call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="Close">
      <MemberSignature Language="C#" Value="public void Close ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void Close() cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.Close" />
      <MemberSignature Language="VB.NET" Value="Public Sub Close ()" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; void Close();" />
      <MemberSignature Language="F#" Value="member this.Close : unit -&gt; unit" Usage="publishingWeb.Close " />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Closes the wrapped <see cref="T:Microsoft.SharePoint.SPWeb" /> object if it was instantiated internally.</summary>
        <remarks>
          <para>To close the underlying wrapped <see cref="T:Microsoft.SharePoint.SPWeb" /> object, call the <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb.Web.Close" /> method instead of this one. This method only closes the underlying <see cref="T:Microsoft.SharePoint.SPWeb" /> if it was instantiated internally.</para>
          <para>After calling this method, you should call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method to save changes.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="CreatedBy">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.SPUser CreatedBy { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.SharePoint.SPUser CreatedBy" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.CreatedBy" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property CreatedBy As SPUser" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property Microsoft::SharePoint::SPUser ^ CreatedBy { Microsoft::SharePoint::SPUser ^ get(); };" />
      <MemberSignature Language="F#" Value="member this.CreatedBy : Microsoft.SharePoint.SPUser" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.CreatedBy" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.SPUser</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets the <see cref="T:Microsoft.SharePoint.SPUser" /> who created this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>The <see cref="T:Microsoft.SharePoint.SPUser" /> who created this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />.</value>
        <remarks>
          <para>This property wraps the <see cref="P:Microsoft.SharePoint.SPWeb.Author" />.property.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="CreatedDate">
      <MemberSignature Language="C#" Value="public DateTime CreatedDate { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance valuetype System.DateTime CreatedDate" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.CreatedDate" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property CreatedDate As DateTime" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property DateTime CreatedDate { DateTime get(); };" />
      <MemberSignature Language="F#" Value="member this.CreatedDate : DateTime" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.CreatedDate" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.DateTime</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets the date and time that this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> was created.</summary>
        <value>The date and time that this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> was created.</value>
        <remarks>
          <para>This property wraps the <see cref="P:Microsoft.SharePoint.SPWeb.Created" /> property.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="CustomMasterUrl">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.InheritableStringProperty CustomMasterUrl { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.SharePoint.Publishing.InheritableStringProperty CustomMasterUrl" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.CustomMasterUrl" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property CustomMasterUrl As InheritableStringProperty" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property Microsoft::SharePoint::Publishing::InheritableStringProperty ^ CustomMasterUrl { Microsoft::SharePoint::Publishing::InheritableStringProperty ^ get(); };" />
      <MemberSignature Language="F#" Value="member this.CustomMasterUrl : Microsoft.SharePoint.Publishing.InheritableStringProperty" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.CustomMasterUrl" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.InheritableStringProperty</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets the custom master URL for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>The custom master URL for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</value>
        <remarks>
          <para>This value may be inherited.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="DefaultDefaultPageName">
      <MemberSignature Language="C#" Value="public static string DefaultDefaultPageName { get; }" />
      <MemberSignature Language="ILAsm" Value=".property string DefaultDefaultPageName" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.DefaultDefaultPageName" />
      <MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Property DefaultDefaultPageName As String" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; static property System::String ^ DefaultDefaultPageName { System::String ^ get(); };" />
      <MemberSignature Language="F#" Value="member this.DefaultDefaultPageName : string" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.DefaultDefaultPageName" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets the default URL name for the Welcome page for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>The default URL name of this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />.object's Welcome page.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="DefaultPage">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.SPFile DefaultPage { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.SharePoint.SPFile DefaultPage" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.DefaultPage" />
      <MemberSignature Language="VB.NET" Value="Public Property DefaultPage As SPFile" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property Microsoft::SharePoint::SPFile ^ DefaultPage { Microsoft::SharePoint::SPFile ^ get(); void set(Microsoft::SharePoint::SPFile ^ value); };" />
      <MemberSignature Language="F#" Value="member this.DefaultPage : Microsoft.SharePoint.SPFile with get, set" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.DefaultPage" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.SPFile</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets and sets the Welcome page for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>The <see cref="T:Microsoft.SharePoint.SPFile" /> instance that is used as the Welcome page for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</value>
        <remarks>
          <para>This property can only be set to an instance of the <see cref="T:Microsoft.SharePoint.SPFile" /> object within the current <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />. An instance of the <b>SPFile</b> object is returned rather than a <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> object because the Welcome page might not be an instance of the <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> class. Use the <see cref="M:Microsoft.SharePoint.Publishing.PublishingPage.IsPublishingPage(Microsoft.SharePoint.SPListItem)" /> method to verify whether this <see cref="T:Microsoft.SharePoint.SPFile" /> is a <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" />.</para>
          <para>This property may return a a null reference (Nothing in Visual Basic) value if a default page has not been explicitly set.</para>
          <para>To save changes after setting this property, call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method.</para>
          <para />
        </remarks>
        <exception cref="System.ArgumentNullException">The value cannot be set to <b>null.</b></exception>
        <exception cref="System.ArgumentException">The <see cref="T:Microsoft.SharePoint.SPFile" /> must exist in this site.</exception>
        <example>
          <para>This example demonstrates setting and saving property values on a publishing Web. Before building and running this example, verify that Publishing feature has been enabled for the <b>SPWeb</b>, and that the <b>defaultPageFileId</b> is <b>SPFile.UniqueId</b> for the new default page.</para>
          <code>using SPContentTypeId = Microsoft.SharePoint.SPContentTypeId;
using SPContentType = Microsoft.SharePoint.SPContentType;
using SPSite = Microsoft.SharePoint.SPSite;
using SPFile = Microsoft.SharePoint.SPFile;
using SPWeb = Microsoft.SharePoint.SPWeb;
using PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite;
using PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb;
using PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection;
using PageLayout = Microsoft.SharePoint.Publishing.PageLayout;

namespace Microsoft.SDK.SharePointServer.Samples
{
    public static class PublishingWebCodeSamples
    {
        public static void SetPublishingWebProperties(SPWeb web, System.Guid defaultPageFileId)
        {
// Replace these variable values and input parameters
// with your own values.
string newTitle = "your Title";         // new PublishingWeb.Title value
string newDescription = "your Description";         // new PublishingWeb.Description value
bool resetInheritPageLayouts = true;    // new PublishingWeb.IsInheritingAvailablePageLayouts value
bool resetInheritWebTemplates = true;   // new PublishingWeb.IsInheritingAvailableWebTemplates value

// Validate the input parameters.
if (null == web)
{
    throw new System.ArgumentNullException("web");
}

// Get the PublishingWeb wrapper for the SPWeb 
// that was passed in.
PublishingWeb publishingWeb = null;
if (PublishingWeb.IsPublishingWeb(web))
{
    publishingWeb = PublishingWeb.GetPublishingWeb(web);
}
else
{
    throw new System.ArgumentException("The SPWeb must be a PublishingWeb", "web");
}

//  Retrieve the SPFile.
SPFile newDefaultPageFile = publishingWeb.Web.GetFile(defaultPageFileId);
if( (null == newDefaultPageFile) ||
    !newDefaultPageFile.Exists )
{
    throw new System.ArgumentException(
        "The Guid does not match an SPFile on the SPWeb",
        "defaultPageFileId");
}

// Set new values on the PublishingWeb.
publishingWeb.Title = newTitle;
publishingWeb.Description = newDescription;
publishingWeb.DefaultPage = newDefaultPageFile;
if( resetInheritPageLayouts &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailablePageLayouts  &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailablePageLayouts();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts);
}
if (resetInheritWebTemplates &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailableWebTemplates &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailableWebTemplates();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates);
}

// Save the new values on the PublishingWeb.
publishingWeb.Update();
        }
    }
}</code>
          <code>Imports SPContentTypeId = Microsoft.SharePoint.SPContentTypeId
Imports SPContentType = Microsoft.SharePoint.SPContentType
Imports SPSite = Microsoft.SharePoint.SPSite
Imports SPFile = Microsoft.SharePoint.SPFile
Imports SPWeb = Microsoft.SharePoint.SPWeb
Imports PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite
Imports PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb
Imports PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection
Imports PageLayout = Microsoft.SharePoint.Publishing.PageLayout

Namespace Microsoft.SDK.SharePointServer.Samples
    Public NotInheritable Class PublishingWebCodeSamples
        Private Sub New()
        End Sub
        Public Shared Sub SetPublishingWebProperties(ByVal web As SPWeb, ByVal defaultPageFileId As System.Guid)
' Replace these variable values and input parameters
' with your own values.
Dim newTitle As String = "your Title" ' new PublishingWeb.Title value
Dim newDescription As String = "your Description" ' new PublishingWeb.Description value
Dim resetInheritPageLayouts As Boolean = True ' new PublishingWeb.IsInheritingAvailablePageLayouts value
Dim resetInheritWebTemplates As Boolean = True ' new PublishingWeb.IsInheritingAvailableWebTemplates value

' Validate the input parameters.
If Nothing Is web Then
    Throw New System.ArgumentNullException("web")
End If

' Get the PublishingWeb wrapper for the SPWeb 
' that was passed in.
Dim publishingWeb As PublishingWeb = Nothing
If PublishingWeb.IsPublishingWeb(web) Then
    publishingWeb = PublishingWeb.GetPublishingWeb(web)
Else
    Throw New System.ArgumentException("The SPWeb must be a PublishingWeb", "web")
End If

'  Retrieve the SPFile.
Dim newDefaultPageFile As SPFile = publishingWeb.Web.GetFile(defaultPageFileId)
If (Nothing Is newDefaultPageFile) OrElse (Not newDefaultPageFile.Exists) Then
    Throw New System.ArgumentException("The Guid does not match an SPFile on the SPWeb", "defaultPageFileId")
End If

' Set new values on the PublishingWeb.
publishingWeb.Title = newTitle
publishingWeb.Description = newDescription
publishingWeb.DefaultPage = newDefaultPageFile
If resetInheritPageLayouts AndAlso (Not publishingWeb.IsInheritingAvailablePageLayouts) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailablePageLayouts()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts)
End If
If resetInheritWebTemplates AndAlso (Not publishingWeb.IsInheritingAvailableWebTemplates) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailableWebTemplates()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates)
End If

' Save the new values on the PublishingWeb.
publishingWeb.Update()
        End Sub
    End Class
End Namespace</code>
        </example>
      </Docs>
    </Member>
    <Member MemberName="DefaultPageLayout">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.PageLayout DefaultPageLayout { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.SharePoint.Publishing.PageLayout DefaultPageLayout" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.DefaultPageLayout" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property DefaultPageLayout As PageLayout" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property Microsoft::SharePoint::Publishing::PageLayout ^ DefaultPageLayout { Microsoft::SharePoint::Publishing::PageLayout ^ get(); };" />
      <MemberSignature Language="F#" Value="member this.DefaultPageLayout : Microsoft.SharePoint.Publishing.PageLayout" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.DefaultPageLayout" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PageLayout</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets the URL token that is used when creating “one-click” pages within this <see cref="T:Microsoft.SharePoint.PublishingWeb" />.</summary>
        <value>Returns <see cref="T:Microsoft.SharePoint.Publishing.PageLayout" />.</value>
        <remarks>
          <para>The <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.NewPageUrlToken" /> property is used when creating new “one-click” pages within this <b>PublishingWeb</b>.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="DefaultPagesListName">
      <MemberSignature Language="C#" Value="public static string DefaultPagesListName { get; }" />
      <MemberSignature Language="ILAsm" Value=".property string DefaultPagesListName" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.DefaultPagesListName" />
      <MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Property DefaultPagesListName As String" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; static property System::String ^ DefaultPagesListName { System::String ^ get(); };" />
      <MemberSignature Language="F#" Value="member this.DefaultPagesListName : string" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.DefaultPagesListName" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets the default URL name that is used for the pages list in the existing locale for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>The default URL name that is used for the pages list in the existing locale.</value>
        <remarks>
          <para>This value is the default URL name for the pages list, if it has not been overridden. To get the actual pages list URL name for a <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object, use the <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.PagesListName" /> property or the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetPagesListName(Microsoft.SharePoint.SPWeb)" /> method instead.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="Delete">
      <MemberSignature Language="C#" Value="public void Delete ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void Delete() cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.Delete" />
      <MemberSignature Language="VB.NET" Value="Public Sub Delete ()" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; void Delete();" />
      <MemberSignature Language="F#" Value="member this.Delete : unit -&gt; unit" Usage="publishingWeb.Delete " />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Deletes the current <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <remarks>
          <para>After calling this method, you should call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method to save changes.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="Delete">
      <MemberSignature Language="C#" Value="public void Delete (bool recursive);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void Delete(bool recursive) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.Delete(System.Boolean)" />
      <MemberSignature Language="VB.NET" Value="Public Sub Delete (recursive As Boolean)" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; void Delete(bool recursive);" />
      <MemberSignature Language="F#" Value="member this.Delete : bool -&gt; unit" Usage="publishingWeb.Delete recursive" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="recursive" Type="System.Boolean" />
      </Parameters>
      <Docs>
        <param name="recursive">
          <b>true</b> for a recursive delete; otherwise, <b>false</b>.</param>
        <summary>Deletes the current <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> instance and potentially all sites in the subtree with a node in this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />.</summary>
        <remarks>
          <para>After calling this method, you should call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method to save changes.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="Description">
      <MemberSignature Language="C#" Value="public string Description { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance string Description" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.Description" />
      <MemberSignature Language="VB.NET" Value="Public Property Description As String" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property System::String ^ Description { System::String ^ get(); void set(System::String ^ value); };" />
      <MemberSignature Language="F#" Value="member this.Description : string with get, set" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.Description" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets or sets the description string for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>The description string for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />.</value>
        <remarks>
          <para>This property wraps the <see cref="P:Microsoft.SharePoint.SPWeb.Description" /> property.</para>
          <para>To save changes after setting this property, call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method.</para>
          <para />
        </remarks>
        <example>
          <para>This example demonstrates setting and saving property values on a publishing Web. Before building and running this example, verify that Publishing feature has been enabled for the <b>SPWeb</b>, and that the <b>defaultPageFileId</b> is <b>SPFile.UniqueId</b> for the new default page.</para>
          <code>using SPContentTypeId = Microsoft.SharePoint.SPContentTypeId;
using SPContentType = Microsoft.SharePoint.SPContentType;
using SPSite = Microsoft.SharePoint.SPSite;
using SPFile = Microsoft.SharePoint.SPFile;
using SPWeb = Microsoft.SharePoint.SPWeb;
using PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite;
using PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb;
using PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection;
using PageLayout = Microsoft.SharePoint.Publishing.PageLayout;

namespace Microsoft.SDK.SharePointServer.Samples
{
    public static class PublishingWebCodeSamples
    {
        public static void SetPublishingWebProperties(SPWeb web, System.Guid defaultPageFileId)
        {
// Replace these variable values and input parameters
// with your own values.
string newTitle = "your Title";         // new PublishingWeb.Title value
string newDescription = "your Description";         // new PublishingWeb.Description value
bool resetInheritPageLayouts = true;    // new PublishingWeb.IsInheritingAvailablePageLayouts value
bool resetInheritWebTemplates = true;   // new PublishingWeb.IsInheritingAvailableWebTemplates value

// Validate the input parameters.
if (null == web)
{
    throw new System.ArgumentNullException("web");
}

// Get the PublishingWeb wrapper for the SPWeb 
// that was passed in.
PublishingWeb publishingWeb = null;
if (PublishingWeb.IsPublishingWeb(web))
{
    publishingWeb = PublishingWeb.GetPublishingWeb(web);
}
else
{
    throw new System.ArgumentException("The SPWeb must be a PublishingWeb", "web");
}

//  Retrieve the SPFile.
SPFile newDefaultPageFile = publishingWeb.Web.GetFile(defaultPageFileId);
if( (null == newDefaultPageFile) ||
    !newDefaultPageFile.Exists )
{
    throw new System.ArgumentException(
        "The Guid does not match an SPFile on the SPWeb",
        "defaultPageFileId");
}

// Set new values on the PublishingWeb.
publishingWeb.Title = newTitle;
publishingWeb.Description = newDescription;
publishingWeb.DefaultPage = newDefaultPageFile;
if( resetInheritPageLayouts &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailablePageLayouts  &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailablePageLayouts();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts);
}
if (resetInheritWebTemplates &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailableWebTemplates &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailableWebTemplates();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates);
}

// Save the new values on the PublishingWeb.
publishingWeb.Update();
        }
    }
}</code>
          <code>Imports SPContentTypeId = Microsoft.SharePoint.SPContentTypeId
Imports SPContentType = Microsoft.SharePoint.SPContentType
Imports SPSite = Microsoft.SharePoint.SPSite
Imports SPFile = Microsoft.SharePoint.SPFile
Imports SPWeb = Microsoft.SharePoint.SPWeb
Imports PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite
Imports PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb
Imports PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection
Imports PageLayout = Microsoft.SharePoint.Publishing.PageLayout

Namespace Microsoft.SDK.SharePointServer.Samples
    Public NotInheritable Class PublishingWebCodeSamples
        Private Sub New()
        End Sub
        Public Shared Sub SetPublishingWebProperties(ByVal web As SPWeb, ByVal defaultPageFileId As System.Guid)
' Replace these variable values and input parameters
' with your own values.
Dim newTitle As String = "your Title" ' new PublishingWeb.Title value
Dim newDescription As String = "your Description" ' new PublishingWeb.Description value
Dim resetInheritPageLayouts As Boolean = True ' new PublishingWeb.IsInheritingAvailablePageLayouts value
Dim resetInheritWebTemplates As Boolean = True ' new PublishingWeb.IsInheritingAvailableWebTemplates value

' Validate the input parameters.
If Nothing Is web Then
    Throw New System.ArgumentNullException("web")
End If

' Get the PublishingWeb wrapper for the SPWeb 
' that was passed in.
Dim publishingWeb As PublishingWeb = Nothing
If PublishingWeb.IsPublishingWeb(web) Then
    publishingWeb = PublishingWeb.GetPublishingWeb(web)
Else
    Throw New System.ArgumentException("The SPWeb must be a PublishingWeb", "web")
End If

'  Retrieve the SPFile.
Dim newDefaultPageFile As SPFile = publishingWeb.Web.GetFile(defaultPageFileId)
If (Nothing Is newDefaultPageFile) OrElse (Not newDefaultPageFile.Exists) Then
    Throw New System.ArgumentException("The Guid does not match an SPFile on the SPWeb", "defaultPageFileId")
End If

' Set new values on the PublishingWeb.
publishingWeb.Title = newTitle
publishingWeb.Description = newDescription
publishingWeb.DefaultPage = newDefaultPageFile
If resetInheritPageLayouts AndAlso (Not publishingWeb.IsInheritingAvailablePageLayouts) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailablePageLayouts()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts)
End If
If resetInheritWebTemplates AndAlso (Not publishingWeb.IsInheritingAvailableWebTemplates) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailableWebTemplates()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates)
End If

' Save the new values on the PublishingWeb.
publishingWeb.Update()
        End Sub
    End Class
End Namespace</code>
        </example>
      </Docs>
    </Member>
    <Member MemberName="DisableScheduling">
      <MemberSignature Language="C#" Value="public static void DisableScheduling (Microsoft.SharePoint.SPList list);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig void DisableScheduling(class Microsoft.SharePoint.SPList list) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.DisableScheduling(Microsoft.SharePoint.SPList)" />
      <MemberSignature Language="VB.NET" Value="Public Shared Sub DisableScheduling (list As SPList)" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; static void DisableScheduling(Microsoft::SharePoint::SPList ^ list);" />
      <MemberSignature Language="F#" Value="static member DisableScheduling : Microsoft.SharePoint.SPList -&gt; unit" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.DisableScheduling list" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="list" Type="Microsoft.SharePoint.SPList" />
      </Parameters>
      <Docs>
        <param name="list">The <b>SPList</b> object on which to disable scheduling</param>
        <summary>Disables scheduling behavior on an <see cref="T:Microsoft.SharePoint.SPList" /> object.</summary>
        <remarks>
          <para>If scheduling is already disabled on the <b>SPList</b> object, then this method will have no effect. The <b>SPList</b> object must have both major and minor (draft) versions enabled, and content approval must be enabled in order for this method to succeed.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="DocumentsLibrary">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.SPDocumentLibrary DocumentsLibrary { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.SharePoint.SPDocumentLibrary DocumentsLibrary" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.DocumentsLibrary" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property DocumentsLibrary As SPDocumentLibrary" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property Microsoft::SharePoint::SPDocumentLibrary ^ DocumentsLibrary { Microsoft::SharePoint::SPDocumentLibrary ^ get(); };" />
      <MemberSignature Language="F#" Value="member this.DocumentsLibrary : Microsoft.SharePoint.SPDocumentLibrary" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.DocumentsLibrary" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.SPDocumentLibrary</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets the designated Documents list of the current <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>Returns <see cref="T:Microsoft.SharePoint.SPDocumentLibrary" />.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="EnableScheduling">
      <MemberSignature Language="C#" Value="public static void EnableScheduling (Microsoft.SharePoint.SPList list);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig void EnableScheduling(class Microsoft.SharePoint.SPList list) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.EnableScheduling(Microsoft.SharePoint.SPList)" />
      <MemberSignature Language="VB.NET" Value="Public Shared Sub EnableScheduling (list As SPList)" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; static void EnableScheduling(Microsoft::SharePoint::SPList ^ list);" />
      <MemberSignature Language="F#" Value="static member EnableScheduling : Microsoft.SharePoint.SPList -&gt; unit" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.EnableScheduling list" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="list" Type="Microsoft.SharePoint.SPList" />
      </Parameters>
      <Docs>
        <param name="list">The <b>SPList</b> object on which to enable scheduling</param>
        <summary>Enables scheduling behavior on an <see cref="T:Microsoft.SharePoint.SPList" /> object.</summary>
        <remarks>
          <para>The <b>SPList</b> object must have both major and minor (draft) versions enabled, and content approval must be enabled in order for this method to succeed.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="GetAvailableCrossLanguageWebTemplates">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.SPWebTemplateCollection GetAvailableCrossLanguageWebTemplates ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.SharePoint.SPWebTemplateCollection GetAvailableCrossLanguageWebTemplates() cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetAvailableCrossLanguageWebTemplates" />
      <MemberSignature Language="VB.NET" Value="Public Function GetAvailableCrossLanguageWebTemplates () As SPWebTemplateCollection" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; Microsoft::SharePoint::SPWebTemplateCollection ^ GetAvailableCrossLanguageWebTemplates();" />
      <MemberSignature Language="F#" Value="member this.GetAvailableCrossLanguageWebTemplates : unit -&gt; Microsoft.SharePoint.SPWebTemplateCollection" Usage="publishingWeb.GetAvailableCrossLanguageWebTemplates " />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.SPWebTemplateCollection</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Returns the cross-language Web templates available for creating subsites below this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />.</summary>
        <returns>An <see cref="T:Microsoft.SharePoint.SPWebTemplateCollection" /> collection of <see cref="T:Microsoft.SharePoint.SPWebTemplate" /> objects available for creating subsites below this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />, regardless of language.</returns>
        <remarks>
          <para>The available Web templates returned by this method may be inherited from a parent <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> as indicated by the <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.IsInheritingAvailableWebTemplates" /> property.</para>
          <para>Use the methods <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.SetAvailableCrossLanguageWebTemplates" />, <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.AllowAllWebTemplates" />, and <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.InheritAvailableWebTemplates" /> to modify the set of Web templates returned by this method.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="GetAvailablePageLayouts">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.PageLayout[] GetAvailablePageLayouts ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.SharePoint.Publishing.PageLayout[] GetAvailablePageLayouts() cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetAvailablePageLayouts" />
      <MemberSignature Language="VB.NET" Value="Public Function GetAvailablePageLayouts () As PageLayout()" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; cli::array &lt;Microsoft::SharePoint::Publishing::PageLayout ^&gt; ^ GetAvailablePageLayouts();" />
      <MemberSignature Language="F#" Value="member this.GetAvailablePageLayouts : unit -&gt; Microsoft.SharePoint.Publishing.PageLayout[]" Usage="publishingWeb.GetAvailablePageLayouts " />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PageLayout[]</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Returns the <see cref="T:Microsoft.SharePoint.Publishing.PageLayout" /> objects available for creating <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects within this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />.</summary>
        <returns>An array of <see cref="T:Microsoft.SharePoint.Publishing.PageLayout" />s available for creating <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects within this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</returns>
        <remarks>
          <para>The available <b>PageLayout</b> objects returned by this method may be inherited from a parent <b>PublishingWeb</b> object, as indicated by the property <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.IsInheritingAvailablePageLayouts" />.</para>
          <para>Use the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetAvailablePageLayouts(SPContentTypeId)" /> method to return a subset of the <b>PageLayout</b> objects filtered by the <see cref="P:Microsoft.SharePoint.Publishing.PageLayout.AssociatedContentType" /> property ID.</para>
          <para>Use the methods <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.SetAvailableCrossLanguage.PageLayouts" />, <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.AllowAllPageLayouts" />, and <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.InheritAvailablePageLayouts" /> to modify the set of <b>PageLayout</b> objects returned by this method.</para>
          <para />
        </remarks>
        <example>
          <para>This example restricts the set of available page layouts used for creating pages in a publishing Web so that only page layouts associated with a specified content type are available.</para>
          <para>Before using this example, verify that the <paramref name="associatedContentTypeId" /> parameter is from a content type on the root Web of the site.</para>
          <code>using SPContentTypeId = Microsoft.SharePoint.SPContentTypeId;
using SPContentType = Microsoft.SharePoint.SPContentType;
using SPSite = Microsoft.SharePoint.SPSite;
using SPFile = Microsoft.SharePoint.SPFile;
using SPWeb = Microsoft.SharePoint.SPWeb;
using PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite;
using PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb;
using PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection;
using PageLayout = Microsoft.SharePoint.Publishing.PageLayout;

namespace Microsoft.SDK.SharePointServer.Samples
{
    public static class PublishingWebCodeSamples
    {
  
        public static void RestrictPageLayoutsByContentType(
PublishingWeb publishingWeb, 
SPContentTypeId associatedContentTypeId)
        {
// Replace these variable values and input parameters with your own values.
bool excludeHiddenLayouts = true;
bool resetAllSubsitesToInherit = true;

// Validate the input parameters.
if (null == publishingWeb)
{
    throw new System.ArgumentNullException("publishingWeb");
}

SPSite site = publishingWeb.Web.Site;
PublishingSite publishingSite = new PublishingSite(site);

// Retrieve a collection of all page layouts in the site collection
// that match the content type.
SPContentType associatedContentType = publishingSite.ContentTypes[associatedContentTypeId];
if (null == associatedContentType)
{
    throw new System.ArgumentException(
        "The SPContentTypeId did not match an SPContentType in the SPSite.RootWeb",
        "associatedContentTypeId");
}

PageLayoutCollection pageLayoutsByContentType = 
    publishingSite.GetPageLayouts(associatedContentType, excludeHiddenLayouts);

// Update the Web to use these page layouts when creating pages.
publishingWeb.SetAvailablePageLayouts(
    pageLayoutsByContentType.ToArray(),
    resetAllSubsitesToInherit);

publishingWeb.Update();

//  Verify the expected results. Note: This is not required. It demonstrates
//  the results of calling the SetAvailablePageLayouts method.
//
System.Diagnostics.Debug.Assert(!publishingWeb.IsAllowingAllPageLayouts);
System.Diagnostics.Debug.Assert(!publishingWeb.IsInheritingAvailablePageLayouts);

PageLayout[] availablePageLayouts = publishingWeb.GetAvailablePageLayouts();
foreach (PageLayout pageLayout in availablePageLayouts)
{
    System.Diagnostics.Debug.Assert(
        pageLayout.AssociatedContentType.Id == associatedContentTypeId);
}
        }
    }
}</code>
          <code>Imports SPContentTypeId = Microsoft.SharePoint.SPContentTypeId
Imports SPContentType = Microsoft.SharePoint.SPContentType
Imports SPSite = Microsoft.SharePoint.SPSite
Imports SPFile = Microsoft.SharePoint.SPFile
Imports SPWeb = Microsoft.SharePoint.SPWeb
Imports PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite
Imports PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb
Imports PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection
Imports PageLayout = Microsoft.SharePoint.Publishing.PageLayout

Namespace Microsoft.SDK.SharePointServer.Samples
    Public NotInheritable Class PublishingWebCodeSamples

        Private Sub New()
        End Sub
        Public Shared Sub RestrictPageLayoutsByContentType(ByVal publishingWeb As PublishingWeb, ByVal associatedContentTypeId As SPContentTypeId)
' Replace these variable values and input parameters with your own values.
Dim excludeHiddenLayouts As Boolean = True
Dim resetAllSubsitesToInherit As Boolean = True

' Validate the input parameters.
If Nothing Is publishingWeb Then
    Throw New System.ArgumentNullException("publishingWeb")
End If

Dim site As SPSite = publishingWeb.Web.Site
Dim publishingSite As New PublishingSite(site)

' Retrieve a collection of all page layouts in the site collection
' that match the content type.
Dim associatedContentType As SPContentType = publishingSite.ContentTypes(associatedContentTypeId)
If Nothing Is associatedContentType Then
    Throw New System.ArgumentException("The SPContentTypeId did not match an SPContentType in the SPSite.RootWeb", "associatedContentTypeId")
End If

Dim pageLayoutsByContentType As PageLayoutCollection = publishingSite.GetPageLayouts(associatedContentType, excludeHiddenLayouts)

' Update the Web to use these page layouts when creating pages.
publishingWeb.SetAvailablePageLayouts(pageLayoutsByContentType.ToArray(), resetAllSubsitesToInherit)

publishingWeb.Update()

'  Verify the expected results. Note: This is not required. It demonstrates
'  the results of calling the SetAvailablePageLayouts method.
'
System.Diagnostics.Debug.Assert((Not publishingWeb.IsAllowingAllPageLayouts))
System.Diagnostics.Debug.Assert((Not publishingWeb.IsInheritingAvailablePageLayouts))

Dim availablePageLayouts() As PageLayout = publishingWeb.GetAvailablePageLayouts()
For Each pageLayout As PageLayout In availablePageLayouts
    System.Diagnostics.Debug.Assert(pageLayout.AssociatedContentType.Id Is associatedContentTypeId)
Next pageLayout
        End Sub
    End Class
End Namespace</code>
        </example>
      </Docs>
    </Member>
    <Member MemberName="GetAvailablePageLayouts">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.PageLayout[] GetAvailablePageLayouts (Microsoft.SharePoint.SPContentTypeId associatedContentTypeId);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.SharePoint.Publishing.PageLayout[] GetAvailablePageLayouts(valuetype Microsoft.SharePoint.SPContentTypeId associatedContentTypeId) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetAvailablePageLayouts(Microsoft.SharePoint.SPContentTypeId)" />
      <MemberSignature Language="VB.NET" Value="Public Function GetAvailablePageLayouts (associatedContentTypeId As SPContentTypeId) As PageLayout()" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; cli::array &lt;Microsoft::SharePoint::Publishing::PageLayout ^&gt; ^ GetAvailablePageLayouts(Microsoft::SharePoint::SPContentTypeId associatedContentTypeId);" />
      <MemberSignature Language="F#" Value="member this.GetAvailablePageLayouts : Microsoft.SharePoint.SPContentTypeId -&gt; Microsoft.SharePoint.Publishing.PageLayout[]" Usage="publishingWeb.GetAvailablePageLayouts associatedContentTypeId" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PageLayout[]</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="associatedContentTypeId" Type="Microsoft.SharePoint.SPContentTypeId" />
      </Parameters>
      <Docs>
        <param name="associatedContentTypeId">The associated <see cref="T:Microsoft.SharePoint.SPContentTypeId" /> by which to filter the <see cref="T:Microsoft.SharePoint.Publishing.PageLayout" /> objects.</param>
        <summary>Returns the <see cref="T:Microsoft.SharePoint.Publishing.PageLayout" /> objects available for creating <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects within this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object, filtered by an associated <see cref="T:Microsoft.SharePoint.SPContentTypeId" /> object.</summary>
        <returns>An array of <see cref="T:Microsoft.SharePoint.Publishing.PageLayout" /> objects available for creating <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects within this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />, filtered by an associated content type.</returns>
        <remarks>
          <para>This method returns a subset of the layouts returned from <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetAvailablePageLayouts(SPContentTypeId)" />, filtered by the <see cref="P:Microsoft.SharePoint.Publishing.PageLayout.AssociatedContentType" /> property ID.</para>
          <para>After calling this method, you should call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method to save changes.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="GetAvailableWebTemplates">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.SPWebTemplateCollection GetAvailableWebTemplates (uint lcid);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.SharePoint.SPWebTemplateCollection GetAvailableWebTemplates(unsigned int32 lcid) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetAvailableWebTemplates(System.UInt32)" />
      <MemberSignature Language="VB.NET" Value="Public Function GetAvailableWebTemplates (lcid As UInteger) As SPWebTemplateCollection" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; Microsoft::SharePoint::SPWebTemplateCollection ^ GetAvailableWebTemplates(System::UInt32 lcid);" />
      <MemberSignature Language="F#" Value="member this.GetAvailableWebTemplates : uint32 -&gt; Microsoft.SharePoint.SPWebTemplateCollection" Usage="publishingWeb.GetAvailableWebTemplates lcid" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.SPWebTemplateCollection</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="lcid" Type="System.UInt32" />
      </Parameters>
      <Docs>
        <param name="lcid">Locale ID of the Web templates to be retrieved.</param>
        <summary>Returns the Web templates available for creating subsites below this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />.</summary>
        <returns>An <see cref="T:Microsoft.SharePoint.SPWebTemplateCollection" /> collection of <see cref="T:Microsoft.SharePoint.SPWebTemplate" /> objects available for creating subsites below this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> for a given locale. This includes any Web templates specified as cross-language by the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.SetAvailableCrossLanguageTemplates(System.Collections.ObjectModel.Collection{Microsoft.SharePoint.SPWebTemplate},System.UInt32,System.Boolean)" /> method if they are available for the specified <paramref name="lcid" />.</returns>
        <remarks>
          <para>The available Web templates returned by this method may be inherited from a parent <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />, as indicated by the property <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.IsInheritingAvailableWebTemplates" />.</para>
          <para>Use the methods <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.SetAvailableWebTemplates" />, <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.SetAvailableCrossLanguageWebTemplates" />, <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.AllowAllWebTemplates" />, and <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.InheritAvailableWebTemplates" /> to modify the set of Web templates returned by this method.</para>
          <para>After calling this method, you should call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method to save changes.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="GetIsSchedulingEnabled">
      <MemberSignature Language="C#" Value="public static bool GetIsSchedulingEnabled (Microsoft.SharePoint.SPList list);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig bool GetIsSchedulingEnabled(class Microsoft.SharePoint.SPList list) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetIsSchedulingEnabled(Microsoft.SharePoint.SPList)" />
      <MemberSignature Language="VB.NET" Value="Public Shared Function GetIsSchedulingEnabled (list As SPList) As Boolean" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; static bool GetIsSchedulingEnabled(Microsoft::SharePoint::SPList ^ list);" />
      <MemberSignature Language="F#" Value="static member GetIsSchedulingEnabled : Microsoft.SharePoint.SPList -&gt; bool" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.GetIsSchedulingEnabled list" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="list" Type="Microsoft.SharePoint.SPList" />
      </Parameters>
      <Docs>
        <param name="list">The <b>SPList</b> object containing the web templates to be retrieved</param>
        <summary>Returns the web templates that are available for creating subsites below this <b>PublishingWeb</b> object.</summary>
        <returns>Returns <see cref="T:System.Boolean" />.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="GetPagesListId">
      <MemberSignature Language="C#" Value="public static Guid GetPagesListId (Microsoft.SharePoint.SPWeb web);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype System.Guid GetPagesListId(class Microsoft.SharePoint.SPWeb web) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetPagesListId(Microsoft.SharePoint.SPWeb)" />
      <MemberSignature Language="VB.NET" Value="Public Shared Function GetPagesListId (web As SPWeb) As Guid" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; static Guid GetPagesListId(Microsoft::SharePoint::SPWeb ^ web);" />
      <MemberSignature Language="F#" Value="static member GetPagesListId : Microsoft.SharePoint.SPWeb -&gt; Guid" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.GetPagesListId web" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Guid</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="web" Type="Microsoft.SharePoint.SPWeb" />
      </Parameters>
      <Docs>
        <param name="web">The Web for which to get the pages list.</param>
        <summary>Returns ID of the pages list in which <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects are stored for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <returns>The ID of the pages list.</returns>
        <remarks>
          <para>If the Web is not a <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />, the application throws an exception.</para>
          <para />
        </remarks>
        <example>
          <para>
            <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetPagesListId(Microsoft.SharePoint.SPWeb)" />
          </para>
          <para>
            <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetPagesListName(Microsoft.SharePoint.SPWeb)" />
          </para>
          <para>
            <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.PagesList" />
          </para>
          <para>
            <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.PagesListId" />
          </para>
          <para>
            <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.PagesListName" />
          </para>
        </example>
      </Docs>
    </Member>
    <Member MemberName="GetPagesListName">
      <MemberSignature Language="C#" Value="public static string GetPagesListName (Microsoft.SharePoint.SPWeb web);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig string GetPagesListName(class Microsoft.SharePoint.SPWeb web) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetPagesListName(Microsoft.SharePoint.SPWeb)" />
      <MemberSignature Language="VB.NET" Value="Public Shared Function GetPagesListName (web As SPWeb) As String" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; static System::String ^ GetPagesListName(Microsoft::SharePoint::SPWeb ^ web);" />
      <MemberSignature Language="F#" Value="static member GetPagesListName : Microsoft.SharePoint.SPWeb -&gt; string" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.GetPagesListName web" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="web" Type="Microsoft.SharePoint.SPWeb" />
      </Parameters>
      <Docs>
        <param name="web">The Web for which to get the name.</param>
        <summary>The URL name of the pages list in which <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects are stored for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />.</summary>
        <returns>The URL Name of the pages list.</returns>
        <remarks>
          <para>If the Web is not a <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object, SharePoint Foundation 2010 throws an exception.</para>
          <para />
        </remarks>
        <example>
          <para>
            <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetPagesListId(Microsoft.SharePoint.SPWeb)" />
          </para>
          <para>
            <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.PagesList" />
          </para>
          <para>
            <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.PagesListId" />
          </para>
          <para>
            <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.PagesListName" />
          </para>
        </example>
      </Docs>
    </Member>
    <Member MemberName="GetPublishingPage">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.PublishingPage GetPublishingPage (int id);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.SharePoint.Publishing.PublishingPage GetPublishingPage(int32 id) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetPublishingPage(System.Int32)" />
      <MemberSignature Language="VB.NET" Value="Public Function GetPublishingPage (id As Integer) As PublishingPage" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; Microsoft::SharePoint::Publishing::PublishingPage ^ GetPublishingPage(int id);" />
      <MemberSignature Language="F#" Value="member this.GetPublishingPage : int -&gt; Microsoft.SharePoint.Publishing.PublishingPage" Usage="publishingWeb.GetPublishingPage id" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PublishingPage</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="id" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="id">To be added.</param>
        <summary>This member is reserved for internal use and is not intended to be used directly from your code.</summary>
        <returns>Returns <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" />.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="GetPublishingPage">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.PublishingPage GetPublishingPage (string strUrl);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.SharePoint.Publishing.PublishingPage GetPublishingPage(string strUrl) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetPublishingPage(System.String)" />
      <MemberSignature Language="VB.NET" Value="Public Function GetPublishingPage (strUrl As String) As PublishingPage" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; Microsoft::SharePoint::Publishing::PublishingPage ^ GetPublishingPage(System::String ^ strUrl);" />
      <MemberSignature Language="F#" Value="member this.GetPublishingPage : string -&gt; Microsoft.SharePoint.Publishing.PublishingPage" Usage="publishingWeb.GetPublishingPage strUrl" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PublishingPage</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="strUrl" Type="System.String" />
      </Parameters>
      <Docs>
        <param name="strUrl">To be added.</param>
        <summary>This member is reserved for internal use and is not intended to be used directly from your code.</summary>
        <returns>Returns <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" />.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="GetPublishingPages">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.PublishingPageCollection GetPublishingPages ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.SharePoint.Publishing.PublishingPageCollection GetPublishingPages() cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetPublishingPages" />
      <MemberSignature Language="VB.NET" Value="Public Function GetPublishingPages () As PublishingPageCollection" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; Microsoft::SharePoint::Publishing::PublishingPageCollection ^ GetPublishingPages();" />
      <MemberSignature Language="F#" Value="member this.GetPublishingPages : unit -&gt; Microsoft.SharePoint.Publishing.PublishingPageCollection" Usage="publishingWeb.GetPublishingPages " />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PublishingPageCollection</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Gets a collection of <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects contained in this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <returns>A <see cref="T:Microsoft.SharePoint.Publishing.PublishingPageCollection" /> collection containing <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects in this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</returns>
        <remarks>
          <para>This method gets all <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object. For a large collection, you can use data paging with the other <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetPublishingPage" /> method(s) to retrieve this collection in smaller subsets.</para>
          <para>To apply sorting or filtering, use a <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetPublishingPages(Microsoft.SharePoint.SPQuery" /> method that takes <see cref="T:Microsoft.SharePoint.SPQuery" />, <see cref="T:System.String" />, or <see cref="T:System.String.UInt32" /> to create a Collaborative Application Markup Language (CAML) query that specifies sorting and collection membership requirements.</para>
          <para />
        </remarks>
        <exception cref="Microsoft.SharePoint.Publishing.InvalidPublishingWebException">The site is not valid. The Pages document library is missing.</exception>
        <example>
          <para>This example creates a new <b>PublishingPage</b> in a <b>PublishingWeb</b>.</para>
          <para>Before compiling and running this example, verify that an <b>SPWeb</b> that is a publishing Web exists and is passed in as the Web parameter. The <b>PageLayout</b> to use for creating the page must also be passed in.</para>
          <code>using SPWeb = Microsoft.SharePoint.SPWeb;
using PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb;
using PageLayout = Microsoft.SharePoint.Publishing.PageLayout;
using PublishingPageCollection = Microsoft.SharePoint.Publishing.PublishingPageCollection;
using PublishingPage = Microsoft.SharePoint.Publishing.PublishingPage;

namespace Microsoft.SDK.SharePointServer.Samples
{
    public static class PublishingPageCollectionCodeSamples
    {
        
       
        public static void CreateNewPage( SPWeb web, PageLayout pageLayout )
        {
// Replace these variable values with your own values.
string newPageName = "Contoso.aspx";    // the URL name of the new page
string checkInComment = "Your check in comments";  // the comment to set when the page is checked in

// Validate the input parameters.
if (null == web)
{
    throw new System.ArgumentNullException("web");
}
if (null == pageLayout)
{
    throw new System.ArgumentNullException("pageLayout");
}

// Get the PublishingWeb wrapper for the SPWeb that was passed in.
PublishingWeb publishingWeb = null;
if (PublishingWeb.IsPublishingWeb(web))
{
    publishingWeb = PublishingWeb.GetPublishingWeb(web);
}
else
{
    throw new System.ArgumentException("The SPWeb must be a PublishingWeb", "web");
}
           
// Create the new page in the PublishingWeb.
PublishingPageCollection pages = publishingWeb.GetPublishingPages();
PublishingPage newPage = pages.Add(newPageName, pageLayout);

// Check in the new page so that others can work on it.
newPage.CheckIn(checkInComment);          
        }
    }
}</code>
          <code>Imports SPWeb = Microsoft.SharePoint.SPWeb
Imports PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb
Imports PageLayout = Microsoft.SharePoint.Publishing.PageLayout
Imports PublishingPageCollection = Microsoft.SharePoint.Publishing.PublishingPageCollection
Imports PublishingPage = Microsoft.SharePoint.Publishing.PublishingPage

Namespace Microsoft.SDK.SharePointServer.Samples
    Public NotInheritable Class PublishingPageCollectionCodeSamples


        Private Sub New()
        End Sub
        Public Shared Sub CreateNewPage(ByVal web As SPWeb, ByVal pageLayout As PageLayout)
' Replace these variable values with your own values.
Dim newPageName As String = "Contoso.aspx" ' the URL name of the new page
Dim checkInComment As String = "Your check in comments" ' the comment to set when the page is checked in

' Validate the input parameters.
If Nothing Is web Then
    Throw New System.ArgumentNullException("web")
End If
If Nothing Is pageLayout Then
    Throw New System.ArgumentNullException("pageLayout")
End If

' Get the PublishingWeb wrapper for the SPWeb that was passed in.
Dim publishingWeb As PublishingWeb = Nothing
If PublishingWeb.IsPublishingWeb(web) Then
    publishingWeb = PublishingWeb.GetPublishingWeb(web)
Else
    Throw New System.ArgumentException("The SPWeb must be a PublishingWeb", "web")
End If

' Create the new page in the PublishingWeb.
Dim pages As PublishingPageCollection = publishingWeb.GetPublishingPages()
Dim newPage As PublishingPage = pages.Add(newPageName, pageLayout)

' Check in the new page so that others can work on it.
newPage.CheckIn(checkInComment)
        End Sub
    End Class
End Namespace</code>
        </example>
      </Docs>
    </Member>
    <Member MemberName="GetPublishingPages">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.PublishingPageCollection GetPublishingPages (Microsoft.SharePoint.SPQuery query);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.SharePoint.Publishing.PublishingPageCollection GetPublishingPages(class Microsoft.SharePoint.SPQuery query) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetPublishingPages(Microsoft.SharePoint.SPQuery)" />
      <MemberSignature Language="VB.NET" Value="Public Function GetPublishingPages (query As SPQuery) As PublishingPageCollection" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; Microsoft::SharePoint::Publishing::PublishingPageCollection ^ GetPublishingPages(Microsoft::SharePoint::SPQuery ^ query);" />
      <MemberSignature Language="F#" Value="member this.GetPublishingPages : Microsoft.SharePoint.SPQuery -&gt; Microsoft.SharePoint.Publishing.PublishingPageCollection" Usage="publishingWeb.GetPublishingPages query" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PublishingPageCollection</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="query" Type="Microsoft.SharePoint.SPQuery" />
      </Parameters>
      <Docs>
        <param name="query">The <see cref="T:Microsoft.SharePoint.SPQuery" /> object to use when retrieving the collection.</param>
        <summary>Gets a collection of <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects contained in this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <returns>A <see cref="T:Microsoft.SharePoint.Publishing.PublishingPageCollection" /> collection containing <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects in this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />, based on the <paramref name="query" /> argument.</returns>
        <remarks>
          <para>Set the <see cref="P:Microsoft.SharePoint.SPQuery.RowLimit" /> property on the query parameter to indicate the paging data size.</para>
          <para>Set the <see cref="P:Microsoft.SharePoint.SPQuery.Query" /> property on the query parameter to indicate the Collaborative Application Markup Language (CAML) query to use when retrieving the collection.</para>
          <para />
        </remarks>
        <exception cref="Microsoft.SharePoint.SPException">The collection retrieval failed. The CAML query may be invalid.</exception>
        <exception cref="Microsoft.SharePoint.Publishing.InvalidPublishingWebException">The site is not valid. The Pages document library is missing.</exception>
        <exception cref="System.ArgumentNullException">The value cannot be set to a null reference (Nothing in Visual Basic).</exception>
        <example>
          <para>You can use the CAML <b>&lt;</b>OrderBy<b>&gt;</b> tag to sort the collection. For example, to order a collection in ascending order based on title, use this CAML query.</para>
          <code>&amp;lt;br/&amp;gt;
&amp;lt;OrderBy&amp;gt;
&amp;lt;FieldRef Name="Title" Ascending="TRUE"&amp;gt;
&amp;lt;/FieldRef&amp;gt;
&amp;lt;/OrderBy&amp;gt;</code>
          <para>You can use the CAML <b>&lt;</b>Where<b>&gt;</b> tag to filter the collection. For example, to filter a collection based on title matching the value "abc", use this CAML query.</para>
          <code>&amp;lt;br/&amp;gt;
&amp;lt;Where&amp;gt;
&amp;lt;Eq&amp;gt;
&amp;lt;FieldRef Name="Title"&amp;gt;
&amp;lt;/FieldRef&amp;gt;
&amp;lt;Value Type="Text"&amp;gt;abc&amp;lt;/Value&amp;gt;
&amp;lt;/Eq&amp;gt;
&amp;lt;/Where&amp;gt;</code>
        </example>
      </Docs>
    </Member>
    <Member MemberName="GetPublishingPages">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.PublishingPageCollection GetPublishingPages (string camlQueryXml);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.SharePoint.Publishing.PublishingPageCollection GetPublishingPages(string camlQueryXml) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetPublishingPages(System.String)" />
      <MemberSignature Language="VB.NET" Value="Public Function GetPublishingPages (camlQueryXml As String) As PublishingPageCollection" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; Microsoft::SharePoint::Publishing::PublishingPageCollection ^ GetPublishingPages(System::String ^ camlQueryXml);" />
      <MemberSignature Language="F#" Value="member this.GetPublishingPages : string -&gt; Microsoft.SharePoint.Publishing.PublishingPageCollection" Usage="publishingWeb.GetPublishingPages camlQueryXml" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PublishingPageCollection</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="camlQueryXml" Type="System.String" />
      </Parameters>
      <Docs>
        <param name="camlQueryXml">The CAML query XML parameter that is used to determine the sort order, filtering, and other properties for the <b>PublishingPageCollection</b> objects that have been retrieved.</param>
        <summary>Gets a collection of <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects contained in this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <returns>A <see cref="T:Microsoft.SharePoint.Publishing.PublishingPageCollection" /> collection containing <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects in this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />, based on the <paramref name="camQueryXml" /> argument.</returns>
        <remarks>
          <para>This method gets <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects that are contained in this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> class, based on the query information provided in the <paramref name="camlQueryXml" /> argument. No item (row) limit applies to the collection; that is, no data paging occurs.</para>
          <para>The <paramref name="camlQueryXml" /> argument passed in this method is equivalent to the <see cref="P:Microsoft.SharePoint.SPQuery.Query" /> property.</para>
          <para />
        </remarks>
        <exception cref="System.ArgumentNullException">The <paramref name="camlQueryXml" /> parameter is a null reference (Nothing in Visual Basic).</exception>
        <exception cref="Microsoft.SharePoint.SPException">The collection retrieval failed. The CAML query may not be valid.</exception>
        <exception cref="Microsoft.SharePoint.Publishing.InvalidPublishingWebException">The site is not valid. The Pages document library is missing.</exception>
        <example>
          <para>You can use the CAML <b>&lt;</b>OrderBy<b>&gt;</b> tag to sort the collection. For example, to order a collection in ascending order based on title, use this CAML query.</para>
          <code>&amp;lt;br/&amp;gt;
&amp;lt;OrderBy&amp;gt;
&amp;lt;FieldRef Name="Title" Ascending="TRUE"&amp;gt;
&amp;lt;/FieldRef&amp;gt;
&amp;lt;/OrderBy&amp;gt;
&amp;lt;br/&amp;gt;</code>
          <para>You can use the CAML <b>&lt;</b>Where<b>&gt;</b> tag to filter the collection. For example, to filter a collection based on the title matching the value "abc", use this CAML query.</para>
          <code>&amp;lt;br/&amp;gt;
&amp;lt;Where&amp;gt;
&amp;lt;Eq&amp;gt;
&amp;lt;FieldRef Name="Title"&amp;gt;
&amp;lt;/FieldRef&amp;gt;
&amp;lt;Value Type="Text"&amp;gt;abc&amp;lt;/Value&amp;gt;
&amp;lt;/Eq&amp;gt;
&amp;lt;/Where&amp;gt;</code>
        </example>
      </Docs>
    </Member>
    <Member MemberName="GetPublishingPages">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.PublishingPageCollection GetPublishingPages (uint rowLimit);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.SharePoint.Publishing.PublishingPageCollection GetPublishingPages(unsigned int32 rowLimit) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetPublishingPages(System.UInt32)" />
      <MemberSignature Language="VB.NET" Value="Public Function GetPublishingPages (rowLimit As UInteger) As PublishingPageCollection" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; Microsoft::SharePoint::Publishing::PublishingPageCollection ^ GetPublishingPages(System::UInt32 rowLimit);" />
      <MemberSignature Language="F#" Value="member this.GetPublishingPages : uint32 -&gt; Microsoft.SharePoint.Publishing.PublishingPageCollection" Usage="publishingWeb.GetPublishingPages rowLimit" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PublishingPageCollection</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="rowLimit" Type="System.UInt32" />
      </Parameters>
      <Docs>
        <param name="rowLimit">The maximum number of items (rows) to return each time the <see cref="T:Microsoft.SharePoint.Publishing.PublishingPageCollection" /> collection is retrieved.</param>
        <summary>Gets a collection of <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects contained in this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <returns>A <see cref="T:Microsoft.SharePoint.Publishing.PublishingPageCollection" /> collection containing the first <paramref name="n" /><see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects in the <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> where <paramref name="n" /> is the <paramref name="rowLimit" /> value</returns>
        <remarks>
          <para>The <paramref name="rowLimit" /> argument passed in this method is equivalent to the <see cref="P:Microsoft.SharePoint.SPQuery.RowLimit" /> property.</para>
          <para>You can use the <see cref="M:Microsoft.SharePoint.Publishing.PublishingPageCollection`1.QueryNext" /> method of the returned collection to retrieve the next <paramref name="n" /> items in the collection where <paramref name="n" /> is the <paramref name="rowLimit" /> argument value. The <see cref="P:Microsoft.SharePoint.Publishing.PublishingPageCollection.RowLimit" /> property of the returned collection returns the <paramref name="rowLimit" /> value set here.</para>
          <para>If the <paramref name="rowLimit" /> value is <paramref name="0" />, then all the <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects for the <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> class are retrieved when the <see cref="T:Microsoft.SharePoint.Publishing.PublishingPageCollection" /> collection is created. The same is true if the <paramref name="rowLimit" /> exceeds the maximum number of <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects in the <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> class.</para>
          <para>The <see cref="T:Microsoft.SharePoint.Publishing.PublishingPageCollection" /> that is returned has no specific sorting or filtering applied.</para>
          <para />
        </remarks>
        <exception cref="Microsoft.SharePoint.Publishing.InvalidPublishingWebException">The site is not valid. The Pages document library is missing.</exception>
      </Docs>
    </Member>
    <Member MemberName="GetPublishingPages">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.PublishingPageCollection GetPublishingPages (string camlQueryXml, uint rowLimit);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.SharePoint.Publishing.PublishingPageCollection GetPublishingPages(string camlQueryXml, unsigned int32 rowLimit) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetPublishingPages(System.String,System.UInt32)" />
      <MemberSignature Language="VB.NET" Value="Public Function GetPublishingPages (camlQueryXml As String, rowLimit As UInteger) As PublishingPageCollection" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; Microsoft::SharePoint::Publishing::PublishingPageCollection ^ GetPublishingPages(System::String ^ camlQueryXml, System::UInt32 rowLimit);" />
      <MemberSignature Language="F#" Value="member this.GetPublishingPages : string * uint32 -&gt; Microsoft.SharePoint.Publishing.PublishingPageCollection" Usage="publishingWeb.GetPublishingPages (camlQueryXml, rowLimit)" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PublishingPageCollection</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="camlQueryXml" Type="System.String" />
        <Parameter Name="rowLimit" Type="System.UInt32" />
      </Parameters>
      <Docs>
        <param name="camlQueryXml">The CAML query XML that is used to determine sort order, filtering, and other properties for the <see cref="T:Microsoft.SharePoint.Publishing.PublishingPageCollection" /> collection.</param>
        <param name="rowLimit">The maximum number of items (rows) to return each time the <see cref="T:Microsoft.SharePoint.Publishing.PublishingPageCollection" /> is retrieved.</param>
        <summary>Gets a collection of <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects that are contained in this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <returns>A <see cref="T:Microsoft.SharePoint.Publishing.PublishingPageCollection" /> containing the first <paramref name="n" /><see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects in this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWebclass" />, where <paramref name="n" /> is the <paramref name="rowLimit" /> value sorted and filtered based on the <paramref name="camlQueryXml" /> argument.</returns>
        <remarks>
          <para>This method gets <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> class based on the query information provided in the <paramref name="camlQueryXml" /> argument. It returns only the first <paramref name="n" /><see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects in this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> where <paramref name="n" /> is the <paramref name="rowLimit" /> value.</para>
          <para>The <paramref name="camlQueryXml" /> argument passed by this method is equivalent to the <see cref="P:Microsoft.SharePoint.SPQuery.Query" /> property in Microsoft SharePoint Foundation.The <paramref name="rowLimit" /> argument is equivalent to the <see cref="P:Microsoft.SharePoint.SPQuery.RowLimit" /> property in SharePoint Foundation.</para>
          <para>You can use the <see cref="M:Microsoft.SharePoint.Publishing.PublishingPageCollection`1.QueryNext" /> method of the returned collection to retrieve the next <paramref name="n" /> items in the collection where <paramref name="n" /> is the <paramref name="rowLimit" /> argument value. The <see cref="M:Microsoft.SharePoint.Publishing.PublishingPageCollection`1.QueryNext" /> property returns the <paramref name="rowLimit" /> value set here.</para>
          <para>If the <paramref name="rowLimit" /> value is zero, then all <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects for the <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> class are retrieved when the <see cref="T:Microsoft.SharePoint.Publishing.PublishingPageCollection" /> is created. The same is true if the <paramref name="rowLimit" /> exceeds the maximum number of <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects in the <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> class.</para>
          <para />
        </remarks>
        <exception cref="Microsoft.SharePoint.SPException">The collection retrieval failed. The CAML query may be invalid.</exception>
        <exception cref="Microsoft.SharePoint.Publishing.InvalidPublishingWebException">The site is not valid. The Pages document library is missing.</exception>
        <example>
          <para>You can use the CAML <b>&lt;</b>OrderBy<b>&gt;</b> tag to sort the collection. For example, to order a collection in ascending order based on title, use this CAML query.</para>
          <code>&amp;lt;br/&amp;gt;
&amp;lt;OrderBy&amp;gt;
&amp;lt;FieldRef Name="Title" Ascending="TRUE"&amp;gt;
&amp;lt;/FieldRef&amp;gt;
&amp;lt;/OrderBy&amp;gt;
&amp;lt;br/&amp;gt;</code>
          <para>You can use the CAML <b>&lt;</b>Where<b>&gt;</b> tag to filter the collection. For example, to filter a collection based on the title matching the value "abc", use this CAML query.</para>
          <code>&amp;lt;br/&amp;gt;
&amp;lt;Where&amp;gt;
&amp;lt;Eq&amp;gt;
&amp;lt;FieldRef Name="Title"&amp;gt;
&amp;lt;/FieldRef&amp;gt;
&amp;lt;Value Type="Text"&amp;gt;abc&amp;lt;/Value&amp;gt;
&amp;lt;/Eq&amp;gt;
&amp;lt;/Where&amp;gt;</code>
        </example>
      </Docs>
    </Member>
    <Member MemberName="GetPublishingWeb">
      <MemberSignature Language="C#" Value="public static Microsoft.SharePoint.Publishing.PublishingWeb GetPublishingWeb (Microsoft.SharePoint.SPWeb web);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig class Microsoft.SharePoint.Publishing.PublishingWeb GetPublishingWeb(class Microsoft.SharePoint.SPWeb web) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetPublishingWeb(Microsoft.SharePoint.SPWeb)" />
      <MemberSignature Language="VB.NET" Value="Public Shared Function GetPublishingWeb (web As SPWeb) As PublishingWeb" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; static Microsoft::SharePoint::Publishing::PublishingWeb ^ GetPublishingWeb(Microsoft::SharePoint::SPWeb ^ web);" />
      <MemberSignature Language="F#" Value="static member GetPublishingWeb : Microsoft.SharePoint.SPWeb -&gt; Microsoft.SharePoint.Publishing.PublishingWeb" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.GetPublishingWeb web" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>Microsoft.SharePoint.Client.ClientCallable(ClientLibraryTargets=Microsoft.SharePoint.Client.ClientLibraryTargets.NonRESTful)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PublishingWeb</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="web" Type="Microsoft.SharePoint.SPWeb" />
      </Parameters>
      <Docs>
        <param name="web">The <see cref="T:Microsoft.SharePoint.SPWeb" /> object to wrap in a <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> instance. </param>
        <summary>Retrieves an instance of the <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> that wraps the specified <see cref="T:Microsoft.SharePoint.SPWeb" /> object.</summary>
        <returns>A <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> instance which wraps the <see cref="T:Microsoft.SharePoint.SPWeb" /> class.</returns>
        <remarks>
          <para>Use this method in order to access <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> behavior for an instance of a <see cref="T:Microsoft.SharePoint.SPWeb" /> class that has already been retrieved. You can also retrieve instances of the <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> class through the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetPublishingWebs" /> method.</para>
          <para>Before you use this method, check the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.IsPublishingWeb(Microsoft.SharePoint.SPWeb)" /> method to confirm that publishing behavior is supported on this instance of the <see cref="T:Microsoft.SharePoint.SPWeb" /> class. If publishing is not supported on the <see cref="T:Microsoft.SharePoint.SPWeb" />, then the methods and properties of the <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> wrapper may behave unexpectedly.</para>
          <para>It is up to the caller of this method to close the instance of the <see cref="T:Microsoft.SharePoint.SPWeb" /> class that was passed in by calling the <b>SPWeb.Close</b> method. Calling the <b>PublishingWeb.Close</b> method has no effect.</para>
          <para />
        </remarks>
        <example>
          <para>This example demonstrates setting and saving property values on a publishing Web. Before building and running this example, verify that Publishing feature has been enabled for the <b>SPWeb</b>, and that the <b>defaultPageFileId</b> is <b>SPFile.UniqueId</b> for the new default page.</para>
          <code>using SPContentTypeId = Microsoft.SharePoint.SPContentTypeId;
using SPContentType = Microsoft.SharePoint.SPContentType;
using SPSite = Microsoft.SharePoint.SPSite;
using SPFile = Microsoft.SharePoint.SPFile;
using SPWeb = Microsoft.SharePoint.SPWeb;
using PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite;
using PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb;
using PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection;
using PageLayout = Microsoft.SharePoint.Publishing.PageLayout;

namespace Microsoft.SDK.SharePointServer.Samples
{
    public static class PublishingWebCodeSamples
    {
        public static void SetPublishingWebProperties(SPWeb web, System.Guid defaultPageFileId)
        {
// Replace these variable values and input parameters
// with your own values.
string newTitle = "your Title";         // new PublishingWeb.Title value
string newDescription = "your Description";         // new PublishingWeb.Description value
bool resetInheritPageLayouts = true;    // new PublishingWeb.IsInheritingAvailablePageLayouts value
bool resetInheritWebTemplates = true;   // new PublishingWeb.IsInheritingAvailableWebTemplates value

// Validate the input parameters.
if (null == web)
{
    throw new System.ArgumentNullException("web");
}

// Get the PublishingWeb wrapper for the SPWeb 
// that was passed in.
PublishingWeb publishingWeb = null;
if (PublishingWeb.IsPublishingWeb(web))
{
    publishingWeb = PublishingWeb.GetPublishingWeb(web);
}
else
{
    throw new System.ArgumentException("The SPWeb must be a PublishingWeb", "web");
}

//  Retrieve the SPFile.
SPFile newDefaultPageFile = publishingWeb.Web.GetFile(defaultPageFileId);
if( (null == newDefaultPageFile) ||
    !newDefaultPageFile.Exists )
{
    throw new System.ArgumentException(
        "The Guid does not match an SPFile on the SPWeb",
        "defaultPageFileId");
}

// Set new values on the PublishingWeb.
publishingWeb.Title = newTitle;
publishingWeb.Description = newDescription;
publishingWeb.DefaultPage = newDefaultPageFile;
if( resetInheritPageLayouts &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailablePageLayouts  &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailablePageLayouts();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts);
}
if (resetInheritWebTemplates &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailableWebTemplates &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailableWebTemplates();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates);
}

// Save the new values on the PublishingWeb.
publishingWeb.Update();
        }
    }
}</code>
          <code>Imports SPContentTypeId = Microsoft.SharePoint.SPContentTypeId
Imports SPContentType = Microsoft.SharePoint.SPContentType
Imports SPSite = Microsoft.SharePoint.SPSite
Imports SPFile = Microsoft.SharePoint.SPFile
Imports SPWeb = Microsoft.SharePoint.SPWeb
Imports PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite
Imports PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb
Imports PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection
Imports PageLayout = Microsoft.SharePoint.Publishing.PageLayout

Namespace Microsoft.SDK.SharePointServer.Samples
    Public NotInheritable Class PublishingWebCodeSamples
        Private Sub New()
        End Sub
        Public Shared Sub SetPublishingWebProperties(ByVal web As SPWeb, ByVal defaultPageFileId As System.Guid)
' Replace these variable values and input parameters
' with your own values.
Dim newTitle As String = "your Title" ' new PublishingWeb.Title value
Dim newDescription As String = "your Description" ' new PublishingWeb.Description value
Dim resetInheritPageLayouts As Boolean = True ' new PublishingWeb.IsInheritingAvailablePageLayouts value
Dim resetInheritWebTemplates As Boolean = True ' new PublishingWeb.IsInheritingAvailableWebTemplates value

' Validate the input parameters.
If Nothing Is web Then
    Throw New System.ArgumentNullException("web")
End If

' Get the PublishingWeb wrapper for the SPWeb 
' that was passed in.
Dim publishingWeb As PublishingWeb = Nothing
If PublishingWeb.IsPublishingWeb(web) Then
    publishingWeb = PublishingWeb.GetPublishingWeb(web)
Else
    Throw New System.ArgumentException("The SPWeb must be a PublishingWeb", "web")
End If

'  Retrieve the SPFile.
Dim newDefaultPageFile As SPFile = publishingWeb.Web.GetFile(defaultPageFileId)
If (Nothing Is newDefaultPageFile) OrElse (Not newDefaultPageFile.Exists) Then
    Throw New System.ArgumentException("The Guid does not match an SPFile on the SPWeb", "defaultPageFileId")
End If

' Set new values on the PublishingWeb.
publishingWeb.Title = newTitle
publishingWeb.Description = newDescription
publishingWeb.DefaultPage = newDefaultPageFile
If resetInheritPageLayouts AndAlso (Not publishingWeb.IsInheritingAvailablePageLayouts) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailablePageLayouts()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts)
End If
If resetInheritWebTemplates AndAlso (Not publishingWeb.IsInheritingAvailableWebTemplates) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailableWebTemplates()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates)
End If

' Save the new values on the PublishingWeb.
publishingWeb.Update()
        End Sub
    End Class
End Namespace</code>
        </example>
      </Docs>
    </Member>
    <Member MemberName="GetPublishingWebs">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.PublishingWebCollection GetPublishingWebs ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.SharePoint.Publishing.PublishingWebCollection GetPublishingWebs() cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetPublishingWebs" />
      <MemberSignature Language="VB.NET" Value="Public Function GetPublishingWebs () As PublishingWebCollection" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; Microsoft::SharePoint::Publishing::PublishingWebCollection ^ GetPublishingWebs();" />
      <MemberSignature Language="F#" Value="member this.GetPublishingWebs : unit -&gt; Microsoft.SharePoint.Publishing.PublishingWebCollection" Usage="publishingWeb.GetPublishingWebs " />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PublishingWebCollection</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Returns child <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> objects immediately below this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <returns>A <see cref="T:Microsoft.SharePoint.Publishing.PublishingWebCollection" /> collection with all child <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> objects immediately below this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />.</returns>
        <remarks>
          <para>All <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> instances in this collection should be closed by the caller using the <b>SPWeb.Close</b> method.</para>
          <para />
        </remarks>
        <example>
          <para>This method creates a new <b>PublishingWeb</b> below the root Web site of a <b>PublishingSite</b>.</para>
          <para>The <b>SPSite</b> that is passed in should be a site that supports the Publishing feature.</para>
          <code>using SPSite = Microsoft.SharePoint.SPSite;
using PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite;
using SPWeb = Microsoft.SharePoint.SPWeb;
using PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb;
using PublishingWebCollection = Microsoft.SharePoint.Publishing.PublishingWebCollection;
using SPWebTemplate = Microsoft.SharePoint.SPWebTemplate;

namespace Microsoft.SDK.SharePointServer.Samples
{
    public static class PublishingWebCollectionCodeSamples
    {

        
        public static void CreatePublishingWebBelowRoot( SPSite site, SPWebTemplate webTemplate )
        {
// Replace these variable values and input parameters with 
// your own values.
string yourWebUrlName = "yourWebUrl";   // your web URL name for the PublishingWeb to create

PublishingWeb newWeb = null;

try
{
    // Validate the input parameters.
    if (null == site)
    {
        throw new System.ArgumentNullException("site");
    }
    if (null == webTemplate)
    {
        throw new System.ArgumentNullException("webTemplate");
    }

    PublishingSite publishingSite = null;
    if (!PublishingSite.IsPublishingSite(site))
    {
        throw new System.ArgumentException(
"The SPSite is expected to be a PublishingSite",
"site");
    }
    publishingSite = new PublishingSite( site );

    SPWeb rootWeb = publishingSite.RootWeb;
    if( !PublishingWeb.IsPublishingWeb( rootWeb ))
    {
        throw new System.ArgumentException(
"The SPSite.RootWeb is expected to be a PublishingWeb",
"site");
    }

    PublishingWeb rootPublishingWeb = PublishingWeb.GetPublishingWeb( rootWeb );
    PublishingWebCollection publishingWebs = rootPublishingWeb.GetPublishingWebs();

    // Create the new PublishingWeb using the example values provided.
    newWeb = publishingWebs.Add(
        yourWebUrlName,
        rootWeb.Language,   // Replace with your language value.
        webTemplate.Name ); // Replace with your Web template name.

    // The Publishing feature is active for the new PublishingWeb.
    System.Diagnostics.Debug.Assert(
        null != newWeb.Web.Features[Microsoft.SharePoint.Publishing.FeatureIds.Publishing]);
       
}
finally
{
    // Always close the SPWeb when done to release memory.
    //
    if( null != newWeb )
    {
        newWeb.Web.Close();
    }
}

        }
    }
}</code>
          <code>Imports SPSite = Microsoft.SharePoint.SPSite
Imports PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite
Imports SPWeb = Microsoft.SharePoint.SPWeb
Imports PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb
Imports PublishingWebCollection = Microsoft.SharePoint.Publishing.PublishingWebCollection
Imports SPWebTemplate = Microsoft.SharePoint.SPWebTemplate

Namespace Microsoft.SDK.SharePointServer.Samples
    Public NotInheritable Class PublishingWebCollectionCodeSamples


        Private Sub New()
        End Sub
        Public Shared Sub CreatePublishingWebBelowRoot(ByVal site As SPSite, ByVal webTemplate As SPWebTemplate)
' Replace these variable values and input parameters with 
' your own values.
Dim yourWebUrlName As String = "yourWebUrl" ' your web URL name for the PublishingWeb to create

Dim newWeb As PublishingWeb = Nothing

Try
    ' Validate the input parameters.
    If Nothing Is site Then
        Throw New System.ArgumentNullException("site")
    End If
    If Nothing Is webTemplate Then
        Throw New System.ArgumentNullException("webTemplate")
    End If

    Dim publishingSite As PublishingSite = Nothing
    If Not PublishingSite.IsPublishingSite(site) Then
        Throw New System.ArgumentException("The SPSite is expected to be a PublishingSite", "site")
    End If
    publishingSite = New PublishingSite(site)

    Dim rootWeb As SPWeb = publishingSite.RootWeb
    If Not PublishingWeb.IsPublishingWeb(rootWeb) Then
        Throw New System.ArgumentException("The SPSite.RootWeb is expected to be a PublishingWeb", "site")
    End If

    Dim rootPublishingWeb As PublishingWeb = PublishingWeb.GetPublishingWeb(rootWeb)
    Dim publishingWebs As PublishingWebCollection = rootPublishingWeb.GetPublishingWebs()

    ' Create the new PublishingWeb using the example values provided.
    newWeb = publishingWebs.Add(yourWebUrlName, rootWeb.Language, webTemplate.Name) ' Replace with your Web template name. -  Replace with your language value.

    ' The Publishing feature is active for the new PublishingWeb.
    System.Diagnostics.Debug.Assert(Nothing IsNot newWeb.Web.Features(Microsoft.SharePoint.Publishing.FeatureIds.Publishing))

Finally
    ' Always close the SPWeb when done to release memory.
    '
    If Nothing IsNot newWeb Then
        newWeb.Web.Close()
    End If
End Try

        End Sub
    End Class
End Namespace</code>
        </example>
      </Docs>
    </Member>
    <Member MemberName="GetVariation">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.PublishingWeb GetVariation (Microsoft.SharePoint.Publishing.VariationLabel varlabel);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.SharePoint.Publishing.PublishingWeb GetVariation(class Microsoft.SharePoint.Publishing.VariationLabel varlabel) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetVariation(Microsoft.SharePoint.Publishing.VariationLabel)" />
      <MemberSignature Language="VB.NET" Value="Public Function GetVariation (varlabel As VariationLabel) As PublishingWeb" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; Microsoft::SharePoint::Publishing::PublishingWeb ^ GetVariation(Microsoft::SharePoint::Publishing::VariationLabel ^ varlabel);" />
      <MemberSignature Language="F#" Value="member this.GetVariation : Microsoft.SharePoint.Publishing.VariationLabel -&gt; Microsoft.SharePoint.Publishing.PublishingWeb" Usage="publishingWeb.GetVariation varlabel" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PublishingWeb</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="varlabel" Type="Microsoft.SharePoint.Publishing.VariationLabel" />
      </Parameters>
      <Docs>
        <param name="varlabel">The Variation Label used to search for the Variation peer <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> of the current <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</param>
        <summary>Gets the peer Variation Publishing site of this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object for the given <paramref name="varlabel." /></summary>
        <returns>A <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object that is a Variation peer of the current <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> in the requested <paramref name="varlabel." /></returns>
        <remarks>
          <para>Call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Close" /> method for the returned object when it is no longer needed to free resources that are allocated to the <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="GetVariation">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.PublishingWeb GetVariation (Microsoft.SharePoint.Publishing.VariationLabel varlabel, bool forceRefresh);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Microsoft.SharePoint.Publishing.PublishingWeb GetVariation(class Microsoft.SharePoint.Publishing.VariationLabel varlabel, bool forceRefresh) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetVariation(Microsoft.SharePoint.Publishing.VariationLabel,System.Boolean)" />
      <MemberSignature Language="VB.NET" Value="Public Function GetVariation (varlabel As VariationLabel, forceRefresh As Boolean) As PublishingWeb" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; Microsoft::SharePoint::Publishing::PublishingWeb ^ GetVariation(Microsoft::SharePoint::Publishing::VariationLabel ^ varlabel, bool forceRefresh);" />
      <MemberSignature Language="F#" Value="member this.GetVariation : Microsoft.SharePoint.Publishing.VariationLabel * bool -&gt; Microsoft.SharePoint.Publishing.PublishingWeb" Usage="publishingWeb.GetVariation (varlabel, forceRefresh)" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PublishingWeb</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="varlabel" Type="Microsoft.SharePoint.Publishing.VariationLabel" />
        <Parameter Name="forceRefresh" Type="System.Boolean" />
      </Parameters>
      <Docs>
        <param name="varlabel">The variation label to use to search for the variation peer <b>PublishingWeb</b> object of the current <b>PublishingWeb</b> object.</param>
        <param name="forceRefresh">A flag to indicate whether finding the peer <b>PublishingWeb</b> object is using cache.</param>
        <summary>Get the peer variation <b>PublishingWeb</b> object of this <b>PublishingWeb</b> object for the given label.</summary>
        <returns>Returns <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object that is a variation peer of the current <b>PublishingWeb</b> object in the requested <b>Label</b> object..</returns>
        <remarks>
          <para>Caller should call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Close" /> method on the returned object when it is not longer needed. It frees up the resources that are allocated to the <b>PublishingWeb</b> object.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="GetVariationUrlFromSourceUrl">
      <MemberSignature Language="C#" Value="public string GetVariationUrlFromSourceUrl (string sourceUrl);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance string GetVariationUrlFromSourceUrl(string sourceUrl) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetVariationUrlFromSourceUrl(System.String)" />
      <MemberSignature Language="VB.NET" Value="Public Function GetVariationUrlFromSourceUrl (sourceUrl As String) As String" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; System::String ^ GetVariationUrlFromSourceUrl(System::String ^ sourceUrl);" />
      <MemberSignature Language="F#" Value="member this.GetVariationUrlFromSourceUrl : string -&gt; string" Usage="publishingWeb.GetVariationUrlFromSourceUrl sourceUrl" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="sourceUrl" Type="System.String" />
      </Parameters>
      <Docs>
        <param name="sourceUrl">The source <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> URL.</param>
        <summary>Returns the current Variation URL for the current <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object for a specific source <b>PublishingWeb</b> location.</summary>
        <returns>The corresponding URL of the <paramref name="sourceUrl" /> in the current <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />.</returns>
        <remarks>
          <para>This method is most commonly used for implementing the <see cref="T:Microsoft.SharePoint.Publishing.IWebPartVariationUpdate" /> interface.</para>
          <para />
        </remarks>
        <example>
          <para>This code snippet demonstrates a Web Part that uses <b>GetVariationUrlFromSourceUrl</b> to translate its property WebAnchorLocation from an old value based on the <b>PublishingWeb</b> object named ownerWeb into its appropriate value in the current <b>PublishingWeb</b>.</para>
          <code>string oldAnchor = this.WebAnchorLocation;
this.WebAnchorLocation = ownerWeb.GetVariationUrlFromSourceUrl(oldAnchor);</code>
          <code>Dim oldAnchor As String = Me.WebAnchorLocation
Me.WebAnchorLocation = ownerWeb.GetVariationUrlFromSourceUrl(oldAnchor)</code>
        </example>
      </Docs>
    </Member>
    <Member MemberName="ImagesLibrary">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.SPDocumentLibrary ImagesLibrary { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.SharePoint.SPDocumentLibrary ImagesLibrary" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.ImagesLibrary" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property ImagesLibrary As SPDocumentLibrary" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property Microsoft::SharePoint::SPDocumentLibrary ^ ImagesLibrary { Microsoft::SharePoint::SPDocumentLibrary ^ get(); };" />
      <MemberSignature Language="F#" Value="member this.ImagesLibrary : Microsoft.SharePoint.SPDocumentLibrary" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.ImagesLibrary" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.SPDocumentLibrary</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets the specified Images list of the current <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>Returns <see cref="T:Microsoft.SharePoint.SPDocumentLibrary" />.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="IncludeInCurrentNavigation">
      <MemberSignature Language="C#" Value="public bool IncludeInCurrentNavigation { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance bool IncludeInCurrentNavigation" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.IncludeInCurrentNavigation" />
      <MemberSignature Language="VB.NET" Value="Public Property IncludeInCurrentNavigation As Boolean" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property bool IncludeInCurrentNavigation { bool get(); void set(bool value); };" />
      <MemberSignature Language="F#" Value="member this.IncludeInCurrentNavigation : bool with get, set" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.IncludeInCurrentNavigation" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Controls whether this Web site is included by <b>PortalSiteMapProvider</b> objects that have <b>NavigationType</b> set to <b>Current</b>.</summary>
        <value>A Boolean value that represents whether this Web site is included.The default value is <b>true</b>. The property is set to <b>true</b> if the <b>PublishingWeb</b> object should be included; otherwise, it is set to <b>false</b>.</value>
        <remarks>
          <para>This property is superseded by <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.IncludeSubSitesInNavigation" /> such that, even if this property is set to <b>true</b>, if the specified property of the parent Web site is set to <b>false</b>, this Web site does not appear in navigation.</para>
          <para>Setting this property causes the parent <b>PublishingWeb</b> to be opened, modified, or updated. This action can make other instances of the same <b>PublishingWeb</b> stale. The <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.IncludeInNavigation(System.Boolean,System.Guid)" /> or <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.ExcludeFromNavigation(System.Boolean,System.Guid)" /> methods may perform better when showing or hiding several child objects of the same parent.</para>
          <para>To save changes after setting this property, call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="IncludeInGlobalNavigation">
      <MemberSignature Language="C#" Value="public bool IncludeInGlobalNavigation { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance bool IncludeInGlobalNavigation" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.IncludeInGlobalNavigation" />
      <MemberSignature Language="VB.NET" Value="Public Property IncludeInGlobalNavigation As Boolean" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property bool IncludeInGlobalNavigation { bool get(); void set(bool value); };" />
      <MemberSignature Language="F#" Value="member this.IncludeInGlobalNavigation : bool with get, set" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.IncludeInGlobalNavigation" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets or sets a value that indicates whether this Web site is included by <b>PortalSiteMapProvider</b> objects that have <b>NavigationType</b> set to <b>Global</b>.</summary>
        <value>A Boolean value that represents whether this Web site is included.This property defaults to <b>true</b>. It is set to <b>true</b> if the <b>PublishingWeb</b> object should be included; otherwise, it is set to <b>false</b>.</value>
        <remarks>
          <para>This property is superseded by <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.IncludeSubSitesInNavigation" /> such that, even if this property is set to <b>true</b>, if the specified property on the parent Web site is set to <b>false</b>, this Web site does not appear in navigation.</para>
          <para>Setting this property opens, modifies, or updates the parent <b>PublishingWeb</b> object. This action can make other instances of the same <b>PublishingWeb</b> stale. When showing or hiding several child objects of the same parent, using <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.IncludeInNavigation(System.Boolean,System.Guid)" /> or <see cref="M:Microsoft.SharePoint.Publishing.PublishingWebExcludeFromNavigation(System.Boolean,System.Guid)" /> may perform better.</para>
          <para>To save changes after setting this property, call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="IncludePagesInNavigation">
      <MemberSignature Language="C#" Value="public bool IncludePagesInNavigation { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance bool IncludePagesInNavigation" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.IncludePagesInNavigation" />
      <MemberSignature Language="VB.NET" Value="Public Property IncludePagesInNavigation As Boolean" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property bool IncludePagesInNavigation { bool get(); void set(bool value); };" />
      <MemberSignature Language="F#" Value="member this.IncludePagesInNavigation : bool with get, set" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.IncludePagesInNavigation" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.Obsolete("Use PublishingWeb.Navigation.GlobalIncludePages/CurrentIncludePages instead.")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <summary> Gets or sets a value that indicates whether to automatically include pages in navigation.</summary>
        <value>A Boolean value representing whether to automatically include pages in navigation.Set to <b>true</b> if the <see cref="T:Microsoft.SharePoint.PublishingPage" /> objects of this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> should appear in navigation; otherwise, set to <b>false</b>.</value>
        <remarks>
          <para>This property affects only a valid <b>PublishingWeb</b> object that has a Pages list.</para>
          <para>To save changes after setting this property, call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="IncludeSubSitesInNavigation">
      <MemberSignature Language="C#" Value="public bool IncludeSubSitesInNavigation { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance bool IncludeSubSitesInNavigation" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.IncludeSubSitesInNavigation" />
      <MemberSignature Language="VB.NET" Value="Public Property IncludeSubSitesInNavigation As Boolean" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property bool IncludeSubSitesInNavigation { bool get(); void set(bool value); };" />
      <MemberSignature Language="F#" Value="member this.IncludeSubSitesInNavigation : bool with get, set" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.IncludeSubSitesInNavigation" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.Obsolete("Use PublishingWeb.Navigation.GlobalIncludeSubSites/CurrentIncludeSubSites instead.")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets or sets a value that indicates whether to automatically include subsites, or any type of <b>SPWeb</b> object, in navigation.</summary>
        <value>A Boolean value that represents whether to automatically include subsites in navigation.Set to <b>true</b> if the subsites of this site should appear in navigation; otherwise, set to <b>false</b>.</value>
        <remarks>
          <para>To save changes after setting this property, call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="InheritAvailablePageLayouts">
      <MemberSignature Language="C#" Value="public void InheritAvailablePageLayouts ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void InheritAvailablePageLayouts() cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.InheritAvailablePageLayouts" />
      <MemberSignature Language="VB.NET" Value="Public Sub InheritAvailablePageLayouts ()" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; void InheritAvailablePageLayouts();" />
      <MemberSignature Language="F#" Value="member this.InheritAvailablePageLayouts : unit -&gt; unit" Usage="publishingWeb.InheritAvailablePageLayouts " />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Sets the <b>PageLayouts</b> available on this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object to be inherited from the parent <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <remarks>
          <para>After calling this method, the <see cref="M:Microsoft.SharePoint.Publishing.PageLayout.GetAvailablePageLayouts" /> method returns the same set of <see cref="T:Microsoft.SharePoint.Publishing.PageLayout" /> objects that are specified in the parent <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> class. The <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.IsInheritingAvailablePageLayouts" /> property is <b>true</b>. The <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.IsAllowingAllPageLayouts" /> property returns the same value as the parent <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />.</para>
          <para>Calling this method on the root site is not supported and results in an error.</para>
          <para />
        </remarks>
        <exception cref="System.InvalidOperationException">The root site cannot inherit properties.</exception>
      </Docs>
    </Member>
    <Member MemberName="InheritAvailableWebTemplates">
      <MemberSignature Language="C#" Value="public void InheritAvailableWebTemplates ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void InheritAvailableWebTemplates() cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.InheritAvailableWebTemplates" />
      <MemberSignature Language="VB.NET" Value="Public Sub InheritAvailableWebTemplates ()" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; void InheritAvailableWebTemplates();" />
      <MemberSignature Language="F#" Value="member this.InheritAvailableWebTemplates : unit -&gt; unit" Usage="publishingWeb.InheritAvailableWebTemplates " />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Sets the available web templates on this PublishingWeb to be inherited from the parent <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />. </summary>
        <remarks>
          <para>After calling this method, the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetAvailableWebTemplates" /> method returns the same set of Web templates that are specified in the parent <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> class. The <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.IsInheritingAvailableWebTemplates" /> property is <b>true</b>. The <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.IsAllowingAllWebTemplates" /> property returns the same value as the parent <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> class.</para>
          <para>Calling this method on the root site is not supported and results in an error.</para>
          <para />
        </remarks>
        <exception cref="System.InvalidOperationException">The root site cannot inherit properties.</exception>
        <example>
          <para>This example demonstrates setting and saving property values on a publishing Web. Before building and running this example, verify that Publishing feature has been enabled for the <b>SPWeb</b>, and that the <b>defaultPageFileId</b> is <b>SPFile.UniqueId</b> for the new default page.</para>
          <code>using SPContentTypeId = Microsoft.SharePoint.SPContentTypeId;
using SPContentType = Microsoft.SharePoint.SPContentType;
using SPSite = Microsoft.SharePoint.SPSite;
using SPFile = Microsoft.SharePoint.SPFile;
using SPWeb = Microsoft.SharePoint.SPWeb;
using PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite;
using PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb;
using PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection;
using PageLayout = Microsoft.SharePoint.Publishing.PageLayout;

namespace Microsoft.SDK.SharePointServer.Samples
{
    public static class PublishingWebCodeSamples
    {
        public static void SetPublishingWebProperties(SPWeb web, System.Guid defaultPageFileId)
        {
// Replace these variable values and input parameters
// with your own values.
string newTitle = "your Title";         // new PublishingWeb.Title value
string newDescription = "your Description";         // new PublishingWeb.Description value
bool resetInheritPageLayouts = true;    // new PublishingWeb.IsInheritingAvailablePageLayouts value
bool resetInheritWebTemplates = true;   // new PublishingWeb.IsInheritingAvailableWebTemplates value

// Validate the input parameters.
if (null == web)
{
    throw new System.ArgumentNullException("web");
}

// Get the PublishingWeb wrapper for the SPWeb 
// that was passed in.
PublishingWeb publishingWeb = null;
if (PublishingWeb.IsPublishingWeb(web))
{
    publishingWeb = PublishingWeb.GetPublishingWeb(web);
}
else
{
    throw new System.ArgumentException("The SPWeb must be a PublishingWeb", "web");
}

//  Retrieve the SPFile.
SPFile newDefaultPageFile = publishingWeb.Web.GetFile(defaultPageFileId);
if( (null == newDefaultPageFile) ||
    !newDefaultPageFile.Exists )
{
    throw new System.ArgumentException(
        "The Guid does not match an SPFile on the SPWeb",
        "defaultPageFileId");
}

// Set new values on the PublishingWeb.
publishingWeb.Title = newTitle;
publishingWeb.Description = newDescription;
publishingWeb.DefaultPage = newDefaultPageFile;
if( resetInheritPageLayouts &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailablePageLayouts  &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailablePageLayouts();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts);
}
if (resetInheritWebTemplates &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailableWebTemplates &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailableWebTemplates();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates);
}

// Save the new values on the PublishingWeb.
publishingWeb.Update();
        }
    }
}</code>
          <code>Imports SPContentTypeId = Microsoft.SharePoint.SPContentTypeId
Imports SPContentType = Microsoft.SharePoint.SPContentType
Imports SPSite = Microsoft.SharePoint.SPSite
Imports SPFile = Microsoft.SharePoint.SPFile
Imports SPWeb = Microsoft.SharePoint.SPWeb
Imports PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite
Imports PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb
Imports PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection
Imports PageLayout = Microsoft.SharePoint.Publishing.PageLayout

Namespace Microsoft.SDK.SharePointServer.Samples
    Public NotInheritable Class PublishingWebCodeSamples
        Private Sub New()
        End Sub
        Public Shared Sub SetPublishingWebProperties(ByVal web As SPWeb, ByVal defaultPageFileId As System.Guid)
' Replace these variable values and input parameters
' with your own values.
Dim newTitle As String = "your Title" ' new PublishingWeb.Title value
Dim newDescription As String = "your Description" ' new PublishingWeb.Description value
Dim resetInheritPageLayouts As Boolean = True ' new PublishingWeb.IsInheritingAvailablePageLayouts value
Dim resetInheritWebTemplates As Boolean = True ' new PublishingWeb.IsInheritingAvailableWebTemplates value

' Validate the input parameters.
If Nothing Is web Then
    Throw New System.ArgumentNullException("web")
End If

' Get the PublishingWeb wrapper for the SPWeb 
' that was passed in.
Dim publishingWeb As PublishingWeb = Nothing
If PublishingWeb.IsPublishingWeb(web) Then
    publishingWeb = PublishingWeb.GetPublishingWeb(web)
Else
    Throw New System.ArgumentException("The SPWeb must be a PublishingWeb", "web")
End If

'  Retrieve the SPFile.
Dim newDefaultPageFile As SPFile = publishingWeb.Web.GetFile(defaultPageFileId)
If (Nothing Is newDefaultPageFile) OrElse (Not newDefaultPageFile.Exists) Then
    Throw New System.ArgumentException("The Guid does not match an SPFile on the SPWeb", "defaultPageFileId")
End If

' Set new values on the PublishingWeb.
publishingWeb.Title = newTitle
publishingWeb.Description = newDescription
publishingWeb.DefaultPage = newDefaultPageFile
If resetInheritPageLayouts AndAlso (Not publishingWeb.IsInheritingAvailablePageLayouts) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailablePageLayouts()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts)
End If
If resetInheritWebTemplates AndAlso (Not publishingWeb.IsInheritingAvailableWebTemplates) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailableWebTemplates()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates)
End If

' Save the new values on the PublishingWeb.
publishingWeb.Update()
        End Sub
    End Class
End Namespace</code>
        </example>
      </Docs>
    </Member>
    <Member MemberName="InheritCurrentNavigation">
      <MemberSignature Language="C#" Value="public bool InheritCurrentNavigation { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance bool InheritCurrentNavigation" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.InheritCurrentNavigation" />
      <MemberSignature Language="VB.NET" Value="Public Property InheritCurrentNavigation As Boolean" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property bool InheritCurrentNavigation { bool get(); void set(bool value); };" />
      <MemberSignature Language="F#" Value="member this.InheritCurrentNavigation : bool with get, set" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.InheritCurrentNavigation" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.Obsolete("Use PublishingWeb.Navigation.InheritCurrent instead.")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets or sets a value that indicates whether the current navigation should be inherited.</summary>
        <value>
          <b>true</b> if the navigation should be inherited; otherwise, <b>false</b>.</value>
        <remarks>
          <para>To save changes after setting this property, call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="InheritDefaultPageLayout">
      <MemberSignature Language="C#" Value="public void InheritDefaultPageLayout ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void InheritDefaultPageLayout() cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.InheritDefaultPageLayout" />
      <MemberSignature Language="VB.NET" Value="Public Sub InheritDefaultPageLayout ()" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; void InheritDefaultPageLayout();" />
      <MemberSignature Language="F#" Value="member this.InheritDefaultPageLayout : unit -&gt; unit" Usage="publishingWeb.InheritDefaultPageLayout " />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Sets the new page URL token on this <b>PublishingWeb</b> object to be inherited from the parent <b>PublishingWeb</b> object.</summary>
        <remarks>
          <para>After calling this method, the <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.NewPageUrlToken" /> property will return the same value that is specified in the parent <b>PublishingWeb</b> object. The <b>P:Microsoft.SharePoint.Publishing.PublishingWeb.IsInheritingNewPageUrlToken</b> property will be <b>True</b>.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="InheritGlobalNavigation">
      <MemberSignature Language="C#" Value="public bool InheritGlobalNavigation { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance bool InheritGlobalNavigation" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.InheritGlobalNavigation" />
      <MemberSignature Language="VB.NET" Value="Public Property InheritGlobalNavigation As Boolean" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property bool InheritGlobalNavigation { bool get(); void set(bool value); };" />
      <MemberSignature Language="F#" Value="member this.InheritGlobalNavigation : bool with get, set" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.InheritGlobalNavigation" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.Obsolete("Use PublishingWeb.Navigation.InheritGlobal instead.")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets or sets a value that indicates whether this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object should display its own global navigation or should use the global navigation of its parent.</summary>
        <value>A Boolean value that represents whether this Web should inherit its global navigation.Set to <b>true</b> if the parent of this <b>PublishingWeb</b> object should be used as the root for the global navigation; otherwise, it is set to <b>false</b>.</value>
        <remarks>
          <para>This property wraps the <see cref="P:Microsoft.SharePoint.Navigation.SPNavigation.UseShared" /> property.</para>
          <para>The top-level Web site cannot inherit its global navigation. Most <b>PublishingWeb</b> objects that are not root Web sites inherit global navigation.</para>
          <para>This property affects the starting node for global navigation. By default, global navigation starts at the root Web site, so this Web site and those beneath it are displayed even when a user is visiting a Web site further down the hierarchy.</para>
          <para>To save changes after setting this property, call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="InheritNewPageUrlToken">
      <MemberSignature Language="C#" Value="public void InheritNewPageUrlToken ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void InheritNewPageUrlToken() cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.InheritNewPageUrlToken" />
      <MemberSignature Language="VB.NET" Value="Public Sub InheritNewPageUrlToken ()" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; void InheritNewPageUrlToken();" />
      <MemberSignature Language="F#" Value="member this.InheritNewPageUrlToken : unit -&gt; unit" Usage="publishingWeb.InheritNewPageUrlToken " />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>This member is reserved for internal use and is not intended to be used directly from your code.</summary>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="IsAllowingAllPageLayouts">
      <MemberSignature Language="C#" Value="public bool IsAllowingAllPageLayouts { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance bool IsAllowingAllPageLayouts" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.IsAllowingAllPageLayouts" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property IsAllowingAllPageLayouts As Boolean" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property bool IsAllowingAllPageLayouts { bool get(); };" />
      <MemberSignature Language="F#" Value="member this.IsAllowingAllPageLayouts : bool" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.IsAllowingAllPageLayouts" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets a Boolean value that indicates whether the available <see cref="T:Microsoft.SharePoint.Publishing.PageLayout" /> objects that are returned by the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetAvailablePageLayouts" /> method are the complete set of page layouts.</summary>
        <value>
          <b>true</b> if the available <see cref="T:Microsoft.SharePoint.Publishing.PageLayout" /> objects for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> are the complete set; otherwise, <b>false</b>.</value>
        <remarks>To be added.</remarks>
        <example>
          <para>This example restricts the set of available page layouts used for creating pages in a publishing Web so that only page layouts associated with a specified content type are available.</para>
          <para>Before using this example, verify that the <paramref name="associatedContentTypeId" /> parameter is from a content type on the top-level Web site of the site.</para>
          <code>using SPContentTypeId = Microsoft.SharePoint.SPContentTypeId;
using SPContentType = Microsoft.SharePoint.SPContentType;
using SPSite = Microsoft.SharePoint.SPSite;
using SPFile = Microsoft.SharePoint.SPFile;
using SPWeb = Microsoft.SharePoint.SPWeb;
using PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite;
using PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb;
using PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection;
using PageLayout = Microsoft.SharePoint.Publishing.PageLayout;

namespace Microsoft.SDK.SharePointServer.Samples
{
    public static class PublishingWebCodeSamples
    {
  
        public static void RestrictPageLayoutsByContentType(
PublishingWeb publishingWeb, 
SPContentTypeId associatedContentTypeId)
        {
// Replace these variable values and input parameters with your own values.
bool excludeHiddenLayouts = true;
bool resetAllSubsitesToInherit = true;

// Validate the input parameters.
if (null == publishingWeb)
{
    throw new System.ArgumentNullException("publishingWeb");
}

SPSite site = publishingWeb.Web.Site;
PublishingSite publishingSite = new PublishingSite(site);

// Retrieve a collection of all page layouts in the site collection
// that match the content type.
SPContentType associatedContentType = publishingSite.ContentTypes[associatedContentTypeId];
if (null == associatedContentType)
{
    throw new System.ArgumentException(
        "The SPContentTypeId did not match an SPContentType in the SPSite.RootWeb",
        "associatedContentTypeId");
}

PageLayoutCollection pageLayoutsByContentType = 
    publishingSite.GetPageLayouts(associatedContentType, excludeHiddenLayouts);

// Update the Web site to use these page layouts when creating pages.
publishingWeb.SetAvailablePageLayouts(
    pageLayoutsByContentType.ToArray(),
    resetAllSubsitesToInherit);

publishingWeb.Update();

// Verify the expected results. Note: This is not required. It demonstrates
// the results of calling the SetAvailablePageLayouts method.
//
System.Diagnostics.Debug.Assert(!publishingWeb.IsAllowingAllPageLayouts);
System.Diagnostics.Debug.Assert(!publishingWeb.IsInheritingAvailablePageLayouts);

PageLayout[] availablePageLayouts = publishingWeb.GetAvailablePageLayouts();
foreach (PageLayout pageLayout in availablePageLayouts)
{
    System.Diagnostics.Debug.Assert(
        pageLayout.AssociatedContentType.Id == associatedContentTypeId);
}
        }
    }
}</code>
          <code>Imports SPContentTypeId = Microsoft.SharePoint.SPContentTypeId
Imports SPContentType = Microsoft.SharePoint.SPContentType
Imports SPSite = Microsoft.SharePoint.SPSite
Imports SPFile = Microsoft.SharePoint.SPFile
Imports SPWeb = Microsoft.SharePoint.SPWeb
Imports PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite
Imports PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb
Imports PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection
Imports PageLayout = Microsoft.SharePoint.Publishing.PageLayout

Namespace Microsoft.SDK.SharePointServer.Samples
    Public NotInheritable Class PublishingWebCodeSamples

        Private Sub New()
        End Sub
        Public Shared Sub RestrictPageLayoutsByContentType(ByVal publishingWeb As PublishingWeb, ByVal associatedContentTypeId As SPContentTypeId)
' Replace these variable values and input parameters with your own values.
Dim excludeHiddenLayouts As Boolean = True
Dim resetAllSubsitesToInherit As Boolean = True

' Validate the input parameters.
If Nothing Is publishingWeb Then
    Throw New System.ArgumentNullException("publishingWeb")
End If

Dim site As SPSite = publishingWeb.Web.Site
Dim publishingSite As New PublishingSite(site)

' Retrieve a collection of all page layouts in the site collection
' that match the content type.
Dim associatedContentType As SPContentType = publishingSite.ContentTypes(associatedContentTypeId)
If Nothing Is associatedContentType Then
    Throw New System.ArgumentException("The SPContentTypeId did not match an SPContentType in the SPSite.RootWeb", "associatedContentTypeId")
End If

Dim pageLayoutsByContentType As PageLayoutCollection = publishingSite.GetPageLayouts(associatedContentType, excludeHiddenLayouts)

' Update the Web site to use these page layouts when creating pages.
publishingWeb.SetAvailablePageLayouts(pageLayoutsByContentType.ToArray(), resetAllSubsitesToInherit)

publishingWeb.Update()

' Verify the expected results. Note: This is not required. It demonstrates
' the results of calling the SetAvailablePageLayouts method.
'
System.Diagnostics.Debug.Assert((Not publishingWeb.IsAllowingAllPageLayouts))
System.Diagnostics.Debug.Assert((Not publishingWeb.IsInheritingAvailablePageLayouts))

Dim availablePageLayouts() As PageLayout = publishingWeb.GetAvailablePageLayouts()
For Each pageLayout As PageLayout In availablePageLayouts
    System.Diagnostics.Debug.Assert(pageLayout.AssociatedContentType.Id Is associatedContentTypeId)
Next pageLayout
        End Sub
    End Class
End Namespace</code>
        </example>
      </Docs>
    </Member>
    <Member MemberName="IsAllowingAllWebTemplates">
      <MemberSignature Language="C#" Value="public bool IsAllowingAllWebTemplates { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance bool IsAllowingAllWebTemplates" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.IsAllowingAllWebTemplates" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property IsAllowingAllWebTemplates As Boolean" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property bool IsAllowingAllWebTemplates { bool get(); };" />
      <MemberSignature Language="F#" Value="member this.IsAllowingAllWebTemplates : bool" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.IsAllowingAllWebTemplates" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets a Boolean value that indicates whether the available Web templates that are returned by the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetAvailableWebTemplates" /> method are the complete set.</summary>
        <value>
          <b>true</b> if the available Web templates for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object are the complete set; otherwise, <b>false</b>.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="IsInheritingAvailablePageLayouts">
      <MemberSignature Language="C#" Value="public bool IsInheritingAvailablePageLayouts { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance bool IsInheritingAvailablePageLayouts" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.IsInheritingAvailablePageLayouts" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property IsInheritingAvailablePageLayouts As Boolean" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property bool IsInheritingAvailablePageLayouts { bool get(); };" />
      <MemberSignature Language="F#" Value="member this.IsInheritingAvailablePageLayouts : bool" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.IsInheritingAvailablePageLayouts" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets a Boolean value that indicates whether the available <see cref="T:Microsoft.SharePoint.Publishing.PageLayout" /> objects that are returned by the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetAvailablePageLayouts" /> method are inherited from the parent <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>
          <b>true</b> if the available <see cref="T:Microsoft.SharePoint.Publishing.PageLayout" /> objects for this <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb" /> object are inherited from the parent <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb" />; otherwise, <b>false</b>.</value>
        <remarks>To be added.</remarks>
        <example>
          <para>This example demonstrates setting and saving property values on a publishing Web. Before building and running this example, verify that Publishing feature has been enabled for the <b>SPWeb</b>, and that the <b>defaultPageFileId</b> is <b>SPFile.UniqueId</b> for the new default page.</para>
          <code>using SPContentTypeId = Microsoft.SharePoint.SPContentTypeId;
using SPContentType = Microsoft.SharePoint.SPContentType;
using SPSite = Microsoft.SharePoint.SPSite;
using SPFile = Microsoft.SharePoint.SPFile;
using SPWeb = Microsoft.SharePoint.SPWeb;
using PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite;
using PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb;
using PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection;
using PageLayout = Microsoft.SharePoint.Publishing.PageLayout;

namespace Microsoft.SDK.SharePointServer.Samples
{
    public static class PublishingWebCodeSamples
    {
        public static void SetPublishingWebProperties(SPWeb web, System.Guid defaultPageFileId)
        {
// Replace these variable values and input parameters
// with your own values.
string newTitle = "your Title";         // new PublishingWeb.Title value
string newDescription = "your Description";         // new PublishingWeb.Description value
bool resetInheritPageLayouts = true;    // new PublishingWeb.IsInheritingAvailablePageLayouts value
bool resetInheritWebTemplates = true;   // new PublishingWeb.IsInheritingAvailableWebTemplates value

// Validate the input parameters.
if (null == web)
{
    throw new System.ArgumentNullException("web");
}

// Get the PublishingWeb wrapper for the SPWeb 
// that was passed in.
PublishingWeb publishingWeb = null;
if (PublishingWeb.IsPublishingWeb(web))
{
    publishingWeb = PublishingWeb.GetPublishingWeb(web);
}
else
{
    throw new System.ArgumentException("The SPWeb must be a PublishingWeb", "web");
}

//  Retrieve the SPFile.
SPFile newDefaultPageFile = publishingWeb.Web.GetFile(defaultPageFileId);
if( (null == newDefaultPageFile) ||
    !newDefaultPageFile.Exists )
{
    throw new System.ArgumentException(
        "The Guid does not match an SPFile on the SPWeb",
        "defaultPageFileId");
}

// Set new values on the PublishingWeb.
publishingWeb.Title = newTitle;
publishingWeb.Description = newDescription;
publishingWeb.DefaultPage = newDefaultPageFile;
if( resetInheritPageLayouts &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailablePageLayouts  &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailablePageLayouts();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts);
}
if (resetInheritWebTemplates &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailableWebTemplates &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailableWebTemplates();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates);
}

// Save the new values on the PublishingWeb.
publishingWeb.Update();
        }
    }
}</code>
          <code>Imports SPContentTypeId = Microsoft.SharePoint.SPContentTypeId
Imports SPContentType = Microsoft.SharePoint.SPContentType
Imports SPSite = Microsoft.SharePoint.SPSite
Imports SPFile = Microsoft.SharePoint.SPFile
Imports SPWeb = Microsoft.SharePoint.SPWeb
Imports PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite
Imports PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb
Imports PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection
Imports PageLayout = Microsoft.SharePoint.Publishing.PageLayout

Namespace Microsoft.SDK.SharePointServer.Samples
    Public NotInheritable Class PublishingWebCodeSamples
        Private Sub New()
        End Sub
        Public Shared Sub SetPublishingWebProperties(ByVal web As SPWeb, ByVal defaultPageFileId As System.Guid)
' Replace these variable values and input parameters
' with your own values.
Dim newTitle As String = "your Title" ' new PublishingWeb.Title value
Dim newDescription As String = "your Description" ' new PublishingWeb.Description value
Dim resetInheritPageLayouts As Boolean = True ' new PublishingWeb.IsInheritingAvailablePageLayouts value
Dim resetInheritWebTemplates As Boolean = True ' new PublishingWeb.IsInheritingAvailableWebTemplates value

' Validate the input parameters.
If Nothing Is web Then
    Throw New System.ArgumentNullException("web")
End If

' Get the PublishingWeb wrapper for the SPWeb 
' that was passed in.
Dim publishingWeb As PublishingWeb = Nothing
If PublishingWeb.IsPublishingWeb(web) Then
    publishingWeb = PublishingWeb.GetPublishingWeb(web)
Else
    Throw New System.ArgumentException("The SPWeb must be a PublishingWeb", "web")
End If

'  Retrieve the SPFile.
Dim newDefaultPageFile As SPFile = publishingWeb.Web.GetFile(defaultPageFileId)
If (Nothing Is newDefaultPageFile) OrElse (Not newDefaultPageFile.Exists) Then
    Throw New System.ArgumentException("The Guid does not match an SPFile on the SPWeb", "defaultPageFileId")
End If

' Set new values on the PublishingWeb.
publishingWeb.Title = newTitle
publishingWeb.Description = newDescription
publishingWeb.DefaultPage = newDefaultPageFile
If resetInheritPageLayouts AndAlso (Not publishingWeb.IsInheritingAvailablePageLayouts) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailablePageLayouts()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts)
End If
If resetInheritWebTemplates AndAlso (Not publishingWeb.IsInheritingAvailableWebTemplates) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailableWebTemplates()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates)
End If

' Save the new values on the PublishingWeb.
publishingWeb.Update()
        End Sub
    End Class
End Namespace</code>
        </example>
      </Docs>
    </Member>
    <Member MemberName="IsInheritingAvailableWebTemplates">
      <MemberSignature Language="C#" Value="public bool IsInheritingAvailableWebTemplates { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance bool IsInheritingAvailableWebTemplates" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.IsInheritingAvailableWebTemplates" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property IsInheritingAvailableWebTemplates As Boolean" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property bool IsInheritingAvailableWebTemplates { bool get(); };" />
      <MemberSignature Language="F#" Value="member this.IsInheritingAvailableWebTemplates : bool" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.IsInheritingAvailableWebTemplates" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets a Boolean value that indicates whether the available Web templates that are returned by the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetAvailableWebTemplates" /> method are inherited from the parent <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />.</summary>
        <value>
          <b>true</b> if the available Web templates for <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> are inherited from the parent <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />; otherwise, <b>false</b>.</value>
        <remarks>To be added.</remarks>
        <example>
          <para>This example demonstrates setting and saving property values on a publishing Web. Before building and running this example, verify that Publishing feature has been enabled for the <b>SPWeb</b>, and that the <b>defaultPageFileId</b> is <b>SPFile.UniqueId</b> for the new default page.</para>
          <code>using SPContentTypeId = Microsoft.SharePoint.SPContentTypeId;
using SPContentType = Microsoft.SharePoint.SPContentType;
using SPSite = Microsoft.SharePoint.SPSite;
using SPFile = Microsoft.SharePoint.SPFile;
using SPWeb = Microsoft.SharePoint.SPWeb;
using PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite;
using PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb;
using PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection;
using PageLayout = Microsoft.SharePoint.Publishing.PageLayout;

namespace Microsoft.SDK.SharePointServer.Samples
{
    public static class PublishingWebCodeSamples
    {
        public static void SetPublishingWebProperties(SPWeb web, System.Guid defaultPageFileId)
        {
// Replace these variable values and input parameters
// with your own values.
string newTitle = "your Title";         // new PublishingWeb.Title value
string newDescription = "your Description";         // new PublishingWeb.Description value
bool resetInheritPageLayouts = true;    // new PublishingWeb.IsInheritingAvailablePageLayouts value
bool resetInheritWebTemplates = true;   // new PublishingWeb.IsInheritingAvailableWebTemplates value

// Validate the input parameters.
if (null == web)
{
    throw new System.ArgumentNullException("web");
}

// Get the PublishingWeb wrapper for the SPWeb 
// that was passed in.
PublishingWeb publishingWeb = null;
if (PublishingWeb.IsPublishingWeb(web))
{
    publishingWeb = PublishingWeb.GetPublishingWeb(web);
}
else
{
    throw new System.ArgumentException("The SPWeb must be a PublishingWeb", "web");
}

//  Retrieve the SPFile.
SPFile newDefaultPageFile = publishingWeb.Web.GetFile(defaultPageFileId);
if( (null == newDefaultPageFile) ||
    !newDefaultPageFile.Exists )
{
    throw new System.ArgumentException(
        "The Guid does not match an SPFile on the SPWeb",
        "defaultPageFileId");
}

// Set new values on the PublishingWeb.
publishingWeb.Title = newTitle;
publishingWeb.Description = newDescription;
publishingWeb.DefaultPage = newDefaultPageFile;
if( resetInheritPageLayouts &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailablePageLayouts  &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailablePageLayouts();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts);
}
if (resetInheritWebTemplates &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailableWebTemplates &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailableWebTemplates();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates);
}

// Save the new values on the PublishingWeb.
publishingWeb.Update();
        }
    }
}</code>
          <code>Imports SPContentTypeId = Microsoft.SharePoint.SPContentTypeId
Imports SPContentType = Microsoft.SharePoint.SPContentType
Imports SPSite = Microsoft.SharePoint.SPSite
Imports SPFile = Microsoft.SharePoint.SPFile
Imports SPWeb = Microsoft.SharePoint.SPWeb
Imports PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite
Imports PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb
Imports PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection
Imports PageLayout = Microsoft.SharePoint.Publishing.PageLayout

Namespace Microsoft.SDK.SharePointServer.Samples
    Public NotInheritable Class PublishingWebCodeSamples
        Private Sub New()
        End Sub
        Public Shared Sub SetPublishingWebProperties(ByVal web As SPWeb, ByVal defaultPageFileId As System.Guid)
' Replace these variable values and input parameters
' with your own values.
Dim newTitle As String = "your Title" ' new PublishingWeb.Title value
Dim newDescription As String = "your Description" ' new PublishingWeb.Description value
Dim resetInheritPageLayouts As Boolean = True ' new PublishingWeb.IsInheritingAvailablePageLayouts value
Dim resetInheritWebTemplates As Boolean = True ' new PublishingWeb.IsInheritingAvailableWebTemplates value

' Validate the input parameters.
If Nothing Is web Then
    Throw New System.ArgumentNullException("web")
End If

' Get the PublishingWeb wrapper for the SPWeb 
' that was passed in.
Dim publishingWeb As PublishingWeb = Nothing
If PublishingWeb.IsPublishingWeb(web) Then
    publishingWeb = PublishingWeb.GetPublishingWeb(web)
Else
    Throw New System.ArgumentException("The SPWeb must be a PublishingWeb", "web")
End If

'  Retrieve the SPFile.
Dim newDefaultPageFile As SPFile = publishingWeb.Web.GetFile(defaultPageFileId)
If (Nothing Is newDefaultPageFile) OrElse (Not newDefaultPageFile.Exists) Then
    Throw New System.ArgumentException("The Guid does not match an SPFile on the SPWeb", "defaultPageFileId")
End If

' Set new values on the PublishingWeb.
publishingWeb.Title = newTitle
publishingWeb.Description = newDescription
publishingWeb.DefaultPage = newDefaultPageFile
If resetInheritPageLayouts AndAlso (Not publishingWeb.IsInheritingAvailablePageLayouts) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailablePageLayouts()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts)
End If
If resetInheritWebTemplates AndAlso (Not publishingWeb.IsInheritingAvailableWebTemplates) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailableWebTemplates()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates)
End If

' Save the new values on the PublishingWeb.
publishingWeb.Update()
        End Sub
    End Class
End Namespace</code>
        </example>
      </Docs>
    </Member>
    <Member MemberName="IsInheritingDefaultPageLayout">
      <MemberSignature Language="C#" Value="public bool IsInheritingDefaultPageLayout { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance bool IsInheritingDefaultPageLayout" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.IsInheritingDefaultPageLayout" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property IsInheritingDefaultPageLayout As Boolean" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property bool IsInheritingDefaultPageLayout { bool get(); };" />
      <MemberSignature Language="F#" Value="member this.IsInheritingDefaultPageLayout : bool" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.IsInheritingDefaultPageLayout" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Specifies the page layout that will be used when creating “one-click” pages within this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object through the UI.</summary>
        <value>Returns <see cref="T:System.Boolean" />.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="IsInheritingNewPageUrlToken">
      <MemberSignature Language="C#" Value="public bool IsInheritingNewPageUrlToken { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance bool IsInheritingNewPageUrlToken" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.IsInheritingNewPageUrlToken" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property IsInheritingNewPageUrlToken As Boolean" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property bool IsInheritingNewPageUrlToken { bool get(); };" />
      <MemberSignature Language="F#" Value="member this.IsInheritingNewPageUrlToken : bool" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.IsInheritingNewPageUrlToken" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets a Boolean value indicating whether the new page URL token that is returned by the <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.NewPageUrlToken" /> property is inherited from the parent <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>Returns <see cref="T:System.Boolean" />.</value>
        <remarks>
          <para>
            <b>true</b> if the new page URL token for this <b>PublishingWeb</b> object is inherited from the parent <b>PublishingWeb</b> object; otherwise, <b>false</b>.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="IsPublishingWeb">
      <MemberSignature Language="C#" Value="public static bool IsPublishingWeb (Microsoft.SharePoint.SPWeb web);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig bool IsPublishingWeb(class Microsoft.SharePoint.SPWeb web) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.IsPublishingWeb(Microsoft.SharePoint.SPWeb)" />
      <MemberSignature Language="VB.NET" Value="Public Shared Function IsPublishingWeb (web As SPWeb) As Boolean" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; static bool IsPublishingWeb(Microsoft::SharePoint::SPWeb ^ web);" />
      <MemberSignature Language="F#" Value="static member IsPublishingWeb : Microsoft.SharePoint.SPWeb -&gt; bool" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.IsPublishingWeb web" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="web" Type="Microsoft.SharePoint.SPWeb" />
      </Parameters>
      <Docs>
        <param name="web">The <see cref="T:Microsoft.SharePoint.SPWeb" /> object to be validated.</param>
        <summary>Checks the <see cref="T:Microsoft.SharePoint.SPWeb" /> object to verify whether it is a <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <returns>
          <b>true</b> if the <see cref="T:Microsoft.SharePoint.SPWeb" /> class supports being wrapped in a <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> instance; otherwise, <b>false</b>.</returns>
        <remarks>
          <para>This method checks the <see cref="T:Microsoft.SharePoint.SPWeb" /> instance to determine if the Publishing feature has been activated on it.</para>
          <para>We recommend that you use this method before you call the <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb.GetPublishingWeb(Microsoft.SharePoint.SPWeb)" /> method.</para>
          <para />
        </remarks>
        <exception cref="System.ArgumentNullException">The <see cref="T:Microsoft.SharePoint.SPWeb" /> cannot be <b>null.</b></exception>
        <example>
          <para>This example demonstrates setting and saving property values on a publishing Web. Before building and running this example, verify that Publishing feature has been enabled for the <b>SPWeb</b>, and that the <b>defaultPageFileId</b> is <b>SPFile.UniqueId</b> for the new default page.</para>
          <code>using SPContentTypeId = Microsoft.SharePoint.SPContentTypeId;
using SPContentType = Microsoft.SharePoint.SPContentType;
using SPSite = Microsoft.SharePoint.SPSite;
using SPFile = Microsoft.SharePoint.SPFile;
using SPWeb = Microsoft.SharePoint.SPWeb;
using PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite;
using PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb;
using PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection;
using PageLayout = Microsoft.SharePoint.Publishing.PageLayout;

namespace Microsoft.SDK.SharePointServer.Samples
{
    public static class PublishingWebCodeSamples
    {
        public static void SetPublishingWebProperties(SPWeb web, System.Guid defaultPageFileId)
        {
// Replace these variable values and input parameters
// with your own values.
string newTitle = "your Title";         // new PublishingWeb.Title value
string newDescription = "your Description";         // new PublishingWeb.Description value
bool resetInheritPageLayouts = true;    // new PublishingWeb.IsInheritingAvailablePageLayouts value
bool resetInheritWebTemplates = true;   // new PublishingWeb.IsInheritingAvailableWebTemplates value

// Validate the input parameters.
if (null == web)
{
    throw new System.ArgumentNullException("web");
}

// Get the PublishingWeb wrapper for the SPWeb 
// that was passed in.
PublishingWeb publishingWeb = null;
if (PublishingWeb.IsPublishingWeb(web))
{
    publishingWeb = PublishingWeb.GetPublishingWeb(web);
}
else
{
    throw new System.ArgumentException("The SPWeb must be a PublishingWeb", "web");
}

//  Retrieve the SPFile.
SPFile newDefaultPageFile = publishingWeb.Web.GetFile(defaultPageFileId);
if( (null == newDefaultPageFile) ||
    !newDefaultPageFile.Exists )
{
    throw new System.ArgumentException(
        "The Guid does not match an SPFile on the SPWeb",
        "defaultPageFileId");
}

// Set new values on the PublishingWeb.
publishingWeb.Title = newTitle;
publishingWeb.Description = newDescription;
publishingWeb.DefaultPage = newDefaultPageFile;
if( resetInheritPageLayouts &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailablePageLayouts  &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailablePageLayouts();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts);
}
if (resetInheritWebTemplates &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailableWebTemplates &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailableWebTemplates();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates);
}

// Save the new values on the PublishingWeb.
publishingWeb.Update();
        }
    }
}</code>
          <code>Imports SPContentTypeId = Microsoft.SharePoint.SPContentTypeId
Imports SPContentType = Microsoft.SharePoint.SPContentType
Imports SPSite = Microsoft.SharePoint.SPSite
Imports SPFile = Microsoft.SharePoint.SPFile
Imports SPWeb = Microsoft.SharePoint.SPWeb
Imports PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite
Imports PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb
Imports PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection
Imports PageLayout = Microsoft.SharePoint.Publishing.PageLayout

Namespace Microsoft.SDK.SharePointServer.Samples
    Public NotInheritable Class PublishingWebCodeSamples
        Private Sub New()
        End Sub
        Public Shared Sub SetPublishingWebProperties(ByVal web As SPWeb, ByVal defaultPageFileId As System.Guid)
' Replace these variable values and input parameters
' with your own values.
Dim newTitle As String = "your Title" ' new PublishingWeb.Title value
Dim newDescription As String = "your Description" ' new PublishingWeb.Description value
Dim resetInheritPageLayouts As Boolean = True ' new PublishingWeb.IsInheritingAvailablePageLayouts value
Dim resetInheritWebTemplates As Boolean = True ' new PublishingWeb.IsInheritingAvailableWebTemplates value

' Validate the input parameters.
If Nothing Is web Then
    Throw New System.ArgumentNullException("web")
End If

' Get the PublishingWeb wrapper for the SPWeb 
' that was passed in.
Dim publishingWeb As PublishingWeb = Nothing
If PublishingWeb.IsPublishingWeb(web) Then
    publishingWeb = PublishingWeb.GetPublishingWeb(web)
Else
    Throw New System.ArgumentException("The SPWeb must be a PublishingWeb", "web")
End If

'  Retrieve the SPFile.
Dim newDefaultPageFile As SPFile = publishingWeb.Web.GetFile(defaultPageFileId)
If (Nothing Is newDefaultPageFile) OrElse (Not newDefaultPageFile.Exists) Then
    Throw New System.ArgumentException("The Guid does not match an SPFile on the SPWeb", "defaultPageFileId")
End If

' Set new values on the PublishingWeb.
publishingWeb.Title = newTitle
publishingWeb.Description = newDescription
publishingWeb.DefaultPage = newDefaultPageFile
If resetInheritPageLayouts AndAlso (Not publishingWeb.IsInheritingAvailablePageLayouts) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailablePageLayouts()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts)
End If
If resetInheritWebTemplates AndAlso (Not publishingWeb.IsInheritingAvailableWebTemplates) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailableWebTemplates()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates)
End If

' Save the new values on the PublishingWeb.
publishingWeb.Update()
        End Sub
    End Class
End Namespace</code>
        </example>
      </Docs>
    </Member>
    <Member MemberName="IsRoot">
      <MemberSignature Language="C#" Value="public bool IsRoot { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance bool IsRoot" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.IsRoot" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property IsRoot As Boolean" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property bool IsRoot { bool get(); };" />
      <MemberSignature Language="F#" Value="member this.IsRoot : bool" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.IsRoot" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets a Boolean value that determines whether this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object is the root <see cref="T:Microsoft.SharePoint.SPWeb" /> object.</summary>
        <value>
          <b>true</b> if this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> is the root <see cref="T:Microsoft.SharePoint.SPWeb" /> object; otherwise, <b>false</b>.</value>
        <remarks>
          <para>This property wraps the <see cref="P:Microsoft.SharePoint.SPWeb.IsRootWeb" /> property.</para>
          <para />
        </remarks>
        <example>
          <para>This example demonstrates setting and saving property values on a publishing Web. Before building and running this example, verify that Publishing feature has been enabled for the <b>SPWeb</b>, and that the defaultPageFileId is <b>SPFile.UniqueId</b> for the new default page.</para>
          <code>using SPContentTypeId = Microsoft.SharePoint.SPContentTypeId;
using SPContentType = Microsoft.SharePoint.SPContentType;
using SPSite = Microsoft.SharePoint.SPSite;
using SPFile = Microsoft.SharePoint.SPFile;
using SPWeb = Microsoft.SharePoint.SPWeb;
using PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite;
using PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb;
using PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection;
using PageLayout = Microsoft.SharePoint.Publishing.PageLayout;

namespace Microsoft.SDK.SharePointServer.Samples
{
    public static class PublishingWebCodeSamples
    {
        public static void SetPublishingWebProperties(SPWeb web, System.Guid defaultPageFileId)
        {
// Replace these variable values and input parameters
// with your own values.
string newTitle = "your Title";         // new PublishingWeb.Title value
string newDescription = "your Description";         // new PublishingWeb.Description value
bool resetInheritPageLayouts = true;    // new PublishingWeb.IsInheritingAvailablePageLayouts value
bool resetInheritWebTemplates = true;   // new PublishingWeb.IsInheritingAvailableWebTemplates value

// Validate the input parameters.
if (null == web)
{
    throw new System.ArgumentNullException("web");
}

// Get the PublishingWeb wrapper for the SPWeb 
// that was passed in.
PublishingWeb publishingWeb = null;
if (PublishingWeb.IsPublishingWeb(web))
{
    publishingWeb = PublishingWeb.GetPublishingWeb(web);
}
else
{
    throw new System.ArgumentException("The SPWeb must be a PublishingWeb", "web");
}

//  Retrieve the SPFile.
SPFile newDefaultPageFile = publishingWeb.Web.GetFile(defaultPageFileId);
if( (null == newDefaultPageFile) ||
    !newDefaultPageFile.Exists )
{
    throw new System.ArgumentException(
        "The Guid does not match an SPFile on the SPWeb",
        "defaultPageFileId");
}

// Set new values on the PublishingWeb.
publishingWeb.Title = newTitle;
publishingWeb.Description = newDescription;
publishingWeb.DefaultPage = newDefaultPageFile;
if( resetInheritPageLayouts &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailablePageLayouts  &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailablePageLayouts();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts);
}
if (resetInheritWebTemplates &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailableWebTemplates &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailableWebTemplates();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates);
}

// Save the new values on the PublishingWeb.
publishingWeb.Update();
        }
    }
}</code>
          <code>Imports SPContentTypeId = Microsoft.SharePoint.SPContentTypeId
Imports SPContentType = Microsoft.SharePoint.SPContentType
Imports SPSite = Microsoft.SharePoint.SPSite
Imports SPFile = Microsoft.SharePoint.SPFile
Imports SPWeb = Microsoft.SharePoint.SPWeb
Imports PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite
Imports PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb
Imports PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection
Imports PageLayout = Microsoft.SharePoint.Publishing.PageLayout

Namespace Microsoft.SDK.SharePointServer.Samples
    Public NotInheritable Class PublishingWebCodeSamples
        Private Sub New()
        End Sub
        Public Shared Sub SetPublishingWebProperties(ByVal web As SPWeb, ByVal defaultPageFileId As System.Guid)
' Replace these variable values and input parameters
' with your own values.
Dim newTitle As String = "your Title" ' new PublishingWeb.Title value
Dim newDescription As String = "your Description" ' new PublishingWeb.Description value
Dim resetInheritPageLayouts As Boolean = True ' new PublishingWeb.IsInheritingAvailablePageLayouts value
Dim resetInheritWebTemplates As Boolean = True ' new PublishingWeb.IsInheritingAvailableWebTemplates value

' Validate the input parameters.
If Nothing Is web Then
    Throw New System.ArgumentNullException("web")
End If

' Get the PublishingWeb wrapper for the SPWeb 
' that was passed in.
Dim publishingWeb As PublishingWeb = Nothing
If PublishingWeb.IsPublishingWeb(web) Then
    publishingWeb = PublishingWeb.GetPublishingWeb(web)
Else
    Throw New System.ArgumentException("The SPWeb must be a PublishingWeb", "web")
End If

'  Retrieve the SPFile.
Dim newDefaultPageFile As SPFile = publishingWeb.Web.GetFile(defaultPageFileId)
If (Nothing Is newDefaultPageFile) OrElse (Not newDefaultPageFile.Exists) Then
    Throw New System.ArgumentException("The Guid does not match an SPFile on the SPWeb", "defaultPageFileId")
End If

' Set new values on the PublishingWeb.
publishingWeb.Title = newTitle
publishingWeb.Description = newDescription
publishingWeb.DefaultPage = newDefaultPageFile
If resetInheritPageLayouts AndAlso (Not publishingWeb.IsInheritingAvailablePageLayouts) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailablePageLayouts()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts)
End If
If resetInheritWebTemplates AndAlso (Not publishingWeb.IsInheritingAvailableWebTemplates) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailableWebTemplates()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates)
End If

' Save the new values on the PublishingWeb.
publishingWeb.Update()
        End Sub
    End Class
End Namespace</code>
        </example>
      </Docs>
    </Member>
    <Member MemberName="IterateOverAllPages">
      <MemberSignature Language="C#" Value="public void IterateOverAllPages (Microsoft.SharePoint.Publishing.PublishingWeb.ProcessPublishingPage callToProcessPublishingPage);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void IterateOverAllPages(class Microsoft.SharePoint.Publishing.PublishingWeb/ProcessPublishingPage callToProcessPublishingPage) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.IterateOverAllPages(Microsoft.SharePoint.Publishing.PublishingWeb.ProcessPublishingPage)" />
      <MemberSignature Language="VB.NET" Value="Public Sub IterateOverAllPages (callToProcessPublishingPage As PublishingWeb.ProcessPublishingPage)" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; void IterateOverAllPages(Microsoft::SharePoint::Publishing::PublishingWeb::ProcessPublishingPage ^ callToProcessPublishingPage);" />
      <MemberSignature Language="F#" Value="member this.IterateOverAllPages : Microsoft.SharePoint.Publishing.PublishingWeb.ProcessPublishingPage -&gt; unit" Usage="publishingWeb.IterateOverAllPages callToProcessPublishingPage" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="callToProcessPublishingPage" Type="Microsoft.SharePoint.Publishing.PublishingWeb+ProcessPublishingPage" />
      </Parameters>
      <Docs>
        <param name="callToProcessPublishingPage">The delegate to process the <b>PublishingPage</b> object.</param>
        <summary>Iterates over all <b>PublishingPage</b> objects in the current <b>PublishingWeb</b> object and processes each PublishingPage by using the given delegate.</summary>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="Label">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.VariationLabel Label { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.SharePoint.Publishing.VariationLabel Label" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.Label" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property Label As VariationLabel" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property Microsoft::SharePoint::Publishing::VariationLabel ^ Label { Microsoft::SharePoint::Publishing::VariationLabel ^ get(); };" />
      <MemberSignature Language="F#" Value="member this.Label : Microsoft.SharePoint.Publishing.VariationLabel" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.Label" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.VariationLabel</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets the <see cref="T:Microsoft.SharePoint.Publishing.VariationLabel" /> object in whose hierarchy this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object is situated.</summary>
        <value>The <see cref="T:Microsoft.SharePoint.Publishing.VariationLabel" /> that is associated with this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />. </value>
        <remarks>
          <para>The return value is a null reference (Nothing in Visual Basic) if the <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> is not located within a Variation Hierarchy.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="LastModifiedDate">
      <MemberSignature Language="C#" Value="public DateTime LastModifiedDate { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance valuetype System.DateTime LastModifiedDate" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.LastModifiedDate" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property LastModifiedDate As DateTime" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property DateTime LastModifiedDate { DateTime get(); };" />
      <MemberSignature Language="F#" Value="member this.LastModifiedDate : DateTime" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.LastModifiedDate" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.DateTime</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets the date and time that an item in this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object was last modified.</summary>
        <value>The date and time that an item in this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object was last modified.</value>
        <remarks>
          <para>This property wraps the <see cref="P:Microsoft.SharePoint.SPWeb.LastItemModifiedDate" /> property.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="MasterUrl">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.InheritableStringProperty MasterUrl { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.SharePoint.Publishing.InheritableStringProperty MasterUrl" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.MasterUrl" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property MasterUrl As InheritableStringProperty" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property Microsoft::SharePoint::Publishing::InheritableStringProperty ^ MasterUrl { Microsoft::SharePoint::Publishing::InheritableStringProperty ^ get(); };" />
      <MemberSignature Language="F#" Value="member this.MasterUrl : Microsoft.SharePoint.Publishing.InheritableStringProperty" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.MasterUrl" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.InheritableStringProperty</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets the master URL for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>The master URL for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />.</value>
        <remarks>
          <para>This value may be inherited.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="Name">
      <MemberSignature Language="C#" Value="public string Name { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance string Name" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.Name" />
      <MemberSignature Language="VB.NET" Value="Public Property Name As String" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property System::String ^ Name { System::String ^ get(); void set(System::String ^ value); };" />
      <MemberSignature Language="F#" Value="member this.Name : string with get, set" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.Name" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets or sets the URL name of this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>The URL name of this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</value>
        <remarks>
          <para>This property wraps the <see cref="P:Microsoft.SharePoint.SPWeb.Name" /> property </para>
          <para>To save changes after setting this property, call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="Navigation">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.Navigation.PortalNavigation Navigation { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.SharePoint.Publishing.Navigation.PortalNavigation Navigation" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.Navigation" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property Navigation As PortalNavigation" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property Microsoft::SharePoint::Publishing::Navigation::PortalNavigation ^ Navigation { Microsoft::SharePoint::Publishing::Navigation::PortalNavigation ^ get(); };" />
      <MemberSignature Language="F#" Value="member this.Navigation : Microsoft.SharePoint.Publishing.Navigation.PortalNavigation" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.Navigation" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.Navigation.PortalNavigation</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets a <see cref="T:Microsoft.SharePoint.Publishing.Navigation.PortalNavigation" /> object that represents the navigation settings for the current publishing Web.</summary>
        <value>Returns <see cref="T:Microsoft.SharePoint.Publishing.Navigation.PortalNavigation" />.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="NavigationAutomaticSortingMethod">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.AutomaticSortingMethod NavigationAutomaticSortingMethod { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance valuetype Microsoft.SharePoint.Publishing.AutomaticSortingMethod NavigationAutomaticSortingMethod" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.NavigationAutomaticSortingMethod" />
      <MemberSignature Language="VB.NET" Value="Public Property NavigationAutomaticSortingMethod As AutomaticSortingMethod" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property Microsoft::SharePoint::Publishing::AutomaticSortingMethod NavigationAutomaticSortingMethod { Microsoft::SharePoint::Publishing::AutomaticSortingMethod get(); void set(Microsoft::SharePoint::Publishing::AutomaticSortingMethod value); };" />
      <MemberSignature Language="F#" Value="member this.NavigationAutomaticSortingMethod : Microsoft.SharePoint.Publishing.AutomaticSortingMethod with get, set" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.NavigationAutomaticSortingMethod" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.Obsolete("Use PublishingWeb.Navigation.AutomaticSortingMethod instead.")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.AutomaticSortingMethod</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets or sets an enumeration value which indicates the sort method to use when automatically sorting navigation items owned by this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>An <see cref="T:Microsoft.SharePoint.Publishing.AutomaticSortingMethod" /> that represents a specific, automatic sorting method.</value>
        <remarks>
          <para>This property is useful only when the <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.NavigationOrderingMethod" /> uses a type of automatic sorting.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="NavigationOrderingMethod">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.OrderingMethod NavigationOrderingMethod { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance valuetype Microsoft.SharePoint.Publishing.OrderingMethod NavigationOrderingMethod" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.NavigationOrderingMethod" />
      <MemberSignature Language="VB.NET" Value="Public Property NavigationOrderingMethod As OrderingMethod" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property Microsoft::SharePoint::Publishing::OrderingMethod NavigationOrderingMethod { Microsoft::SharePoint::Publishing::OrderingMethod get(); void set(Microsoft::SharePoint::Publishing::OrderingMethod value); };" />
      <MemberSignature Language="F#" Value="member this.NavigationOrderingMethod : Microsoft.SharePoint.Publishing.OrderingMethod with get, set" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.NavigationOrderingMethod" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.Obsolete("Use PublishingWeb.Navigation.OrderingMethod instead.")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.OrderingMethod</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets or sets an enumeration value that indicates the ordering of navigation items owned by this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>
          <see cref="T:Microsoft.SharePoint.Publishing.OrderingMethod" /> that represents a specific ordering method.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="NavigationShowSiblings">
      <MemberSignature Language="C#" Value="public bool NavigationShowSiblings { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance bool NavigationShowSiblings" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.NavigationShowSiblings" />
      <MemberSignature Language="VB.NET" Value="Public Property NavigationShowSiblings As Boolean" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property bool NavigationShowSiblings { bool get(); void set(bool value); };" />
      <MemberSignature Language="F#" Value="member this.NavigationShowSiblings : bool with get, set" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.NavigationShowSiblings" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.Obsolete("Use PublishingWeb.Navigation.ShowSiblings instead.")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets or sets a value that indicates whether this Web site should display siblings of the current Web site in current navigation.</summary>
        <value>A Boolean value that represents whether this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> should display siblings.Defaults to <b>true</b> for <b>PublishingWeb</b> objects.Defaults to <b>false</b> for most other types of Web sites.</value>
        <remarks>
          <para>Current navigation normally starts at the current Web site, so only this Web site and those items beneath it would be visible. This property forces the starting node up one level so that siblings of the current Web site are available. Any child objects of the sibling nodes are automatically removed.</para>
          <para>To save changes after setting this property, call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="NavigationSortAscending">
      <MemberSignature Language="C#" Value="public bool NavigationSortAscending { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance bool NavigationSortAscending" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.NavigationSortAscending" />
      <MemberSignature Language="VB.NET" Value="Public Property NavigationSortAscending As Boolean" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property bool NavigationSortAscending { bool get(); void set(bool value); };" />
      <MemberSignature Language="F#" Value="member this.NavigationSortAscending : bool with get, set" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.NavigationSortAscending" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.Obsolete("Use PublishingWeb.Navigation.SortAscending instead.")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets or sets a Boolean value that indicates whether navigation of this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object is sorted in ascending or descending order.</summary>
        <value>
          <b>true</b> if this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object should be included in ascending sort order; otherwise, <b>false</b>.</value>
        <remarks>
          <para>To save changes after setting this property, call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="NewPageUrlToken">
      <MemberSignature Language="C#" Value="public string NewPageUrlToken { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance string NewPageUrlToken" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.NewPageUrlToken" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property NewPageUrlToken As String" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property System::String ^ NewPageUrlToken { System::String ^ get(); };" />
      <MemberSignature Language="F#" Value="member this.NewPageUrlToken : string" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.NewPageUrlToken" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets the URL token that is usede when creating “one-click” pages within the current <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>Returns <see cref="T:System.String" />.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="PagesList">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.SPList PagesList { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.SharePoint.SPList PagesList" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.PagesList" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property PagesList As SPList" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property Microsoft::SharePoint::SPList ^ PagesList { Microsoft::SharePoint::SPList ^ get(); };" />
      <MemberSignature Language="F#" Value="member this.PagesList : Microsoft.SharePoint.SPList" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.PagesList" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.SPList</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets the pages list in which <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects are stored for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>The pages list in which <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects are stored for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="PagesListId">
      <MemberSignature Language="C#" Value="public Guid PagesListId { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance valuetype System.Guid PagesListId" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.PagesListId" />
      <MemberSignature Language="VB.NET" Value="Public Property PagesListId As Guid" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property Guid PagesListId { Guid get(); void set(Guid value); };" />
      <MemberSignature Language="F#" Value="member this.PagesListId : Guid with get, set" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.PagesListId" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Guid</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets or sets the ID of the pages list in which the <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects are stored for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /><b />object<b>.</b></summary>
        <value>The ID of the pages list in which the <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects are stored for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /><b></b>object.</value>
        <remarks>
          <para>To save changes after setting this property, call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="PagesListName">
      <MemberSignature Language="C#" Value="public string PagesListName { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance string PagesListName" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.PagesListName" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property PagesListName As String" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property System::String ^ PagesListName { System::String ^ get(); };" />
      <MemberSignature Language="F#" Value="member this.PagesListName : string" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.PagesListName" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets or sets the URL name of the pages list in which <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects are stored for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>The URL name of the pages list in which <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects are stored for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</value>
        <remarks>
          <para>To save changes after setting this property, call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="ParentPublishingWeb">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.PublishingWeb ParentPublishingWeb { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.SharePoint.Publishing.PublishingWeb ParentPublishingWeb" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.ParentPublishingWeb" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property ParentPublishingWeb As PublishingWeb" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property Microsoft::SharePoint::Publishing::PublishingWeb ^ ParentPublishingWeb { Microsoft::SharePoint::Publishing::PublishingWeb ^ get(); };" />
      <MemberSignature Language="F#" Value="member this.ParentPublishingWeb : Microsoft.SharePoint.Publishing.PublishingWeb" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.ParentPublishingWeb" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.PublishingWeb</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets the parent <see cref="T:Microsoft.SharePoint.SPWeb" /> object as a <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> instance.</summary>
        <value>The parent <see cref="T:Microsoft.SharePoint.SPWeb" /> object as a <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /><b></b> instance.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="SetAvailableCrossLanguageWebTemplates">
      <MemberSignature Language="C#" Value="public void SetAvailableCrossLanguageWebTemplates (System.Collections.ObjectModel.Collection&lt;Microsoft.SharePoint.SPWebTemplate&gt; webTemplates, bool resetAllSubsitesToInherit);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void SetAvailableCrossLanguageWebTemplates(class System.Collections.ObjectModel.Collection`1&lt;class Microsoft.SharePoint.SPWebTemplate&gt; webTemplates, bool resetAllSubsitesToInherit) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.SetAvailableCrossLanguageWebTemplates(System.Collections.ObjectModel.Collection{Microsoft.SharePoint.SPWebTemplate},System.Boolean)" />
      <MemberSignature Language="VB.NET" Value="Public Sub SetAvailableCrossLanguageWebTemplates (webTemplates As Collection(Of SPWebTemplate), resetAllSubsitesToInherit As Boolean)" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; void SetAvailableCrossLanguageWebTemplates(System::Collections::ObjectModel::Collection&lt;Microsoft::SharePoint::SPWebTemplate ^&gt; ^ webTemplates, bool resetAllSubsitesToInherit);" />
      <MemberSignature Language="F#" Value="member this.SetAvailableCrossLanguageWebTemplates : System.Collections.ObjectModel.Collection&lt;Microsoft.SharePoint.SPWebTemplate&gt; * bool -&gt; unit" Usage="publishingWeb.SetAvailableCrossLanguageWebTemplates (webTemplates, resetAllSubsitesToInherit)" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="webTemplates" Type="System.Collections.ObjectModel.Collection&lt;Microsoft.SharePoint.SPWebTemplate&gt;" />
        <Parameter Name="resetAllSubsitesToInherit" Type="System.Boolean" />
      </Parameters>
      <Docs>
        <param name="webTemplates">A collection of <see cref="T:Microsoft.SharePoint.SPWebTemplate" /> objects.</param>
        <param name="resetAllSubsitesToInherit">This Boolean parameter indicates whether the available Web templates should be pushed down to all subsites.</param>
        <summary>Specifies the cross-language Web templates that are available for creating subsites below this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <remarks>
          <para>After calling this method, the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetAvailableCrossLanguageWebTemplates" /> method returns this set of Web templates. The <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.IsInheritingAvailableWebTemplates" /> and <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.IsAllowingAllWebTemplates" /> properties are <b>false</b>. The <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetAvailableWebTemplates(UInt32,LCID)" /> method includes this set of Web templates if they are available for the specified LCID.</para>
          <para>To save changes after calling this method, call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method.</para>
          <para />
        </remarks>
        <exception cref="System.UnauthorizedAccessException">The current user does not have sufficient permissions to perform this action.</exception>
      </Docs>
    </Member>
    <Member MemberName="SetAvailablePageLayouts">
      <MemberSignature Language="C#" Value="public void SetAvailablePageLayouts (Microsoft.SharePoint.Publishing.PageLayout[] pageLayouts, bool resetAllSubsitesToInherit);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void SetAvailablePageLayouts(class Microsoft.SharePoint.Publishing.PageLayout[] pageLayouts, bool resetAllSubsitesToInherit) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.SetAvailablePageLayouts(Microsoft.SharePoint.Publishing.PageLayout[],System.Boolean)" />
      <MemberSignature Language="VB.NET" Value="Public Sub SetAvailablePageLayouts (pageLayouts As PageLayout(), resetAllSubsitesToInherit As Boolean)" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; void SetAvailablePageLayouts(cli::array &lt;Microsoft::SharePoint::Publishing::PageLayout ^&gt; ^ pageLayouts, bool resetAllSubsitesToInherit);" />
      <MemberSignature Language="F#" Value="member this.SetAvailablePageLayouts : Microsoft.SharePoint.Publishing.PageLayout[] * bool -&gt; unit" Usage="publishingWeb.SetAvailablePageLayouts (pageLayouts, resetAllSubsitesToInherit)" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="pageLayouts" Type="Microsoft.SharePoint.Publishing.PageLayout[]" />
        <Parameter Name="resetAllSubsitesToInherit" Type="System.Boolean" />
      </Parameters>
      <Docs>
        <param name="pageLayouts">An array of <see cref="T:Microsoft.SharePoint.Publishing.PageLayout" /> objects that are available for use in creating <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects within this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</param>
        <param name="resetAllSubsitesToInherit">This Boolean parameter indicates whether the available <see cref="T:Microsoft.SharePoint.Publishing.PageLayout" /> objects should be pushed down to all subsites.</param>
        <summary>Specifies <see cref="T:Microsoft.SharePoint.Publishing.PageLayout" /> objects that are available for use in creating <see cref="T:Microsoft.SharePoint.Publishing.PublishingPage" /> objects within this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <remarks>
          <para>After calling this method, the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetAvailablePageLayouts" /> method returns this set <see cref="T:Microsoft.SharePoint.Publishing.PageLayout" /> objects. The <see cref="P:Microsoft.SharePoint.Publishing.PageLayout.IsInheritingAvailablePageLayouts" /><b />and <see cref="P:Microsoft.SharePoint.Publishing.PageLayout.IsAllowingAllPageLayouts" /> properties are False.</para>
          <para>To save changes after calling this method, call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method.</para>
          <para>
            <b>Note</b>: This operation is synchronous.</para>
          <para />
        </remarks>
        <example>
          <para>This example restricts the set of available page layouts used for creating pages in a publishing Web so that only page layouts associated with a specified content type are available.</para>
          <para>Before using this example, verify that the <paramref name="associatedContentTypeId" /> parameter is from a content type on the root Web site of the site.</para>
          <code>using SPContentTypeId = Microsoft.SharePoint.SPContentTypeId;
using SPContentType = Microsoft.SharePoint.SPContentType;
using SPSite = Microsoft.SharePoint.SPSite;
using SPFile = Microsoft.SharePoint.SPFile;
using SPWeb = Microsoft.SharePoint.SPWeb;
using PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite;
using PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb;
using PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection;
using PageLayout = Microsoft.SharePoint.Publishing.PageLayout;

namespace Microsoft.SDK.SharePointServer.Samples
{
    public static class PublishingWebCodeSamples
    {
  
        public static void RestrictPageLayoutsByContentType(
PublishingWeb publishingWeb, 
SPContentTypeId associatedContentTypeId)
        {
// Replace these variable values and input parameters with your own values.
bool excludeHiddenLayouts = true;
bool resetAllSubsitesToInherit = true;

// Validate the input parameters.
if (null == publishingWeb)
{
    throw new System.ArgumentNullException("publishingWeb");
}

SPSite site = publishingWeb.Web.Site;
PublishingSite publishingSite = new PublishingSite(site);

// Retrieve a collection of all page layouts in the site collection
// that match the content type.
SPContentType associatedContentType = publishingSite.ContentTypes[associatedContentTypeId];
if (null == associatedContentType)
{
    throw new System.ArgumentException(
        "The SPContentTypeId did not match an SPContentType in the SPSite.RootWeb",
        "associatedContentTypeId");
}

PageLayoutCollection pageLayoutsByContentType = 
    publishingSite.GetPageLayouts(associatedContentType, excludeHiddenLayouts);

// Update the Web to use these page layouts when creating pages.
publishingWeb.SetAvailablePageLayouts(
    pageLayoutsByContentType.ToArray(),
    resetAllSubsitesToInherit);

publishingWeb.Update();

//  Verify the expected results. Note: This is not required. It demonstrates
//  the results of calling the SetAvailablePageLayouts method.
//
System.Diagnostics.Debug.Assert(!publishingWeb.IsAllowingAllPageLayouts);
System.Diagnostics.Debug.Assert(!publishingWeb.IsInheritingAvailablePageLayouts);

PageLayout[] availablePageLayouts = publishingWeb.GetAvailablePageLayouts();
foreach (PageLayout pageLayout in availablePageLayouts)
{
    System.Diagnostics.Debug.Assert(
        pageLayout.AssociatedContentType.Id == associatedContentTypeId);
}
        }
    }
}</code>
          <code>Imports SPContentTypeId = Microsoft.SharePoint.SPContentTypeId
Imports SPContentType = Microsoft.SharePoint.SPContentType
Imports SPSite = Microsoft.SharePoint.SPSite
Imports SPFile = Microsoft.SharePoint.SPFile
Imports SPWeb = Microsoft.SharePoint.SPWeb
Imports PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite
Imports PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb
Imports PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection
Imports PageLayout = Microsoft.SharePoint.Publishing.PageLayout

Namespace Microsoft.SDK.SharePointServer.Samples
    Public NotInheritable Class PublishingWebCodeSamples

        Private Sub New()
        End Sub
        Public Shared Sub RestrictPageLayoutsByContentType(ByVal publishingWeb As PublishingWeb, ByVal associatedContentTypeId As SPContentTypeId)
' Replace these variable values and input parameters with your own values.
Dim excludeHiddenLayouts As Boolean = True
Dim resetAllSubsitesToInherit As Boolean = True

' Validate the input parameters.
If Nothing Is publishingWeb Then
    Throw New System.ArgumentNullException("publishingWeb")
End If

Dim site As SPSite = publishingWeb.Web.Site
Dim publishingSite As New PublishingSite(site)

' Retrieve a collection of all page layouts in the site collection
' that match the content type.
Dim associatedContentType As SPContentType = publishingSite.ContentTypes(associatedContentTypeId)
If Nothing Is associatedContentType Then
    Throw New System.ArgumentException("The SPContentTypeId did not match an SPContentType in the SPSite.RootWeb", "associatedContentTypeId")
End If

Dim pageLayoutsByContentType As PageLayoutCollection = publishingSite.GetPageLayouts(associatedContentType, excludeHiddenLayouts)

' Update the Web to use these page layouts when creating pages.
publishingWeb.SetAvailablePageLayouts(pageLayoutsByContentType.ToArray(), resetAllSubsitesToInherit)

publishingWeb.Update()

'  Verify the expected results. Note: This is not required. It demonstrates
'  the results of calling the SetAvailablePageLayouts method.
'
System.Diagnostics.Debug.Assert((Not publishingWeb.IsAllowingAllPageLayouts))
System.Diagnostics.Debug.Assert((Not publishingWeb.IsInheritingAvailablePageLayouts))

Dim availablePageLayouts() As PageLayout = publishingWeb.GetAvailablePageLayouts()
For Each pageLayout As PageLayout In availablePageLayouts
    System.Diagnostics.Debug.Assert(pageLayout.AssociatedContentType.Id Is associatedContentTypeId)
Next pageLayout
        End Sub
    End Class
End Namespace</code>
        </example>
      </Docs>
    </Member>
    <Member MemberName="SetAvailableWebTemplates">
      <MemberSignature Language="C#" Value="public void SetAvailableWebTemplates (System.Collections.ObjectModel.Collection&lt;Microsoft.SharePoint.SPWebTemplate&gt; webTemplates, uint lcid, bool resetAllSubsitesToInherit);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void SetAvailableWebTemplates(class System.Collections.ObjectModel.Collection`1&lt;class Microsoft.SharePoint.SPWebTemplate&gt; webTemplates, unsigned int32 lcid, bool resetAllSubsitesToInherit) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.SetAvailableWebTemplates(System.Collections.ObjectModel.Collection{Microsoft.SharePoint.SPWebTemplate},System.UInt32,System.Boolean)" />
      <MemberSignature Language="VB.NET" Value="Public Sub SetAvailableWebTemplates (webTemplates As Collection(Of SPWebTemplate), lcid As UInteger, resetAllSubsitesToInherit As Boolean)" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; void SetAvailableWebTemplates(System::Collections::ObjectModel::Collection&lt;Microsoft::SharePoint::SPWebTemplate ^&gt; ^ webTemplates, System::UInt32 lcid, bool resetAllSubsitesToInherit);" />
      <MemberSignature Language="F#" Value="member this.SetAvailableWebTemplates : System.Collections.ObjectModel.Collection&lt;Microsoft.SharePoint.SPWebTemplate&gt; * uint32 * bool -&gt; unit" Usage="publishingWeb.SetAvailableWebTemplates (webTemplates, lcid, resetAllSubsitesToInherit)" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="webTemplates" Type="System.Collections.ObjectModel.Collection&lt;Microsoft.SharePoint.SPWebTemplate&gt;" />
        <Parameter Name="lcid" Type="System.UInt32" />
        <Parameter Name="resetAllSubsitesToInherit" Type="System.Boolean" />
      </Parameters>
      <Docs>
        <param name="webTemplates">A list of <see cref="T:Microsoft.SharePoint.SPWebTemplate" /> objects that are available for use in creating subsites below this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> class.</param>
        <param name="lcid">The locale ID that is related to the specified Web templates.</param>
        <param name="resetAllSubsitesToInherit">This Boolean parameter indicates whether the available Web templates should be pushed down to all subsites.</param>
        <summary>Specifies the Web templates that are available for creating subsites below this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object for a specific locale</summary>
        <remarks>
          <para>Generally, Web templates are designed to be used in many languages, so you should use the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.SetAvailableCrossLanguageWebTemplates(System.Collections.ObjectModel.Collection{Microsoft.SharePoint.SPWebTemplate},System.Boolean)" /> method.</para>
          <para>After calling this method, the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.GetAvailableWebTemplates" /> method returns this set of Web templates. The <see cref="P:Microsoft.SharePoint.Publishing.PageLayout.IsInheritingAvailableWebTemplates" /><b />and <see cref="P:Microsoft.SharePoint.Publishing.PageLayout.IsAllowingAllWebTemplates" /> properties are False.</para>
          <para>To save changes after calling this method, call the <see cref="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method.</para>
          <para>
            <b>Note</b>: This operation is synchronous.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="SetDefaultPageLayout">
      <MemberSignature Language="C#" Value="public void SetDefaultPageLayout (Microsoft.SharePoint.Publishing.PageLayout pageLayout, bool resetAllSubsitesToInherit);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void SetDefaultPageLayout(class Microsoft.SharePoint.Publishing.PageLayout pageLayout, bool resetAllSubsitesToInherit) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.SetDefaultPageLayout(Microsoft.SharePoint.Publishing.PageLayout,System.Boolean)" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; void SetDefaultPageLayout(Microsoft::SharePoint::Publishing::PageLayout ^ pageLayout, bool resetAllSubsitesToInherit);" />
      <MemberSignature Language="F#" Value="member this.SetDefaultPageLayout : Microsoft.SharePoint.Publishing.PageLayout * bool -&gt; unit" Usage="publishingWeb.SetDefaultPageLayout (pageLayout, resetAllSubsitesToInherit)" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="pageLayout" Type="Microsoft.SharePoint.Publishing.PageLayout" />
        <Parameter Name="resetAllSubsitesToInherit" Type="System.Boolean" />
      </Parameters>
      <Docs>
        <param name="pageLayout">The URL token representing the page layout to be set.</param>
        <param name="resetAllSubsitesToInherit">Indicates whether this setting should be pushed down to all subsites</param>
        <summary>Specifies the URL token that will be used when creating “one-click” pages within the current <b>PublishingWeb</b> object.</summary>
        <remarks>
          <para>After calling this method, the <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.NewPageUrlToken" /> will return the given page layout and the given URL token. The <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.IsInheritingNewPageUrlToken" /> property will be <b>False</b>.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="SetNewPageUrlToken">
      <MemberSignature Language="C#" Value="public void SetNewPageUrlToken (string urlToken, bool resetAllSubsitesToInherit);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void SetNewPageUrlToken(string urlToken, bool resetAllSubsitesToInherit) cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.SetNewPageUrlToken(System.String,System.Boolean)" />
      <MemberSignature Language="VB.NET" Value="Public Sub SetNewPageUrlToken (urlToken As String, resetAllSubsitesToInherit As Boolean)" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; void SetNewPageUrlToken(System::String ^ urlToken, bool resetAllSubsitesToInherit);" />
      <MemberSignature Language="F#" Value="member this.SetNewPageUrlToken : string * bool -&gt; unit" Usage="publishingWeb.SetNewPageUrlToken (urlToken, resetAllSubsitesToInherit)" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="urlToken" Type="System.String" />
        <Parameter Name="resetAllSubsitesToInherit" Type="System.Boolean" />
      </Parameters>
      <Docs>
        <param name="urlToken">The URL token to be set.</param>
        <param name="resetAllSubsitesToInherit">Indicates whether the setting should be pushed down to all subsites.</param>
        <summary>Sets the available web templates on this <b>PublishingWeb</b> object to be inherited from the parent <b>PublishingWeb</b> object.</summary>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="ThemedCssFolderUrl">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.Publishing.InheritableStringProperty ThemedCssFolderUrl { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.SharePoint.Publishing.InheritableStringProperty ThemedCssFolderUrl" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.ThemedCssFolderUrl" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property ThemedCssFolderUrl As InheritableStringProperty" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property Microsoft::SharePoint::Publishing::InheritableStringProperty ^ ThemedCssFolderUrl { Microsoft::SharePoint::Publishing::InheritableStringProperty ^ get(); };" />
      <MemberSignature Language="F#" Value="member this.ThemedCssFolderUrl : Microsoft.SharePoint.Publishing.InheritableStringProperty" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.ThemedCssFolderUrl" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.Publishing.InheritableStringProperty</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets the URL of the folder containing the themed CSS for the current <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object, or a null reference (Nothing in Visual Basic) if no theme is applied.</summary>
        <value>Returns <see cref="T:Microsoft.SharePoint.Publishing.InheritableStringProperty" />.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="Title">
      <MemberSignature Language="C#" Value="public string Title { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance string Title" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.Title" />
      <MemberSignature Language="VB.NET" Value="Public Property Title As String" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property System::String ^ Title { System::String ^ get(); void set(System::String ^ value); };" />
      <MemberSignature Language="F#" Value="member this.Title : string with get, set" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.Title" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets or sets the title of the <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>The title of the <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />.</value>
        <remarks>
          <para>This property wraps the <see cref="P:Microsoft.SharePoint.SPWeb.Title" /> property.</para>
          <para>To save changes after setting this property, call the <see cref="P:Microsoft.SharePoint.Publishing.PublishingWeb.Update" /> method.</para>
          <para />
        </remarks>
        <example>
          <para>This example demonstrates setting and saving property values on a publishing Web. Before building and running this example, verify that Publishing feature has been enabled for the <b>SPWeb</b>, and that the defaultPageFileId is <b>SPFile.UniqueId</b> for the new default page.</para>
          <code>using SPContentTypeId = Microsoft.SharePoint.SPContentTypeId;
using SPContentType = Microsoft.SharePoint.SPContentType;
using SPSite = Microsoft.SharePoint.SPSite;
using SPFile = Microsoft.SharePoint.SPFile;
using SPWeb = Microsoft.SharePoint.SPWeb;
using PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite;
using PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb;
using PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection;
using PageLayout = Microsoft.SharePoint.Publishing.PageLayout;

namespace Microsoft.SDK.SharePointServer.Samples
{
    public static class PublishingWebCodeSamples
    {
        public static void SetPublishingWebProperties(SPWeb web, System.Guid defaultPageFileId)
        {
// Replace these variable values and input parameters
// with your own values.
string newTitle = "your Title";         // new PublishingWeb.Title value
string newDescription = "your Description";         // new PublishingWeb.Description value
bool resetInheritPageLayouts = true;    // new PublishingWeb.IsInheritingAvailablePageLayouts value
bool resetInheritWebTemplates = true;   // new PublishingWeb.IsInheritingAvailableWebTemplates value

// Validate the input parameters.
if (null == web)
{
    throw new System.ArgumentNullException("web");
}

// Get the PublishingWeb wrapper for the SPWeb 
// that was passed in.
PublishingWeb publishingWeb = null;
if (PublishingWeb.IsPublishingWeb(web))
{
    publishingWeb = PublishingWeb.GetPublishingWeb(web);
}
else
{
    throw new System.ArgumentException("The SPWeb must be a PublishingWeb", "web");
}

//  Retrieve the SPFile.
SPFile newDefaultPageFile = publishingWeb.Web.GetFile(defaultPageFileId);
if( (null == newDefaultPageFile) ||
    !newDefaultPageFile.Exists )
{
    throw new System.ArgumentException(
        "The Guid does not match an SPFile on the SPWeb",
        "defaultPageFileId");
}

// Set new values on the PublishingWeb.
publishingWeb.Title = newTitle;
publishingWeb.Description = newDescription;
publishingWeb.DefaultPage = newDefaultPageFile;
if( resetInheritPageLayouts &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailablePageLayouts  &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailablePageLayouts();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts);
}
if (resetInheritWebTemplates &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailableWebTemplates &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailableWebTemplates();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates);
}

// Save the new values on the PublishingWeb.
publishingWeb.Update();
        }
    }
}</code>
          <code>Imports SPContentTypeId = Microsoft.SharePoint.SPContentTypeId
Imports SPContentType = Microsoft.SharePoint.SPContentType
Imports SPSite = Microsoft.SharePoint.SPSite
Imports SPFile = Microsoft.SharePoint.SPFile
Imports SPWeb = Microsoft.SharePoint.SPWeb
Imports PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite
Imports PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb
Imports PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection
Imports PageLayout = Microsoft.SharePoint.Publishing.PageLayout

Namespace Microsoft.SDK.SharePointServer.Samples
    Public NotInheritable Class PublishingWebCodeSamples
        Private Sub New()
        End Sub
        Public Shared Sub SetPublishingWebProperties(ByVal web As SPWeb, ByVal defaultPageFileId As System.Guid)
' Replace these variable values and input parameters
' with your own values.
Dim newTitle As String = "your Title" ' new PublishingWeb.Title value
Dim newDescription As String = "your Description" ' new PublishingWeb.Description value
Dim resetInheritPageLayouts As Boolean = True ' new PublishingWeb.IsInheritingAvailablePageLayouts value
Dim resetInheritWebTemplates As Boolean = True ' new PublishingWeb.IsInheritingAvailableWebTemplates value

' Validate the input parameters.
If Nothing Is web Then
    Throw New System.ArgumentNullException("web")
End If

' Get the PublishingWeb wrapper for the SPWeb 
' that was passed in.
Dim publishingWeb As PublishingWeb = Nothing
If PublishingWeb.IsPublishingWeb(web) Then
    publishingWeb = PublishingWeb.GetPublishingWeb(web)
Else
    Throw New System.ArgumentException("The SPWeb must be a PublishingWeb", "web")
End If

'  Retrieve the SPFile.
Dim newDefaultPageFile As SPFile = publishingWeb.Web.GetFile(defaultPageFileId)
If (Nothing Is newDefaultPageFile) OrElse (Not newDefaultPageFile.Exists) Then
    Throw New System.ArgumentException("The Guid does not match an SPFile on the SPWeb", "defaultPageFileId")
End If

' Set new values on the PublishingWeb.
publishingWeb.Title = newTitle
publishingWeb.Description = newDescription
publishingWeb.DefaultPage = newDefaultPageFile
If resetInheritPageLayouts AndAlso (Not publishingWeb.IsInheritingAvailablePageLayouts) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailablePageLayouts()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts)
End If
If resetInheritWebTemplates AndAlso (Not publishingWeb.IsInheritingAvailableWebTemplates) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailableWebTemplates()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates)
End If

' Save the new values on the PublishingWeb.
publishingWeb.Update()
        End Sub
    End Class
End Namespace</code>
        </example>
      </Docs>
    </Member>
    <Member MemberName="Update">
      <MemberSignature Language="C#" Value="public void Update ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void Update() cil managed" />
      <MemberSignature Language="DocId" Value="M:Microsoft.SharePoint.Publishing.PublishingWeb.Update" />
      <MemberSignature Language="VB.NET" Value="Public Sub Update ()" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; void Update();" />
      <MemberSignature Language="F#" Value="member this.Update : unit -&gt; unit" Usage="publishingWeb.Update " />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Saves changes to this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <remarks>To be added.</remarks>
        <example>
          <para>This example demonstrates setting and saving property values on a publishing Web. Before building and running this example, verify that Publishing feature has been enabled for the <b>SPWeb</b>, and that the <b>defaultPageFileId</b> is <b>SPFile.UniqueId</b> for the new default page.</para>
          <code>using SPContentTypeId = Microsoft.SharePoint.SPContentTypeId;
using SPContentType = Microsoft.SharePoint.SPContentType;
using SPSite = Microsoft.SharePoint.SPSite;
using SPFile = Microsoft.SharePoint.SPFile;
using SPWeb = Microsoft.SharePoint.SPWeb;
using PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite;
using PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb;
using PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection;
using PageLayout = Microsoft.SharePoint.Publishing.PageLayout;

namespace Microsoft.SDK.SharePointServer.Samples
{
    public static class PublishingWebCodeSamples
    {
        public static void SetPublishingWebProperties(SPWeb web, System.Guid defaultPageFileId)
        {
// Replace these variable values and input parameters
// with your own values.
string newTitle = "your Title";         // new PublishingWeb.Title value
string newDescription = "your Description";         // new PublishingWeb.Description value
bool resetInheritPageLayouts = true;    // new PublishingWeb.IsInheritingAvailablePageLayouts value
bool resetInheritWebTemplates = true;   // new PublishingWeb.IsInheritingAvailableWebTemplates value

// Validate the input parameters.
if (null == web)
{
    throw new System.ArgumentNullException("web");
}

// Get the PublishingWeb wrapper for the SPWeb 
// that was passed in.
PublishingWeb publishingWeb = null;
if (PublishingWeb.IsPublishingWeb(web))
{
    publishingWeb = PublishingWeb.GetPublishingWeb(web);
}
else
{
    throw new System.ArgumentException("The SPWeb must be a PublishingWeb", "web");
}

//  Retrieve the SPFile.
SPFile newDefaultPageFile = publishingWeb.Web.GetFile(defaultPageFileId);
if( (null == newDefaultPageFile) ||
    !newDefaultPageFile.Exists )
{
    throw new System.ArgumentException(
        "The Guid does not match an SPFile on the SPWeb",
        "defaultPageFileId");
}

// Set new values on the PublishingWeb.
publishingWeb.Title = newTitle;
publishingWeb.Description = newDescription;
publishingWeb.DefaultPage = newDefaultPageFile;
if( resetInheritPageLayouts &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailablePageLayouts  &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailablePageLayouts();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts);
}
if (resetInheritWebTemplates &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailableWebTemplates &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailableWebTemplates();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates);
}

// Save the new values on the PublishingWeb.
publishingWeb.Update();
        }
    }
}</code>
          <code>Imports SPContentTypeId = Microsoft.SharePoint.SPContentTypeId
Imports SPContentType = Microsoft.SharePoint.SPContentType
Imports SPSite = Microsoft.SharePoint.SPSite
Imports SPFile = Microsoft.SharePoint.SPFile
Imports SPWeb = Microsoft.SharePoint.SPWeb
Imports PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite
Imports PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb
Imports PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection
Imports PageLayout = Microsoft.SharePoint.Publishing.PageLayout

Namespace Microsoft.SDK.SharePointServer.Samples
    Public NotInheritable Class PublishingWebCodeSamples
        Private Sub New()
        End Sub
        Public Shared Sub SetPublishingWebProperties(ByVal web As SPWeb, ByVal defaultPageFileId As System.Guid)
' Replace these variable values and input parameters
' with your own values.
Dim newTitle As String = "your Title" ' new PublishingWeb.Title value
Dim newDescription As String = "your Description" ' new PublishingWeb.Description value
Dim resetInheritPageLayouts As Boolean = True ' new PublishingWeb.IsInheritingAvailablePageLayouts value
Dim resetInheritWebTemplates As Boolean = True ' new PublishingWeb.IsInheritingAvailableWebTemplates value

' Validate the input parameters.
If Nothing Is web Then
    Throw New System.ArgumentNullException("web")
End If

' Get the PublishingWeb wrapper for the SPWeb 
' that was passed in.
Dim publishingWeb As PublishingWeb = Nothing
If PublishingWeb.IsPublishingWeb(web) Then
    publishingWeb = PublishingWeb.GetPublishingWeb(web)
Else
    Throw New System.ArgumentException("The SPWeb must be a PublishingWeb", "web")
End If

'  Retrieve the SPFile.
Dim newDefaultPageFile As SPFile = publishingWeb.Web.GetFile(defaultPageFileId)
If (Nothing Is newDefaultPageFile) OrElse (Not newDefaultPageFile.Exists) Then
    Throw New System.ArgumentException("The Guid does not match an SPFile on the SPWeb", "defaultPageFileId")
End If

' Set new values on the PublishingWeb.
publishingWeb.Title = newTitle
publishingWeb.Description = newDescription
publishingWeb.DefaultPage = newDefaultPageFile
If resetInheritPageLayouts AndAlso (Not publishingWeb.IsInheritingAvailablePageLayouts) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailablePageLayouts()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts)
End If
If resetInheritWebTemplates AndAlso (Not publishingWeb.IsInheritingAvailableWebTemplates) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailableWebTemplates()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates)
End If

' Save the new values on the PublishingWeb.
publishingWeb.Update()
        End Sub
    End Class
End Namespace</code>
        </example>
      </Docs>
    </Member>
    <Member MemberName="Uri">
      <MemberSignature Language="C#" Value="public Uri Uri { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class System.Uri Uri" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.Uri" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property Uri As Uri" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property Uri ^ Uri { Uri ^ get(); };" />
      <MemberSignature Language="F#" Value="member this.Uri : Uri" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.Uri" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Uri</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets the URI of this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>The URI of the <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="Url">
      <MemberSignature Language="C#" Value="public string Url { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance string Url" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.Url" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property Url As String" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property System::String ^ Url { System::String ^ get(); };" />
      <MemberSignature Language="F#" Value="member this.Url : string" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.Url" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets the URL for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</summary>
        <value>URL for this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" />.</value>
        <remarks>
          <para>This property wraps the <see cref="P:Microsoft.SharePoint.SPWeb.Url" /> property.</para>
          <para />
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="VariationPublishingWebUrls">
      <MemberSignature Language="C#" Value="public System.Collections.Specialized.StringCollection VariationPublishingWebUrls { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class System.Collections.Specialized.StringCollection VariationPublishingWebUrls" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.VariationPublishingWebUrls" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property VariationPublishingWebUrls As StringCollection" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property System::Collections::Specialized::StringCollection ^ VariationPublishingWebUrls { System::Collections::Specialized::StringCollection ^ get(); };" />
      <MemberSignature Language="F#" Value="member this.VariationPublishingWebUrls : System.Collections.Specialized.StringCollection" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.VariationPublishingWebUrls" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Collections.Specialized.StringCollection</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets a collection of URLs of the variant publishing Webs associated with this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object</summary>
        <value>A collection of URLs of the variant publishing Webs associated with this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> object.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="Web">
      <MemberSignature Language="C#" Value="public Microsoft.SharePoint.SPWeb Web { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class Microsoft.SharePoint.SPWeb Web" />
      <MemberSignature Language="DocId" Value="P:Microsoft.SharePoint.Publishing.PublishingWeb.Web" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property Web As SPWeb" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property Microsoft::SharePoint::SPWeb ^ Web { Microsoft::SharePoint::SPWeb ^ get(); };" />
      <MemberSignature Language="F#" Value="member this.Web : Microsoft.SharePoint.SPWeb" Usage="Microsoft.SharePoint.Publishing.PublishingWeb.Web" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Microsoft.SharePoint.Publishing</AssemblyName>
        <AssemblyVersion>15.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>Microsoft.SharePoint.Client.ClientCallable(ClientLibraryTargets=Microsoft.SharePoint.Client.ClientLibraryTargets.NonRESTful)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>Microsoft.SharePoint.SPWeb</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets the <see cref="T:Microsoft.SharePoint.SPWeb" /> object that is wrapped by this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> instance.</summary>
        <value>The <see cref="T:Microsoft.SharePoint.SPWeb" /> that is wrapped by this <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> instance.</value>
        <remarks>
          <para>The <see cref="T:Microsoft.SharePoint.Publishing.PublishingWeb" /> class wraps the <see cref="T:Microsoft.SharePoint.SPWeb" /> class. This property directly exposes the underlying <see cref="T:Microsoft.SharePoint.SPWeb" /> so that additional <see cref="T:Microsoft.SharePoint.SPWeb" /> functionality can be easily accessed.</para>
          <para />
        </remarks>
        <example>
          <para>This example demonstrates setting and saving property values on a publishing Web. Before building and running this example, verify that Publishing feature has been enabled for the <b>SPWeb</b>, and that the <b>defaultPageFileId</b> is <b>SPFile.UniqueId</b> for the new default page.</para>
          <code>using SPContentTypeId = Microsoft.SharePoint.SPContentTypeId;
using SPContentType = Microsoft.SharePoint.SPContentType;
using SPSite = Microsoft.SharePoint.SPSite;
using SPFile = Microsoft.SharePoint.SPFile;
using SPWeb = Microsoft.SharePoint.SPWeb;
using PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite;
using PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb;
using PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection;
using PageLayout = Microsoft.SharePoint.Publishing.PageLayout;

namespace Microsoft.SDK.SharePointServer.Samples
{
    public static class PublishingWebCodeSamples
    {
        public static void SetPublishingWebProperties(SPWeb web, System.Guid defaultPageFileId)
        {
// Replace these variable values and input parameters
// with your own values.
string newTitle = "your Title";         // new PublishingWeb.Title value
string newDescription = "your Description";         // new PublishingWeb.Description value
bool resetInheritPageLayouts = true;    // new PublishingWeb.IsInheritingAvailablePageLayouts value
bool resetInheritWebTemplates = true;   // new PublishingWeb.IsInheritingAvailableWebTemplates value

// Validate the input parameters.
if (null == web)
{
    throw new System.ArgumentNullException("web");
}

// Get the PublishingWeb wrapper for the SPWeb 
// that was passed in.
PublishingWeb publishingWeb = null;
if (PublishingWeb.IsPublishingWeb(web))
{
    publishingWeb = PublishingWeb.GetPublishingWeb(web);
}
else
{
    throw new System.ArgumentException("The SPWeb must be a PublishingWeb", "web");
}

//  Retrieve the SPFile.
SPFile newDefaultPageFile = publishingWeb.Web.GetFile(defaultPageFileId);
if( (null == newDefaultPageFile) ||
    !newDefaultPageFile.Exists )
{
    throw new System.ArgumentException(
        "The Guid does not match an SPFile on the SPWeb",
        "defaultPageFileId");
}

// Set new values on the PublishingWeb.
publishingWeb.Title = newTitle;
publishingWeb.Description = newDescription;
publishingWeb.DefaultPage = newDefaultPageFile;
if( resetInheritPageLayouts &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailablePageLayouts  &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailablePageLayouts();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts);
}
if (resetInheritWebTemplates &amp;amp;&amp;amp; 
    !publishingWeb.IsInheritingAvailableWebTemplates &amp;amp;&amp;amp;
    !publishingWeb.IsRoot)
{
    publishingWeb.InheritAvailableWebTemplates();
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates);
}

// Save the new values on the PublishingWeb.
publishingWeb.Update();
        }
    }
}</code>
          <code>Imports SPContentTypeId = Microsoft.SharePoint.SPContentTypeId
Imports SPContentType = Microsoft.SharePoint.SPContentType
Imports SPSite = Microsoft.SharePoint.SPSite
Imports SPFile = Microsoft.SharePoint.SPFile
Imports SPWeb = Microsoft.SharePoint.SPWeb
Imports PublishingSite = Microsoft.SharePoint.Publishing.PublishingSite
Imports PublishingWeb = Microsoft.SharePoint.Publishing.PublishingWeb
Imports PageLayoutCollection = Microsoft.SharePoint.Publishing.PageLayoutCollection
Imports PageLayout = Microsoft.SharePoint.Publishing.PageLayout

Namespace Microsoft.SDK.SharePointServer.Samples
    Public NotInheritable Class PublishingWebCodeSamples
        Private Sub New()
        End Sub
        Public Shared Sub SetPublishingWebProperties(ByVal web As SPWeb, ByVal defaultPageFileId As System.Guid)
' Replace these variable values and input parameters
' with your own values.
Dim newTitle As String = "your Title" ' new PublishingWeb.Title value
Dim newDescription As String = "your Description" ' new PublishingWeb.Description value
Dim resetInheritPageLayouts As Boolean = True ' new PublishingWeb.IsInheritingAvailablePageLayouts value
Dim resetInheritWebTemplates As Boolean = True ' new PublishingWeb.IsInheritingAvailableWebTemplates value

' Validate the input parameters.
If Nothing Is web Then
    Throw New System.ArgumentNullException("web")
End If

' Get the PublishingWeb wrapper for the SPWeb 
' that was passed in.
Dim publishingWeb As PublishingWeb = Nothing
If PublishingWeb.IsPublishingWeb(web) Then
    publishingWeb = PublishingWeb.GetPublishingWeb(web)
Else
    Throw New System.ArgumentException("The SPWeb must be a PublishingWeb", "web")
End If

'  Retrieve the SPFile.
Dim newDefaultPageFile As SPFile = publishingWeb.Web.GetFile(defaultPageFileId)
If (Nothing Is newDefaultPageFile) OrElse (Not newDefaultPageFile.Exists) Then
    Throw New System.ArgumentException("The Guid does not match an SPFile on the SPWeb", "defaultPageFileId")
End If

' Set new values on the PublishingWeb.
publishingWeb.Title = newTitle
publishingWeb.Description = newDescription
publishingWeb.DefaultPage = newDefaultPageFile
If resetInheritPageLayouts AndAlso (Not publishingWeb.IsInheritingAvailablePageLayouts) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailablePageLayouts()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailablePageLayouts)
End If
If resetInheritWebTemplates AndAlso (Not publishingWeb.IsInheritingAvailableWebTemplates) AndAlso (Not publishingWeb.IsRoot) Then
    publishingWeb.InheritAvailableWebTemplates()
    System.Diagnostics.Debug.Assert(publishingWeb.IsInheritingAvailableWebTemplates)
End If

' Save the new values on the PublishingWeb.
publishingWeb.Update()
        End Sub
    End Class
End Namespace</code>
        </example>
      </Docs>
    </Member>
  </Members>
</Type>