Chris's Blog

Shift Space on a Dotnet Datagrid

2006-04-03T08:59:00.000-07:00

Microsoft have added some fairly dumb (IMO) features to the datagrid.
One of the worst is the one where if the user accidently has the SHIFT key down when they press the SPACE then the whole row is selected, and the user usually finishes up deleting everything they just typed.
The only work-round I have found is this.

You need to derive your own version of the datagrid:

public class MyDataGrid:System.Windows.Forms.DataGrid
{

// A couple of setup bits:
const int WM_KEYDOWN = 256;
[DllImport("user32.dll")]
public static extern int GetKeyboardState(ref Byte pbKeyState);
[DllImport("user32.dll")]
public static extern int SetKeyboardState(ref Byte pbKeyState);

// then override the 'ProcessCmdKey' method:
protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
{
Keys keyCode = ((Keys)msg.WParam.ToInt32()) & Keys.KeyCode;
if(msg.Msg == WM_KEYDOWN && keyCode == Keys.Space)
{
if (Control.ModifierKeys == Keys.Shift)
{
byte[] keystates = new byte[255];
GetKeyboardState(ref keystates[0]);
keystates[16] = 0;
SetKeyboardState(ref keystates[0]);
SendKeys.Send(" ");
return true;
}
}
return base.ProcessCmdKey (ref msg, keyData);
}

I don't much like this, seems like a bit of a bodge, but as is a lot to do with the datagrid it seems...
Anyway, it works, and now my user is a happy bunny once more :-)

Using Words SpellCheck in C# Application

2006-01-11T07:00:00.000-08:00

They wanted my Windows Form application to spell check some of the fields.
As I have control over all machines running the system, and I know that they all have MS Word installed, the simplest way is to use the Spell Checker already built into Word.
This was much easier than I thought it would be...
Before you start, you need to add a reference to the COM Object 'Microsoft Word 9.0 Object Library' (I guess it should work for other versions of Word, but this is the only one I've tried it with).

public string SpellCheck(string textToCheck)
{
if (textToCheck.Length ==0)
return; //No point in trying to spell check an empty string!
string returnText = textToCheck; //Default return text to original text.
object optional = System.Reflection.Missing.Value;
object dontSaveChanges = false;
Word._Document wd;
/Create a new Word Application Object.
Word.Application wa = new Word.ApplicationClass();
Word.ProofreadingErrors spellErrors;
wa.Visible = false;
//Create a new Document with the Word Application Object.
wd = wa.Documents.Add(ref optional,ref optional,ref optional,ref optional);
//We use the object optional to pass Null as it has to be passed by Reference(ref)
//Stuff the text to be checked into the new (blank) document.
wd.Words.First.InsertBefore(textToCheck);
//Get a list of all the spelling mistakes.
spellErrors = wd.SpellingErrors;
//If there ARE some mistakes...
if (spellErrors.Count > 0)
{
//Check the spelling. All the parameters are about which dictionary to use etc. They can be ignored.
wd.CheckSpelling(ref optional,ref optional,ref optional,ref optional,ref optional,ref optional,ref optional,ref optional,ref optional,ref optional,ref optional,ref optional);
object first=0;
object last=wd.Characters.Count -1;
//Suck the corrected text back out of the Word Document into the string to be returned.
returnText = wd.Range(ref first, ref last).Text;
//Have to declare things as objects as they need to be passed by ref.
}
else
{
MessageBox.Show("No Errors Found");
}
wa.Quit(ref dontSaveChanges,ref optional,ref optional);
//Can't just pass 'false' to this Quit method as it has to be sent by ref. Hence need to delcare an object.
return returnText;
}

Altering the behavior of TAB key

2006-01-06T04:06:00.000-08:00

Chris's Blog

It is sometimes necessary to alter the way the tab key works on a form (eg tabbing out of a particular textbox may move you to another screen rather than the next control).

In the form that contains the controls where the altered behavior is required:

protected override bool ProcessTabKey(bool forward)
{
if (this.ActiveControl = textBox1) //Assuming textBox1 is where you require the altered effect
{
DoDifferentStuff();
return true;
}
else
{
return base.ProcessTabKey(forward); // carry on as normal
}
}

the forward parameter is true if you are tabbing forwards through the form (false for Shift-Tab). So you can alter the behavior in one direction only.

System Tray Icons and Balloon Popups

2005-12-22T04:15:00.000-08:00

Wanted to write a little status application that ran hidden, and only made itself know when somthing happened.
Best way seemed to be an app that ran with a hidden window and an icon that sat in the System Tray.

Putting somthing in the System Tray is very simple in DotNet, you just instantiate an instance of the 'NotifyIcon' class.
NotifyIcon ni = new NotifyIcon();

You can set the icon that is displayed with the ni.Icon property. Change the pop-up text associated with it with the ni.Text property. You can also assign a Context menu to it so that you can control program functions via the icon without needing to see the actual app window.

Next I thought it would be nice if you got a little Balloon Message to draw attention if somthing changed... not so easy. A little research turned up the following code which does make the implementation of this pretty straightforward.

First you need a few references to the API:

[DllImport("shell32.Dll")]
public static extern System.Int32 Shell_NotifyIcon(NotifyCommand cmd,
ref NotifyIconData data);

[DllImport("Kernel32.Dll")]
public static extern System.UInt32 GetCurrentThreadId();

public delegate System.Int32 EnumThreadWndProc(System.IntPtr hWnd,
System.UInt32 lParam);

[DllImport("user32.Dll")]
public static extern System.Int32 EnumThreadWindows(System.UInt32
threadId, EnumThreadWndProc callback, System.UInt32 param);

[DllImport("user32.Dll")]
public static extern System.Int32 GetClassName(System.IntPtr hWnd,
System.Text.StringBuilder className, System.Int32 maxCount);

** DllImport belongs to the 'System.Runtime.InteropServices' namespace.

Then you need to declare a Structure for the NotifyIconData:

public struct NotifyIconData
{
public System.UInt32 cbSize; // DWORD
public System.IntPtr hWnd; // HWND
public System.UInt32 uID; // UINT
public NotifyFlags uFlags; // UINT
public System.UInt32 uCallbackMessage; // UINT
public System.IntPtr hIcon; // HICON
[MarshalAs(UnmanagedType.ByValTStr, SizeConst=128)]
public System.String szTip; // char[128]
public System.UInt32 dwState; // DWORD
public System.UInt32 dwStateMask; // DWORD
[MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]
public System.String szInfo; // char[256]
public System.UInt32 uTimeoutOrVersion; // UINT
[MarshalAs(UnmanagedType.ByValTStr, SizeConst=64)]
public System.String szInfoTitle; // char[64]
public System.UInt32 dwInfoFlags; // DWORD
}

Next a little Method to get the current system version info:

And finally the actual display balloon method itself:

public void ShowBalloon(uint uintIconID, string strTitle, string
strText, uint uintTimeout)
{
try
{
bool blnVersionOk = false;
blnVersionOk = this.GetShell32VersionInfo() >= 5;
if(blnVersionOk)
{
// get the current thread ID
uint uintThreadId = GetCurrentThreadId();

Type objType= ni.GetType();

IntPtr intPtrWindow =
((NativeWindow)objType.GetField("window",System.Reflection.BindingFlags.Instance
|
System.Reflection.BindingFlags.NonPublic).GetValue(ni)).Handle;
int intID
=(int)objType.GetField("id",System.Reflection.BindingFlags.Instance |
System.Reflection.BindingFlags.NonPublic).GetValue(ni);

// show the balloon
NotifyIconData objData = new NotifyIconData();
objData.cbSize =
(System.UInt32)System.Runtime.InteropServices.Marshal.SizeOf(typeof(NotifyIconData));
objData.hWnd = intPtrWindow;
objData.uID = (UInt32)intID;
objData.uFlags = NotifyFlags.Info;
//objData.uTimeoutOrVersion =uintTimeout;
objData.uTimeoutOrVersion =NOTIFYICON_VERSION ;
objData.szInfo = strText;
objData.szInfoTitle = strTitle;
int q=Shell_NotifyIcon(NotifyCommand.SetVersion,ref objData);
int k=Shell_NotifyIcon(NotifyCommand.Modify, ref objData);
//MessageBox.Show(q.ToString()+k.ToString());
}
}
catch(Exception objException)
{
throw new ApplicationException(objException.Message);
}
}

Then when required, you simply use the ShowBalloon(uint IconId, string BalloonTitle, string BalloonText, unit Timeout)
and the balloon will pop up next to the NotifyIcon.
This is where I found the original code:
http://www.hightechtalks.com/archive/index.php/t-2217576-notify-icon-n-balloon-tip-help-urgent.html

No guarantees on robustness!! it's not even my code(which is probably a good thing...), but it seems to work, and as it is only a tool running on my own computer, it's good enough for me!

Cheers!

Using Winzip from the command line

2005-12-20T09:52:00.000-08:00

Below is some information about the undocumented command line options for using the WinZip program module, winzip32.exe.

WinZip supports command line options to add and extract from files. Be sure to read the Notes section below for additional important information.

Adding Files
The command format is:

winzip32 [-min] action [options] filename[.zip] files

where:
-min specifies that WinZip should run minimized. If -min is specified, it must be the first command line parameter.

action
-a for add, -f for freshen, -u for update, and -m for move. You must specify one (and only one) of these actions. The actions correspond to the actions described in the section titled "Add dialog box options" in the online manual.

options
-r corresponds to the Include subfolders checkbox in the Add dialog and causes WinZip to add files from subfolders. Folder information is stored for files added from subfolders. If you add -p, WinZip will store folder information for all files added, not just for files from subfolders; the folder information will begin with the folder specified on the command line.

-ex, -en, -ef, -es, and -e0 determine the compression method: eXtra, Normal, Fast, Super fast, and no compression. The default is "Normal". -hs includes hidden and system files. Use -sPassword to specify a case-sensitive password. The password can be enclosed in quotes, for example, -s"Secret Password".

filename.zip
Specifies the name of the Zip file involved. Be sure to use the full filename (including the folder).

files
Is a list of one or more files, or the @ character followed by the filename containing a list of files to add, one filename per line. Wildcards (e.g. *.bak) are allowed.

Extracting Files
The command format is:

winzip32 -e [options] filename[.zip] folder
where -e is required.
options
-o and -j stand for "Overwrite existing files without prompting" and "Junk pathnames", respectively. Unless -j is specified, folder information is used. Use -sPassword to specify a case-sensitive password. The password can be enclosed in quotes, for example, -s"Secret Password".

filename.zip
Specifies the name of the Zip file involved. Be sure to specify the full filename (including the folder).

folder
Is the name of the folder to which the files are extracted. If the folder does not exist it is created.

Notes
VERY IMPORTANT: always specify complete filenames, including the full folder name and drive letter, for all file IDs.

To run WinZip in a minimized inactive icon use the "-min" option. When specified this option must be the first option.

Only operations involving the built-in zip and unzip are supported.

Enclose long filenames in quotes.

When using a list ("@") file, no leading or trailing spaces should appear in file IDs in the list.

The action and each option must be separated by at least one space.

WinZip can be used to compress files with cc:Mail . Change the compress= line in the [cc:Mail] section of the appropriate WMAIL.INI files to specify the full path for WinZip followed by "-a %1 @%2". For example, if WinZip is installed in your c:\winzip folder, specify
compress=c:\winzip\winzip.exe -a %1 @%2

Syntax Errors in SQL - Check for Reserved Words

2005-12-15T04:24:00.000-08:00

After spending the best part of an hour trying to workout what was wrong with my query... when trying to update the dataset, I kept getting a 'Syntax Error' message.
Turns out one of the fields in my table was 'Password' which of course is a reserved word... Doh!!!

Dot Net Encryption

2005-12-15T01:45:00.000-08:00

Looking for a safer way to store some passwords in the database than just using plain text, I came across this class which makes use to the built in DotNet Cryptography classes.

using System;
using System.IO;
using System.Security.Cryptography;

namespace APTS
{
///

/// Summary description for EncDec.
///

public class EncDec
{
// Encrypt a byte array into a byte array using a key and an IV
public static byte[] Encrypt(byte[] clearData, byte[] Key, byte[] IV)
{
// Create a MemoryStream to accept the encrypted bytes
MemoryStream ms = new MemoryStream();

// Create a symmetric algorithm.
// We are going to use Rijndael because it is strong and
// available on all platforms.
// You can use other algorithms, to do so substitute the
// next line with something like
// TripleDES alg = TripleDES.Create();
Rijndael alg = Rijndael.Create();

// Now set the key and the IV.
// We need the IV (Initialization Vector) because
// the algorithm is operating in its default
// mode called CBC (Cipher Block Chaining).
// The IV is XORed with the first block (8 byte)
// of the data before it is encrypted, and then each
// encrypted block is XORed with the
// following block of plaintext.
// This is done to make encryption more secure.

// There is also a mode called ECB which does not need an IV,
// but it is much less secure.
alg.Key = Key;
alg.IV = IV;

// Create a CryptoStream through which we are going to be
// pumping our data.
// CryptoStreamMode.Write means that we are going to be
// writing data to the stream and the output will be written
// in the MemoryStream we have provided.
CryptoStream cs = new CryptoStream(ms,
alg.CreateEncryptor(), CryptoStreamMode.Write);

// Write the data and make it do the encryption
cs.Write(clearData, 0, clearData.Length);

// Close the crypto stream (or do FlushFinalBlock).
// This will tell it that we have done our encryption and
// there is no more data coming in,
// and it is now a good time to apply the padding and
// finalize the encryption process.
cs.Close();

// Now get the encrypted data from the MemoryStream.
// Some people make a mistake of using GetBuffer() here,
// which is not the right way.
byte[] encryptedData = ms.ToArray();

return encryptedData;
}

// Encrypt a string into a string using a password
// Uses Encrypt(byte[], byte[], byte[])

public static string Encrypt(string clearText, string Password)
{
// First we need to turn the input string into a byte array.
byte[] clearBytes =
System.Text.Encoding.Unicode.GetBytes(clearText);

// Then, we need to turn the password into Key and IV
// We are using salt to make it harder to guess our key
// using a dictionary attack -
// trying to guess a password by enumerating all possible words.
PasswordDeriveBytes pdb = new PasswordDeriveBytes(Password,
new byte[] {0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d,
0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76});

// Now get the key/IV and do the encryption using the
// function that accepts byte arrays.
// Using PasswordDeriveBytes object we are first getting
// 32 bytes for the Key
// (the default Rijndael key length is 256bit = 32bytes)
// and then 16 bytes for the IV.
// IV should always be the block size, which is by default
// 16 bytes (128 bit) for Rijndael.
// If you are using DES/TripleDES/RC2 the block size is
// 8 bytes and so should be the IV size.
// You can also read KeySize/BlockSize properties off
// the algorithm to find out the sizes.
byte[] encryptedData = Encrypt(clearBytes,
pdb.GetBytes(32), pdb.GetBytes(16));

// Now we need to turn the resulting byte array into a string.
// A common mistake would be to use an Encoding class for that.
//It does not work because not all byte values can be
// represented by characters.
// We are going to be using Base64 encoding that is designed
//exactly for what we are trying to do.
return Convert.ToBase64String(encryptedData);

}

// Encrypt bytes into bytes using a password
// Uses Encrypt(byte[], byte[], byte[])

public static byte[] Encrypt(byte[] clearData, string Password)
{
// We need to turn the password into Key and IV.
// We are using salt to make it harder to guess our key
// using a dictionary attack -
// trying to guess a password by enumerating all possible words.
PasswordDeriveBytes pdb = new PasswordDeriveBytes(Password,
new byte[] {0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d,
0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76});

// Now get the key/IV and do the encryption using the function
// that accepts byte arrays.
// Using PasswordDeriveBytes object we are first getting
// 32 bytes for the Key
// (the default Rijndael key length is 256bit = 32bytes)
// and then 16 bytes for the IV.
// IV should always be the block size, which is by default
// 16 bytes (128 bit) for Rijndael.
// If you are using DES/TripleDES/RC2 the block size is 8
// bytes and so should be the IV size.
// You can also read KeySize/BlockSize properties off the
// algorithm to find out the sizes.
return Encrypt(clearData, pdb.GetBytes(32), pdb.GetBytes(16));

}

// Decrypt a byte array into a byte array using a key and an IV
public static byte[] Decrypt(byte[] cipherData,
byte[] Key, byte[] IV)
{
// Create a MemoryStream that is going to accept the
// decrypted bytes
MemoryStream ms = new MemoryStream();

// Create a symmetric algorithm.
// We are going to use Rijndael because it is strong and
// available on all platforms.
// You can use other algorithms, to do so substitute the next
// line with something like
// TripleDES alg = TripleDES.Create();
Rijndael alg = Rijndael.Create();

// Now set the key and the IV.
// We need the IV (Initialization Vector) because the algorithm
// is operating in its default
// mode called CBC (Cipher Block Chaining). The IV is XORed with
// the first block (8 byte)
// of the data after it is decrypted, and then each decrypted
// block is XORed with the previous
// cipher block. This is done to make encryption more secure.
// There is also a mode called ECB which does not need an IV,
// but it is much less secure.
alg.Key = Key;
alg.IV = IV;

// Create a CryptoStream through which we are going to be
// pumping our data.
// CryptoStreamMode.Write means that we are going to be
// writing data to the stream
// and the output will be written in the MemoryStream
// we have provided.
CryptoStream cs = new CryptoStream(ms,
alg.CreateDecryptor(), CryptoStreamMode.Write);

// Write the data and make it do the decryption
cs.Write(cipherData, 0, cipherData.Length);

// Close the crypto stream (or do FlushFinalBlock).
// This will tell it that we have done our decryption
// and there is no more data coming in,
// and it is now a good time to remove the padding
// and finalize the decryption process.
cs.Close();

// Now get the decrypted data from the MemoryStream.
// Some people make a mistake of using GetBuffer() here,
// which is not the right way.
byte[] decryptedData = ms.ToArray();

return decryptedData;
}

// Decrypt a string into a string using a password
// Uses Decrypt(byte[], byte[], byte[])

public static string Decrypt(string cipherText, string Password)
{
// First we need to turn the input string into a byte array.
// We presume that Base64 encoding was used
byte[] cipherBytes = Convert.FromBase64String(cipherText);

// Then, we need to turn the password into Key and IV
// We are using salt to make it harder to guess our key
// using a dictionary attack -
// trying to guess a password by enumerating all possible words.
PasswordDeriveBytes pdb = new PasswordDeriveBytes(Password,
new byte[] {0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65,
0x64, 0x76, 0x65, 0x64, 0x65, 0x76});

// Now get the key/IV and do the decryption using
// the function that accepts byte arrays.
// Using PasswordDeriveBytes object we are first
// getting 32 bytes for the Key
// (the default Rijndael key length is 256bit = 32bytes)
// and then 16 bytes for the IV.
// IV should always be the block size, which is by
// default 16 bytes (128 bit) for Rijndael.
// If you are using DES/TripleDES/RC2 the block size is
// 8 bytes and so should be the IV size.
// You can also read KeySize/BlockSize properties off
// the algorithm to find out the sizes.
byte[] decryptedData = Decrypt(cipherBytes,
pdb.GetBytes(32), pdb.GetBytes(16));

// Now we need to turn the resulting byte array into a string.
// A common mistake would be to use an Encoding class for that.
// It does not work
// because not all byte values can be represented by characters.
// We are going to be using Base64 encoding that is
// designed exactly for what we are trying to do.
return System.Text.Encoding.Unicode.GetString(decryptedData);
}

// Decrypt bytes into bytes using a password
// Uses Decrypt(byte[], byte[], byte[])

public static byte[] Decrypt(byte[] cipherData, string Password)
{
// We need to turn the password into Key and IV.
// We are using salt to make it harder to guess our key
// using a dictionary attack -
// trying to guess a password by enumerating all possible words.
PasswordDeriveBytes pdb = new PasswordDeriveBytes(Password,
new byte[] {0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d,
0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76});

// Now get the key/IV and do the Decryption using the
//function that accepts byte arrays.
// Using PasswordDeriveBytes object we are first getting
// 32 bytes for the Key
// (the default Rijndael key length is 256bit = 32bytes)
// and then 16 bytes for the IV.
// IV should always be the block size, which is by default
// 16 bytes (128 bit) for Rijndael.
// If you are using DES/TripleDES/RC2 the block size is
// 8 bytes and so should be the IV size.

// You can also read KeySize/BlockSize properties off the
// algorithm to find out the sizes.
return Decrypt(cipherData, pdb.GetBytes(32), pdb.GetBytes(16));
}
}
}

Changing the clock/info bulbs in Vauxhall Astra

2005-12-13T05:54:00.000-08:00

Came across this while looking for somthing totally different. But I may well need to do this sometime, so might as well remember it...

To replace your info display bulb just lift out the rubber mat below it and undo the screws. It will now pull forward and out. Two second job,replace both bulbs in it.

Two State WinForm

2005-12-09T07:18:00.000-08:00

OK, so I wanted a form that would let you fill in the upper half of the form (say a Booking in ref and some header details) then when TAB or ENTER is pressed in the last field of the header items, switch to the lower half to allow entry of all items in that batch.

Need:
integer to contain current state of the form (0 or 1 in this case, so could be a bool, but may want a third or more state in the future, so int makes more sense (I think))

A private property on the form (formState) and a simple Method is used to select the state that is required, then call the Method to make that state 'active':

private void SetFormState(int newState)
{
if (newState == formState)
return;
if (formState == 0)
formState = 1;
else
formState = 0;
DoFormState();
}

The main difference between states is which controls on the form are active. This is handled by a simple Switch like this:

private void DoFormState()
{
switch(formState)
{
case 0:
{
txtBatchId.Enabled = true;
dteBookedDate.Enabled = true;
txtLinePrice.Enabled = false;
txtLinePrice.Text = "";
txtLineQty.Enabled = false;
txtLineQty.Text = "";
txtPartNumber.Enabled = false;
txtPartNumber.Text = "";
cmdAddToBatch.Enabled = false;
break;
}
case 1:
{
txtPartNumber.Enabled = true;
txtLineQty.Enabled = true;
txtLinePrice.Enabled = true;
cmdAddToBatch.Enabled = true;
dteBookedDate.Enabled = false;
txtPartNumber.Enabled = true;
txtBatchId.Enabled = false;
dteBookedDate.Enabled = false;
break;
}
}
}

To detect when to switch to the second state, initially, just trapped OnLeave event of BookingInRef textbox, but that isn't really good enough as if you mouse-click out of the box or do a Shift-TAB (most likely going back to change an earlier box in the upper-header screen), you may not want to switch states when you leave the BookingInRef box..

Next looked at KeyUp/KeyDown events, but no good as TAB key doesn't show up here, or if it does, the Form has already used it to move to the next control on the form.

Finaly result seemed to be to override ProcessDialogKey event on the form thus:

protected override bool ProcessDialogKey(Keys keyData)
{
if (keyData == Keys.Tab && keyData !=Keys.Shift)
{
if (this.ActiveControl.Name == "txtBatchId")
{
SetFormState(1);
return true;
}
}
return base.ProcessDialogKey(keyData);
}

So if a TAB key is pressed and the SHIFT key is not down and the focus is on the BookingIn reference textbox then we switch the form into the other state. Otherwise we process the DialogKey as normal.

To catch ENTER which was also required to switch states is far simpler. I caught the KeyDown event in the TextBox thus:

private void txtBatchId_KeyDown(object sender, System.Windows.Forms.KeyEventArgs e)
{
if (e.KeyCode == Keys.Enter)
SetFormState(1);
}

Finally to finish off, I caught the ESCAPE key on the form and either moved back to the previous state, or if already in the initial state, leave the form:

private void frmBatchCommercial_KeyUp(object sender, System.Windows.Forms.KeyEventArgs e)
{
if (e.KeyCode == Keys.Escape)
{
if (formState == 1)
SetFormState(0);
else
this.Close();
}
}

NOTE: For that to work, needed to set KeyPreview property of Form to True so that it gets a go at any keys pressed before the controls on the form.

Mobile Blog

2005-11-25T06:10:00.000-08:00

Posted an entry from my mobile... This is clever :-)

From email

2005-11-25T05:56:00.000-08:00

Added a post from my email

Well here we are then

2005-11-25T05:11:00.000-08:00

This is the first posting in my new Blog. No idea quite what I'm going to put here, but might be a good place to jot this and that from time to time...
At the moment, I intend to use it kind of like a notepad to make a note of stuff I find out.

Not sure how often I will post stuff here. If it's anything like my diaries when I was younger, probably not very often... ;-)