function getStyle (oElm, strCssRule)
		{	var strValue = "";

			if ( document.defaultView && document.defaultView.getComputedStyle )
				{	strValue = document.defaultView.getComputedStyle(oElm, "").getPropertyValue(strCssRule);
				}
			else if ( oElm.currentStyle )
				{	strCssRule = strCssRule.replace(/\-(\w)/g, function (strMatch, p1){return p1.toUpperCase();});
					strValue = oElm.currentStyle[strCssRule];
				};

			return strValue;
		};
	
	DropClass =
		{	// Initialize the class.
			drop_targets: new Array(),
			
			// This method registers a new drop object.
			createDropObject: function (element)
				{	// Set default event handlers.
					element.onDragTargetDropped = element.onDragTargetDropped ? element.onDragTargetDropped : function (drag_object) { };

					// Add the drop target.
					this.drop_targets[this.drop_targets.length] = element;
				}, // function createDropObject (element)

			// This method looks for a drop target at the specified screen region.
			getDropObjectContaining: function (id, x, y, width, height)
				{	// Search all the drop targets.
					for ( var index = 0; index < this.drop_targets.length; index++ )
						{	// Get the next target.
							var drop_target = this.drop_targets[index];

							// Get the element's parent.
							var node	= drop_target;	
							var dx		= 0;
							var dy		= 0;
							var dw		= drop_target.offsetWidth;
							var dh		= drop_target.offsetHeight;

							// Compute the drop target's position.
							while ( node )
								{	dx		+= node.offsetLeft;
									dy		+= node.offsetTop;
									node	= node.offsetParent;									
								}; // while ( node )

							// Perform the boundary checks.
							var test_horiz	= ( x >= dx && x <= (dx + dw) ) || ( (x + width) >= dx && (x + width) <= (dx + dw) );
							var test_vert	= ( y >= dy && y <= (dy + dh) ) || ( (y + height) >= dy && (y + height) <= (dy + dh) );

							// Found the drop target.
							if ( test_horiz && test_vert )
								{	return drop_target;
								} // if ( test_horiz && test_vert )
						}; // for ( var index = 0; index < this.drop_targets.length; index++ )

					return undefined;
				}, // function getDropObjectContaining (id, x, y, width, height)

			// This method determines whether the current browser is Internet Explorer.
			isInternetExplorer: function ()
				{	return document.all != undefined;
				} // function isInternetExplorer ()

		}; // function DropClass ()
	
	// This class defines a transform to snap an object back to its original location.
	function SnapToTransform (ms)
		{	// Initialize properties.
			this.node			= null;
			this.start_coords	= null;
			this.end_coords		= null;
			this.t_value		= 0;
			this.timer			= null;
			this.ms				= ms;

			// This method resets the transform.
			this.reset = function ()
				{	DOMFuncs.debug("Resetting snap transform.");

					// Reset the time value.
					this.t_value = 0;
				}; // function reset ()

			// This method sets the element to transform.
			this.setNode = function (node)
				{	DOMFuncs.debug("Setting transform element.");

					// Set the element.
					this.node = node;

					// Get its ending coordinates (the element's current coordinates.)
					this.end_coords = DOMFuncs.getPosition(node);

					// Get the starting location.
					var start_x = node.drag_start_x	? node.drag_start_x : this.end_coords.getX();
					var start_y = node.drag_start_y	? node.drag_start_y : this.end_coords.getY();

					// Get its ending coordinates (the coordinates before the drag began.)
					this.start_coords = new DOMCoords(start_x, start_y);

					DOMFuncs.debug("End Pos: " + this.end_coords.getX() + ", " + this.end_coords.getY());
					DOMFuncs.debug("Start Pos: " + this.start_coords.getX() + ", " + this.start_coords.getY());
				}; // function setNode (element)

			// This method starts the transform.
			this.start = function ()
				{	// Setup a timer to process the transform.
					if ( this.node != null )
						{	DOMFuncs.debug("Starting snap transform.");

							// Notify the element that the transform is beginning.
							if ( this.node.onBeginTransform )
								{	this.node.onBeginTransform(this);
								}; // if ( this.node.onBeginTransform )

							// Create a reference to ourself.
							var _self = this;

							// Set the interval.
							this.timer = setInterval(function (ms) { _self.update(ms); }, this.ms);
						}; // if ( this.node != null )
				}; // function start ()

			// This method stops the transform.
			this.stop = function ()
				{	DOMFuncs.debug("Stopping snap transform.");

					// Clear the timer.
					clearInterval(this.timer);

					// Make sure the node is at 

					// Notify the element that the transform has stopped.
					if ( this.node.onEndTransform )
						{	this.node.onEndTransform(this);
						}; // if ( this.node.onEndTransform )
				}; // function stop ()

			// This method updates the transform.
			this.update = function (ms)
				{	DOMFuncs.debug("Updating snap transform on " + this.node.nodeName + " at t = " + this.t_value);

					// Update the time value.					
					if ( (this.t_value += 5) <= 100 )
						{	// Compute the new coordinates.
							var coords = this.end_coords.linearPos(this.start_coords, this.t_value / 100);

							// Set the element's new value.
							this.node.style.left	= Math.floor(coords.x) + "px";
							this.node.style.top	= Math.floor(coords.y) + "px";

							// Notify the element that the transform has been updated.
							if ( this.node.onUpdateTransform )
								{	this.node.onUpdateTransform(this, this.t_value / 100);
								}; // if ( this.node.onUpdateTransform )
						} // if ( (this.t_value += 5) <= 100 )

					// Stop the transform.
					else
						{	this.stop();
						}; // else
				}; // function update (ms)

			return this;
		}; // function SnapToTransform ()

	// This class is responsible for registering and unregistering events.
	var EventClass =
		{	// This method registers an event.
			register: 				
				function (element, event_id, func, useCapture)
					{	if ( element.addEventListener ) 
							{	element.addEventListener(event_id.replace(/^on/, ""), func, useCapture);
							} // if ( element.addEventListener ) 

						else if ( element.attachEvent ) 
							{	element.attachEvent(event_id, func);
							} // else if ( element.attachEvent ) 

						else 
							{	element[event_id] = func;
							}; // else
					}, // function register (element, event_id, func, useCapture)

			// This method unregisters an event.
			unregister:
				function (element, event_id, func, useCapture)
					{	if ( element.removeEventListener ) 
							{	element.removeEventListener(event_id.replace(/^on/, ""), func, useCapture);
							} // if ( element.removeEventListener ) 

						else if ( element.attachEvent ) 
							{	element.detachEvent(event_id, func);
							} // else if ( element.attachEvent ) 

						else 
							{	element[event_id] = null;
							}; // else
					} // function unregister (element, event_id, func, useCapture)
		}; // var EventClass		

	// This class defines common DOM utility functions.
	var DOMFuncs = 
		{	// The current debugging index.
			debug_index: 1,
			
			// This method outputs a debugging message.
			debug: function (msg)
				{	// Get the debug component.
					var debug = document.getElementById("debug");

					// We will supply a default element.
					if ( !debug )
						{	// Create the debugging window.
							debug = document.createElement("div");

							// Set its id.
							debug.id = "debug";

							// Create the background.
							var bkg = document.createElement("div");

							// Set its CSS class name.
							bkg.className = "bkg";

							// Add it to the window.
							debug.appendChild(bkg);

							// Create the header.
							var header = document.createElement("h1");

							// Set its content.
							header.innerHTML = "&nbsp;";

							// Set the method to get the drag container.
							header.getDragContainer = function ()
								{	return this.parentNode;
								}; // function getDragContainer ()

							// Make the window draggable.
							DragClass.createDragObject(header, new DragProperties(false, .5, false, null, 0));

							// Add it to the debug window.
							debug.appendChild(header);

							// Create the debug list.
							var list = document.createElement("ol");

							// Set its class.
							list.className = "debug_lines";
					
							// Add it to the debug window.
							debug.appendChild(list);																							
							
							// Add the component to the document.
							document.getElementsByTagName("body").item(0).appendChild(debug);
						}; // if ( !debug )
			
					// Output the debug message.
					if ( debug )
						{	// Get the existing content.
							var content = debug.getElementsByTagName("ol").item(0);

							// Sanitize the message.
							msg = msg.replace(/&/, "&amp;");
							msg = msg.replace(/</, "&lt;");
							msg = msg.replace(/</, "&gt;");

							// Create the new content.
							var item		= document.createElement("li");
							item.innerHTML	= msg;

							// Append the item.
							content.appendChild(item);
							
							// Set the new debugging value.
							//debug.innerHTML = "<strong>Line " + (this.debug_index++) + "</strong>: " + msg + ( this.debug_index > 2 ? "<br />" : "" ) + content;
						}; // if ( debug )
				}, // function debug (msg)

			// This method returns the dimensions of a DOM node.
			getDimensions:
				function (node)
					{	// Get the dimensions.
						var width	= node.offsetWidth;
						var height	= node.offsetHeight;

						// Create the DOM dimensions.
						var dimensions = new DOMDimensions(width, height);

						return dimensions;
					}, // function getDimensionsize (node)
			
			// This method returns the current position of a DOM node.
			getPosition: 
				function (node)
					{	// The current coordinates.
						var x = 0;
						var y = 0;
						var element = node;

						// Get the current coordinates.
						while ( node )
							{	// Fix for absolute positioned parents.
								//if ( getStyle(node, "position") == "absolute" )
								//	{	break;
								//	}; // if ( getStyle(node, "position") == "absolute" )
								// End fix.

								x		+= node.offsetLeft;
								y		+= node.offsetTop;

								node	= node.offsetParent;									
							}; // while ( node )

						var padding_left	= element ? getStyle(element, "padding-left") : "0";
						padding_left		= parseInt(padding_left.replace(/px$/, ""));

						// Create the DOM coordinate.
						var coords = new DOMCoords(x + padding_left, y);

						return coords;
					}, // function getPosition (node)
					
			// The method sets the opacity on a node; where the opacity is a number between 0 and 1 inclusive.
			setOpacity: function (node, opacity)
				{	// Set it the standard way.
					node.style.opacity	= opacity;

					// Take care of Internet Explorer.
					//node.style.filter	= "alpha(opacity=" + parseInt(100 * opacity) + ")";

					//DOMFuncs.debug("alpha(opacity=" + parseInt(100 * opacity) + ")");
				} // setOpacity: function (node)

		}; // var DOMFuncs

	// This function defines a class representing a coordinate.
	function DOMCoords (x, y)
		{	// Initialize the object.
			this.x = x;
			this.y = y;

			// This method computes the distance between two coordinates.
			this.distance = function (coords)
				{	// Compute the displacements.
					var dx = coords.getX() - this.x;
					var dy = coords.getY() - this.y;

					// Compute the distance squared.
					var dist2 = dx * dx + dy * dy;

					// Zero distance.
					if ( dist2 <= 0 )
						{	return 0;
						} // if ( dist2 <= 0 )

					// Non-zero distance.
					else
						{	return Math.sqrt(dist2);
						}; // else
				}; // function (coords)
			
			// This method returns the x-coordinate.
			this.getX = function ()
				{	return this.x;
				}; // function getX ()

			// This method returns the y-coordinate.
			this.getY = function ()
				{	return this.y;
				}; // function getY ()

			// This method computes the position along a line at a given time value.
			this.linearPos = function (end_coords, time)
				{	// Compute the coordinates.
					var x = this.x + time * (end_coords.x - this.x);
					var y = this.y + time * (end_coords.y - this.y);

					// Create the coordinate.
					var coords = new DOMCoords(x, y);

					return coords;
				}; // this.linearPos = function (end_coords, time)

			return this;
		}; // function DOMCoords (x, y)

	// This function defines a class representing dimensions.
	function DOMDimensions (width, height)
		{	// Initialize the object.
			this.width	= width;
			this.height	= height;

			// This method returns the height.
			this.getHeight = function ()
				{	return this.height;
				}; // function getHeight ()
			
			// This method returns the width.
			this.getWidth = function ()
				{	return this.width;
				}; // function getWidth ()

			return this;
		}; // function DOMCoords (x, y)

	// This method defines a class representing drag object properties.
	function DragProperties (drop_ids, opacity, clone_object, transform, drag_threshold)
		{	// Set the attributes.
			this.drop_ids		= drop_ids;
			this.opacity		= opacity;
			this.clone_object	= clone_object;
			this.transform		= transform;
			this.drag_threshold	= drag_threshold ? drag_threshold : 0;

			// This method returns the drop ids.
			this.getDropIds = function ()
				{	return this.drop_ids;
				}; // function getDropIds ()

			// This method returns the drag opacity.
			this.getDragOpacity = function ()
				{	return this.opacity;
				}; // function getDragOpacity ()

			// This method returns the drag threshold.
			this.getDragThreshold = function ()
				{	return this.drag_threshold;
				}; // function getDragThreshold ()

			// This method returns the transform to apply when the user releases the drag object.
			this.getTransform = function ()
				{	return this.transform;
				}; // function getTransform ()

			// This method returns the clone flag.
			this.isCloneable = function ()
				{	return this.clone_object;
				}; // function isCloneable ()			

			return this;
		}; // function DragProperties (drop_ids, opacity, clone_object, transform, drag_threshold)

	// This class is responsible for providing drag functionality.
	var DragClass =
			{	// Initialize the class.
				STATE_ACTIVE:		"active",
				STATE_DRAGGING:		"dragging",
				STATE_INACTIVE:		"inactive",
				curr_drag_object:	null,
				curr_drag_x:		null,
				curr_drag_y:		null,
				curr_drag_dx:		null,
				curr_drag_dy:		null,
				top_layer:			999,
				threshold_met:		false,

				// This method creates a new drag object.
				createDragObject: function (element, drag_props)
					{	// Set the drag properties.
						element.drag_props			= drag_props ? drag_props : new DragProperties(null, 100);
						element.getDragProperties	= function () { return this.drag_props; };

						// Set miscellaneous methods.
						element.getDragContainer	= element.getDragContainer ? element.getDragContainer : function () { return null; };
						element.getDragValue		= element.getDragValue ? element.getDragValue : function () { return undefined; };

						// Set the event handlers.
						element.onDragClick			= element.onclick ? element.onclick : function () { return false; };						
						element.onDragReleased		= element.onDragReleased ? element.onDragReleased : function () { };
						element.onDropTarget		= element.onDropTarget ? element.onDropTarget : function () { };
						element.onclick				= function () { return false; };
						element.onmousemove			= null;
						element.onmouseup			= null;
						element.onmousedown			= function (event) { DragClass.setDragObject(this, DragClass.fixEventCoords(event)); return false; };
					}, // function createDragObject (element, drag_props)

				// This method fixes the event coordinates.
				fixEventCoords: function (event)
					{	event		= event != null ? event : window.event;
						var coords	= new DOMCoords(event.clientX, event.clientY);

						return coords;
					}, // function fixEventCoords (event)

				// This method returns the current drag object.
				getDragObject: function (drag_object)
					{	return this.curr_drag_object;
					}, // function getDragObject (drag_object)

				// Initialize the drag parameters.
				initDragParams: function (drag_object, event)
					{	// Get the current coordinates.
						var drag_coords = DOMFuncs.getPosition(drag_object);
						var drag_x		= drag_coords.getX();
						var drag_y		= drag_coords.getY();						

						// Save the drag coordinates and compute the displacement coordinates.
						this.curr_drag_x			= drag_x;
						this.curr_drag_y			= drag_y;
						this.curr_drag_dx			= event.getX() - drag_x;
						this.curr_drag_dy			= event.getY() - drag_y;
						drag_object.drag_start_x	= drag_x;
						drag_object.drag_start_y	= drag_y;
					}, // function initDragParams (drag_object, event)

				// This method handles all drag move events.
				onDragMoved: function (event)
					{	// Update the drag object.
						this.updateDragObject(event);

						return false;
					}, // function onDragMoved (event)

				// This method handles all drag release events.
				onDragReleased: function (event)
					{	// Get the current drag object.
						var drag_object = this.getDragObject();
						var drag_x		= this.curr_drag_x;
						var drag_y		= this.curr_drag_y;

						// Get the drag object's dimensions.
						var dims		= DOMFuncs.getDimensions(drag_object);
						var drag_width	= dims.width;
						var drag_height	= dims.height;

						// Set the current drag object to null.
						this.setDragObject(null, event);

						// The object has been dragged.
						if ( this.threshold_met != false  )
							{	// Get the drag properties.
								var props = drag_object && drag_object.getDragProperties ? drag_object.getDragProperties() : false;

								// Get the drop ids.
								var drop_ids = props && props.getDropIds ? props.getDropIds() : false;
									
								// Get the containing drop object.
								var drop_object = DropClass.getDropObjectContaining(drop_ids, drag_x, drag_y, drag_width, drag_height);

								// Found the drop targer.
								if ( drop_object )
									{	drag_object.onDropTarget(drop_object);
										drop_object.onDragTargetDropped(drag_object);
									} // if ( drop_object )

								// Apply the transform.
								else
									{	/**
										// Get any transform the drag object may have defined.
										var transform = props && props.getTransform ? props.getTransform() : false;

										// Apply the transform.
										if ( transform )
											{	// Reset the transform.
												transform.reset();

												// Set the node to be transformed.
												transform.setNode(drag_object);

												// Now tell it to start transforming the drag object.
												transform.start();
											}; // if ( transform )
										**/
										drag_object.onDragReleased();
									}; // else
							} // if ( this.threshold_met != false )

						// The object has not been dragged; therefore, execute the onclick event.
						else if ( drag_object.onDragClick )
							{	drag_object.onDragClick(event);
							}; // else if ( drag_object.onDragClick )

						return false;
					}, // function onDragReleased (event)

				// This method handles all mouse move events.
				onMouseMove: function (event)
					{	// Fix the event.
						event = DragClass.fixEventCoords(event);

						// Update the drag object.
						DragClass.onDragMoved(event);

						return false;
					}, // function onMouseMove (event)
				
				// This method handles all mouse release events.
				onMouseUp: function (event)
					{	// Fix the event.
						event = DragClass.fixEventCoords(event);
					
						// Notify the drag class.
						DragClass.onDragReleased(event);

						return false;
					}, // function onMouseUp (event)

				// This method sets the current drag object.
				setDragObject: function (drag_object, event)
					{	// Set the object's new z-index to place it on top of all other objects.
						if ( drag_object != null )
							{	if ( !drag_object.canDrag || drag_object.canDrag() )
									{	// Notify the existing drag object.
										if ( this.curr_drag_object != null && drag_object.onEndDrag )
											{	drag_object.onEndDrag(event);
											}; // if ( this.curr_drag_object != null && drag_object.onEndDrag )

										// Get the drag properties.
										var props = drag_object.getDragProperties ? drag_object.getDragProperties() : false;

										// Determine if this object should be cloned.
										var clone_object = props && props.isCloneable && props.isCloneable();

										// Get the node to use.
										var node = clone_object ? drag_object.cloneNode(true) : drag_object;

										// Get the drag container if it exists.
										var drag_container = drag_object.getDragContainer ? drag_object.getDragContainer() : null;

										// Set its opacity.
										var opacity	= "" + (props && props.getDragOpacity() ? props.getDragOpacity() : 1);		
										DOMFuncs.setOpacity(drag_container != null ? drag_container : node, opacity);

										// Set its new z-index.
										if ( drag_container == null )
											{	node.style.position	= "absolute";
												node.style.zIndex	= this.top_layer++;		
											} // if ( drag_container == null )

										else
											{	drag_container.style.position	= "absolute";
												drag_container.style.zIndex		= this.top_layer++;		
											}; // else

										// Clone this object.
										if ( clone_object )
											{	// Set the drag object's clone.
												drag_object.drag		= {};
												drag_object.drag.clone	= node;
												
												// Copy essential properties.
												node.drag_props			= drag_object.getDragProperties();
												node.getDragProperties	= function () { return this.drag_props; };
												node.getDragValue		= drag_object.getDragValue ? drag_object.getDragValue : function () { return undefined; };
												node.onDragClick		= drag_object.onDragClick ? drag_object.onDragClick : function (event) { return true; };
												node.onDragReleased		= drag_object.onDragReleased ? drag_object.onDragReleased : function (event) { return true; };
												node.onDropTarget		= drag_object.onDropTarget ? drag_object.onDropTarget : function (drop_object) { return true; };

												// Get the current coordinates.
												var coords = DOMFuncs.getPosition(drag_object);
												var curr_x = coords.getX();
												var curr_y = coords.getY();

												// Set the clone's coordinates.
												node.style.left = curr_x + "px";
												node.style.top	= curr_y + "px";

												// @fix 07/17/2008 - Links inside absolutely positioned parents with clipping set weren't working properly.

												// Check if this node has is a absolutely positioned parent.
												var absPos	= false;
												var pnode	= drag_object.offsetParent;

												while ( pnode )
													{	if ( getStyle(pnode, "position") == "absolute" )
															{	absPos = true;
															}; // if ( getStyle(pnode, "position") == "absolute" )
														pnode	= pnode.offsetParent;
													}; // while ( node.offsetParent )

												// Insert the clone into the document.
												if ( !absPos )
													{	drag_object.parentNode.insertBefore(node, drag_object);
													} // if ( !absPos )

												else
													{	document.getElementsByTagName("body").item(0).appendChild(node);
														node.className = "free_drag_object";
													}; // else

												// @end_fix 07/17/2008

												// Copy over any transformation event handlers.
												if ( drag_object.onBeginTransform )
													{	node.onBeginTransform = drag_object.onBeginTransform;
													}; // if ( drag_object.onBeginTransform )

												if ( drag_object.onEndTransform )
													{	node.onEndTransform = drag_object.onEndTransform;
													}; // if ( drag_object.onBeginTransform )

												if ( drag_object.onUpdateTransform )
													{	node.onUpdateTransform = drag_object.onUpdateTransform;
													}; // if ( drag_object.onUpdateTransform )

												// We don't do this here because the clone wouldn't have the same CSS style then.
												//document.getElementsByTagName("body").item(0).appendChild(node);
											}; // if ( clone_object )

										// Set the current drag object.
										this.curr_drag_object = node;
										
										// Notify the drag object.
										if ( drag_object.onBeginDrag )
											{	drag_object.onBeginDrag(event);
											}; // if ( drag_object.onBeginDrag )

										// Reset the drag threshold.
										this.threshold_met = false;

										// Capture all events.
										EventClass.register(document, "onmousemove", this.onMouseMove, false);
										EventClass.register(document, "onmouseup", this.onMouseUp, false);							
									}; // if ( !drag_object.canDrag || drag_object.canDrag() )
							} // if ( drag_object != null )

						else
							{	// Restore the opacity.
								// @note: Should restore to the opacity the object had upon clicking.
								if ( this.curr_drag_object != null )
									{	// Get the node to revert the opacity of.
										var node	= this.curr_drag_object.getDragContainer ? this.curr_drag_object.getDragContainer() : null;
										node		= node != null ? node : this.curr_drag_object;

										// Revert the opacity.
										DOMFuncs.setOpacity(node, 1);
									}; // if ( this.curr_drag_object != null )
							
								// Notify the existing drag object.
								if ( this.curr_drag_object != null && this.curr_drag_object.onEndDrag )
									{	this.curr_drag_object.onEndDrag(event);
									}; // if ( this.curr_drag_object != null && this.curr_drag_object.onEndDrag )							
							
								// Set the current drag object.
								this.curr_drag_object	= null;
								this.curr_drag_x		= null;
								this.curr_drag_y		= null;
								this.curr_drag_dx		= null;
								this.curr_drag_dy		= null;

								// Clear all events.
								EventClass.unregister(document, "onmousemove", this.onMouseMove, false);
								EventClass.unregister(document, "onmouseup", this.onMouseUp, false);								
							}; // else
					}, // function setDragObject (drag_object, event)	
					
				// This method updates the current drag object.
				updateDragObject: function (event)
					{	// Update the drag object.
						if ( this.curr_drag_object != null )
							{	// Initialize the drag parameters.
								if ( this.curr_drag_x == null )
									{	this.initDragParams(this.curr_drag_object, event);										
									}; // if ( this.curr_drag_x == null )
								
								// Compute the next coordinates.
								var new_x = event.getX() - this.curr_drag_dx;
								var new_y = event.getY() - this.curr_drag_dy;

								// The drag threshold hasn't been met.
								if ( !this.threshold_met )
									{	// Get the drag properties.
										var props = this.curr_drag_object.getDragProperties ? this.curr_drag_object.getDragProperties() : false;

										// Get the drag threshold.
										var drag_threshold = props.getDragThreshold ? props.getDragThreshold() : 0;

										// Create the two coordinates to compare.
										var coord1 = new DOMCoords(this.curr_drag_x, this.curr_drag_y);
										var coord2 = new DOMCoords(new_x, new_y);

										// Compute the distance between the two coordinates.
										var dist = coord1.distance(coord2);		

										// The threshold has not been met.
										if ( dist < drag_threshold )
											{	return false;
											}; // if ( dist < drag_threshold )

										// The threshold has been met; therefore, set our flag.
										this.threshold_met = true;
										DOMFuncs.debug("Threshold met at distance " + dist + "!!!");
									}; // if ( !this.threshold_met )

								// Get the drag container if it exists.
								var drag_container = this.curr_drag_object.getDragContainer ? this.curr_drag_object.getDragContainer() : null;

								// Update the drag object's coordinates.
								if ( drag_container == null )
									{	this.curr_drag_object.style.left	= new_x + "px";
										this.curr_drag_object.style.top		= new_y + "px";
									} // if ( drag_container == null )

								// Actually move the drag container instead.
								else
									{	// Get the drag container's current coordinates.
										var coords = DOMFuncs.getPosition(drag_container);

										// Set the drag container's new coordinates.
										drag_container.style.left	= (coords.getX() + ( new_x - this.curr_drag_x )) + "px";
										drag_container.style.top	= (coords.getY() + ( new_y - this.curr_drag_y )) + "px";
									}; // else

								// Save the new drag coordinates.
								this.curr_drag_x = new_x;
								this.curr_drag_y = new_y;
							}; // if ( this.curr_drag_object != null )
					} // function updateDragObject (event)

			}; // function DragClass ()