basics Archives - Bool Tech

JSGrid is the javascript framework in SharePoint used in Quick Edit View (previously Datasheet View). There are a few very good blog posts on this topic (See below in “Sources”). Nevertheless the fact is that jsgrid and working with quick edit from a developer’s perspective is a huge undiscovered area. Articles I have seen are intended for advanced developers. The goal with my post today is to outline the very basics of working with JSGrid. When you know the basics you will be more comfortable to discover and try out more.

The example I want to show is a jsgrid code for a “VerySimpleColumn”. The source code can be found on gist.github.com: https://gist.github.com/mirontoli/838d60df76107fac56a0 To focus on jsgrid, I assume you have knowledge and some experience of working with jslink, which is related to jsgrid.

A word of caution before we start

JSGrid is an undocumented part of SharePoint javascript “ecosystem”, neither it is a part of the official SharePoint javascript api. So actually we should not use it. On the other hand JSGrid indicates something that is more like a full-fledged javascript api because:

It seems to be carefully prepared (all possible situations are covered)
The api is human-readable. The events and properties are called OnBeginEdit, OnEndEdit, Focus, BindToCell and so on (opposed to the properties in the SP.Microfeed.js like $v_1, $v_2)
It follows many best-practices for handling the UI in javascript, eventhough some constructs are clumsy, e.g. using absolute-positioned overlays on top of original table cells while editing a cell value.

So to me it seems quite okay to use it in real applications, but we have to live with the risk that the jsgrid api will be changed without any notice to us developers.

Set up a site column with a custom jslink

The first step is to set up everything so we can start discovering jsgrid. It is just a walkthrough, not a detailed explanation. If you are eager to look at jsgrid, jump directly to that section. In this example we’ll apply a jslink to a custom site column. The very same jslink will be used in jsgrid, too.

First of all add a new Site Column, call it VerySimpleColumn. The type is Multiple lines of text:

Let us put it in a new group: Tolle Columns (beautiful, huh?)

Three lines of plain text. Nothing extravagant.

After that we can verify that the column exists. Fine.

Now we have to update the jslink property for the new column. Make it in an app:

Now add a custom list, call it “TolleList”:

In the List Settings add the new site column, then you’ll see this:

Now upload an empty js file to the Style Library, call it field.jslink.verysimplecolumn.js:

It goes so fast :) Now it is time to implement some jslink code

Writing jslink

I’ve been thinking a while. What example could I use for that jslink? I want it to be a very simple example, so we don’t need to concentrate on actual rendering logic. You can see sophisticated examples that I listed below in “Sources”. Here we will be using this example: We’ll append a text to the field value: “This field is fully controlled by jslink”. This text should be visible on all forms, but it is not a part of the actual field value. Well here it is:

The code should appear simple for us who have written at least some jslink code.

(function () {
    function verySimpleView(ctx, field) {
        var wrapper = 'This field is fully controlled by jslink&lt;hr&gt;&lt;span&gt;{0}&lt;/span&gt;';
        var value = ctx.CurrentItem[ctx.CurrentFieldSchema.Name] || &quot;&quot;;
        return String.format(wrapper, value);
    }
    
    function verySimpleNewAndEdit(ctx) {
        var wrapper = 'This field is fully controlled by jslink&lt;br&gt;&lt;input type=&quot;text&quot; id=&quot;{0}&quot; value&quot;{1}&quot;/&gt;';
        var id = 'tolle-' + new Date().getTime();
        var formCtx = SPClientTemplates.Utility.GetFormContextForCurrentField(ctx);
 
        formCtx.registerGetValueCallback(formCtx.fieldName, function () {
            var input = document.getElementById(id);
            return input.value;
        });
        var value = ctx.CurrentItem[ctx.CurrentFieldSchema.Name] || &quot;&quot;;
        var html = String.format(wrapper, id, value);
        return html;
    }
    var overrideContext = {};
 
    overrideContext.Templates = overrideContext.Templates || {};
    overrideContext.Templates.Fields = {
        'VerySimpleColumn': {
            'View': verySimpleView,
            'DisplayForm': verySimpleView,
            'EditForm': verySimpleNewAndEdit,
            'NewForm': verySimpleNewAndEdit
        }
    };
 
    SPClientTemplates.TemplateManager.RegisterTemplateOverrides(overrideContext);
})();

(function () {

function verySimpleView(ctx, field) {

var wrapper = 'This field is fully controlled by jslink<hr>{0}';

var value = ctx.CurrentItem[ctx.CurrentFieldSchema.Name] || "";

return String.format(wrapper, value);

}

function verySimpleNewAndEdit(ctx) {

var wrapper = 'This field is fully controlled by jslink <input type="text" id="{0}" value"{1}"/>';

var id = 'tolle-' + new Date().getTime();

var formCtx = SPClientTemplates.Utility.GetFormContextForCurrentField(ctx);

formCtx.registerGetValueCallback(formCtx.fieldName, function () {

var input = document.getElementById(id);

return input.value;

});

var value = ctx.CurrentItem[ctx.CurrentFieldSchema.Name] || "";

var html = String.format(wrapper, id, value);

return html;

}

var overrideContext = {};

overrideContext.Templates = overrideContext.Templates || {};

overrideContext.Templates.Fields = {

'VerySimpleColumn': {

'View': verySimpleView,

'DisplayForm': verySimpleView,

'EditForm': verySimpleNewAndEdit,

'NewForm': verySimpleNewAndEdit

}

};

SPClientTemplates.TemplateManager.RegisterTemplateOverrides(overrideContext);

})();

This is how it looks like in the DispForm:

JSGrid. First Step: Disable the field in Quick Edit

Now we are ready to handle the Quick Edit. What we’ll do first is to disable editing our column. Why? Let’s say we have some complicated logic for rendering and editing of our field, we don’t the quick edit override it. So before we start implementing the QuickEdit part of the field, we want to disable it. Here, perhaps, ends the implementation of Quick Edit for some business cases.

To determine the Quick Edit we can use the propery of ther Render Context called inGridMode. The Quick Edit list uses the “View” template:

; title: ; notranslate ]
function handleGridMode(ctx, field) {
    field.AllowGridEditing = false;
}
function verySimpleView(ctx, field) {
    var wrapper = 'This field is fully controlled by jslink&lt;hr&gt;&lt;span&gt;{0}&lt;/span&gt;';
    var value = ctx.CurrentItem[ctx.CurrentFieldSchema.Name] || &quot;&quot;;
    if (ctx.inGridMode) {
        handleGridMode(ctx, field);
    }
    return String.format(wrapper, value);
}

; title: ; notranslate ]

function handleGridMode(ctx, field) {

field.AllowGridEditing = false;

}

function verySimpleView(ctx, field) {

var wrapper = 'This field is fully controlled by jslink<hr>{0}';

var value = ctx.CurrentItem[ctx.CurrentFieldSchema.Name] || "";

if (ctx.inGridMode) {

handleGridMode(ctx, field);

}

return String.format(wrapper, value);

}

Wiring up a jsgrid EditControl

When our code works in all forms and the values are not “damaged” in the Quick Edit View, then the next step is to create an Edit Control that is used by the jsgrid “engine”. The very minimal Edit Control object is as follows. It contains a few event listeners and properties:

{
    SupportedWriteMode: SP.JsGrid.EditActorWriteType.LocalizedOnly,
    SupportedReadMode: SP.JsGrid.EditActorReadType.LocalizedOnly,
    BindToCell: function () { console.log(&quot;tolle BindToCell&quot;); },
    OnCellMove: function () { console.log(&quot;tolle OnCellMove&quot;); },
    Focus: function () { console.log(&quot;tolle Focus&quot;); },
    OnBeginEdit: function () { console.log(&quot;tolle OnBeginEdit&quot;); },
    OnEndEdit: function () { console.log(&quot;tolle OnEndEdit&quot;); },
    Unbind: function () { console.log(&quot;tolle Unbind&quot;); },
    Dispose: function () { console.log(&quot;tolle Dispose&quot;); }
}

{

SupportedWriteMode: SP.JsGrid.EditActorWriteType.LocalizedOnly,

SupportedReadMode: SP.JsGrid.EditActorReadType.LocalizedOnly,

BindToCell: function () { console.log("tolle BindToCell"); },

OnCellMove: function () { console.log("tolle OnCellMove"); },

Focus: function () { console.log("tolle Focus"); },

OnBeginEdit: function () { console.log("tolle OnBeginEdit"); },

OnEndEdit: function () { console.log("tolle OnEndEdit"); },

Unbind: function () { console.log("tolle Unbind"); },

Dispose: function () { console.log("tolle Dispose"); }

}

This edit control is created and returned in a function that is called: createVerySimpleColumnGridEditControl.

; title: ; notranslate ]
var createVerySimpleColumnGridEditControl = function (gridContext, cellControl) {
    return {
        SupportedWriteMode: SP.JsGrid.EditActorWriteType.LocalizedOnly,
        SupportedReadMode: SP.JsGrid.EditActorReadType.LocalizedOnly,
        BindToCell: function () { console.log(&quot;tolle BindToCell&quot;); },
        OnCellMove: function () { console.log(&quot;tolle OnCellMove&quot;); },
        Focus: function () { console.log(&quot;tolle Focus&quot;); },
        OnBeginEdit: function () { console.log(&quot;tolle OnBeginEdit&quot;); },
        OnEndEdit: function () { console.log(&quot;tolle OnEndEdit&quot;); },
        Unbind: function () { console.log(&quot;tolle Unbind&quot;); },
        Dispose: function () { console.log(&quot;tolle Dispose&quot;); }
    }
};

; title: ; notranslate ]

var createVerySimpleColumnGridEditControl = function (gridContext, cellControl) {

return {

SupportedWriteMode: SP.JsGrid.EditActorWriteType.LocalizedOnly,

SupportedReadMode: SP.JsGrid.EditActorReadType.LocalizedOnly,

BindToCell: function () { console.log("tolle BindToCell"); },

OnCellMove: function () { console.log("tolle OnCellMove"); },

Focus: function () { console.log("tolle Focus"); },

OnBeginEdit: function () { console.log("tolle OnBeginEdit"); },

OnEndEdit: function () { console.log("tolle OnEndEdit"); },

Unbind: function () { console.log("tolle Unbind"); },

Dispose: function () { console.log("tolle Dispose"); }

}

};

Now we have to register our Edit Control when jsgrid is ready. We have to write a callback function and invoke SP.GanttControl.WaitForGanttCreation. Inside the callback function we register our Edit Control for our field: SP.JsGrid.PropertyType.Utils.RegisterEditControl

; title: ; notranslate ]
function handleGridMode(ctx, field) {
    window.SP.SOD.executeOrDelayUntilScriptLoaded(function () {
        window.SP.GanttControl.WaitForGanttCreation(function (ganttChart) {
            var verySimpleColumn = null;
            var editId = &quot;EDIT_TOLLE_VERYSIMPLEFIELD&quot;;
            var columns = ganttChart.get_Columns();

            for (var i = 0; i &lt; columns.length; i++) {
                if (columns[i].columnKey == &quot;VerySimpleColumn&quot;) {
                    verySimpleColumn = columns[i];
                    break;
                }
            }
            if (verySimpleColumn) {
                verySimpleColumn.fnGetEditControlName = function (record, fieldKey) {
                    return editId;
                };

                window.SP.JsGrid.PropertyType.Utils.RegisterEditControl(editId, function (gridContext, cellControl) {
                    return createVerySimpleColumnGridEditControl(gridContext, cellControl);
                }, []);
            }

        });
    }, &quot;spgantt.js&quot;);
}

; title: ; notranslate ]

function handleGridMode(ctx, field) {

window.SP.SOD.executeOrDelayUntilScriptLoaded(function () {

window.SP.GanttControl.WaitForGanttCreation(function (ganttChart) {

var verySimpleColumn = null;

var editId = "EDIT_TOLLE_VERYSIMPLEFIELD";

var columns = ganttChart.get_Columns();

for (var i = 0; i < columns.length; i++) {

if (columns[i].columnKey == "VerySimpleColumn") {

verySimpleColumn = columns[i];

break;

}

if (verySimpleColumn) {

verySimpleColumn.fnGetEditControlName = function (record, fieldKey) {

return editId;

};

window.SP.JsGrid.PropertyType.Utils.RegisterEditControl(editId, function (gridContext, cellControl) {

return createVerySimpleColumnGridEditControl(gridContext, cellControl);

}, []);

}

});

}, "spgantt.js");

}

In our first version of the Edit Control we only log the event names to the web browser console. It works.

Implementing the actual editing

When working on this I did small changes to these events and tried it out in the web browser. I’d recommend it to you, too. Trying out is the best way of learning. Here comes the functions that we need to have to implement:

createVerySimpleColumnGridEditControl (“constructor”). Here we initialize the edit control
bindToCell. Here we get the cellContext that we save as a “private” variable on that Edit Control object. The cell context is needed to get and set the field value.
focus. Here we define what element should be focused. In this case we forward the focus event to the actual input
onBeginEdit. Here we show the Edit Control and make it editable.
onEndEdit. Here we save the field value and hide the edit control.

Some notes on the Edit Control and Events

The Edit Control has a “container” – a html element that contains the representation of the field in edit mode. The Edit Control Container is an overlay – an absolutely-positioned element that exists outside the actual listview. We must set the position and we are responsible for hiding it when the field is not edited:

container.style.cssText = 'visibility:hidden;position:absolute;top:0;left:0;background:#ffffff;';

1	container.style.cssText = 'visibility:hidden;position:absolute;top:0;left:0;background:#ffffff;';

We also need to set the dimensions of the edit control container. It is quite easy using the information from cellContext:

; title: ; notranslate ]
var bindToCell = function(ctx) {
    cellContext = ctx;
    //An input is put as an overlay. 
    //We have to set the width and height so that it takes the whole cell place
    container.style.minWidth = cellContext.cellWidth + 'px';
    container.style.width = cellContext.cellWidth + 'px';
    container.style.height = cellContext.cellHeight + 'px';
    console.log(&quot;tolle BindToCell&quot;);
};

; title: ; notranslate ]

var bindToCell = function(ctx) {

cellContext = ctx;

//An input is put as an overlay.

//We have to set the width and height so that it takes the whole cell place

container.style.minWidth = cellContext.cellWidth + 'px';

container.style.width = cellContext.cellWidth + 'px';

container.style.height = cellContext.cellHeight + 'px';

console.log("tolle BindToCell");

};

In OnBeginEdit we have to show the container, and in OnEndEdit we have to hide it

//OnBeginEdit
cellContext.Show(container);
//OnEndEdit
cellContext.Hide(container);

//OnBeginEdit

cellContext.Show(container);

//OnEndEdit

cellContext.Hide(container);

We have to save the value using the cellContext.

; title: ; notranslate ]
var value = input.value;
cellContext.SetCurrentValue({
    localized: value
});

; title: ; notranslate ]

var value = input.value;

cellContext.SetCurrentValue({

localized: value

});

Final code

(function () { var editWrapper = 'This field is fully controlled by jslink <input type="text" id="{0}" value"{1}"/>'; var createVerySimpleColumnGridEditControl = function (gridContext, gridTextInputElement) { var cellContext, inEdit, html, container, input, id; id = "tolle-" + new Date().getTime(); html = String.format(editWrapper, id, ""); container = document.createElement("div"); container.innerHTML = html; input = container.getElementsByTagName("input")[0]; container.style.cssText = 'visibility:hidden;position:absolute;top:0;left:0;background:#ffffff;'; gridContext.parentNode.appendChild(container); var bindToCell = function(ctx) { cellContext = ctx; //An input is put as an overlay. We have to set the width and height so that it takes the whole cell place container.style.minWidth = cellContext.cellWidth + 'px'; container.style.width = cellContext.cellWidth + 'px'; container.style.height = cellContext.cellHeight + 'px'; console.log("tolle BindToCell"); }; var onCellMove = function () { console.log("tolle OnCellMove"); }; var focus = function(eventInfo) { input.focus(); console.log("tolle Focus", eventInfo); }; var onBeginEdit = function (eventInfo) { inEdit = true; var currentValue = cellContext.originalValue.localized; if (currentValue) { input.value = currentValue; } cellContext.Show(container); console.log("tolle OnBeginEdit"); this.Focus(eventInfo); }; var onEndEdit = function() { cellContext.Hide(container); inEdit = false; var value = input.value; cellContext.SetCurrentValue({ localized: value }); console.log("tolle OnEndEdit"); }; var unbind = function() { console.log("tolle Unbind"); }; var dispose = function () { console.log("tolle Dispose"); } return { SupportedWriteMode: window.SP.JsGrid.EditActorWriteType.LocalizedOnly, SupportedReadMode: window.SP.JsGrid.EditActorReadType.LocalizedOnly, BindToCell: bindToCell, OnCellMove: onCellMove, Focus: focus, OnBeginEdit: onBeginEdit, OnEndEdit: onEndEdit, Unbind: unbind, Dispose: dispose } }; function handleGridMode(ctx, field) { window.SP.SOD.executeOrDelayUntilScriptLoaded(function () { window.SP.GanttControl.WaitForGanttCreation(function (ganttChart) { var verySimpleColumn = null; var editId = "EDIT_TOLLE_VERYSIMPLEFIELD"; var columns = ganttChart.get_Columns(); for (var i = 0; i < columns.length; i++) { if (columns[i].columnKey == "VerySimpleColumn") { verySimpleColumn = columns[i]; break; } } if (verySimpleColumn) { verySimpleColumn.fnGetEditControlName = function (record, fieldKey) { return editId; }; window.SP.JsGrid.PropertyType.Utils.RegisterEditControl(editId, function (gridContext, cellControl) { return createVerySimpleColumnGridEditControl(gridContext, cellControl); }, []); } }); }, "spgantt.js"); } function verySimpleView(ctx, field) { var wrapper = 'This field is fully controlled by jslink<hr>{0}'; var value = ctx.CurrentItem[ctx.CurrentFieldSchema.Name] || ""; if (ctx.inGridMode) { handleGridMode(ctx, field); } return String.format(wrapper, value); } function verySimpleNewAndEdit(ctx) { var id = 'tolle-' + new Date().getTime(); var formCtx = window.SPClientTemplates.Utility.GetFormContextForCurrentField(ctx); formCtx.registerGetValueCallback(formCtx.fieldName, function () { var input = document.getElementById(id); return input.value; }); var value = ctx.CurrentItem[ctx.CurrentFieldSchema.Name] || ""; var html = String.format(editWrapper, id, value); return html; } var overrideContext = {}; overrideContext.Templates = overrideContext.Templates || {}; overrideContext.Templates.Fields = { 'VerySimpleColumn': { 'View': verySimpleView, 'DisplayForm': verySimpleView, 'EditForm': verySimpleNewAndEdit, 'NewForm': verySimpleNewAndEdit } }; window.SPClientTemplates.TemplateManager.RegisterTemplateOverrides(overrideContext); })();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

(function () {
 var editWrapper = 'This field is fully controlled by jslink <input type="text" id="{0}" value"{1}"/>';
 var createVerySimpleColumnGridEditControl = function (gridContext, gridTextInputElement) {
 var cellContext, inEdit, html, container, input, id;
 id = "tolle-" + new Date().getTime();
 html = String.format(editWrapper, id, "");
 container = document.createElement("div");
 container.innerHTML = html;
 input = container.getElementsByTagName("input")[0];
 container.style.cssText = 'visibility:hidden;position:absolute;top:0;left:0;background:#ffffff;';
 gridContext.parentNode.appendChild(container);
 var bindToCell = function(ctx) {
 cellContext = ctx;
 //An input is put as an overlay. We have to set the width and height so that it takes the whole cell place
 container.style.minWidth = cellContext.cellWidth + 'px';
 container.style.width = cellContext.cellWidth + 'px';
 container.style.height = cellContext.cellHeight + 'px';
 console.log("tolle BindToCell");
 };
 var onCellMove = function () { console.log("tolle OnCellMove"); };
 var focus = function(eventInfo) {
 input.focus();
 console.log("tolle Focus", eventInfo);
 };
 var onBeginEdit = function (eventInfo) {
 inEdit = true;
 var currentValue = cellContext.originalValue.localized;
 if (currentValue) {
 input.value = currentValue;
 }
 cellContext.Show(container);
 console.log("tolle OnBeginEdit");
 this.Focus(eventInfo);
 };
 var onEndEdit = function() {
 cellContext.Hide(container);
 inEdit = false;
 var value = input.value;
 cellContext.SetCurrentValue({
 localized: value
 });
 console.log("tolle OnEndEdit");
 };

 var unbind = function() { console.log("tolle Unbind"); };
 var dispose = function () { console.log("tolle Dispose"); }

 return {
 SupportedWriteMode: window.SP.JsGrid.EditActorWriteType.LocalizedOnly,
 SupportedReadMode: window.SP.JsGrid.EditActorReadType.LocalizedOnly,
 BindToCell: bindToCell,
 OnCellMove: onCellMove,
 Focus: focus,
 OnBeginEdit: onBeginEdit,
 OnEndEdit: onEndEdit,
 Unbind: unbind,
 Dispose: dispose
 }
 };

 function handleGridMode(ctx, field) {
 window.SP.SOD.executeOrDelayUntilScriptLoaded(function () {
 window.SP.GanttControl.WaitForGanttCreation(function (ganttChart) {
 var verySimpleColumn = null;
 var editId = "EDIT_TOLLE_VERYSIMPLEFIELD";
 var columns = ganttChart.get_Columns();

 for (var i = 0; i < columns.length; i++) {
 if (columns[i].columnKey == "VerySimpleColumn") {
 verySimpleColumn = columns[i];
 break;
 }
 }
 if (verySimpleColumn) {
 verySimpleColumn.fnGetEditControlName = function (record, fieldKey) {
 return editId;
 };

 window.SP.JsGrid.PropertyType.Utils.RegisterEditControl(editId, function (gridContext, cellControl) {
 return createVerySimpleColumnGridEditControl(gridContext, cellControl);
 }, []);
 }

 });
 }, "spgantt.js");
 }

 function verySimpleView(ctx, field) {
 var wrapper = 'This field is fully controlled by jslink<hr>{0}';
 var value = ctx.CurrentItem[ctx.CurrentFieldSchema.Name] || "";
 if (ctx.inGridMode) {
 handleGridMode(ctx, field);
 }
 return String.format(wrapper, value);
 }

 function verySimpleNewAndEdit(ctx) {
 var id = 'tolle-' + new Date().getTime();
 var formCtx = window.SPClientTemplates.Utility.GetFormContextForCurrentField(ctx);

 formCtx.registerGetValueCallback(formCtx.fieldName, function () {
 var input = document.getElementById(id);
 return input.value;
 });
 var value = ctx.CurrentItem[ctx.CurrentFieldSchema.Name] || "";
 var html = String.format(editWrapper, id, value);
 return html;
 }
 var overrideContext = {};

 overrideContext.Templates = overrideContext.Templates || {};
 overrideContext.Templates.Fields = {
 'VerySimpleColumn': {
 'View': verySimpleView,
 'DisplayForm': verySimpleView,
 'EditForm': verySimpleNewAndEdit,
 'NewForm': verySimpleNewAndEdit
 }
 };

 window.SPClientTemplates.TemplateManager.RegisterTemplateOverrides(overrideContext);
})();

Summary

Well, jsgrid is quite complicated. I have tried to keep it as simple and minimalistic as possible. When we can these basics, we can move on and master advanced examples where we can deliver high value to business that loves Quick Edit :)

Sources

Source code of /_layouts/15/jsgrid.debug.js
Anton Avishnyakov‘s blog, spdevlab.com
- Custom Field Type for SharePoint 2013 – Custom “Quick Edit” mode rendering, Visa field example.
- Source code for custom fields for SharePoint 2013, including the support for Quick Edit (codeplex)
Andrey Markeev‘s blog posts
- Master-detail with JSGrid. An extremely advanced but pedagogically explained article with source code (Code Project)
- A whole series about JSGrid (in Russian, awesome content)

Interesting, Anton, Andrey and me are born in Sovyet and are interested in JSGrid. Coincidence? :)

Kategoriarkiv: basics

JSGrid Basics

A word of caution before we start

Set up a site column with a custom jslink

Writing jslink

JSGrid. First Step: Disable the field in Quick Edit

Wiring up a jsgrid EditControl

Implementing the actual editing

Some notes on the Edit Control and Events

Summary

Sources