To get the whole story, see my post Unable to find an entry point name ‘TaskDialogIndirect’ in DLL ‘comctl32.dll’

Thanks to Bart Desmet, you can access all flavors of icons; these are not present in the TaskDialog documentation, I think they have been removed.

Another CancelShutdown ?

Replace the TaskDialogStandardIcon definition with the one below.

    /// <summary>
    /// Specifies the icon displayed in a task dialog.
    /// </summary>
    public enum TaskDialogStandardIcon
    {
        /// <summary>
        /// Displays no icons (default).
        /// </summary>
        None = 0,

        /// <summary>
        /// Displays the warning icon.
        /// </summary>
        Warning = 65535,

        /// <summary>
        /// Displays the error icon.
        /// </summary>
        Error = 65534,

        /// <summary>
        /// Displays the Information icon.
        /// </summary>
        Information = 65533,

        /// <summary>
        /// Displays the User Account Control shield.
        /// </summary>
        Shield = 65532,

        SecurityShieldBlue = 65531,

        SecurityWarning = 65530,

        SecurityError = 65529,

        SecuritySuccess = 65528,

        SecurityShieldGray = 65527,
    }

If you are lazy like I am, get the code : TaskDialogHiddenIcons

Too easy,

• You still have to get the Windows API Code Pack,
• Point the Core project location to where you extracted it,
• Update the TaskDialogStandardIcon definition with the one provided above,
• Enjoy !

If you’re even lazier than I am (I didn’t know this was possible, I have to meet you right now :-), go to bin\Debug and run the application’s .EXE :-)

Too bad,

I was happy when I heard they finally released a managed API for those (not yet managed) APIs …

I have been struggling a lot last year to try get it working with C#, thanks to Chris Dunford’s VistaBridge Considered Harmful; An Alternative which would have otherwise, never happened.

(Credits goes to Kenny Kerr too, for his article and Bart Desmet’s Using Windows Vista’s TaskDialog API in managed code)

The main problem is was the activation context,

Solution is here :

[Seven / Vista] La classe TaskDialog et l’erreur “Unable to find an entry point named ‘TaskDialogIndirect’ in DLL ‘comctl32.dll’”

Here is the translation in english :

1. Open your project properties in the Solution Explorer,
2. On the Security tab, check Enable ClickOnce Security Settings,
3. Now you can see appearing the app.manifest file in the Properties folder of your solution, open it,
4. Beneath the </trustInfo> tag, insert the following code :

     <dependency>
       <dependentAssembly>
         <assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="*" publicKeyToken="6595b64144ccf1df" language="*" />
       </dependentAssembly>
     </dependency>
   

5. If you try to build there’ll be an error, to fix it, uncheck the Enable ClickOnce Security Settings.

MonitorConfigurationAPI

Requirements : Vista and a display monitor with Vista drivers.

Usage : Click ‘Probe’ button then wait a few seconds !

Issues

• Color temperature doesn’t produce expected results
• During detection, some monitors may change their settings

If you don’t have a Vista-specific driver, you shouldn’t install an old XP driver otherwise it will break a couple of things on your system like monitor management for instance. You may think that you can roll-back to the previous driver, but it’ll be broken anyway ! I have seen some results with monitor that don’t have Vista drivers with the Generic PnP Monitor that is installed by default, though.

I needed to detect what is the type of the monitor plugged onto the PC. This then, would allow me to provide custom scanlines PNGs, dependent of the technology used.

CRT ?

or LCD ?

Knowing that LCD does blurry stretching when not set at its native resolution, it is critical to know what display we are going to play on, in order to provide The (best possible) visual experience.

Proper arcade games emulation is somewhat sensitive to your display settings, hence, it’s always best to try provide nearest if not exact, display settings (resolution & refresh rate).

This all came out when I decided to try MAME, seriously (this time) on my LCD screen.
I got the following conclusion : it is possible to have a very good display experience even on LCDs, compared to using PowerStrip with my CRT.

While I have a great P1130 which is nothing more than a repainted G520 from Sony and is very good, if not one of the best CRTs to play your arcade games on, I like to play MAME quickly on my desktop PC (which in fact is a laptop) who is connected to the LCD screen. This is because since I got a new PC, the old Precision 360 workstation has been converted to a gaming-only PC. Too lazy to stand up and play just like in a real arcade game …

I thought : “This should be simple to get, I only need to know what is the type of screen, nothing more. (So it’s gonna be easy, yeah ?)”

But life was different,

In fact this post is kind of, the tip of the iceberg I’ve been sitting on and didn’t even know there was an iceberg under my feets until recently … So I decided to write this post, because now I got it working and other people can benefit from it.

I knew that display monitors have a protocol so the PC can speak with them, DDC/CI.

But here the problems comes,

• The protocol is using nothing more than I²C
• This is something low-level, not addressable with C# directly

And the list grows with time, why such simple request be so complicated to code ?

Now here are the possible solutions,

• Get EDID string from Windows registry
  (Nice try but the string is in its raw form, decode it ? the specifications are not free …)
• Use a software like softMCCS, or better, an SDK like WinI2C/DDC,
  (Nice try again but these analysis softwares are stand-alone application, and while WinI2C is exactly what is needed, it’s pricey and not to consider because of the target project : Another free MAME GUI (already claiming it’s the best).

While I’ve spent some time on WinI2C, the time-bombed samples always crashed for me, though the compiled demo ran … so I haven’t even been able to use it !

Now I don’t really need it because i have the same thing I coded myself but this wouldn’t happen without help right from Microsoft :-) considering you have Vista or better.

Monitor Configuration

You can use the monitor configuration functions to get information from a monitor and to change a monitor’s settings. You can use these functions to :

* Change a monitor’s geometry settings, such as the width and height of the display.
* Change image settings, such as brightness and contrast.
* Reset a monitor’s settings to their factory defaults.
* Degauss the monitor.

Internally, the monitor configuration functions use the Display Data Channel Command Interface (DDC/CI) to send commands to the monitor.
Now while this kicks ass, again, it’s for C++ …

Okay it does 99% of the job, all you have to do is call the functions you need, in fact it is even handier for my project as I am even able to change the colors of the monitor (if supported), great for monochrome emulation !

Now the only thing we need is a C# wrapper. (But some of it ran into trouble)

…

It got stuck when trying to get the physical monitors from the monitor, the pointer pointing to 0 was indeed correct (a pointer of pointer ?). While I hate pointers I find them working great when they are tamed.

But you still have to do a lot of things even with this API to get your Graal.

In the next part I will unveil a complete monitor configuration wrapper for C# :-)

This is longer than expected as I decided to fully document it, and it’s tedious !
(I am already considering another project that creates P/Invoke declarations fully documented from MSDN site but here comes dirty HTML and Regular Expressions …)

ShutdownBlockReasonCreate

Running the program then initiating a shutdown will display the Windows feature.

As things seems to have changed a little in Windows 7, it doesn’t work with it. I will post an updated version of it, when the documentation is available.

Sometimes you need to handle a shutdown that has been accidentally initiated …

(Yes it can happen, at least for me).

For example in XP, when you have an application running and initiate a shutdown, a small window appears, saying that the application is not responding :

By simply pressing Cancel you were able to abort the shutdown process.

Now on Vista, things have a changed a little, there is a new more user-friendly interface that appears when you try to shutdown while other applications are running :

There’s an API in Windows that you have to use, though.

In fact that API is more subtile than it looks, because of lack of examples and that you have to place these functions in a precise place in your code.

(Note that while the two provided links are unknown to each other, there are complementary informations on them !)

You have to request that you need to block the shutdown process, probably because the application is doing whatever you think, is a critical operation.

However, according to Microsoft, it is not recommended practice.

Your application shall never block a shutdown process, especially if it’s a critical shutdown (one initiated by the user, from the shutdown button present on the Start menu).

A better practice, would be to save your application’s data and shut it down.

I needed this, so I started using the API but ran onto some issues …

Numerous examples on the web didn’t work for me, when not C++ at best I could see the new UI for 5 seconds only.

Now what I wanted is, just like in Outlook, when you shut down while it is running, the system waits for it to finish Send/Receive then it continues the shutdown process.

On the documentation it seems that the content has not been verified, there are duplicate paragraphs and actually, we can make Vista wait more than 30 + 5 seconds (just as Outlook does or seems to), even in a critical shutdown !

There is also an obscure function, so obscure that Microsoft removed its documentation, CancelShutdown. It does what it says even under Vista and 7, it is able to (need to confirm that) cancel shutdown on these platforms.

We’ll look at all the coding needed for that, on part 2 …