extern "C" __declspec(dllexport) BSTR _stdcall getIMEI()
{   CString  IMEI;
    WCHAR unicodeStringIMEI[20];
    DWORD dwSize = sizeof(unicodeStringIMEI);
    DWORD dwStrLen = 0;
    IMEI= pDevInfo->getIMEI(unicodeStringIMEI,dwSize, dwStrLen);
    return IMEI.AllocSysString();    
}

extern "C" __declspec(dllexport) BSTR _stdcall getIMSI()
{   CString  IMSI;
    WCHAR unicodeStringIMSI[20];
    DWORD dwSize = sizeof(unicodeStringIMSI);
    DWORD dwStrLen = 0;
    IMSI= pDevInfo->getIMSI(unicodeStringIMSI,dwSize, dwStrLen);
    return IMSI.AllocSysString();    
}

extern "C" __declspec(dllexport) BSTR _stdcall getPhoneNbr()
{ SMS_ADDRESS s;
  SmsGetPhoneNumber (&s);
  CString tempo = (CString)s.ptsAddress;
  return tempo.AllocSysString();    
}

extern "C" __declspec(dllexport) BSTR _stdcall getOEMinfo()
{  CString OEM = "";
    WCHAR wszOemInfo[50];
    UINT cbOemInfo = sizeof(wszOemInfo);

    if (SystemParametersInfoW(SPI_GETOEMINFO, cbOemInfo, wszOemInfo, 0))
       {OEM = (CString)wszOemInfo; }
    else if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
        OEM="Insufficient buffer";     
    else
        OEM ="Some other error.";  
    return OEM.AllocSysString();    
}

static public String getDisplayHorzRes()
        { return Screen.PrimaryScreen.Bounds.Width.ToString(); }

        /*===================**===================*/
        static public String getDisplayVertRes()
        { return Screen.PrimaryScreen.Bounds.Height.ToString();
}
//end

public class SYSTEM_POWER_STATUS_EX
        {
            public byte ACLineStatus;
            public byte BatteryFlag;
            public byte BatteryLifePercent;
            public byte Reserved1;
            public uint BatteryLifeTime;
            public uint BatteryFullLifeTime;
            public byte Reserved2;
            public byte BackupBatteryFlag;
            public byte BackupBatteryLifePercent;
            public byte Reserved3;
            public uint BackupBatteryLifeTime;
            public uint BackupBatteryFullLifeTime;
        }
    //=======

        [DllImport("coredll")]
        public static extern uint GetSystemPowerStatusEx(SYSTEM_POWER_STATUS_EX lpSystemPowerStatus, bool fUpdate);
      
       //======

        static public string getBatterylevel()    
        {   SYSTEM_POWER_STATUS_EX PilDurum = new SYSTEM_POWER_STATUS_EX();
            int BatLev = 0;
            if (GetSystemPowerStatusEx(PilDurum, true) == 1)
            { BatLev = PilDurum.BatteryLifePercent;}
            return BatLev.ToString() + "%";
        }

    //end
    //===

#include <atlstr.h>
#pragma comment(lib , "atlsd.lib")

// ActivSyncMgr.cpp : Defines the entry point for the DLL application.
//

#include "stdafx.h"
#include <windows.h>
#include <commctrl.h>
#include <tlhelp32.h>

#include <atlstr.h>
#include <stdio.h>
#pragma comment(lib,"atlsd.lib")
#pragma comment(lib, "Toolhelp.lib")


BOOL APIENTRY DllMain( HANDLE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{
    return TRUE;
}
//==============

extern "C" __declspec(dllexport) BSTR _stdcall ListProcess()
{    CString Error="";
    // first check the OS we are running on...
    OSVERSIONINFO osinfo;

    // this structure size must be set prior to calling GetVersionEx
    osinfo.dwOSVersionInfoSize=sizeof(OSVERSIONINFO);

    if (!GetVersionEx(&osinfo))
    {    Error = "Unable to get OS version!\n";
        return Error.AllocSysString();            
    }

    // Enumerate the proces list of the system

    // "0" means to createsnapshot in context of our process
    HANDLE hSnapshot=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);

    if (!hSnapshot)
        {  Error = "Unable to create snapshot!";
           return Error.AllocSysString();            
        }

    // prepare to enumerate the processes.
    PROCESSENTRY32 pe;
    ULONG count=0;

    // remember to init the structure...
    pe.dwSize=sizeof(PROCESSENTRY32);
    BOOL retval=Process32First(hSnapshot,&pe);

    CString ProcessList = "";

    while(retval)
    {
        // increment the process count
        count++;

        // display the process name and ID
        printf("[%08X] %c\n",pe.th32ProcessID,pe.szExeFile);
        // Store process name in a CString
        ProcessList += (CString)pe.szExeFile;
        // move to next process
        retval=Process32Next(hSnapshot,&pe);        
    }
    //close the snapshot handle
    CloseHandle(hSnapshot);
    
    
    return ProcessList.AllocSysString();    
    
}

[DllImport("ActivSyncMgr.dll")]
        public static extern IntPtr ListProcess();

IntPtr ptrProcList = ListProcess();
            string strProcList = Marshal.PtrToStringBSTR(ptrProcList);
            Marshal.FreeBSTR(ptrProcList);

int test = strProcList.IndexOf("rapisrv.exe");
            if (test == -1)
                textBox1.Text = "ActiveSync :OFF";
            else
                textBox1.Text = "ActiveSync :ON";

[DllImport("coredll.dll", SetLastError = true)]
        public static extern int SetDevicePower(string pvDevice, int dwDeviceFlags, DevicePowerState DeviceState);
        [DllImport("coredll.dll", SetLastError = true)]
        public static extern int GetDevicePower(string pvDevice, int dwDeviceFlags, ref DevicePowerState DeviceState);
        [DllImport("coredll.dll", SetLastError = true)]
        public static extern int DevicePowerNotify(string device, DevicePowerState state, int flags);

        public enum DevicePowerState : int
        {
            Unspecified = -1,
            D0 = 0, // Full On: full power, full functionality
            D1 = 1, // Low Power On: fully functional at low power/performance
            D2 = 2, // Standby: partially powered with automatic wake
            D3 = 3, // Sleep: partially powered with device initiated wake
            D4 = 4, // Off: unpowered
        }

PowNotif = DevicePowerNotify(deviceName, DevicePowerState.D4, POWER_NAME);
            SetDevPow = SetDevicePower(deviceName, POWER_NAME, DevicePowerState.D0);

PowNotif = DevicePowerNotify(deviceName, DevicePowerState.D0, POWER_NAME);
SetDevPow = SetDevicePower(deviceName, POWER_NAME, DevicePowerState.D4);

public string deviceName = "{98C5250D-C29A-4985-AE5F-AFE5367E5006}\\TIACXWLN1";

#define PMCLASS_GENERIC_DEVICE          TEXT("{A32942B7-920C-486b-B0E6-92A702A99B35}")
#define PMCLASS_NDIS_MINIPORT           TEXT("{98C5250D-C29A-4985-AE5F-AFE5367E5006}")
#define PMCLASS_BLOCK_DEVICE            TEXT("{8DD679CE-8AB4-43c8-A14A-EA4963FAA715}")
#define PMCLASS_DISPLAY                 TEXT("{EB91C7C9-8BF6-4a2d-9AB8-69724EED97D1}")

#include <Pm.h>
  :
  :

#define adapterName L"{98C5250D-C29A-4985-AE5F-AFE5367E5006}\\TIACXWLN1"

void Ccellid01Dlg::OnBnClickedButtonstartwifi()
{
    DevicePowerNotify(adapterName, D0, 1);
    SetDevicePower(adapterName, 1, D0);    
}
void Ccellid01Dlg::OnBnClickedButtonstopwifi()
{
    DevicePowerNotify(adapterName, D4, 1);
    SetDevicePower(adapterName, 1, D4);    
}

         Byte[] buffer = new Byte[516];
         fixed (byte* pAddr = buffer)
         {
            IntPtr res = SmsGetPhoneNumber((IntPtr)pAddr);
            if (res != IntPtr.Zero)
               throw new Exception("Could not get phone number from SIM");
            byte *pCurrent = pAddr;
            phoneaddr.AddressType = (AddressType)Marshal.ReadInt32((IntPtr)pCurrent);
            pCurrent += Marshal.SizeOf(phoneaddr.AddressType);
            phoneaddr.Address = Marshal.PtrToStringUni((IntPtr)pCurrent);
        }

  unsafe public static PhoneAddress GetPhoneNumber()
        {   PhoneAddress phoneaddr = new PhoneAddress();
            Byte[] buffer = new Byte[100];

            fixed (byte* pAddr = buffer)
            {
                IntPtr res = SmsGetPhoneNumber((IntPtr)pAddr);

                if (res != IntPtr.Zero)
                   MessageBox.Show("Getting phone number from SIM failed.");
                byte* pCurrent = pAddr;
                phoneaddr.AddressType = (AddressType)Marshal.ReadInt32((IntPtr)pCurrent);
                pCurrent += Marshal.SizeOf(phoneaddr.AddressType);
                phoneaddr.Address = Marshal.PtrToStringUni((IntPtr)pCurrent);
            }
            return phoneaddr;
        }

[DllImport("sms.dll")]
        public static extern IntPtr SmsGetPhoneNumber(IntPtr psmsaAddress);

public enum AddressType
        {
            Unknown,
            International,
            National,
            NetworkSpecific,
            Subscriber,
            Alphanumeric,
            Abbreviated
        }

    public struct PhoneAddress
        {
            public AddressType AddressType;
            public String Address;
        }

PhoneAddress PhonAdd = GetPhoneNumber(); MessageBox.Show(PhonAdd.Address);

static public Bitmap Copy(Bitmap srcBitmap, Rectangle section)
{
    // Create the new bitmap and associated graphics object
    Bitmap bmp = new Bitmap(section.Width, section.Height);
    Graphics g = Graphics.FromImage(bmp);

    // Draw the specified section of the source bitmap to the new one
    g.DrawImage(srcBitmap, 0, 0, section, GraphicsUnit.Pixel);

    // Clean up
    g.Dispose();

    // Return the bitmap
    return bmp;
}

Overloads Public Shared Function Copy(srcBitmap As Bitmap, _
  section As Rectangle) As Bitmap

    ' Create the new bitmap and associated graphics object
    Dim bmp As New Bitmap(section.Width, section.Height)
    Dim g As Graphics = Graphics.FromImage(bmp)
      
    ' Draw the specified section of the source bitmap to the new one
    g.DrawImage(srcBitmap, 0, 0, section, GraphicsUnit.Pixel)
      
    ' Clean up
    g.Dispose()
      
    ' Return the bitmap
    Return bmp

End Function 'Copy

// C#
public class SYSTEM_POWER_STATUS_EX2
{
    public byte ACLineStatus;
    public byte BatteryFlag;
    public byte BatteryLifePercent;
    public byte Reserved1;
    public uint BatteryLifeTime;
    public uint BatteryFullLifeTime;
    public byte Reserved2;
    public byte BackupBatteryFlag;
    public byte BackupBatteryLifePercent;
    public byte Reserved3;
    public uint BackupBatteryLifeTime;
    public uint BackupBatteryFullLifeTime;
    public uint BatteryVoltage;
    public uint BatteryCurrent;
    public uint BatteryAverageCurrent;
    public uint BatteryAverageInterval;
    public uint BatterymAHourConsumed;
    public uint BatteryTemperature;
    public uint BackupBatteryVoltage;
   public byte BatteryChemistry;
}

public class SYSTEM_POWER_STATUS_EX
{
    public byte ACLineStatus;
    public byte BatteryFlag;
    public byte BatteryLifePercent;
    public byte Reserved1;
    public uint BatteryLifeTime;
    public uint BatteryFullLifeTime;
    public byte Reserved2;
    public byte BackupBatteryFlag;
    public byte BackupBatteryLifePercent;
    public byte Reserved3;
    public uint BackupBatteryLifeTime;
    public uint BackupBatteryFullLifeTime;
}

' VB
Public Class SYSTEM_POWER_STATUS_EX2
    Public ACLineStatus As Byte
    Public BatteryFlag As Byte
    Public BatteryLifePercent As Byte
    Public Reserved1 As Byte
    Public BatteryLifeTime As System.UInt32
    Public BatteryFullLifeTime As System.UInt32
    Public Reserved2 As Byte
    Public BackupBatteryFlag As Byte
    Public BackupBatteryLifePercent As Byte
    Public Reserved3 As Byte
    Public BackupBatteryLifeTime As System.UInt32
    Public BackupBatteryFullLifeTime As System.UInt32
    Public BatteryVoltage As System.UInt32
    Public BatteryCurrent As System.UInt32
    Public BatteryAverageCurrent As System.UInt32
    Public BatteryAverageInterval As System.UInt32
    Public BatterymAHourConsumed As System.UInt32
    Public BatteryTemperature As System.UInt32
    Public BackupBatteryVoltage As System.UInt32
    Public BatteryChemistry As Byte
End Class 'SYSTEM_POWER_STATUS_EX2

Public Class SYSTEM_POWER_STATUS_EX
    Public ACLineStatus As Byte
    Public BatteryFlag As Byte
    Public BatteryLifePercent As Byte
    Public Reserved1 As Byte
    Public BatteryLifeTime As System.UInt32
    Public BatteryFullLifeTime As System.UInt32
    Public Reserved2 As Byte
    Public BackupBatteryFlag As Byte
    Public BackupBatteryLifePercent As Byte
    Public Reserved3 As Byte
    Public BackupBatteryLifeTime As System.UInt32
    Public BackupBatteryFullLifeTime As System.UInt32
End Class 'SYSTEM_POWER_STATUS_EX

//C#
[DllImport("coredll")]
private static extern uint GetSystemPowerStatusEx(SYSTEM_POWER_STATUS_EX lpSystemPowerStatus,
    bool fUpdate);

[DllImport("coredll")]
private static extern uint GetSystemPowerStatusEx2(SYSTEM_POWER_STATUS_EX2 lpSystemPowerStatus,
    uint dwLen, bool fUpdate);

'VB
<DllImport("coredll")> _
Private Shared Function GetSystemPowerStatusEx( _
  ByVal lpSystemPowerStatus As SYSTEM_POWER_STATUS_EX, _
  ByVal fUpdate As Boolean) As System.UInt32
End Function


<DllImport("coredll")> _
Private Shared Function GetSystemPowerStatusEx2(ByVal _
  lpSystemPowerStatus As SYSTEM_POWER_STATUS_EX2, _
  ByVal dwLen As System.UInt32, ByVal fUpdate As Boolean) _
  As System.UInt32
End Function

//C#
SYSTEM_POWER_STATUS_EX status = new SYSTEM_POWER_STATUS_EX();
SYSTEM_POWER_STATUS_EX2 status2 = new SYSTEM_POWER_STATUS_EX2();

if (GetSystemPowerStatusEx(status, false) == 1)
{
    this.label_main.Text = String.Format("{0}%",
        status.BatteryLifePercent);
}

if (GetSystemPowerStatusEx2(status2,
    (uint)Marshal.SizeOf(status2), false) ==
    (uint)Marshal.SizeOf(status2))
{
    this.label_backup.Text = String.Format("{0}%",
        status2.BackupBatteryLifePercent);
}

'VB
Private Sub Form1_Load(ByVal sender As Object, _
    ByVal e As System.EventArgs) Handles MyBase.Load
    
    Dim status As New SYSTEM_POWER_STATUS_EX
    Dim status2 As New SYSTEM_POWER_STATUS_EX2

    If Convert.ToInt32(GetSystemPowerStatusEx(status, False)) = 1 Then
        Me.label_main.Text = String.Format("{0}%", _
            status.BatteryLifePercent)
    End If

    If Convert.ToInt32(GetSystemPowerStatusEx2(status2, _
        Convert.ToUInt32(Marshal.SizeOf(status2)), False)) = _
        Marshal.SizeOf(status2) Then
        
        Me.label_backup.Text = String.Format("{0}%",
            status2.BackupBatteryLifePercent)
    End If
End Sub 'Form1_Load

using Microsoft.WindowsMobile.Forms;

CameraCaptureDialog myCapture = new CameraCaptureDialog();
            myCapture.Mode = CameraCaptureMode.Still;
            myCapture.Resolution = new Size(160, 160);
            myCapture.StillQuality = CameraCaptureStillQuality.High;
            myCapture.ShowDialog();
            string strFileName = "";
            strFileName = myCapture.FileName;
            pictureBox1.Image = new Bitmap(strFileName);

            // Line Init
            [DllImport("coredll")]
            public static extern int lineInitializeEx(out IntPtr lpm_hLineApp,
                                                      IntPtr hInstance,
                                                      IntPtr lpfnCallback,
                                                      string lpszFriendlyAppName,
                                                      out int lpdwNumDevs,
                                                      ref int lpdwAPIVersion,
                                                      ref LINEINITIALIZEEXPARAMS lpLineInitializeExParams);
            // Line open
            [DllImport("coredll")]
            public static extern int lineOpen(IntPtr m_hLineApp,
                                              int dwDeviceID,
                                              out IntPtr lphLine,
                                              int dwAPIVersion,
                                              int dwExtVersion,
                                              IntPtr dwCallbackInstance,
                                              int dwPrivileges,
                                              int dwMediaModes,
                                              IntPtr lpCallParams);
            // Line Navigate
            [DllImport("coredll")]
            public static extern int lineNegotiateAPIVersion(IntPtr m_hLineApp,
                                                             int dwDeviceID,
                                                             int dwAPILowVersion,
                                                             int dwAPIHighVersion,
                                                             out int lpdwAPIVersion,
                                                             out LINEEXTENSIONID lpExtensionID);
            // Line retreive Infos
            [DllImport("cellcore")]
            public static extern int lineGetGeneralInfo(IntPtr hLine,
                                                        byte[] bytes);
            // Line close
            [DllImport("coredll")]
            public static extern int lineClose(IntPtr hLine);
            // Line shutdown
            [DllImport("coredll")]
            public static extern int lineShutdown(IntPtr m_hLineApp);

    public struct LINEEXTENSIONID
        {
            public IntPtr dwExtensionID0;
            public IntPtr dwExtensionID1;
            public IntPtr dwExtensionID2;
            public IntPtr dwExtensionID3;
        }

    public class LINEGENERALINFO
    {
        public int dwManufacturerOffset;
        public int dwManufacturerSize;
        public int dwModelOffset;
        public int dwModelSize;
        public int dwNeededSize;
        public int dwRevisionOffset;
        public int dwRevisionSize;
        public int dwSerialNumberOffset;
        public int dwSerialNumberSize;
        public int dwSubscriberNumberOffset;
        public int dwSubscriberNumberSize;
        public int dwTotalSize;
        public int dwUsedSize;
    }

    public void details()
        {   IntPtr hLine;
            int dwNumDev;
            int num1 = 0x20000;
            LINEINITIALIZEEXPARAMS lineInitializeParams = new LINEINITIALIZEEXPARAMS();
            lineInitializeParams.dwTotalSize = (uint)Marshal.SizeOf(lineInitializeParams);
            lineInitializeParams.dwNeededSize = lineInitializeParams.dwTotalSize;
            lineInitializeParams.dwOptions = 2;
            lineInitializeParams.hEvent = IntPtr.Zero;
            lineInitializeParams.hCompletionPort = IntPtr.Zero;

            // lineInitializeEx
            int result = Tapi.lineInitializeEx(out hLine, IntPtr.Zero, IntPtr.Zero, null, out dwNumDev, ref num1, ref lineInitializeParams);

            if (result != 0)
            {
                MessageBox.Show(string.Format("lineInitializeEx failed!\n\nError Code:{0}", result.ToString()));
                this.Close();
                return;
            }

            // lineNegotiateAPIVerison
            int version;
            int dwAPIVersionLow = 0x10004;
            int dwAPIVersionHigh = 0x20000;
            LINEEXTENSIONID lineExtensionID;
            result = Tapi.lineNegotiateAPIVersion(hLine, 0, dwAPIVersionLow, dwAPIVersionHigh, out version, out lineExtensionID);
            // navigation failed
            if (result != 0)  
            {
                MessageBox.Show(string.Format("lineNegotiateAPIVersion failed!\n\nError Code: {0}", result.ToString()));
                this.Close();
                return;
            }

            // lineOpen
            IntPtr hLine2 = IntPtr.Zero;
            result = Tapi.lineOpen(hLine, 0, out hLine2, version, 0, IntPtr.Zero, 0x00000002, 0x00000004, IntPtr.Zero);
            // lineOpen failed
            if (result != 0)
                {
                MessageBox.Show(string.Format("lineNegotiateAPIVersion failed!\n\nError Code: {0}", result.ToString()));
                this.Close();
                return;
            }

            // lineGetGeneralInfo
            int structSize = Marshal.SizeOf(new LINEGENERALINFO());
            byte[] bytes = new byte[structSize];
            byte[] tmpBytes = BitConverter.GetBytes(structSize);

            for (int index = 0; index < tmpBytes.Length; index++)
            { bytes[index] = tmpBytes[index]; }

            // make initial query to retrieve necessary size
            result = Tapi.lineGetGeneralInfo(hLine2, bytes);

            // get the needed size
            int neededSize = BitConverter.ToInt32(bytes, 4);

            // resize the array
            bytes = new byte[neededSize];

            // write out the new allocated size to the byte stream
            tmpBytes = BitConverter.GetBytes(neededSize);
            for (int index = 0; index < tmpBytes.Length; index++)
            { bytes[index] = tmpBytes[index]; }

            // fetch the information with properly size buffer
            result = Tapi.lineGetGeneralInfo(hLine2, bytes);

            if (result != 0)
            {
                MessageBox.Show(Marshal.GetLastWin32Error().ToString());
                this.Close();
                return;
            }
                        
            int size;
            int offset;
            // Now all the required information are stored in the variable "bytes"
            //  which we well have to parse.

            // manufacture
            size = BitConverter.ToInt32(bytes, 12);
            offset = BitConverter.ToInt32(bytes, 16);
            manufacture = Encoding.Unicode.GetString(bytes, offset, size);
            manufacture = manufacture.Substring(0, manufacture.IndexOf(''));

            // model
            size = BitConverter.ToInt32(bytes, 20);
            offset = BitConverter.ToInt32(bytes, 24);
            model = Encoding.Unicode.GetString(bytes, offset, size);
            model = model.Substring(0, model.IndexOf(''));

            // revision
            size = BitConverter.ToInt32(bytes, 28);
            offset = BitConverter.ToInt32(bytes, 32);
            revision = Encoding.Unicode.GetString(bytes, offset, size);
            revision = revision.Substring(0, revision.IndexOf(''));

            // serial number
            size = BitConverter.ToInt32(bytes, 36);
            offset = BitConverter.ToInt32(bytes, 40);
            serialNumber = Encoding.Unicode.GetString(bytes, offset, size);
            serialNumber = serialNumber.Substring(0, serialNumber.IndexOf(''));

            // subscriber id
            size = BitConverter.ToInt32(bytes, 44);
            offset = BitConverter.ToInt32(bytes, 48);
            subscriberID = Encoding.Unicode.GetString(bytes, offset, size);
            subscriberID = subscriberID.Substring(0, subscriberID.IndexOf(''));

            // lineClose for hLine2
            Tapi.lineClose(hLine2);

            // lineShutdown for hLine
            Tapi.lineShutdown(hLine);

        }

[DllImport("coredll.dll")]
  public extern static void SipShowIM(uint dwFlag);
        
  private void Open_Btn_Click(object sender, EventArgs e)
  {  SipShowIM(0x0001);  }

  private void Close_btn_Click(object sender, EventArgs e)
  { SipShowIM(0x0000); }

[DllImport("Coredll.dll")]
static extern int SHGetSpecialFolderPath(IntPtr hwndOwner, StringBuilder lpszPath, int nFolder, int fCreate);

public enum SpecialFolders : int
{   CSIDL_WINDOWS = 0x0024,   }

public static string GetSpecialFolder(SpecialFolders specialFolder)
{   StringBuilder path = new StringBuilder(260);
     if (SHGetSpecialFolderPath(IntPtr.Zero, path, (int)specialFolder, 0) == 0)
      throw new Exception("Windows path not found.");
  return path.ToString();
}

string driverFileName = Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Loquendo\LTTS\default.session", "DataPath", @"\Loquendo TTS data\").ToString();
string windowsFolder = GetSpecialFolder(SpecialFolders.CSIDL_WINDOWS);
string driverPath = Path.Combine(windowsFolder, driverFileName);
bool driverExists = File.Exists(driverPath);
if (driverExists)
{MessageBox.Show("Driver exists", "Sucess");}
else {MessageBox.Show("Driver not found", "Failure");}

Registry.SetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Loquendo\LTTS\default.session", "DataPath", @"\Storage Card\");

using Microsoft.Win32;

        string IsLocked()
        {
            int status = -1;
            string DeviceStatus;
            string driverFileName = Microsoft.Win32.Registry.GetValue(@"HKEY_LOCAL_MACHINE\System\State",
                                                                      "Lock",
                                                                      "1").ToString();
            status = Int32.Parse(driverFileName);

            switch (status)
            {
                case 0: DeviceStatus = "Unlocked";             break;
                case 1: DeviceStatus = "Locked with password"; break;
                case 2: DeviceStatus = "Locked";               break;
                default: DeviceStatus = "Unknown status";      break;
            }
            return DeviceStatus;
        }