Just use statcounter.com - sign up for a free account and everything is taken care of (with either weekly or monthly stat reports.)

Okies, let me see. Been awhile from the last PHP code for me, but maybe I can cook up something for you.

I checked your code through and made a bit simpler and shorter version for you as a function. If you save the function in a separated file with .php extension, you can include it into the file you need to use it in and then just call the function in where you want to draw the counter. I added additional return value for this function you can optionally use to draw how many times the counter has gone around. I commented the code quite heavily, so hopefully it helps to understand what's going on. But I add the code here and you can save it as a file.

<?php
// Draws the provided counter value with images.
// $counter is value of the counter. Defaults to 0.
// $digits is the number of digits wanted to be drawn. Defaults to 5.
function drawCounter($counter=0, $digits=5) {
    $tag_s = "<IMG src=";
    $path = "Pic/counter/";
    $file_ext = ".jpg";
    $tag_e = ">";

    // Need to add leading zeros if too few digits.
    // At the same time me convert the counter value into string.
    $format_str = "%0{$digits}d";
    $formatted_counter = sprintf($format_str, $counter);

    // We take as many last digits as is wanted by parameter.
    $shown_digits = substr($formatted_counter, -$digits);

    // Rest is saved in variable that can be used if wanted to print
    // how many times the counter has gone around.
    $gone_around = substr($formatted_counter, 0, -$digits);
    if (strlen($gone_around) == 0) $gone_around = 0;

    // Then we go through the digits one by one and add image tag
    // for every digit to draw the counter.
    for ($i = 0; $i < strlen($shown_digits); $i++) {
        echo "{$tag_s}\"{$path}{$shown_digits[$i]}{$file_ext}\"{$tag_e}";
    }

    // Finally the amount of how many times the counter has gone around
    // is returned to caller, so it can be printed if wanted.
    return $gone_around;
}
?>
 

So if we would have saved the above code in example file called "counter_draw.php", we could use the function by first including it in the pages' PHP, then calling the function in the location of code where we want the counter to be drawn. If you want to draw also the times the counter has gone around, you can use the function's return value for that.

Here's small example in PHP how to use it.

<?php
// Small example how to use the function.
// You can include the file of function where needed.
// Usually functions are included in the beginning of the file tho.

include_once("counter_draw.php");

// After to use the function to draw the counter in the calling location.
drawCounter(987654321,3);

// Optionally you can also use the returned value to draw how
//many times the counter has gone around.
//$arounds = drawCounter(987654321,3);
//echo "\nCounter has gone around $arounds times.";
?>

Additionally, the function does not have to be saved in it's own file actually. If you have some file you include in every page already, like example file called functions.php, you can just add this function's code in there and it would then be usable when that file is included.

Hopefully this helped and my explanations was clear enough. This is of course only one kind of solution and there might well be better ones. But for the task you're having, this does the trick.

Also if there's aomething you want to ask about this, feel free to do so.

--------------------------------------------
Have fun, but let others have too :)

dmn I just realized, nothing changes the value of $var... I could throw that in after echo and before calling lessdigit() function, just put somehting like $varreduc = $digit * $c then $var -= $varreduc

www.pyroamos.com - check it out ^^

I have now read your code through several times during these two - three days and I have not really understood what you've tried to do with it, haha. But what I do know is that neither one of the code's versions will work in their current state. The way you've tried to use the functions is a bit off, as well with the for-loop. With functions you can only return one value, but it can be example a table though. But because the return clause will stop running the function and return to the caller when the return clause is executed, you cannot really use several sequential return clauses to forward values.

The for-loops on the other hand uses three statements as a parameter: initializer, comparing and lastly part to be ran at the end of every loop. The way you have used the for-loop won't really work for it's purpose. While-loop might be easier to understand at first and does the trick as long as you remember to increase your iterator or a kind in your loop to prevent it to be stuck to infinite looping.

Also it's generally good idea to name the variables in a way where you see where they are meant for as well as comment the functions and their parameters with what they should do. This helps if other people need to read your code or you have to get back to it later.

Could you explain with more detail what your code should do and maybe I could give some suggestions how to do it. I might just make some number based version for you anyway and maybe explain a bit further that first example of mine that handles the counter value as string. The string based system is pretty much as short of a code as you can do though.

--------------------------------------------
Have fun, but let others have too :)

OK, took a while but I think I got what you were aiming for. There were some parts a bit backwards, like the $c >= $var, but generally your logic does work. I also added a check that prevents errors if the counter has zeros somewhere in it or the counter value is not yet large enough to reach all the digits. In those cases the added code prints zero as supposed.

I tried to keep the code as much the original as possible.This however ain't using the functions etc to it's benefit too well and so has the same code multiple times. Also lots of it is hardcoded, where example the number of digits in the counter has been decided in it. Additionally passing larger counter value than six digits breaks the result so it relies into additional coding to be functioning properly.

<?php
/* For testing purposes */
//$countervalue=103456;
//$countervalue=3456;

/* Setup Initial Variables */
$a = 999999;
$c = 100000;
$var = $countervalue;
$digit = 10;

/* Create function to reduce to next digit
   &$a is the biggest possible value for remaining counter. (alias)
   &$c is the lowest possible value for remaining counter. (alias)
   $digit is the number of the counter currently being handled. In
          other words the leftmost digit of the remaining counter value.
   * The alias (or reference) value means that any change to the
     variable effects also to the original variable that was
     passed to the function *
 */
function lessdigit(&$a, &$c, $digit) {
    $freevar = 10 - $digit;
    $freevar *= $c;
    $a += $freevar;
    $a -= 9;
    $a /= 10;
    $c /= 10;
}

/* Create function to echo current front digit
   &$a is the biggest possible value for remaining counter. (alias)
   &$c is the lowest possible value for remaining counter. (alias)
   &$var is the value for remaining counter. (alias)
   $digit is the number of the counter currently being handled. Starts
          from 10.
 */
function eachnum(&$a, &$c, &$var, $digit) {

    // if the given counter value is smaller than there
    // should be digits or there has been zero as the number,
    // we mark the number being a zero and reduce $a and $c to
    // next number of the counter.
    if ($c > $var) {
        lessdigit($a, $c, $digit);
        $digit = 0; //this not needed if the image for zero is 10.jpg
    } else {
        // assuming that we initially pass counter value smaller than
        // $a, we know to find out the next largest number of the counter by
        // looping through in descending order between $a and $c. The top
        // value of the gap ($a) is reduced until it is smaller than our
        // remaining counter.
        for (; $c <= $var && $a > 0 ; ) { // while-loop suits better
        //while ($c <= $var && $a > 0) {
            // when the remaining counter is bigger than the top value, we
            // have the largest number in the iterator. We can then remove the
            // digit from the remaining counter value and lower the gap to next
            // number after breaking the loop - this digit has already been handled.
            if ($var > $a) {
                $lessvar = $digit * $c;
                $var -= $lessvar;
                lessdigit($a, $c, $digit);
                break;
            } else {
                $a -= $c;
                $digit -= 1;
            }
        }
    }
    echo "<IMG src=\"Pic/counter/$digit.jpg\">";
}

/* Now to put counter on site */
echo "Pyro's counter:\n";
eachnum($a, $c, $var, $digit);
eachnum($a, $c, $var, $digit);
eachnum($a, $c, $var, $digit);
eachnum($a, $c, $var, $digit);
eachnum($a, $c, $var, $digit);
eachnum($a, $c, $var, $digit);

?>

--------------------------------------------
Have fun, but let others have too :)

Here comes the code for additional functionality for text area to limit it's length in client side. It basically adds functions to existing objects to do so. To give the length, there's multiple choices, but I explain those after the code.

<script type="text/javascript">

/* Author: Teemu Huumo, June 2009.
 *
 * Limits textarea into amount of characters that's defined
 * in the passed element object as maxlength.
 *
 * maxlength can be attribute either in DOM elemet or JS object.
 */
function limitText() {
    var warning = "You reached the maximum length for this field!";
    var maxlength = Number(this.getAttribute("maxlength"));

    if (!maxlength) {
        maxlength = Number(this.maxlength);
        if (!maxlength)
            return;
    }

    if (this.value.length > maxlength) {
        this.value = this.oldvalue;
        alert(warning);
    } else {
        this.oldvalue = this.value;
    }

    if (this.counter)
        this.counter.update(maxlength - this.value.length);
}

window.onload = function() {
    var form = document.updateform;
    form.body.maxlength = 10;
    //form.body.maxlength = <?php echo $commentLength ?>;
    //form.body.setAttribute("maxlength", "10");

    form.counter.update = function(count) {this.value = count;};

    form.body.counter = form.counter;
    form.body.onkeyup = limitText;

    form.body.onkeyup();
}

</script>

Then the example for the HTML form. I took this code from your page and made couple small changes for this functionality in mind. Mostly these changes are related to the counter box, but I also added tabindex attribute in the form fields to skip the counter.

<form method="post" name="updateform">
<TR><TD>Leave a new comment:</TD></TR>
<TR><TD>
  <TABLE border="0" cellspacing="0" bgcolor="#000000" width="100%">
    <TR><TD width="50%">Name: <input name="name" type="text" tabindex="1"></TD>
    <TD width="30%">Full Link: <input name="link" type="text" value="http://" tabindex="2"></TD>
    <TD width="20%">Characters Left: <input name="counter" type="text" readonly value="" size="3" onfocus="this.blur()" style="text-align:right;"></TD>
    </TR></TABLE>
</TD></TR>
<TR><TD><textarea name="body" tabindex="3" cols="110" rows="15"></textarea>
<BR><input name="btnUpdate" tabindex="4" type="submit" value="Submit comment"></TD></TR>
</form>

As you notice in the window.onload, there's several ways to give the maximum length for the text area.

    form.body.maxlength = 10;
    //form.body.maxlength = <?php echo $commentLength ?>;
    //form.body.setAttribute("maxlength", "10");

The form.body references to the text area by it's name attribute and if you're familiar with object oriented coding, form.body.maxlength = 10 assigns attribute/variable named maxlength to the form.body object (that is the text area). By doing it this way, it however does not show in the page source. This is to avoid non-standard code in the source. If you do not mind that, you can use the form.body.setAttribute("maxlength", "10"); that adds the attribute in the actual page source. This would be same as putting the attribute directly into your HTML in the way of <textarea name="body" maxlength="10" etc.>. Additionally there is example how to pass data from PHP to your JavaScrip, when you could use one variable for the comment length in PHP and pass it to the JavaScript and so make sure you have same values both in client and server side.

window.onload is an event that's ran when the whole page has been successfully loaded. JavaScript dealing with page structure should be initialized only after that. So let's go through the window.onload line by line:

window.onload = function() {
We assign a function to the window.onload event. This function will be executed when the page is fully loaded.

var form = document.updateform;
We get the form handling the comments in a variable to shorten our typing.

form.body.maxlength = <?php echo $commentLength ?>;
Then we bring maxlength from PHP and assign it as variable to the text area of the form. As in the above code, there's several ways to do this phase tho, but this one would be good.

form.counter.update = function(count) {this.value = count;};
We assign new function to our counter element. The update function will handle the updating the counter value. When we do it this way, we can basically add any kind of element to be our counter - we just need to add update function into it that handles the updating for that element type.

form.body.counter = form.counter;
In here we assign/link the counter element into our text area. After this we can reference the counter from the text area.

form.body.onkeyup = limitText;
Here we assign the previously declared and defined limitText function into onkeyup event of our text area. This practically means, that when you type into the text area and release a key, the limitText function will be executed.

form.body.onkeyup();
We are calling the onkeyup event once to initialize the counter value. Otherwise the counter field would be empty until user starts typing into the text area. We could of course give the initial value on the input field of the counter also by using the PHP variable to inject it into the HTML and remove this line.

The limitText function does the actual work. It basically checks after every key press that did the user exceed the maximum length. If she did not, the function copies the current text into oldvalue attribute of the text area. If the maximum length was exceeded, the previous version of text is copied over into the text area and warning is shown to the user.

If the maxlength is not given either in the source or JavaScript object level, then the text area works as normally. Also the counter element is optional - you do not have to assign a counter element for the limiting to actually work.

--------------------------------------------
Have fun, but let others have too :)