w00t!

[Via: BT Plc.]

I’m using PHP to get each record. There isn’t much on the web about working with timestamp fields in PHP, so I created the function below to convert and store the OLToken as an integer:

function ConvertOLToken ($theToken)
{
   $OLToken = "";
   for ($i = 0; $i < strlen ($theToken); $i++)
   {
      $Byte = dechex (ord ($theToken[$i]));
      $OLToken .= str_pad ($Byte, 2, "0", STR_PAD_LEFT);
   }
   return hexdec($OLToken);
}

This value is passed back to stored procedures as an integer parameter and used in stored procedures:

IF EXISTS (
   SELECT 1
   FROM [Table]
   WHERE [ID] = @pID
      AND [OLToken] = CONVERT([binary](8), @pOLToken))
BEGIN
...
END

Through trial and error, I established the following works:

1. Add the following lines to wp-config.php:

   define('FS_METHOD', 'direct');
   define('FTP_BASE', '/public/');
   define('FTP_CONTENT_DIR', '/public/wp-content/');
   define('FTP_PLUGIN_DIR ', '/public/wp-content/plugins/');
   define('FTP_USER', '---your username---');
   define('FTP_HOST', 'ssh.phx.nearlyfreespeech.net:22');
   define('FTP_PASS', '---your password---');
   

2. Using PuTTY, log-in.
3. Enter the following command: chgrp -R web *. This will change the group ownership of all files and directories to web. This is the required ownership for WordPress to perform the upgrade.
4. Enter the following command: chmod -R 777 *. This will change the permissions on all files and directories to full public access.
5. Perform any WordPress upgrades; core, plugins or themes. It shouldn’t ask for any connection details.
6. Enter the following command: find . -type d -print0 | xargs -0 chmod 755. This will reset all directory permissions to read-only for everyone except the owner (you).
7. Enter the following command: find . -type f -print0 | xargs -0 chmod 644. This will reset all file permissions to read-only for everyone except the owner (you).
8. Enter the following command: chmod -R 775 wp-content. This will update the permissions on the wp-content directory to be 775, allowing uploads, including from the media library.

You only have to do steps 1 and 3 once. Steps 4 to 8 have to be performed for upgrade.

Although not essential, the last three steps should be performed, as it is highly insecure to leave permissions set as public (777).

Also using SSH rather than FTP conforms with the view of NearlyFreeSpeech.net that FTP should not be used as passwords are transferred in plaintext.

Thanks to SNARP for the original article.

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

[Via: ASP FAQ]

Nor did I say “‘Mon then! I’ll hae ye a’!”.

The service, having had some teething troubles, is now fully functional with availability 24 hours a day.

The transmission is fed from the desk at Arbroath Infirmary into a Barix Instreamer 100 (which is also used to trasmit the DAB service), and the streaming service itself is supplied by MixStream. A very big thanks to the guys on the service desk who provided some much need support.

This is the first streaming service I have set-up, so hopefully it will be well received.

It’s written using jQuery, which I’m thoroughly enjoying; as is another larger project that I’m working on.

More on that soon, but until then, have a look at the Bingo at let me know what you think…

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.