or
<
telerik:GridTemplateColumn
HeaderText
=
"Program Id"
AllowFiltering
=
"true"
Reorderable
=
"true"
SortExpression
=
"Program_Id"
UniqueName
=
"Program_Id"
DataField
=
"Program_Id"
>
<
ItemTemplate
>
<
asp:Label
ID
=
"lblProgrammeId"
runat
=
"server"
Text='<%# Eval("Program_Id") %>' />
</
ItemTemplate
>
<
EditItemTemplate
>
<
telerik:RadTextBox
ID
=
"txbProgrammeId"
Width
=
"50px"
runat
=
"server"
TextMode
=
"SingleLine"
Text='<%# Bind("Program_Id") %>' />
<
telerik:RadButton
ID
=
"ValidateProgBtn"
AutoPostBack
=
"true"
runat
=
"server"
Width
=
"16px"
Height
=
"16px"
CommandName
=
"ValidateProgId"
ToolTip
=
"Validate the programme id"
Text
=
"Cancel"
>
<
Image
ImageUrl
=
"Images/1305817624_clean.png"
/>
</
telerik:RadButton
>
<%--OnClientClicked="ClearFields" OnClientClicking="OnClientButtonClickingHandler"--%>
<
telerik:RadButton
ID
=
"RadButton1"
AutoPostBack
=
"true"
Value
=
"NoPostBack"
runat
=
"server"
Width
=
"16px"
Height
=
"16px"
CommandName
=
"Clear All"
ToolTip
=
"Clear the fields"
Text
=
"Clear"
>
<
Image
ImageUrl
=
"Images/1305817654_edit-clear.png"
/>
</
telerik:RadButton
>
<
asp:Label
ID
=
"IsNewProgLbl"
runat
=
"server"
style
=
"width:auto; color:Orange"
Text
=
""
></
asp:Label
>
</
EditItemTemplate
>
<
ItemStyle
VerticalAlign
=
"Top"
/>
</
telerik:GridTemplateColumn
>
......
if (e.CommandName == "Clear All")
{
(e.Item.FindControl("txbProgrammeId") as RadTextBox).Text = "";
(e.Item.FindControl("txbProgrammeId") as RadTextBox).ReadOnly = false;
...........
e.Item.Edit = true;
GridEditableItem editedItem = e.Item as GridEditableItem;
function RequiredOnLoadHandler(sender) {
if (sender.isEmpty()) {
$(sender._textBoxElement).addClass("requiredEmpty");
}
}
<
Menu
Skin
=
"Outlook"
>
<
Item
Text
=
"Parent"
LeftLogo
=
"Img\parent.gif"
>
<
Group
Width
=
"140"
Flow
=
"Vertical"
>
<
Item
Text
=
"Child 1"
/>
<
Item
IsSeparator
=
"True"
/>
<
Item
Text
=
"Child 2"
/>
</
Group
>
</
Item
>
</
Menu
>
<
Tree
>
<
Node
Text
=
"North America"
Expanded
=
"True"
Value
=
"1"
>
<
Node
>
<
Node
>
</
Node
>
</
Node
>
</
Node
>
</
Tree
>
function
OnClientClose(oWnd, args) {
//get the transferred arguments
var
arg = args.get_argument();
if
(arg) {
var
clientId = arg.ClientId;
var
txtClientId = $find(
"<%= txtNewlclient.ClientID %>"
);
txtClientId.set_value(clientId.toString());
}
}
function
showClientSearch() {
window.radopen(
"../../Sections/Clients/ClientSearch.aspx"
,
"rwindClientSearch"
);
}
<
telerik:RadWindowManager
ID
=
"rwindMgr"
runat
=
"server"
>
<
Windows
>
<
telerik:RadWindow
ID
=
"rwindClientSearch"
Title
=
"Client Search"
runat
=
"server"
Width
=
"350px"
Height
=
"300px"
OnClientClose
=
"OnClientClose"
ReloadOnShow
=
"true"
ShowContentDuringLoad
=
"false"
>
</
telerik:RadWindow
>
</
Windows
>
</
telerik:RadWindowManager
>
using
System;
using
System.Collections.Generic;
using
System.Linq;
using
System.Web;
using
Telerik.Web.UI.Widgets;
using
System.Drawing.Imaging;
using
System.Collections;
using
System.IO;
using
System.Drawing;
using
Telerik.Web.UI;
using
ICON.Management.Framework.LinqContexts;
using
Icon.Common.Data;
using
System.Text;
namespace
ICON.Management.Framework.MediaLibrary
{
public
class
IconFileBrowserContentProvider : FileBrowserContentProvider
{
#region DirectoryLister
private
class
DirectoryLister
{
public
DirectoryLister(IconFileBrowserContentProvider contentProvider,
bool
includeFiles,
bool
includeDirectories)
{
_contentProvider = contentProvider;
_includeFiles = includeFiles;
_includeDirectories = includeDirectories;
}
protected
bool
IsParentOf(
string
virtualParent,
string
virtualChild)
{
return
_contentProvider.IsParentOf(virtualParent, virtualChild);
}
protected
FileItem[] GetFiles(DirectoryInfo directory, PathPermissions permissions,
string
location)
{
ArrayList files =
new
ArrayList();
Hashtable fileNames =
new
Hashtable();
foreach
(
string
searchPattern
in
_contentProvider.SearchPatterns)
{
FileInfo[] fs = directory.GetFiles(searchPattern);
for
(
int
i = 0; i < fs.Length; i++)
{
FileInfo file = fs[i];
if
(!fileNames.ContainsKey(file.FullName) && _contentProvider.IsValid(file))
{
fileNames.Add(file.FullName,
string
.Empty);
//In list mode we need the tag because with the different folder structure
// we are unable to build proper urls for the files
string
tag = IsListMode ? location + file.Name :
string
.Empty;
files.Add(
new
FileItem(file.Name, file.Extension, file.Length,
string
.Empty,
string
.Empty, tag, permissions));
}
}
}
return
(FileItem[])files.ToArray(
typeof
(FileItem));
}
protected
DirectoryItem[] GetDirectories(DirectoryInfo directory,
string
parentPath)
{
DirectoryInfo[] dirs = directory.GetDirectories();
ArrayList directories =
new
ArrayList();
for
(
int
i = 0; i < dirs.Length; i++)
{
DirectoryInfo dir = dirs[i];
if
(_contentProvider.IsValid(dir))
{
directories.Add(GetDirectory(dir, VirtualPathUtility.AppendTrailingSlash(parentPath) + dir.Name));
}
}
return
(DirectoryItem[])directories.ToArray(
typeof
(DirectoryItem));
}
public
DirectoryItem GetDirectory(DirectoryInfo dir,
string
virtualName,
string
location,
string
fullPath,
string
tag)
{
PathPermissions permissions = _contentProvider.GetPermissions(fullPath);
bool
includeDirectories = IsListMode ? IncludeDirectories : IsParentOf(fullPath, SelectedUrl);
bool
includeFiles = IsParentOf(fullPath, SelectedUrl);
DirectoryItem[] subdirectories = IncludeDirectories ? GetDirectories(dir, fullPath) :
new
DirectoryItem[] { };
FileItem[] files = IncludeFiles ? GetFiles(dir, permissions, fullPath +
"\\"
) :
new
FileItem[] { };
DirectoryItem item =
new
DirectoryItem(virtualName, location, fullPath, tag, permissions, files, subdirectories);
item.Attributes.Add(
"Date Created"
, DateTime.Now.ToString());
return
item;
}
public
DirectoryItem GetDirectory(DirectoryInfo dir,
string
fullPath)
{
string
tag = IsListMode ? fullPath :
string
.Empty;
return
GetDirectory(dir, dir.Name,
string
.Empty, fullPath, tag);
}
protected
bool
IsListMode
{
get
{
return
false
;
}
}
protected
string
SelectedUrl
{
get
{
return
_contentProvider.SelectedUrl;
}
}
protected
bool
IncludeFiles
{
get
{
return
_includeFiles;
}
}
protected
bool
IncludeDirectories
{
get
{
return
_includeDirectories;
}
}
private
IconFileBrowserContentProvider _contentProvider;
private
bool
_includeFiles;
private
bool
_includeDirectories;
}
#endregion
#region DirectoryFlattener
private
class
DirectoryFlattener
{
private
ArrayList _directories =
new
ArrayList();
public
DirectoryFlattener(DirectoryItem item)
{
if
(item ==
null
)
{
return
;
}
Flatten(item);
_directories.Add(item);
}
private
void
Flatten(DirectoryItem item)
{
foreach
(DirectoryItem subdirectory
in
item.Directories)
{
Flatten(subdirectory);
}
_directories.AddRange(item.Directories);
item.ClearDirectories();
}
public
DirectoryItem[] Directories
{
get
{
return
(DirectoryItem[])_directories.ToArray(
typeof
(DirectoryItem));
}
}
}
#endregion
public
IconFileBrowserContentProvider(HttpContext context,
string
[] searchPatterns,
string
[] viewPaths,
string
[] uploadPaths,
string
[] deletePaths,
string
selectedUrl,
string
selectedItemTag)
:
base
(context, searchPatterns, viewPaths, uploadPaths, deletePaths, selectedUrl, selectedItemTag)
{
ProcessPaths(ViewPaths);
ProcessPaths(UploadPaths);
ProcessPaths(DeletePaths);
SelectedUrl = RemoveProtocolNameAndServerName(GetAbsolutePath(SelectedUrl));
}
protected
virtual
bool
IsValid(FileInfo file)
{
return
true
;
}
protected
virtual
bool
IsValid(DirectoryInfo directory)
{
return
true
;
}
public
override
DirectoryItem ResolveRootDirectoryAsTree(
string
path)
{
string
physicalPath = path;
DirectoryInfo info =
new
DirectoryInfo(path);
if
(!info.Exists)
{
return
null
;
}
string
virtualName = info.Name;
if
(UploadPaths.Contains(path)
|| ViewPaths.Contains(path)
|| DeletePaths.Contains(path))
{
using
(IconStorageCentralContext context = DbUtils.IconStorageCentralDataContext)
{
virtualName = (from libraries
in
context.Libraries
where libraries.Id ==
int
.Parse(info.Name)
select libraries.Name).Single();
}
}
string
virtualParentPath = info.Parent.FullName;
DirectoryLister directoryLister =
new
DirectoryLister(
this
,
false
,
true
);
return
directoryLister.GetDirectory(info, virtualName, virtualParentPath, path,
string
.Empty);
}
public
override
DirectoryItem ResolveDirectory(
string
path)
{
string
physicalPath = path;
DirectoryInfo dir =
new
DirectoryInfo(physicalPath);
if
(!dir.Exists)
{
return
null
;
}
DirectoryLister directoryLister =
new
DirectoryLister(
this
,
true
,
false
);
return
directoryLister.GetDirectory(dir, path);
}
public
override
bool
CanCreateDirectory
{
get
{
return
true
;
}
}
public
override
string
GetFileName(
string
url)
{
return
Path.GetFileName(RemoveProtocolNameAndServerName(GetAbsolutePath(url)));
}
public
override
string
GetPath(
string
url)
{
string
virtualPath = RemoveProtocolNameAndServerName(GetAbsolutePath(url));
return
virtualPath;
}
public
override
Stream GetFile(
string
url)
{
string
physicalPath = url;
if
(!System.IO.File.Exists(physicalPath))
{
return
null
;
}
return
System.IO.File.OpenRead(physicalPath);
}
public
override
string
StoreBitmap(Bitmap bitmap,
string
url, ImageFormat format)
{
bitmap.Save(url, format);
return
url;
}
public
override
string
StoreFile(UploadedFile file,
string
path,
string
name,
params
string
[] arguments)
{
string
targetFullPath = Path.Combine(path, name);
if
(System.IO.File.Exists(targetFullPath))
{
System.IO.File.Delete(targetFullPath);
}
//normalize slashes
file.SaveAs(targetFullPath);
return
targetFullPath;
}
public
override
string
DeleteFile(
string
path)
{
string
physicalPath = path;
try
{
if
(System.IO.File.Exists(physicalPath))
{
if
((System.IO.File.GetAttributes(physicalPath) & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
{
return
"FileReadOnly"
;
}
System.IO.File.Delete(physicalPath);
}
}
catch
(UnauthorizedAccessException)
{
return
"NoPermissionsToDeleteFile"
;
}
return
string
.Empty;
}
public
override
string
DeleteDirectory(
string
path)
{
string
physicalPath = path;
try
{
if
(Directory.Exists(physicalPath))
{
Directory.Delete(physicalPath,
true
);
}
}
catch
(UnauthorizedAccessException)
{
return
"NoPermissionsToDeleteFolder"
;
}
return
string
.Empty;
}
public
override
string
CreateDirectory(
string
path,
string
name)
{
if
(name.IndexOfAny(Path.GetInvalidPathChars()) >= 0)
{
return
"InvalidCharactersInPath"
;
}
string
newFolderPath = (path + name);
if
(Directory.Exists(newFolderPath))
{
return
"DirectoryAlreadyExists"
;
}
try
{
Directory.CreateDirectory(newFolderPath);
}
catch
(UnauthorizedAccessException)
{
return
"NoPermissionsToCreateFolder"
;
}
catch
(Exception e)
{
return
e.Message;
}
return
string
.Empty;
}
public
override
string
MoveDirectory(
string
path,
string
newPath)
{
string
oldPhysicalPath = path;
string
newPhysicalPath = newPath;
try
{
Directory.Move(oldPhysicalPath, newPhysicalPath);
}
catch
(Exception e)
{
return
e.Message;
}
return
string
.Empty;
}
public
override
string
MoveFile(
string
path,
string
newPath)
{
string
oldPhysicalPath = path;
string
newPhysicalPath = newPath;
if
(!System.IO.File.Exists(oldPhysicalPath))
return
"FileNotFound"
;
if
(System.IO.File.Exists(newPhysicalPath))
return
"NewFileAlreadyExists"
;
try
{
System.IO.File.Move(oldPhysicalPath, newPhysicalPath);
}
catch
(UnauthorizedAccessException)
{
return
"NoPermissionsToMoveFile"
;
}
return
string
.Empty;
}
public
void
ProcessPaths(
string
[] paths)
{
for
(
int
i=0; i < paths.Length; i++)
{
paths[i] = GetAbsolutePath(paths[i]);
}
}
protected
string
GetAbsolutePath(
string
path)
{
if
(path.StartsWith(
"~"
))
{
path = VirtualPathUtility.AppendTrailingSlash(VirtualPathUtility.AppendTrailingSlash(Context.Request.ApplicationPath) + path.Substring(2));
return
path.Substring(0, path.Length - 1);
}
return
path;
}
protected
bool
IsParentOf(
string
virtualParent,
string
virtualChild)
{
//original function did not cover all cases - e.g. parent="/test" and child="/testing" should return false
if
(virtualChild.ToLower().StartsWith(virtualParent.ToLower()))
{
if
(virtualParent.Length == virtualChild.Length)
{
return
true
;
}
else
{
//if the parent ends with slash, or the child has a slash after the parent part
//we should be OK
int
len = virtualParent.Length;
if
(virtualChild[len] ==
'/'
|| virtualChild[len] ==
'\\'
||
virtualChild[len - 1] ==
'/'
|| virtualChild[len - 1] ==
'\\'
)
return
true
;
}
}
return
false
;
}
protected
PathPermissions GetPermissions(
string
path)
{
PathPermissions permissions = PathPermissions.Read;
if
(CanUpload(path))
permissions |= PathPermissions.Upload;
if
(CanDelete(path))
permissions |= PathPermissions.Delete;
return
permissions;
}
protected
bool
CanUpload(
string
path)
{
foreach
(
string
uploadPath
in
UploadPaths)
{
if
(IsParentOf(uploadPath, path))
{
return
true
;
}
}
return
false
;
}
protected
bool
CanDelete(
string
path)
{
foreach
(
string
deletePath
in
DeletePaths)
{
if
(IsParentOf(deletePath, path))
{
return
true
;
}
}
return
false
;
}
}
}
public
static
IQueryable<vw_TrainingCompanyLocations> GetTrainingCompanyLocations(
string
filterExpression,
string
sortExpression,
int
maximumRows,
int
startRowIndex)
{
KolipeEntities db =
new
KolipeEntities();
IQueryable<vw_TrainingCompanyLocations> data;
if
(!
string
.IsNullOrEmpty(filterExpression))
data = db.vw_TrainingCompanyLocations.Where(filterExpression);
else
data = db.vw_TrainingCompanyLocations;
return
data;
}
Do you have any idea how to get this to work?
MsgBox(
"Information has been updated. "
, MsgBoxStyle.Information,
"Information Update"
)