ManagedWinapi

Listens to events from the Windows accessibility system. These events are useful if you want to write a screenreader or similar program.

Initializes a new instance of this class with the specified container.

The container to add it to.

Initializes a new instance of this class.

Releases all resources used by the System.ComponentModel.Component.

Whether to dispose managed resources.

Occurs when an accessible event is received.

Enables this listener so that it reports accessible events.

The minimal event type to listen to.

The maximal event type to listen to.

The Process ID to listen to. Default 0 listens to all processes.

The Thread ID to listen to. Default 0 listens to all threads.

Represents the method that will handle accessibility events.

Provides data for accessible events.

Initializes a new instance of the AccessibleEventArgs class.

Type of this accessible event

Handle of the affected window, if any.

Object ID.

Child ID.

The thread that generated this event.

Time in milliseconds when the event was generated.

The accessible object related to this event.

This enumeration lists known accessible event types.

Sent when a sound is played. Currently nothing is generating this, we are going to be cleaning up the SOUNDSENTRY feature in the control panel and will use this at that time. Applications implementing WinEvents are perfectly welcome to use it. Clients of IAccessible* will simply turn around and get back a non-visual object that describes the sound.

Sent when an alert needs to be given to the user. MessageBoxes generate alerts for example.

Sent when the foreground (active) window changes, even if it is changing to another window in the same thread as the previous one.

Sent when entering into and leaving from menu mode (system, app bar, and track popups).

Sent when a menu popup comes up and just before it is taken down. Note that for a call to TrackPopupMenu(), a client will see EVENT_SYSTEM_MENUSTART followed almost immediately by EVENT_SYSTEM_MENUPOPUPSTART for the popup being shown.

Sent when a window takes the capture and releases the capture.

Sent when a window enters and leaves move-size dragging mode.

Sent when a window enters and leaves context sensitive help mode.

Sent when a window enters and leaves drag drop mode. Note that it is up to apps and OLE to generate this, since the system doesn't know. Like EVENT_SYSTEM_SOUND, it will be a while before this is prevalent.

Sent when a dialog comes up and just before it goes away.

Sent when beginning and ending the tracking of a scrollbar in a window, and also for scrollbar controls.

Sent when beginning and ending alt-tab mode with the switch window.

Sent when a window minimizes.

Sent just before a window restores.

hwnd + ID + idChild is created item

hwnd + ID + idChild is destroyed item

hwnd + ID + idChild is shown item

hwnd + ID + idChild is hidden item

hwnd + ID + idChild is parent of zordering children

hwnd + ID + idChild is focused item

hwnd + ID + idChild is selected item (if only one), or idChild is OBJID_WINDOW if complex

hwnd + ID + idChild is item added

hwnd + ID + idChild is item removed

hwnd + ID + idChild is parent of changed selected items

hwnd + ID + idChild is item w/ state change

hwnd + ID + idChild is moved/sized item

hwnd + ID + idChild is item w/ name change

hwnd + ID + idChild is item w/ desc change

hwnd + ID + idChild is item w/ value change

hwnd + ID + idChild is item w/ new parent

hwnd + ID + idChild is item w/ help change

hwnd + ID + idChild is item w/ def action change

hwnd + ID + idChild is item w/ keybd accel change

The lowest possible event value

The highest possible event value

The content of an object that supports the Accessibility API (used by screen readers and similar programs).

An abstract representation of the content of a window or control.

A short description of the type of this window.

A short description of this content.

The full description of this content.

A list of properties of this content.

Provides methods for getting additional information about files, like icons or compressed file size.

Get the icon used for folders.

Whether to get the small icon instead of the large one

Get the icon used for files that do not have their own icon

Whether to get the small icon instead of the large one

Get the icon used by files of a given extension.

The extension without leading dot Whether to get the small icon instead of the large one

Get the icon used for a given, existing file.

Name of the file Whether to get the small icon instead of the large one

Get the size a file requires on disk. This takes NTFS compression into account.

Get the cluster size for the filesystem that contains the given file.

The unicode range of codepoints supported by a font.

Creates a new CodepointRange object for a font.

Returns a dictionary containing codepoint ranges of all fonts. If multiple fonts of one family (bold, italic, etc.) share their codepoint range, only their base font is included in this list, otherwise all different variants are included.

Tests whether a specific codepoint is supported by this font.

Finds the next codepoint that is either supported or not.

Returns a representation of this codepoint range.

The number of codepoints supported by this font.

The first (lowest) supported codepoint.

The last (highest) supported codepoint.

A hook is a point in the system message-handling mechanism where an application can install a subroutine to monitor the message traffic in the system and process certain types of messages before they reach the target window procedure.

Creates a new hook and hooks it.

Creates a new hook.

Hooks the hook.

Unhooks the hook.

Unhooks the hook if necessary.

Override this method if you want to prevent a call to the CallNextHookEx method or if you want to return a different return value. For most hooks this is not needed.

Occurs when the hook's callback is called.

The type of the hook.

Whether this hook has been started.

Represents a method that handles a callback from a hook.

A hook that intercepts local window messages.

Creates a local message hook and hooks it.

Creates a local message hook.

Called when a message has been intercepted.

Represents a method that handles a message from a message hook.

Hook Types. See the documentation of SetWindowsHookEx for reference.

Blocks keyboard and mouse input until this object is disposed. Unlike , you cannot detect when the systems removes the block (which happens when the user presses CTRL+ALT+DEL), but it works on Windows Vista as well.

Blocks keyboard and mouse input until this object is disposed.

Unblocks keyboard and mouse input.

Abstract base class for hooks that can be used to create or playback a log of keyboard and mouse events.

Creates a new journal hook.

Hooks the hook.

Unhooks the hook.

Occurs when the journal activity has been cancelled by CTRL+ALT+DEL or CTRL+ESC.

An event that has been recorded by a journal hook.

Creates a new journal message.

Returns a System.String that represents the current System.Object.

The window this message has been sent to.

The message.

The first parameter of the message.

The second parameter of the message.

The timestamp of the message.

Event data for a journal record event.

The recorded message.

A hook that can be used to create a log of keyboard and mouse events.

Creates a new journal record hook.

Occurs when a system modal dialog appears. This may be used to stop recording.

Occurs when a system modal dialog disappears. This may be used to continue recording.

Occurs when an event can be recorded.

A hook that can be used to playback a log of keyboard and mouse events.

Creates a new journal playback hook.

Occurs when a system modal dialog appears. This may be used to stop playback.

Occurs when a system modal dialog disappears. This may be used to continue playback.

Occurs when the next journal message is needed. If the message is and a timestamp in the future, it just waits for that time and asks for a message again. If the message is and the timestamp is in the past, playback stops.

Represents a method that yields the next journal message.

Convenience class that uses a journal playback hook to block keyboard and mouse input for some time.

Locks the input for interval * count milliseconds. The lock can be canceled every interval milliseconds. If count is negative, the lock will be active until cancelled.

The interval to lock the input. How often to lock the input. If true, the lock cannot be canceled by pressing Control+Alt+Delete

Unlocks the input.

Lock input for given number of milliseconds

Number of milliseconds to lock If true, the lock cannot be canceled by pressing Control+Alt+Delete

This class contains utility methods related to keys on the keyboard.

Initializes a new instance of this class for a given key.

Press this key and release it.

Press this key.

Release this key.

Inject a keyboard event into the event loop, as if the user performed it with his keyboard.

Inject a mouse event into the event loop, as if the user performed it with his mouse.

The state of this key, as seen by this application.

The global state of this key.

Determine the name of a key in the current keyboard layout.

The key's name

A hook that intercepts keyboard events.

Creates a low-level keyboard hook and hooks it.

Creates a low-level keyboard hook.

Called when a key has been intercepted.

Called when a character has been intercepted.

Called when a key message has been intercepted.

Represents a method that handles an intercepted key.

Represents a method that handles an intercepted character.

The message that caused the character. Usually Either WM_KEYDOWN or WM_SYSKEYDOWN. The character(s) that have been typed, or an empty string if a non-character key (like a cursor key) has been pressed. Whether a dead key is pending. If a dead key is pending, you may not call the ToUnicode method or similar methods, because they will destroy the deadkey state. The virtual key code of the message that caused the character. The scancode of the message that caused the character. The flags of the message that caused the character. The timestamp of the message that caused the character. The extra info of the message that caused the character.

A hook that intercepts mouse events

Creates a low-level mouse hook and hooks it.

Creates a low-level mouse hook.

Called when a mouse action has been intercepted.

Called when a mouse message has been intercepted.

Represents a method that handles an intercepted mouse action.

Represents a method that handles an intercepted low-level message.

A message that has been intercepted by a low-level hook

Replays this event as if the user did it again.

The time this message happened.

Flags of the message. Its contents depend on the message.

The message identifier.

Extra information. Its contents depend on the message.

A message that has been intercepted by a low-level mouse hook

Creates a new low-level mouse message.

Replays this event.

The mouse position where this message occurred.

Additional mouse data, depending on the type of event.

Mouse event flags needed to replay this message.

A message that has been intercepted by a low-level mouse hook

Creates a new low-level keyboard message.

Replays this event.

The virtual key code that caused this message.

The scan code that caused this message.

Flags needed to replay this event.

Contains utility functions to determine values that are (almost) unique on each computer. These values can be useful for locking software to a machine.

The security identifier of this machine. This id is generated at installation time (or when running tools like SysPrep or NewSid) and is used to generate security identifiers of local users and to authenticate the machine in a domain.

The DNS host name of this machine. Can be easily changed.

The NetBIOS name of this machine. Can be easily changed; having two machines with same name on the same network can cause trouble with shared folders, though.

The Media Access Control addresses of all network adapters. Note that these values are the addresses loaded from the driver, and thus could have been set by the user. Having two network cards with same MAC connected to the same physical network segment will lead into trouble. Usually MAC addresses are burned into the PROM of a NIC, so this is no problem unless someone changes his MAC deliberately (for example) to bypass access restrictions.

Get all network interfaces. Use them to get MAC addresses or IP addresses, or the MAC address that is used for connecting to a specific IP address.

Get the Volume Serial Numbers from all hard disk partitions. These values are part of the filesystem, and were originally intended to detect floppy swaps where the same floppy has been removed and inserted again (because, in this case, unwritten data may still be written). Today these are easily tweakable and of no real use, except for badly-designed software licensing schemes.

Return the ID of all CPUs in this machine. Depending on BIOS configuration, CPU IDs might not be readable.

A chunk in another processes memory. Mostly used to allocate buffers in another process for sending messages to its windows.

Create a new memory chunk that points to existing memory. Mostly used to read that memory.

Allocate a chunk in another process.

Allocate a chunk in another process and unmarshal a struct there.

Free the memory in the other process, if it has been allocated before.

Write a structure into this chunk.

Write into this chunk.

Write a byte array into this chunk.

Read this chunk.

Read a part of this chunk.

Read this chunk to a pointer in this process.

Read a part of this chunk to a pointer in this process.

Read a part of this chunk to a structure.

Querys the process for it's memory regions (pages)

start address of the pages to get size of pages to get (max address) a list of memory regions (pages)

The process this chunk refers to.

The location in memory (of the other process) this chunk refers to.

The size of the chunk.

Memory protection options (for an entire memory region)

No Allocation protection (NONE)

Disables all access to the committed region of pages. An attempt to read from, write to, or execute the committed region results in an access violation. This flag is not supported by the CreateFileMapping function.

Enables read-only access to the committed region of pages. An attempt to write to the committed region results in an access violation. If Data Execution Prevention is enabled, an attempt to execute code in the committed region results in an access violation.

Enables read-only or read/write access to the committed region of pages. If Data Execution Prevention is enabled, attempting to execute code in the committed region results in an access violation.

Enables read-only or copy-on-write access to a mapped view of a file mapping object. An attempt to write to a committed copy-on-write page results in a private copy of the page being made for the process. The private page is marked as PAGE_READWRITE, and the change is written to the new page. If Data Execution Prevention is enabled, attempting to execute code in the committed region results in an access violation. This flag is not supported by the VirtualAlloc or VirtualAllocEx functions.

Enables execute access to the committed region of pages. An attempt to read from or write to the committed region results in an access violation. This flag is not supported by the CreateFileMapping function.

Enables execute or read-only access to the committed region of pages. An attempt to write to the committed region results in an access violation.

Enables execute, read-only, or read/write access to the committed region of pages.

Enables execute, read-only, or copy-on-write access to a mapped view of a file mapping object. An attempt to write to a committed copy-on-write page results in a private copy of the page being made for the process. The private page is marked as PAGE_EXECUTE_READWRITE, and the change is written to the new page. This flag is not supported by the VirtualAlloc or VirtualAllocEx functions.

Pages in the region become guard pages. Any attempt to access a guard page causes the system to raise a STATUS_GUARD_PAGE_VIOLATION exception and turn off the guard page status. Guard pages thus act as a one-time access alarm. For more information, see Creating Guard Pages. When an access attempt leads the system to turn off guard page status, the underlying page protection takes over. If a guard page exception occurs during a system service, the service typically returns a failure status indicator. This value cannot be used with PAGE_NOACCESS. This flag is not supported by the CreateFileMapping function.

Sets all pages to be non-cachable. Applications should not use this attribute except when explicitly required for a device. Using the interlocked functions with memory that is mapped with SEC_NOCACHE can result in an EXCEPTION_ILLEGAL_INSTRUCTION exception. The PAGE_NOCACHE flag cannot be used with the PAGE_GUARD, PAGE_NOACCESS, or PAGE_WRITECOMBINE flags. The PAGE_NOCACHE flag can be used only when allocating private memory with the VirtualAlloc, VirtualAllocEx, or VirtualAllocExNuma functions. To enable non-cached memory access for shared memory, specify the SEC_NOCACHE flag when calling the CreateFileMapping function.

Sets all pages to be write-combined. Applications should not use this attribute except when explicitly required for a device. Using the interlocked functions with memory that is mapped as write-combined can result in an EXCEPTION_ILLEGAL_INSTRUCTION exception. The PAGE_WRITECOMBINE flag cannot be specified with the PAGE_NOACCESS, PAGE_GUARD, and PAGE_NOCACHE flags. The PAGE_WRITECOMBINE flag can be used only when allocating private memory with the VirtualAlloc, VirtualAllocEx, or VirtualAllocExNuma functions. To enable write-combined memory access for shared memory, specify the SEC_WRITECOMBINE flag when calling the CreateFileMapping function.

Contains information about a range of pages in the virtual address space of a process. The VirtualQuery and VirtualQueryEx functions use this structure.

A pointer to the base address of the region of pages.

A pointer to the base address of a range of pages allocated by the VirtualAlloc function. The page pointed to by the BaseAddress member is contained within this allocation range.

The memory protection option when the region was initially allocated. This member can be one of the memory protection constants or 0 if the caller does not have access.

The size of the region beginning at the base address in which all pages have identical attributes, in bytes.

The state of the pages in the region. This member can be one of the following values (MEM_COMMIT [0x1000] | MEM_FREE [0x10000] | MEM_RESERVE [0x2000])

The access protection of the pages in the region. This member is one of the values listed for the AllocationProtect member.

The type of pages in the region. The following types are defined (MEM_IMAGE [0x1000000] | MEM_MAPPED [0x40000] | MEM_PRIVATE [0x20000])

String representation of the data

a string

The states of a memory page

An unknown page state, or no state set

Indicates committed pages for which physical storage has been allocated, either in memory or in the paging file on disk.

Indicates free pages not accessible to the calling process and available to be allocated. For free pages, the information in the AllocationBase, AllocationProtect, Protect, and Type members is undefined.

Indicates reserved pages where a range of the process's virtual address space is reserved without any physical storage being allocated. For reserved pages, the information in the Protect member is undefined.

The types of a memory page

An unknown page type, or no type set

Indicates that the memory pages within the region are mapped into the view of an image section.

Indicates that the memory pages within the region are mapped into the view of a section.

Indicates that the memory pages within the region are private (that is, not shared by other processes).

A Wrapper for cref: MEMORY_BASIC_INFORMATION

The start address of the region

The End address of the region

The size of the region

The encapsulated MEMORY_BASIC_INFORMATION structure data

String representation of the data

a string

A that can be used to select a keyboard shortcut. A context menu allows selecting keys that are not available directly by typing them.

Creates a new shortcut box.

Required designer variable.

Clean up any resources being used.

true if managed resources should be disposed; otherwise, false.

Required method for Designer support - do not modify the contents of this method with the code editor.

The "non-modifier" key code of the currently selected shortcut, or if no key is selected.

Whether the currently selected shortcut includes the Shift key.

Whether the currently selected shortcut includes the Alt key.

Whether the currently selected shortcut includes the Control key.

Whether the currently selected shortcut includes the Windows key.

The textual representation of the currently selected key. This property cannot be set.

Collection of miscellaneous actions that cannot be performed as a non-administrative user, like shutdown or setting the system time.

Shutdown the system.

Get or set the system time in the local timezone.

Get or set the system time, in UTC.

Actions that can be performed at shutdown.

Log off the currently logged-on user.

Shut down the system.

Reboot the system.

Shut down the system and power it off.

Reboot the system and restart applications that are running now and support this feature.

Whether shutdown should be forced if an application cancels it or is hung.

Do not force shutdown, applications can cancel it.

Force shutdown, even if application cancels it or is hung.

Force shutdown if application is hung, but not if it cancels it.

Provides access to the Active Accessibility API. Every has one ore more AccessibleObjects attached that provide information about the window to visually impaired people. This information is mainly used by screen readers and other accessibility software..

Create an accessible object from an IAccessible instance and a child ID.

Gets an accessibility object for given screen coordinates.

Gets an accessibility object for a given window.

The window Which accessibility object to get

Convert a role number to a localized string.

Convert a state number (which may include more than one state bit) to a localized string.

Convert a single state bit to a localized string.

Perform the default action of this accessible object.

Compare two instances of this class for equality.

Compare two instances of this class for inequality.

The IAccessible instance of this object (if is zero) or its parent.

The underlying child ID

Gets an accessibility object for the mouse cursor.

Gets an accessibility object for the input caret, or null if there is none.

The description of this accessible object.

The name of this accessible object.

The role of this accessible object. This can either be an int (for a predefined role) or a string.

The role of this accessible object, as an integer. If this role is not predefined, -1 is returned.

The role of this accessible object, as a localized string.

The location of this accessible object on screen. This rectangle is the smallest rectangle that includes the whole object, but not every point in the rectangle must be part of the object.

The value of this accessible object.

The state of this accessible object.

A string representation of the state of this accessible object.

Whether this accessibile object is visible.

The parent of this accessible object, or null if none exists.

The keyboard shortcut of this accessible object.

A string describing the default action of this accessible object. For a button, this might be "Press".

Get all objects of this accessible object that are selected.

Get the SystemWindow that owns this accessible object.

Get all child accessible objects.

This enumeration lists all kinds of accessible objects that can be directly assigned to a window.

The window itself.

The system menu.

The title bar.

The menu.

The client area.

The vertical scroll bar.

The horizontal scroll bar.

The size grip (part in the lower right corner that makes resizing the window easier).

The caret (text cursor).

The mouse cursor. There is only one mouse cursor and it is not assigned to any window.

An alert window.

A sound this window is playing.

Helper class that contains static methods useful for API programming. This class is not exposed to the user.

Throw a if the supplied (return) value is zero. This exception uses the last Win32 error code as error message.

The return value to test.

Throw a if the supplied (return) value is zero. This exception uses the last Win32 error code as error message.

The return value to test.

Specifies a component that monitors the system clipboard for changes.

Creates a new clipboard notifier.

The container.

Creates a new clipboard notifier.

Frees resources.

Occurs when the clipboard contents have changed.

The content of a list box or combo box.

The value in this list or combo box that is selected. In a combo box, this value may not be in the list.

The index of the selected item, or -1 if no item is selected.

The number of items in this list.

Accesses individual list items.

Index of list item. The list item.

The content of a text box.

This component displays a crosshair icon that can be dragged to any point on screen. This is useful to select other programs by dragging the crosshair to a program window.

Creates a new crosshair control.

When a window is hidden, the .NET framework releases mouse capture. If you hide your window while the crosshair is dragged, invoke this method afterwards to restore mouse capture.

Required designer variable.

Clean up any resources being used.

true if managed resources should be disposed; otherwise, false.

Required method for Designer support - do not modify the contents of this method with the code editor.

Occurs when the user finished dragging the crosshair. Use to detect the cursor position.

Occurs while the user drags the crosshair. Use to detect the cursor position.

Represents a mixer provided by a sound card. Each mixer has multiple destination lines (e. g. Record and Playback) of which each has multiple source lines (Wave, MIDI, Mic, etc.).

Opens a mixer.

The zero-based index of this mixer. A reference to this mixer.

Occurs when a control of this mixer changes value.

Occurs when a line of this mixer changes.

Disposes this mixer.

Find a line of this mixer by ID.

ID of the line to find The line, or null if no line was found.

Find a control of this mixer by ID.

ID of the control to find. The control, or null if no control was found.

Gets the number of available mixers in this system.

Whether to create change events. Enabling this may create a slight performance impact, so only enable it if you handle these events.

Gets the name of this mixer's sound card.

Gets the number of destination lines of this mixer.

Gets all destination lines of this mixer

Represents the method that will handle the LineChanged or ControlChanged event of a Mixer.

The source of the event. A MixerEventArgs that contains the event data.

Provides data for the LineChanged and ControlChanged events of a Mixer.

Initializes a new instance of the MixerEventArgs class.

The affected mixer The affected line The affected control, or null if this is a LineChanged event.

The affected mixer.

The affected line.

The affected control.

A control of a mixer line. This can be for example a volume slider or a mute switch.

Occurs when the value of this control is changed

The ID of this control.

The short name of this control.

The long name of this control.

The class of this control. For example FADER or SWITCH.

The type of the control. For example mute switch.

The flags of this control.

Whether this control is uniform. A uniform control controls more than one channel, but can only set one value for all channels.

Whether this control has multiple values per channel. An example for a multiple value control is a three-band equalizer.

The number of channels.

The number of multiple values. For a three band equalizer, this is 3. Will be always one if IsMultiple is false.

The number of raw values that have to be get or set. This value is provided as a convenience; it can be computed from MultipleValuesCount, IsUniform and ChannelCount.

The line this control belongs to.

The mixer this control belongs to.

A mixer control that is adjusted by a vertical fader, with a linear scale of positive values (ie, 0 is the lowest possible value).

The minimum value of this fader.

The maximum value of this fader.

Used to get or set the values of this fader.

A control that is has only two states (ie, values), and is therefore adjusted via a button.

Used to get or set the values of this switch.

Mixer control type classes. These classes are roughly based upon what type of value a control adjusts, and therefore what kind of graphical user interface you would normally present to the enduser to let him adjust that control's value. The descriptions for these classes have been taken from http://www.borg.com/~jglatt/tech/mixer.htm.

A custom class of control. If none of the others are applicable.

A control that is adjusted by a graphical meter.

A control that is has only two states (ie, values), and is therefore adjusted via a button.

A control that is adjusted by numeric entry.

A control that is adjusted by a horizontal slider with a linear scale of negative and positive values. (ie, Generally, 0 is the mid or "neutral" point).

A control that is adjusted by a vertical fader, with a linear scale of positive values (ie, 0 is the lowest possible value).

A control that allows the user to enter a time value, such as Reverb Decay Time.

A control that is adjusted by a listbox containing numerous "values" to be selected. The user will single-select, or perhaps multiple-select if desired, his choice of value(s).

Flags of a mixer control.

This control has multiple channels, but only one value for all of them.

This control has multiple values for one channel (like an equalizer).

This control is disabled.

The type of a mixer control. You can find descriptions for most of these types on http://www.borg.com/~jglatt/tech/mixer.htm.

Represents a mixer line, either a source line or a destination line.

Occurs when this line changes.

All controls of this line.

The volume control of this line, if it has one.

The mute switch of this control, if it has one.

Gets the ID of this line.

Gets the number of channels of this line.

Gets the number of controls of this line.

Gets the short name of this line;

Gets the full name of this line.

Gets the component type of this line;

The mixer that owns this line.

Represents a destination line. There is one destination line for each way sound can leave the mixer. Usually there are two destination lines, one for playback and one for recording.

Gets the number of source lines of this destination line.

Gets all source lines of this destination line.

Represents a source line. Source lines represent way sound for one destination enters the mixer. So, if you can both record and playback CD audio, there will be two CD audio source lines, one for the Recording destination line and one for the Playback destination line.

Types of source or destination lines. The descriptions for these lines have been taken from http://www.borg.com/~jglatt/tech/mixer.htm.

An undefined destination line type.

A digital destination, for example, a SPDIF output jack.

A line output destination. Typically used for a line output jack, if there is a separate speaker output (ie, MIXERLINE_COMPONENTTYPE_DST_SPEAKERS).

Typically a "Monitor Out" jack to be used for a speaker system separate from the main speaker out. Or, it could be some built-in monitor speaker on the sound card itself, such as a speaker for a built-in modem.

The audio output to a pair of speakers (ie, the "Speaker Out" jack).

Typically, a headphone output jack.

Typically used to daisy-chain a telephone to an analog modem's "telephone out" jack.

The card's ADC (to digitize analog sources, for example, in recording WAVE files of such).

May be some sort of hardware used for voice recognition. Typically, a microphone source line would be attached to this.

An undefined source line type.

A digital source, for example, a SPDIF input jack.

A line input source. Typically used for a line input jack, if there is a separate microphone input (ie, MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE).

Microphone input (but also used for a combination of Mic/Line input if there isn't a separate line input source).

Musical synth. Typically used for a card that contains a synth capable of playing MIDI. This would be the audio out of that built-in synth.

The audio feed from an internal CDROM drive (connected to the sound card).

Typically used for a telephone line's incoming audio to be piped through the computer's speakers, or the telephone line in jack for a built-in modem.

Typically, to allow sound, that normally goes to the computer's built-in speaker, to instead be routed through the card's speaker output. The motherboard's system speaker connector would be internally connected to some connector on the sound card for this purpose.

Wave playback (ie, this is the card's DAC).

An aux jack meant to be routed to the Speaker Out, or to the ADC (for WAVE recording). Typically, this is used to connect external, analog equipment (such as tape decks, the audio outputs of musical instruments, etc) for digitalizing or playback through the sound card.

May be used similiarly to MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY (although I have seen some mixers use this like MIXERLINE_COMPONENTTYPE_SRC_PCSPEAKER). In general, this would be some analog connector on the sound card which is only accessible internally, to be used to internally connect some analog component inside of the computer case so that it plays through the speaker out.

Wrapper around the Winapi POINT type.

The X Coordinate.

The Y Coordinate.

Creates a new POINT.

Implicit cast.

Wrapper around the Winapi RECT type.

LEFT

TOP

RIGHT

BOTTOM

Creates a new RECT.

Convert RECT to a Rectangle.

Convert Rectangle to a RECT

Returns the hash code for this instance.

Implicit Cast.

HEIGHT

WIDTH

SIZE

LOCATION

Utility class to escape literal strings so that they can be used for the class.

Escapes a literal string.

The literal string to be sent. Whether you prefer to put characters into braces. The escaped string.

The singleton instance.

Specifies if a character needs to be escaped.

The character cannot be used at all with SendKeys.

The character must be escaped by putting it into braces

The character may not be escaped by putting it into braces

Both ways are okay.

Called by an EventDispatchingNativeWindow when a window message is received

The message to handle. Whether the event has already been handled. If this value is true, the handler should return immediately. It may set the value to true to indicate that no others should handle it. If the event is not handled by any handler, it is passed to the default WindowProc.

A Win32 native window that delegates window messages to handlers. So several components can use the same native window to save "USER resources". This class is useful when writing your own components.

Create your own event dispatching window.

Parse messages passed to this window and send them to the event handlers.

A System.Windows.Forms.Message that is associated with the current Windows message.

A global instance which can be used by components that do not need their own window.

Attach your event handlers here.

Specifies a component that creates a global keyboard hotkey.

Initializes a new instance of this class with the specified container.

The container to add it to.

Initializes a new instance of this class.

Releases all resources used by the System.ComponentModel.Component.

Whether to dispose managed resources.

Occurs when the hotkey is pressed.

Enables the hotkey. When the hotkey is enabled, pressing it causes a HotkeyPressed event instead of being handled by the active application.

The key code of the hotkey.

Whether the shortcut includes the Control modifier.

Whether this shortcut includes the Alt modifier.

Whether this shortcut includes the shift modifier.

Whether this shortcut includes the Windows key modifier. The windows key is an addition by Microsoft to the keyboard layout. It is located between Control and Alt and depicts a Windows flag.

The exception is thrown when a hotkey should be registered that has already been registered by another application.

Utility class that can be used to create key events with all current locking keys (like Caps Lock) disabled. Other modifier keys (like Ctrl or Shift) are also ignored if they are currently pressed on the "real" keyboard.


            using (new LockKeysResetter()) {
                SendKeys.Send("Hello");
            }

Reset all modifier keys and remember in this object which modifier keys have been set.

Set all modifier keys that have been set before. Since this class implements , you can use the using keyword in C# to automatically set modifier keys when you have finished.

Convenience method to send keys with all modifiers disabled.

The keys to send

Convenience method to send keys and wait for them (like SendKeys.SendWait) with all modifiers disabled.

Any list box, including those from other applications.

Get a SystemListBox reference from a SystemWindow (which is a list box)

The SystemWindow instance that represents this list box.

The number of elements in this list box.

The index of the selected element in this list box.

The selected element in this list box.

Get an element of this list box by index.

Any combo box, including those from other applications.

Get a SystemComboBox reference from a SystemWindow (which is a combo box)

The SystemWindow instance that represents this combo box.

The number of elements in this combo box.

Gets an element by index.

Any list view, including those from other applications.

Get a SystemListView reference from a SystemWindow (which is a list view)

The number of items (icons) in this list view.

An item of this list view.

A subitem (a column value) of an item of this list view.

All columns of this list view, if it is in report view.

An item of a list view.

The title of this item

The index of this item's image in the image list of this list view.

State bits of this item.

Position of the upper left corner of this item.

Bounding rectangle of this item.

A column of a list view.

The format (like left justified) of this column.

The width of this column.

The subindex of the subitem displayed in this column. Note that the second column does not necessarily display the second subitem - especially when the columns can be reordered by the user.

The title of this column.

Any tree view, including those from other applications.

Get a SystemTreeView reference from a SystemWindow (which is a tree view)

The number of items (icons) in this tree view.

The root items of this tree view.

An item of a tree view.

The title of that item.

All child items of that item.

Window Style Flags. The original constants started with WS_.

WS_OVERLAPPED

WS_POPUP

WS_CHILD

WS_MINIMIZE

WS_VISIBLE

WS_DISABLED

WS_CLIPSIBLINGS

WS_CLIPCHILDREN

WS_MAXIMIZE

WS_BORDER

WS_DLGFRAME

WS_VSCROLL

WS_HSCROLL

WS_SYSMENU

WS_THICKFRAME

WS_GROUP

WS_TABSTOP

WS_MINIMIZEBOX

WS_MAXIMIZEBOX

WS_CAPTION

WS_TILED

WS_ICONIC

WS_SIZEBOX

WS_TILEDWINDOW

WS_OVERLAPPEDWINDOW

WS_POPUPWINDOW

WS_CHILDWINDOW

Extended Window Style Flags. The original constants started with WS_EX_.

Specifies that a window created with this style accepts drag-drop files.

Forces a top-level window onto the taskbar when the window is visible.

Specifies that a window has a border with a sunken edge.

Windows XP: Paints all descendants of a window in bottom-to-top painting order using double-buffering. For more information, see Remarks. This cannot be used if the window has a class style of either CS_OWNDC or CS_CLASSDC.

Includes a question mark in the title bar of the window. When the user clicks the question mark, the cursor changes to a question mark with a pointer. If the user then clicks a child window, the child receives a WM_HELP message. The child window should pass the message to the parent window procedure, which should call the WinHelp function using the HELP_WM_HELP command. The Help application displays a pop-up window that typically contains help for the child window. WS_EX_CONTEXTHELP cannot be used with the WS_MAXIMIZEBOX or WS_MINIMIZEBOX styles.

The window itself contains child windows that should take part in dialog box navigation. If this style is specified, the dialog manager recurses into children of this window when performing navigation operations such as handling the TAB key, an arrow key, or a keyboard mnemonic.

Creates a window that has a double border; the window can, optionally, be created with a title bar by specifying the WS_CAPTION style in the dwStyle parameter.

Windows 2000/XP: Creates a layered window. Note that this cannot be used for child windows. Also, this cannot be used if the window has a class style of either CS_OWNDC or CS_CLASSDC.

Arabic and Hebrew versions of Windows 98/Me, Windows 2000/XP: Creates a window whose horizontal origin is on the right edge. Increasing horizontal values advance to the left.

Creates a window that has generic left-aligned properties. This is the default.

If the shell language is Hebrew, Arabic, or another language that supports reading order alignment, the vertical scroll bar (if present) is to the left of the client area. For other languages, the style is ignored.

The window text is displayed using left-to-right reading-order properties. This is the default.

Creates a multiple-document interface (MDI) child window.

Windows 2000/XP: A top-level window created with this style does not become the foreground window when the user clicks it. The system does not bring this window to the foreground when the user minimizes or closes the foreground window. To activate the window, use the SetActiveWindow or SetForegroundWindow function. The window does not appear on the taskbar by default. To force the window to appear on the taskbar, use the WS_EX_APPWINDOW style.

Windows 2000/XP: A window created with this style does not pass its window layout to its child windows.

Specifies that a child window created with this style does not send the WM_PARENTNOTIFY message to its parent window when it is created or destroyed.

Combines the WS_EX_CLIENTEDGE and WS_EX_WINDOWEDGE styles.

Combines the WS_EX_WINDOWEDGE, WS_EX_TOOLWINDOW, and WS_EX_TOPMOST styles.

The window has generic "right-aligned" properties. This depends on the window class. This style has an effect only if the shell language is Hebrew, Arabic, or another language that supports reading-order alignment; otherwise, the style is ignored. Using the WS_EX_RIGHT style for static or edit controls has the same effect as using the SS_RIGHT or ES_RIGHT style, respectively. Using this style with button controls has the same effect as using BS_RIGHT and BS_RIGHTBUTTON styles.

Vertical scroll bar (if present) is to the right of the client area. This is the default.

If the shell language is Hebrew, Arabic, or another language that supports reading-order alignment, the window text is displayed using right-to-left reading-order properties. For other languages, the style is ignored.

Creates a window with a three-dimensional border style intended to be used for items that do not accept user input.

Creates a tool window; that is, a window intended to be used as a floating toolbar. A tool window has a title bar that is shorter than a normal title bar, and the window title is drawn using a smaller font. A tool window does not appear in the taskbar or in the dialog that appears when the user presses ALT+TAB. If a tool window has a system menu, its icon is not displayed on the title bar. However, you can display the system menu by right-clicking or by typing ALT+SPACE.

Specifies that a window created with this style should be placed above all non-topmost windows and should stay above them, even when the window is deactivated. To add or remove this style, use the SetWindowPos function.

Specifies that a window created with this style should not be painted until siblings beneath the window (that were created by the same thread) have been painted. The window appears transparent because the bits of underlying sibling windows have already been painted. To achieve transparency without these restrictions, use the SetWindowRgn function.

Specifies that a window has a border with a raised edge.

Represents any window used by Windows, including those from other applications.

Returns all toplevel windows that match the given predicate.

The predicate to filter. The filtered toplevel windows

Finds the system window below the given point. This need not be a toplevel window; disabled windows are not returned either. If you have problems with transparent windows that cover nontransparent windows, consider using , since that method tries hard to avoid this problem.

X coordinate Y coordinate

Finds the system window below the given point. This method uses a more sophisticated algorithm than , but is slower.

X coordinate Y coordinate Whether to return the toplevel window. Whether to return enabled windows only.

Create a new SystemWindow instance from a window handle.

The window handle.

Create a new SystemWindow instance from a Windows Forms Control.

The control.

Returns all child windows that match the given predicate.

Whether to include only direct children (no descendants) The predicate to filter. The list of child windows.

Check whether this window is a descendant of ancestor

The suspected ancestor If this is really an ancestor

Gets a device context for this window.

Whether to get the context for the client area or for the full window.

Whether this SystemWindow represents a valid window that existed when this SystemWindow instance was created. To check if a window still exists, better check its property.

Send a message to this window that it should close. This is equivalent to clicking the "X" in the upper right corner or pressing Alt+F4.

Highlights the window with a red border.

Forces the window to invalidate its client area and immediately redraw itself and any child controls.

Compare two instances of this class for equality.

Compare two instances of this class for inequality.

Allows getting the current foreground window and setting it.

The Desktop window, i. e. the window that covers the complete desktop.

Returns all available toplevel windows.

Return all descendant windows (child windows and their descendants).

Return all direct child windows.

The Window handle of this window.

The title of this window (by the GetWindowText API function).

The name of the window class (by the GetClassName API function). This class has nothing to do with classes in C# or other .NET languages.

Whether this window is currently visible. A window is visible if its and all ancestor's visibility flags are true.

Whether this window always appears above all other windows that do not have this property set to true.

Whether this window is currently enabled (able to accept keyboard input).

Returns or sets the visibility flag.

This window's style flags.

This window's extended style flags.

This window's parent. A dialog's parent is its owner, a component's parent is the window that contains it.

The window's parent, but only if this window is its parent child. Some parents, like dialog owners, do not have the window as its child. In that case, null will be returned.

The window's position inside its parent or on the screen.

The window's location inside its parent or on the screen.

The window's size.

The window's position in absolute screen coordinates. Use if you want to use the relative position.

The process which created this window.

The Thread which created this window.

Whether this window is minimized or maximized.

Whether this window can be moved on the screen by the user.

Whether this window can be resized by the user. Resizing a window that cannot be resized by the user works, but may be irritating to the user.

An image of this window. Unlike a screen shot, this will not contain parts of other windows (partially) cover this window. If you want to create a screen shot, use the function and use the property for the range.

The window's visible region.

The character used to mask passwords, if this control is a text field. May be used for different purpose by other controls.

The ID of a control within a dialog. This is used in WM_COMMAND messages to distinguish which control sent the command.

Get the window that is below this window in the Z order, or null if this is the lowest window.

Get the window that is above this window in the Z order, or null, if this is the foreground window.

The content of this window. Is only supported for some kinds of controls (like text or list boxes).

Whether this control, which is a check box or radio button, is checked.

A device context of a window that allows you to draw onto that window.

Creates a Graphics object for this device context.

Frees this device context.

The device context handle.