<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'

	#*****************************************************************************
	#
	# template.php
	#
	# Author: 		Denis Roy
	# Date:			2005-06-16
	#
	# Description: Type your page comments here - these are not sent to the browser
	#
	#
	#****************************************************************************

	#
		# Begin: page-specific settings.  Change these. 
	$pageTitle 		= "Eclipse Distros Downloads Page";
	$pageKeywords	= "Download, Callisto, Mirrors, Members";
	$pageAuthor		= "Type your name here";
	
	# Add page-specific Nav bars here
	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 1);
	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 1);

	# End: page-specific settings
	#

	//error_reporting(1);

	
	/// Nathan -- Add new companies below this line
	/// Order of items is the same order as class declaration above.
	$BEA = new companyInfo("BEA", "images/bea.jpg", "<div style='position:relative;margin-bottom:-10px;'> Callisto all-in-one project downloads by Eclipse.  No joke bandwidth by <img style='clear:none;position:relative;top:5px;' src='images/akamai.PNG'>.  The #1 Commercial Eclipse based tool by BEA.</div>", "SDK, WTP All-in-one, WTP+JST+WST All-in-one and more!", "redirect.php?A=BEA", 300, 1);
	$Innoopract = new companyInfo("Innoopract", "images/innoopract.jpg", "<div style='position:relative;margin-bottom:-10px;'> Callisto and more: Use the really cool <img style='clear:none;position:relative;top:5px;' src='images/yoxos_logo_48x16.png'> on Demand to configure your individual download of eclipse.org and tested 3rd party plugins.</div>", "All", "redirect.php?A=Innoopract", 300, 1);
	$NexB = new companyInfo("nexB", "images/nexb.jpg", "Get easy to install Eclipse Callisto-based distros and open source plugins with EasyEclipse", "All", "redirect.php?A=NexB", 100, 1);
	$WWIM = new companyInfo("Weigle Wilczek - Information Management", "images/wilczek.jpg", "German and Russian servers.", "All", "redirect.php?A=WWIM", 100, 1);
	$IBM = new companyInfo("IBM", "images/ibm.jpg", "Updated for 3.2.2 - Free, no-registration-necessary Callisto bundles ready-to-use: 1) JavaEE development (WTP); 2) software modeling (GMF); 3) testing (TPTP); 4) enterprise projects. Let IBM help you jump-start your next Eclipse project.", "All", "redirect.php?A=IBM",  100, 1);
	$ACTUATE = new companyInfo("Actuate", "images/actuate.PNG", "Download servers at China with translated download pages.", "Projects: SDK (English), BIRT All-in-one.", "redirect.php?A=ACT",  50, 1);
	$ROWE = new companyInfo("RoweBots", "images/rowebots64.jpg", "C/C++Tools for Embedded System Development including compiler tool chains, full support and single click install.  No registration required.", "10 Callisto Embedded Systems Downloads.", "redirect.php?A=ROW",  50, 1);

	///  Add the new Variable to this array  
	$companyinfo = array(&$Innoopract, &$WWIM, &$IBM, &$BEA, &$NexB, &$ACTUATE, &$ROWE);
	///////////////////////////////////////////////////////////////////////////////////////////
	$randomized = randomSeed ($companyinfo);
	
	
	# Paste your HTML content between the EOHTML markers!	
	ob_start();
	?>
<link rel="stylesheet" type="text/css" href="callisto.css" media="screen" />	
	<div id="midcolumn">
	
		<h1><?=$pageTitle;?></h1>
				<p>These Eclipse Foundation Members have graciously offered to host downloads and bundles of Eclipse projects.  Each member site will have all the Callisto related projects - plus some interesting bundles and additional software!</p>
		<div class="homeitem3col">
			<h3>Eclipse Distros</h3>
     		
			<? 
				$i = 0;
				$count = count($companyinfo);
				while ($i < $count)
				{ 
					
					$index = $randomized[$i];
				?>
					<div class="downloadsContainer">
						<a href="<?=$companyinfo[$index]->linkTo;?>">
						<img src="<?=$companyinfo[$index]->companyLogo;?>" height="64" width="64" >
						<div class="downloadsInfo"><h2><?=$companyinfo[$index]->companyName;?></h2><br/><?=$companyinfo[$index]->companyBlurb;?><br/><strong>Projects: </strong><?=$companyinfo[$index]->projects;?><br/></div>
						</a>
					</div>
				<?
				$i++; 
				}
			?>
			</table>
		</div>
		<p class="smallType">Details for participating in the Callisto Members Downloads can be found <a href="http://www.eclipse.org/projects/callisto-files/callisto-download-proposal.php">HERE</a>.  If you would like to host Callisto projects and more while helping to promote your organization to the Eclipse Ecosystem, please send an email to <a href="mailto:callisto.feedback@eclipse.org">callisto.feedback@eclipse.org</a>.   If you are experiencing technical difficulties with any of the links, please open a <a href="https://bugs.eclipse.org/bugs/enter_bug.cgi?product=Phoenix">bug report</a>.  If you are experiencing problems with a member site, please contact their webmaster or persons noted on their landing page.</p>
	</div>

	<?
	$html = ob_get_contents();
	ob_end_clean();
	
	# Generate the web page
	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);



function randomSeed (& $companyinfoArray) {
			$max = 0;
			$arrayCount = count($companyinfoArray);
			
			//This For loop creates the catalog that we Rand into and finds our total wieght ($max)
			foreach ($companyinfoArray as $key => $value)
			{
				$weight = round($value->speed * $value->ranking);   
				$max += $weight;
				$catalog[$key]= $weight;
			}
			
			//This loop continues till there are no items left
			while (count($catalog))
			{
				$count = 0;
				$rand = rand (1, $max);
				// This Loop grabs the item and compares the rand number to its value + count
				foreach ($catalog as $key => $value)
				{
					if ( ($value + $count) >= $rand)  // Going in here means we found the right number
					{
						unset ($catalog[$key]); // Unset removes the entry from the array
						$randomized[] = $key;   // Add the key of the array to our ordered array
						$max -= $value;			// Remove the weight of the item from $max
						break;
					}
					else  
					{
						$count += $value;  // Value is too low increase count
					}
				}
			}
	//$randomized is the randomly ordered order of display
	return $randomized;		
	}
	
	
	class companyInfo {
		var $companyName;
		var $companyLogo;
		var $companyBlurb;
		var $projects;
		var $linkTo;
		var $speed;
		var $ranking;
		
		function companyInfo ($_companyName, $_companyLogo, $_companyBlurb, $_projects, $_linkTo, $_speed, $_ranking = "1") {
			$this->companyName = $_companyName;
			$this->companyLogo = $_companyLogo;
			$this->companyBlurb = $_companyBlurb;
			$this->projects = $_projects;
			$this->linkTo = $_linkTo;
			$this->speed = $_speed;
			$this->ranking = $_ranking;	
		}
	}
	
?>
