When you are Backup and Restore a site collection, you are actually performing 3 separate operations:

1. Backup the site to a single file.
2. Create a new site collection as the target site collection.
3. Do the Restore.

1. Backup SharePoint site collection

A. Click “Start” enter “All Programs.”

B.?Select “SharePoint 2010 Management Shell“(Run as Administrator).

C. Execute the following command as shown in figure below:

backup-SPSite http://kongyang:8081 -Path C:\8081.bak

D. The backup file 8081.bak has been generated in the Local Desk (C:) .

Note: http://kongyang:8081 is the name of the web application to be backed up.

2. Create Target Site Collection

SharePoint site collection is based on the web application, so we need to create a web application for the target site collection. And don’t forget to take attention to the Database Server name and Database name.

A. Create a web application (As shown in the Figure below)

B. Create site collection for the web application

3. Restore site collection

A. Click “Start“ enter “All Programs.”

B. Select “SharePoint 2010 Management Shell“(Run as Administrator).

C. Execute the following command as shown in Figure 3:
Restore-SPSite http://kongyang:2345 -Path C:\8081.bak -Force -DatabaseServer KONGYANG -DatabaseName wss_content_8081backup

D. Input “A,” then press “Enter,” will execute the restore.

Note: KONGYANG is the name of Database Server. wss_content_8081backup is the name of Database.

Exporting Site Columns

If you export a Managed Metadata Column and a Content Type using it to Visual Studio (SharePoint Designer > Export > Visual Studio Import, you know the drill) then you end up with definitions like below.

The Site Column is based on the TaxonomyFieldType and contains a Customization element which contains an array of properties (I’ve omitted most of them here). These properties contains IDs of the Managed Metadata group, term store and service application. Since these are unique for each MMS this definition cannot be provisioned to another farm (for instance from dev to stage, stage to prod etc).

<Field

Overwrite="TRUE">
<Default />
<Customization>
<ArrayOfProperty>
<Property>
<Name>SspId</Name>
<Value
xmlns:q1="http://www.w3.org/2001/XMLSchema"
p4:type="q1:string"
xmlns:p4="http://www.w3.org/2001/XMLSchema
instance">b98dd270-8577-4db8-99e1-b9e894624fdb
</Value>
</Property>
<Property>
<Name>GroupId</Name>
</Property>
<Property>
<Name>TermSetId</Name>
<Value
xmlns:q2="http://www.w3.org/2001/XMLSchema"
p4:type="q2:string"
xmlns:p4="http://www.w3.org/2001/XMLSchema
instance">b7ae10cd-6c7c-4386-a1f2-7abec8e759e1
</Value>
</Property>
<Property>
<Name>AnchorId</Name>
<Value
xmlns:q3="http://www.w3.org/2001/XMLSchema"
p4:type="q3:string"
xmlns:p4="http://www.w3.org/2001/XMLSchema-instance">00000000-0000-0000-0000-000000000000
</Value>
</Property>
...
</ArrayOfProperty>
</Customization>
</Field>

And if you examine the XML further you will also notice that a second field is defined for this Site Column. This field is of the type Note and is hidden.

<Field DisplayName="__Custom_0" StaticName="__CustomTaxHTField0"
ShowInViewForms="FALSE" Required="FALSE"     Hidden="TRUE" CanToggleHidden="TRUE"
SourceID="{5e68c9eb-5efe-4bcc-b8db-93d38d797fbe}" Overwrite="TRUE" />

A lot of XML but quite useless for reuse…

So how do I do then?

To provision the Site Columns and Content Types without these hardcoded Guids and IDs you basically have two options:

1. Create an event receiver (or similar) that creates the Site Columns and Content Types programmatically
2. A combination of declarative and the programmatic approach above

I prefer the second approach and I will show you how to do it (the first one can quite easily be done based on the code that will follow).

First you need to create a new SharePoint 2010 project in Visual Studio 2010, create a new Empty SharePoint project. Then add a new Content Type SharePoint Project Item (SPI) to the project and inherit it from the Item content type. Then add a new XML file to the SPI and name it Fields.xml. This elements manifest will contain the Site Column definition, but in order to make it into a manifest file you need to select the file and press F4 to edit the properties of the file. Change the Deplyment Type from NoDeployment to ElementManifest. Your solution should look like the image to the right. Also make sure to set the feature to be scoped to Site (Site Collection) level – we’re talking about deploying Site Columns and Content Types here.

Then it is time to write the declarative part (i.e. the XML). You need to add a new Field element of the type TaxonomyFieldType (or TaxonomyFieldTypeMulti). Configure it as follows or as it suits your needs. Notice that I have set the ShowField attribute to Term1033, this is needed by the MMS to select the correct term value.

xml version="1.0" encoding="utf-8" ?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
<Field ID="{749DA0D1-4649-4C25-871B-05F0C07221FC}"
Type="TaxonomyFieldType"
DisplayName="Home Country"
ShowField="Term1033"
Required="TRUE"
EnforceUniqueValues="FALSE"
Group="_Custom"
StaticName="HomeCountry"
Name="HomeCountry"
/>
</Elements>

To add this field to the content type there is no rocket science, just do as you normally do:

<FieldRef ID="{749DA0D1-4649-4C25-871B-05F0C07221FC}" Name="HomeCountry"/>

That’s all that you can do declarative. If this would be deployed a field would be created of the type Managed Metadata but you have to manually connect it to the MMS.

Now we have to dig into some programming to connect the field to the MMS. This is done in an Event Receiver for the feature. Right-click the feature and select Add Event Receiver. Uncomment the FeatureActivated method and implement it as follows:

public override void FeatureActivated(SPFeatureReceiverProperties properties) {
SPSite site = properties.Feature.Parent as SPSite;
Guid fieldId = new Guid("{749DA0D1-4649-4C25-871B-05F0C07221FC}");
if (site.RootWeb.Fields.Contains(fieldId)) {
TaxonomySession session = new TaxonomySession(site);

// Connect to MMS
field.SspId = termSet.TermStore.Id;
field.TermSetId = termSet.Id;
field.TargetTemplate = string.Empty;
field.AnchorId = Guid.Empty;
field.Update();
}
}
}

This method will first check if the field has been deployed. The field is retrieved using the Guid of the Field, defined in the XML. Once that is confirmed that the field exists a TaxonomySession object is acquired using the SPSite object. The TaxonomySession object is declared in the Microsoft.SharePoint.Taxonomy assembly – so you have to add a reference to that assembly first. To connect the field to the MMS you need to retrieve the Term Store, Group and Term Set. All this is done using the names of them as defined in the MMS. The image to the right shows how the MMS looks like that this code is connecting the field to. It is very likely that you have the same structure of the MMS in your different environments – if not you have to come up with a more configurable way

Note the GetByName method used above is a custom extension that looks like this:

public static Group GetByName(this GroupCollection groupCollection, string name) {
if (String.IsNullOrEmpty(name)) {
throw new ArgumentException("Not a valid group name", "name");
}
foreach (var group in groupCollection) {
if (group.Name == name) {
return group;
}
}
throw new ArgumentOutOfRangeException("name", name, "Could not find the group");
}

Once you have a hold on the taxonomy objects then it is time to convert the Field to a TaxonomyField object. This object is then configured with a set of properties. Specifically the ID of the Term Store and Term Set is set. Finally the field is updated to reflect the changes.

The Result!

That’s it. All you now have to do is deploy it and test it out.

The utility can be downloaded here:

http://code.msdn.microsoft.com/SPDisposeCheck

To integrate the utility into your development environment, in Visual Studio go to the “Tools” menu and select the “External Tools” menu item. Select “Add” and configure the tools options as follows:

The command argument should point to the SPDisposeCheck executable. Pass the project BIN directory as an argument, and set the initial directory to your solution directory. Select the “Use Output window” checkbox so that the results from the tool display in the Visual Studio output window.

To use the tool, select a project in your solution, and then select the “SPDispose Checker” utility from your tools menu. The results from the tool will display in the output window. If you have any improperly disposed objects, the results in your output window will direct you to where the problems are located in the assembly.

What we want to do

The objective is to create a Silverlight application capable to list the Libraries and Lists of a Sharepoint site in a DataGrid. We want to be able to insert one or more files into a Library or List through a simple drag & drop of files from the file system over an item of the DataGrid. I decided to do this because the standard procedure to upload files on Sharepoint is a little boring as you will see in the next paragraph.
In this video you can see briefly the creation of the application and here you can download the code.

The standard procedure to upload images and files in Sharepoint

Depending on the site template you have chosen, SharePoint 2010 provides a series of lists and libraries where it is suggested to load the images, style sheets, documents, files, etc. In particular, the “Team Site” template includes four Document Libraries which, as you can see in the image below, should be used according to the rules described on the right.

Now let’s suppose we want to add a series of images to the Site Assets Library and a css file to the Style Library. Starting from the home page, we have to click on “Libraries”, then on “Site Assets”, then on “add document”, then on “Upload multiple files…”, then drag&drop the image files and eventually click OK. To insert the css file we have to follow more or less the same procedure. The following image shows all the steps required.

It is a little boring, isn’t it? Would not it be better to see all the Libraries and Lists inside a flat grid and perform the drag and drop on a row of the grid? Let’s find out in the next paragraphs.

Building the Silverlight application responsible for uploading files

First of all make sure you have installed the Silverlight Toolkit, since we will use some controls included in this package. Let’s create a new project of type “Silverlight application” in Visual Studio; you can skip the option to “Host the Silverlight application in a new Web site” since we will use a Sharepoint site instead. Add the references to “System.Windows.Controls.Toolkit” and “System.Windows.Controls.Data.Toolkit” and insert the xaml code below in MainPage.xaml:

xmlns:toolkit="http://schemas.microsoft.com/winfx/2006/xaml/presentation/toolkit"
xmlns:toolkitData="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data.Toolkit"
>
<toolkit:BusyIndicator x:Name="busyIndicatorElement" IsBusy="false" BusyContent="Contacting Sharepoint..." >
<toolkitData:DataGridDragDropTarget x:Name="MainGridDragDropElement" HorizontalAlignment="Stretch">
<sdk:DataGrid Name="MainGridElement" AutoGenerateColumns="True" AllowDrop="True"  HorizontalScrollBarVisibility="Auto" VerticalScrollBarVisibility="Visible"  HorizontalAlignment="Stretch" />
</toolkitData:DataGridDragDropTarget>
</toolkit:BusyIndicator>

As you can see the interface is very basic: a BusyIndicator Control surrounds a DataGrid with its drag-n-drop-target Content Control. I used the BusyIndicator Control to get an immediate feedback each time the application is waiting for a response from Sharepoint.

Getting data from Sharepoint using the Silverlight Client Object Model

Using the SL Client Object model to retrieve data from Sharepoint is easier than it seems. However, before going any further you should have three things clear in mind:

1. since Silverlight follows an asynchronous model, you can only make asynchronous queries to the Sharepoint Server from the UI thread. You can perform synchronous queries only in a thread that does not interact with the UI thread for instance using a ThreadPool.QueueUserWorkItem()
2. you have to perform two separate tasks: firstly inform the Client Object Model about operations that you need (i.e. accessing properties of Sharepoint objects, data retrieval etc) using a “Load()” method and then send these “loaded operations” to Sharepoint launching an asynchronous call.
3. any asynchronous query you make, be it successful or failed, will fire a callback running into another thread other than the main UI thread.

To play with the Client Object model you need to add the following reference assemblies: Microsoft.SharePoint.Client.Silverlight and Microsoft.SharePoint.Client.Silverlight.Runtime. They are usually located in “\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\TEMPLATE\LAYOUTS\ClientBin”.

The namespace to use is, as you may guess, Microsoft.SharePoint.Client;

In our specific application that we want to build we need to know the title of the Libraries and Lists included in our Sharepoint site. How can that be obtained? First by defining a ClientContext object in the MainPage code behind , then by creating a method to load your requests to the Client Model and recall it from the MainPage() constructor after InitializeComponent():

public partial class MainPage : UserControl

private ClientContext myClContext;

public MainPage()
{
InitializeComponent();

// Drop Event Handler
MainGridElement.Drop += new DragEventHandler(SPListsGrid_Drop);

ConnectToSP();
}

private void ConnectToSP()
{
myClContext = new ClientContext("http://My_Server_name");

myClContext.Load(myClContext.Web);
myClContext.Load(myClContext.Web.Lists);

myClContext.ExecuteQueryAsync(OnConnectSucceeded, OnConnectFailed);
busyIndicatorElement.IsBusy = true;
}

As you can see, I instantiated a ClientContext giving the Url of the server then I asked for the access to the Web and Lists objects of Sharepoint calling the load() method. Eventually, I called ExecuteQueryAsync() passing the callbacks to activate in case of success and failure.

Since the callbacks run in a separate thread we can only schedule the execution of the necessary update of the UI using a Dispatcher:

// callbacks
private void OnConnectSucceeded(Object sender, ClientRequestSucceededEventArgs args)
{
Dispatcher.BeginInvoke(FillGrid);
}

private void OnConnectFailed(object sender, ClientRequestFailedEventArgs args)
{
Dispatcher.BeginInvoke(NotifyFailure);
}

The OnConnectSucceeded(..) callback invokes the execution of the method FillGrid() in the UI thread; FillGrid() performs the databinding to the DataGrid as follows:

private void FillGrid()
{
busyIndicatorElement.IsBusy = false;
var isource = from List ls in myClContext.Web.Lists.AsEnumerable()
select new InfoList() { Title = ls.Title, Description = ls.Description };

MainGridElement.ItemsSource = isource;
}

public class InfoList
{
public string Title { get; set; }
public string Description { get; set; }
}

where I used a dummy object (InfoList) since the databinding with anonymous types is still an issue in Silverlight.

Capturing the Drop event and uploading the files dragged

Now it’s time to add the logic for handling the drag&drop of files in the DataGrid. Just an event handler for the Drop event is needed:

void SPListsGrid_Drop(object sender, DragEventArgs e)
{
if (e.Data == null)
return;

// we have to identify the item in the Grid where the file is dropped
Point loc = e.GetPosition(Application.Current.RootVisual);

var list = VisualTreeHelper.FindElementsInHostCoordinates(loc, MainGridElement);
DataGridRow row = list.FirstOrDefault(i => i is DataGridRow) as DataGridRow;

if (row != null)
{
IDataObject dataObject = e.Data as IDataObject;
FileInfo[] files = dataObject.GetData(DataFormats.FileDrop) as FileInfo[];

InfoList listDetails = row.DataContext as InfoList;
foreach (FileInfo file in files)
{
UploadFile(file, listDetails.Title);
}
}
}

The code above locates the row where the files were dropped and for each of them calls the Upload() method where, again, the Client Object Model is implicated. Here the code for the Upload() method:

private void UploadFile(FileInfo fileToUpload, string libraryTitle)
{
var web = myClContext.Web;
List destinationList = web.Lists.GetByTitle(libraryTitle);

var fciFileToUpload = new FileCreationInformation();

Stream streamToUpload = fileToUpload.OpenRead();
int length = (int)streamToUpload.Length;  // get file length

fciFileToUpload.Content = new byte[length];

int count = 0;                        // actual number of bytes read
int sum = 0;                          // total number of bytes read

while ((count = streamToUpload.Read(fciFileToUpload.Content, sum, length - sum)) > 0)
sum += count;  // sum is a buffer offset for next reading
streamToUpload.Close();

fciFileToUpload.Url = fileToUpload.Name;

Microsoft.SharePoint.Client.File clFileToUpload = destinationList.RootFolder.Files.Add(fciFileToUpload);

myClContext.Load(clFileToUpload);
myClContext.ExecuteQueryAsync(OnLoadingSucceeded, OnLoadingFailed);
busyIndicatorElement.IsBusy = true;
}

What is interesting to highlight in the UploadFile() above is that we make use of the Web object of the ClientContext included as a request in the previous query to get the List (or Library) where we want to put the file. Once we have the list (destinationList), we read the file and create a Sharepoint.Client.File object, then load it in the ClientContext created at the beginning. Once again, an asynchronous request is submitted to perform the action. In the OnLoadingSucceeded() callback you can notify the user about the positive result of the operation in various ways. In the source code of my example I just added a “OK, file uploaded!” message box.

Deploy the Silverlight application using a Visual WebPart

In my previous article “Silverlight and Sharepoint 2010: Getting Started” I described three different methods to insert a Silverlight application in a Sharepoint Site. Now we are going to see the fourth (yes, another one). Somehow it is a combination between the second method, “Using a web part”, and the third method “Using a Sharepoint module”. In fact, as in the second method, the Silverlight application is attached to the Visual Web Part by adding a portion of HTML code, which includes the Silverlight host control to the rendering of the web part. Furthermore, for the deployment this fourth method makes use of a mechanism similar to the module method where a module ferries the Silverlight application inside Sharepoint but this time the ‘ferry’ is the Visual WebPart.

The reason why I used this new method will be clear in a moment, for now I anticipate that in this way we will be able to pass values and parameters between the web part and the Silverlight application. Let’s go ahead by adding a new project to the solution of the Siverlight app that we have just created. Choose the “Sharepoint 2010 Visual Web Part” template from “New Project in Visual Studio:

Choose the option “Deploy as a farm solution”, in the Solution Explorer, locate the “VisualWebPart1” automatically generated and delete it. Now right click on the Project name and choose “Add new item”; from the dialog box choose the “Visual Web Part” template of Sharepoint 2010 and call it “FileUploaderVWP” as in the image below:

Don’t worry about this strange procedure, it’s just a pragmatic way to give an identifiable name to the Visual Web Part without having to change it by hand here and there in various files. Open the source code of the Visual Web Part (it should be the file “FileUploaderVWP.cs”) and override the Prerender() method as follows:

protected override void OnPreRender(EventArgs e)
{
string webUrl = SPContext.Current.Web.Url;

string renderHost = @"<div id='silverlightControlHost'>
<object data='data:application/x-silverlight-2,'
type='application/x-silverlight-2' width='100%' height='100%'>
<param name='source' value='/_catalogs/wp/SLFileUpload.xap'/>
<param name='background' value='white' />
<param name='minRuntimeVersion' value='4.0.50303.0' />
<param name='autoUpgrade' value='true' />
<param name='windowless' value='false'/>
<param name='initParams' value='host_url=" + webUrl +  @"' />
<a href='http://go.microsoft.com/fwlink/?LinkID=149156
&v=4.0.50303.0' style='text-decoration:none'>
<img src='http://go.microsoft.com/fwlink/?LinkId=161376'
alt='Get Microsoft Silverlight' style='border-style:none'/>
</a>
</object><iframe id='_sl_historyFrame' style='visibility:hidden;
height:0px;width:0px;border:0px'></iframe></div>";

LiteralControl host = new LiteralControl(renderHost);
Controls.Add(host);
base.OnPreRender(e);
}

As you may see a Silverlight host control is injected into the HTML before the rendering of the web part. Now give a look at the value of “source” parameter: “/_catalogs/wp/”; it is the default path where Sharepoint puts all the web parts. We will put also our Silverlight app in this folder in a while. The other interesting thing here is that at the beginning we make a call to the server object model of Sharepoint to retrieve the Url of our Sharepoint site (this code runs on the server so we don’t need to invoke the client model here). The url is then passed to the Silverlight app as an initParams attribute called “host_url”. Why are we doing this? Because when in the Silverlight app we query the Client object model for the first time , we can’t obtain this information in any way.

If you have noticed in the code snippet added in the paragraph Getting data from Sharepoint using the Silverlight Client Object Model, I had included the name of the server statically:

myClContext = new ClientContext(http://my_server_name/);

This makes the application unusable in other domains without recompile. Passing this information as parameter solves the problem. Now you can substitute the line of code above with the following:

string webUrl = App.Current.Host.InitParams["host_url"];
myClContext = new ClientContext(webUrl);

and the application will work also in other domains.

Using the Visual Web Part as a ‘ferry’

The next step is to raise your thumb and hitchhike to find someone who has a seat available for your Silverlight application, destination: ‘Sharepoint’. In my previous article it was a module, this time it is the visual Web Part itself. Let’s go back to Visual Studio and, in the Solution Explorer, right click on your Web Part (FileUploaderVWP) and click on “Properties” in the context menu. In the Properties panel Select the “Project Output References” property and click on the small button on the right to open the “Project Output References” Dialog Box; here click on the “Add” button to add an item to the list on the left; configure the properties on the right as shown in the following image:

Unfortunately this step is not enough to fully instruct the deployment process. We need to manually modify the file Elements.xml under the Visual Web Part tree including the line highlighted:

<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/" >
<Module Name="SPFileUploadVWP" List="113" Url="_catalogs/wp">
<File Path="SPFileUploadVWP\SPFileUploadVWP.webpart" Url="SPFileUploadVWP.webpart" Type="GhostableInLibrary" >
<Property Name="Group" Value="Custom" />
</File>
<File Path="SPFileUploadVWP\SLFileUpload.xap" Url="SLFileUpload.xap" />
</Module>
</Elements>

Here, contrary to what we saw in the ‘module method’ Visual Studio does not help us to update the file automatically.
You can now select the Sharepoint project just included in the Solution as the “Startup project”, add the Silverlight Project to its “Project Dependencies” and deploy your solution. Your “.xap” file will be added to Sharepoint in the same folder of the other web parts.

Don’t forget to enable debugging: open the dialog box of the properties of your Sharepoint Visual Web Part project; click on the “SharePoint” tab option and set the “Enable Silverlight debugging (instead of Script debugging) checkbox”.

Summary

In this article we have put togheter the potential of Silverlight and of the SL Client Object Model added in Sharepoint 2010 to create a small but useful utility to quickly load files in a List or Library of Sharepoint. We have learned how to get the title and description of all the Libraries and Lists in our Sharepoint site and how to insert files in a List. We have also learned how to pass data from the host Web Part to the Silverlight application. Possible improvements are: finding a way to allow upload ing of large files (this is regulated by a setting of the site accessible from the administration) , an extended DataGrid showing the files included in each List or Library, interaction with the publishing framework and a better look and feel in general.

There is a solution that fits the needs of designers, developers, their clients and their end-users: Enter the SP2010 Ribbon Toggler! Toggle it with a keystroke, querystring, or a button. Let’s implement it:

How to do it

1. Open an editor of your choice to create a new .js file and paste the following code into it:

function ShowRibbon() {
$('#s4-ribbonrow').show();
$('#s4-workspace').height($(document).height() – $('#s4-ribbonrow').height() * 2);
}

function HideRibbon() {
$('#s4-ribbonrow').hide();
var newHeight = $(document).height();
if ($.browser.msie) { newHeight = newHeight – 3; }
$('#s4-workspace').height(newHeight);
}

2. Save your .js file as SP2010_RibbonToggler.js.
3. Open up SharePoint Designer and browse to your root site.
4. In the left tool pane called “Site Objects” click on “Site Assets.”
5. In the top tool bar, select “Import Files” and import the .js file you created. (If you’d like to create a separate “scripts” folder within Site Assets, or organize it in any way you’d like, now’s the time.)
6. In the left tool pane again select “Master Pages.”
7. Open the Master Page that you’re using for your Site. In most cases you’re probably using v4.master.
8. In the HTML markup, find the section and place the following JavaScript references within the head section:

<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js"></script>
< script src="/SiteAssets/SP2010_RibbonToggler.js"></script>

Note: We’re first here referencing the jQuery framework. Our code uses this framework to easily and quickly access the Document Object across differing browers. We then reference our SP2010_RibbonToggler.js file. Remember to change the reference path if you put your SP2010_RibbonToggler.js file in a different location than instructed to at the beginning of this tutorial.

We now have two functions in our SharePoint site for turning on and off the ribbon! Now we just need to implement some Javascript code to use these functions. The sky’s the limit for how you want to accomplish this. At Concurrency, we like to use a keystroke combination (ctrl+shift+r) to pop up the ribbon. Here’s how to do that:

In your SP2010_RibbonToggler.js file, at the following code to it:

$(document).keydown(function (e) {
if (e.keyCode == 17) { ks = "a"; return false; }
if (e.keyCode == 16) { if (ks == "a") { ks = ks + "b"; return false; } }
if (e.keyCode == 82) {
if (ks == "ab") {
ks = "";
if($('#s4-ribbonrow').css('display')=="none") {
//show
ShowRibbon();
} else {
//hide
HideRibbon();
}
return false;
}
}
return true;
});

Additional ways to toggle

Another way to turn on and off the ribbon now is by passing a query string to the page. If we append ?ribn=1 to our site address at any time, the ribbon will show. This is how to do that:

In your SP2010_RibbonToggler.js file, at the following code to it:

$(document).ready(function(){
if(getParameterByName('ribn')=="1″) {
ShowRibbon();
} else {
HideRibbon();
}
});

function getParameterByName(name) {
name = name.replace(/[\[]/, "\\\[").replace(/[\]]/, "\\\]");
var regexS = "[\\?&]" + name + "=([^&#]*)";
var regex = new RegExp(regexS);
var results = regex.exec(window.location.href);
if (results == null)
return "";
else
return decodeURIComponent(results[1].replace(/\+/g, " "));
}

Or perhaps you only want to show the ribbon if the user has authenticated to SharePoint? Here’s how to do that:

In your SP2010_RibbonToggler.js file, at the following code to it:

$(document).ready(function(){
if (typeof _spUserId == "undefined") {
HideRibbon();
}else {
ShowRibbon();
}
});

In fact, you can add all of these examples to your SP2010_RibbonToggler.js file and they will all work together for you. Wouldn’t if be nice if you could download a fully functional .js file with all this working? It would…