Post your CTRL+V.

[Deity]

Here is mine!
http://localhost/test.php

[AceInfinity]

Lighting Control Systems Programming - D3 Pro

[playzzzz]

Here is mine: Jesse Labrocca
Don't know who it is

---

EDIT: my know one: http://www.myspace.com/labrocca/photos/7...3A13787306}
Don't hate

[Grin]

This thread is aimed towards those interested in the art of lucid dreaming

For those not aware of lucid dreaming (being able to control your dreams) I've come here to inform and educate. 

What lucid dreaming basically is, is being able to control your dreams and in those controlled dreams - being able to do anything you could possibly ever want to do. The possibilities are endless. You can fly, talk to deceased relatives/friends, climb mountains, everything really. So since I have nothing else to do, I'll be informing, helping, and encouraging those who actually try this out (everyone should be doing this lmao). In this thread, I'll be giving my methods, tips, and tricks as to how to lucid dream. So let's get started!

Basic Information

As I've stated above, the most basic definition of lucid dreaming is being able to control and contort your dreams into anything you desire. With determination, practice and resilience; you will be successful (as with life). Before I get into the logistics of what lucid dreaming actually is, allow me to explain the brain functions when you're sleeping. Usually, it takes like what? 30-45 minutes to fall asleep (for me anyways)? During this process, you probably have noticed many unusual things happen. For instance, you know those sometimes bright lights behind your closed eyelids? That's called Hypnagogia Imagery. It's your brains way of sending signals to the optic nerves of your eyes already trying to form a dream. How about weird noises or even voices when you're trying to fall asleep? This is your brains way of trying to figure out if you're actually asleep or not. You might hear voices of laughter, taunting, or just general chatter but you know it's something. You might hear your doorbell, a knock at the door or something of the sort (your brain be trolin). Now, lucid dreaming isn't a one night thing. I wish I could tell you that by the end of this thread, you will will able to go to bed tonight and lucid dream instantly. It doesn't work that way and never has. But, sometime in your life, you've probably already lucid dreamed and not know it. At night when we all fall asleep, despite some people's opinions, you dream constantly throughout the night. Every single minute/second/hour you're dreaming. Some people say they don't dream - no, they dream but they just have bad dream recall (or a certain section of their brain is malfunctioned [srs]). The only reason we don't remember all of our dreams is because the only time we actually recollect in depth is when we just woke up either in the middle or right after a dream. We have peaks when we are in a deep sleep or a weak sleep. Usually 4-5 hours into the night is when we're in our deepest, and gradually when the hours progress - we go less and less into a deep sleep. 

Reality Checks, Dream Recall, and Dream Journals


In this section, I'll be covering reality checks, dream recall and dream journals.

Firstly, reality checks are little signals you give yourself on a daily basis to remind yourself that you're not sleeping. It may sound stupid but just make it a habit. What this does is if you make it a daily ritual and a habit, your dream self will, in turn, do it without thinking. Let's say you have a watch, and your watch is set to beep every hour. Once it beeps, ask yourself out loud "Am I dreaming?" Keeping your watch next to you when you sleep, once you hear that beep, your dream self will ask himself if he's dreaming and boom. Your brain recognizes the signal and you'll realize you're dreaming. It sounds weird but it works and it a definite method with nothing but positive benefits. 

Dream recall is basically the ability to remember your dreams. People have good dream recall, some have bad. If you don't remember half your dreams every night, don't worry - in due time you can enhance your dream recall and make it better. To make it better, you have to at least try to remember any little insignificant detail about a dream you had just woken up from and write it down. Sometimes you'll remember, sometimes you won't.

Dream journals are what will makes you successful in lucidity. What dream journals are is basically you writing down whatever dream you had that night. Every little detail, every little everything. What was it like? was the son bright? was it dark? were there people around you? if so what were they talking about/doing? etc. doing this will not only enhance and build up your dream recall (seen above) but it will (somehow) help with lucid dreaming. I'm not exactly filled in on the facts on why it helps, but it's been proven. Can't argue with results. You don't have to write them down, but it's whatever. It won't hurt to try. 

Lucid Dreaming Information

Again, successful lucid dreaming tactics require determination and and perseverance (and practice). You won't lucid dream tonight but like with anything to get better, try and try again - keep at it. Now, there are many ways to lucid dream. But, since I'm the one spreading knowledge; I'm going to explain the method I've used for a couple of years. Before going to bed tonight, or whenever you crazy kids go to bed nowadays, I highly suggest meditating for even 10-15 minutes just to clear your mind and put yourself in a calming state. It may seem weird and freakin stupid but trust me son, it's some deep ass crap. So, tonight after you've meditated (if you did) and cleared your mind, hop into bed. Get in a relaxing position and be prepared to stay in that position for awhile. Make sure you have everything set, you're comfortable; once that's good, you're ready to begin. Once you started the process, you CAN NOT MOVE A MUSCLE AT ALL. The reason being is because you're tricking your brain into thinking you're sleeping. That's when the brain starts throwing some trickery at you to fool you. The most common one is feeling the uncontrollable urge to switch sides and move around. Like I said, you can't move a muscle. Through the process, weird things will begin to happen. Your arms will feel as if they're floating or just cut off and gone (normal). You will begin to see more Hypnagogia Imagery as the night progresses. Keeping still and relaxing, slowly trying to fall asleep, you'll begin to notice shapely figures that you recognize (i.e cars, landscapes, your room, a house etc). This means that you're very close and need to keep doing this crap. You're close into crossing lucidity. But, yes but, before you cross you will have to deal with Sleep Paralysis. SP is (basically) the shutting down of your muscles (you can't move your head, hands, arms, legs, feet etc). If you have to experience this (98% of you will) you will need to relax and calm down. Because you will also experience hallucination (things that are not there). Generally speaking, all hallucinations are terrifying to go through. Because - when you're sleeping at night, what do you associate dark with? evil, right? So your brain makes that connection and you'll be seeing demented crap everywhere. The worst case scenario is you waking up. Nothing can happen and nothing will happen. It's a figment of your imagination. Nothing more. All you need to do is stick through it, RELAX YOUR PUSSY ASS, and know you're literally a couple seconds/minutes away from lucid dreaming. So yes, once you experience this scar-for-life encounter, if you haven't woken up, you'll be lucid dreaming. Look around your room/shack/shanty or whatever you're in right now. When you're lucid dreaming - it feels just like that except 100x more vibrant and amazing. You can walk, talk, eat, drink, run, jump, throw, fudge, kill. It's a free-for-all. You control it. However, since it's your first night, you won't last five minutes. Sorry but that's the truth. Once you've successfully lucid dreamed, you'll be filled with excitement that you'll end up waking yourself up. It's unavoidable unless you go in there with a sense of poise. Because really, you need to set your mind on the goal for that night - YOU'VE COME TO LUCID DREAM. But to avoid this pitfall, just relax a bit and look around the world you're inside. Go outside, feel the grass, breathe in the fresh air. Look up at the birds, see the people walking by. Do anything to relax yourself knowing that limits is just a word. If you feel yourself losing lucidity, here's a couple of things to keep you inside: spin in a circle, rub your hands together, jump up. These keep you hooked onto your lucidity because all of your focus is being put onto doing one task (instead of your mind wandering to different places). 

Misc. eBooks, Tools and Websites About Lucid Dreaming


I have over fifty eBooks on lucid dreaming that I've collected for awhile. They contain work from many scientists of the study (such as LeBerge, Allan Wallace, Charles Tart and so on). I also have a lucid dreaming binaural beat I found awhile back (click here for information.) Both the eBooks and binaural beat can be attained by simply PMing me and asking for them. Simple as that.

http://www.world-of-lucid-dreaming.com/i...aming.html
http://www.lucidity.com/
http://www.dreamviews.com/content/what-l...eaming-16/

I'll be updating this thread daily with information I left out or information I feel the need to be added.

[Uzi]

My currently copied item is this..

"[font=Tahoma]"

I always use the Tahoma font, and it's much quicker if I paste it using 'CTRL+V'.

[Monetize™]

www.google.com/url?sa=t&rct=j&q=trash can forum (3.0)&source=web&cd=1&sqi=2&ved=0CGwQFjAA&url=http://www.phpbb.com/community/viewtopic.php?t=571551&ei=Yd66T562BsqagwfJneHICg&usg=AFQjCNFe2PYzxsMHl0veeKlAOpgUm20BHw&sig2=Pdo4EhZYGxyBGTr5yDF3gQ

[Diabolic]

My CTRL+V:
dsafdsfsdfsdvgsdfgvsvrwgvdsvgfdv


Was spamming a friend lol.

[Toxic Injection]

How do i setup this freakin program

[Grin]

http://www.hackforums.net/forumdisplay.php?fid=137

Whoops...

[Mercury]

using System;
using System.IO;
using System.Drawing;
using System.Diagnostics;
using System.Windows.Forms;
using System.ComponentModel;
using Microsoft.VisualBasic;
using System.Drawing.Imaging;
using System.Drawing.Drawing2D;
using System.Collections.Generic;
using System.ComponentModel.Design;
using System.Runtime.InteropServices;

//---------/CREDITS/-----------
//
//Themebase creator: Aeonhack
//Site: elitevs.net
//Created: 08/02/2011
//Changed: 12/06/2011
//Version: 1.5.4
//
//Theme creator: Mavamaarten
//Created: 9/12/2011
//Changed: 3/03/2012
//Version: 2.0
//
//Thanks to Tedd for helping
//with combobox & tabcontrol!
//
//Converted to C# by: Ethernal Five
//On: 3/04/2012
//--------/CREDITS/------------

#region "THEMEBASE"
abstract class ThemeContainer154 : ContainerControl
{

#region " Initialization "

protected Graphics G;

protected Bitmap B;
public ThemeContainer154()
{
SetStyle((ControlStyles)139270, true);

_ImageSize = Size.Empty;
Font = new Font("Verdana", 8);

MeasureBitmap = new Bitmap(1, 1);
MeasureGraphics = Graphics.FromImage(MeasureBitmap);

DrawRadialPath = new GraphicsPath();

InvalidateCustimization();
}

protected override sealed void OnHandleCreated(EventArgs e)
{
if (DoneCreation)
InitializeMessages();

InvalidateCustimization();
ColorHook();

if (!(_LockWidth == 0))
Width = _LockWidth;
if (!(_LockHeight == 0))
Height = _LockHeight;
if (!_ControlMode)
base.Dock = DockStyle.Fill;

Transparent = _Transparent;
if (_Transparent && _BackColor)
BackColor = Color.Transparent;

base.OnHandleCreated(e);
}

private bool DoneCreation;
protected override sealed void OnParentChanged(EventArgs e)
{
base.OnParentChanged(e);

if (Parent == null)
return;
_IsParentForm = Parent is Form;

if (!_ControlMode)
{
InitializeMessages();

if (_IsParentForm)
{
ParentForm.FormBorderStyle = _BorderStyle;
ParentForm.TransparencyKey = _TransparencyKey;

if (!DesignMode)
{
ParentForm.Shown += FormShown;
}
}

Parent.BackColor = BackColor;
}

OnCreation();
DoneCreation = true;
InvalidateTimer();
}

#endregion

private void DoAnimation(bool i)
{
OnAnimation();
if (i)
Invalidate();
}

protected override sealed void OnPaint(PaintEventArgs e)
{
if (Width == 0 || Height == 0)
return;

if (_Transparent && _ControlMode)
{
PaintHook();
e.Graphics.DrawImage(B, 0, 0);
}
else
{
G = e.Graphics;
PaintHook();
}
}

protected override void OnHandleDestroyed(EventArgs e)
{
ThemeShare.RemoveAnimationCallback(DoAnimation);
base.OnHandleDestroyed(e);
}

private bool HasShown;
private void FormShown(object sender, EventArgs e)
{
if (_ControlMode || HasShown)
return;

if (_StartPosition == FormStartPosition.CenterParent || _StartPosition == FormStartPosition.CenterScreen)
{
Rectangle SB = Screen.PrimaryScreen.Bounds;
Rectangle CB = ParentForm.Bounds;
ParentForm.Location = new Point(SB.Width / 2 - CB.Width / 2, SB.Height / 2 - CB.Width / 2);
}

HasShown = true;
}


#region " Size Handling "

private Rectangle Frame;
protected override sealed void OnSizeChanged(EventArgs e)
{
if (_Movable && !_ControlMode)
{
Frame = new Rectangle(7, 7, Width - 14, _Header - 7);
}

InvalidateBitmap();
Invalidate();

base.OnSizeChanged(e);
}

protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified)
{
if (!(_LockWidth == 0))
width = _LockWidth;
if (!(_LockHeight == 0))
height = _LockHeight;
base.SetBoundsCore(x, y, width, height, specified);
}

#endregion

#region " State Handling "

protected MouseState State;
private void SetState(MouseState current)
{
State = current;
Invalidate();
}

protected override void OnMouseMove(MouseEventArgs e)
{
if (!(_IsParentForm && ParentForm.WindowState == FormWindowState.Maximized))
{
if (_Sizable && !_ControlMode)
InvalidateMouse();
}

base.OnMouseMove(e);
}

protected override void OnEnabledChanged(EventArgs e)
{
if (Enabled)
SetState(MouseState.None);
else
SetState(MouseState.Block);
base.OnEnabledChanged(e);
}

protected override void OnMouseEnter(EventArgs e)
{
SetState(MouseState.Over);
base.OnMouseEnter(e);
}

protected override void OnMouseUp(MouseEventArgs e)
{
SetState(MouseState.Over);
base.OnMouseUp(e);
}

protected override void OnMouseLeave(EventArgs e)
{
SetState(MouseState.None);

if (GetChildAtPoint(PointToClient(MousePosition)) != null)
{
if (_Sizable && !_ControlMode)
{
Cursor = Cursors.Default;
Previous = 0;
}
}

base.OnMouseLeave(e);
}

protected override void OnMouseDown(MouseEventArgs e)
{
if (e.Button == System.Windows.Forms.MouseButtons.Left)
SetState(MouseState.Down);

if (!(_IsParentForm && ParentForm.WindowState == FormWindowState.Maximized || _ControlMode))
{
if (_Movable && Frame.Contains(e.Location))
{
Capture = false;
WM_LMBUTTONDOWN = true;
DefWndProc(ref Messages[0]);
}
else if (_Sizable && !(Previous == 0))
{
Capture = false;
WM_LMBUTTONDOWN = true;
DefWndProc(ref Messages[Previous]);
}
}

base.OnMouseDown(e);
}

private bool WM_LMBUTTONDOWN;
protected override void WndProc(ref Message m)
{
base.WndProc(ref m);

if (WM_LMBUTTONDOWN && m.Msg == 513)
{
WM_LMBUTTONDOWN = false;

SetState(MouseState.Over);
if (!_SmartBounds)
return;

if (IsParentMdi)
{
CorrectBounds(new Rectangle(Point.Empty, Parent.Parent.Size));
}
else
{
CorrectBounds(Screen.FromControl(Parent).WorkingArea);
}
}
}

private Point GetIndexPoint;
private bool B1;
private bool B2;
private bool B3;
private bool B4;
private int GetIndex()
{
GetIndexPoint = PointToClient(MousePosition);
B1 = GetIndexPoint.X < 7;
B2 = GetIndexPoint.X > Width - 7;
B3 = GetIndexPoint.Y < 7;
B4 = GetIndexPoint.Y > Height - 7;

if (B1 && B3)
return 4;
if (B1 && B4)
return 7;
if (B2 && B3)
return 5;
if (B2 && B4)
return 8;
if (B1)
return 1;
if (B2)
return 2;
if (B3)
return 3;
if (B4)
return 6;
return 0;
}

private int Current;
private int Previous;
private void InvalidateMouse()
{
Current = GetIndex();
if (Current == Previous)
return;

Previous = Current;
switch (Previous)
{
case 0:
Cursor = Cursors.Default;
break;
case 1:
case 2:
Cursor = Cursors.SizeWE;
break;
case 3:
case 6:
Cursor = Cursors.SizeNS;
break;
case 4:
case 8:
Cursor = Cursors.SizeNWSE;
break;
case 5:
case 7:
Cursor = Cursors.SizeNESW;
break;
}
}

private Message[] Messages = new Message[9];
private void InitializeMessages()
{
Messages[0] = Message.Create(Parent.Handle, 161, new IntPtr(2), IntPtr.Zero);
for (int I = 1; I <= 8; I++)
{
Messages[I] = Message.Create(Parent.Handle, 161, new IntPtr(I + 9), IntPtr.Zero);
}
}

private void CorrectBounds(Rectangle bounds)
{
if (Parent.Width > bounds.Width)
Parent.Width = bounds.Width;
if (Parent.Height > bounds.Height)
Parent.Height = bounds.Height;

int X = Parent.Location.X;
int Y = Parent.Location.Y;

if (X < bounds.X)
X = bounds.X;
if (Y < bounds.Y)
Y = bounds.Y;

int Width = bounds.X + bounds.Width;
int Height = bounds.Y + bounds.Height;

if (X + Parent.Width > Width)
X = Width - Parent.Width;
if (Y + Parent.Height > Height)
Y = Height - Parent.Height;

Parent.Location = new Point(X, Y);
}

#endregion


#region " Base Properties "

public override DockStyle Dock
{
get { return base.Dock; }
set
{
if (!_ControlMode)
return;
base.Dock = value;
}
}

private bool _BackColor;
[Category("Misc")]
public override Color BackColor
{
get { return base.BackColor; }
set
{
if (value == base.BackColor)
return;

if (!IsHandleCreated && _ControlMode && value == Color.Transparent)
{
_BackColor = true;
return;
}

base.BackColor = value;
if (Parent != null)
{
if (!_ControlMode)
Parent.BackColor = value;
ColorHook();
}
}
}

public override Size MinimumSize
{
get { return base.MinimumSize; }
set
{
base.MinimumSize = value;
if (Parent != null)
Parent.MinimumSize = value;
}
}

public override Size MaximumSize
{
get { return base.MaximumSize; }
set
{
base.MaximumSize = value;
if (Parent != null)
Parent.MaximumSize = value;
}
}

public override string Text
{
get { return base.Text; }
set
{
base.Text = value;
Invalidate();
}
}

public override Font Font
{
get { return base.Font; }
set
{
base.Font = value;
Invalidate();
}
}

[Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public override Color ForeColor
{
get { return Color.Empty; }
set { }
}
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public override Image BackgroundImage
{
get { return null; }
set { }
}
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public override ImageLayout BackgroundImageLayout
{
get { return ImageLayout.None; }
set { }
}

#endregion

#region " Public Properties "

private bool _SmartBounds = true;
public bool SmartBounds
{
get { return _SmartBounds; }
set { _SmartBounds = value; }
}

private bool _Movable = true;
public bool Movable
{
get { return _Movable; }
set { _Movable = value; }
}

private bool _Sizable = true;
public bool Sizable
{
get { return _Sizable; }
set { _Sizable = value; }
}

private Color _TransparencyKey;
public Color TransparencyKey
{
get
{
if (_IsParentForm && !_ControlMode)
return ParentForm.TransparencyKey;
else
return _TransparencyKey;
}
set
{
if (value == _TransparencyKey)
return;
_TransparencyKey = value;

if (_IsParentForm && !_ControlMode)
{
ParentForm.TransparencyKey = value;
ColorHook();
}
}
}

private FormBorderStyle _BorderStyle;
public FormBorderStyle BorderStyle
{
get
{
if (_IsParentForm && !_ControlMode)
return ParentForm.FormBorderStyle;
else
return _BorderStyle;
}
set
{
_BorderStyle = value;

if (_IsParentForm && !_ControlMode)
{
ParentForm.FormBorderStyle = value;

if (!(value == FormBorderStyle.None))
{
Movable = false;
Sizable = false;
}
}
}
}

private FormStartPosition _StartPosition;
public FormStartPosition StartPosition
{
get
{
if (_IsParentForm && !_ControlMode)
return ParentForm.StartPosition;
else
return _StartPosition;
}
set
{
_StartPosition = value;

if (_IsParentForm && !_ControlMode)
{
ParentForm.StartPosition = value;
}
}
}

private bool _NoRounding;
public bool NoRounding
{
get { return _NoRounding; }
set
{
_NoRounding = value;
Invalidate();
}
}

private Image _Image;
public Image Image
{
get { return _Image; }
set
{
if (value == null)
_ImageSize = Size.Empty;
else
_ImageSize = value.Size;

_Image = value;
Invalidate();
}
}

private Dictionary<string, Color> Items = new Dictionary<string, Color>();
public Bloom[] Colors
{
get
{
List<Bloom> T = new List<Bloom>();
Dictionary<string, Color>.Enumerator E = Items.GetEnumerator();

while (E.MoveNext())
{
T.Add(new Bloom(E.Current.Key, E.Current.Value));
}

return T.ToArray();
}
set
{
foreach (Bloom B in value)
{
if (Items.ContainsKey(B.Name))
Items[B.Name] = B.Value;
}

InvalidateCustimization();
ColorHook();
Invalidate();
}
}

private string _Customization;
public string Customization
{
get { return _Customization; }
set
{
if (value == _Customization)
return;

byte[] Data = null;
Bloom[] Items = Colors;

try
{
Data = Convert.FromBase64String(value);
for (int I = 0; I <= Items.Length - 1; I++)
{
Items[I].Value = Color.FromArgb(BitConverter.ToInt32(Data, I * 4));
}
}
catch
{
return;
}

_Customization = value;

Colors = Items;
ColorHook();
Invalidate();
}
}

private bool _Transparent;
public bool Transparent
{
get { return _Transparent; }
set
{
_Transparent = value;
if (!(IsHandleCreated || _ControlMode))
return;

if (!value && !(BackColor.A == 255))
{
throw new Exception("Unable to change value to false while a transparent BackColor is in use.");
}

SetStyle(ControlStyles.Opaque, !value);
SetStyle(ControlStyles.SupportsTransparentBackColor, value);

InvalidateBitmap();
Invalidate();
}
}

#endregion

#region " Private Properties "

private Size _ImageSize;
protected Size ImageSize
{
get { return _ImageSize; }
}

private bool _IsParentForm;
protected bool IsParentForm
{
get { return _IsParentForm; }
}

protected bool IsParentMdi
{
get
{
if (Parent == null)
return false;
return Parent.Parent != null;
}
}

private int _LockWidth;
protected int LockWidth
{
get { return _LockWidth; }
set
{
_LockWidth = value;
if (!(LockWidth == 0) && IsHandleCreated)
Width = LockWidth;
}
}

private int _LockHeight;
protected int LockHeight
{
get { return _LockHeight; }
set
{
_LockHeight = value;
if (!(LockHeight == 0) && IsHandleCreated)
Height = LockHeight;
}
}

private int _Header = 24;
protected int Header
{
get { return _Header; }
set
{
_Header = value;

if (!_ControlMode)
{
Frame = new Rectangle(7, 7, Width - 14, value - 7);
Invalidate();
}
}
}

private bool _ControlMode;
protected bool ControlMode
{
get { return _ControlMode; }
set
{
_ControlMode = value;

Transparent = _Transparent;
if (_Transparent && _BackColor)
BackColor = Color.Transparent;

InvalidateBitmap();
Invalidate();
}
}

private bool _IsAnimated;
protected bool IsAnimated
{
get { return _IsAnimated; }
set
{
_IsAnimated = value;
InvalidateTimer();
}
}

#endregion


#region " Property Helpers "

protected Pen GetPen(string name)
{
return new Pen(Items[name]);
}
protected Pen GetPen(string name, float width)
{
return new Pen(Items[name], width);
}

protected SolidBrush GetBrush(string name)
{
return new SolidBrush(Items[name]);
}

protected Color GetColor(string name)
{
return Items[name];
}

protected void SetColor(string name, Color value)
{
if (Items.ContainsKey(name))
Items[name] = value;
else
Items.Add(name, value);
}
protected void SetColor(string name, byte r, byte g, byte b)
{
SetColor(name, Color.FromArgb(r, g, b));
}
protected void SetColor(string name, byte a, byte r, byte g, byte b)
{
SetColor(name, Color.FromArgb(a, r, g, b));
}
protected void SetColor(string name, byte a, Color value)
{
SetColor(name, Color.FromArgb(a, value));
}

private void InvalidateBitmap()
{
if (_Transparent && _ControlMode)
{
if (Width == 0 || Height == 0)
return;
B = new Bitmap(Width, Height, PixelFormat.Format32bppPArgb);
G = Graphics.FromImage(B);
}
else
{
G = null;
B = null;
}
}

private void InvalidateCustimization()
{
MemoryStream M = new MemoryStream(Items.Count * 4);

foreach (Bloom B in Colors)
{
M.Write(BitConverter.GetBytes(B.Value.ToArgb()), 0, 4);
}

M.Close();
_Customization = Convert.ToBase64String(M.ToArray());
}

private void InvalidateTimer()
{
if (DesignMode || !DoneCreation)
return;

if (_IsAnimated)
{
ThemeShare.AddAnimationCallback(DoAnimation);
}
else
{
ThemeShare.RemoveAnimationCallback(DoAnimation);
}
}

#endregion


#region " User Hooks "

protected abstract void ColorHook();
protected abstract void PaintHook();

protected virtual void OnCreation()
{
}

protected virtual void OnAnimation()
{
}

#endregion


#region " Offset "

private Rectangle OffsetReturnRectangle;
protected Rectangle Offset(Rectangle r, int amount)
{
OffsetReturnRectangle = new Rectangle(r.X + amount, r.Y + amount, r.Width - (amount * 2), r.Height - (amount * 2));
return OffsetReturnRectangle;
}

private Size OffsetReturnSize;
protected Size Offset(Size s, int amount)
{
OffsetReturnSize = new Size(s.Width + amount, s.Height + amount);
return OffsetReturnSize;
}

private Point OffsetReturnPoint;
protected Point Offset(Point p, int amount)
{
OffsetReturnPoint = new Point(p.X + amount, p.Y + amount);
return OffsetReturnPoint;
}

#endregion

#region " Center "


private Point CenterReturn;
protected Point Center(Rectangle p, Rectangle c)
{
CenterReturn = new Point((p.Width / 2 - c.Width / 2) + p.X + c.X, (p.Height / 2 - c.Height / 2) + p.Y + c.Y);
return CenterReturn;
}
protected Point Center(Rectangle p, Size c)
{
CenterReturn = new Point((p.Width / 2 - c.Width / 2) + p.X, (p.Height / 2 - c.Height / 2) + p.Y);
return CenterReturn;
}

protected Point Center(Rectangle child)
{
return Center(Width, Height, child.Width, child.Height);
}
protected Point Center(Size child)
{
return Center(Width, Height, child.Width, child.Height);
}
protected Point Center(int childWidth, int childHeight)
{
return Center(Width, Height, childWidth, childHeight);
}

protected Point Center(Size p, Size c)
{
return Center(p.Width, p.Height, c.Width, c.Height);
}

protected Point Center(int pWidth, int pHeight, int cWidth, int cHeight)
{
CenterReturn = new Point(pWidth / 2 - cWidth / 2, pHeight / 2 - cHeight / 2);
return CenterReturn;
}

#endregion

#region " Measure "

private Bitmap MeasureBitmap;

private Graphics MeasureGraphics;
protected Size Measure()
{
lock (MeasureGraphics)
{
return MeasureGraphics.MeasureString(Text, Font, Width).ToSize();
}
}
protected Size Measure(string text)
{
lock (MeasureGraphics)
{
return MeasureGraphics.MeasureString(text, Font, Width).ToSize();
}
}

#endregion


#region " DrawPixel "


private SolidBrush DrawPixelBrush;
protected void DrawPixel(Color c1, int x, int y)
{
if (_Transparent)
{
B.SetPixel(x, y, c1);
}
else
{
DrawPixelBrush = new SolidBrush(c1);
G.FillRectangle(DrawPixelBrush, x, y, 1, 1);
}
}

#endregion

#region " DrawCorners "


private SolidBrush DrawCornersBrush;
protected void DrawCorners(Color c1, int offset)
{
DrawCorners(c1, 0, 0, Width, Height, offset);
}
protected void DrawCorners(Color c1, Rectangle r1, int offset)
{
DrawCorners(c1, r1.X, r1.Y, r1.Width, r1.Height, offset);
}
protected void DrawCorners(Color c1, int x, int y, int width, int height, int offset)
{
DrawCorners(c1, x + offset, y + offset, width - (offset * 2), height - (offset * 2));
}

protected void DrawCorners(Color c1)
{
DrawCorners(c1, 0, 0, Width, Height);
}
protected void DrawCorners(Color c1, Rectangle r1)
{
DrawCorners(c1, r1.X, r1.Y, r1.Width, r1.Height);
}
protected void DrawCorners(Color c1, int x, int y, int width, int height)
{
if (_NoRounding)
return;

if (_Transparent)
{
B.SetPixel(x, y, c1);
B.SetPixel(x + (width - 1), y, c1);
B.SetPixel(x, y + (height - 1), c1);
B.SetPixel(x + (width - 1), y + (height - 1), c1);
}
else
{
DrawCornersBrush = new SolidBrush(c1);
G.FillRectangle(DrawCornersBrush, x, y, 1, 1);
G.FillRectangle(DrawCornersBrush, x + (width - 1), y, 1, 1);
G.FillRectangle(DrawCornersBrush, x, y + (height - 1), 1, 1);
G.FillRectangle(DrawCornersBrush, x + (width - 1), y + (height - 1), 1, 1);
}
}

#endregion

#region " DrawBorders "

protected void DrawBorders(Pen p1, int offset)
{
DrawBorders(p1, 0, 0, Width, Height, offset);
}
protected void DrawBorders(Pen p1, Rectangle r, int offset)
{
DrawBorders(p1, r.X, r.Y, r.Width, r.Height, offset);
}
protected void DrawBorders(Pen p1, int x, int y, int width, int height, int offset)
{
DrawBorders(p1, x + offset, y + offset, width - (offset * 2), height - (offset * 2));
}

protected void DrawBorders(Pen p1)
{
DrawBorders(p1, 0, 0, Width, Height);
}
protected void DrawBorders(Pen p1, Rectangle r)
{
DrawBorders(p1, r.X, r.Y, r.Width, r.Height);
}
protected void DrawBorders(Pen p1, int x, int y, int width, int height)
{
G.DrawRectangle(p1, x, y, width - 1, height - 1);
}

#endregion

#region " DrawText "

private Point DrawTextPoint;

private Size DrawTextSize;
protected void DrawText(Brush b1, HorizontalAlignment a, int x, int y)
{
DrawText(b1, Text, a, x, y);
}
protected void DrawText(Brush b1, string text, HorizontalAlignment a, int x, int y)
{
if (text.Length == 0)
return;

DrawTextSize = Measure(text);
DrawTextPoint = new Point(Width / 2 - DrawTextSize.Width / 2, Header / 2 - DrawTextSize.Height / 2);

switch (a)
{
case HorizontalAlignment.Left:
G.DrawString(text, Font, b1, x, DrawTextPoint.Y + y);
break;
case HorizontalAlignment.Center:
G.DrawString(text, Font, b1, DrawTextPoint.X + x, DrawTextPoint.Y + y);
break;
case HorizontalAlignment.Right:
G.DrawString(text, Font, b1, Width - DrawTextSize.Width - x, DrawTextPoint.Y + y);
break;
}
}

protected void DrawText(Brush b1, Point p1)
{
if (Text.Length == 0)
return;
G.DrawString(Text, Font, b1, p1);
}
protected void DrawText(Brush b1, int x, int y)
{
if (Text.Length == 0)
return;
G.DrawString(Text, Font, b1, x, y);
}

#endregion

#region " DrawImage "


private Point DrawImagePoint;
protected void DrawImage(HorizontalAlignment a, int x, int y)
{
DrawImage(_Image, a, x, y);
}
protected void DrawImage(Image image, HorizontalAlignment a, int x, int y)
{
if (image == null)
return;
DrawImagePoint = new Point(Width / 2 - image.Width / 2, Header / 2 - image.Height / 2);

switch (a)
{
case HorizontalAlignment.Left:
G.DrawImage(image, x, DrawImagePoint.Y + y, image.Width, image.Height);
break;
case HorizontalAlignment.Center:
G.DrawImage(image, DrawImagePoint.X + x, DrawImagePoint.Y + y, image.Width, image.Height);
break;
case HorizontalAlignment.Right:
G.DrawImage(image, Width - image.Width - x, DrawImagePoint.Y + y, image.Width, image.Height);
break;
}
}

protected void DrawImage(Point p1)
{
DrawImage(_Image, p1.X, p1.Y);
}
protected void DrawImage(int x, int y)
{
DrawImage(_Image, x, y);
}

protected void DrawImage(Image image, Point p1)
{
DrawImage(image, p1.X, p1.Y);
}
protected void DrawImage(Image image, int x, int y)
{
if (image == null)
return;
G.DrawImage(image, x, y, image.Width, image.Height);
}

#endregion

#region " DrawGradient "

private LinearGradientBrush DrawGradientBrush;

private Rectangle DrawGradientRectangle;
protected void DrawGradient(ColorBlend blend, int x, int y, int width, int height)
{
DrawGradientRectangle = new Rectangle(x, y, width, height);
DrawGradient(blend, DrawGradientRectangle);
}
protected void DrawGradient(ColorBlend blend, int x, int y, int width, int height, float angle)
{
DrawGradientRectangle = new Rectangle(x, y, width, height);
DrawGradient(blend, DrawGradientRectangle, angle);
}

protected void DrawGradient(ColorBlend blend, Rectangle r)
{
DrawGradientBrush = new LinearGradientBrush(r, Color.Empty, Color.Empty, 90f);
DrawGradientBrush.InterpolationColors = blend;
G.FillRectangle(DrawGradientBrush, r);
}
protected void DrawGradient(ColorBlend blend, Rectangle r, float angle)
{
DrawGradientBrush = new LinearGradientBrush(r, Color.Empty, Color.Empty, angle);
DrawGradientBrush.InterpolationColors = blend;
G.FillRectangle(DrawGradientBrush, r);
}


protected void DrawGradient(Color c1, Color c2, int x, int y, int width, int height)
{
DrawGradientRectangle = new Rectangle(x, y, width, height);
DrawGradient(c1, c2, DrawGradientRectangle);
}
protected void DrawGradient(Color c1, Color c2, int x, int y, int width, int height, float angle)
{
DrawGradientRectangle = new Rectangle(x, y, width, height);
DrawGradient(c1, c2, DrawGradientRectangle, angle);
}

protected void DrawGradient(Color c1, Color c2, Rectangle r)
{
DrawGradientBrush = new LinearGradientBrush(r, c1, c2, 90f);
G.FillRectangle(DrawGradientBrush, r);
}
protected void DrawGradient(Color c1, Color c2, Rectangle r, float angle)
{
DrawGradientBrush = new LinearGradientBrush(r, c1, c2, angle);
G.FillRectangle(DrawGradientBrush, r);
}

#endregion

#region " DrawRadial "

private GraphicsPath DrawRadialPath;
private PathGradientBrush DrawRadialBrush1;
private LinearGradientBrush DrawRadialBrush2;

private Rectangle DrawRadialRectangle;
public void DrawRadial(ColorBlend blend, int x, int y, int width, int height)
{
DrawRadialRectangle = new Rectangle(x, y, width, height);
DrawRadial(blend, DrawRadialRectangle, width / 2, height / 2);
}
public void DrawRadial(ColorBlend blend, int x, int y, int width, int height, Point center)
{
DrawRadialRectangle = new Rectangle(x, y, width, height);
DrawRadial(blend, DrawRadialRectangle, center.X, center.Y);
}
public void DrawRadial(ColorBlend blend, int x, int y, int width, int height, int cx, int cy)
{
DrawRadialRectangle = new Rectangle(x, y, width, height);
DrawRadial(blend, DrawRadialRectangle, cx, cy);
}

public void DrawRadial(ColorBlend blend, Rectangle r)
{
DrawRadial(blend, r, r.Width / 2, r.Height / 2);
}
public void DrawRadial(ColorBlend blend, Rectangle r, Point center)
{
DrawRadial(blend, r, center.X, center.Y);
}
public void DrawRadial(ColorBlend blend, Rectangle r, int cx, int cy)
{
DrawRadialPath.Reset();
DrawRadialPath.AddEllipse(r.X, r.Y, r.Width - 1, r.Height - 1);

DrawRadialBrush1 = new PathGradientBrush(DrawRadialPath);
DrawRadialBrush1.CenterPoint = new Point(r.X + cx, r.Y + cy);
DrawRadialBrush1.InterpolationColors = blend;

if (G.SmoothingMode == SmoothingMode.AntiAlias)
{
G.FillEllipse(DrawRadialBrush1, r.X + 1, r.Y + 1, r.Width - 3, r.Height - 3);
}
else
{
G.FillEllipse(DrawRadialBrush1, r);
}
}


protected void DrawRadial(Color c1, Color c2, int x, int y, int width, int height)
{
DrawRadialRectangle = new Rectangle(x, y, width, height);
DrawRadial(c1, c2, DrawGradientRectangle);
}
protected void DrawRadial(Color c1, Color c2, int x, int y, int width, int height, float angle)
{
DrawRadialRectangle = new Rectangle(x, y, width, height);
DrawRadial(c1, c2, DrawGradientRectangle, angle);
}

protected void DrawRadial(Color c1, Color c2, Rectangle r)
{
DrawRadialBrush2 = new LinearGradientBrush(r, c1, c2, 90f);
G.FillRectangle(DrawGradientBrush, r);
}
protected void DrawRadial(Color c1, Color c2, Rectangle r, float angle)
{
DrawRadialBrush2 = new LinearGradientBrush(r, c1, c2, angle);
G.FillEllipse(DrawGradientBrush, r);
}

#endregion

#region " CreateRound "

private GraphicsPath CreateRoundPath;

private Rectangle CreateRoundRectangle;
public GraphicsPath CreateRound(int x, int y, int width, int height, int slope)
{
CreateRoundRectangle = new Rectangle(x, y, width, height);
return CreateRound(CreateRoundRectangle, slope);
}

public GraphicsPath CreateRound(Rectangle r, int slope)
{
CreateRoundPath = new GraphicsPath(FillMode.Winding);
CreateRoundPath.AddArc(r.X, r.Y, slope, slope, 180f, 90f);
CreateRoundPath.AddArc(r.Right - slope, r.Y, slope, slope, 270f, 90f);
CreateRoundPath.AddArc(r.Right - slope, r.Bottom - slope, slope, slope, 0f, 90f);
CreateRoundPath.AddArc(r.X, r.Bottom - slope, slope, slope, 90f, 90f);
CreateRoundPath.CloseFigure();
return CreateRoundPath;
}

#endregion

}

abstract class ThemeControl154 : Control
{


#region " Initialization "

protected Graphics G;

protected Bitmap B;
public ThemeControl154()
{
SetStyle((ControlStyles)139270, true);

_ImageSize = Size.Empty;
Font = new Font("Verdana", 8);

MeasureBitmap = new Bitmap(1, 1);
MeasureGraphics = Graphics.FromImage(MeasureBitmap);

DrawRadialPath = new GraphicsPath();

InvalidateCustimization();
//Remove?
}

protected override sealed void OnHandleCreated(EventArgs e)
{
InvalidateCustimization();
ColorHook();

if (!(_LockWidth == 0))
Width = _LockWidth;
if (!(_LockHeight == 0))
Height = _LockHeight;

Transparent = _Transparent;
if (_Transparent && _BackColor)
BackColor = Color.Transparent;

base.OnHandleCreated(e);
}

private bool DoneCreation;
protected override sealed void OnParentChanged(EventArgs e)
{
if (Parent != null)
{
OnCreation();
DoneCreation = true;
InvalidateTimer();
}

base.OnParentChanged(e);
}

#endregion

private void DoAnimation(bool i)
{
OnAnimation();
if (i)
Invalidate();
}

protected override sealed void OnPaint(PaintEventArgs e)
{
if (Width == 0 || Height == 0)
return;

if (_Transparent)
{
PaintHook();
e.Graphics.DrawImage(B, 0, 0);
}
else
{
G = e.Graphics;
PaintHook();
}
}

protected override void OnHandleDestroyed(EventArgs e)
{
ThemeShare.RemoveAnimationCallback(DoAnimation);
base.OnHandleDestroyed(e);
}

#region " Size Handling "

protected override sealed void OnSizeChanged(EventArgs e)
{
if (_Transparent)
{
InvalidateBitmap();
}

Invalidate();
base.OnSizeChanged(e);
}

protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified)
{
if (!(_LockWidth == 0))
width = _LockWidth;
if (!(_LockHeight == 0))
height = _LockHeight;
base.SetBoundsCore(x, y, width, height, specified);
}

#endregion

#region " State Handling "

private bool InPosition;
protected override void OnMouseEnter(EventArgs e)
{
InPosition = true;
SetState(MouseState.Over);
base.OnMouseEnter(e);
}

protected override void OnMouseUp(MouseEventArgs e)
{
if (InPosition)
SetState(MouseState.Over);
base.OnMouseUp(e);
}

protected override void OnMouseDown(MouseEventArgs e)
{
if (e.Button == System.Windows.Forms.MouseButtons.Left)
SetState(MouseState.Down);
base.OnMouseDown(e);
}

protected override void OnMouseLeave(EventArgs e)
{
InPosition = false;
SetState(MouseState.None);
base.OnMouseLeave(e);
}

protected override void OnEnabledChanged(EventArgs e)
{
if (Enabled)
SetState(MouseState.None);
else
SetState(MouseState.Block);
base.OnEnabledChanged(e);
}

protected MouseState State;
private void SetState(MouseState current)
{
State = current;
Invalidate();
}

#endregion


#region " Base Properties "

[Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public override Color ForeColor
{
get { return Color.Empty; }
set { }
}
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public override Image BackgroundImage
{
get { return null; }
set { }
}
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public override ImageLayout BackgroundImageLayout
{
get { return ImageLayout.None; }
set { }
}

public override string Text
{
get { return base.Text; }
set
{
base.Text = value;
Invalidate();
}
}
public override Font Font
{
get { return base.Font; }
set
{
base.Font = value;
Invalidate();
}
}

private bool _BackColor;
[Category("Misc")]
public override Color BackColor
{
get { return base.BackColor; }
set
{
if (!IsHandleCreated && value == Color.Transparent)
{
_BackColor = true;
return;
}

base.BackColor = value;
if (Parent != null)
ColorHook();
}
}

#endregion

#region " Public Properties "

private bool _NoRounding;
public bool NoRounding
{
get { return _NoRounding; }
set
{
_NoRounding = value;
Invalidate();
}
}

private Image _Image;
public Image Image
{
get { return _Image; }
set
{
if (value == null)
{
_ImageSize = Size.Empty;
}
else
{
_ImageSize = value.Size;
}

_Image = value;
Invalidate();
}
}

private bool _Transparent;
public bool Transparent
{
get { return _Transparent; }
set
{
_Transparent = value;
if (!IsHandleCreated)
return;

if (!value && !(BackColor.A == 255))
{
throw new Exception("Unable to change value to false while a transparent BackColor is in use.");
}

SetStyle(ControlStyles.Opaque, !value);
SetStyle(ControlStyles.SupportsTransparentBackColor, value);

if (value)
InvalidateBitmap();
else
B = null;
Invalidate();
}
}

private Dictionary<string, Color> Items = new Dictionary<string, Color>();
public Bloom[] Colors
{
get
{
List<Bloom> T = new List<Bloom>();
Dictionary<string, Color>.Enumerator E = Items.GetEnumerator();

while (E.MoveNext())
{
T.Add(new Bloom(E.Current.Key, E.Current.Value));
}

return T.ToArray();
}
set
{
foreach (Bloom B in value)
{
if (Items.ContainsKey(B.Name))
Items[B.Name] = B.Value;
}

InvalidateCustimization();
ColorHook();
Invalidate();
}
}

private string _Customization;
public string Customization
{
get { return _Customization; }
set
{
if (value == _Customization)
return;

byte[] Data = null;
Bloom[] Items = Colors;

try
{
Data = Convert.FromBase64String(value);
for (int I = 0; I <= Items.Length - 1; I++)
{
Items[I].Value = Color.FromArgb(BitConverter.ToInt32(Data, I * 4));
}
}
catch
{
return;
}

_Customization = value;

Colors = Items;
ColorHook();
Invalidate();
}
}

#endregion

#region " Private Properties "

private Size _ImageSize;
protected Size ImageSize
{
get { return _ImageSize; }
}

private int _LockWidth;
protected int LockWidth
{
get { return _LockWidth; }
set
{
_LockWidth = value;
if (!(LockWidth == 0) && IsHandleCreated)
Width = LockWidth;
}
}

private int _LockHeight;
protected int LockHeight
{
get { return _LockHeight; }
set
{
_LockHeight = value;
if (!(LockHeight == 0) && IsHandleCreated)
Height = LockHeight;
}
}

private bool _IsAnimated;
protected bool IsAnimated
{
get { return _IsAnimated; }
set
{
_IsAnimated = value;
InvalidateTimer();
}
}

#endregion


#region " Property Helpers "

protected Pen GetPen(string name)
{
return new Pen(Items[name]);
}
protected Pen GetPen(string name, float width)
{
return new Pen(Items[name], width);
}

protected SolidBrush GetBrush(string name)
{
return new SolidBrush(Items[name]);
}

protected Color GetColor(string name)
{
return Items[name];
}

protected void SetColor(string name, Color value)
{
if (Items.ContainsKey(name))
Items[name] = value;
else
Items.Add(name, value);
}
protected void SetColor(string name, byte r, byte g, byte b)
{
SetColor(name, Color.FromArgb(r, g, b));
}
protected void SetColor(string name, byte a, byte r, byte g, byte b)
{
SetColor(name, Color.FromArgb(a, r, g, b));
}
protected void SetColor(string name, byte a, Color value)
{
SetColor(name, Color.FromArgb(a, value));
}

private void InvalidateBitmap()
{
if (Width == 0 || Height == 0)
return;
B = new Bitmap(Width, Height, PixelFormat.Format32bppPArgb);
G = Graphics.FromImage(B);
}

private void InvalidateCustimization()
{
MemoryStream M = new MemoryStream(Items.Count * 4);

foreach (Bloom B in Colors)
{
M.Write(BitConverter.GetBytes(B.Value.ToArgb()), 0, 4);
}

M.Close();
_Customization = Convert.ToBase64String(M.ToArray());
}

private void InvalidateTimer()
{
if (DesignMode || !DoneCreation)
return;

if (_IsAnimated)
{
ThemeShare.AddAnimationCallback(DoAnimation);
}
else
{
ThemeShare.RemoveAnimationCallback(DoAnimation);
}
}
#endregion


#region " User Hooks "

protected abstract void ColorHook();
protected abstract void PaintHook();

protected virtual void OnCreation()
{
}

protected virtual void OnAnimation()
{
}

#endregion


#region " Offset "

private Rectangle OffsetReturnRectangle;
protected Rectangle Offset(Rectangle r, int amount)
{
OffsetReturnRectangle = new Rectangle(r.X + amount, r.Y + amount, r.Width - (amount * 2), r.Height - (amount * 2));
return OffsetReturnRectangle;
}

private Size OffsetReturnSize;
protected Size Offset(Size s, int amount)
{
OffsetReturnSize = new Size(s.Width + amount, s.Height + amount);
return OffsetReturnSize;
}

private Point OffsetReturnPoint;
protected Point Offset(Point p, int amount)
{
OffsetReturnPoint = new Point(p.X + amount, p.Y + amount);
return OffsetReturnPoint;
}

#endregion

#region " Center "


private Point CenterReturn;
protected Point Center(Rectangle p, Rectangle c)
{
CenterReturn = new Point((p.Width / 2 - c.Width / 2) + p.X + c.X, (p.Height / 2 - c.Height / 2) + p.Y + c.Y);
return CenterReturn;
}
protected Point Center(Rectangle p, Size c)
{
CenterReturn = new Point((p.Width / 2 - c.Width / 2) + p.X, (p.Height / 2 - c.Height / 2) + p.Y);
return CenterReturn;
}

protected Point Center(Rectangle child)
{
return Center(Width, Height, child.Width, child.Height);
}
protected Point Center(Size child)
{
return Center(Width, Height, child.Width, child.Height);
}
protected Point Center(int childWidth, int childHeight)
{
return Center(Width, Height, childWidth, childHeight);
}

protected Point Center(Size p, Size c)
{
return Center(p.Width, p.Height, c.Width, c.Height);
}

protected Point Center(int pWidth, int pHeight, int cWidth, int cHeight)
{
CenterReturn = new Point(pWidth / 2 - cWidth / 2, pHeight / 2 - cHeight / 2);
return CenterReturn;
}

#endregion

#region " Measure "

private Bitmap MeasureBitmap;
//TODO: Potential issues during multi-threading.
private Graphics MeasureGraphics;

protected Size Measure()
{
return MeasureGraphics.MeasureString(Text, Font, Width).ToSize();
}
protected Size Measure(string text)
{
return MeasureGraphics.MeasureString(text, Font, Width).ToSize();
}

#endregion


#region " DrawPixel "


private SolidBrush DrawPixelBrush;
protected void DrawPixel(Color c1, int x, int y)
{
if (_Transparent)
{
B.SetPixel(x, y, c1);
}
else
{
DrawPixelBrush = new SolidBrush(c1);
G.FillRectangle(DrawPixelBrush, x, y, 1, 1);
}
}

#endregion

#region " DrawCorners "


private SolidBrush DrawCornersBrush;
protected void DrawCorners(Color c1, int offset)
{
DrawCorners(c1, 0, 0, Width, Height, offset);
}
protected void DrawCorners(Color c1, Rectangle r1, int offset)
{
DrawCorners(c1, r1.X, r1.Y, r1.Width, r1.Height, offset);
}
protected void DrawCorners(Color c1, int x, int y, int width, int height, int offset)
{
DrawCorners(c1, x + offset, y + offset, width - (offset * 2), height - (offset * 2));
}

protected void DrawCorners(Color c1)
{
DrawCorners(c1, 0, 0, Width, Height);
}
protected void DrawCorners(Color c1, Rectangle r1)
{
DrawCorners(c1, r1.X, r1.Y, r1.Width, r1.Height);
}
protected void DrawCorners(Color c1, int x, int y, int width, int height)
{
if (_NoRounding)
return;

if (_Transparent)
{
B.SetPixel(x, y, c1);
B.SetPixel(x + (width - 1), y, c1);
B.SetPixel(x, y + (height - 1), c1);
B.SetPixel(x + (width - 1), y + (height - 1), c1);
}
else
{
DrawCornersBrush = new SolidBrush(c1);
G.FillRectangle(DrawCornersBrush, x, y, 1, 1);
G.FillRectangle(DrawCornersBrush, x + (width - 1), y, 1, 1);
G.FillRectangle(DrawCornersBrush, x, y + (height - 1), 1, 1);
G.FillRectangle(DrawCornersBrush, x + (width - 1), y + (height - 1), 1, 1);
}
}

#endregion

#region " DrawBorders "

protected void DrawBorders(Pen p1, int offset)
{
DrawBorders(p1, 0, 0, Width, Height, offset);
}
protected void DrawBorders(Pen p1, Rectangle r, int offset)
{
DrawBorders(p1, r.X, r.Y, r.Width, r.Height, offset);
}
protected void DrawBorders(Pen p1, int x, int y, int width, int height, int offset)
{
DrawBorders(p1, x + offset, y + offset, width - (offset * 2), height - (offset * 2));
}

protected void DrawBorders(Pen p1)
{
DrawBorders(p1, 0, 0, Width, Height);
}
protected void DrawBorders(Pen p1, Rectangle r)
{
DrawBorders(p1, r.X, r.Y, r.Width, r.Height);
}
protected void DrawBorders(Pen p1, int x, int y, int width, int height)
{
G.DrawRectangle(p1, x, y, width - 1, height - 1);
}

#endregion

#region " DrawText "

private Point DrawTextPoint;

private Size DrawTextSize;
protected void DrawText(Brush b1, HorizontalAlignment a, int x, int y)
{
DrawText(b1, Text, a, x, y);
}
protected void DrawText(Brush b1, string text, HorizontalAlignment a, int x, int y)
{
if (text.Length == 0)
return;

DrawTextSize = Measure(text);
DrawTextPoint = Center(DrawTextSize);

switch (a)
{
case HorizontalAlignment.Left:
G.DrawString(text, Font, b1, x, DrawTextPoint.Y + y);
break;
case HorizontalAlignment.Center:
G.DrawString(text, Font, b1, DrawTextPoint.X + x, DrawTextPoint.Y + y);
break;
case HorizontalAlignment.Right:
G.DrawString(text, Font, b1, Width - DrawTextSize.Width - x, DrawTextPoint.Y + y);
break;
}
}

protected void DrawText(Brush b1, Point p1)
{
if (Text.Length == 0)
return;
G.DrawString(Text, Font, b1, p1);
}
protected void DrawText(Brush b1, int x, int y)
{
if (Text.Length == 0)
return;
G.DrawString(Text, Font, b1, x, y);
}

#endregion

#region " DrawImage "


private Point DrawImagePoint;
protected void DrawImage(HorizontalAlignment a, int x, int y)
{
DrawImage(_Image, a, x, y);
}
protected void DrawImage(Image image, HorizontalAlignment a, int x, int y)
{
if (image == null)
return;
DrawImagePoint = Center(image.Size);

switch (a)
{
case HorizontalAlignment.Left:
G.DrawImage(image, x, DrawImagePoint.Y + y, image.Width, image.Height);
break;
case HorizontalAlignment.Center:
G.DrawImage(image, DrawImagePoint.X + x, DrawImagePoint.Y + y, image.Width, image.Height);
break;
case HorizontalAlignment.Right:
G.DrawImage(image, Width - image.Width - x, DrawImagePoint.Y + y, image.Width, image.Height);
break;
}
}

protected void DrawImage(Point p1)
{
DrawImage(_Image, p1.X, p1.Y);
}
protected void DrawImage(int x, int y)
{
DrawImage(_Image, x, y);
}

protected void DrawImage(Image image, Point p1)
{
DrawImage(image, p1.X, p1.Y);
}
protected void DrawImage(Image image, int x, int y)
{
if (image == null)
return;
G.DrawImage(image, x, y, image.Width, image.Height);
}

#endregion

#region " DrawGradient "

private LinearGradientBrush DrawGradientBrush;

private Rectangle DrawGradientRectangle;
protected void DrawGradient(ColorBlend blend, int x, int y, int width, int height)
{
DrawGradientRectangle = new Rectangle(x, y, width, height);
DrawGradient(blend, DrawGradientRectangle);
}
protected void DrawGradient(ColorBlend blend, int x, int y, int width, int height, float angle)
{
DrawGradientRectangle = new Rectangle(x, y, width, height);
DrawGradient(blend, DrawGradientRectangle, angle);
}

protected void DrawGradient(ColorBlend blend, Rectangle r)
{
DrawGradientBrush = new LinearGradientBrush(r, Color.Empty, Color.Empty, 90f);
DrawGradientBrush.InterpolationColors = blend;
G.FillRectangle(DrawGradientBrush, r);
}
protected void DrawGradient(ColorBlend blend, Rectangle r, float angle)
{
DrawGradientBrush = new LinearGradientBrush(r, Color.Empty, Color.Empty, angle);
DrawGradientBrush.InterpolationColors = blend;
G.FillRectangle(DrawGradientBrush, r);
}


protected void DrawGradient(Color c1, Color c2, int x, int y, int width, int height)
{
DrawGradientRectangle = new Rectangle(x, y, width, height);
DrawGradient(c1, c2, DrawGradientRectangle);
}
protected void DrawGradient(Color c1, Color c2, int x, int y, int width, int height, float angle)
{
DrawGradientRectangle = new Rectangle(x, y, width, height);
DrawGradient(c1, c2, DrawGradientRectangle, angle);
}

protected void DrawGradient(Color c1, Color c2, Rectangle r)
{
DrawGradientBrush = new LinearGradientBrush(r, c1, c2, 90f);
G.FillRectangle(DrawGradientBrush, r);
}
protected void DrawGradient(Color c1, Color c2, Rectangle r, float angle)
{
DrawGradientBrush = new LinearGradientBrush(r, c1, c2, angle);
G.FillRectangle(DrawGradientBrush, r);
}

#endregion

#region " DrawRadial "

private GraphicsPath DrawRadialPath;
private PathGradientBrush DrawRadialBrush1;
private LinearGradientBrush DrawRadialBrush2;

private Rectangle DrawRadialRectangle;
public void DrawRadial(ColorBlend blend, int x, int y, int width, int height)
{
DrawRadialRectangle = new Rectangle(x, y, width, height);
DrawRadial(blend, DrawRadialRectangle, width / 2, height / 2);
}
public void DrawRadial(ColorBlend blend, int x, int y, int width, int height, Point center)
{
DrawRadialRectangle = new Rectangle(x, y, width, height);
DrawRadial(blend, DrawRadialRectangle, center.X, center.Y);
}
public void DrawRadial(ColorBlend blend, int x, int y, int width, int height, int cx, int cy)
{
DrawRadialRectangle = new Rectangle(x, y, width, height);
DrawRadial(blend, DrawRadialRectangle, cx, cy);
}

public void DrawRadial(ColorBlend blend, Rectangle r)
{
DrawRadial(blend, r, r.Width / 2, r.Height / 2);
}
public void DrawRadial(ColorBlend blend, Rectangle r, Point center)
{
DrawRadial(blend, r, center.X, center.Y);
}
public void DrawRadial(ColorBlend blend, Rectangle r, int cx, int cy)
{
DrawRadialPath.Reset();
DrawRadialPath.AddEllipse(r.X, r.Y, r.Width - 1, r.Height - 1);

DrawRadialBrush1 = new PathGradientBrush(DrawRadialPath);
DrawRadialBrush1.CenterPoint = new Point(r.X + cx, r.Y + cy);
DrawRadialBrush1.InterpolationColors = blend;

if (G.SmoothingMode == SmoothingMode.AntiAlias)
{
G.FillEllipse(DrawRadialBrush1, r.X + 1, r.Y + 1, r.Width - 3, r.Height - 3);
}
else
{
G.FillEllipse(DrawRadialBrush1, r);
}
}


protected void DrawRadial(Color c1, Color c2, int x, int y, int width, int height)
{
DrawRadialRectangle = new Rectangle(x, y, width, height);
DrawRadial(c1, c2, DrawRadialRectangle);
}
protected void DrawRadial(Color c1, Color c2, int x, int y, int width, int height, float angle)
{
DrawRadialRectangle = new Rectangle(x, y, width, height);
DrawRadial(c1, c2, DrawRadialRectangle, angle);
}

protected void DrawRadial(Color c1, Color c2, Rectangle r)
{
DrawRadialBrush2 = new LinearGradientBrush(r, c1, c2, 90f);
G.FillEllipse(DrawRadialBrush2, r);
}
protected void DrawRadial(Color c1, Color c2, Rectangle r, float angle)
{
DrawRadialBrush2 = new LinearGradientBrush(r, c1, c2, angle);
G.FillEllipse(DrawRadialBrush2, r);
}

#endregion

#region " CreateRound "

private GraphicsPath CreateRoundPath;

private Rectangle CreateRoundRectangle;
public GraphicsPath CreateRound(int x, int y, int width, int height, int slope)
{
CreateRoundRectangle = new Rectangle(x, y, width, height);
return CreateRound(CreateRoundRectangle, slope);
}

public GraphicsPath CreateRound(Rectangle r, int slope)
{
CreateRoundPath = new GraphicsPath(FillMode.Winding);
CreateRoundPath.AddArc(r.X, r.Y, slope, slope, 180f, 90f);
CreateRoundPath.AddArc(r.Right - slope, r.Y, slope, slope, 270f, 90f);
CreateRoundPath.AddArc(r.Right - slope, r.Bottom - slope, slope, slope, 0f, 90f);
CreateRoundPath.AddArc(r.X, r.Bottom - slope, slope, slope, 90f, 90f);
CreateRoundPath.CloseFigure();
return CreateRoundPath;
}

#endregion

}

static class ThemeShare
{

#region " Animation "

private static int Frames;
private static bool Invalidate;

public static PrecisionTimer ThemeTimer = new PrecisionTimer();
//1000 / 50 = 20 FPS
public static int FPS = 20;

public static int Rate = 50;
public delegate void AnimationDelegate(bool invalidate);


private static List<AnimationDelegate> Callbacks = new List<AnimationDelegate>();
private static void HandleCallbacks(IntPtr state, bool reserve)
{
Invalidate = (Frames >= FPS);
if (Invalidate)
Frames = 0;

lock (Callbacks)
{
for (int I = 0; I <= Callbacks.Count - 1; I++)
{
Callbacks[I].Invoke(Invalidate);
}
}

Frames += Rate;
}

private static void InvalidateThemeTimer()
{
if (Callbacks.Count == 0)
{
ThemeTimer.Delete();
}
else
{
ThemeTimer.Create(0, (uint)Rate, HandleCallbacks);
}
}

public static void AddAnimationCallback(AnimationDelegate callback)
{
lock (Callbacks)
{
if (Callbacks.Contains(callback))
return;

Callbacks.Add(callback);
InvalidateThemeTimer();
}
}

public static void RemoveAnimationCallback(AnimationDelegate callback)
{
lock (Callbacks)
{
if (!Callbacks.Contains(callback))
return;

Callbacks.Remove(callback);
InvalidateThemeTimer();
}
}

#endregion

}

enum MouseState : byte
{
None = 0,
Over = 1,
Down = 2,
Block = 3
}

struct Bloom
{

public string _Name;
public string Name
{
get { return _Name; }
}

private Color _Value;
public Color Value
{
get { return _Value; }
set { _Value = value; }
}

public string ValueHex
{
get { return string.Concat("#", _Value.R.ToString("X2", null), _Value.G.ToString("X2", null), _Value.B.ToString("X2", null)); }
set
{
try
{
_Value = ColorTranslator.FromHtml(value);
}
catch
{
return;
}
}
}


public Bloom(string name, Color value)
{
_Name = name;
_Value = value;
}
}

//------------------
//Creator: aeonhack
//Site: elitevs.net
//Created: 11/30/2011
//Changed: 11/30/2011
//Version: 1.0.0
//------------------
class PrecisionTimer : IDisposable
{

private bool _Enabled;
public bool Enabled
{
get { return _Enabled; }
}

private IntPtr Handle;

private TimerDelegate TimerCallback;
[DllImport("kernel32.dll", EntryPoint = "CreateTimerQueueTimer")]
private static extern bool CreateTimerQueueTimer(ref IntPtr handle, IntPtr queue, TimerDelegate callback, IntPtr state, uint dueTime, uint period, uint flags);

[DllImport("kernel32.dll", EntryPoint = "DeleteTimerQueueTimer")]
private static extern bool DeleteTimerQueueTimer(IntPtr queue, IntPtr handle, IntPtr callback);

public delegate void TimerDelegate(IntPtr r1, bool r2);

public void Create(uint dueTime, uint period, TimerDelegate callback)
{
if (_Enabled)
return;

TimerCallback = callback;
bool Success = CreateTimerQueueTimer(ref Handle, IntPtr.Zero, TimerCallback, IntPtr.Zero, dueTime, period, 0);

if (!Success)
ThrowNewException("CreateTimerQueueTimer");
_Enabled = Success;
}

public void Delete()
{
if (!_Enabled)
return;
bool Success = DeleteTimerQueueTimer(IntPtr.Zero, Handle, IntPtr.Zero);

if (!Success && !(Marshal.GetLastWin32Error() == 997))
{
//ThrowNewException("DeleteTimerQueueTimer")
}

_Enabled = !Success;
}

private void ThrowNewException(string name)
{
throw new Exception(string.Format("{0} failed. Win32Error: {1}", name, Marshal.GetLastWin32Error()));
}

public void Dispose()
{
Delete();
}
}
#endregion

class GhostTheme : ThemeContainer154
{


protected override void ColorHook()
{
}

private bool _ShowIcon;
public bool ShowIcon
{
get { return _ShowIcon; }
set
{
_ShowIcon = value;
Invalidate();
}
}

protected override void PaintHook()
{
G.Clear(Color.DimGray);
ColorBlend hatch = new ColorBlend(2);
DrawBorders(Pens.Gray, 1);
hatch.Colors[0] = Color.DimGray;
hatch.Colors[1] = Color.FromArgb(60, 60, 60);
hatch.Positions[0] = 0;
hatch.Positions[1] = 1;
DrawGradient(hatch, new Rectangle(0, 0, Width, 24));
hatch.Colors[0] = Color.FromArgb(100, 100, 100);
hatch.Colors[1] = Color.DimGray;
DrawGradient(hatch, new Rectangle(0, 0, Width, 12));
HatchBrush asdf = null;
asdf = new HatchBrush(HatchStyle.DarkDownwardDiagonal, Color.FromArgb(15, Color.Black), Color.FromArgb(0, Color.Gray));
hatch.Colors[0] = Color.FromArgb(120, Color.Black);
hatch.Colors[1] = Color.FromArgb(0, Color.Black);
DrawGradient(hatch, new Rectangle(0, 0, Width, 30));
G.FillRectangle(asdf, 0, 0, Width, 24);
G.DrawLine(Pens.Black, 6, 24, Width - 7, 24);
G.DrawLine(Pens.Black, 6, 24, 6, Height - 7);
G.DrawLine(Pens.Black, 6, Height - 7, Width - 7, Height - 7);
G.DrawLine(Pens.Black, Width - 7, 24, Width - 7, Height - 7);
G.FillRectangle(new SolidBrush(Color.FromArgb(60, 60, 60)), new Rectangle(1, 24, 5, Height - 6 - 24));
G.FillRectangle(asdf, 1, 24, 5, Height - 6 - 24);
G.FillRectangle(new SolidBrush(Color.FromArgb(60, 60, 60)), new Rectangle(Width - 6, 24, Width - 1, Height - 6 - 24));
G.FillRectangle(asdf, Width - 6, 24, Width - 2, Height - 6 - 24);
G.FillRectangle(new SolidBrush(Color.FromArgb(60, 60, 60)), new Rectangle(1, Height - 6, Width - 2, Height - 1));
G.FillRectangle(asdf, 1, Height - 6, Width - 2, Height - 1);
DrawBorders(Pens.Black);
asdf = new HatchBrush(HatchStyle.LightDownwardDiagonal, Color.DimGray);
G.FillRectangle(asdf, 7, 25, Width - 14, Height - 24 - 8);
G.FillRectangle(new SolidBrush(Color.FromArgb(230, 20, 20, 20)), 7, 25, Width - 14, Height - 24 - 8);
DrawCorners(Color.Fuchsia);
DrawCorners(Color.Fuchsia, 0, 1, 1, 1);
DrawCorners(Color.Fuchsia, 1, 0, 1, 1);
DrawPixel(Color.Black, 1, 1);

DrawCorners(Color.Fuchsia, 0, Height - 2, 1, 1);
DrawCorners(Color.Fuchsia, 1, Height - 1, 1, 1);
DrawPixel(Color.Black, Width - 2, 1);

DrawCorners(Color.Fuchsia, Width - 1, 1, 1, 1);
DrawCorners(Color.Fuchsia, Width - 2, 0, 1, 1);
DrawPixel(Color.Black, 1, Height - 2);

DrawCorners(Color.Fuchsia, Width - 1, Height - 2, 1, 1);
DrawCorners(Color.Fuchsia, Width - 2, Height - 1, 1, 1);
DrawPixel(Color.Black, Width - 2, Height - 2);

ColorBlend cblend = new ColorBlend(2);
cblend.Colors[0] = Color.F