The following code shows the basic for it and get_pages() is the key from the core of WordPress to get to these results. This function provides the necessary result of using the parameter and the output via the parameter sort_order provides the sequence and identification of the first page, which is then either the first or last page in this structure.

// First post in structure
// simple, but usefull 
global $post;

$page_childs = get_pages( 'child_of=' . $post->post_parent . '&sort_order=ASC' );
$first_child = $page_childs[0];

if ( get_the_ID() === (int) $first_child->ID )
 echo 'First Child';

// Last post in structure
global $post;

$page_childs = get_pages( 'child_of=' . $post->post_parent . '&sort_order=DESC' );
$last_child  = $page_childs[0];

if ( get_the_ID() === (int) $last_child->ID )
 echo 'Last Child';

<?php
/*
 * Template Name: Blogpage
 */
load_template(TEMPLATEPATH . '/index.php' );
?>

Then write a new page, for example Blog, leave the content empty, select the template Blogpage and publish the page. After that, select "static page" in "Reading Options". That's all!

If you work with WordPress 3.0 already, you can use this code:

<?php
/*
 * Template Name: Blogpage
 */
locate_template( array( 'index.php' ), true );
?>

In our first example we send every hour a mail with the help of the WordPress function wp_mail(). FYI, this is just a possibility, please don't do it on your system!

As default, WordPress can handle 3 time keys, which you can call with the function wp_schedule_event.

// send automatic scheduled email
if ( ! wp_next_scheduled('my_task_hook') ) {
	wp_schedule_event( time(), 'hourly', 'my_task_hook' ); // hourly, daily and twicedaily
}

add_action( 'my_task_hook', 'my_task_function' );
function my_task_function() {

	wp_mail(
		'example@yoursite.com',
		'Automatic mail',
		'Hello, this is an automatically scheduled email from WordPress.'
	);
}

If you use the cron in a Plugin or theme, then don't forget to deactivate the cron if you don't need it anymore.

delete_action( 'my_task_hook', 'my_task_deactivate' );
// clean the scheduler
function my_task_deactivate() {

	wp_clear_scheduled_hook( 'my_task_hook' );
}

But not always are 3 time values enough. Luckily you can expand the control via a filter.

add_filter( 'cron_schedules', 'filter_cron_schedules' );
// add custom time to cron
function filter_cron_schedules( $param ) {
	return array( 'once_half_hour' => array(
		'interval' => 1800, // seconds
		'display'  => __( 'Once Half an Hour' )
	) );
}

fetch_feed() Since WordPress 2.8

With version 2.8 of WordPress, they add the class SimplePie into the core. SimplePie has always distinguished by a very rapid development and a stable user-friendly class. Before MagpieRSS has been used, which in many cases was not available and the development is rather slow. For some time SimplePie is no longer be maintained by the developer, which worried the developer community. But developers from the WordPress team took care of it and keep the class alive. More information can be find on the blog WP Dev Updates

Now the class is in the core of WordPress and is capable of generating RSS and ATOM feeds. It uses the cache of WordPress and can be controlled via a hook.

But first a small sample to read a feed with the class in WordPress.

<?php
include_once(ABSPATH . WPINC . '/feed.php');
$rss = fetch_feed('http://bueltge.de/feed/');
$rss_items = $rss->get_items( 0, $rss->get_item_quantity(5) );
if ( !$rss_items ) {
    echo 'no items';
} else {
    foreach ( $rss_items as $item ) {
        echo '<p><a href="' . $item->get_permalink() . '">' . $item->get_title() . '</a></p>';
    }
}
?>

The small sample reads my feed and returns the last 5 entries.

Essential is the function fetch_feed(). This function has a hook which can make influence on caching - wp_feed_cache_transient_lifetime.
The standard of the cache is set to 12 hours ( 43,200 ), which is not always the favorite setting for users. The value is operated on the method WP_Feed_Cache_Transient(), parameter $lifetime. Therefore, it is advisable to use the following little query, be it in the Plugin or in the functions.php of the theme.

add_filter( 'wp_feed_cache_transient_lifetime', create_function( '$a', 'return 1800;' ) );

In this example, I set the cache to 30 minutes. With the help of Conditional Tags you can control the whole of it so that the cache-hook is only activated when you click on a page (is_page()) or for example you are in the front end (!is_admin()) of the blog. Here you must simply use the opportunities and adapt to your own needs.

A small possibility I would like to point out more, available as of WordPress 2.9 (ticket 11117), to simplify debugging for developers. Thus, the cache is disabled in the environment, if the constant WP_DEBUG is set, which can be important now and then. Setting the constant is usually done in the wp-config.php of the installation, or as alternative in the Plugin.

function do_not_cache_feeds(&$feed) {
	$feed->enable_cache(false);
}

if ( defined('WP_DEBUG') && WP_DEBUG )
	add_action( 'wp_feed_options', 'do_not_cache_feeds' );

fetch_rss()

Another function is fetch_rss(), which was set with WordPress 2.8 on the suspense list. As an alternative, the above function is active. Current is fetch_rss() still available and is also supported. Therefore, for completeness, also the possibility to influence the cache.

Here an example to read feed and output the last 5 entries of the feed

<?php
include_once(ABSPATH . WPINC . '/rss.php');
$rss = fetch_rss('http://bueltge.de/feed/');
$rss_items = array_slice($rss->items, 0, 5);
if ( empty($rss_items) ) {
    echo 'no items';
} else {
    foreach ( $rss_items as $item ) {
        echo '<p><a href="' . $item['link'] . '">' . $item['title'] . '</a></p>';
    }
}
?>

Here, the function fetch_rss() is used for reading and the cache can be changed via the constants. This must defined either directly in wp-config.php where they will apply globally to all applications, or you need to integrate them into its own functions.

define('MAGPIE_CACHE_ON', 0); // deactivate cache
define('MAGPIE_CACHE_AGE', 60*60) // Cache 1 hour in seconds

Conclusion

Since WordPress decided not to support MagpieRSS any longer in the future, you should only deal with SimplePie and not with the second possibility.

With custom fields

In the first case, the solution using a custom field to be displayed, while the data must be maintained in this field to a key.

In version 1 you store the value of the authors to the key author link, so it's easy to understand the use of the fields. More information about this can be found in the Codex.

Version 1

The output of the key is handed over by using the template tag get_post_meta(). The function expects the Id of the post and the key value as a mandatory, or alternatively you can set if a value or arrays are allowed. Put on true and it returns only a string

/**
 * @param int $post_id Post ID.
 * @param string $key The meta key to retrieve.
 * @param bool $single Whether to return a single value.
 * @return mixed Will be an array if $single is false. Will be value of meta data field if $single
 *  is true.
 */
function get_post_meta($post_id, $key, $single = false)

<?php $key = 'authorlink'; ?>
<p>Photo of <a href="<?php echo get_post_meta($post->ID, $key, true);?>"></a>.</p>

The next step is basically no different, except that we now put the address in a value to another key, where the picture is. This requires the author to know address and save the URL.

In version 2, however, we go one step further and put a function into the functions.php, which takes care of it and then we can feed it with data. Again, this is just an example and needs in this version the key of the custom fields, the width and height of the images. These three sample values, we then write in the tag to output the image.

Version 2

/*Custom Field Images*/
function image_attachment($key, $width, $height) {
	global $post;

	$custom_field = get_post_meta($post->ID, $key, true);
	if ($custom_field) {
		echo '<img src="' . $custom_field . '" alt="Post Image" width="' . $width . '" height="' . $height . '" />';
	} else {
		return;
	}
}

The output of the template is determined by the above function as follows.

<?php
$image_key = 'image';
$myimage = get_post_meta($post->ID, $image_key, true);
if ($myimage) { ?>
	<div class="post-image">
		<?php image_attachment($image_key, 512, 200); ?>
	</div>
<?php } ?>

This really can make some beautiful things. Many theme authors would like to just have a picture to a post, which is directly taken at various points. Often this is achieved through the above solution. However, this requires that the authors need to know the custom fields and maintain them, so the key of the custom field and URL to the image.

Not very comfortable, so I want to show a solution, how you can get the image that was uploaded to the post, which can be found in the Gallery of the post.

WordPress own functions for images

One of the many options is wp_get_attachment_image(), which represents in my view, the simplest solution. Here is an example of what explains it in more detail.

At first we just get all pictures, not all the attachments of the posts that has been uploaded directly to the post. These images, we can directly display. The syntax must always be in the loop.

<?php
$attachments = get_children( array('post_parent' => get_the_ID(), 'post_type' => 'attachment', 'post_mime_type' => 'image') );
foreach ( $attachments as $attachment_id => $attachment ) {
	echo wp_get_attachment_image($attachment_id);
} ?>

The above example loads via the loop all images and display them. We don't take care about the actual size of the image, in default it will display the thumbnail. By setting post_mime_type = image, it only fetches images and not other attachments of the post.
The function of WordPress, which outputs the image with HTML, requieres the ID of the attachment, so you have to retrieve the ID to the post beforehand, we'll do with get_children().

A few words now to function wp_get_attachment_image() of WP to display the images. As already mentioned, there are several functions that all have a similar structure, and either give back other markup or allow other parameters. For a simple output, this function is best. It is also described in the Codex.

The function allows for 3 parameters:

/**
 * Get an HTML img element representing an image attachment
 *
 * @param int $attachment_id Image attachment ID.
 * @param string $size Optional, default is 'thumbnail'.
 * @param bool $icon Optional, default is false. Whether it is an icon.
 * @return string HTML img element or empty string on failure.
 */
function wp_get_attachment_image($attachment_id, $size = 'thumbnail', $icon = false)

You get the markup back for the img-Tag, like the following example.

<mg width="150" height="150" src="http://example.com/wp-content/uploads/2009/08/DSC00261-150x150.jpg"; class="attachment-thumbnail2 alt="Image Example" title="Example Image" />

The last of the three parameters is not really interesting in association with pictures, since it displays an icon. But the second parameter is there even more exciting, because this allows to set the size of the image. Here you can give either one of the preconfigured sizes, the sizes which you can configure in the settings of WordPress and are created when you upload using the media library. The following options are available.

• Default-Values: thumbnail, medium, large oder full
• Custom sizes via Array: array( width, height ) Example: array(100, 100)

If you pass your own values, then WordPress fetches the appropriate image in dependence of these values. So if you set, for example, 100x100 and the thumbnails are 150px150px, then these images are drawn. If you have your own array of 200x200, it will output the medium image because the thumbnail is too small.

<?php
$attachments = get_children( array('post_parent' => get_the_ID(), 'post_type' => 'attachment', 'post_mime_type' =>'image') );
foreach ( $attachments as $attachment_id => $attachment ) {
	echo wp_get_attachment_image( $attachment_id, array(200, 250) );
} ?>

Images with links

Now I will not always just the pictures, but also have the image with a link to the image in original size. In that case there is the function wp_get_attachment_link(). Here an example:

<?php
$attachments = get_children( array('post_parent' => get_the_ID(), 'post_type' => 'attachment', 'post_mime_type' =>'image') );
foreach ( $attachments as $attachment_id => $attachment ) {
	echo wp_get_attachment_link( $attachment_id, 'medium' );
} ?>

The HTML looks like this.

<a href="http://example.com/wp-content/uploads/2009/08/DSC00261.JPG" title="Example Image"><img src="http://example.com/wp-content/uploads/2009/08/DSC00261-150x150.jpg" class="attachment-thumbnail" alt="Image Example" title="Example Image" height="150" width="150"/></a>

Thus the image in the requested size is generated, and the link was set to the image in original size.

Determine size of the images

Sometimes you want to know in advance how big is the image. There is a function that returns the values as an array. This is an example of the output:

<?php
$attachments = get_children( array('post_parent' => get_the_ID(), 'post_type' => 'attachment', 'post_mime_type' => 'image') );
foreach ( $attachments as $attachment_id => $attachment ) {
	$src = wp_get_attachment_image_src( $attachment_id, 'full' );
	var_dump($src);
} ?>

This simple loop to output the values returns an array.

array
  0 => string 'http://example.com/wp-content/uploads/2009/08/DSC00261.JPG' (length=63)
  1 => int 1632
  2 => int 1224
  3 => boolean false

The order of the array is allocated as follows.

• $src[0] => url
• $src[1] => width
• $src[2] => height
• $src[3] => icon

Thus, it can react to the size, depending on requirements. Alternatively, you can work with the function image_get_intermediate_size($post_id, $size='thumbnail'), which returns some more values. A sample of the output for 'medium':

array
  'file' => string 'DSC00261-300x225.jpg' (length=20)
  'width' => string '300' (length=3)
  'height' => string '225' (length=3)
  'path' => string '2009/08/example-300x225.jpg' (length=28)
  'url' => string 'http://example.com/wp-content/uploads/2009/08/DSC00261-300x225.jpg' (length=71)

Further functions and possibilities

In this context, there are a few other functions that enable the work with attachments or pictures. I do not want to explain each of them, therefore I constribute a small loop for testing purposes. This covers many possibilities and are self explanatory, I think.

<?php
$attachments = get_children( array('post_parent' => get_the_ID(), 'post_type' => 'attachment', 'post_mime_type' => 'image') );
foreach ( $attachments as $attachment_id => $attachment ) {
	echo '<p>';
	echo 'wp_get_attachment_image: ' . wp_get_attachment_image( $attachment_id, array(200,250) ) . '<br />';
	echo 'wp_get_attachment_link: ' . wp_get_attachment_link( $attachment_id ) . '<br />';
	echo 'wp_get_attachment_url: ' . wp_get_attachment_url( $attachment_id ) . '<br />';
	echo 'wp_get_attachment_thumb_url: ' . wp_get_attachment_thumb_url( $attachment_id ) . '<br />';
	echo 'get_attachment_link: ' . get_attachment_link( $attachment_id ) . '<br />';
	$src = image_get_intermediate_size( $attachment_id, 'medium'	 );
	echo 'image_get_intermediate_size. '; var_dump($src); echo '<br />';
	$src = wp_get_attachment_image_src( $attachment_id, 'full', true );
	echo 'wp_get_attachment_image_src. '; var_dump($src); echo '<br />';
	echo 'Title of attachment: ' . apply_filters( 'the_title', $attachment->post_title ) . '<br />';
	echo 'Link to post: ' . get_permalink($image->post_parent) . '<br />';
	echo '<hr style="clear:both;" /></p>';
} ?>

Remember, the syntax must be in the loop of WordPress.

Only one picture to post

Now I have explained how to get the pictures but in general you will probably not need to post all the pictures, but you want just one picture. This occurs, for example, in magazine themes, where a small picture is displayed to make the post more interesting. Through these functions I can give the author of the respective post the control of that picture. Normally I do this in such a way that it explicitly output the first picture from the gallery to the post. Thus, the author can move the image in the gallery by dragging and dropping to the right place.

This is not an own function, you just have to feed get_children() accordingly. The output of the image, and other values to the image is again as described above.

In our first example we pick only the first image from the gallery.

<?php
$attachments = get_children( array(
				'post_parent'    => get_the_ID(),
				'post_type'      => 'attachment',
				'numberposts'    => 1, // show all -1
				'post_status'    => 'inherit',
				'post_mime_type' => 'image',
				'order'          => 'ASC',
				'orderby'        => 'menu_order ASC'
				) );
foreach ( $attachments as $attachment_id => $attachment ) {
	echo wp_get_attachment_image( $attachment_id );
} ?&>

Now the author of the contribution can always choose the first image of what he wants to use.

Alternatively we can turn the tables and get the last image from the Gallery .

<?php
$attachments = get_children( array(
				'post_parent'    => get_the_ID(),
				'post_type'      => 'attachment',
				'numberposts'    => 1, // show all -1
				'post_status'    => 'inherit',
				'post_mime_type' => 'image',
				'order'          => 'DESC',
				'orderby'        =>'menu_order ASC'
				) );
foreach ( $attachments as $attachment_id => $attachment ) {
	echo wp_get_attachment_image( $attachment_id );
} ?>

With the help of numberposts, we specify how many images are to be fetched. So we fetch in the following example the first 2 pics and after the last 2 pictures.

<?php
$attachments = get_children( array(
				'post_parent'    => get_the_ID(),
				'post_type'      => 'attachment',
				'numberposts'    => 1, // show all -1
				'post_status'    => 'inherit',
				'post_mime_type' => 'image',
				'order'          => 'ASC',
				'orderby'        => 'menu_order ASC'
				) );
foreach ( $attachments as $attachment_id => $attachment ) {
	echo wp_get_attachment_image( $attachment_id );
} ?>

Well, the last two pictures, starting with the last picture.

<?php
$attachments = get_children( array(
				'post_parent'    => get_the_ID(),
				'post_type'      => 'attachment',
				'numberposts'    => 2, // show all -1
				'post_status'    => 'inherit',
				'post_mime_type' => 'image',
				'order'          => 'DESC',
				'orderby'        => 'menu_order ASC'
				) );
foreach ( $attachments as $attachment_id => $attachment ) {
	echo wp_get_attachment_image( $attachment_id );
} ?>

Meta-Data of images

WordPress saves various meta data to the images. Now and then these are very useful, and why not simply use them.

First an example to get to the data. This we do with the function wp_get_attachment_metadata(). This function returns quite a lot of data and we can access the size of images, their path and also access the meta data.

<?php
$attachments = get_children( array(
				'post_parent'    => get_the_ID(),
				'post_type'      => 'attachment',
				'numberposts'    => 1, // show all -1
				'post_status'    => 'inherit',
				'post_mime_type' => 'image',
				'order'          => 'ASC',
				'orderby'        => 'menu_order ASC'
				) );
foreach ( $attachments as $attachment_id =>; $attachment ) {
	echo wp_get_attachment_image( $attachment_id );
	$imagemeta = wp_get_attachment_metadata( $attachment_id );
	var_dump($imagemeta); // list values in array

	$aperture          = $imagemeta['image_meta']['aperture'];
	$credit            = $imagemeta['image_meta']['credit'];
	$camera            = $imagemeta['image_meta']['camera'];
	$caption           = $imagemeta['image_meta']['caption'];
	$created_timestamp = $imagemeta['image_meta']['created_timestamp'];
	$copyright         = $imagemeta['image_meta']['copyright'];
	$focal_length      = $imagemeta['image_meta']['focal_length'];
	$iso               = $imagemeta['image_meta']['iso'];
	$shutter_speed     = $imagemeta['image_meta']['shutter_speed'];
	$title             = $imagemeta['image_meta']['title'];
} ?>

In the above code is the output value of a var_dump() in it. Thus we see very quickly which content in the array exists and where they can be accessed.
All values of the meta data, I have written in each variable, so that even less experienced users should understand it.

For a simple picture, of what would be created via cell phone camera, for example, the array looks like this.

array
  'width' => string '1632' (length=4)
  'height' => string '1224' (length=4)
  'hwstring_small' => string 'height='96' width='128'' (length=23)
  'file' => string '2009/08/DSC00261.JPG' (length=20)
  'sizes' =>
    array
      'thumbnail' =>
        array
          'file' => string 'DSC00261-150x150.jpg' (length=20)
          'width' => string '150' (length=3)
          'height' => string '150' (length=3)
      'medium' =>
        array
          'file' => string 'DSC00261-300x225.jpg' (length=20)
          'width' => string '300' (length=3)
          'height' => string '225' (length=3)
      'large' =>
        array
          'file' => string 'DSC00261-1024x768.jpg' (length=21)
          'width' => string '1024' (length=4)
          'height' => string '768' (length=3)
  'image_meta' =>
    array
      'aperture' => string '2.8' (length=3)
      'credit' => string '' (length=0)
      'camera' => string 'W800i' (length=5)
      'caption' => string '' (length=0)
      'created_timestamp' => string '1184253323' (length=10)
      'copyright' => string '' (length=0)
      'focal_length' => string '0' (length=1)
      'iso' => string '100' (length=3)
      'shutter_speed' => string '0.0166666666667' (length=15)
      'title' => string '' (length=0)

Alternative in WordPress 2.9

Using WordPress version 2.9, there is a template tag just for this request, so it is easier and more understandable. You just use the the_post_image() and you can set the size. Default is thumbnail, it is possible thumbnail, medium, large or full.

the_post_image(); // without parameter -> Thumbnail
the_post_image('thumbnail'); // Thumbnail
the_post_image('medium'); // Medium resolution - use full,

As a small alternative is still get_the_post_image() available, whereas the function doesn't have echo, and can optionally have the ID of the post.
get_the_post_image( $size = 'thumbnail', $post_id = NULL )

Conclusion

WordPress offers a lot of different functions to access attachments, whether pictures or other files. Also a part of meta-data is stored, which can be used. Many approaches can be found in the code, primarily in the wp-includes/media.php. Perhaps I could point out some solutions which in my view a better alternative than the use of custom fields, or even scanning the content.

You can disable the unneccessary Widgets in your functions.php of your theme with a small function. The following syntax will switch off all the standard widgets. It should therefore be adjusted depending on your requirements:

// unregister all default WP Widgets
function unregister_default_wp_widgets() {

	unregister_widget('WP_Widget_Pages');

	unregister_widget('WP_Widget_Calendar');

	unregister_widget('WP_Widget_Archives');

	unregister_widget('WP_Widget_Links');

	unregister_widget('WP_Widget_Meta');

	unregister_widget('WP_Widget_Search');

	unregister_widget('WP_Widget_Text');

	unregister_widget('WP_Widget_Categories');

	unregister_widget('WP_Widget_Recent_Posts');

	unregister_widget('WP_Widget_Recent_Comments');

	unregister_widget('WP_Widget_RSS');

	unregister_widget('WP_Widget_Tag_Cloud');
}

add_action('widgets_init', 'unregister_default_wp_widgets', 1);

The function unregister_widget() needs as parameters the class, therefore the code is working since version 2.8 only. In prior versions, Widgets were supported differently.

How to create your own Widgets since WordPress Version 2.8 is explained in Build A WordPress 2.8 Widget With The New Widget API.

All functions of cache are in the Codex by WordPress listed, so a look at the Codex is worthwhile if you deal with the syntax.

The first cache solution came with WordPress 2.3 and was file based. The cache was optional and had some parameters to configure.
You were able to activate via following constant: define ( 'ENABLE_CACHE', true);

The biggest improvement happened in version 2.6, in which the cache has changed to an object-oriented solution. Therefore the opportunities for cache usage are lying rather on the server and not explicitly on WordPress. This was mainly realized in order to maximize the resources of the server and not to be handed over to WordPress. With this introduction, the cache of WordPress has no longer explicitly be activated, it is always active. Therefore, it is important that the server has a certain minimum amount of RAM available, WordPress requires 32 MByte - but that is not always the case, for example, when updating the core, it contains a call which defines the RAM to 128MByte, which in many cases is not available and therefore the update does not work.
But this is not the topic of this post today, because I want to explain how to use the cache in your own extensions. So back to the syntax and I just start with the key functions to realize a small example.

All functions can be found in wp-includes/cache.php, or alternatively in Codex.

To reset the cache, insofar there is no data for this key, you can use the following function.

/**
 * @param int|string $key The cache ID to use for retrieval later
 * @param mixed $data The data to add to the cache store
 * @param string $flag The group to add the cache to
 * @param int $expire When the cache data should be expired
 */
wp_cache_add($key, $data, $flag = '', $expire = 0)

To delete cache data for a key, here is the opposite.

/**
 * @param int|string $id What the contents in the cache are called
 * @param string $flag Where the cache contents are grouped
 * @return bool True on successful removal, false on failure
 */
wp_cache_delete($id, $flag = '')

Fetching data for a key is done by using:

/**
 * @param int|string $id What the contents in the cache are called
 * @param string $flag Where the cache contents are grouped
 * @return bool|mixed False on failure to retrieve contents or the cache
 */
wp_cache_get($id, $flag = '')

Should within the cache to a key the content to be replaced, then the following function will work.

/**
 * @param int|string $id What to call the contents in the cache
 * @param mixed $data The contents to store in the cache
 * @param string $flag Where to group the cache contents
 * @param int $expire When to expire the cache contents
 * @return bool False if cache ID and group already exists, true on success
 */
wp_cache_replace($key, $data, $flag = '', $expire = 0)

But now a small example, which caches the feed. The feed gets loaded by fetch_rss(), a function of WordPress which is available since version 1.5.

$mycache = wp_cache_get( 'mycache' ); // fetch data from cache to the key "mycache"
if ($mycache == false) { // if no data, then
	$mycache = fetch_rss("http://mycache.com/feed/"); // parse feed
	wp_cache_set( 'mycache', $mycache ); // save feed content to key "mycache"
}
var_dump( $mycache ); // display content

FYI: You get an insight into the cache of WordPress easily via the variable $wp_object_cache or using the Plugin Debug Objects or WP Cache Inspect; whereas Debug Objects explicitly has been made for this and should be used in development environments only.

Nevertheless, there is a possibility and with the help of two hooks, the sender can be changed. I created a small Plugin, where you can easy and simple adjust the sender name and sender email.
-
The Plugin is available in the following source code and has no options for the backend and doesn't leave any data in the database. Anyone who wants can simply extend the Plugin.

<?php
/**
 * @package WP Mail From
 * @author Frank Bültge
 * @version 0.1
 */

/*
Plugin Name: WP Mail From
Plugin URI: http://bueltge.de/
Description: Change the default address that WordPress sends it’s email from.
Version: 0.1
Author: Frank Bültge
Author URI: http://bueltge.de/
Last Change: 11.08.2009 08:41:06
*/

if ( !function_exists('add_action') ) {
	header('Status: 403 Forbidden');
	header('HTTP/1.1 403 Forbidden');
	exit();
}

if ( !class_exists('wp_mail_from') ) {
	class wp_mail_from {

		function wp_mail_from() {
			add_filter( 'wp_mail_from', array(&$this, 'fb_mail_from') );
			add_filter( 'wp_mail_from_name', array(&$this, 'fb_mail_from_name') );
		}

		// new name
		function fb_mail_from_name() {
			$name = 'My Blog is my Blog';
			// alternative the name of the blog
			// $name = get_option('blogname');
			$name = esc_attr($name);
			return $name;
		}

		// new email-adress
		function fb_mail_from() {
			$email = 'info@example.com';
			$email = is_email($email);
			return $email;
		}

	}

	$wp_mail_from = new wp_mail_from();
}
?>

The values for name and email have to be maintain in each of the associated function. After that, the two values are getting examined, but is not necessarily needed.

As a note: the function esc_attr() is only since version 2.8 available and replaces the function attribute_escape(). Should the solution be used in an earlier version, then you have to change the function.

For suggestions and improvements, I am grateful, as always. You can use this Plugin to improve WordPress a bit and the user is not surprised about the sender "WordPress".

function my_update_notice() {
	$info = __( 'ATTENTION! Plugin was modified.', MY_TEXTDOMAIN );
	echo '<span class="spam">' . strip_tags( $info, '<br><a><b><i><span>' ) . '</span>';
}

if ( is_admin() )
	add_action( 'in_plugin_update_message-' . plugin_basename(__FILE__), 'my_update_notice' );

The work of every author is different and the dashboard is the center of information. Therefore we have decided to supplement a widget in the Dashboard, which shows the last five drafts of all authors. I enhanced the existing Plugin Draft Feed.

• It provides a feed of all drafts
• And the last 5 drafts of all authors in the Dashboard.

Everybody who needs something like this, can download this Plugin from my German Blog. It doesn't have any options and doesn't exist in SVN of WordPress - if you want you can use and expand it or leave a comment if you have a question. Enjoy!