mkrono.class

Ir para a documentação deste ficheiro.

<?php
/*
+--+ Project Name: KronoClass
+--+ Version: 0.7
+--+ Project Author: Tommaso D'Argenio
+--+ Author Email: rajasi@ziobudda.net, info@holosoft.it
+--+ Build Date:  January 10 2003 16.18 (CET)
+--+ Update: September 9 2003 16.35 (CET)
 
+--+ DISCLAIMER
Copyright (c) 2002-03 Tommaso D'Argenio <rajasi@ziobudda.net>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public License
as published by the Free Software Foundation; either version
2.1 of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.  See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public
License along with this program; if not, write to the
Free Software Foundation, Inc.,
59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
http://www.fsf.org
 
+--+ NOTES FROM AUTHOR
* Please, if you make any change in the code let me know by email!!!
   if use this class in your project, please let me know, in this way i can publish it.
    
   If you want to personalize the language settings, please take a look in all ini files.
 
+--+ Requirements:
        PHP 4.0+
*/
 
class MKrono
{
    var $dayNameExt;
    
    var $dayNameCon;
    
    var $monthNameExt;
    
    var $monthNameCon;
 
    var $dataFrom;
 
    var $dataTo;
    
    var $error;
    
    var $abbr;
    
    var $lan; 
    
    var $version='0.7';
    
    var $dateFormat;
    
    var $timeFormat;
 
    var $separator;
    
    var $path;
    
    function __construct($lan='it', $dateFormat='it', $timeFormat='it',$separator='/')
    {
        global $MIOLO;
        
        $this->path = $MIOLO->GetConf('home.etc') . '/mkrono.conf';    
        $xml = new SimpleXML($this->path);
        $this->lan = (string)$xml->xml->language;
        $this->dateFormat = (string)$xml->xml->dateFormat;
        $this->separator = (string)$xml->xml->separator;
        $this->timeFormat = (string)$xml->xml->timeFormat;
        $this->error='';
 
        $this->_checkIniFile();
 
        $array = $xml->ToArray($conf, $xml->xml->longDay);
        foreach($array as $k=>$v) $this->dayNameExt[$k] = $v['day'];
        $array = $xml->ToArray($conf, $xml->xml->shortDay);
        foreach($array as $k=>$v) $this->dayNameCon[$k] = $v['day'];
        $array = $xml->ToArray($conf, $xml->xml->longMonth);
        foreach($array as $k=>$v) $this->monthNameExt[$k] = $v['month'];
        $array = $xml->ToArray($conf, $xml->xml->shortMonth);
        foreach($array as $k=>$v) $this->monthNameCon[$k] = $v['month'];
 
/*        
        $this->dayNameExt=parse_ini_file($this->path.'_long_day.ini', TRUE);
            
        $this->dayNameCon=parse_ini_file($this->path.'_short_day.ini', TRUE);
 
        $this->monthNameExt=parse_ini_file($this->path.'_long_month.ini', TRUE);
 
        $this->monthNameCon=parse_ini_file($this->path.'_short_month.ini', TRUE);
*/
    }
    
    function _checkIniFile()
    {
/*
        if(!file_exists($this->path.'_long_day.ini'))
            $this->error.='Long Days ini languages does\'nt exists!<br>';
        if(!file_exists($this->path.'_short_day.ini'))
            $this->error.='Short Days ini languages does\'nt exists!<br>';
        if(!file_exists($this->path.'_long_month.ini'))
            $this->error.='Long Months ini languages does\'nt exists!<br>';
        if(!file_exists($this->path.'_short_month.ini'))
            $this->error.='Short Months ini languages does\'nt exists!<br>';
*/        
        $this->exitOnError();    
    }
    
    function exitOnError()
    {
        if($this->error!='')
        {
            echo ' [Fatal Error] <b>'.$this->error.'</b> ';
            exit;
        }
    }
    
    function _update()
    {
        $s=stat(__FILE__);
        return $this->kDate('%l %d %F %Y',$s[9]);
    }
    
    function _format()
    {
        switch($this->dateFormat)
        {
            case 'ansi': 
                if(!$this->abbr) 
                    return 'Y'.$this->separator.'m'.$this->separator.'d'; 
                else 
                    return 'Y'.$this->separator.'n'.$this->separator.'j'; 
            break;
            case 'it': 
            case 'br':
                if(!$this->abbr)
                    return 'd'.$this->separator.'m'.$this->separator.'Y';
                else
                    return 'j'.$this->separator.'n'.$this->separator.'Y';
            break; 
            case 'en': 
            case 'std': 
                if(!$this->abbr)
                    return 'm'.$this->separator.'d'.$this->separator.'Y';
                else 
                    return 'n'.$this->separator.'j'.$this->separator.'Y';
            break;        
            default: $this->error='Date Format not recognized, must be "ansi", "it", "std", "br" or "en" !! '; $this->exitOnError();            
        }
    }
    
    function _language()
    {
        switch($this->lan)
        {
            case 'it': return 'Italian'; break;
            case 'en': return 'English'; break;
            case 'de': return 'Deutch'; break;
            case 'fr': return 'French'; break;
            case 'es': return 'Spanish'; break;
            case 'id': return 'Indonesian'; break;
            case 'no': return 'Norway'; break;
            case 'jp': return 'Japanese'; break;
            case 'fi': return 'Finnish'; break;
            case 'nl': return 'Dutch'; break;
            case 'br': return 'Brazilian Portuguese'; break;
            default: return 'Language not recognized!!'; 
        }
    }
    
    function _debug()
    {
        $debug ='
                    Format of Date: <i>'.$this->_format().'</i><br>
                       Date Separator: <i>'.$this->separator.'</i><br>
                    Language: <i>'.$this->_language().'</i>
                    ';
        return $debug;
    }
    function _disclaimer()
    {
        echo '<span style="font-family:helvetica,verdana,serif;font-size:14px;color:#ff9900;">';
        echo '<b>KronoClass</b> v. '.$this->version.' <br>';
        echo '<i>Copyright (c) 2002-2003 by Tommaso D\'Argenio &lt;<a href="mailto:rajasi@ziobudda.net" title="Send me an email">rajasi@ziobudda.net</a>&gt;<br>';
        echo 'Last modified on: '.$this->_update().'</i><br><hr size="1px" width="50%" color="black" align="left"></span><br>';
    }
    
    function _isDaylight($time)
    {
        list($dom, $dow, $month, $hour, $min) = explode(":", date("d:w:m:H:i", $time)); 
        
        if   ($month > 4 && $month < 10) 
        { 
          $retval = 1;        # May thru September 
        } 
        elseif ($month == 4 && $dom > 7) 
        { 
          $retval = 1;        # After first week in April 
        } 
        elseif ($month == 4 && $dom <= 7 && $dow == 0 && $hour >= 2) 
        { 
          $retval = 1;        # After 2am on first Sunday ($dow=0) in April 
        } 
        elseif ($month == 4 && $dom <= 7 && $dow != 0 && ($dom-$dow > 0)) 
        { 
          $retval = 1;        # After Sunday of first week in April 
        } 
        elseif ($month == 10 && $dom < 25) 
        { 
          $retval = 1;        # Before last week of October 
        } 
        elseif ($month == 10 && $dom >= 25 && $dow == 0 && $hour < 2) 
        { 
          $retval = 1;        # Before 2am on last Sunday in October 
        } 
        elseif ($month == 10 && $dom >= 25 && $dow != 0 && ($dom-24-$dow < 1) ) 
        { 
          $retval = 1;        # Before Sunday of last week in October 
        } 
        else 
        { 
          $retval = 0; 
        } 
        
        return($retval);     
    }
    
    
    function dayToN($day)
    {
        if($day=='' || strlen($day)<3)
        {
            $this->error='Day name not valid!';
            $this->exitOnError();            
        }
        
        $day=ucwords($day);        
        if(strlen($day)==3)
            $ar=$this->dayNameCon[$this->lan];
        else
            $ar=$this->dayNameExt[$this->lan];
            
        if(in_array($day,$ar))
        {
            $k=array_keys($ar,$day);
            return($k[0]);
        }
    }
    
    function NToDay($day)
    {
        if($day>6 || $day<0)
        {
            $this->error='Day range not valid. Must be 0 to 6!';
            $this->exitOnError();
        }
        
        if($this->abbr===true)
            return($this->dayNameCon[$this->lan][$day]);
        elseif($this->abbr!=true)
            return($this->dayNameExt[$this->lan][$day]);
    }
    
    function monthToN($month)
    {
        if($month=='' || strlen($month)<3)
        {
            $this->error='Month name not valid!';
            $this->exitOnError();            
        }
        
        $month=ucwords($month);        
        if(strlen($month)==3)
            $ar=$this->monthNameCon[$this->lan];
        else
            $ar=$this->monthNameExt[$this->lan];
            
        if(in_array($month,$ar))
        {
            $k=array_search($month,$ar);
            return($k+1);
        }
        else
            return -1;
    }
    
    function NToMonth($month)
    {
        if($month>12 || $month<1)
        {
            $this->error='Month range not valid. Must be 1 to 12!';
            $this->exitOnError();
        }
 
        if($this->abbr===true)
            return($this->monthNameCon[$this->lan][$month-1]);
        elseif($this->abbr!=true)
            return($this->monthNameExt[$this->lan][$month-1]);
    }
 
 
    function isDay($data,$day)
    {
        $data=str_replace('-','/',$data);
        $data=str_replace('.','/',$data);
        $exp=explode('/',$data);
        
        $data_unix=$this->kMkTime($exp);
        $giorno_unix=date('w',$data_unix);
    
        if(!is_numeric($day))
        {
            $day=$this->dayToN($day);        
        }
    
        if($giorno_unix==$day)
            return 1;
        else
            return $this->NToDay($giorno_unix);    
    }
 
    function dateToTimestamp($date)
    {
        if(strstr($date,' '))
        {
            $t = explode(' ',$date);
            $date = $t[0];
            $time = explode(':',$t[1]);
        }
        else
            $time = '';
        $date=str_replace('-','/',$date);
        $date=str_replace('.','/',$date);
        $exp=explode('/',$date);
        if($time!='')
        {
            $exp[3]=(isset($time[0])) ? $time[0] : 0;
            $exp[4]=(isset($time[1])) ? $time[1] : 0;
            $exp[5]=(isset($time[2])) ? $time[2] : 0;
        }
        return $this->kMkTime($exp);
    }
    
    function daysDiff($data_ini,$data_fin)
    {
        $data_ini=str_replace('-','/',$data_ini);
        $data_ini=str_replace('.','/',$data_ini);
        $data_fin=str_replace('-','/',$data_fin);
        $data_fin=str_replace('.','/',$data_fin);
        
        $exp_ini=explode('/',$data_ini);
        $exp_fin=explode('/',$data_fin);
        
        $ini=date('z',$this->kMkTime($exp_ini));
        $fin=date('z',$this->kMkTime($exp_fin));
 
        $days = floor(($this->kMkTime($exp_fin)-$this->kMkTime($exp_ini))/(60*60*24));        
        return $days;
    }
 
    function timesDiff($time_from,$time_to,$result_in="m")
    {
        if( (strstr($time_from,'.') || strstr($time_from,':')) && (strstr($time_to,'.') || strstr($time_to,':')) )
        {
            $time_from=str_replace(':','.',$time_from);
            $time_to=str_replace(':','.',$time_to);
            
            $t1=explode('.',$time_from);
            $t2=explode('.',$time_to);
            
            $h1=$t1[0];
            $m1=$t1[1];
            
            $h2=$t2[0];
            $m2=$t2[1];
            
            if($h1<=24 && $h2<=24 && $h1>=0 && $h2>=0 && $m1<=59 && $m2<=59 && $m1>=0 && $m2>=0)
            {
                $diff=($h2*3600+$m2*60)-($h1*3600+$m1*60);
                if($result_in=="s")
                    return $diff;
                elseif($result_in=="m")
                {
                    return $diff/60;
                }
                elseif($result_in=="h")
                {
                    $r=$diff/3600;
                    $t=explode('.',$r);
                    $h=$t[0];
                    if($h>24)
                        $h-=24;                    
                    $m=round("0.$t[1]"*60);
                    return $h.'h'.$m.'m';
                }            
            }
            else
            {
                $this->error='Time range not valid. Must be 0 to 24 for hours and 0 to 59 for minutes!';
                $this->exitOnError();
            }                            
        }
        else
        {
            $this->error='Time format not valid. Must be in format HH:mm or HH.mm';
            $this->exitOnError();        
        }    
    }
    
    function timesAdd($time,$add,$what)
    {
        if( (strstr($time,'.') || strstr($time,':')))
        {
            $time=str_replace(':','.',$time);            
            $t1=explode('.',$time);            
            $h1=$t1[0];
            $m1=$t1[1];
            if($h1<=24 && $h1>=0  && $m1<=59 && $m1>=0)
            {
                if($what=="m")
                {
                    $res=($h1*60)+$m1+$add;
                    $r=$res/60;
                    $t=explode('.',$r);
                    $h=$t[0];
                    if($h>24)
                        $h-=24;                    
                    $m=round("0.$t[1]"*60);
                    return $h.':'.$m;
                }
                elseif($what=="h")
                {
                    $res=($h1*60)+$m1+($add*60);
                    $r=$res/60;
                    $t=explode('.',$r);
                    $h=$t[0];
                    if($h>24)
                        $h-=24;                    
                    $m=round("0.$t[1]"*60);
                    return $h.':'.$m;                
                }
                elseif($what=="t")
                {
                    if( (strstr($add,'.') || strstr($add,':')))
                    {
                        $add=str_replace(':','.',$add);            
                        $t1=explode('.',$add);            
                        $h2=$t1[0];
                        $m2=$t1[1];
                        if($h2<=24 && $h2>=0  && $m2<=59 && $m2>=0)
                        {
                            $res=($h1*60)+($h2*60)+$m1+$m2;
                            $r=$res/60;
                            $t=explode('.',$r);
                            $h=$t[0];
                            if($h>24)
                                $h-=24;
                            $m=round("0.$t[1]"*60);
                            return $h.':'.$m;                                            
                        }                        
                    }                    
                    else
                    {
                        $this->error='Time format not valid. Must be in format HH:mm or HH.mm';
                        $this->exitOnError();        
                    }    
                }
            }
            else
            {
                $this->error='Time range not valid. Must be 0 to 24 for hours and 0 to 59 for minutes!';
                $this->exitOnError();
            }                            
        }
        else
        {
            $this->error='Time format not valid. Must be in format HH:mm or HH.mm';
            $this->exitOnError();        
        }    
    }
    
    function howTo($data)
    {
        $data=str_replace('-','/',$data);
        $data=str_replace('.','/',$data);
        $exp=explode('/',$data);
        $data_unix=$this->kMkTime($exp);
        $diff = $data_unix-time();
        if($data_unix>time())
            return (date("z",$diff));
        else
        {
            $this->error='Cannot perform calculation on past time!';
            $this->exitOnError();
        }
    }
 
    function howDays($data_ini,$data_fin,$day)
    {
        $data_ini=str_replace('-','/',$data_ini);
        $data_ini=str_replace('.','/',$data_ini);    
    
        $eta_data=$this->daysDiff($data_ini,$data_fin);
 
        $giorno=(int)$this->atomDate($data_ini,'d');
        $mese=(int)$this->atomDate($data_ini,'m');
        $anno=(int)$this->atomDate($data_ini,'Y');
        
        $count=0;
 
        for($i=0;$i<$eta_data;$i++)
        {        
            $data=date($this->_format(),mktime(0,0,0,$mese,$giorno+$i,$anno));
            if($this->isDay($data,$day)===1)
                $count++;
        }        
        return $count;
    }
    
    function kMkTime($exp)
    {
        (isset($exp[3])) ? $h=$exp[3] : $h=0;
        (isset($exp[4])) ? $m=$exp[4] : $m=0;
        (isset($exp[5])) ? $s=$exp[5] : $s=0;        
        switch($this->dateFormat) 
        {
            case 'ansi': return $this->makeTime($h,$m,$s,$exp[1],$exp[2],$exp[0]); break; // using YYYY-MM-DD                
            case 'it': return $this->makeTime($h,$m,$s,$exp[1],$exp[0],$exp[2]); break;// using DD-MM-YYYY
            case 'br': return $this->makeTime($h,$m,$s,$exp[1],$exp[0],$exp[2]); break;// using DD-MM-YYYY
            case 'std': return $this->makeTime($h,$m,$s,$exp[0],$exp[1],$exp[2]); break; // using MM-DD-YYYY                                        
            case 'en': return $this->makeTime($h,$m,$s,$exp[0],$exp[1],$exp[2]); break; // using MM-DD-YYYY                                                        
            default: $this->error='Date Format not recognized, must be "ansi", "it", "std", "br" or "en" !! '; $this->exitOnError();
        }
    }
    
    function atomDate($date,$atom)
    {
        if(strlen($date)<=10)
        {
            $date.=' 00:00:00';
        }
 
        $t=explode(' ',$date);
        $exp1=explode('/',$t[0]);
        $exp2=explode(':',$t[1]);
        $exp=array_merge($exp1,$exp2);
        // Extract only time
        switch($atom)
        {
            case 'h': return $exp[3]; break;
            case 'i': return $exp[4]; break;
            case 's': return $exp[5]; break;
        }
        // Extract day,month and year
        switch($this->dateFormat)
        {
            case 'ansi':
            {
                switch($atom)
                {
                    case 'd': return $exp[2]; break;
                    case 'm': return $exp[1]; break;
                    case 'y': return substr($exp[0],2,2); break;
                    case 'Y': return $exp[0]; break;
                    default: $this->error='Atom not recognized, must be "d", "m", "y" or "Y" !!'; $this->exitOnError();
                }
                break;
            }            
            case 'it':
            case 'br':
            {
                switch($atom)
                {
                    case 'd': return $exp[0]; break;
                    case 'm': return $exp[1]; break;
                    case 'y': return substr($exp[2],2,2); break;
                    case 'Y': return $exp[2]; break;
                    default: $this->error='Atom not recognized, must be "d", "m", "y" or "Y" !!'; $this->exitOnError();
                }
                break;
            }            
            case 'en':
            case 'std':
            {
                switch($atom)
                {
                    case 'd': return $exp[1]; break;
                    case 'm': return $exp[0]; break;
                    case 'y': return substr($exp[2],2,2); break;
                    case 'Y': return $exp[2]; break;
                    default: $this->error='Atom not recognized, must be "d", "m", "y" or "Y" !!'; $this->exitOnError();
                }
                break;
            }            
            default: $this->error='Date Format not recognized, must be "ansi", "it", "std","br" or "en" !! '; $this->exitOnError();            
        }
    }
    
 
    function kDate($format="%l %d %F %Y",$timestamp=0)
    {    
        if($timestamp==0)
            $timestamp=time();
            
 
        if(!preg_match('/\%l|\%F|\%D|\%M/',$format))
        {
            return date(str_replace('%','',$format),$timestamp);
        }
        else
        {
            $out=$format;
            if(strstr($format,'%l'))
            {
                $this->abbr=false;
                $out=str_replace('%l',$this->NToDay(date('w',$timestamp)),$out);
            }
            if(strstr($format,'%F'))
            {
                $this->abbr=false;
                $out=str_replace('%F',$this->NToMonth(date('m',$timestamp)),$out);
            }
            if(strstr($format,'%D'))
            {
                $this->abbr=true;
                $out=str_replace('%D',$this->NToDay(date('w',$timestamp)),$out);
            }
            if(strstr($format,'%M'))
            {
                $this->abbr=true;
                $out=str_replace('%M',$this->NToMonth(date('m',$timestamp)),$out);
            }            
            if(strstr($format,'%Y'))
                $out=str_replace('%Y',date('Y',$timestamp),$out);
            if(strstr($format,'%y'))
                $out=str_replace('%y',date('y',$timestamp),$out);
            if(strstr($format,'%d'))
                $out=str_replace('%d',date('d',$timestamp),$out);
            if(strstr($format,'%m'))
                $out=str_replace('%m',date('m',$timestamp),$out);
            if(strstr($format,'%n'))
                $out=str_replace('%n',date('n',$timestamp),$out);
            if(strstr($format,'%j'))
                $out=str_replace('%j',date('j',$timestamp),$out);
 
            return $out;
        }
    }
    
    /* Perform operation like sum or subtraction on date 
    *  @access public
    *  @return date The date transformed by calc
    *  @param  string $operator Operator may be
    *  +  '+' -> for sum
    *  +  'sum' -> for sum
    *  +  'add' -> for sum
    *  +  '-' -> for subtraction
    *  +  'sub'-> for subtraction
    *  +  'sot'-> for subtraction
    *  @param  date $date The date to calc on
    *  @param  string $operand is a number plus '%D' for days, '%M' for months, '%Y' for years
    *  + Example:
    *    - Add 1 month to a date:
    *    - $obj->operation('+','10/01/2003','1%M');
    * 
    *    - Subtract 20 days from a date:
    *    - $obj->operation('-','10/01/2003','20%D');
    */    
    function operation($operator,$date,$operand)
    {
        // Thanks to Tim Hodson tim@trundlie.fsnet.co.uk - Begin Change
        if(is_array($date))
        {    //to take a date as an array rather than hardcoded string
            $date2=$this->kMkTime($date);
            $ts=$date2; 
        }
        elseif(is_string($date))
        { // to handle an original string
            $ts=$this->dateToTimestamp($date);
        }
        elseif(is_integer($date))
        { // to handle a timestamp
            $ts = $date;
        }
        // end change of Tim
        
        if(!strstr($operand,'%'))
        {
            $this->error='Bad operand type!!';
            $this->exitOnError();
        }
 
        $t=explode('%',$operand);
        $how=$t[0];
        
        switch($t[1])
        {
            case 'D':
            {
                if($operator=='+' || $operator=='sum' || $operator=='add')
                {
                    return date($this->_format(),mktime(0,0,0,date('m',$ts),date('d',$ts)+$how,date('Y',$ts)));
                }
                elseif($operator=='-' || $operator=='sub' || $operator=='sot')
                {
                    return date($this->_format(),mktime(0,0,0,date('m',$ts),date('d',$ts)-$how,date('Y',$ts)));                
                }
                else
                {
                    $this->error='Operator not recognized!!';
                    $this->exitOnError();
                }
                break;
            }
            case 'M':
            {
                if($operator=='+' || $operator=='sum' || $operator=='add')
                {
                    return date($this->_format(),mktime(0,0,0,date('m',$ts)+$how,date('d',$ts),date('Y',$ts)));
                }
                elseif($operator=='-' || $operator=='sub' || $operator=='sot')
                {
                    return date($this->_format(),mktime(0,0,0,date('m',$ts)-$how,date('d',$ts),date('Y',$ts)));                
                }
                else
                {
                    $this->error='Operator not recognized!!';
                    $this->exitOnError();
                }
                break;
            }
            case 'Y':
            {
                if($operator=='+' || $operator=='sum' || $operator=='add')
                {
                    return date($this->_format(),mktime(0,0,0,date('m',$ts),date('d',$ts),date('Y',$ts)+$how));
                }
                elseif($operator=='-' || $operator=='sub' || $operator=='sot')
                {
                    return date($this->_format(),mktime(0,0,0,date('m',$ts),date('d',$ts),date('Y',$ts)-$how));                
                }
                else
                {
                    $this->error='Operator not recognized!!';
                    $this->exitOnError();
                }
                break;
            }
            default: 
            {
                $this->error='Bad operand type!!';
                $this->exitOnError();
            }
        }        
    }    
    
    function netTimestamp($server='time-a.nist.gov', $port=37) 
    {           
        if ($fp = fsockopen($server, $port, $errno, $errstr, 25)) 
        { 
            fputs($fp, "\n"); 
            $timevalue = fread($fp, 49); 
            fclose($fp); 
        } 
        else
        {
            $this->error=$server.' Time Server unavailable or u\'re not connected on the net!!';
            $this->exitOnError();
        }
 
        $ts = (abs(hexdec('7fffffff') - hexdec(bin2hex($timevalue)) - hexdec('7fffffff')) - 2208988800); 
        return $ts; 
    } 
 
    function swatchTime() 
    { 
      $offset = 60; 
      $beat_division = 24 * 60 / 1000; 
      $current_date = getdate(time()); 
      $hour = $current_date["hours"]; 
      $minute = $current_date["minutes"]; 
      $seconds = $current_date["seconds"]; 
      $total_minutes = $minute + $offset + $hour * 60; 
      $beats = round ($total_minutes / $beat_division); 
      if ($beats >= 1000) 
      { 
        $beats = $beats % 1000; 
      } 
       return ("@".$beats); 
    }     
    
    function mysql_time_easy($timestamp,$mode='mysqlfrom') 
    { 
      $formated='';
      
        if($mode=='mysqlfrom')
        {
            $hour = substr($timestamp,8,2);  
            $minute = substr($timestamp,10,2);  
            $second = substr($timestamp,12,2);  
            $month = substr($timestamp,4,2);  
            $day = substr($timestamp,6,2);  
            $year = substr($timestamp,0,4);  
            $mktime = mktime($hour, $minute, $second, $month, $day, $year);  
            $format=$this->_format();
            $f=explode($this->separator,$format);
            $format='%'.$f[0].$this->separator.'%'.$f[1].$this->separator.'%'.$f[2].' %g:%i %a';
             $formated = $this->kDate($format,$mktime); 
        }
        else
        {
            $data=str_replace('-','/',$timestamp);
            $data=str_replace('.','/',$data);
            $m=$this->atomDate($data,'m');
            $d=$this->atomDate($data,'d');
            $Y=$this->atomDate($data,'Y');
            $h=$this->atomDate($data,'h');
            $i=$this->atomDate($data,'i');
            $s=$this->atomDate($data,'s');
            $formated=$Y.$m.$d.$h.$i.$s;
        }        
        return $formated; 
    } 
    
    function getNthDay($number,$weekday,$month,$year=0) 
    { 
        if($number>5)
        {
            $this->error='There isn\'t more than 5 '.$weekday.' in a month, usually!!';
            $this->exitOnError();
        }
 
        $date_counter=1;  
        $week_counter=0;  
        
        if($year==0)
            $year=date('Y');
        
        if(strlen($weekday)>3)
            $format_dow='%l';
        else
            $format_dow='%D';
        
        if(!is_numeric($month))
        {
            $month=$this->monthToN($month);
        }
        
        do
        {
            $itsit=mktime(0,0,0,$month,$date_counter,$year); 
            $dow=$this->kDate($format_dow,$itsit); 
            if($dow==$weekday)
            {   
                $week_counter++; 
            } 
            
            if( ($week_counter==$number) && ($weekday==$dow) ) 
            {
                $week_counter=$number; 
                if($date_counter > 1) // Thanks to Maurizio Marini <maumar@datalogica.com>
                    $date_counter--;
            } 
            else 
            { 
                $date_counter++; 
            } 
        } 
        while($week_counter<$number);
 
        $itsit=mktime(0,0,0,$month,$date_counter+1,$year); 
        $format=$this->_format();
        $f=explode($this->separator,$format);
        $format='%'.$f[0].$this->separator.'%'.$f[1].$this->separator.'%'.$f[2];                 
        
        if($this->kDate('n',$itsit)!=$month)
        {
            $this->error='Bad request, try again!!';
            $this->exitOnError();
        }
        else
        {
            return $this->kDate($format,$itsit); 
        }
    }     
    
    function romanDate($date)
    {
        $unit=array(0=>"",1=>'I',2=>'II',3=>'III',4=>'IV',5=>'V',6=>'VI',7=>'VII',8=>'VIII',9=>'IX');
        $tens=array(0=>"",10=>'X',20=>'XX',30=>'XXX',40=>'XL',50=>'L',60=>'LX',70=>'LXX',80=>'LXXX',90=>'XC');
        $hund=array(0=>"",100=>'C',200=>'CC',300=>'CCC',400=>'CD',500=>'D',600=>'DC',700=>'DCC',800=>'DCCC',900=>'CM');
        $thou=array(0=>"",1000=>'M',2000=>'MM',3000=>'MMM',4000=>'MMMM',5000=>'MMMMM');    
 
        if($date=='')
        {
            $date=date('d/m/Y',time());        
            $old_state=$this->dateFormat;
            $this->dateFormat='it';
            $year=$this->atomDate($date,'Y');
            $month=$this->atomDate($date,'m');
            $day=$this->atomDate($date,'d');
            $this->dateFormat=$old_state;
        }
        else
        {
            $year=$this->atomDate($date,'Y');
            $month=$this->atomDate($date,'m');
            $day=$this->atomDate($date,'d');
        }
        
         $y_thou = substr($year, -4, 1) * 1000; 
         $y_hund = substr($year, -3, 1) * 100; 
         $y_tens = substr($year, -2, 1) * 10; 
         $y_unit = substr($year, -1, 1); 
         
         $m_tens=substr($month,-2,1)*10;
         $m_unit=substr($month,-1,1);
         
         $d_tens=substr($day,-2,1)*10;
         $d_unit=substr($day,-1,1);
         
         return $tens[$d_tens].$unit[$d_unit].
                     $tens[$m_tens].$unit[$m_unit].
                    $thou[$y_thou].$hund[$y_hund].$tens[$y_tens].$unit[$y_unit];
    }
    
     function yearMoonPhases($Y) 
     { 
       //Converted from Basic by Roger W. Sinnot, Sky & Telescope, March 1985. 
       //Converted from javascript by Are Pedersen 2002 
       //Javascript found at http://www.stellafane.com/moon_phase/moon_phase.htm 
        
       $R1 = 3.14159265 / 180; 
       $U = false; 
       $s = ""; // Formatted Output String 
       $K0 = intval(($Y-1900)*12.3685); 
       $T = ($Y-1899.5) / 100; 
       $T2 = $T*$T; $T3 = $T*$T*$T; 
       $J0 = 2415020 + 29*$K0; 
       $F0 = 0.0001178*$T2 - 0.000000155*$T3; 
       $F0 += (0.75933 + 0.53058868*$K0); 
       $F0 -= (0.000837*$T + 0.000335*$T2); 
       //X In the Line Below, F is not yet initialized, and J is not used before it set in the FOR loop. 
       //X J += intval(F); F -= INT(F); 
       //X Ken Slater, 2002-Feb-19 on advice of Pete Moore of Houston, TX 
       $M0 = $K0*0.08084821133; 
       $M0 = 360*($M0 - intval($M0)) + 359.2242; 
       $M0 -= 0.0000333*$T2; 
       $M0 -= 0.00000347*$T3; 
       $M1 = $K0*0.07171366128; 
       $M1 = 360*($M1 - intval($M1)) + 306.0253; 
       $M1 += 0.0107306*$T2; 
       $M1 += 0.00001236*$T3; 
       $B1 = $K0*0.08519585128; 
       $B1 = 360*($B1 - intval($B1)) + 21.2964; 
       $B1 -= 0.0016528*$T2; 
       $B1 -= 0.00000239*$T3; 
       for ( $K9=0; $K9 <= 28; $K9=$K9+0.5 ) 
       { 
         $J = $J0 + 14*$K9; $F = $F0 + 0.765294*$K9; 
         $K = $K9/2; 
         $M5 = ($M0 + $K*29.10535608)*$R1; 
         $M6 = ($M1 + $K*385.81691806)*$R1; 
         $B6 = ($B1 + $K*390.67050646)*$R1; 
         $F -= 0.4068*sin($M6); 
         $F += (0.1734 - 0.000393*$T)*sin($M5); 
         $F += 0.0161*sin(2*$M6); 
         $F += 0.0104*sin(2*$B6); 
         $F -= 0.0074*sin($M5 - $M6); 
         $F -= 0.0051*sin($M5 + $M6); 
         $F += 0.0021*sin(2*$M5); 
         $F += 0.0010*sin(2*$B6-$M6); 
         $F += 0.5 / 1440; //Adds 1/2 minute for proper rounding to minutes per Sky & Tel article 
         $J += intval($F); $F -= intval($F); 
         //Convert from JD to Calendar Date 
         $julian=$J+round($F); 
         $s = jdtogregorian ($julian); 
         //half K 
         if (($K9-floor($K9))>0)
         { 
             if (!$U)
             { 
                 //New half 
                 $phases[$s]="New Half"; 
             }
             else
             { 
                 //Full half 
                 $phases[$s]="Full Half"; 
             } 
         }
         else
         { 
             //full K 
             if ( !$U )
             { 
                 $phases[$s]="New Moon"; 
             }
             else
             { 
                 $phases[$s]="Full Moon"; 
             } 
             $U = !$U; 
         } 
       } // Next 
       return $phases; 
     } //End MoonPhase 
    
     /*
         Public: Return the Moon phase for given date, if no date is present refer to present day
     */
     function todayMoonPhase($date='')
     { 
        if(!isset($date) || $date=='')
        {
            $time=time();
        }
        else
            $time=$this->dateToTimestamp($date);
 
           $moon_phases=$this->yearMoonPhases(date("Y",$time));          
         $day=$this->kDate("%n/%j/%Y",$time); 
         $k=array_keys($moon_phases);
         $ab=$this->abbr;
         $this->abbr=true;
         while(!$key=array_search($day,$k))
         {         
             $day=$this->operation('-',$day,'1%D');
         }         
         $this->abbr=$ab;
         return $moon_phases[$day]; 
     } 
     
     function getSunTime($latitude=0,$longitude=0,$timezone=1,$location='IT|Roma',$daylight=1,$date='')
     {
        $result='';
        if(!isset($date) || $date=='')
        {
            $time=time();
        }
        else
            $time=$this->dateToTimestamp($date);
 
         if($location!='' && ($latitude==0 || $longitude==0))
        {
            require_once '_it_geo_coord.dat.php';            
            $location=strtoupper($location);
            if(in_array($location,array_keys($_geo_coord)))
            {
                $exp=explode('|',$_geo_coord[$location]);
                $latitude=$exp[0];
                $longitude=$exp[1];
            }            
        }
        
        $yday = date('z',$time); 
        $mon = date('n',$time); 
        $mday = date('j',$time); 
        $year = date('Y',$time); 
        
 
        $DST=$this->_isDaylight($time); 
        if($DST) 
        {
            $timezone = ($timezone + 1);
        } 
        
        if($timezone == "13") 
        {
            $timezone = "-11";
        } 
    
       $A = 1.5708; 
       $B = 3.14159; 
       $C = 4.71239; 
       $D = 6.28319;      
       $E = 0.0174533 * $latitude; 
       $F = 0.0174533 * $longitude; 
       $G = 0.261799  * $timezone; 
    
       # For astronomical twilight, use R = -.309017 
       # For     nautical twilight, use R = -.207912 
       # For        civil twilight, use R = -.104528 
       # For     sunrise or sunset, use R = -.0145439 
       $R = -.0145439;     
    
        for ($i = 0; $i < 2; $i++) 
        { 
    
            if (!$i) 
            {
                $J =  $A;  
                $type = "rise";
            }    # calculate sunrise 
            else  
            {
                $J =  $C;  
                $type = "set"; 
            }    # calculate sunset 
    
           $K = $yday + (($J - $F) / $D); 
           $L = ($K * .017202) - .0574039;              # Solar Mean Anomoly 
           $M = $L + .0334405 * sin($L);                # Solar True Longitude 
           $M += 4.93289 + (3.49066E-04) * sin(2 * $L); 
          # Quadrant Determination 
             if ($D == 0) 
             {
                 $this->error="Trying to normalize with zero offset..."; 
                $this->exitOnError();
             } 
             
             while($M < 0)   
             {
                 $M = ($M + $D);
             } 
             
             while($M >= $D) 
             {
                 $M = ($M - $D);
             } 
        
               if (($M / $A) - intval($M / $A) == 0) 
               {
                       $M += 4.84814E-06;
               } 
               
               $P = sin($M) / cos($M);                   # Solar Right Ascension 
               $P = atan2(.91746 * $P, 1); 
            
               # Quadrant Adjustment 
               if ($M > $C) 
               {
                       $P += $D;
               } 
               else 
               {
                       if ($M > $A) 
                    {
                        $P += $B;
                    } 
               } 
            
               $Q = .39782 * sin($M);            # Solar Declination 
               $Q = $Q / sqrt(-$Q * $Q + 1);     # This is how the original author wrote it! 
               $Q = atan2($Q, 1); 
            
               $S = $R - (sin($Q) * sin($E)); 
               $S = $S / (cos($Q) * cos($E)); 
            
               if (abs($S) > 1) 
               {
                    $result.='none';
               }     # Null phenomenon 
            
               $S = $S / sqrt(-$S * $S + 1); 
               $S = $A - atan2($S, 1); 
            
               if ($type == 'rise') 
               {
                       $S = $D - $S ;
               } 
            
               $T = $S + $P - 0.0172028 * $K - 1.73364; # Local apparent time 
               $U = $T - $F;                            # Universal timer 
               $V = $U + $G;                            # Wall clock time 
              # Quadrant Determination 
                 if ($D == 0) 
                 {
                     $this->error="Trying to normalize with zero offset..."; 
                    $this->exitOnError();
                 } 
                 
                 while($V < 0)
                 {
                     $V = ($V + $D);
                 } 
                 
                 while($V >= $D) 
                 {
                     $V = ($V - $D);
                 } 
 
               $V = $V * 3.81972; 
            
               $hour = intval($V); 
               $min  = intval((($V - $hour) * 60) + 0.5); 
            
               $result.="sun$type is at: "; 
               
               if($this->timeFormat=='12' || $this->timeFormat==12 || $this->timeFormat='en')
                      $result.=date( "g:i A", mktime($hour,$min,0,$mon,$mday,$year) ); 
               else
                   $result.=date( "H:i", mktime($hour,$min,0,$mon,$mday,$year) );                 
                   
               $result.='&nbsp;-&nbsp;';
          }
        return $result;
     }    
     
     function pg_time_easy($timestamp)
     {
        $Date_Time = explode(" ", $timestamp);
        $date_pieces = explode("-", $Date_Time[0]);
        $time_convert = explode("-", $Date_Time[1]);
        $time_pieces = explode(":", $time_convert[0]);
        
        $timestamp = mktime($time_pieces[0], $time_pieces[1], $time_pieces[2], $date_pieces[1], $date_pieces[2], $date_pieces[0]);
        return $this->kDate('',$timestamp);
    }
    
    function timeToText($seconds, $format="h")
    {
        $hours=0;
        $minutes=0;
        $days=0;
 
        if($seconds<=60)
        {
            $hours=0;
            $minutes=0;
        }        
        elseif($seconds>=60 && $seconds<3600)
        {
            $hours=0;
            $minutes=$seconds/60;
            $t=explode('.',$minutes);
            $minutes=$t[0];
            $seconds=round("0.$t[1]"*60);
        }
        elseif($seconds>=3600 && $seconds<86400)
        {
            $r=$seconds/3600;
            $t=explode('.',$r);
            $hours=$t[0];
            if($hours>24)
                $hours-=24;                    
 
            $minutes="0.$t[1]"*60;
            $t=explode('.',$minutes);
            $minutes=$t[0];
            $seconds=round("0.$t[1]"*60);
        }                
        elseif($seconds>=86400)        
        {
            $r=$seconds/86400;
            $t=explode('.',$r);
            $days=$t[0];
            $hours="0.$t[1]"*24;
            if(!strstr($hours,"."))
            {
                $minutes=0;
                 $seconds=0;
            }
            else
            {
                $t=explode(".",$hours);
                $hours=$t[0];
                $mi="0.$t[1]"*60;
                if(!strstr($mi,"."))
                {
                    $minutes=$mi;
                    $seconds=0;
                }
                else
                {
                    $t=explode(".",$mi);
                    $minutes=$t[0];
                    $seconds=round("0.$t[1]"*60);
                }
            }        
        }
        
        if($hours>1)
            $hours.=($format=='h' || $format=='d') ? 'h ' : 'hours ';
        else
            $hours.=($format=='h' || $format=='d') ? 'h ' : 'hour ';
            
        if($minutes>1)
            $minutes.=($format=='h' || $format=='d') ? 'm ' : 'minutes ';
        else
            $minutes.=($format=='h' || $format=='d') ? 'm ' : 'minute ';        
            
        if($seconds>1)
            $seconds.=($format=='h' || $format=='d') ? 's ' : 'seconds ';
        else
            $seconds.=($format=='h' || $format=='d') ? 's ' : 'second ';
            
        if($days>1)
            $days.=($format=='h' || $format=='d') ? 'd ' : 'days ';
        else
            $days.=($format=='h' || $format=='d') ? 'd ' : 'day ';       
            
       $timestr=$hours.$minutes.$seconds;
       $datestr=$days;
        
        if($format=="d" || $format=="D")
            return $datestr.$timestr;
        else        
            return $timestr;
    }
    
    function secsToTime($secs)
    {
        if($secs == 0)
        {
            return "-empty-";
        }
        else
        {
            $hours = round(floor(($secs/3600)),0); // just the whole hours
            $minutes = $secs % 3600;  //remainder
            $minutes = $minutes/60;
            
            if($minutes == 0)
            { // tidy up output
                $minutes = '00';
            }
                        
            return $hours.":".$minutes;
        }
    }     
    
    function isValid($date)
    {
       if(strstr($date, ':'))
       {
               if(strstr($date," "))
            {
                $t = explode(' ',$date);
                $time = $t[1];
                $date = explode($this->separator,$t[0]);
            }
            else
            {
                $time = $date;
                $date = "";
            }
       }
       else
           $date = explode($this->separator,$date);
    
       $time = (isset($time)) ? explode(':',$time) : "";
       
        if(isset($time) && $time!="")
        {
            $hour = $time[0];
            $mins = (isset($time[1])) ? $time[1] : 0;
            $seconds = (isset($time[2])) ? $time[2] : 0;
        }
        else
        {
            $time = 1;
            $hour = 0;
            $mins = 0;
            $seconds = 0;
        }
       
       if($date!="")
       {
           switch($this->dateFormat) 
            {
                case 'ansi': $year=$date[1]; $month=$date[2]; $day=$date[0]; break; // using YYYY-MM-DD                
                case 'it': $day=$date[1]; $month=$date[0]; $year=$date[2]; break;// using dd-mm-yyyy
                case 'br': $day=$date[1]; $month=$date[0]; $year=$date[2]; break;// using dd-mm-yyyy
                case 'std': $month=$date[0]; $day=$date[1]; $year=$date[2]; break; // using MM-DD-YYYY                                        
                case 'en': $month=$date[0]; $day=$date[1]; $year=$date[2]; break; // using MM-DD-YYYY                                                        
                default: $this->error='Date Format not recognized, must be "ansi", "it", "std" or "en" !! '; $this->exitOnError();
            }
        }
        
        switch($this->timeFormat)
        {
            case 'it':
            case 24:
            case '24':
                if($hour>=0 && $hour<=24 && $mins>=0 && $mins<=59 && $seconds>=0 && $seconds<=59)
                    $time=1;
                else
                    $time=0;
                break;
            case 'en':
            case '12':
            case 12:
                if($hour>=0 && $hour<=12 && $mins>=0 && $mins<=59 && $seconds>=0 && $seconds<=59)
                    $time=1;
                else
                    $time=0;
                break;
            default: $this->error='Time Format not recognized, must be "it" or "24", "en" or "12" !! '; $this->exitOnError();
        }       
        if($date!="")
            $date = checkdate($month,$day,$year);        
        else
            $date=true;
            
        if($date && $time)
            return true;
        elseif(!$date)
            return -1;
        elseif(!$time)
            return -2;
        elseif(!$date && !$time)
            return false;
    }  
      
 
    function getInfo($date,$what,$format="short")
    {
        $result = false;
        if($this->isValid($date))
        {
          if($format=="short" || $format=="s")
            $this->abbr=true;
          elseif($format=="long" || $format=="l")
            $this->abbr=false;
          switch(strtolower($what))
          {
            case 'monthname':
                                        $m=$this->atomDate($date,'m');
                                        $result = $this->NToMonth($m);
                                        break;
            case 'dayname':
                                        $time=$this->dateToTimestamp($date);
                                        $weekday = date("w",$time);
                                        $result = $this->NToDay($weekday);
                                        break;
            case 'dayofweek':
                                        $time=$this->dateToTimestamp($date);
                                        $weekday = date("w",$time);
                                        $result = $weekday+1;
                                        break;
            case 'dayofyear':
                                        $time=$this->dateToTimestamp($date);
                                        $result = date("z",$time)+1;
                                        break;
            case 'week':
                                        $time=$this->dateToTimestamp($date);
                                        $week = date("W",$time);
                                        $result = $week;
                                        break;
            
            case 'trimester':
                                        $m=$this->atomDate($date,'m');
                                        if($m>1 && $m<=3)
                                            $result = 1;
                                        elseif($m>3 && $m<=6)
                                            $result = 2;
                                        elseif($m>6 && $m<=9)
                                            $result = 3;
                                        elseif($m>9 && $m<=12)
                                            $result = 4;
                                        break;            
 
            default: $this->error='You must specify what kind of info need!';
          }
        }
        else
            $this->error='Date Format not recognized, must be "ansi", "it", "std", "br" or "en" !! '; 
    
        $this->exitOnError();
        return $result;
    }
 
    function InvertDate($date=null)
    {
        $date=str_replace('-',$this->separator,$date);
        $date=str_replace('.',$this->separator,$date);    
        list($obj1, $obj2, $obj3) = preg_split('/'.$this->separator.'/', $date, 3);
        $date = $obj3 . $this->separator . $obj2 . $this->separator . $obj1;
        if ( ( $date == ($this->separator . $this->separator) ) ) $date = 'Invalid Date!';
        return $date;
    }
 
    function CompareDate($dateA, $operator, $dateB) 
    {
        list($dayA,$monthA,$yearA) = explode("/",$dateA);
        list($dayB,$monthB,$yearB) = explode("/",$dateB);
        $date1 = $yearA.$monthA.$dayA;
        $date2 = $yearB.$monthB.$dayB;
        switch ($operator) {
            case '==':
                if ($date1 == $date2) return true; else return false; 
                break;
            case '=':
                if ($date1 == $date2) return true; else return false; 
                break;
            case '>':
                if ($date1 > $date2) return true; else return false; 
                break;
            case '<':
                if ($date1 < $date2) return true; else return false; 
                break;
            case '>=':
                if ($date1 >= $date2) return true; else return false; 
                break;
            case '<=':
                if ($date1 <= $date2) return true; else return false; 
                break;
            case '!=':
                if ( !($date1 == $date2) ) return true; else return false; 
                break;
            case '<>':
                if ( !($date1 == $date2) ) return true; else return false; 
                break;
        }
    }
 
    function GetDay($date)
    {
        list($day,$month,$year) = explode("/",$date);
        return $day;
    }
 
    function GetMonth($date)
    {
        list($day,$month,$year) = explode("/",$date);
        return $month;
    }
 
    function GetYear($date)
    {
        list($day,$month,$year) = explode("/",$date);
        return $year;
    }
    
    function Between($date1, $date, $date2)   
    {    
        $num1 = str_replace( "/", "", $this->InvertDate($date1) );
        $num  = str_replace( "/", "", $this->InvertDate($date) );      
        $num2 = str_replace( "/", "", $this->InvertDate($date2) );        
        if ( ($num1 <= $num) && ($num <=$num2) )     
            return TRUE;    
        else     
            return FALSE;   
    } 
 
    function makeTime()
    {
       $objArgs = func_get_args();
       $nCount = count($objArgs);
       if ($nCount < 7)
       {
           $objDate = getdate();
           if ($nCount < 1)
               $objArgs[] = $objDate["hours"];
           if ($nCount < 2)
               $objArgs[] = $objDate["minutes"];
           if ($nCount < 3)
               $objArgs[] = $objDate["seconds"];
           if ($nCount < 4)
               $objArgs[] = $objDate["mon"];
           if ($nCount < 5)
               $objArgs[] = $objDate["mday"];
           if ($nCount < 6)
               $objArgs[] = $objDate["year"];
           if ($nCount < 7)
               $objArgs[] = -1;
       }
       $nYear = $objArgs[5];
       $nOffset = 0;
       if ($nYear < 1970)
       {    
           if ($nYear < 1902)
               return 0;
           else if ($nYear < 1952)
           {
               $nOffset = -2650838400;
               $objArgs[5] += 84;
               // Apparently dates before 1942 were never DST
               if ($nYear < 1942)
                   $objArgs[6] = 0;
           }
           else
           {
               $nOffset = -883612800;
               $objArgs[5] += 28;
           }
       }
       unset($objArgs[6]);
       //die(var_export($objArgs, true));
 
    return call_user_func_array("mktime", $objArgs) + $nOffset;
    }
}
?>