w00t!

[Via: BT Plc.]

SELECT [ROUTINE_NAME], [ROUTINE_DEFINITION]
FROM [INFORMATION_SCHEMA].[ROUTINES]
WHERE [ROUTINE_DEFINITION] LIKE '%<insert_text_here>%'
AND [ROUTINE_TYPE] = 'PROCEDURE'

[Via: ASP FAQ]

The problem is the DataGridView is not double-buffered by default, nor is there any visible property on the DataGridView object to set it as double-buffered.

Google to the rescue!

Thanks to the guys at StackOverflow.com for this elegant solution that uses reflection rather than defining a custom class.

typeof(DataGridView).InvokeMember(
   "DoubleBuffered",
   BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.SetProperty,
   null,
   myDataGridViewObject,
   new object[] { true });

[Via: stackoverflow]

This is fine, unless you only want one instance of your app to be running at any one time. Each time an associated file is opened, a new instance of the ClickOnce app will be launched. If your single-instance app is open and you try to open an associated file, the reference to the file will be lost when the new instance detects that the original instance is running and terminates. Grrr.

However, you can get round this. After detecting that there is another instance of your app running, simply pass the file reference to the original instance before closing.

Note the callback is made using an IpcChannel rather than a TcpChannel. If a TcpChannel is specified, Vista and Windows 7 will require permission from the user to allow communication through the firewall.

Here is the code:

            // Single instance checked
            bool IsFirstInstance;
            Mutex theMutex =
                new Mutex(false, "Local\\" + Application.ProductName, out IsFirstInstance);
            string[] theActivationData =
                AppDomain.CurrentDomain.SetupInformation.ActivationArguments.ActivationData;

            if (IsFirstInstance)
            {
                IpcChannel theChannel =
                    new IpcChannel(Application.ProductName);

                try
                {
                    ChannelServices.RegisterChannel(theChannel, false);
                    RemotingServices.Marshal(this._MainView, "MainView");

                    this.MainView_Show();

                    this.ConsumeLaunchParameters(theActivationData);

                    Application.Run(this._AppContext);
                }
                catch (SocketException) { }
                finally
                {
                    ChannelServices.UnregisterChannel(theChannel);
                }
            }
            else
            {
                if (null != theActivationData &&
                    theActivationData.Length > 0)
                {
                    try
                    {
                        MainView theOriginalMainView =
                            (MainView)RemotingServices.Connect(
                                typeof(MainView),
                                "ipc://" + Application.ProductName + "/MainView");

                        theOriginalMainView.ConsumeArguments(theActivationData);
                    }
                    catch (SocketException) { }
                }
            }

            theMutex.Close();
            Application.Exit();

Since my app uses a centralised controller system, I had to add the following code to the MainView form to pass the arguments back to the controller:

        public void ConsumeArguments(
            string[] theArguments)
        {
            // Note that it is not allowed for non-UI thread to access
            // controls on the form, instead, we should use the Invoke method of the form
            // to execute a delegate on the UI thread that own's the control's underlying
            // windows handle.
            if (this.InvokeRequired)
            {
                this.Invoke(
                    new MethodCallback(ConsumeArguments),
                    new object[]
                        { theArguments });

                return;
            }
            else
            {
                if (null != this.ArgumentsConsumed)
                {
                    this.ArgumentsConsumed(theArguments);
                }
            }
        }

        public event MethodCallback ArgumentsConsumed;

        public delegate void MethodCallback(string[] args);

The console app has elevated privileges that are passed on to the re-launched ClickOnce app.

If I didn’t include this, the application would fail with (what I assumed was the first of many permissions errors) a registry access error. I decided to remove the UACLauncher and debug each error as it occurred. All my ClickOnce applications that require registry access to store settings store them in the LocalMachine hive. After googling the registry permission error, the main suggestion that came back was to move the settings to the CurrentUser hive.

Fair enough, but upon publishing the new version, there were no more errors. It seems that the only thing the app was doing that required administrator-level access was to attempt to write to the LocalMachine hive of the registry.

We’ve always liked Weather Underground for its no-nonsense, real-time weather info. Today they’ve released a new service called Full Screen Weather that mashes up Google Maps with weather data for nothing but maps and up-to-the-minute weather info.

[Via: Lifehacker]

Robots born with the sole purpose of solving the Rubik’s Cube are nothing new, but we’re pretty sure we haven’t seen one crack the code in under a dozen seconds before.

[Via: engadget]

What if you want to snap a window to the right edge of the primary monitor, or the left edge of the secondary monitor for that matter?

Well, thankfully, Aero Snap can also be utilised via the keyboard:

• Holding the Windows key down and tapping the left cursor key will cycle the current window from monitor edge to monitor edge anti-clockwise.

• Holding the Windows key down and tapping the right cursor key will cycle the current window from monitor edge to monitor edge clockwise.
• Holding the Windows key down and tapping the up cursor key will maximise the current window on the monitor which it is displayed.
• Holding the Windows key down and tapping the down cursor key will restore the current window if it is maximised and minimise it if it is restored.

Like prior versions of Windows, this is one of your options when right-clicking an item; it does what it says: it sends a copy of the object to the option you choose. The default choices with a normal right-click are the Desktop, a Zip folder, a fax or mail recipient, or any additional drives connected to your PC.

The How-To Geek offers an easy way to customize the default choices. Simply type “shell:sendto” (without the quotes) in the location bar of a Windows Explorer window. You’ll see the default choices here. Now you can pull any of the defaults out or you can add locations you want in the standard list with a simple drag-and-drop.

The couple I usually add are Notepad++ and BareTail for log file monitoring.

[Via: jkOnTheRun]

One of the cooler stories out (of) the whole Google-China debacle is that Google hacked the hackers.

[Via: Gizmodo]