<?

if($folder == "base") {
	$serverpath = ".";
} else {
	$serverpath = "..";
}

// SPECIFY PATHS TO SMARTY RESOURCES
$smartypath_template_dir = realpath("$serverpath/templates");
$smartypath_compile_dir = realpath("$serverpath/include/smarty/templates_c");
$smartypath_cache_dir = realpath("$serverpath/include/smarty/cache");
$smartypath_config_dir = realpath("$serverpath/include/smarty/configs");

// INITIATE SMARTY CLASS
require("$serverpath/include/smarty/Smarty.class.php");
$smarty = new Smarty();

// ASSIGN SMARTY TEMPLATE DIRECTORY PATHS
$smarty->template_dir = $smartypath_template_dir;
$smarty->compile_dir = $smartypath_compile_dir;
$smarty->cache_dir = $smartypath_cache_dir;
$smarty->config_dir = $smartypath_config_dir;

?>
<?
$database_host = 'localhost';
$database_username = 'de5z6k1_db39127_';
$database_password = 'vbxud?FkJGUn1xg4';
$database_name = 'de5z6k1_db39127_slackengine';
?><?

//  THIS CLASS CONTAINS DATABASE-RELATED METHODS
//  IT IS USED TO CONNECT TO THE DATABASE, RUN QUERIES, AND REPORT ERRORS
//  CURRENTLY MySQL IS THE DATABASE TYPE, EVENTUALLY ADD SUPPORT FOR OTHER DATABASE TYPES
//  METHODS IN THIS CLASS:
//    se_database()
//    database_connect()
//    database_select()
//    database_query()
//    database_fetch_array()
//    database_fetch_assoc()
//    database_num_rows()
//    database_affected_rows()
//    database_set_charset()
//    database_real_escape_string()
//    database_insert_id()
//    database_error()
//    database_close()


class se_database {

	// INITIALIZE VARIABLES
	var $database_connection;		// VARIABLE REPRESENTING DATABASE LINK IDENTIFIER

	var $log_stats;				// VARIABLE DETERMINING WHETHER QUERY INFO SHOULD BE LOGGED
	var $query_stats;			// ARRAY CONTAINING RELEVANT INFORMATION ABOUT QUERIES RUN


	// THIS METHOD CONNECTS TO THE SERVER AND SELECTS THE DATABASE
	// INPUT: $database_host REPRESENTING THE DATABASE HOST
	//	  $database_username REPRESENTING THE DATABASE USERNAME
	//	  $database_password REPRESENTING THE DATABASE PASSWORD
	//	  $database_name REPRESENTING THE DATABASE NAME
	// OUTPUT: 
	function se_database($database_host, $database_username, $database_password, $database_name) {

	  $this->database_connection = $this->database_connect($database_host, $database_username, $database_password) or die($this->database_error());
	  $this->database_select($database_name) or die($this->database_error());
	
	  $this->log_stats = 1;
	  $this->query_stats = Array();

	} // END se_database() METHOD


	// THIS METHOD CONNECTS TO A DATABASE SERVER
	// INPUT: $database_host REPRESENTING THE DATABASE HOST
	//	  $database_username REPRESENTING THE DATABASE USERNAME
	//	  $database_password REPRESENTING THE DATABASE PASSWORD
	// OUTPUT: RETURNS A DATABASE LINK IDENTIFIER
	function database_connect($database_host, $database_username, $database_password) {

	  return mysql_connect($database_host, $database_username, $database_password, TRUE);

	} // END database_connect() METHOD


	// THIS METHOD SELECTS A DATABASE
	// INPUT: $database_name REPRESENTING THE DATABASE NAME
	// OUTPUT: RETURNS OUTPUT FOR DATABASE SELECTION
	function database_select($database_name) {

	  return mysql_select_db($database_name, $this->database_connection);

	} // END database_select() METHOD


	// THIS METHOD QUERIES A DATABASE
	// INPUT: $database_query REPRESENTING THE DATABASE QUERY TO RUN
	// OUTPUT: RETURNS A DATABASE QUERY RESULT RESOURCE
	function database_query($database_query) {
	
	  $query_timer_start = getmicrotime();
	  $query_result = mysql_query($database_query, $this->database_connection); 
	  
	  if($this->log_stats != 0) {
	    $query_time = round(getmicrotime()-$query_timer_start, 5);
	    $this->query_stats[] = Array('query' => $database_query,
					'time' => $query_time);
	  }

	  return $query_result;

	} // END database_query() METHOD


	// THIS METHOD FETCHES A ROW AS A NUMERIC ARRAY
	// INPUT: $database_result REPRESENTING A DATABASE QUERY RESULT RESOURCE
	// OUTPUT: RETURNS A NUMERIC ARRAY FOR A DATABASE ROW
	function database_fetch_array($database_result) {

	  return mysql_fetch_array($database_result);

	} // END database_fetch_array() METHOD


	// THIS METHOD FETCHES A ROW AS AN ASSOCIATIVE ARRAY
	// INPUT: $database_result REPRESENTING A DATABASE QUERY RESULT RESOURCE
	// OUTPUT: RETURNS AN ASSOCIATIVE ARRAY FOR A DATABASE ROW
	function database_fetch_assoc($database_result) {

	  return mysql_fetch_assoc($database_result);

	} // END database_fetch_assoc() METHOD


	// THIS METHOD RETURNS THE NUMBER OF ROWS IN A RESULT
	// INPUT: $database_result REPRESENTING A DATABASE QUERY RESULT RESOURCE
	// OUTPUT: RETURNS THE NUMBER OF ROWS IN A RESULT
	function database_num_rows($database_result) {

	  return mysql_num_rows($database_result);

	} // END database_num_rows() METHOD


	// THIS METHOD RETURNS THE NUMBER OF ROWS IN A RESULT
	// INPUT: $database_result REPRESENTING A DATABASE QUERY RESULT RESOURCE
	// OUTPUT: RETURNS THE NUMBER OF ROWS IN A RESULT
	function database_affected_rows() {

	  return mysql_affected_rows($this->database_connection);

	} // END database_affected_rows() METHOD 


	// THIS METHOD SETS THE CLIENT CHARACTER SET FOR THE CURRENT CONNECTION
	// INPUT: $charset REPRESENTING A VALID CHARACTER SET NAME
	// OUTPUT: 
	function database_set_charset($charset) {

	  if(function_exists('mysql_set_charset') === TRUE) {
	    return mysql_set_charset($charset, $this->database_connection);
	  } else {
	    return $this->database_query('SET NAMES "'.$charset.'"');
	  }

	} // END database_set_charset() METHOD 


	// THIS METHOD ESCAPES SPECIAL CHARACTERS IN A STRING FOR USE IN AN SQL STATEMENT
	// INPUT: $unescaped_string REPRESENTING THE STRING TO ESCAPE
	// OUTPUT: 
	function database_real_escape_string($unescaped_string) {

	  return mysql_real_escape_string($unescaped_string, $this->database_connection);

	} // END database_real_escape_string() METHOD 


	// THIS METHOD RETURNS THE ID GENERATED FROM THE PREVIOUS INSERT OPERATION
	// INPUT: 
	// OUTPUT: RETURNS THE ID GENERATED FROM THE PREVIOUS INSERT OPERATION
	function database_insert_id() {

	  return mysql_insert_id($this->database_connection);

	} // END database_insert_id() METHOD


	// THIS METHOD RETURNS THE DATABASE ERROR
	// INPUT: 
	// OUTPUT: 
	function database_error() {

	  return mysql_error($this->database_connection);

	} // END database_error() METHOD


	// THIS METHOD CLOSES A CONNECTION TO THE DATABASE SERVER
	// INPUT: 
	// OUTPUT: 
	function database_close() {

	  mysql_close($this->database_connection);

	} // END database_close() METHOD

}
?><?

//  THIS CLASS CONTAINS DATE/TIME-RELATED METHODS.
//  IT IS USED TO FORMAT TIMESTAMPS
//  METHODS IN THIS CLASS:
//    cdate()
//    untimezone()
//    timezone()
//    time_since()
//    age()


class se_datetime {

	// INITIALIZE VARIABLES
	var $is_error;			// DETERMINES WHETHER THERE IS AN ERROR OR NOT


	// THIS METHOD SETS INITIAL VARS SUCH AS PRELOADING LANG VARS
	// INPUT:  
	// OUTPUT: 
	function se_datetime() {
	  SE_Language::_preload_multi(773, 774, 775, 776, 777, 778, 779);
	} // END se_datetime() METHOD


	// THIS METHOD RETURNS A FORMATTED DATE (MULTILANGUAGE)
	// INPUT: $format REPRESENTING A DATE FORMAT BASED ON THE PHP DATE() FUNCTION FORMAT
	//	  $time (OPTIONAL) REPRESENTING A TIMESTAMP
	// OUTPUT: A STRING REPRESENTING A FORMATTED DATE BASED ON THE GIVEN TIMESTAMP
	function cdate($format, $time = "") {
	  global $multi_language;

	  if($time == "") { $time = time(); }

	  if(!$multi_language) {
	    return date($format, $time);
	  } else {
	    $date_letters = Array("a", "A", "B", "c", "D", "d", "F", "m", "M", "I", "i", "g", "h", "H", "G", "j", "l", "L", "n", "O", "r", "S", "s", "t", "U", "W", "w", "Y", "y", "z", "Z", "T");
	    $strftime_letters = Array("%p", "%p", "", "", "%a", "%d", "%B", "%m", "%b", "", "%M", "%I", "%I", "%H", "%H", "%e", "%A", "", "%m", "", "", "", "%S", "", "", "%V", "%w", "%Y", "%y", "%j", "", "%Z");
	    $new_format = str_replace($date_letters, $strftime_letters, $format);
	    return strftime($new_format, $time);
	  }

	} // END cdate() METHOD


	// THIS METHOD RETURNS A TIMESTAMP IN THE SERVER TIMEZONE
	// INPUT: $time REPRESENTING A TIMESTAMP IN USER'S TIME
	//	  $timezone REPRESENTING A TIMEZONE
	// OUTPUT: A TIMESTAMP IN THE SERVER TIMEZONE
	function untimezone($time, $timezone) {

	  switch($timezone) {
	    case -12: $new_time = $time + 43200; break;
	    case -11: $new_time = $time + 39600; break;
	    case -10: $new_time = $time + 33000; break;
	    case -9: $new_time = $time + 32400; break;
	    case -8: $new_time = $time + 28800; break;
	    case -7: $new_time = $time + 25200; break;
	    case -6: $new_time = $time + 21600; break;
	    case -5: $new_time = $time + 18000; break;
	    case -4: $new_time = $time + 14400; break;
	    case -3.3: $new_time = $time + 11880; break;
	    case -3: $new_time = $time + 10800; break;
	    case -2: $new_time = $time + 7200; break;
	    case -1: $new_time = $time + 3600; break;
	    case 0: $new_time = $time; break;
  	    case 1: $new_time = $time - 3600; break;
  	    case 2: $new_time = $time - 7200; break;
  	    case 3: $new_time = $time - 10800; break;
  	    case 3.3: $new_time = $time - 11880; break;
  	    case 4: $new_time = $time - 14400; break;
  	    case 4.3: $new_time = $time - 15480; break;
  	    case 5: $new_time = $time - 18000; break;
  	    case 5.5: $new_time = $time - 19800; break;
  	    case 6: $new_time = $time - 21600; break;
  	    case 7: $new_time = $time - 25200; break;
  	    case 8: $new_time = $time - 28800; break;
  	    case 9: $new_time = $time - 32400; break;
  	    case 9.3: $new_time = $time - 33480; break;
  	    case 10: $new_time = $time - 33000; break;
  	    case 11: $new_time = $time - 39600; break;
  	    case 12: $new_time = $time - 43200; break;
	  }

	  $new_time = $new_time+(date("Z")-(date("I")*3600));

	  return $new_time;
  
	} // END untimezone() METHOD


	// THIS METHOD RETURNS A TIMESTAMP IN THE CORRECT TIMEZONE
	// INPUT: $time REPRESENTING A TIMESTAMP IN SERVER TIME
	//	  $timezone REPRESENTING A TIMEZONE
	// OUTPUT: A TIMESTAMP IN THE CORRECT TIMEZONE
	function timezone($time, $timezone) {

	  $time = $time-(date("Z")-(date("I")*3600));

	  switch($timezone) {
	    case -12: $new_time = $time - 43200; break;
	    case -11: $new_time = $time - 39600; break;
	    case -10: $new_time = $time - 33000; break;
	    case -9: $new_time = $time - 32400; break;
	    case -8: $new_time = $time - 28800; break;
	    case -7: $new_time = $time - 25200; break;
	    case -6: $new_time = $time - 21600; break;
	    case -5: $new_time = $time - 18000; break;
	    case -4: $new_time = $time - 14400; break;
	    case -3.3: $new_time = $time - 11880; break;
	    case -3: $new_time = $time - 10800; break;
	    case -2: $new_time = $time - 7200; break;
	    case -1: $new_time = $time - 3600; break;
	    case 0: $new_time = $time; break;
  	    case 1: $new_time = $time + 3600; break;
  	    case 2: $new_time = $time + 7200; break;
  	    case 3: $new_time = $time + 10800; break;
  	    case 3.3: $new_time = $time + 11880; break;
  	    case 4: $new_time = $time + 14400; break;
  	    case 4.3: $new_time = $time + 15480; break;
  	    case 5: $new_time = $time + 18000; break;
  	    case 5.5: $new_time = $time + 19800; break;
  	    case 6: $new_time = $time + 21600; break;
  	    case 7: $new_time = $time + 25200; break;
  	    case 8: $new_time = $time + 28800; break;
  	    case 9: $new_time = $time + 32400; break;
  	    case 9.3: $new_time = $time + 33480; break;
  	    case 10: $new_time = $time + 33000; break;
  	    case 11: $new_time = $time + 39600; break;
  	    case 12: $new_time = $time + 43200; break;
	  }

	  return $new_time;
  
	} // END timezone() METHOD


	// THIS METHOD RETURNS A STRING SPECIFYING THE TIME SINCE THE SPECIFIED TIMESTAMP
	// INPUT: $time REPRESENTING A TIMESTAMP
	// OUTPUT: A STRING SPECIFYING THE TIME SINCE THE SPECIFIED TIMESTAMP
	function time_since($time) {

	  $now = time();
	  $now_day = date("j", $now);
	  $now_month = date("n", $now);
	  $now_year = date("Y", $now);

	  $time_day = date("j", $time);
	  $time_month = date("n", $time);
	  $time_year = date("Y", $time);
	  $time_since = "";
	  $lang_var = 0;

	  switch(TRUE) {
	  
	    case ($now-$time < 60):
	      // RETURNS SECONDS
	      $seconds = $now-$time;
	      $time_since = $seconds;
	      $lang_var = 773;
	      break;
	    case ($now-$time < 3600):
	      // RETURNS MINUTES
	      $minutes = round(($now-$time)/60);
	      $time_since = $minutes;
	      $lang_var = 774;
	      break;
	    case ($now-$time < 86400):
	      // RETURNS HOURS
	      $hours = round(($now-$time)/3600);
	      $time_since = $hours;
	      $lang_var = 775;
	      break;
	    case ($now-$time < 1209600):
	      // RETURNS DAYS
	      $days = round(($now-$time)/86400);
	      $time_since = $days;
	      $lang_var = 776;
	      break;
	    case (mktime(0, 0, 0, $now_month-1, $now_day, $now_year) < mktime(0, 0, 0, $time_month, $time_day, $time_year)):
	      // RETURNS WEEKS
	      $weeks = round(($now-$time)/604800);
	      $time_since = $weeks;
	      $lang_var = 777;
	      break;
	    case (mktime(0, 0, 0, $now_month, $now_day, $now_year-1) < mktime(0, 0, 0, $time_month, $time_day, $time_year)):
	      // RETURNS MONTHS
	      if($now_year == $time_year) { $subtract = 0; } else { $subtract = 12; }
	      $months = round($now_month-$time_month+$subtract);
	      $time_since = $months;
	      $lang_var = 778;
	      break;
	    default:
	      // RETURNS YEARS
	      if($now_month < $time_month) { 
	        $subtract = 1; 
	      } elseif($now_month == $time_month) {
	        if($now_day < $time_day) { $subtract = 1; } else { $subtract = 0; }
	      } else { 
	        $subtract = 0; 
	      }
	      $years = $now_year-$time_year-$subtract;
	      $time_since = $years;
	      $lang_var = 779;
	      if($years == 0) { $time_since = ""; $lang_var = 0; }
	      break;

	  }

	  return Array($lang_var, $time_since);
  
	} // END time_since() METHOD


	// THIS METHOD RETURNS AN AGE BASED ON A GIVEN MYSQL DATE
	// INPUT: $time REPRESENTING A MYSQL-FORMAT DATE (YYYY-MM-DD)
	// OUTPUT: AN INTEGER REPRESENTING AN AGE BASED ON THE DATE
	function age($time) {

	  $now = time();
	  $now_day = date("d", $now);
	  $now_month = date("m", $now);
	  $now_year = date("Y", $now);

	  $time_day = substr($time, 8, 2);
	  $time_month = substr($time, 5, 2);
	  $time_year = substr($time, 0, 4);

	  // RETURNS YEARS
	  if($now_month < $time_month) { 
	    $subtract = 1; 
	  } elseif($now_month == $time_month) {
	    if($now_day < $time_day) {
	      $subtract = 1;
	    } else {
	      $subtract = 0;
	    }
	  } else { 
	    $subtract = 0; 
	  }
	  $years = $now_year-$time_year-$subtract;
	  return $years;
  
	} // END age() METHOD

}
?><?

//  THIS CLASS CONTAINS COMMENT-RELATED METHODS 
//  IT IS USED FOR ALL COMMENTING (INCLUDING PLUGINS)
//  METHODS IN THIS CLASS:
//    se_comment()
//    comment_total()
//    comment_list()
//    comment_post()
//    comment_edit()
//    comment_delete()
//    comment_delete_selected()


class se_comment {

	// INITIALIZE VARIABLES
	var $is_error;			// DETERMINES WHETHER THERE IS AN ERROR OR NOT

	var $comment_type;		// CONTAINS THE PREFIX CORRESPONDING TO THE COMMENT TYPE (EX: PROFILE FOR SE_PROFILECOMMENTS)
	var $comment_identifier;	// CONTAINS THE IDENTIFYING COLUMN IN THE TABLE (EX: USER_ID FOR SE_PROFILECOMMENTS)
	var $comment_identifying_value;	// CONTAINS THE VALUE TO MATCH TO THE IDENTIFIER


	// THIS METHOD SETS INITIAL VARS
	// INPUT: $type REPRESENTING THE PREFIX CORRESPONDING TO THE COMMENT TYPE
	//	  $identifier REPRESENTING THE IDENTIFYING COLUMN IN THE TABLE
	// OUTPUT: 
	function se_comment($type, $identifier, $identifying_value) {

	  $this->comment_type = $type;
	  $this->comment_identifier = $identifier;
	  $this->comment_identifying_value = $identifying_value;

	} // END se_comment() METHOD


	// THIS METHOD RETURNS THE TOTAL NUMBER OF COMMENTS
	// INPUT:
	// OUTPUT: AN INTEGER REPRESENTING THE NUMBER OF COMMENTS
	function comment_total() {
	  global $database;

	  $comment_query = "SELECT ".$this->comment_type."comment_id FROM se_".$this->comment_type."comments WHERE ".$this->comment_type."comment_".$this->comment_identifier."='".$this->comment_identifying_value."'";
	  $comments_total = $database->database_num_rows($database->database_query($comment_query));

	  return $comments_total;

	} // END comment_total() METHOD


	// THIS METHOD RETURNS AN ARRAY CONTAINING COMMENT INFO
	// INPUT: $start REPRESENTING THE COMMENT TO START WITH
	//	  $limit REPRESENTING THE NUMBER OF COMMENTS TO RETURN
	// OUTPUT: AN ARRAY OF COMMENTS
	function comment_list($start, $limit) {
	  global $database, $setting, $user;

	  $comment_array = Array();
	  $comment_query = "SELECT 
				se_".$this->comment_type."comments.*, 
				se_users.user_id, 
				se_users.user_username, 
				se_users.user_fname,
				se_users.user_lname,
				se_users.user_photo,
			CASE
			  WHEN ((se_users.user_privacy & @SE_PRIVACY_REGISTERED) AND {$user->user_exists}<>0)
			    THEN FALSE
			  WHEN ((se_users.user_privacy & @SE_PRIVACY_ANONYMOUS) AND {$user->user_exists}=0)
			    THEN FALSE
			  WHEN ((se_users.user_privacy & @SE_PRIVACY_SELF) AND se_users.user_id={$user->user_info[user_id]})
			    THEN FALSE
			  WHEN ((se_users.user_privacy & @SE_PRIVACY_FRIEND) AND (SELECT TRUE FROM se_friends WHERE friend_user_id1=se_users.user_id AND friend_user_id2={$user->user_info[user_id]} AND friend_status='1' LIMIT 1))
			    THEN FALSE
			  WHEN ((se_users.user_privacy & @SE_PRIVACY_SUBNET) AND se_users.user_subnet_id={$user->user_info[user_subnet_id]})
			    THEN FALSE
			  WHEN ((se_users.user_privacy & @SE_PRIVACY_FRIEND2) AND se_users.user_subnet_id={$user->user_info[user_subnet_id]} AND (SELECT TRUE FROM se_friends AS friends_primary LEFT JOIN se_friends AS friends_secondary ON friends_primary.friend_user_id2=friends_secondary.friend_user_id1 WHERE friends_primary.friend_user_id1=se_users.user_id AND friends_secondary.friend_user_id2={$user->user_info[user_id]} LIMIT 1))
			    THEN FALSE
			  ELSE TRUE
			END
			AS is_profile_private
			FROM 
				se_".$this->comment_type."comments 
			LEFT JOIN 
				se_users 
			ON 
				se_".$this->comment_type."comments.".$this->comment_type."comment_authoruser_id=se_users.user_id 
			WHERE 
				".$this->comment_type."comment_".$this->comment_identifier."='".$this->comment_identifying_value."' 
			ORDER BY ".$this->comment_type."comment_id DESC 
			LIMIT $start, $limit";

	  $comments = $database->database_query($comment_query);
	  while($comment_info = $database->database_fetch_assoc($comments)) {

	    // CREATE AN OBJECT FOR AUTHOR
	    $author = new se_user();
	    if($comment_info[user_id] != $comment_info[$this->comment_type.'comment_authoruser_id']) {
	      $author->user_exists = 0;
	    } else {
	      $author->user_exists = 1;
	      $author->user_info[user_id] = $comment_info[user_id];
	      $author->user_info[user_username] = $comment_info[user_username];
	      $author->user_info[user_fname] = $comment_info[user_fname];
	      $author->user_info[user_lname] = $comment_info[user_lname];
	      $author->user_info[user_photo] = $comment_info[user_photo];
	      $author->user_displayname();

	    }

	    // SET COMMENT ARRAY
	    $comment_array[] = Array('comment_id' => $comment_info[$this->comment_type.'comment_id'],
					'comment_authoruser_id' =>$comment_info[$this->comment_type.'comment_authoruser_id'],
					'comment_author' => $author,
					'comment_date' => $comment_info[$this->comment_type.'comment_date'],
					'comment_body' => $comment_info[$this->comment_type.'comment_body'],
					'comment_author_private' => $comment_info[is_profile_private]);
	  }

	  return $comment_array;

	} // END comment_list() METHOD


	// THIS METHOD POSTS A COMMENT
	// INPUT: $comment_body REPRESENTING THE COMMENT BODY BEING POSTED
	//	  $comment_secure REPRESENTING THE SECURITY CODE VALUE (IF APPLICABLE)
	//	  $object_title (OPTIONAL) REPRESENTING THE COMMENTED OBJECT'S TITLE
	//	  $object_owner (OPTIONAL) REPRESENTING THE OWNER OF THE OBJECT (ex 'user')
	//	  $object_owner_id (OPTIONAL) REPRESENTING THE OWNER OF THE OBJECT'S ID
	//	  $object_privacy (OPTIONAL) REPRESENTING THE PRIVACY OF THE OBJECT
	// OUTPUT: AN ARRAY CONTAINING ALL THE SAVED COMMENT DATA
	function comment_post($comment_body, $comment_secure, $object_title = "", $object_owner = "", $object_owner_id = 0, $object_privacy = "") {
	  global $database, $user, $owner, $setting, $actions, $notify, $url;

	  $comment_date = time();

	  // RETRIEVE AND CHECK SECURITY CODE IF NECESSARY
	  if($setting[setting_comment_code] != 0) {
	    session_start();
	    $code = $_SESSION['code'];
	    if($code == "") { $code = randomcode(); }
	    if($comment_secure != $code) { $this->is_error = 1; }
	  }

	  // MAKE SURE COMMENT BODY IS NOT EMPTY - ADD BREAKS AND CENSOR
	  $comment_body = str_replace("\r\n", "<br>", cleanHTML(censor($comment_body), $setting[setting_comment_html], Array("style")));
	  $comment_body = preg_replace('/(<br>){3,}/is', '<br><br>', $comment_body);
	  $comment_body = str_replace("'", "\'", $comment_body);
	  if(trim($comment_body) == "") { $this->is_error = 1; $comment_body = ""; }

	  // ADD COMMENT IF NO ERROR
	  if($this->is_error == 0) {

	    $database->database_query("INSERT INTO se_".$this->comment_type."comments (".$this->comment_type."comment_".$this->comment_identifier.", ".$this->comment_type."comment_authoruser_id, ".$this->comment_type."comment_date, ".$this->comment_type."comment_body) VALUES ('".$this->comment_identifying_value."', '".$user->user_info[user_id]."', '$comment_date', '$comment_body')");

	    // INSERT ACTION IF USER EXISTS
	    if($user->user_exists != 0) {
	      $commenter = $user->user_displayname;
	      $comment_body_encoded = $comment_body;
	      if(strlen(strip_tags($comment_body_encoded)) > 250) { $comment_body_encoded = cleanHTML(chopHTML($comment_body_encoded, 0, 240), $setting[setting_comment_html])."..."; }
	      $comment_body_encoded = str_replace(Array("<br>", "<br />"), " ", $comment_body_encoded);
	      $actions->actions_add($user, $this->comment_type."comment", Array($user->user_info[user_username], $user->user_displayname, $owner->user_info[user_username], $owner->user_displayname, $comment_body_encoded, $this->comment_identifying_value, $object_title), Array(), 0, false, $object_owner, $object_owner_id, $object_privacy);
	    } else {
	      SE_Language::_preload(835);
	      SE_Language::load();
	      $commenter = SE_Language::_get(835);
	    }

	    // SEND PROFILE COMMENT NOTIFICATION IF COMMENTER IS NOT OWNER
	    if($owner->user_info[user_id] != $user->user_info[user_id]) { 
	      $notifytype = $notify->notify_add($owner->user_info[user_id], $this->comment_type."comment", $this->comment_identifying_value, Array($owner->user_info[user_username], $this->comment_identifying_value), Array($object_title));
	      $object_url = $url->url_base.vsprintf($notifytype[notifytype_url], Array($owner->user_info[user_username], $this->comment_identifying_value));
	      $owner->user_settings();
	      if($owner->usersetting_info['usersetting_notify_'.$this->comment_type.'comment']) { send_systememail($this->comment_type."comment", $owner->user_info[user_email], Array($owner->user_displayname, $commenter, "<a href=\"$object_url\">$object_url</a>")); }
	    }

	  }

	  return Array('comment_body' => $comment_body, 'comment_date' => $comment_date);

	} // END comment_post() METHOD


	// THIS METHOD EDITS A COMMENT
	// INPUT: $comment_id REPRESENTING THE ID FOR THE COMMENT BEING EDITED
	//	  $comment_body REPRESENTING THE COMMENT BODY BEING EDITED
	// OUTPUT:
	function comment_edit($comment_id, $comment_body) {
	  global $database, $user, $setting;

	  // MAKE SURE COMMENT BODY IS NOT EMPTY - ADD BREAKS AND CENSOR
	  $comment_body = str_replace("\r\n", "<br>", cleanHTML(censor($comment_body), $setting[setting_comment_html]));
	  $comment_body = preg_replace('/(<br>){3,}/is', '<br><br>', $comment_body);
	  $comment_body = str_replace("'", "\'", $comment_body);

	  // EDIT COMMENT IF NO ERROR
	  if(trim($comment_body) != "") {
	    $database->database_query("UPDATE se_".$this->comment_type."comments SET ".$this->comment_type."comment_body='$comment_body' WHERE ".$this->comment_type."comment_".$this->comment_identifier."='".$this->comment_identifying_value."' AND ".$this->comment_type."comment_id=$comment_id AND ".$this->comment_type."comment_authoruser_id='".$user->user_info[user_id]."'");
	  }


	} // END comment_edit() METHOD


	// THIS METHOD DELETES A SINGLE COMMENT
	// INPUT: $comment_id REPRESENTING THE ID OF THE COMMENT TO DELETE
	// OUTPUT: 
	function comment_delete($comment_id) {
	  global $database;

	  $database->database_query("DELETE FROM se_".$this->comment_type."comments WHERE ".$this->comment_type."comment_".$this->comment_identifier."='".$this->comment_identifying_value."' AND ".$this->comment_type."comment_id=$comment_id");
	  

	} // END comment_delete() METHOD


	// THIS METHOD DELETES MANY COMMENTS BASED ON WHAT HAS BEEN POSTED
	// INPUT: $start REPRESENTING THE COMMENT TO START WITH
	//	  $limit REPRESENTING THE NUMBER OF COMMENTS TO RETURN
	// OUTPUT: 
	function comment_delete_selected($start, $limit) {
	  global $database;

	  $delete_query = "";
	  $comment_query = "SELECT se_".$this->comment_type."comments.".$this->comment_type."comment_id FROM se_".$this->comment_type."comments WHERE ".$this->comment_type."comment_".$this->comment_identifier."='".$this->comment_identifying_value."' ORDER BY ".$this->comment_type."comment_id DESC LIMIT $start, $limit";
	  $comments = $database->database_query($comment_query);
	  while($comment_info = $database->database_fetch_assoc($comments)) {
	    $var = "comment_".$comment_info[$this->comment_type.'comment_id'];

	    if($_POST[$var] == 1) {
	      if($delete_query != "") { $delete_query .= " OR "; }
	      $delete_query .= $this->comment_type."comment_id='".$comment_info[$this->comment_type.'comment_id']."'";
	    }
	  }

	  if($delete_query != "") { $database->database_query("DELETE FROM se_".$this->comment_type."comments WHERE $delete_query"); }

	} // END comment_delete_selected() METHOD

}
?><?


//  THIS CLASS CONTAINS UPLOAD-RELATED METHODS.
//  IT IS USED DURING THE UPLOAD OF A FILE.
//  METHODS IN THIS CLASS:
//    new_upload()
//    upload_file()
//    upload_photo()
//    upload_thumb()
//    image_resize_on()
//    ConvertBMP2GD()
//    imagecreatefrombmp()


class se_upload {

	// INITIALIZE VARIABLES
	var $is_error = 0;		// DETERMINES WHETHER THERE IS AN ERROR OR NOT, CONTAINS RELEVANT ERROR CODE

	var $file_name;			// CONTAINS NAME OF UPLOADED FILE
	var $file_type;			// CONTAINS UPLOADED FILE MIME TYPE
	var $file_size;			// CONTAINS UPLOADED FILE SIZE
	var $file_tempname;		// CONTAINS TEMP NAME OF UPLOADED FILE
	var $file_error;		// CONTAINS UPLOADED FILE ERROR
	var $file_ext;			// CONTAINS UPLOADED FILE EXTENSION
	var $file_width;		// CONTAINS UPLOADED IMAGE WIDTH
	var $file_height;		// CONTAINS UPLOADED IMAGE HEIGHT

	var $is_image;			// DETERMINES WHETHER FILE IS AN IMAGE OR NOT
	var $file_maxwidth;		// CONTAINS THE MAXIMUM WIDTH OF AN UPLOADED IMAGE
	var $file_maxheight;		// CONTAINS THE MAXIMUM HEIGHT OF AN UPLOADED IMAGE


	// THIS METHOD SETS INITIAL VARS SUCH AS FILE NAME
	// INPUT: $file REPRESENTING THE NAME OF THE FILE INPUT
	//	  $file_maxsize REPRESENTING THE MAXIMUM ALLOWED FILESIZE
	//	  $file_exts REPRESENTING AN ARRAY OF LOWERCASE ALLOWABLE EXTENSIONS
	//	  $file_types REPRESENTING AN ARRAY OF LOWERCASE ALLOWABLE MIME TYPES
	//	  $file_maxwidth (OPTIONAL) REPRESENTING THE MAXIMUM WIDTH OF THE UPLOADED PHOTO
	//	  $file_maxheight (OPTIONAL) REPRESENTING THE MAXIMUM HEIGHT OF THE UPLOADED PHOTO
	// OUTPUT: 
	function new_upload($file, $file_maxsize, $file_exts, $file_types, $file_maxwidth = "", $file_maxheight = "") {

	  // GET FILE VARS
	  $this->file_name = $_FILES[$file]['name'];
	  $this->file_type = strtolower($_FILES[$file]['type']);
	  $this->file_size = $_FILES[$file]['size'];
	  $this->file_tempname = $_FILES[$file]['tmp_name'];
	  $this->file_error = $_FILES[$file]['error'];
	  $this->file_ext = strtolower(str_replace(".", "", strrchr($this->file_name, "."))); 

	  $file_dimensions = @getimagesize($this->file_tempname);
	  $this->file_width = $file_dimensions[0];
	  $this->file_height = $file_dimensions[1];
	  if($file_maxwidth == "") { $file_maxwidth = $this->file_width; }
	  if($file_maxheight == "") { $file_maxheight = $this->file_height; }
	  $this->file_maxwidth = $file_maxwidth;
	  $this->file_maxheight = $file_maxheight;

	  // ENSURE THE FILE IS AN UPLOADED FILE
	  if(!is_uploaded_file($this->file_tempname)) { $this->is_error = 718; }

	  // CHECK THAT FILESIZE IS LESS THAN GIVEN FILE MAXSIZE
	  if($this->file_size > $file_maxsize) { $this->is_error = 719; }

	  // CHECK EXTENSION OF FILE TO MAKE SURE ITS ALLOWED
	  if(!in_array($this->file_ext, $file_exts)) { $this->is_error = 720; }

	  // CHECK MIME TYPE OF FILE TO MAKE SURE ITS ALLOWED
	  if(!in_array($this->file_type, $file_types)) { $this->is_error = 720; }

	  // DETERMINE IF FILE IS A PHOTO (AND IF GD CAN BE USED) - DO NOT COUNT GIFs AS IMAGES, OTHERWISE ANIMATION WON'T WORK!!
	  if($file_dimensions !== FALSE && in_array($this->file_ext, Array('jpg', 'jpeg', 'png', 'bmp', 'gif')) !== FALSE) {
	    $this->is_image = 1;
	    // ENSURE THE UPLOADED FILE IS NOT LARGER THAN MAX WIDTH AND HEIGHT IF GD IS NOT AVAILABLE
	    if(!$this->image_resize_on()) {
	      $this->is_image = 0;
	      if($this->file_width > $this->file_maxwidth || $this->file_height > $this->file_maxheight) { $this->is_error = 721; }
	    }
	    // IF THIS IS A GIF, RESIZE ONLY IF IT IS GREATER THAN THE MAX WIDTH/HEIGHT, OTHERWISE SIMPLY MOVE
	    if($this->file_ext == 'gif' && $this->file_width <= $this->file_maxwidth && $this->file_height <= $this->file_maxheight) {
	      $this->is_image = 0;
	    }
	  } else {
	    $this->is_image = 0;
	  }


	} // END new_upload() METHOD


	// THIS METHOD UPLOADS A FILE
	// INPUT: $file_dest REPRESENTS THE DESTINATION OF THE UPLOADED FILE
	// OUTPUT: BOOLEAN INDICATING WHETHER UPLOAD SUCCEEDED OR FAILED
	function upload_file($file_dest) { 

	  // TRY MOVING UPLOADED FILE, RETURN ERROR UPON FAILURE
          if(!move_uploaded_file($this->file_tempname, $file_dest)) { 
	    $this->is_error = 718; 
	    return false;
	  } else {
	    chmod($file_dest, 0777);
	    return true;
	  }

	} // END upload_file() METHOD


	// THIS METHOD UPLOADS A PHOTO
	// INPUT: $photo_dest REPRESENTS THE DESTINATION OF THE UPLOADED PHOTO
	//	  $file_maxwidth (OPTIONAL) REPRESENTING THE MAXIMUM WIDTH OF THE UPLOADED PHOTO
	//	  $file_maxheight (OPTIONAL) REPRESENTING THE MAXIMUM HEIGHT OF THE UPLOADED PHOTO
	// OUTPUT: BOOLEAN INDICATING WHETHER UPLOAD SUCCEEDED OR FAILED
	function upload_photo($photo_dest, $file_maxwidth = "", $file_maxheight = "") { 
	  
	  // SET MAX WIDTH AND HEIGHT
	  if($file_maxwidth == "") { $file_maxwidth = $this->file_maxwidth; }
	  if($file_maxheight == "") { $file_maxheight = $this->file_maxheight; }

	  // CHECK IF DIMENSIONS ARE LARGER THAN ADMIN SPECIFIED SETTINGS
	  // AND SET DESIRED WIDTH AND HEIGHT
	  if($this->file_width > $file_maxwidth || $this->file_height > $file_maxheight) { 
	    if($this->file_height > $file_maxheight) {
	      $width = ($this->file_width)*$file_maxheight/($this->file_height);
	      $height = $file_maxheight;
	    }
	    if($this->file_width > $file_maxwidth) {
	      $height = ($this->file_height)*$file_maxwidth/($this->file_width);
	      $width = $file_maxwidth;
	    }
	  } else {
	    $width = $this->file_width;
	    $height = $this->file_height;
	  }


	  // RESIZE IMAGE AND PUT IN USER DIRECTORY
	  switch($this->file_ext) {
	    case "gif":
	      $file = imagecreatetruecolor($width, $height);
	      $new = imagecreatefromgif($this->file_tempname);
	      $kek=imagecolorallocate($file, 255, 255, 255);
	      imagefill($file,0,0,$kek);
	      imagecopyresampled($file, $new, 0, 0, 0, 0, $width, $height, $this->file_width, $this->file_height);
	      imagejpeg($file, $photo_dest, 100);
	      ImageDestroy($new);
	      ImageDestroy($file);
	      break;
	    case "bmp":
	      $file = imagecreatetruecolor($width, $height);
	      $new = $this->imagecreatefrombmp($this->file_tempname);
	      for($i=0; $i<256; $i++) { imagecolorallocate($file, $i, $i, $i); }
	      imagecopyresampled($file, $new, 0, 0, 0, 0, $width, $height, $this->file_width, $this->file_height); 
	      imagejpeg($file, $photo_dest, 100);
	      ImageDestroy($new);
	      ImageDestroy($file);
	      break;
	    case "jpeg":
	    case "jpg":
	      $file = imagecreatetruecolor($width, $height);
	      $new = imagecreatefromjpeg($this->file_tempname);
	      for($i=0; $i<256; $i++) { imagecolorallocate($file, $i, $i, $i); }
	      imagecopyresampled($file, $new, 0, 0, 0, 0, $width, $height, $this->file_width, $this->file_height);
	      imagejpeg($file, $photo_dest, 100);
	      ImageDestroy($new);
	      ImageDestroy($file);
	      break;
	    case "png":
	      $file = imagecreatetruecolor($width, $height);
	      $new = imagecreatefrompng($this->file_tempname);
	      for($i=0; $i<256; $i++) { imagecolorallocate($file, $i, $i, $i); }
	      imagecopyresampled($file, $new, 0, 0, 0, 0, $width, $height, $this->file_width, $this->file_height); 
	      imagejpeg($file, $photo_dest, 100);
	      ImageDestroy($new);
	      ImageDestroy($file);
	      break;
	  } 

	  chmod($photo_dest, 0777);

	  return true;

	} // END upload_photo() METHOD


	// THIS METHOD CREATES A SQUARE THUMBNAIL
	// INPUT: $photo_dest REPRESENTS THE DESTINATION OF THE UPLOADED PHOTO
	//	  $file_maxdim (OPTIONAL) REPRESENTING THE MAXIMUM WIDTH AND HEIGHT OF THE UPLOADED PHOTO
	// OUTPUT: BOOLEAN INDICATING WHETHER UPLOAD SUCCEEDED OR FAILED
	function upload_thumb($photo_dest, $file_maxdim = "60") { 
	  
	  // SET DESIRED WIDTH AND HEIGHT
	  $width = $this->file_width;
	  $height = $this->file_height;
	  if($width > $height) { 
	    $x = ceil(($width - $height) / 2);
	    $width = $height;
	  } elseif($width < $height) {
	    $y = ceil(($height - $width) / 2);
	    $height = $width;
	  }


	  // RESIZE IMAGE AND PUT IN USER DIRECTORY
	  switch($this->file_ext) {
	    case "gif":
	      $file = imagecreatetruecolor($file_maxdim, $file_maxdim);
	      $new = imagecreatefromgif($this->file_tempname);
	      $kek=imagecolorallocate($file, 255, 255, 255);
	      imagefill($file,0,0,$kek);
	      imagecopyresampled($file, $new, 0, 0, $x, $y, $file_maxdim, $file_maxdim, $width, $height);
	      imagejpeg($file, $photo_dest, 100);
	      ImageDestroy($new);
	      ImageDestroy($file);
	      break;
	    case "bmp":
	      $file = imagecreatetruecolor($file_maxdim, $file_maxdim);
	      $new = $this->imagecreatefrombmp($this->file_tempname);
	      for($i=0; $i<256; $i++) { imagecolorallocate($file, $i, $i, $i); }
	      imagecopyresampled($file, $new, 0, 0, $x, $y, $file_maxdim, $file_maxdim, $width, $height); 
	      imagejpeg($file, $photo_dest, 100);
	      ImageDestroy($new);
	      ImageDestroy($file);
	      break;
	    case "jpeg":
	    case "jpg":
	      $file = imagecreatetruecolor($file_maxdim, $file_maxdim);
	      $new = imagecreatefromjpeg($this->file_tempname);
	      for($i=0; $i<256; $i++) { imagecolorallocate($file, $i, $i, $i); }
	      imagecopyresampled($file, $new, 0, 0, $x, $y, $file_maxdim, $file_maxdim, $width, $height);
	      imagejpeg($file, $photo_dest, 100);
	      ImageDestroy($new);
	      ImageDestroy($file);
	      break;
	    case "png":
	      $file = imagecreatetruecolor($file_maxdim, $file_maxdim);
	      $new = imagecreatefrompng($this->file_tempname);
	      for($i=0; $i<256; $i++) { imagecolorallocate($file, $i, $i, $i); }
	      imagecopyresampled($file, $new, 0, 0, $x, $y, $file_maxdim, $file_maxdim, $width, $height); 
	      imagejpeg($file, $photo_dest, 100);
	      ImageDestroy($new);
	      ImageDestroy($file);
	      break;
	  } 

	  chmod($photo_dest, 0777);

	  return true;

	} // END upload_thumb() METHOD


	// THIS METHOD CHECKS FOR NECESSARY IMAGE RESIZING SUPPORT
	// INPUT: 
	// OUTPUT: BOOLEAN INDICATING WHETHER GD CAN BE USED TO RESIZE IMAGES 
	function image_resize_on() {

	  // CHECK IF GD LIBRARY IS INSTALLED
	  if( !is_callable('gd_info') ) return FALSE;
	
	  $gd_info = gd_info();
	  preg_match('/\d/', $gd_info['GD Version'], $match);
	  $gd_ver = $match[0];

	  if($gd_ver >= 2 && $gd_info['GIF Read Support'] == TRUE && $gd_info['JPG Support'] == TRUE && $gd_info['PNG Support'] == TRUE) {
	    return true;
	  } else {
	    return false;
	  }
	} // END image_resize_on() METHOD


	// THIS METHOD CONVERTS BMP TO GD
	// INPUT: $src REPRESENTING THE SOURCE OF THE BMP
	//	  $dest (OPTIONAL) REPRESENTING THE DESTINATION OF THE GD
	// OUTPUT: BOOLEAN INDICATING WHETHER THE CONVERSION SUCCEEDED OR FAILED
	function ConvertBMP2GD($src, $dest = false) {
	  if(!($src_f = fopen($src, "rb"))) {
	    return false;
	  }
	  if(!($dest_f = fopen($dest, "wb"))) {
	    return false;
	  }

	  $header = unpack("vtype/Vsize/v2reserved/Voffset", fread($src_f, 14));
	  $info = unpack("Vsize/Vwidth/Vheight/vplanes/vbits/Vcompression/Vimagesize/Vxres/Vyres/Vncolor/Vimportant", fread($src_f, 40));

	  extract($info);
	  extract($header);

	  if($type != 0x4D42) {  // signature "BM"
	    return false;
	  }

	  $palette_size = $offset - 54;
	  $ncolor = $palette_size / 4;
	  $gd_header = "";
	  // true-color vs. palette
	  $gd_header .= ($palette_size == 0) ? "\xFF\xFE" : "\xFF\xFF"; 
	  $gd_header .= pack("n2", $width, $height);
	  $gd_header .= ($palette_size == 0) ? "\x01" : "\x00";
	  if($palette_size) {
	    $gd_header .= pack("n", $ncolor);
	  }
	  // no transparency
	  $gd_header .= "\xFF\xFF\xFF\xFF";     
	
	  fwrite($dest_f, $gd_header);
	
	  if($palette_size) {
	    $palette = fread($src_f, $palette_size);
	    $gd_palette = "";
	    $j = 0;
	    while($j < $palette_size) {
	      $b = $palette{$j++};
	      $g = $palette{$j++};
	      $r = $palette{$j++};
	      $a = $palette{$j++};
	      $gd_palette .= "$r$g$b$a";
	    }
	    $gd_palette .= str_repeat("\x00\x00\x00\x00", 256 - $ncolor);
	    fwrite($dest_f, $gd_palette);
	  }
	
	  $scan_line_size = (($bits * $width) + 7) >> 3;
	  $scan_line_align = ($scan_line_size & 0x03) ? 4 - ($scan_line_size & 0x03) : 0;
	
	  for($i = 0, $l = $height - 1; $i < $height; $i++, $l--) {
	    // BMP stores scan lines starting from bottom
	    fseek($src_f, $offset + (($scan_line_size + $scan_line_align) * $l));
	    $scan_line = fread($src_f, $scan_line_size);
	    if($bits == 24) {
	      $gd_scan_line = "";
	      $j = 0;
	      while($j < $scan_line_size) {
	        $b = $scan_line{$j++};
	        $g = $scan_line{$j++};
	        $r = $scan_line{$j++};
	        $gd_scan_line .= "\x00$r$g$b";
	      }
	    } elseif($bits == 8) {
	      $gd_scan_line = $scan_line;
	    } elseif($bits == 4) {
	      $gd_scan_line = "";
	      $j = 0;
	      while($j < $scan_line_size) {
	        $byte = ord($scan_line{$j++});
	        $p1 = chr($byte >> 4);
	        $p2 = chr($byte & 0x0F);
	        $gd_scan_line .= "$p1$p2";
	      } 
	      $gd_scan_line = substr($gd_scan_line, 0, $width);
	    } elseif($bits == 1) {
	      $gd_scan_line = "";
	      $j = 0;
	      while($j < $scan_line_size) {
	        $byte = ord($scan_line{$j++});
	        $p1 = chr((int) (($byte & 0x80) != 0));
	        $p2 = chr((int) (($byte & 0x40) != 0));
	        $p3 = chr((int) (($byte & 0x20) != 0));
	        $p4 = chr((int) (($byte & 0x10) != 0)); 
	        $p5 = chr((int) (($byte & 0x08) != 0));
	        $p6 = chr((int) (($byte & 0x04) != 0));
	        $p7 = chr((int) (($byte & 0x02) != 0));
	        $p8 = chr((int) (($byte & 0x01) != 0));
	        $gd_scan_line .= "$p1$p2$p3$p4$p5$p6$p7$p8";
	      } 
	      $gd_scan_line = substr($gd_scan_line, 0, $width);
	    }
	    
	    fwrite($dest_f, $gd_scan_line);
	  }
	
	  fclose($src_f);
	  fclose($dest_f);
	
	  return true;
	
	} // END ConvertBMP2GD() METHOD
	

	// THIS METHOD CREATES IMAGE FROM BMP FUNCTION
	// INPUT: $filename REPRESENTING THE NAME OF THE FILE TO BE USED FOR CREATION
	// OUTPUT: BOOLEAN INDICATING WHETHER THE CREATION SUCCEEDED OR FAILED
	function imagecreatefrombmp($filename) {
	
	  $tmp_name = tempnam("/tmp", "GD");
	  if($this->ConvertBMP2GD($filename, $tmp_name)) {
	    $img = imagecreatefromgd($tmp_name);
	    unlink($tmp_name);
	    return $img;
	  } else {
	    return false;
	  }

	} //END imagecreatefrombmp() METHOD


}

?><?

//  THIS CLASS CONTAINS URL-RELATED METHODS.
//  IT IS USED TO RETURN THE CURRENT URL AND CREATE NEW URLS
//  METHODS IN THIS CLASS:
//    se_url()
//    url_create()
//    url_current()
//    url_userdir()
//    url_encode()


class se_url {

	// INITIALIZE VARIABLES
	var $is_error;			// DETERMINES WHETHER THERE IS AN ERROR OR NOT
	var $url_base;			// CONTAINS THE BASE URL TO WHICH FILENAMES CAN BE APPENDED
	var $convert_urls;		// CONTAINS THE URL CONVERSIONS


	// THIS METHOD SETS THE BASE URL TO WHICH FILENAMES CAN BE APPENDED
	// INPUT:
	// OUTPUT: A STRING REPRESENTING A PATH TO WHICH FILENAMES CAN BE APPENDED TO CREATE URLs
	function se_url() {
	  global $database;

	  $server_array = explode("/", $_SERVER['PHP_SELF']);
	  $server_array_mod = array_pop($server_array);
	  if($server_array[count($server_array)-1] == "admin") { $server_array_mod = array_pop($server_array); }
	  $server_info = implode("/", $server_array);
	  $this->url_base = "http://".$_SERVER['HTTP_HOST'].$server_info."/";

	  $se_urls = $database->database_query("SELECT url_file, url_regular, url_subdirectory FROM se_urls");
	  while($se_url_info = $database->database_fetch_assoc($se_urls)) {
	    $this->convert_urls[$se_url_info[url_file]] = Array('url_regular' => $se_url_info[url_regular],
								'url_subdirectory' => $se_url_info[url_subdirectory]);
	  }
	  $this->convert_urls['profile'] = Array('url_regular' => 'profile.php?user=$user',
						'url_subdirectory' => '$user/');

	} // END se_url() METHOD


	// THIS METHOD CREATES A FULL URL TO A GIVEN PAGE
	// INPUT: $file REPRESENTING THE PAGE TO CREATE THE URL FOR
	//	  $user REPRESENTING THE USERNAME OF THE USER
	//	  THERE ARE FURTHER OPTIONAL PARAMETERS TO ALLOW FOR ADDITIONAL REPLACEMENTS
	// OUTPUT: A STRING REPRESENTING A URL
	function url_create($file, $user) {
	  global $setting;

	  $url_conversion = $this->convert_urls[$file];
	  
	  if($setting[setting_url] == 1) {
	    $new_url = $url_conversion[url_subdirectory];
	  } else {
	    $new_url = $url_conversion[url_regular];
	  }

	  $num_args = func_num_args();
	  $search = Array('$user');
	  $replace = Array($user);
	  for($a=2;$a<$num_args;$a++) {
	    $search[] = '$id'.($a-1);
	    $replace[] = func_get_arg($a);
	  }

	  $new_url = str_replace($search, $replace, $new_url);

	  return $this->url_base.$new_url;
  
	} // END url_create() METHOD


	// THIS METHOD RETURNS THE URL TO THE CURRENT PAGE
	// INPUT: 
	// OUTPUT: A STRING REPRESENTING THE URL TO THE CURRENT PAGE
	function url_current() {
	  $current_url_domain = $_SERVER['HTTP_HOST'];
	  $current_url_path = $_SERVER['SCRIPT_NAME'];
	  $current_url_querystring = $_SERVER['QUERY_STRING'];
	  $current_url = "http://".$current_url_domain.$current_url_path;
	  if($current_url_querystring != "") {  $current_url .= "?".$current_url_querystring; }
	  $current_url = urlencode($current_url);
	  return $current_url;
	} // END url_current() METHOD


	// THIS METHOD RETURNS THE PATH TO THE GIVEN USER'S DIRECTORY
	// INPUT: $user_id REPRESENTING A USER'S USER_ID
	// OUTPUT: A STRING REPRESENTING THE RELATIVE PATH TO THE USER'S DIRECTORY
	function url_userdir($user_id) {
	  $subdir = $user_id+999-(($user_id-1)%1000);
	  $userdir = "./uploads_user/$subdir/$user_id/";
	  return $userdir;
	} // END url_userdir() METHOD


	// THIS METHOD RETURNS A URLENCODED VERSION OF THE GIVEN STRING
	// INPUT: $url REPRESENTING ANY STRING
	// OUTPUT: A STRING REPRESENTING A URLENCODED VERSION OF THE GIVEN STRING
	function url_encode($url) {
	  return urlencode($url);
	} // END url_encode() METHOD

}
?><?

//  THIS CLASS CONTAINS MISC METHODS TO BE AVAILABLE TO SMARTY
//  METHODS IN THIS CLASS:
//    photo_size()


class se_misc {


	// THIS METHOD RETURNS WIDTH OR HEIGHT, PROPORTIONALLY, BASED ON GIVEN MAX WIDTH AND MAX HEIGHT
	// INPUT: $photo REPRESENTING THE PATH TO THE PHOTO
	//	  $max_width REPRESENTING THE MAXIMUM WIDTH IN PIXELS
	//	  $max_height REPRESENTING THE MAXIMUM HEIGHT IN PIXELS
	//	  $return_value (OPTIONAL) REPRESENTING THE VALUE TO RETURN (CAN BE "w" FOR WIDTH OR "h" FOR HEIGHT)
	// OUTPUT: A WIDTH OR HEIGHT IN PIXELS THAT SCALES THE PHOTO BASED ON A MAX WIDTH AND HEIGHT
	function photo_size($photo, $max_width, $max_height, $return_value = "w") {

	  $dimensions = @getimagesize($photo);
	  $width = $dimensions[0];
	  $height = $dimensions[1];

	  if($width > $max_width | $height > $max_height) { 
	    if($width > $max_width) {
	      $height = $height*$max_width/$width;
	      $width = $max_width;
	    }
	    if($height > $max_height) {
	      $width = $width*$max_height/$height;
	      $height = $max_height;
	    }
	  }

	  if($return_value == "w") { $image_dimension = $width; } else { $image_dimension = $height; }
	
	  return round($image_dimension, 2);

	} // END photo_size() METHOD

}
?><?

//  THIS CLASS IS USED TO DISPLAY AND MANAGE AD CAMPAIGN BANNERS
//  METHODS IN THIS CLASS:
//    se_ads()
//    ad_display()


class se_ads {


	var $ad_top; 			// VARIABLE REPRESENTING PAGE TOP BANNER HTML
	var $ad_belowmenu; 		// VARIABLE REPRESENTING BELOW MENU BANNER HTML
	var $ad_left; 			// VARIABLE REPRESENTING LEFT SIDE BANNER HTML
	var $ad_right; 			// VARIABLE REPRESENTING RIGHT SIDE BANNER HTML
	var $ad_bottom; 		// VARIABLE REPRESENTING PAGE BOTTOM BANNER HTML
	var $ad_feed;	 		// VARIABLE REPRESENTING ACTIVITY FEED BANNER HTML
	var $ad_custom;			// VARIABLE REPRESENTING AN ARRAY OF CUSTOM BANNER HTML


	// THIS METHOD IS USED TO DETERMINE WHAT ADS SHOULD BE SHOWN ON THE PAGE
	// THIS ONLY INCLUDES AD CAMPAIGNS THAT HAVE BEEN GIVEN A POSITION BY THE ADMIN
	// OUTPUT: AD BANNER HTML (IF AVAILABLE) FOR PAGE TOP, BELOW MENU, LEFT, RIGHT, AND BOTTOM
	function se_ads() {
	  global $database, $datetime, $setting, $user, $page;
	
	  // DON'T RETRIEVE ADS ON HIDDEN PAGE
	  if($page == "ad") return;

	  // GET CURRENT TIME IN ADMINS TIMEZONE
	  $nowtime = time();

	  // BEGIN BUILDING AD QUERY 
	  $ad_querystring = "SELECT ad_id, ad_position, ad_html FROM se_ads WHERE ad_date_start<'$nowtime' AND (ad_date_end>'$nowtime' OR ad_date_end='0')";

	  // MAKE SURE AD IS NOT PAUSED
	  $ad_querystring .= " AND ad_paused!='1'";

	  // MAKE SURE AD HAS NOT REACHED ITS VIEW LIMIT
	  $ad_querystring .= " AND (ad_limit_views=0 OR ad_limit_views>ad_total_views)";

	  // MAKE SURE AD HAS NOT REACHED ITS CLICK LIMIT
	  $ad_querystring .= " AND (ad_limit_clicks=0 OR ad_limit_clicks>ad_total_clicks)";

	  // MAKE SURE AD HAS NOT REACHED ITS CTR LIMIT
          $ad_querystring .= " AND (ad_limit_ctr=0 OR ad_limit_ctr<(ad_total_clicks/(ad_total_views+1))*100)";

	  // IF VIEWER IS NOT LOGGED-IN, ONLY SHOW PUBLIC AD CAMPAIGNS
          if($user->user_exists == 0) {
	    $ad_querystring .= " AND ad_public='1'";

	  // IF VIEWER IS LOGGED-IN, ONLY SHOW AD IF VIEWER'S LEVEL AND SUBNETS MATCH
	  } else { 
	    $level_id = $user->level_info[level_id];
	    $subnet_id = $user->subnet_info[subnet_id];
	    $ad_querystring .= " AND (ad_levels LIKE '%,$level_id,%' AND ad_subnets LIKE '%,$subnet_id,%')";
	  }

	  // RANDOMIZE QUERY RESULTS
	  $ad_querystring .= " ORDER BY RAND()";

	  // DETERMINE WHICH ADS SHOULD BE SHOWN
	  $ad_query = $database->database_query($ad_querystring);

	  // PREPARE STAT UPDATE QUERY
	  $stats_string = "";

	  // SET AD HTML FOR EACH POSITION
	  while($ad_info = $database->database_fetch_assoc($ad_query)) {

	    // CONVERT TO HTML AND ADD CLICK-TRACKING JAVASCRIPT
	    $ad_info[ad_html] = htmlspecialchars_decode($ad_info[ad_html], ENT_QUOTES);
	    $ad_info[ad_html] = "<div onClick=\"document.getElementById('doclickimage$ad_info[ad_id]').src='ad.php?ad_id=$ad_info[ad_id]';\">$ad_info[ad_html]<img src='images/trans.gif' border='0' id='doclickimage$ad_info[ad_id]' style='display: none;'></div>";

	    $this->ad_custom[$ad_info[ad_id]] = $ad_info[ad_html];

	    if($ad_info[ad_position] == "top" AND $this->ad_top == "") {
	        $this->ad_top = $ad_info[ad_html];
	        if($stats_string != "") { $stats_string .= " OR"; }
		$stats_string .= " ad_id=$ad_info[ad_id]";
	    }
	    elseif($ad_info[ad_position] == "belowmenu" AND $this->ad_belowmenu == "") {
	        $this->ad_belowmenu = $ad_info[ad_html];
	        if($stats_string != "") { $stats_string .= " OR"; }
		$stats_string .= " ad_id=$ad_info[ad_id]";
	    }
	    elseif($ad_info[ad_position] == "left" AND $this->ad_left == "") {
	        $this->ad_left = $ad_info[ad_html];
	        if($stats_string != "") { $stats_string .= " OR"; }
		$stats_string .= " ad_id=$ad_info[ad_id]";
	    }
	    elseif($ad_info[ad_position] == "right" AND $this->ad_right == "") {
	        $this->ad_right = $ad_info[ad_html];
	        if($stats_string != "") { $stats_string .= " OR"; }
		$stats_string .= " ad_id=$ad_info[ad_id]";
	    }
	    elseif($ad_info[ad_position] == "feed" AND $this->ad_feed == "") {
	        $this->ad_feed = $ad_info[ad_html];
	        if($stats_string != "") { $stats_string .= " OR"; }
		$stats_string .= " ad_id=$ad_info[ad_id]";
	    }
	    elseif($ad_info[ad_position] == "bottom" AND $this->ad_bottom == "") {
	        $this->ad_bottom = $ad_info[ad_html];
	        if($stats_string != "") { $stats_string .= " OR"; }
		$stats_string .= " ad_id=$ad_info[ad_id]";
	    }

	  }

	  // UPDATE THE ADS VIEW STATS
	  if($stats_string != "") { $database->database_query("UPDATE se_ads SET ad_total_views=ad_total_views+1 WHERE ".$stats_string); }

	} // END se_ads() METHOD


	// THIS METHOD IS DISPLAYS THE CUSTOM AD AND UPDATES THE VIEWS
	// INPUT: $ad_id REPRESENTING AN AD ID
	// OUTPUT: AD BANNER HTML (IF AVAILABLE) FOR GIVEN AD ID
	function ads_display($ad_id) {
	  global $database;

	  // UPDATE THE ADS VIEW STATS
          $database->database_query("UPDATE se_ads SET ad_total_views=ad_total_views+1 WHERE ad_id=$ad_id");
	  
	  // DISPLAY AD
	  return $this->ad_custom[$ad_id];

	} // END ads_display() METHOD


}
?><?

//  THIS FILE CONTAINS GENERAL FUNCTIONS
//  FUNCTIONS IN THIS FILE:
//    cheader()
//    make_page()
//    bumplog()
//    randomcode()
//    is_email_address()
//    str_ireplace()
//    htmlspecialchars_decode()
//    str_split()
//    security()
//    select_subnet()
//    link_field_values()
//    censor()
//    dirsize()
//    online_users()
//    user_privacy_levels()
//    search_profile()
//    getmicrotime()
//    cleanHTML()
//    chopHTML()
//    choptext()
//    chunkHTML_split()
//    strlen_utf8()


// THIS FUNCTION CHANGES LOCATION HEADER TO REDIRECT FOR IIS PRIOR TO SETTING COOKIES
// INPUT: $url REPRESENTING THE URL TO REDIRECT TO
// OUTPUT: 
function cheader($url) {
	if(preg_match("/Microsoft/", $_SERVER['SERVER_SOFTWARE'])) {
	  header("Refresh: 0; URL=$url");
	} else {
	  header("Location: $url");
	}
	exit();
} // END cheader() FUNCTION


// THIS FUNCTION RETURNS APPROPRIATE PAGE VARIABLES
// INPUT: $total_items REPRESENTING THE TOTAL NUMBER OF ITEMS
//	  $items_per_page REPRESENTING THE NUMBER OF ITEMS PER PAGE
//	  $p REPRESENTING THE CURRENT PAGE
// OUTPUT: AN ARRAY CONTAINING THE STARTING ITEM, THE PAGE, AND THE MAX PAGE
function make_page($total_items, $items_per_page, $p) {

	if($items_per_page == 0) { $items_per_page = 1; }
	if(($total_items % $items_per_page) != 0) { $maxpage = ($total_items) / $items_per_page + 1; } else { $maxpage = ($total_items) / $items_per_page; }
	$maxpage = (int) $maxpage;
	if($maxpage <= 0) { $maxpage = 1; }
	if($p > $maxpage) { $p = $maxpage; } elseif($p < 1) { $p = 1; }
	$start = ($p - 1) * $items_per_page;

	return Array($start, $p, $maxpage);

} // END make_page() FUNCTION


// THIS FUNCTION BUMPS LOGIN LOG
// INPUT:
// OUTPUT: 
function bumplog() {
	global $database;
	$log_entries = $database->database_num_rows($database->database_query("SELECT login_id FROM se_logins"));
	if($log_entries > 1000) {
	  $oldest_log = $database->database_fetch_assoc($database->database_query("SELECT login_id FROM se_logins ORDER BY login_id ASC LIMIT 0,1"));
	  $database->database_query("DELETE FROM se_logins WHERE login_id='$oldest_log[login_id]'");
	  bumplog();
	}
} // END bumplog() FUNCTION


// THIS FUNCTION RETURNS A RANDOM CODE OF DEFAULT LENGTH 8
// INPUT: $len (OPTIONAL) REPRESENTING THE LENGTH OF THE RANDOM STRING
// OUTPUT: A RANDOM ALPHANUMERIC STRING
function randomcode($len="8") {

	$code = NULL;
	for($i=0;$i<$len;$i++) {
	  $char = chr(rand(48,122));
	  while(!ereg("[a-zA-Z0-9]", $char)) {
	    if($char == $lchar) { continue; }
	    $char = chr(rand(48,90));
	  }
	  $pass .= $char;
	  $lchar = $char;
	}
	return $pass;

} // END randomcode() FUNCTION


// THIS FUNCTION CHECKS IF PROVIDED STRING IS AN EMAIL ADDRESS
// INPUT: $email REPRESENTING THE EMAIL ADDRESS TO CHECK
// OUTPUT: TRUE/FALSE DEPENDING ON WHETHER THE EMAIL ADDRESS IS VALIDLY CONSTRUCTED
function is_email_address($email) {

	$regexp="/^[a-z0-9]+([a-z0-9_\+\\.-]+)*@([a-z0-9]+([\.-][a-z0-9]+)*)+\\.[a-z]{2,}$/i";
	if(!preg_match($regexp, $email) ) { return false; } else { return true; }

} // END is_email_address() FUNCTION


// THIS FUNCTION SETS STR_IREPLACE IF FUNCTION DOESN'T EXIST
// INPUT: $search REPRESENTING THE STRING TO SEARCH FOR
//	  $replace REPRESENTING THE STRING TO REPLACE IT WITH
//	  $subject REPRESENTING THE STRING WITHIN WHICH TO SEARCH
// OUTPUT: RETURNS A STRING IN WHICH ONE STRING HAS BEEN CASE-INSENSITIVELY REPLACED BY ANOTHER
if(!function_exists('str_ireplace')) {
function str_ireplace($search, $replace, $subject) {
	$search = preg_quote($search, "/");
	return preg_replace("/".$search."/i", $replace, $subject); 
} 
} // END str_ireplace() FUNCTION


// THIS FUNCTION SETS HTMLSPECIALCHARS_DECODE IF FUNCTION DOESN'T EXIST
// INPUT: $text REPRESENTING THE TEXT TO DECODE
//	  $ent_quotes (OPTIONAL) REPRESENTING WHETHER TO REPLACE DOUBLE QUOTES, ETC
// OUTPUT: A STRING WITH HTML CHARACTERS DECODED
if(!function_exists('htmlspecialchars_decode')) {
function htmlspecialchars_decode($text, $ent_quotes = "") {
	$text = str_replace("&quot;", "\"", $text);
	$text = str_replace("&#039;", "'", $text);
	$text = str_replace("&lt;", "<", $text);
	$text = str_replace("&gt;", ">", $text);
	$text = str_replace("&amp;", "&", $text);
	return $text;
}
} // END htmlspecialchars() FUNCTION


// THIS FUNCTION SETS STR_SPLIT IF FUNCTION DOESN'T EXIST
// INPUT: $string REPRESENTING THE STRING TO SPLIT
//	  $split_length (OPTIONAL) REPRESENTING WHERE TO CUT THE STRING
// OUTPUT: AN ARRAY OF STRINGS 
if(!function_exists('str_split')) { 
function str_split($string, $split_length = 1) { 
	$count = strlen($string);  
	if($split_length < 1) { 
	  return false;  
	} elseif($split_length > $count) { 
	  return array($string); 
	} else { 
	  $num = (int)ceil($count/$split_length);  
	  $ret = array();  
	  for($i=0;$i<$num;$i++) {  
	    $ret[] = substr($string,$i*$split_length,$split_length);  
	  }  
	  return $ret; 
	}      
}  
} // END str_split() FUNCTION


// THIS FUNCTION STRIPSLASHES AND ENCODES HTML ENTITIES FOR SECURITY PURPOSES
// INPUT: $value REPRESENTING A STRING OR ARRAY TO CLEAN
// OUTPUT: THE ARRAY OR STRING WITH HTML CHARACTERS ENCODED
function security($value) {
	if(is_array($value)) {
	  $value = array_map('security', $value);
	} else {
	  if(!get_magic_quotes_gpc()) {
	    $value = htmlspecialchars($value, ENT_QUOTES, 'UTF-8');
	  } else {
	    $value = htmlspecialchars(stripslashes($value), ENT_QUOTES, 'UTF-8');
	  }
	  $value = str_replace("\\", "\\\\", $value);
	}
	return $value;
} // END security() FUNCTION


// THIS FUNCTION LINKS FIELD VALUES
// INPUT: $field_value REPRESENTING THE VALUE TO LINK
//	  $key (NEEDED TO USE ARRAY WALK)
//	  $additional REPRESENTING THE ADDITIONAL PARAMETERS
// OUTPUT: 
function link_field_values(&$field_value, $key, $additional) {
	global $url;

	$field_id = $additional[0];
	$field_browse = $additional[1];
	$field_link = $additional[2];
	$field_display = $additional[3];
	$field_value = trim($field_value);
	if(trim($field_link) == "" && $field_display == 2) {
	  if($field_browse == "") { $field_browse = urlencode(htmlspecialchars_decode($field_value, ENT_QUOTES)); }
	  $browse_url = $url->url_base."search_advanced.php?task=browse&field_id=".$field_id."&field_value=".$field_browse;
	  if($field_value != "") { $field_value = "<a href='$browse_url'>$field_value</a>"; }
	} elseif(trim($field_link) != "" && $field_value != "") {
	  if(preg_match('/^www([.]?[a-zA-Z0-9_\/-])*/', $field_value)) { $field_link = "http://".$field_value; }
	  $link_to = str_replace("[field_value]", $field_value, $field_link);
	  $field_value = "<a href='$link_to' target='_blank'>$field_value</a>"; 
	}

} // END link_field_values() FUNCTION


// THIS FUNCTION CENSORS WORDS FROM A STRING
// INPUT: $field_value REPRESENTING THE VALUE TO CENSOR
// OUTPUT: THE VALUE WITH BANNED WORDS CENSORED
function censor($field_value) {
	global $setting;

	$censored_array = explode(",", trim($setting[setting_banned_words]));
	foreach($censored_array as $key => $value) {
	  $replace_value = str_pad("", strlen(trim($value)), "*");
	  $field_value = str_ireplace(trim($value), $replace_value, $field_value);
	}
 
	return $field_value;

} // END censor() FUNCTION


// THIS FUNCTION RETURNS THE SIZE OF A DIRECTORY
// INPUT: $dirname REPRESENTING THE PATH TO A DIRECTORY
// OUTPUT: THE SIZE OF ALL THE FILES WITHIN THE DIRECTORY
function dirsize($dirname) {
	if(!is_dir($dirname) || !is_readable($dirname)) { return false; }

	$dirname_stack[] = $dirname;
	$size = 0;

	do {
	  $dirname = array_shift($dirname_stack);
	  $handle = opendir($dirname);
	  while(false !== ($file = readdir($handle))) {
	    if($file != '.' && $file != '..' && is_readable($dirname . DIRECTORY_SEPARATOR . $file)) {
	      if(is_dir($dirname . DIRECTORY_SEPARATOR . $file)) {
	        $dirname_stack[] = $dirname . DIRECTORY_SEPARATOR . $file;
	      }
	      $size += filesize($dirname . DIRECTORY_SEPARATOR . $file);
	    }
	  }
	  closedir($handle);
	} while(count($dirname_stack) > 0);

	return $size;

} // END dirsize() FUNCTION


// THIS FUNCTION RETURNS AN ARRAY CONTAINING THE USERNAMES OF ONLINE USERS
// INPUT:
// OUTPUT: AN ARRAY OF USERNAMES FOR USERS CURRENTLY ACTIVE IN THE SYSTEM
function online_users() {
	global $database;

	// GET LOGGED IN USERS ONLINE
	$onlineusers_array = Array();
	$online_time = time()-10*60;
	$online_users = $database->database_query("SELECT user_username, user_fname, user_lname FROM se_users WHERE user_lastactive>'$online_time' AND user_invisible=0 ORDER BY user_lastactive DESC LIMIT 2000");
	while($online_user_info = $database->database_fetch_assoc($online_users)) {
	  $online_user = new se_user();
	  $online_user->user_info[user_id] = $online_user_info[user_id];
	  $online_user->user_info[user_username] = $online_user_info[user_username];
	  $online_user->user_info[user_fname] = $online_user_info[user_fname];
	  $online_user->user_info[user_lname] = $online_user_info[user_lname];
	  $online_user->user_displayname();

	  // SET ONLINE USERS ARRAY
	  $onlineusers_array[] = $online_user;
	  $onlineusers_usernames[] = $online_user->user_info[user_username];
	}

	// GET VISITORS ONLINE
	$total_visitors = $database->database_num_rows($database->database_query("SELECT visitor_ip FROM se_visitors WHERE visitor_lastactive>'".(time()-600)."'"));

	return Array($onlineusers_array, $total_visitors, $onlineusers_usernames);
} // END online_users() FUNCTION


// THIS FUNCTION RETURNS TEXT CORRESPONDING TO THE GIVEN USER PRIVACY LEVEL
// INPUT: $privacy_level REPRESENTING THE LEVEL OF USER PRIVACY
// OUTPUT: A STRING EXPLAINING THE GIVEN PRIVACY SETTING
function user_privacy_levels($privacy_level) {
	global $functions_general;

	switch($privacy_level) {
	  case 63: $privacy = 323; break;
	  case 31: $privacy = 324; break;
	  case 15: $privacy = 325; break;
	  case 7: $privacy = 326; break;
	  case 3: $privacy = 327; break;
	  case 1: $privacy = 328; break;
	  case 0: $privacy = 329; break;
	  default: $privacy = ""; break;
	}

	return $privacy;
} // END user_privacy_levels() FUNCTION


// THIS FUNCTION SEARCHES THROUGH PROFILE INFORMATION
// INPUT: 
// OUTPUT:
function search_profile() {
	global $database, $url, $results_per_page, $p, $search_text, $t, $search_objects, $results, $total_results;

	// GET FIELDS
	$fields = $database->database_query("SELECT profilefield_id AS field_id, profilefield_type AS field_type, profilefield_options AS field_options FROM se_profilefields WHERE profilefield_type<>'5' AND (profilefield_dependency<>'0' OR (profilefield_dependency='0' AND profilefield_display<>'0'))");
	$profile_query = "se_users.user_username LIKE '%$search_text%' OR CONCAT(se_users.user_fname, ' ', se_users.user_lname) LIKE '%$search_text%'";
    
	// LOOP OVER FIELDS
	while($field_info = $database->database_fetch_assoc($fields)) {
    
	  // TEXT FIELD OR TEXTAREA
	  if($field_info[field_type] == 1 || $field_info[field_type] == 2) {
	    if($profile_query != "") { $profile_query .= " OR "; }
	    $profile_query .= "se_profilevalues.profilevalue_".$field_info[field_id]." LIKE '%$search_text%'";

	  // RADIO OR SELECT BOX
	  } elseif($field_info[field_type] == 3 || $field_info[field_type] == 4) {
	    $options = unserialize($field_info[field_options]);
 	    $langids = Array();
	    $cases = Array();
	    for($i=0,$max=count($options);$i<$max;$i++) { 
	      $cases[] = "WHEN languagevar_id={$options[$i][label]} THEN {$options[$i][value]}";
	      $langids[] = $options[$i][label]; 
	    }
	    if(count($cases) != 0) {
	      if($profile_query != "") { $profile_query .= " OR "; }
	      $profile_query .= "se_profilevalues.profilevalue_".$field_info[field_id]." IN (SELECT CASE ".implode(" ", $cases)." END AS value FROM se_languagevars WHERE languagevar_id IN (".implode(", ", $langids).") AND languagevar_value LIKE '%$search_text%')";
	    }

	  // CHECKBOX
	  } elseif($field_info[field_type] == 6) {
	    $options = unserialize($field_info[field_options]);
 	    $langids = Array();
	    $cases = Array();
	    for($i=0,$max=count($options);$i<$max;$i++) { 
	      $cases[] = "WHEN languagevar_id={$options[$i][label]} THEN ".(pow(2, $i));
	      $langids[] = $options[$i][label]; 
	    }
	    if(count($cases) != 0) {
	      if($profile_query != "") { $profile_query .= " OR "; }
	      $profile_query .= "se_profilevalues.profilevalue_".$field_info[field_id]." & (SELECT sum(CASE ".implode(" ", $cases)." END) AS value FROM se_languagevars WHERE languagevar_id IN (".implode(", ", $langids).") AND languagevar_value LIKE '%$search_text%')";
	    }
	  }
	}

	// CONSTRUCT QUERY
	$profile_query = "SELECT se_users.user_id, se_users.user_username, se_users.user_fname, se_users.user_lname, se_users.user_photo FROM se_profilevalues LEFT JOIN se_users ON se_profilevalues.profilevalue_user_id=se_users.user_id LEFT JOIN se_levels ON se_levels.level_id=se_users.user_level_id WHERE se_users.user_verified='1' AND se_users.user_enabled='1' AND (se_users.user_search='1' OR se_levels.level_profile_search='0') AND ($profile_query)";

	// GET TOTAL PROFILES
	$total_profiles = $database->database_num_rows($database->database_query($profile_query." LIMIT 201"));

	// IF NOT TOTAL ONLY
	if($t == "0") {

	  // MAKE PROFILE PAGES
	  $start = ($p - 1) * $results_per_page;
	  $limit = $results_per_page+1;

	  // SEARCH PROFILES
	  $online_users_array = online_users();
	  $profiles = $database->database_query($profile_query." ORDER BY se_users.user_id DESC LIMIT $start, $limit");
	  while($profile_info = $database->database_fetch_assoc($profiles)) {

	    // CREATE AN OBJECT FOR USER
	    $profile = new se_user();
	    $profile->user_info[user_id] = $profile_info[user_id];
	    $profile->user_info[user_username] = $profile_info[user_username];
	    $profile->user_info[user_fname] = $profile_info[user_fname];
	    $profile->user_info[user_lname] = $profile_info[user_lname];
	    $profile->user_info[user_photo] = $profile_info[user_photo];
	    $profile->user_displayname();

	    // DETERMINE IF USER IS ONLINE
	    if(in_array($profile_info[user_username], $online_users_array[0])) { $is_online = 1; } else { $is_online = 0; }

	    $results[] = Array('result_url' => $url->url_create('profile', $profile_info[user_username]),
			       'result_icon' => $profile->user_photo('./images/nophoto.gif', TRUE),
			       'result_name' => 509,
			       'result_name_1' => $profile->user_displayname,
			       'result_desc' => '',
			       'result_online' => $is_online);
	  }

	  // SET TOTAL RESULTS
	  $total_results = $total_profiles;

	}

	// SET ARRAY VALUES
	SE_Language::_preload_multi(509, 1072);
	if($total_profiles > 200) { $total_profiles = "200+"; }
	$search_objects[] = Array('search_type' => '0',
				'search_lang' => 1072,
				'search_total' => $total_profiles);


} // END search_profile() FUNCTION


// THIS FUNCTION RETURNS TIME IN SECONDS WITH MICROSECONDS
// INPUT:
// OUTPUT: RETURNS THE TIME IN SECONDS WITH MICROSECONDS
function getmicrotime() {
	list($usec, $sec) = explode(" ",microtime());
	return ((float)$usec + (float)$sec);
} // END getmicrotime() FUNCTION


// THIS FUNCTION CLEANS HTML TAGS FROM TEXT
// INPUT: $text REPRESENTING THE STRING TO CLEAN
//	  $allowable_tags REPRESENTING THE ALLOWABLE HTML TAGS (AS A COMMA-DELIMITED STRING)
//	  $forbidden_attr (OPTIONAL) REPRESENTING AND ARRAY OF ANY ADDITIONAL FORBIDDEN ATTRIBUTES (SUCH AS A STYLE TAG)
// OUTPUT: THE CLEANED TEXT
function cleanHTML($text, $allowable_tags, $forbidden_attr = "") {

  // INCLUDE FILTER CLASS
  if(!class_exists("InputFilter")) { if(file_exists("./include/class_inputfilter.php")) { include "./include/class_inputfilter.php"; } else { include "../include/class_inputfilter.php"; } }

  // INSTANTIATE INPUT FILTER CLASS WITH APPROPRIATE TAGS
  $xssFilter = new InputFilter(explode(",", str_replace(" ", "", $allowable_tags)), "", 0, 1, 1);

  // ADD NECESSARY BLACKLIST ITEMS
  for($i=0;$i<count($forbidden_attr);$i++) {
    $xssFilter->attrBlacklist[] = $forbidden_attr[$i];
  }

  // RETURN PROCESSED TEXT
  return $xssFilter->process($text);

} // END cleanHTML() FUNCTION


// THIS FUNCTION TRIMS A GIVEN STRING PRESERVING HTML
// INPUT: $string REPRESENTING THE STRING TO SHORTEN
//	  $start REPRESENTING THE CHARACTER TO START WITH
//	  $length REPRESENTING THE LENGTH OF THE STRING TO RETURN
// OUTPUT: THE CLEANED TEXT
function chopHTML($string, $start, $length=false) {
    $pattern = '/(\[\w+[^\]]*?\]|\[\/\w+\]|<\w+[^>]*?>|<\/\w+>)/i';
    $clean = preg_replace($pattern, chr(1), $string);

    if(!$length)
        $str = substr($clean, $start);
    else {
        $str = substr($clean, $start, $length);
        $str = substr($clean, $start, $length + substr_count($str, chr(1)));
    }
    $pattern = str_replace(chr(1),'(.*?)',preg_quote($str));
    if(preg_match('/'.$pattern.'/is', $string, $matched))
        return $matched[0];
    return $string;
} // END chopHTML() FUNCTION


// THIS FUNCTION CHOPS A GIVEN STRING AND INSERTS A STRING AT THE END OF EACH CHOP
// INPUT: $string REPRESENTING THE STRING TO CHOP
//        $length REPRESENTING THE LENGTH OF EACH SEGMENT
//        $insert_char REPRESENTING THE STRING TO INSERT AT THE END OF EACH SEGMENT
function choptext($string, $length=32, $insert_char=' ') {
  return preg_replace("!(?:^|\s)([\w\!\?\.]{" . $length . ",})(?:\s|$)!e",'chunk_split("\\1",' . $length . ',"' . $insert_char. '")',$string);
} // END choptext() FUNCTION


// THIS FUNCTION CHOPS A GIVEN STRING AND INSERTS A STRING AT THE END OF EACH CHOP (PRESERVING HTML ENTITIES)
// INPUT: $html REPRESENTING THE STRING TO CHOP
//        $size REPRESENTING THE LENGTH OF EACH SEGMENT
//        $delim REPRESENTING THE STRING TO INSERT AT THE END OF EACH SEGMENT
function chunkHTML_split($html, $size, $delim) {
  $pos=0;
  for($i=0;$i<strlen($html);$i++) {
    if($pos >= $size && !$unsafe) {
      $out .= $delim;
      $unsafe = 0;
      $pos = 0;
    }
    $c = substr($html,$i,1);
    if($c == "&")
      $unsafe = 1;
    elseif($c == ";")
      $unsafe = 0;
    $out .= $c;
    $pos++;
  }
  return $out;
} // END chunkHTML_split


// THIS FUNCTION RETURNS THE LENGTH OF A STRING, ACCOUNTING FOR UTF8 CHARS
// INPUT: $str REPRESENTING THE STRING
// OUTPUT: THE LENGTH OF THE STRING
function strlen_utf8($str) {
  $i = 0;
  $count = 0;
  $len = strlen($str);
  while($i < $len) {
    $chr = ord ($str[$i]);
    $count++;
    $i++;
    if($i >= $len)
        break;

    if($chr & 0x80) {
      $chr <<= 1;
      while ($chr & 0x80) {
        $i++;
        $chr <<= 1;
      }
    }
  }
  return $count;
} // END strlen_utf8() FUNCTION


?><?

//  THIS FILE CONTAINS EMAIL-RELATED FUNCTIONS
//  FUNCTIONS IN THIS CLASS:
//    send_generic()
//    send_systememail()


// THIS FUNCTION SENDS A CUSTOM EMAIL
// INPUT: $recipient REPRESENTING THE RECIPIENT'S EMAIL
//	  $sender REPRESENTING THE SENDER'S NAME/EMAIL
//	  $subject REPRESENTING THE EMAIL SUBJECT
//	  $message REPRESENTING THE EMAIL MESSAGE
//	  $search REPRESENTING THE ARRAY OF STRINGS TO SEARCH FOR
//	  $replace REPRESENTING THE ARRAY OF STRINGS TO REPLACE $search WITH
//	  $bcc (OPTIONAL) REPRESENTING WHETHER TO BCC ALL RECIPIENTS
// OUTPUT: 
function send_generic($recipient, $sender, $subject, $message, $search, $replace, $bcc = FALSE) {

	// DECODE SUBJECT AND EMAIL FOR SENDING
	$subject = htmlspecialchars_decode($subject, ENT_QUOTES);
	$message = htmlspecialchars_decode($message, ENT_QUOTES);

	// REPLACE VARIABLES IN SUBJECT AND MESSAGE
	$subject = str_replace($search, $replace, $subject);
	$message = str_replace($search, $replace, $message);

	// ENCODE SUBJECT FOR UTF8
	$subject="=?UTF-8?B?".base64_encode($subject)."?=";

	// REPLACE CARRIAGE RETURNS WITH BREAKS
	$message = str_replace("\n", "<br>", $message);

	// SET HEADERS
	$headers = "MIME-Version: 1.0"."\n";
	$headers .= "Content-type: text/html; charset=utf-8"."\n";
	$headers .= "Content-Transfer-Encoding: 8bit"."\n";
	$headers .= "From: $sender"."\n";
	$headers .= "Return-Path: $sender"."\n";
	$headers .= "Reply-To: $sender\n";

	// IF BCC, SET TO AND BCC
	if($bcc) {
	  $headers .= "Bcc: $recipient\n";
	  $recipient = "noreply@domain.com";
	}

	// SEND MAIL
	mail($recipient, $subject, $message, $headers);

	return true;
} // END send_generic() FUNCTION


// THIS FUNCTION SENDS A CUSTOM EMAIL
// INPUT: $systememail REPRESENTING THE SYSTEM EMAIL TO SEND
//	  $recipient_email REPRESENTING THE EMAIL(S) OF THE RECIPIENT
//	  $replace (OPTIONAL) REPRESENTING THE VARIABLES TO BE INSERTED
//	  $bcc (OPTIONAL) REPRESENTING WHETHER TO BCC ALL RECIPIENTS
// OUTPUT: 
function send_systememail($systememail, $recipient_email, $replace = Array(), $bcc = FALSE) {
	global $setting, $database;

	// RETRIEVE EMAIL INFO
	$email = $database->database_fetch_assoc($database->database_query("SELECT * FROM se_systememails WHERE systememail_name='$systememail'"));

	SE_Language::_preload_multi($email[systememail_subject], $email[systememail_body]);
	SE_Language::load();

	// GET/DECODE SUBJECT AND MESSAGE 
	$subject = htmlspecialchars_decode(SE_Language::_get($email[systememail_subject]), ENT_QUOTES);
	$message = htmlspecialchars_decode(SE_Language::_get($email[systememail_body]), ENT_QUOTES);

	// REPLACE VARIABLES IN SUBJECT AND MESSAGE
	$subject = vsprintf($subject, $replace);
	$message = vsprintf($message, $replace);

	// ENCODE SUBJECT FOR UTF8
	$subject="=?UTF-8?B?".base64_encode($subject)."?=";

	// REPLACE CARRIAGE RETURNS WITH BREAKS
	$message = str_replace("\n", "<br>", $message);

	// SET HEADERS
	$sender = "$setting[setting_email_fromname] <$setting[setting_email_fromemail]>";
	$headers = "MIME-Version: 1.0"."\n";
	$headers .= "Content-type: text/html; charset=utf-8"."\n";
	$headers .= "Content-Transfer-Encoding: 8bit"."\n";
	$headers .= "From: $sender"."\n";
	$headers .= "Return-Path: $sender"."\n";
	$headers .= "Reply-To: $sender\n";

	// IF BCC, SET TO AND BCC
	if($bcc) {
	  $headers .= "Bcc: $recipient_email\n";
	  $recipient_email = "noreply@domain.com";
	}

	// SEND MAIL
	mail($recipient_email, $subject, $message, $headers);

	return true;
} // END send_systememail() FUNCTION


?><?


//  THIS FILE CONTAINS STAT-RELATED FUNCTIONS
//  FUNCTIONS IN THIS CLASS:
//    update_stats()
//    update_refurls()


// THIS FUNCTION UPDATES THE LATEST ROW IN THE STATS TABLE
// INPUT: $type REPRESENTING WHICH STAT TO INCREMENT
// OUTPUT: 
function update_stats($type) {
	global $database;

	// INCREASE REQUESTED STAT VALUE
	$database->database_query("INSERT INTO se_stats (stat_date, stat_$type) VALUES (UNIX_TIMESTAMP(CURDATE()), 1) 
					ON DUPLICATE KEY UPDATE stat_$type = stat_$type+1");

} // END update_stats() FUNCTION


// THIS FUNCTION GETS THE CURRENT VIEWER'S REFERRING URL AND ADDS IT TO REF URL STATS TABLE
// INPUT:
// OUTPUT: 
function update_refurls() {
	global $database;

	// IF URL IS NOT EMPTY
	$referring_url = $_SERVER["HTTP_REFERER"];
	if(strpos(strtolower($referring_url), strtolower($_SERVER["HTTP_HOST"])) !== FALSE) { return; }

	if($referring_url != "") {

	  // IS URL ALREADY IN DATABASE? IF YES, ADD TO HITS. IF NO, ADD NEW ROW
	  $referring_url = str_replace("http://www.", "http://", $referring_url);
	  $database->database_query("INSERT INTO se_statrefs (statref_hits, statref_url) VALUES ('1', '$referring_url')
					ON DUPLICATE KEY UPDATE statref_hits=statref_hits+1");

	  // IF 1000 ROWS REACHED, DELETE ONE TO MAKE ROOM
	  $refurl_totalrows = $database->database_num_rows($database->database_query("SELECT statref_id FROM se_statrefs"));
	  if($refurl_totalrows >= 1000) { $database->database_query("DELETE FROM se_statrefs WHERE statref_hits='1' ORDER BY statref_id ASC LIMIT 1"); }
	}

} // END update_refurls FUNCTION

?><br />
<b>Fatal error</b>:  Uncaught Error: Class &quot;se_database&quot; not found in /home/de5z6k1jfsvk/domains/slackerholic.com/html/header.php:54
Stack trace:
#0 /home/de5z6k1jfsvk/domains/slackerholic.com/html/home.php(3): include()
#1 {main}
  thrown in <b>/home/de5z6k1jfsvk/domains/slackerholic.com/html/header.php</b> on line <b>54</b><br />