Dll: CustomizeFolder
Publicado: 06 May 2011 14:50
Hola amigos de AMSSpecialist.info, quiero presentaros otra DLL mas que he creado es una dll muy simple y limitada pero bueno es lo que diríamos practicas con Visual Studio. Como el nombre bien describe esta DLL es para personalizar los directorios con iconos tooltips y demás tonterías que windows nos permite, he añadido 4 funciones para poder crear, comprobar, etc... mas adelante la mejorare por ahora me contento con esto jejeje... si detectarais algún error decírmelo gracias!!
Funciones:
CreateIconedFolder(folderName, iconFile, iconIndex, toolTip, preventSharing, confirmDelete)
UndoIconedFolder(folderName)
IsIconedFolder(folderName)
GetIconedFolderInfo(folderName)
para poder leer contenidos de archivos INI he tenido que añadir
una plantilla que encontré en The Code Project, A Complete Win32 INI File Utility Class.
Codigo C#:
UnmanagedExports.cs
IniFile.cs
Ejemplos Lua:
Descarga:
Funciones:
CreateIconedFolder(folderName, iconFile, iconIndex, toolTip, preventSharing, confirmDelete)
UndoIconedFolder(folderName)
IsIconedFolder(folderName)
GetIconedFolderInfo(folderName)
para poder leer contenidos de archivos INI he tenido que añadir
una plantilla que encontré en The Code Project, A Complete Win32 INI File Utility Class.
Codigo C#:
UnmanagedExports.cs
using System;
using System.Collections.Generic;
using System.Text;
using RGiesecke.DllExport;
using System.IO;
using IniUtilities;
namespace CustomizeFolder
{
internal static class UnmanagedExports
{
[DllExport("CreateIconedFolder", CallingConvention = System.Runtime.InteropServices.CallingConvention.StdCall)]
static bool CreateIconedFolder(string folderName, string iconFile, int iconIndex, string toolTip, int preventSharing, int confirmDelete)
{
#region Private Variables
DirectoryInfo folder;
string fileName = "desktop.ini";
#endregion Private Variables
#region Data Validation
if (Directory.Exists(folderName) == false)
{
return false;
}
#endregion Data Validation
#region Create Iconed Folder
try
{
folder = new DirectoryInfo(folderName);
fileName = Path.Combine(folderName, fileName);
using (StreamWriter sw = new StreamWriter(fileName))
{
sw.WriteLine("[.ShellClassInfo]");
{
if (confirmDelete == 0)
sw.WriteLine("ConfirmFileOp={0}", false);
else if (confirmDelete == 1)
sw.WriteLine("ConfirmFileOp={0}", true);
}
{
if (preventSharing == 0)
sw.WriteLine("NoSharing={0}", false);
else if (preventSharing == 1)
sw.WriteLine("NoSharing={0}", true);
}
sw.WriteLine("IconFile={0}", iconFile);
sw.WriteLine("IconIndex={0}", iconIndex);
sw.WriteLine("InfoTip={0}", toolTip);
sw.Close();
}
folder.Attributes = folder.Attributes | FileAttributes.System;
File.SetAttributes(fileName, File.GetAttributes(fileName) | FileAttributes.Hidden);
}
catch
{
return false;
}
return true;
#endregion Create Iconed Folder
}
[DllExport("UndoIconedFolder", CallingConvention = System.Runtime.InteropServices.CallingConvention.StdCall)]
static bool UndoIconedFolder(string folderName)
{
#region Private Variables
DirectoryInfo folder;
#endregion Private Variables
#region Data Validation
if (Directory.Exists(folderName) == false)
{
return false;
}
#endregion Data Validation
#region File Validation and Undo Iconed Folder
if (File.Exists(folderName + "\\desktop.ini") == false)
{
return false;
}
else
{
try
{
folder = new DirectoryInfo(folderName);
FileInfo file = new FileInfo(Path.Combine(folderName, "desktop.ini"));
if (file.Exists)
{
file.Delete();
}
folder.Attributes = (folder.Attributes | FileAttributes.System);
}
catch
{
return false;
}
return true;
}
#endregion File Validation and Undo Iconed Folder
}
[DllExport("IsIconedFolder", CallingConvention = System.Runtime.InteropServices.CallingConvention.StdCall)]
static bool IsIconedFolder(string folderName)
{
#region Private Variables
DirectoryInfo folder;
#endregion Private Variables
#region Data Validation
if (Directory.Exists(folderName) == false)
{
return false;
}
#endregion Data Validation
#region File Validation
if (File.Exists(folderName + "\\desktop.ini") == false)
{
return false;
}
else
{
return true;
}
#endregion File Validation
}
[DllExport("GetIconedFolderInfo", CallingConvention = System.Runtime.InteropServices.CallingConvention.StdCall)]
static string GetIconedFolderInfo(string folderName)
{
#region Private Variables
DirectoryInfo folder;
#endregion Private Variables
#region Folder/File Validation and Ini Return
if (Directory.Exists(folderName) == false)
{
return "Folder not exist.";
}
else
{
if (File.Exists(folderName + "\\desktop.ini") == false)
{
return "File not exist.";
}
else
{
string returnvalue;
IniFile iniFile = new IniFile(folderName + "\\desktop.ini");
string IconResource = iniFile.GetString(".ShellClassInfo", "IconResource", "");
string LocalizedResourceName = iniFile.GetString(".ShellClassInfo", "LocalizedResourceName", "");
string IconFile = iniFile.GetString(".ShellClassInfo", "IconFile", "");
string IconIndex = iniFile.GetString(".ShellClassInfo", "IconIndex", "");
string InfoTip = iniFile.GetString(".ShellClassInfo", "InfoTip", "");
string ConfirmFileOp = iniFile.GetString(".ShellClassInfo", "ConfirmFileOp", "");
string NoSharing = iniFile.GetString(".ShellClassInfo", "NoSharing", "");
if (IconResource == "") { returnvalue = "nil|"; }
else { returnvalue = IconResource + "|"; }
if (LocalizedResourceName == "") { returnvalue = returnvalue + "nil|"; }
else { returnvalue = returnvalue + LocalizedResourceName + "|"; }
if (IconFile == "") { returnvalue = returnvalue + "nil|"; }
else { returnvalue = returnvalue + IconFile + "|"; }
if (IconIndex == "") { returnvalue = returnvalue + "nil|"; }
else { returnvalue = returnvalue + IconIndex + "|"; }
if (InfoTip == "") { returnvalue = returnvalue + "nil|"; }
else { returnvalue = returnvalue + InfoTip + "|"; }
if (ConfirmFileOp == "") { returnvalue = returnvalue + "nil|"; }
else { returnvalue = returnvalue + ConfirmFileOp + "|"; }
if (NoSharing == "") { returnvalue = returnvalue + "nil"; }
else { returnvalue = returnvalue + NoSharing; }
return returnvalue;
}
}
#endregion Folder/File Validation and Ini Return
}
}
}
IniFile.cs
using System;
using System.Text;
using System.Runtime.InteropServices;
using System.Globalization;
using System.Collections.Generic;
namespace IniUtilities
{
/// <summary>
/// Provides methods for reading and writing to an INI file.
/// </summary>
public class IniFile
{
/// <summary>
/// The maximum size of a section in an ini file.
/// </summary>
/// <remarks>
/// This property defines the maximum size of the buffers
/// used to retreive data from an ini file. This value is
/// the maximum allowed by the win32 functions
/// GetPrivateProfileSectionNames() or
/// GetPrivateProfileString().
/// </remarks>
public const int MaxSectionSize = 32767; // 32 KB
//The path of the file we are operating on.
private string m_path;
#region P/Invoke declares
/// <summary>
/// A static class that provides the win32 P/Invoke signatures
/// used by this class.
/// </summary>
/// <remarks>
/// Note: In each of the declarations below, we explicitly set CharSet to
/// Auto. By default in C#, CharSet is set to Ansi, which reduces
/// performance on windows 2000 and above due to needing to convert strings
/// from Unicode (the native format for all .Net strings) to Ansi before
/// marshalling. Using Auto lets the marshaller select the Unicode version of
/// these functions when available.
/// </remarks>
[System.Security.SuppressUnmanagedCodeSecurity]
private static class NativeMethods
{
[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
public static extern int GetPrivateProfileSectionNames(IntPtr lpszReturnBuffer,
uint nSize,
string lpFileName);
[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
public static extern uint GetPrivateProfileString(string lpAppName,
string lpKeyName,
string lpDefault,
StringBuilder lpReturnedString,
int nSize,
string lpFileName);
[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
public static extern uint GetPrivateProfileString(string lpAppName,
string lpKeyName,
string lpDefault,
[In, Out] char[] lpReturnedString,
int nSize,
string lpFileName);
[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
public static extern int GetPrivateProfileString(string lpAppName,
string lpKeyName,
string lpDefault,
IntPtr lpReturnedString,
uint nSize,
string lpFileName);
[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
public static extern int GetPrivateProfileInt(string lpAppName,
string lpKeyName,
int lpDefault,
string lpFileName);
[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
public static extern int GetPrivateProfileSection(string lpAppName,
IntPtr lpReturnedString,
uint nSize,
string lpFileName);
//We explicitly enable the SetLastError attribute here because
// WritePrivateProfileString returns errors via SetLastError.
// Failure to set this can result in errors being lost during
// the marshal back to managed code.
[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
public static extern bool WritePrivateProfileString(string lpAppName,
string lpKeyName,
string lpString,
string lpFileName);
}
#endregion
/// <summary>
/// Initializes a new instance of the <see cref="IniFile"/> class.
/// </summary>
/// <param name="path">The ini file to read and write from.</param>
public IniFile(string path)
{
//Convert to the full path. Because of backward compatibility,
// the win32 functions tend to assume the path should be the
// root Windows directory if it is not specified. By calling
// GetFullPath, we make sure we are always passing the full path
// the win32 functions.
m_path = System.IO.Path.GetFullPath(path);
}
/// <summary>
/// Gets the full path of ini file this object instance is operating on.
/// </summary>
/// <value>A file path.</value>
public string Path
{
get
{
return m_path;
}
}
#region Get Value Methods
/// <summary>
/// Gets the value of a setting in an ini file as a <see cref="T:System.String"/>.
/// </summary>
/// <param name="sectionName">The name of the section to read from.</param>
/// <param name="keyName">The name of the key in section to read.</param>
/// <param name="defaultValue">The default value to return if the key
/// cannot be found.</param>
/// <returns>The value of the key, if found. Otherwise, returns
/// <paramref name="defaultValue"/></returns>
/// <remarks>
/// The retreived value must be less than 32KB in length.
/// </remarks>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> or <paramref name="keyName"/> are
/// a null reference (Nothing in VB)
/// </exception>
public string GetString(string sectionName,
string keyName,
string defaultValue)
{
if (sectionName == null)
throw new ArgumentNullException("sectionName");
if (keyName == null)
throw new ArgumentNullException("keyName");
StringBuilder retval = new StringBuilder(IniFile.MaxSectionSize);
NativeMethods.GetPrivateProfileString(sectionName,
keyName,
defaultValue,
retval,
IniFile.MaxSectionSize,
m_path);
return retval.ToString();
}
/// <summary>
/// Gets the value of a setting in an ini file as a <see cref="T:System.Int16"/>.
/// </summary>
/// <param name="sectionName">The name of the section to read from.</param>
/// <param name="keyName">The name of the key in section to read.</param>
/// <param name="defaultValue">The default value to return if the key
/// cannot be found.</param>
/// <returns>The value of the key, if found. Otherwise, returns
/// <paramref name="defaultValue"/>.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> or <paramref name="keyName"/> are
/// a null reference (Nothing in VB)
/// </exception>
public int GetInt16(string sectionName,
string keyName,
short defaultValue)
{
int retval = GetInt32(sectionName, keyName, defaultValue);
return Convert.ToInt16(retval);
}
/// <summary>
/// Gets the value of a setting in an ini file as a <see cref="T:System.Int32"/>.
/// </summary>
/// <param name="sectionName">The name of the section to read from.</param>
/// <param name="keyName">The name of the key in section to read.</param>
/// <param name="defaultValue">The default value to return if the key
/// cannot be found.</param>
/// <returns>The value of the key, if found. Otherwise, returns
/// <paramref name="defaultValue"/></returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> or <paramref name="keyName"/> are
/// a null reference (Nothing in VB)
/// </exception>
public int GetInt32(string sectionName,
string keyName,
int defaultValue)
{
if (sectionName == null)
throw new ArgumentNullException("sectionName");
if (keyName == null)
throw new ArgumentNullException("keyName");
return NativeMethods.GetPrivateProfileInt(sectionName, keyName, defaultValue, m_path);
}
/// <summary>
/// Gets the value of a setting in an ini file as a <see cref="T:System.Double"/>.
/// </summary>
/// <param name="sectionName">The name of the section to read from.</param>
/// <param name="keyName">The name of the key in section to read.</param>
/// <param name="defaultValue">The default value to return if the key
/// cannot be found.</param>
/// <returns>The value of the key, if found. Otherwise, returns
/// <paramref name="defaultValue"/></returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> or <paramref name="keyName"/> are
/// a null reference (Nothing in VB)
/// </exception>
public double GetDouble(string sectionName,
string keyName,
double defaultValue)
{
string retval = GetString(sectionName, keyName, "");
if (retval == null || retval.Length == 0)
{
return defaultValue;
}
return Convert.ToDouble(retval, CultureInfo.InvariantCulture);
}
#endregion
#region GetSectionValues Methods
/// <summary>
/// Gets all of the values in a section as a list.
/// </summary>
/// <param name="sectionName">
/// Name of the section to retrieve values from.
/// </param>
/// <returns>
/// A <see cref="List{T}"/> containing <see cref="KeyValuePair{T1, T2}"/> objects
/// that describe this section. Use this verison if a section may contain
/// multiple items with the same key value. If you know that a section
/// cannot contain multiple values with the same key name or you don't
/// care about the duplicates, use the more convenient
/// <see cref="GetSectionValues"/> function.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> is a null reference (Nothing in VB)
/// </exception>
public List<KeyValuePair<string, string>> GetSectionValuesAsList(string sectionName)
{
List<KeyValuePair<string, string>> retval;
string[] keyValuePairs;
string key, value;
int equalSignPos;
if (sectionName == null)
throw new ArgumentNullException("sectionName");
//Allocate a buffer for the returned section names.
IntPtr ptr = Marshal.AllocCoTaskMem(IniFile.MaxSectionSize);
try
{
//Get the section key/value pairs into the buffer.
int len = NativeMethods.GetPrivateProfileSection(sectionName,
ptr,
IniFile.MaxSectionSize,
m_path);
keyValuePairs = ConvertNullSeperatedStringToStringArray(ptr, len);
}
finally
{
//Free the buffer
Marshal.FreeCoTaskMem(ptr);
}
//Parse keyValue pairs and add them to the list.
retval = new List<KeyValuePair<string, string>>(keyValuePairs.Length);
for (int i = 0; i < keyValuePairs.Length; ++i)
{
//Parse the "key=value" string into its constituent parts
equalSignPos = keyValuePairs.IndexOf('=');
key = keyValuePairs.Substring(0, equalSignPos);
value = keyValuePairs.Substring(equalSignPos + 1,
keyValuePairs.Length - equalSignPos - 1);
retval.Add( new KeyValuePair<string, string>(key, value) );
}
return retval;
}
/// <summary>
/// Gets all of the values in a section as a dictionary.
/// </summary>
/// <param name="sectionName">
/// Name of the section to retrieve values from.
/// </param>
/// <returns>
/// A <see cref="Dictionary{T, T}"/> containing the key/value
/// pairs found in this section.
/// </returns>
/// <remarks>
/// If a section contains more than one key with the same name,
/// this function only returns the first instance. If you need to
/// get all key/value pairs within a section even when keys have the
/// same name, use <see cref="GetSectionValuesAsList"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> is a null reference (Nothing in VB)
/// </exception>
public Dictionary<string, string> GetSectionValues(string sectionName)
{
List<KeyValuePair<string, string>> keyValuePairs;
Dictionary<string, string> retval;
keyValuePairs = GetSectionValuesAsList(sectionName);
//Convert list into a dictionary.
retval = new Dictionary<string, string>(keyValuePairs.Count);
foreach (KeyValuePair<string, string> keyValuePair in keyValuePairs)
{
//Skip any key we have already seen.
if (!retval.ContainsKey(keyValuePair.Key))
{
retval.Add(keyValuePair.Key, keyValuePair.Value);
}
}
return retval;
}
#endregion
#region Get Key/Section Names
/// <summary>
/// Gets the names of all keys under a specific section in the ini file.
/// </summary>
/// <param name="sectionName">
/// The name of the section to read key names from.
/// </param>
/// <returns>An array of key names.</returns>
/// <remarks>
/// The total length of all key names in the section must be
/// less than 32KB in length.
/// </remarks>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> is a null reference (Nothing in VB)
/// </exception>
public string[] GetKeyNames(string sectionName)
{
int len;
string[] retval;
if (sectionName == null)
throw new ArgumentNullException("sectionName");
//Allocate a buffer for the returned section names.
IntPtr ptr = Marshal.AllocCoTaskMem(IniFile.MaxSectionSize);
try
{
//Get the section names into the buffer.
len = NativeMethods.GetPrivateProfileString(sectionName,
null,
null,
ptr,
IniFile.MaxSectionSize,
m_path);
retval = ConvertNullSeperatedStringToStringArray(ptr, len);
}
finally
{
//Free the buffer
Marshal.FreeCoTaskMem(ptr);
}
return retval;
}
/// <summary>
/// Gets the names of all sections in the ini file.
/// </summary>
/// <returns>An array of section names.</returns>
/// <remarks>
/// The total length of all section names in the section must be
/// less than 32KB in length.
/// </remarks>
public string[] GetSectionNames()
{
string[] retval;
int len;
//Allocate a buffer for the returned section names.
IntPtr ptr = Marshal.AllocCoTaskMem(IniFile.MaxSectionSize);
try
{
//Get the section names into the buffer.
len = NativeMethods.GetPrivateProfileSectionNames(ptr,
IniFile.MaxSectionSize, m_path);
retval = ConvertNullSeperatedStringToStringArray(ptr, len);
}
finally
{
//Free the buffer
Marshal.FreeCoTaskMem(ptr);
}
return retval;
}
/// <summary>
/// Converts the null seperated pointer to a string into a string array.
/// </summary>
/// <param name="ptr">A pointer to string data.</param>
/// <param name="valLength">
/// Length of the data pointed to by <paramref name="ptr"/>.
/// </param>
/// <returns>
/// An array of strings; one for each null found in the array of characters pointed
/// at by <paramref name="ptr"/>.
/// </returns>
private static string[] ConvertNullSeperatedStringToStringArray(IntPtr ptr, int valLength)
{
string[] retval;
if (valLength == 0)
{
//Return an empty array.
retval = new string[0];
}
else
{
//Convert the buffer into a string. Decrease the length
//by 1 so that we remove the second null off the end.
string buff = Marshal.PtrToStringAuto(ptr, valLength - 1);
//Parse the buffer into an array of strings by searching for nulls.
retval = buff.Split('\0');
}
return retval;
}
#endregion
#region Write Methods
/// <summary>
/// Writes a <see cref="T:System.String"/> value to the ini file.
/// </summary>
/// <param name="sectionName">The name of the section to write to .</param>
/// <param name="keyName">The name of the key to write to.</param>
/// <param name="value">The string value to write</param>
/// <exception cref="T:System.ComponentModel.Win32Exception">
/// The write failed.
/// </exception>
private void WriteValueInternal(string sectionName, string keyName, string value)
{
if (!NativeMethods.WritePrivateProfileString(sectionName, keyName, value, m_path))
{
throw new System.ComponentModel.Win32Exception();
}
}
/// <summary>
/// Writes a <see cref="T:System.String"/> value to the ini file.
/// </summary>
/// <param name="sectionName">The name of the section to write to .</param>
/// <param name="keyName">The name of the key to write to.</param>
/// <param name="value">The string value to write</param>
/// <exception cref="T:System.ComponentModel.Win32Exception">
/// The write failed.
/// </exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> or <paramref name="keyName"/> or
/// <paramref name="value"/> are a null reference (Nothing in VB)
/// </exception>
public void WriteValue(string sectionName, string keyName, string value)
{
if (sectionName == null)
throw new ArgumentNullException("sectionName");
if (keyName == null)
throw new ArgumentNullException("keyName");
if (value == null)
throw new ArgumentNullException("value");
WriteValueInternal(sectionName, keyName, value);
}
/// <summary>
/// Writes an <see cref="T:System.Int16"/> value to the ini file.
/// </summary>
/// <param name="sectionName">The name of the section to write to .</param>
/// <param name="keyName">The name of the key to write to.</param>
/// <param name="value">The value to write</param>
/// <exception cref="T:System.ComponentModel.Win32Exception">
/// The write failed.
/// </exception>
public void WriteValue(string sectionName, string keyName, short value)
{
WriteValue(sectionName, keyName, (int)value);
}
/// <summary>
/// Writes an <see cref="T:System.Int32"/> value to the ini file.
/// </summary>
/// <param name="sectionName">The name of the section to write to .</param>
/// <param name="keyName">The name of the key to write to.</param>
/// <param name="value">The value to write</param>
/// <exception cref="T:System.ComponentModel.Win32Exception">
/// The write failed.
/// </exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> or <paramref name="keyName"/> are
/// a null reference (Nothing in VB)
/// </exception>
public void WriteValue(string sectionName, string keyName, int value)
{
WriteValue(sectionName, keyName, value.ToString(CultureInfo.InvariantCulture));
}
/// <summary>
/// Writes an <see cref="T:System.Single"/> value to the ini file.
/// </summary>
/// <param name="sectionName">The name of the section to write to .</param>
/// <param name="keyName">The name of the key to write to.</param>
/// <param name="value">The value to write</param>
/// <exception cref="T:System.ComponentModel.Win32Exception">
/// The write failed.
/// </exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> or <paramref name="keyName"/> are
/// a null reference (Nothing in VB)
/// </exception>
public void WriteValue(string sectionName, string keyName, float value)
{
WriteValue(sectionName, keyName, value.ToString(CultureInfo.InvariantCulture));
}
/// <summary>
/// Writes an <see cref="T:System.Double"/> value to the ini file.
/// </summary>
/// <param name="sectionName">The name of the section to write to .</param>
/// <param name="keyName">The name of the key to write to.</param>
/// <param name="value">The value to write</param>
/// <exception cref="T:System.ComponentModel.Win32Exception">
/// The write failed.
/// </exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> or <paramref name="keyName"/> are
/// a null reference (Nothing in VB)
/// </exception>
public void WriteValue(string sectionName, string keyName, double value)
{
WriteValue(sectionName, keyName, value.ToString(CultureInfo.InvariantCulture));
}
#endregion
#region Delete Methods
/// <summary>
/// Deletes the specified key from the specified section.
/// </summary>
/// <param name="sectionName">
/// Name of the section to remove the key from.
/// </param>
/// <param name="keyName">
/// Name of the key to remove.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> or <paramref name="keyName"/> are
/// a null reference (Nothing in VB)
/// </exception>
public void DeleteKey(string sectionName, string keyName)
{
if (sectionName == null)
throw new ArgumentNullException("sectionName");
if (keyName == null)
throw new ArgumentNullException("keyName");
WriteValueInternal(sectionName, keyName, null);
}
/// <summary>
/// Deletes a section from the ini file.
/// </summary>
/// <param name="sectionName">
/// Name of the section to delete.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> is a null reference (Nothing in VB)
/// </exception>
public void DeleteSection(string sectionName)
{
if (sectionName == null)
throw new ArgumentNullException("sectionName");
WriteValueInternal(sectionName, null, null);
}
#endregion
}
}
Ejemplos Lua:
-----------------------------------
-- GetIconedFolderInfo
-----------------------------------
local FolderPath = Dialog.FolderBrowse("Please select a folder:", "");
if (FolderPath ~= "CANCEL") then
local IconFile = Dialog.FileBrowse(true, "Locate File", "", "ICO Files (*.ico)|*.ico|", "", "ico", false, true);
if (IconFile[1] ~= "CANCEL") then
local IconIndex = 0;
local InfoTip = "Sample tooltip for this folder";
local NoSharing = 0;
local ConfirmFileOp = 0;
local arg = "\""..FolderPath.."\",\""..IconFile[1].."\","..IconIndex..",\""..InfoTip.."\","..NoSharing..","..ConfirmFileOp
local DLLFile = "Autoplay\\Docs\\CustomizeFolder.dll"
local result = DLL.CallFunction(DLLFile, "CreateIconedFolder", arg, DLL_RETURN_TYPE_INTEGER, DLL_CALL_STDCALL);
-- if result 1 file as been build successful, else return 0 file not been build successful.
Dialog.Message("", result);
end
end
-----------------------------------
-- UndoIconedFolder
-----------------------------------
local FolderPath = Shell.GetFolder(SHF_MYMUSIC);
File.Copy(FolderPath.."\\desktop.ini", FolderPath.."\\desktop.bak", true, true, false, true, nil);
local DLLFile = "Autoplay\\Docs\\CustomizeFolder.dll"
local result = DLL.CallFunction(DLLFile, "UndoIconedFolder", "\""..FolderPath.."\"", DLL_RETURN_TYPE_INTEGER, DLL_CALL_STDCALL);
-- if result 1 file as been delete, else if return 0 file not been delete or not exist.
Dialog.Message("", result)
-- this is for restore "desktop.bak" to "desktop.ini"
File.Rename(FolderPath.."\\desktop.bak", FolderPath.."\\desktop.ini");
-----------------------------------
-- IsIconedFolder
-----------------------------------
local FolderPath = Shell.GetFolder(SHF_COMMONFILES); -- return 0 is "desktop.ini" file not exist.
--local FolderPath = Shell.GetFolder(SHF_MYDOCUMENTS); -- return 1 is "desktop.ini" file exist.
local DLLFile = "Autoplay\\Docs\\CustomizeFolder.dll"
local result = DLL.CallFunction(DLLFile, "IsIconedFolder", "\""..FolderPath.."\"", DLL_RETURN_TYPE_INTEGER, DLL_CALL_STDCALL);
Dialog.Message("", result)
-----------------------------------
-- GetIconedFolderInfo
-----------------------------------
local FolderPath = Shell.GetFolder(SHF_MYDOCUMENTS);
local DLLFile = "Autoplay\\Docs\\CustomizeFolder.dll"
local result = DLL.CallFunction(DLLFile, "GetIconedFolderInfo", "\""..FolderPath.."\"", DLL_RETURN_TYPE_STRING, DLL_CALL_STDCALL);
Dialog.Message("", result)
