Pseudo formula:

// Acronyms used to save space.
New style.left = PCW+((E.X-PCX)-(MDX-PCX))
New style.top = PCH+((E.Y-PCY)-(MDY-PCY))

// PCW/PCH = Previous Container Width/Height.
// E.X/E.Y = Event X/Y.
// PCX/PCY = Previous Container Left/Top.
// MDX/MDY = Mouse Down X/Y (where you clicked).

With this formula you will resize the layer relative to where you clicked on it. An extended version of the movement formula. In effect it will take the existing width/height and add the amount of pixel movement as a positive or negative number.

My example, just view the source to see my code.

Pseudo formula:

New style.left = MovingMouseX-(PushedMouseX-PreviousStyleLeft)
New style.top = MovingMouseY-(PushedMouseY-PreviousStyleTop)

With this formula you will move the layer relative to where you clicked on it.

My example, just view the source to see my code.

IE would not recognize the session at all. IE did not block the cookies either, and I tested the SID constant thoroughly, it was not getting populated either.

The problem
In the same browser application I had open – just in another tab – I was logged into a HTTP AUTH session on another site, though under the same domain.

Of some reason IE seems to mix up the processes when opening up different tabs or windows through the same opened application. This way it doesn’t seem to properly keep track of which sessions belong to which processes.

The solution
Exit the IE application and start a new one. If I open up my session based website in the first tab, it works. It also works fine after opening the HTTP AUTH website in a second tab. But I don’t know how stable this is.

Just another IE annoyance…

The most logical place to look, is in:
wp-includes/js/tinymce/plugins/spellchecker/editor_plugin.js

Changes made there however doesn’t reflect in the administration editor. You also need to make changes in:
/wp-admin/includes/post.php

By default, spell checker uses the google gmail engine. This does not support the norwegian language in my case. So I changed over to the pspell engine. This is what I did to make that work for me:

(on the server, a debian box)
// Check first if you already have your language available.
#aspell dicts
-bash: aspell: command not found

// I did not, so I had to install it and make PHP support it as well.
#apt-get install aspell-no php5-pspell

// Reload the apache web server to reflect PHP update.
#/etc/init.d/apache2 reload

// Verify installation
#aspell dicts
nb
nn
no

... Looks good.

Next you change the engine in this file:
/wp-includes/js/tinymce/plugins/spellchecker/config.php

from: $config['general.engine'] = ‘GoogleSpell’;
to: $config['general.engine'] = ‘PSpell’;

That’s it.

How does it work?
A key is generated on the first page that also encrypts the string (or code if you want). The same key is used on the second page to decrypt it. Consider the functions below for more information. On the bottom you’ll find a test script to see the effect of the functions.

Generating a random string value in PHP (e.g a Captcha code):

function CreateRandomStringPHP() {
  $code = substr(str_shuffle('abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789'),0,5);
  return $code;
}

If you are using another language, consider using a function like this:

function CreateRandomString() {
  $Characters = array(
  'a','b','c','d','e','f','g','h','i','j','k','m','n','p','q','r','s','t','u','v','w','x','y','z',
  'A','B','C','D','E','F','G','H','J','K','L','M','N','P','Q','R','S','T','U','V','W','X','Y','Z',
  '2','3','4','5','6','7','8','9');

  $Code = '';
  for( $loop_b = 1; $loop_b <= 5; $loop_b++ ) {
    $Code .= $Characters[mt_rand(0,count($Characters)-1)];
  }

  return $Code;
}

Both of the above functions will generate a 5-length value. This will provide one value out of 550731776 possible combinations which should be enough for most needs.

The lock (or encrypt) function:

/*
  str LockCode(str $code, str $key)

  A codelock function (or encryption if you want).
  I wrote because I wanted a nice solution for keeping codes
  such as Captcha codes safe and secure for transferring between
  sites.

  It takes a $code of random length and locking $key as parameters.
  You'll need to use the same key to unlock it.

  The value this function returns, is simply a set of location
  coordinates in the key where the characters of the $code is found.
  This is again merged together with the lengths of every coordinate,
  since every coordinate can be 1 or 2 in length as long as the $key
  is under 100 characters in length (0-99).

  In the end, it should provide a safely locked $code, based on that
  you keep the $key hidden. Do NOT show it in your HTML. The key
  used in this example, with 56 alphanumeric characters where I have
  stripped out the following chars: 1, I, l, o, O and 0 (they are
  unpractical) has 7,9164324866862966607842406018063e+97
  combinations. This should be enough to keep the $code safe...
*/
function LockCode($code,$key) {
  $key_chars = str_split($key);
  $code_chars = str_split($code);
  $LockedKeyCoords = '';
  $LockedCoordLengths = '';

  foreach($code_chars as $c_char) {
    for($loop_a=0; $loop_a<count($key_chars); $loop_a++) {
      if($c_char==$key_chars[$loop_a]) {
        $LockedKeyCoords .= (string)$loop_a;
        $LockedCoordLengths .= (string)strlen($loop_a);
      }
    }
  }

  return $LockedKeyCoords . $LockedCoordLengths;
}

The unlock (or decrypt) function:

/*
  str UnlockCode(str $coords, str $key, int $keylength)

  The unlock function introduces a new parameter: $Keylength.
  This defines how many characters your $code was before you locked it.
*/
function UnlockCode($coords,$key,$keylength) {
  $key_chars = str_split($key);
  $keylengths = str_split(substr($coords,-$keylength));
  $UnlockedCode = '';

  foreach($keylengths as $length) {
    $UnlockedCode .= $key_chars[(int)substr($coords,0,(int)$length)];
    $coords = substr($coords,(int)$length);
  }

  return $UnlockedCode;
}

PHP code to test with:

/*
  The $Key MUST contain the characters you use to create the
  code with. Using the same string as you did to make the $Code
  with is a good choice. Generate a key on a standalone page,
  then use the same key on the page that locks the string, and
  on the page that unlocks the string.

  If you want a new random key every time you use the locking
  functions, you'll have to use a database system to store and
  retrieve them. And use sessions for identifying the keys. This
  would make a separate article, so I won't explain how to do it
  here.
*/
$Key = str_shuffle('abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789');

// Test it out.
$Code = CreateRandomStringPHP();
$LockedCode = LockCode($Code,$Key);
echo 'Key used: '. $Key .'<br><br>';
echo 'New code: '. $Code .'<br>';
echo 'Locked code: '. $LockedCode .'<br>';
echo 'Unlocked code: '. UnlockCode($LockedCode,$Key,5) .'<br><br>';
echo 'Reload this page to generate new results.';

The above testing code would produce something like this:

Key used: F7AYMQTscfHEPvSBXw5C3eWhj6kUxbn2ayrtGzNiqDV4m9ugJLKZpR8d

New code: c42yV
Locked code: 84331334212222
Unlocked code: c42yV

You can try it out yourself here (opens in a new window).

In my last article, I used the following code to create a random numeric value:

// 1000-9999 gives 5832 possibilies, strong enough for most captcha uses.
$VerificationCode = rand(1000, 9999);

You can use the following code instead to create a random alphanumeric value instead:

// This function will return a 5-length alphanumeric value.
// It will produce one out of 550731776 possible values.
function createCaptchaCode() {
  $stringChoices = array(
  'a','b','c','d','e','f','g','h','i','j','k','m','n','p','q','r','s','t','u','v','w','x','y','z',
  'A','B','C','D','E','F','G','H','J','K','L','M','N','P','Q','R','S','T','U','V','W','X','Y','Z',
  '2','3','4','5','6','7','8','9');

  $code = '';
  for( $loop_b = 1; $loop_b <= 5; $loop_b++ ) {
    $code .= $stringChoices[mt_rand(0,count($stringChoices)-1)];
  }
  return $code;
}

I suppose the above function could be written in PHP as simple as this:

function createCaptchaCode2() {
	$code = substr(str_shuffle('abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789'),0,5);
	return $code;
}

You might have noticed that the following characters are missing: 1, I, l, o, O and 0. This is to prevent unnecessary user frustration (they are very similar).

This covers how to generate a random alphanumeric value, what about encryption when you’re sending it between web pages? This subject is bigger than I thought it would be, so I’m going to make a new article on it.

You’ll find it here when it’s ready.

The idea is to send the actual answer to the other side, but with a simple encryption.

// First page variables.

// Create the random numeric code that a user/visitor will have to confirm it.
// 1000-9999 gives 5832 possibilies, strong enough for most captcha uses.
$VerificationCode = rand(1000, 9999);

// This is not a live example, so we’ll give $UserInput a manual value.
// In your own script, you would capture what the user had typed in.
$UserInput = ‘1234′;

// Create a key that only the other side will know.
// Send this key together with the answer the user provided.
$MySeed = 12345;
$VerificationKey = ($VerificationCode + ($MySeed*(int)date(‘d’)));

/*
The key is now made based on your custom value ($MySeed) that only YOU will know. To hack the key, the hacker would have to know it. AND would have to know what you do with it. In this example we keep it dynamic from day to day by multiplying it with the current day extracted from the current date. It’s easy to figure out something else that would be much harder to guess.

Now you send both $UserInput and $VerificationKey to the next page.
*/

// Second page variables and handling.

// This naturally has to match the value in page one.
$MySeed = 12345;

// Decrypt the key
$ReceivedKey = ((int)$VerificationKey – ($MySeed*(int)date(‘d’)));

// Now you can compare the user input with $ReceivedKey
$VerificationStatus = ((int)$UserInput==$ReceivedKey?true:false);

echo ($VerificationStatus?’Accepted’:'Not accepted’);

Representing the random code to the user
When you have created a random number and/or code you can represent it to your visitor like this: . Images are widely used to ask Captcha questions since they are binary with different random colors and shapes that’s hard to scan for a bot that’s scanning the Internet to collect or spam information.

Can I use your image script to show my random codes?
The image script I’ve used above takes a GET variable and prints it on a chosen image. It’s of no good use to anyone else other than an example, as it would be simple to just read the code right out of your source code for a spam-bot. So please make your own

Download your own copy WITH deciphering!
To make it easy for you, you can download the image script here and adapt it to your own needs. (This image script is adjusted to receive a key and view it dechiphered, adjust after your own needs. Bots will NOT be able to scan the code from THIS script, unless they know your way of encrypting the key).

You can try out the script here, and/or download it here.

Illustrational images:

I disabled this by adding the following to my wp-config file:

define(‘WP_POST_REVISIONS’,false);

To delete all the revisions you already have in your entire WordPress database, insert and run the following query in your DBMS:

DELETE FROM wp_posts WHERE post_type = ‘revision’

This will still keep your single autosave/draft.

An onclick event will work perfectly in Firefox, but when you try in Internet Explorer 7 (and maybe 6) it will seemingly bug out without any error or warnings at all.

Reason
This is simply because of how IE decides to “remember” visited links (the one you call in the AJAX function), and it simply don’t run your onclick event more than perhaps once per click.

I solved this by adding something I’d like to call a no-cache-seed to the url that will be unique for every click, forcing the browser to handle every event as a new URL. Then it worked perfectly.

The following javascript snippet will create a variable with the number of seconds since January 1, 1970. Needless to say it will always be different unless you demand reaction times under 1 millisecond which is unrealistic from a single user.

var currentTime = new Date();
var nocacheseed = currentTime.getTime();

Code in effect:
http://example.com/file.php?foo=1&bar=1&nocacheseed=

Reload the page to see how it is different every time.