This is an issue that I had faced during one of my project using Joomla 1.5. After some try I got this solution. I am sharing it here, hope it will help someone.

Step By Step.

1. Open modules/mod_login/tmpl/default.php
2. Change the textbox name to email
3. Open components/com_user/controller.php
4. Inside the function login replace $credentials['username'] with $credentials['email']
5. Open plugins/authentication/joomla.php
6. Inside the function onAuthenticate, Replace the query around line no: 74
$query = ‘SELECT `id`, `password`, `gid`’
. ‘ FROM `#__users`’
. ‘ WHERE email=’ . $db->Quote( $credentials['email'] )
;

Thats it. Try to login with your email id.

Please let me know if you have any other options for the same.

Thanks

Here is the solution for a customizable image uploading class. This class can be used to upload images, along with its thumbnail with a single click. Each and every location for the image can be specified. Also you can create watermark images.

Source Code Image.class.php
——————————–

/**
* Image File Upload Class
* Author : Aneesh Ramakrishna Pillai
* Email : aneeshrp@ymail.com
* Friday, July 25, 2008
* Version 1.0
*/
class Image
{
/**
* @var
* TYPE : String
* Upload Dir
*/
var $strUploadPath = “../images/Uploads”;

/**
* @var
* TYPE : String
* Directory Path Seperator
*/
var $strPathSeperator = “/”;

/**
* @var
* TYPE : String
* Upload Dir
*/
var $strOriginalImageLocation = “FullSize”;

/**
* @var
* TYPE : String
* Upload Dir
*/
var $strThumbnailImageLocation = “Thumbnail”;

/**
* @var
* TYPE : String
* Upload Dir
*/
var $fileFieldName = NULL;

/**
* @var
* TYPE : DOUBLE
* Maximum Size of an Image
*/
var $intMaximumImageSize = 2000000;

/**
* @var
* TYPE : ARRAY
* Allowd Image Types
*/
var $arrAllowedImageType = array(“JPEG”,”JPG”,”GIF”,”BMP”,”PNG”,”PJPEG”);

/**
* @var
* TYPE : String
* Error Message
*/
var $strUploadErrorMessage = NULL;

/**
* @var
* TYPE : String
* Watermark Image
*/
var $strWaterMarkImage = NULL;

/**
* @var
* TYPE : Boolean
* Boolean Watermark status
*/
var $bolWaterMark = FALSE;

/**
* @var
* TYPE : String
* Final Path of the uploaded Image
*/
var $strUploadedImage = NULL;

/**
* Constructor
*/
public function Image($strFieldName,$strLocation = NULL, $intMaxSize = NULL,$strWaterMarkResource = NULL,$bolWaterMark = true)
{
$this->fileFieldName = $strFieldName;
if(!empty($strLocation)){
$this->strUploadPath = $strLocation;
}

if(!empty($intMaxSize)){
$this->intMaximumImageSize = $intMaxSize;
}

if($bolWaterMark){
$this->bolWaterMark = true;
}

if(!empty($strWaterMarkResource)){
$this->strWaterMarkResource = $strWaterMarkResource;
} else {
$this->strWaterMarkResource = “NAME”;
}
}

/**
* Set Original Image Location
* @param String $strLocationName
*/
public function setFullsizeLocation($strOriginalImageLocation)
{
if(!empty($strOriginalImageLocation)){
$this->strOriginalImageLocation = $strOriginalImageLocation;
}
}

/**
* Set Original Image Location
* @param String $strThumbnailImageLocation
*/
public function setThumbnailLocation($strThumbnailImageLocation)
{
if(!empty($strThumbnailImageLocation)){
$this->strThumbnailImageLocation = $strThumbnailImageLocation;
}
}

public function MoveImageToServer()
{
//Create Root Upload Directory for this section
//if(!is_dir($this->strUploadPath)){ mkdir($this->strUploadPath);}
//Create Sub Directory for orignal image
if(!is_dir($this->strOriginalImageLocation)){
mkdir($this->strUploadPath . $this->strPathSeperator . $this->strOriginalImageLocation,0777);
}

//Create Sub Directory for Thumbail image

if(!is_dir($this->strThumbnailImageLocation)){
mkdir($this->strUploadPath . $this->strPathSeperator . $this->strThumbnailImageLocation,0777);
}
//Upload Full Size Image
//Pick Image Format
$strImageType = $_FILES[$this->fileFieldName]['type'];
if(!empty($strImageType) && stripos($strImageType,$this->strPathSeperator)){
$strImageType = split($this->strPathSeperator,$strImageType);
$strImageType = $strImageType[1];
} else {
$strImageType = NULL;
}
//Pick Image Size
$intImageSize = $_FILES[$this->fileFieldName]['size'];

//Check Necessary Credentials
if(in_array(strtoupper($strImageType),$this->arrAllowedImageType)){
//Create New Image Name
$strNewImageName = substr(time(),rand(0,5),rand(5,9));
$strNewImageName .= basename($_FILES[$this->fileFieldName]['name']);
$strImageDestination = $this->strOriginalImageLocation . $this->strPathSeperator . $strNewImageName;
$this->strUploadedImage = $strImageDestination;
if(move_uploaded_file($_FILES[$this->fileFieldName]['tmp_name'], $strImageDestination)){

$this->createThumbnailImage($strImageDestination);
//$this->addWaterMarks($strImageDestination);
}
return true;
} else {
$this->strUploadErrorMessage = “Pegasus does not support this format or Image size is too large”;
return false;
}
}

public function MoveThumbnailImageToServer()
{
//Create Root Upload Directory for this section
if(!is_dir($this->strUploadPath)){ mkdir($this->strUploadPath);}
//Create Sub Directory for orignal image
if(!is_dir($this->strUploadPath . $this->strPathSeperator . $this->strOriginalImageLocation)){
mkdir($this->strUploadPath . $this->strPathSeperator . $this->strOriginalImageLocation,0777);
}

//Create Sub Directory for Thumbail image
if(!is_dir($this->strUploadPath . $this->strPathSeperator . $this->strThumbnailImageLocation)){
mkdir($this->strUploadPath . $this->strPathSeperator . $this->strThumbnailImageLocation,0777);
}
//Upload Full Size Image
//Pick Image Format
$strImageType = $_FILES[$this->fileFieldName]['type'];
if(!empty($strImageType) && stripos($strImageType,$this->strPathSeperator)){
$strImageType = split($this->strPathSeperator,$strImageType);
$strImageType = $strImageType[1];
} else {
$strImageType = NULL;
}
//Pick Image Size
$intImageSize = $_FILES[$this->fileFieldName]['size'];
//Check Necessary Credentials
if(in_array(strtoupper($strImageType),$this->arrAllowedImageType)){
//Create New Image Name
$strNewImageName = substr(time(),rand(0,5),rand(5,9));
$strNewImageName .= basename($_FILES[$this->fileFieldName]['name']);
$strImageDestination = $this->strUploadPath . $this->strPathSeperator . $this->strThumbnailImageLocation . $this->strPathSeperator . $strNewImageName;
$this->strUploadedImage = $strImageDestination;
if(move_uploaded_file($_FILES[$this->fileFieldName]['tmp_name'], $strImageDestination)){
$this->createThumbnailImage($strImageDestination);
//$this->addWaterMarks($strImageDestination);
}
return true;
} else {
$this->strUploadErrorMessage = “Protaj does not support this format or Image size is too large”;
return false;
}
}

/**
* Create Thumbnail Images From Image ize
*/
public function createThumbnailImage($strImageSource,$withSampling=true)
{

//Create Thumnail Size
$ImageSize = getimagesize($strImageSource);
$Thumbnail = new Thumbnail($ImageSize[0],$ImageSize[1]);
$Thumbnail->ResizeImage();
$strNewFileName = basename($strImageSource);
$strImageDestination = $this->strThumbnailImageLocation . $this->strPathSeperator . $strNewFileName;

$strFileExtension = $this->getFileExtension(basename($strImageSource));
$strFileExtension = strtoupper($strFileExtension);

$intNewWidth = $Thumbnail->New_Width;
$intNewheight = $Thumbnail->New_Height;

// Load
$thumb = imagecreatetruecolor($intNewWidth, $intNewheight);

switch($strFileExtension){
case ‘JPG’:
case ‘JPEG’:
$imSource = imagecreatefromjpeg($strImageSource);
break;

case ‘GIF’:
$imSource = imagecreatefromgif($strImageSource);
break;

case ‘PNG’:
$imSource = imagecreatefrompng($strImageSource);
break;
}
// Resize
if($withSampling)
imagecopyresampled($thumb, $imSource, 0, 0, 0, 0, $intNewWidth, $intNewheight, $ImageSize[0], $ImageSize[1]);
else
imagecopyresized($thumb, $imSource, 0, 0, 0, 0, $intNewWidth, $intNewheight, $ImageSize[0], $ImageSize[1]);

// Output
switch($strFileExtension){
case ‘JPG’:
case ‘JPEG’:
return imagejpeg($thumb,$strImageDestination);
break;

case ‘GIF’:
return imagegif($thumb,$strImageDestination);
break;

case ‘PNG’:
return imagepng($thumb,$strImageDestination);
break;
}
}

/**
* Add water marks to full size images
*/
public function addWaterMarks($strSourceImageName)
{
list($o_Width,$o_Height) = getimagesize($strSourceImageName);
list($w_Width,$w_Height) = getimagesize($this->strWaterMarkResource);

$intWaterMarkLocationHeight = ceil($o_Height/2) – ceil($w_Height/2);
$intWaterMarkLocationWidth = ceil($o_Width/2) – ceil($w_Width/2);

$strSourceImageExtension = $this->getFileExtension(basename($strSourceImageName));
$strSourceImageExtension = strtoupper($strSourceImageExtension);

$WaterMarkIm = imagecreatefrompng($this->strWaterMarkResource);
switch($strSourceImageExtension){
case ‘JPG’:
case ‘JPEG’:
$imgIM = imagecreatefromjpeg($strSourceImageName);
break;

case ‘GIF’:
$imgIM = imagecreatefromgif($strSourceImageName);
break;

case ‘PNG’:
$imgIM = imagecreatefrompng($strSourceImageName);
break;
}

$newImage = imagecreatetruecolor($o_Width,$o_Height);

imagecopyresized($newImage,$imgIM,0,0,0,0,$o_Width,$o_Height,$o_Width,$o_Height);
imagecopy($newImage, $WaterMarkIm, $intWaterMarkLocationWidth, $intWaterMarkLocationHeight,0,0,$w_Width,$w_Height);

switch($strSourceImageExtension){
case ‘JPG’:
case ‘JPEG’:
case ‘PNG’:
imagejpeg($newImage,$strSourceImageName,100);
break;

case ‘GIF’:
imagegif($newImage,$strSourceImageName,100);
break;
}
chmod($strSourceImageName,0777);
}

/**
* Remove An Image from folder
* @param String $strImageLocation
* @return Boolean
*/
public static function Remove($strImageName,$id=”)
{
if(!empty($strImageName)){
if(empty($id)){
//Remove FullSize Image
if(file_exists(PARENT_PATH . COMMON . FULLSIZE . PATH_SEP . $strImageName)){
$bolRemoveFullSize = @unlink(PARENT_PATH . COMMON . FULLSIZE . PATH_SEP . $strImageName);
}
//Remove Thumbnail Image
if(file_exists(PARENT_PATH . COMMON . THUMBNAIL . PATH_SEP . $strImageName)){
$bolRemoveThumbnail = @unlink(PARENT_PATH . COMMON . THUMBNAIL . PATH_SEP . $strImageName);
}
if($bolRemoveFullSize && $bolRemoveThumbnail){
return true;
}
} else {
//Remove FullSize Image
if(file_exists(PARENT_PATH . UPLOADS . $id . PATH_SEP . FULLSIZE . PATH_SEP . $strImageName)){
$bolRemoveFullSize = unlink(PARENT_PATH . UPLOADS . $id . PATH_SEP . FULLSIZE . PATH_SEP . $strImageName);
}
//Remove Thumbnail Image
if(file_exists(PARENT_PATH . UPLOADS . $id . PATH_SEP . THUMBNAIL . PATH_SEP . $strImageName)){
$bolRemoveThumbnail = unlink(PARENT_PATH . UPLOADS . $id . PATH_SEP . THUMBNAIL . PATH_SEP . $strImageName);
}
if($bolRemoveFullSize && $bolRemoveThumbnail){
return true;
}
}
}
}

/**
* Get File Extension From Given String
* @param String
* @return String
*/
public function getFileExtension($strFileName)
{
$ext = substr($strFileName, strrpos($strFileName, ‘.’) + 1);
return $ext;
}
}

Source Code upload_photo.php
———————————-

//Calling the required class file
require_once ‘Image/Image.class.php’;

$File = new Image(‘file_input_name’,'upload_dir’,'watermark_image_loc’);
$File->setFullsizeLocation(‘fullsize_img_upload_location’);
$File->setThumbnailLocation(‘thumbnail_img_upload_location’);
$File->MoveImageToServer();

Thats it ..

Execute the upload_photo.php and enjoy…

This code snippet allows you to resize the image dimensions without affecting the original image’s look and feel.

Source Code ResizeImage.class.php
————————————–
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Thumbnail Creation class. Its s simple class where You can create Thobnail image *
* of your current image, it will not create image rather it reduces the size of the *
* image *
* *
* Name : Thumbnail Class *
* Author : Aneesh *
* Email : webonphp@yahoo.com *
* Date : Saturday, April 07, 2007 *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

class Thumbnail{

var $thumb_Width = 100; //Width Limit For Thumb Nail

var $thumb_Height = 100; //Height Limit For Thumb Nail

var $medium_Width = 275; // Width Limit For Medium SIze Image (Say for Mouse Over Display)

var $medium_Height = 250; // Height Limit For Medium SIze Image (Say for Mouse Over Display)

var $large_Height = 400;

var $large_Width = 600;

var $small_Width = 75; //Less than a Thumnail

var $small_Height = 75; //Less than a Thumnail

var $original_Width; // Original WIdth of the Image, ie the width of the image to be resized

var $original_Height; // Original Height of the Image, ie the height of the image to be resized

var $New_Height; // Resized Images’ Height

var $New_Width; // Resized Images’ Width

var $reszie_Type; // What typ of image we need to create ?? Thumb nail or mouse over

var $base_height; // Base height For Resize type, Will Update dynamically

var $base_width; // Base Width For Resize type, Will Update dynamically

/**
@param int OriginalWidth
@param int Originalheight
@param string ResizeType [Thumb | Hover | Full Size]
return NULL
**/
function Thumbnail($o_Width,$o_Height,$r_Type=’Thumb’){
$this->original_Width = $o_Width;
$this->original_Height = $o_Height;
$this->reszie_Type = $r_Type;
$this->SetBaseLimit();
}

/**
Set Base size or can say as size limits for each type of image
$param NULL
**/
function SetBaseLimit(){
switch($this->reszie_Type){
case ‘Small’:
// Base Size Limit for Thumb Nail Images
$this->base_height = $this->small_Height;
$this->base_width = $this->small_Width;
break;

case ‘Thumb’:
// Base Size Limit for Thumb Nail Images
$this->base_height = $this->thumb_Height;
$this->base_width = $this->thumb_Width;
break;

case ‘Hover’:
// Base Size Limit for Mouse Over Images
$this->base_height = $this->medium_Height;
$this->base_width = $this->medium_Width;
break;

case ‘Large’:
// Base Size Limit for Mouse Over Images
$this->base_height = $this->large_Height;
$this->base_width = $this->large_Width;
break;
}
}

/**
Finds the Image is to resized or not
@param NULL
$return Boolean
**/
function isImageToResize(){
if($this->original_Width > $this->base_width || $this->original_Height > $this->base_height)
return true;
else
return false;
}

/**
Fins the Width Type of Image, ie whther it is a Width > Height Image
or Height >Width Image or Height == Width Image
$return String W ['Width >Height'] |
$return String H ['Width
$return String WH ['Width==Height'] |
**/

function GetImageSizeType(){
/*if($this->original_Width > $this->original_Height)
return ‘W’;
if($this->original_Width < $this->original_Height)
return ‘H’;
if($this->original_Width == $this->original_Height)
return ‘WH’;*/
if($this->reszie_Type == ‘Hover’){
if($this->original_Width > $this->original_Height)
return ‘W’;
if($this->original_Width < $this->original_Height)
return ‘H’;
if($this->original_Width == $this->original_Height)
return ‘WH’;
} else {
return ‘H’;
}
}

/**
Based on the Imagetype and width resize the original image
**/

function ResizeImage(){
if($this->isImageToResize()){
$ImageSizeType = $this->GetImageSizeType();
switch($ImageSizeType){
case ‘W’:
$this->SetSizeOnWidth();
break;
case ‘H’:
$this->SetSizeOnHeight();
break;
case ‘WH’:
$this->SetSizeOnHeight();
break;
}
}else{
$this->SetToDefault();
}
}

/**
Resize the Image Baesd on width
**/
function SetSizeOnWidth(){
$new_width = $this->base_width;
$reduced_width = $this->original_Width – $this->base_width;
$reduced_percentage = ($reduced_width/$this->original_Width)*100;
$height_to_reduce = ($this->original_Height*$reduced_percentage)/100;
$new_height = $this->original_Height-$height_to_reduce;
$this->New_Height = floor($new_height);
$this->New_Width = $new_width;
}

/**
Resize the Image Baesd on Height
**/
function SetSizeOnHeight(){
$new_height = $this->base_height;
$reduced_height = $this->original_Height – $this->base_height;
$reduced_percentage = ($reduced_height/$this->original_Height)*100;
$width_to_reduce = ($this->original_Width*$reduced_percentage)/100;
$new_width = $this->original_Width-$width_to_reduce;
$this->New_Height = floor($new_height);
$this->New_Width = floor($new_width);
}

/**
Set the Image size to its default
**/
function SetToDefault(){
$this->New_Height = $this->original_Height;
$this->New_Width = $this->original_Width;
}
}
?>

Source Code show_image.php
——————————
<img src=”original_image.jpg” > <br />
list($width,$height) = getimagesize(‘original_image.jpg’);
//You can choose Small,Thumb,Hover,Large (each set have a predefined dimensions which can be changed in class file

$SmallThumb = new Thumbnail($width,$height,’Small’);
$SmallThumb->ResizeImage();
$t_width = $SmallThumb->New_Width;
$t_height = $SmallThumb->New_Height;
?>
<img src=”original_image.jpg” height=”" /> ” width=”">