Beispiel Screenshots

Die Funktion

Die folgende Funktion stellt den Kern da und kann als Plugin oder im Theme, in der functions.php abgelegt werden. Der Code-Abschnitt im Anschluss stellt die Möglichkeit der Anpassung via Hook da, so dass man auf die Parameter zugreifen kann.

function fb_paging_bar( $args = array() ) {
	
	$defaults = array(
		'range'           => 4,
		'custom_query'    => FALSE,
		'previous_string' => __( '«««', FB_GREYFOTO_TEXTDOMAIN ),
		'next_string'     => __( '»»»', FB_GREYFOTO_TEXTDOMAIN ),
		'view_fp'         => TRUE,
		'view_lp'         => TRUE,
		'before_output'   => '<div class="postlink">',
		'after_output'    => '</div>'
	);
	
	$args = wp_parse_args( 
		$args, 
		apply_filters( 'fb_paging_bar_defaults', $defaults )
	);
	
	$args['range'] = (int) $args['range'] - 1;
	if ( !$args['custom_query'] )
		$args['custom_query'] = @$GLOBALS['wp_query'];
	$count = (int) $args['custom_query']->max_num_pages;
	$page  = intval( get_query_var( 'paged' ) );
	$ceil  = ceil( $args['range'] / 2 );
	
	if ( $count <= 1 )
		return FALSE;
	
	if ( !$page )
		$page = 1;
	
	if ( $count > $args['range'] ) {
		if ( $page <= $args['range'] ) {
			$min = 1;
			$max = $args['range'] + 1;
		} elseif ( $page >= ($count - $ceil) ) {
			$min = $count - $args['range'];
			$max = $count;
		} elseif ( $page >= $args['range'] && $page < ($count - $ceil) ) {
			$min = $page - $ceil;
			$max = $page + $ceil;
		}
	} else {
		$min = 1;
		$max = $count;
	}
	
	$echo = '';
	$previous = intval($page) - 1;
	$previous = esc_attr( get_pagenum_link($previous) );
	if ( $previous && (1 != $page) )
		$echo .= '<a href="' . $previous . '" title="' . __( 'previous', FB_GREYFOTO_TEXTDOMAIN) . '">' . $args['previous_string'] . '</a>';
	$firstpage = esc_attr( get_pagenum_link(1) );
	
	if ( $args['view_fp'] && $firstpage && (1 != $page) )
		$echo .= '<a href="' . $firstpage . '">' . __( 'First', FB_GREYFOTO_TEXTDOMAIN ) . '</a>';
	
	if ( !empty($min) && !empty($max) ) {
		for( $i = $min; $i <= $max; $i++ ) {
			if ($page == $i) {
				$echo .= '<span class="active">' . str_pad( (int)$i, 2, '0', STR_PAD_LEFT ) . '</span>';
			} else {
				$echo .= sprintf( '<a href="%s">%002d</a>', esc_attr( get_pagenum_link($i) ), $i );
			}
		}
	}
	
	if ($args['view_lp']) {
		$lastpage = esc_attr( get_pagenum_link($count) );
		if ( $lastpage && ($count != $page) ) {
			$count = str_pad( (int)$count, 2, '0', STR_PAD_LEFT );
			$echo .= '<a href="' . $lastpage . '">' . __( 'Last', FB_GREYFOTO_TEXTDOMAIN ) . '(' . $count . ')' . '</a>';
		}
	}
	
	$next = intval($page) + 1;
	$next = esc_attr( get_pagenum_link($next) );
	if ($next && ($count != $page) )
		$echo .= '<a href="' . $next . '" title="' . __( 'next', FB_GREYFOTO_TEXTDOMAIN) . '">' . $args['next_string'] . '</a>';
	
	if ( isset($echo) )
		echo $args['before_output'] . $echo . $args['after_output'];
}

Im Template, wo die Pagination genutzt werden soll, wird einfach die Funktion aufgerufen:

<?php if ( function_exists('fb_paging_bar') ) fb_paging_bar(); ?>

Beispiel für Anpassungen

Für eigene Argumente steht ein Hook bereit und mittels diesem Hook kann jeder Parameter des Arrays $args angepasst werden.

function change_fb_paging_bar_defaults($args) {
	
	$args['previous_string'] = ''; // empty string
	$args['next_string'] = '';
	
	return $args;
}
add_filter('fb_paging_bar_defaults', 'change_fb_paging_bar_defaults');

Viel Freude damit und für Hinweise, Ideen und Verbesserungen bin ich wie immer dankbar.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

/**
 * return post thumbnail inside style in head
 */
if ( !function_exists('fb_background_image') ) {
	
	function fb_background_image() {
		// only frontend
		if ( is_feed() || is_trackback() ) {
			return;
		}
		
		// default image, when no set an post thumbnail
		if ( !has_post_thumbnail($GLOBALS['post']->ID) ) {
			$style = '<style type="text/css">.banner {background-image:url(\'' . get_bloginfo('stylesheet_directory') . '/images/banner.jpg\');} </style>' . "\n\n";
		} else {
			// get post thumbnail
			$image = wp_get_attachment_image_src(
				get_post_thumbnail_id($GLOBALS['post']->ID),
				'banner' // size for image; defined via add_image_size
			);
			
			$style = sprintf(
				'<style type="text/css">.banner {background-image:url(\'%s\');}</style>',
				esc_attr($image[0]),
				"\n\n"
			);
		}
		if ($style)
			echo $style;
	}
	
	// add functions
	add_action( 'wp_head', 'fb_background_image' );
	add_theme_support( 'post-thumbnails' );
	add_image_size( 'banner', 980, 350, true );
	
}

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

$categories = get_terms( 'link_category' );
if ( $categories )
    echo $categories[0]->count;

Die Gesamtanzahl ein Linkkategorie geht ebenfalls, dazu steht der folgende Code als Beispiel. Hier muss die ID der Linkkategorie mitgegeben werden, im Beispiel ist dies die 2.

$term = get_term( 2, 'link_category' ); // ID of link category
if ( $term ) {
	echo __( 'Link category', 'textdoamin' ) . ' ' . $term->name . __( ', number of links', 'textdomain' ) . ' '. $term->count;
}

Die Snippets verwendet ihr im Template eures Themes oder erstellt eine Funktion, die euch die Ausgabe steuert.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Der grobe Ablauf

• Kopie der page.php in guestbook-page.php erstellen
• Inhaltlich einige Veränderungen vornehmen
• Kopie der comments.php in guestbook.php erstellen
• Inhaltlich den Aufbau ändern
• Templates in den Theme-Ordner kopieren oder Child-Theme erstellen
• Seite im Backend von WordPress erstellen und Template wählen

Die guestbook-page.php

Im neuen Template sind nur wenige Veränderungen vorzunehmen. Im ersten Schritt braucht das Template einen Namen, damit es im backend von WordPress für statische Seiten erkannt wird. Dies geschieht in den Kommentaren am Anfang der Datei.

<?php
/**
 * Template Name: Guestbook
 *
 * A custom page for guestbook function.
 *
 * The "Template Name:" bit above allows this to be selectable
 * from a dropdown menu on the edit page screen.
 *
 * @package WordPress
 * @subpackage Twenty_Ten
 * @since Twenty Ten 1.0
 */

Im Anschluss wird im Aufruf der Kommentarfunktion noch der Name der Datei mitgegeben, der sich um die Darstellung der Gästebucheinträge kümmert und das Formular zum Eintragen enthält. Im Grunde könnte man dies auch weglassen, aber dann ist inhaltlich alles auf Kommentare abgeglichen und das Formular für Neueinträge befindet sich am Ende, also nach den Einträgen. Da es bei Gästebüchern aber meist anders ist, legen wir das Formular vor die Liste der Einträge und ändern die Texte.
Daher muss also die Datei an die Funktion übergeben werden.

<?php comments_template( '/guestbook.php' ); ?>

Das Beispieltemplate mit den Änderungen in der kompletten Sicht:

<?php
/**
 * Template Name: Guestbook
 *
 * A custom page for guestbook function.
 *
 * The "Template Name:" bit above allows this to be selectable
 * from a dropdown menu on the edit page screen.
 *
 * @package WordPress
 * @subpackage Twenty_Ten
 * @since Twenty Ten 1.0
 */

get_header(); ?>


		<div id="container">
			<div id="content" role="main">

<?php if ( have_posts() ) while ( have_posts() ) : the_post(); ?>

				<div id="post-<?php the_ID(); ?>" <?php post_class(); ?>>
					<?php if ( is_front_page() ) { ?>
						<h2 class="entry-title"><?php the_title(); ?></h2>
					<?php } else { ?>
						<h1 class="entry-title"><?php the_title(); ?></h1>
					<?php } ?>

					<div class="entry-content">
						<?php the_content(); ?>
						<?php wp_link_pages( array( 'before' => '<div class="page-link">' . __( 'Pages:', 'twentyten' ), 'after' => '</div>' ) ); ?>
						<?php edit_post_link( __( 'Edit', 'twentyten' ), '<span class="edit-link">', '</span>' ); ?>
					</div><!-- .entry-content -->
				</div><!-- #post-## -->

				<?php comments_template( '/guestbook.php' ); ?>

<?php endwhile; ?>

			</div><!-- #content -->
		</div><!-- #container -->

<?php get_sidebar(); ?>
<?php get_footer(); ?>

Die guestbook-page.php

Auch hier gibt es wenig Verändeurngen. Im ersten Schritt holen wir das Formular vor die Ausgabe der Gästbuch-Einträge. Der folgende Code ist das Original und ruft das Formualr seit WordPress 3.0 auf.

<?php comment_form(); ?>

Diesen Code setzen wir nun vor die Ausgabe der Einträge, also vor

<?php
	// You can start editing here -- including this comment!
?>

<?php if ( have_comments() ) : ?>

Um nun aber die Felder richtig anzupassen und entsprechende Texte mitzugeben, müssen einige Paramter der Funktion übergeben werden. Die Funktion comment_form() lässt sehr viele Möglichkeiten zu und alle Parameter werden in einem Array übergeben. Im Codex findet man die einzelnen Felder erläutert.
In meinem Fall sieht der Abschnitt dann wie folgt aus.

<?php
// You can start editing here -- including this comment!

// the form
$attr = array(
					'comment_field'        => '<p class="comment-form-comment"><label for="comment">' . _x( 'Guestbook entry', 'noun', 'twentyten' ) . '</label><textarea id="comment" name="comment" cols="45" rows="8" aria-required="true"></textarea></p>',
					'label_submit'         => __( 'Post Entry', 'twentyten' ),
					'title_reply'          => __( 'Leave a Entry', 'twentyten' ),
					'title_reply_to'       => __( 'Leave a Entry to %s', 'twentyten' ),
					'cancel_reply_link'    => __( 'Cancel reply', 'twentyten' ),
				);
comment_form( $attr );

// list of guestbook entries
if ( have_comments() ) : ?>

Das Beispieltemplate mit den Änderungen in der kompletten Sicht:

<?php
/**
 * The template for displaying Comments.
 *
 * The area of the page that contains both current comments
 * and the comment form.  The actual display of comments is
 * handled by a callback to twentyten_comment which is
 * located in the functions.php file.
 *
 * @package WordPress
 * @subpackage Twenty_Ten
 * @since Twenty Ten 1.0
 */
?>

			<div id="comments">
<?php if ( post_password_required() ) : ?>
				<p class="nopassword"><?php _e( 'This post is password protected. Enter the password to view any comments.', 'twentyten' ); ?></p>
			</div><!-- #comments -->
<?php
		/* Stop the rest of comments.php from being processed,
		 * but don't kill the script entirely -- we still have
		 * to fully load the template.
		 */
		return;
	endif;
?>

<?php
// You can start editing here -- including this comment!

// the form
$attr = array(
					'comment_field'        => '<p class="comment-form-comment"><label for="comment">' . _x( 'Guestbook entry', 'noun', 'twentyten' ) . '</label><textarea id="comment" name="comment" cols="45" rows="8" aria-required="true"></textarea></p>',
					'label_submit'         => __( 'Post Entry', 'twentyten' ),
					'title_reply'          => __( 'Leave a Entry', 'twentyten' ),
					'title_reply_to'       => __( 'Leave a Entry to %s', 'twentyten' ),
					'cancel_reply_link'    => __( 'Cancel reply', 'twentyten' ),
				);
comment_form( $attr );

// list of guestbook entries
if ( have_comments() ) : ?>
			<h3 id="comments-title"><?php
			printf( _n( 'One Entry in %2$s', '%1$s Entries in %2$s', get_comments_number(), 'twentyten' ),
			number_format_i18n( get_comments_number() ), '<em>' . get_the_title() . '</em>' );
			?></h3>

<?php if ( get_comment_pages_count() > 1 && get_option( 'page_comments' ) ) : // Are there comments to navigate through? ?>
			<div class="navigation">
				<div class="nav-previous"><?php previous_comments_link( __( '<span class="meta-nav">&larr;</span> Older Entries', 'twentyten' ) ); ?></div>
				<div class="nav-next"><?php next_comments_link( __( 'Newer Entries <span class="meta-nav">&rarr;</span>', 'twentyten' ) ); ?></div>
			</div> <!-- .navigation -->
<?php endif; // check for comment navigation ?>

			<ol class="commentlist">
				<?php
					/* Loop through and list the comments. Tell wp_list_comments()
					 * to use twentyten_comment() to format the comments.
					 * If you want to overload this in a child theme then you can
					 * define twentyten_comment() and that will be used instead.
					 * See twentyten_comment() in twentyten/functions.php for more.
                     * use param reverse_top_level to reverse the order of the guestbook-entries
					 */
					wp_list_comments( array( 'reverse_top_level' => TRUE, 'callback' => 'twentyten_comment' ) );
				?>
			</ol>

<?php if ( get_comment_pages_count() > 1 && get_option( 'page_comments' ) ) : // Are there comments to navigate through? ?>
			<div class="navigation">
				<div class="nav-previous"><?php previous_comments_link( __( '<span class="meta-nav">&larr;</span> Older Entries', 'twentyten' ) ); ?></div>
				<div class="nav-next"><?php next_comments_link( __( 'Newer Entries <span class="meta-nav">&rarr;</span>', 'twentyten' ) ); ?></div>
			</div><!-- .navigation -->
<?php endif; // check for comment navigation ?>

<?php else : // or, if we don't have comments:

	/* If there are no comments and comments are closed,
	 * let's leave a little note, shall we?
	 */
	if ( ! comments_open() ) :
?>
	<p class="nocomments"><?php _e( 'Guestbook are closed.', 'twentyten' ); ?></p>
<?php endif; // end ! comments_open() ?>

<?php endif; // end have_comments() ?>

</div><!-- #comments -->

Die Sprache

Nun müssen die Felder übersetzt werden. Dazu sollte ein Werkzeug genutzt werden - meine Empfehlung das Plugin für WordPress Localization. Damit wird nun die Sprachdatei des TwentyTen Theme neu erstellt und die neuen Sprachschlüssel erkannt, welche dann übersetzt werden können.

Hinweis: Damit wird ein Teil dem Update entnommen - die Sprachdatei. Daher ist es sauberer, wenn man ein Child-Theme anlegt, dort die beiden Templates ablegt und die Sprachdatei dort erzeugt. Hinweise, wie man ein Child-Theme erzeugt, findet ihr im Artikel WordPress Child Themes verstehen. Trotzdem habe ich mal als Beispiel als Child Theme erzeugt. Es enthält die Sprachdateien und die Templates für das Gästebuch, sowie die notwendigen Dateien und Strings um ein Child Theme für diese Funktion zu erzeugen. Damit sollte es einfach möglich sein ein Child Theme mit der Möglichkeit der Erweiterung und einem Gästebuch zu erstellen. Der Download ist in den folgenden Zeilen zu finden.

Abschluss

Nun gilt es die beiden php-Templates und die Sprachdatei in das Theme zu kopieren und eine neue Seite über das Backend zu erstellen. Vergebt einen Namen für das Gästebuch, hinterlasst eventuell einen einführenden Text für die Gäste und wählt das neue Template „Guestbook“ in der Meta-Box dieser Seite.
Wenn alles ok ist, dann steht nun euer Gästebuch und kann genutzt werden. Keine Plugins, keine unnötigen Ressourcen oder Tabellen in der Datenbank. Aber, abhängig von Theme, was auch richtig ist, denn es handelt sich im Themen zum Design - der Inhalt steht in der Datenbank.

Für alle, die sich das Kopieren des Code ersparen wollen, lege ich die beiden Dateien als zip ab, so dass man sie downloaden und nutzen kann.

Download:

Ist die Arbeit nicht 1 Euro wert?
Jede Spende wird dankbar angenommen und ermöglicht das weitere Arbeiten an freier Software.
Möchtest du mehr oder anders spenden, so besuche meine Wunschliste.

• Template-Dateien im Download als zip-Datei: guestbook-twentyten.zip - 2 kByte
• Child Theme inkl. Sprachdateien Deutsch etc. im Download als zip-Datei: guestbook-tutorial.zip - 28 kByte

Viel Freude damit und viel Erfolg beim Verstehen des Code und meiner kurzen Anleitung. Für Hinweise, Verbesserungen und Fehler steht die Kommentarfunktion zur Verfügung - vielen Dank.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Die Funktion der Child Themes kann im Grunde bei jedem Theme angewandt werden und die neuen Funktionen erleichtern den Zugriff und das Erstellen einen Child Themes. Im Vorfeld gab es auch Möglichkeiten ein Theme zu verändern ohne die eigentlichen Dateien des Themes stark zu verändern. Mit Hilfe der Unterstützung von Child Themes ist dies nun aber komplett unabhängig und so kann man ein Theme nutzen, kann ohne Problem updaten, und trotzdem eigene Ideen realisieren.

In einigen Beiträgen des Netzes wurde die Child Themes schon angesprochen und ich habe bisher nur Artikel gefunden, die die Aktivierung und Änderung des Stylesheets ansprechen. Daher möchte ich dazu nur kurz eingehen, dass ist im Grunde auch recht einfach und dann die verschiedenen Möglichkeiten im Bezug der Template-Dateien aufzeigen.

Vorteile der Idee Child Theme

Mehr oder weniger versucht jeder Administrator einer WordPress Installation etwas Individualismus zu leben. Dabei gehen nicht alle den Weg eines eigens erstellen Themes. Nicht selten wird ein freies oder kommerzielles Theme genutzt und dann an die eigenen Bedürfnisse angepasst. Dabei haben diverse Themes unterschiedliche Optionen, die aber trotzdem nur selten für das Anpassen ausreichen. Will man die einzelnen Darstellungen anpassen, beispielsweise die Sicht einer Kategorie, führt dies schnell zu sehr starken Veränderungen des Themes. Egal wie umfangreich, ein Update eines Themes ist nicht mehr ohne Probleme realisierbar. Hier kommen die Child Themes ins Spiel.

Mit einem Child Theme kann ein Theme angepasst werden oder man kann ein Theme als "Framework" nutzen und dabei komplett eigene Ideen umsetzen. Egal wie umfangreich, das eigentliche Theme bleibt unangetastet und kann ein Update erfahren.

Nachteile der Verwendung Child Theme

Wie so oft, wo Vorteile sind, sind auch Nachteile. Nicht selten sind die "Framework" Themes sehr umfangreich und bringen sehr viele Funktionen mit, die man als Laie nicht mehr überschauen kann und das Anpassen kann viel Mühe und Zeit kosten. Hier können auch die Child Themes nicht helfen.
Einen großen Nachteile sehe ich in der Performance, muss WordPress doch einnen Schritt weiter gehen und sich in zwei Bereichen nach den Templates umsehen und entsprechend ziehen.
Im weiteren werden in der Regel die Stylesheets, wenn man auf sie aufbaut, via @-Regel eingebunden, die Nachteile in der Performance hat.

In allen negativen Punkten kommt es auf Können und Wissen des Entwicklers an, also wie man das Theme bzw. Child Theme erstellt. Damit kann man die Punkte entkräften. Wichtig: die neue Funktion ist kein Freibrief, sie sollte genauso überlegt eingesetzt werden. Aber sie sorgt dafür, dass man sein erstandenes Theme nicht anfassen muss und trotzdem sehr überschaubar Anpassungen vornehmen kann.

Child Theme anlegen

Genug der Vorrede, die man sicher erweitern und diskutieren kann. Am Beispiel Theme TwentyTen soll nun eine angepasstes Theme entstehen - ich nenne es TwentyTenJump

Im ersten Schritt wird ein neuer Ordner angelegt, in dem wir alle Template-Dateien, Bilder, Scripte und Stylesheets ablegen - was man im Grunde für das Child Theme benötigt. In diesem Beispiel ist das der Ordner twentytenjump. Um ein Child Theme zu erzeugen und WordPress dieses erkennbar zu machen bedarf es lediglich der style.css innerhalb der neuen Ordners mit diversen Strings in einem Kommentar.

Innerhalb der style.css sieht es wie folgt aus.

@charset "UTF-8";

/**
 * Theme Name:     TwentyTenJump
 * Theme URI:      http://bueltge.de/?p=1192
 * Description:    Child theme for the Twenty Ten theme. Realized for a small tutorial to child themes in WordPress.
 * Author:         Frank Bültge
 * Author URI:     http://bueltge.de/
 * Template:       twentyten
 * Version:        0.1.0
 */

@import url('../twentyten/style.css');

Entscheidend sind die Schlüssel Theme Name und Template. Der Schlüssel Template verweist auf den Ordner-Namen des Theme, welches als Basis gezogen wird - in diesem Beispiel das Theme Twentyten.

Folgenden Aufbau habe ich nun innerhalb der Installation von WordPress.

• wp-content
  • themes
    • twentyten

    (das Basis-Theme, inkl. aller Template-Dateien)

    • style.css
    • index.php
    • ...
    • twentytenjump
      • style.css (muss diese Namenskonvetion erfüllen: style.css)

Damit sind die ersten Voraussetzungen geschaffen und man kann das neue Theme im Backend von WordPress aktivieren.
Achtung: der Verweis auf das Basis-Theme ist nicht sonderlich auffällig, so dass man die Abhängigkeit übersehen könnte. Darum also immer kontrolliert ein Theme löschen. Am verwendeten Theme gibt es keinerlei Hinweis, dass ein anderes Theme als Child-Theme auf dieses Theme zugreift.

Am Stylesheet drehen

Ab nun kann man jede beliebe Änderung in dem eigenen Stylesheet ablegen. Ebenfalls kann natürlich der Aufruf des Stylesheets @import url('../twentyten/style.css'); aus dem Basis-Theme entfallen und man kann sich komplett eigene Stylesheet-Strukturen aufbauen.

Man nutzt quasi die Template-Dateien, den Aufbau und das PHP-KnowHow vom Basis Theme, in dem Fall Twenty Ten. Man kümmert sich ausschließlich um das Design und das im beliebigen Umfang. Beispielsweise könnte das im einfachsten Fall eine Farbänderung des Hintergrund sein und alternativ kann ein komplett eigenes Design kreiert werden.

Templates ersetzen

Die Funktionalität des Child Theme lässt aber mehr zu als das Änderung des Aussehen. So kann man bestehende Template-Dateien des Basis-Themes ersetzen. WordPress sucht quasi im ersten Schritt im übergeordneten Child Theme und dann im Basis-Theme nach dem möglichen Template. Durchläuft dabei die Hierarchie der Template-Dateien.

An vielen Punkten vom Theme kann man via Hook eingreifen, was aber nicht jedem Nutzer liegt und kompliziert erscheint. So wird nicht selten die Ausgabe des Titel im head einer Website mit eigenen Funktionen oder von Plugins ersetzt. Man kann entweder via Hook den Titel bearbeiten oder die Ausgabe über eine Funktion steuern. Für das Beispiel soll nun der Titel mit einer Funktion aus einem Plugin ausgegeben werden. In dem Fall muss die header.php bearbeitet werden und darum muss man wie folgt vorgehen, so dass das Basis-Theme unangetastet bleibt.

Es ist lediglich die header.php, die den head-Abschnitt für das Theme enthält in das eigene Child Theme zu kopieren und hier kann sie beliebig bearbeitet werden. Ab nun zieht WordPress diese header.php und nicht mehr die Original-Datei aus dem Basis Theme Twenty Ten.

Damit kann nun auch die angesprochene Funktion in den Title integriert werden, ein Beispiel:

<title><?php
	/*
	 * Print the <title> tag based on what is being viewed.
	 * We filter the output of wp_title() a bit -- see
	 * twentyten_filter_wp_title() in functions.php.
	 */
	if ( function_exists('seo_title_tag') )
		seo_title_tag();
	else
		wp_title( '|', true, 'right' );

	?></title>

Das Basis-Theme bleibt unangetastet, kann weiterhin via Updates auf dem neusten Stand gehalten werden und ab nun zieht WordPress die header.php immer aus dem Child Theme.

Wie in diesem kleinen Beispiel kann man jedes Template ersetzen und so an die eigenen Anforderungen angepasst werden. Trotzdem sollte man bedenken, dass man das Template komplett ersetzt - in dem Beispiel-Fall würde man also ein Update der header.php nicht mitbekommen. Insofern kann es nützlich sein, wenn man auf diverse Bereiche besser via Hook zugreift und diese in eigenen Funktionen abbildet, dazu gleich mehr.

Wichtig: eine Ausnahme ist die functions.php, dazu im Anschluss mehr.

Templates erweitern

Um eigene Anforderungen zu erfüllen, kann es sein, dass man neue Templates benötigt, Template-Dateien die es im Ist-Zustand nicht im Basis-Theme nicht gibt. Im Sinne der Hirarchie kann man immer erweitern. Beispielsweise besitzt Twenty Ten keine home.php - sollte man die aber definieren wollen, also dann wenn die definierte Home-Seite des Backend im Frontend geladen wird, dann kann man diese Datei einfach in das Child-Theme ablegen und WordPress zieht diese Datei, wenn der Zustand is_home() wahr ist.

Mit WordPress Version 3.0 gibt es aber eine weitere Möglichkeit außerhalb der Template-Hirarchie um eigene Templates einzubringen - get_template_part().
Diese Funktion wird konsequent innerhalb von Twenty Ten verwendet - damit muss man in diversen Fällen keine eigenen Templates für den kompletten Aufruf anlegen, sondern lediglich den Abschnitt des Loop.
Beispielsweise nutzt Twenty Ten für die Darstellung der Kategorie-Archive den Aufruf get_template_part( 'loop', 'category' );. Damit ist es möglich, dass in unserem Child Theme ein Template abgelegt wird, was diesen Loop bedient. Es ist also lediglich eine Datei loop-category.php anzulegen und dort alle notwendigen Infos abzulegen.
Im folgenden Beispiel passe ich den Loop an, wenn man sich einem der vier Kategorien befindet. Weitere Änderungen sind möglich, so dass man volle Kontrolle und Flexibilität erhält.

// Anpassungen des Loop
if ( in_category( array(47, 37, 27, 45) ) ) {
	query_posts( 'cat='.$cat.'&posts_per_page=-1&orderby=title&order=ASC' );
}	else {
	query_posts( 'cat='.$cat.'&posts_per_page=20&paged='.$paged );
}
while ( have_posts() ) : the_post(); ?>

Ähnlich könnte man so den Loop für die index.php anpassen - Template Datei loop-index.php wäre dann im Spiel

Funktionen einbringen

Natürlich kann man auch innerhalb des Child-Theme eigene Funktionen einbringen. Wenn man eine eigene functions.php im Child Theme ablegt, dann ersetzt diese Datei nicht die functions.php des Basis-Theme!
Es werden immer die Funktionen des Basis-Theme genutzt; man muss sie via Hook deaktivieren. Die Möglichkeit wird auch in einer Doku in der Datei functions.php erklärt.

add_action( 'after_setup_theme', 'my_child_theme_setup' );
function my_child_theme_setup() {
		// We are providing our own filter for excerpt_length (or using the unfiltered value)
		remove_filter( 'excerpt_length', 'twentyten_excerpt_length' );
		...
}

Innerhalb der Funktion my_child_theme_setup() kann man nun Funktione des Basis-Theme deaktivieren und eigene Funktionen einbringen.

Weitere Funktionen gehören in die functions.php des Child Themes - das Basis-Theme bleibt immer unangetastet. Im folgenden Code dazu ein Beispiel.
Dabei deaktiviere ich die Funktion des Basis Theme Twenty Ten zur Länge des Excerpt und lade dazu eine eigene Funktion twentytenjump_excerpt_length() und es wird ein Widget eingebracht.

<?php
function twentytenjump_setup() {
	
	remove_filter( 'excerpt_length', 'twentyten_excerpt_length' );
	add_filter( 'excerpt_length', 'twentytenjump_excerpt_length' );
	
	add_action( 'widgets_init', 'register_limited_catagories_widget' );
}
add_action( 'after_setup_theme', 'twentytenjump_setup' );

function twentytenjump_excerpt_length( $length ) {
	return 10;
}

class limited_catagories_list_widget extends WP_Widget {
	
	function limited_catagories_list_widget(){
		$widget_ops = array( 'classname' => __('Selective categories'), 'description' => __('Show a list of Categories, with the ability to exclude categories') );
		
		$control_ops = array( 'id_base' => 'some-cats-widget' );
		$this->WP_Widget( 'some-cats-widget', __('Selective Catagories'), $widget_ops, $control_ops );
	}
 
	function form ( $instance){
		$defaults = array( 'title' => __('Catagories'), 'cats' => '', 'count' => 0 );
		$instance = wp_parse_args( (array) $instance, $defaults );
		$count = isset($instance['count']) ? (bool) $instance['count'] :false;
		?>
		<p>
			<label for="<?php echo $this->get_field_id( 'title' ); ?>"><?php _e( 'Title:' ); ?></label>
			<input id="<?php echo $this->get_field_id( 'title' ); ?>" name="<?php echo $this->get_field_name( 'title' ); ?>" value="<?php echo $instance['title']; ?>" class="widefat" />
		</p>
		<p>
			<input type="checkbox" class="checkbox" id="<?php echo $this->get_field_id('count'); ?>" name="<?php echo $this->get_field_name('count'); ?>"<?php checked( $count ); ?> />
			<label for="<?php echo $this->get_field_id('count'); ?>"><?php _e( 'Show post counts' ); ?></label><br />
		</p>
		<p>
			<label for="<?php echo $this->get_field_id( 'cats' ); ?>"><?php _e( 'Categories to exclude (comma separated list of Category-IDs): ' ); ?></label>
			<input id="<?php echo $this->get_field_id( 'cats' ); ?>" name="<?php echo $this->get_field_name( 'cats' ); ?>" value="<?php echo $instance['cats']; ?>" class="widefat" />
		</p>
		<?php
	}
 
	function update($new_instance, $old_instance) {
			$instance = $old_instance;
			$instance['title'] = strip_tags( $new_instance['title'] );
			$instance['count'] = !empty($new_instance['count']) ? 1 : 0;
			$instance['cats']  = strip_tags( $new_instance['cats'] );
			return $instance;
	}
 
	function widget($args, $instance){
		extract( $args );
		$title = apply_filters('widget_title', $instance['title'] );
		$c     = $instance['count'] ? '1' : '0';
		$cats  = $instance['cats'];
		echo $before_widget;
		if ( $title )
			echo $before_title . $title . $after_title;
		echo '<ul>';
		wp_list_categories("exclude=$cats&title_li=&show_count=$c");
		echo '</ul>';
		echo $after_widget;
	}

}

function register_limited_catagories_widget(){
	register_widget('limited_catagories_list_widget');
}
?>

Fazit

Ich meine aktuell, dass durch die Einführung des neuen Standard-Theme Twenty Ten sicher einige neue schöne Funktionen hinzugekommen sind. Ich denke aber ebenso, dass Twenty Ten sehr ungeeignet ist um die Arbeit von WordPress im Bereich des Themes zu verstehen. Gerade Einsteiger und PHP-Neulinge werden sich schwer tun. Trotzdem entstehen so neue Möglichkeiten und will man Child Themes sauber nutzen, dann kommt man um das Verständnis der Hooks in der WordPress API nicht herum. WordPress führt die Idee der Hooks konsequent fort, schon immer in Plugins beliebt, machen sie sich nun auch in Themes breit. Alles hat Vor- und Nachteile.
Nutzt man aber ein gut gepflegtes Theme oder Framework, dann wird man die neuen Möglichkeiten schätzen und kann so immer ohne Probleme Updaten. Entscheidend wird das eigene Wissen um WordPress sein - je nach Interesse, Wissensstand und Arbeitsweise kann man eigene Themes erstellen. Man sollte sich im Vorfeld Gedanken machen und nicht blind loslegen und wie so oft, am Theme schrauben.

Download:

Zum Abschluss noch das Theme mit den entsprechenden Template-Dateien als Downlaod, so dass man einen kleinen Start zum Spielen hat.

Ist die Arbeit nicht 1 Euro wert?
Jede Spende wird dankbar angenommen und ermöglicht das weitere Arbeiten an freier Software.
Möchtest du mehr oder anders spenden, so besuche meine Wunschliste.
Download als zip-Datei: twentytenjump.zip - 5 kByte
Einen Stand online einsehbar und erweiterbar, eventuell gepflegt findest du auf Github: github.com/bueltge/TwentyTenJump

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Liste aller Unterkategorien

Manchmal braucht man einfach nur eine Liste alle untergeordneten Kategorien, fragt nicht warum. Die Anforderungen von Projekten kann sehr vielfältig sein, ebenso der Lösungsweg und in meinem Fall ist ein kleiner Code-Schnippsel entstanden, die sich um die Ausgabe der Subcategories kümmert; zum mitnehmen, spielen, verbessern und erweitern.

$echo = '<ul>' . "\n";
$childcats = get_categories('child_of=' . $cat . '&hide_empty=1');
foreach ($childcats as $childcat) {
	if (1 == $childcat->category_parent) {
		$echo .= "\t" . '<li><a href="' . get_category_link($childcat->cat_ID).'" title="' . $childcat->category_description . '">';
		$echo .= $childcat->cat_name . '</a>';
		$echo .= '</li>' . "\n";
	}
}
$echo .= '</ul>' . "\n";
echo $echo;

Abfrage, ob in Kategorie oder Subkategorie

Die zweite Sache brauchte ich nicht erstellen, die habe ich bei valen gefunden - klein aber fein. Sie gibt zurück, ob man sich in einer untergeordneten- oder der Haupt-Kategorie befindet. Brauchen kann man so was, wenn man komplexe Strukturen aufbaut und steuern will. Als Übergabe muss die ID der Kategorie mitgegeben werden, kein Slug!

function is_category_or_subcategory($catID = 0) {
	foreach (get_the_category() as $cat) {
		if ( $catID == $cat->cat_ID || cat_is_ancestor_of($catID, $cat) )
			return true;
	}
	return false;
}

In dem Zusammenhang im übrigen der Hinweis auf die Funktion cat_is_ancestor_of() - sehr mächtig und nützlich.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Als kleines Präsent zum heiligen Abend heute habe ich euch ein Plugin erstellt, was euch zum einen zusätzliche Felder in den Bereich Schreiben von WordPress bringt, was euch zeigt, wie einfach man den Bereich erweitern kann und was nach belieben von euch genutzt werden darf.

Das Plugin bringt 3 neue Felder in einer Metabox mit:

• Untertitel - wie der Name schon sagt, eine Zeile ohne Formatierung in der Ausgabe
• Zusatzinformationen - ein vollwertiger Editor, ebenso kann man jede Art von Attachments hinzufügen, also fast gleich dem Content-Editor.
• Listdaten - Hier wird ermöglicht, dass man pro Zeile einen Inhalt pflegt und jede Zeile als List-Element ausgeben wird, ungeordnete Liste ul

Jedes dieser Felder kann gezielt im Template des Themes eingesetzt werden, hat also einen Template Tag, der die Ausgabe steuert. Nur wenn es in diesem Feld Daten gibt, dann werden sie auch ausgegeben. Im folgenden ein Beispiel, der die drei neuen Felder ausgibt.

<div <?php post_class() ?> id="post-<?php the_ID(); ?>">

	<h2><?php the_title(); ?></h2>

	<h3><?php if ( function_exists('the_DifferentTypeFacts') ) the_DifferentTypeFacts($post->ID, 'heading'); ?></h3>

	<div class="entry">

		<?php the_content('<p class="serif">Read the rest of this entry &raquo;</p>'); ?>

		<?php if ( function_exists('the_DifferentTypeFacts') ) the_DifferentTypeFacts($post->ID, 'additional-info'); ?>

		<?php if ( function_exists('the_DifferentTypeFacts') ) the_DifferentTypeFacts($post->ID, 'listdata'); ?>

Das Plugin soll als Vorlage dienen, wer also mag, der passt es an und schafft eine Oberfläche, in der sich die Autoren wohl fühlen, keine Pflege der benutzerdefinierten Felder.

Das Plugin sorgt dafür, dass die Metaboxen "Benutzerdefinierte Felder" und "Trackbacks" nicht mehr da sind (remove_meta_box()); auch das als Beispiel für die Nutzung. Zu jedem der genutzten Code-Schnipsel im Plugin gibt es hier im Blog einen Beitrag und so sollte man damit klar kommen. Im folgenden der Code ohne Zusatzfiles und im Anschluss das Plugin als Download, inkl. readme, Sprachfiles für deutsche User und die nötigen Scripte.

<?php
/**
 * @package Different Type
 * @author Frank B&uuml;ltge
 * @version 0.1
 */
 
/*
	Plugin Name: Different Type
	Plugin URI: http://bueltge.de/
	Description: Add different types to posts
	Author: Frank B&uuml;ltge
	Version: 0.1
	License: GPL
	Author URI: http://bueltge.de/
	Last change: 24.12.2009 00:00:00
*/

/**
 * Example for use outside the loop:
 * <?php the_DifferentTypeFacts($post->ID); ?>
 * @param $id Integer - Post-ID
 * @param $type String - heading, additional-info, listdata (default is ''-empty)
 *
 * Example: <?php the_DifferentTypeFacts($post->ID, 'heading'); ?>
 */

//avoid direct calls to this file, because now WP core and framework has been used
if ( !function_exists('add_action') ) {
	header('Status: 403 Forbidden');
	header('HTTP/1.1 403 Forbidden');
	exit();
}

if ( function_exists('add_action') ) {
	//WordPress definitions
	if ( !defined('WP_CONTENT_URL') )
		define('WP_CONTENT_URL', get_option('siteurl') . '/wp-content');
	if ( !defined('WP_CONTENT_DIR') )
		define('WP_CONTENT_DIR', ABSPATH . 'wp-content');
	if ( !defined('WP_PLUGIN_URL') )
		define('WP_PLUGIN_URL', WP_CONTENT_URL.'/plugins');
	if ( !defined('WP_PLUGIN_DIR') )
		define('WP_PLUGIN_DIR', WP_CONTENT_DIR.'/plugins');
	if ( !defined('PLUGINDIR') )
		define( 'PLUGINDIR', 'wp-content/plugins' ); // Relative to ABSPATH.  For back compat.
	if ( !defined('WP_LANG_DIR') )
		define('WP_LANG_DIR', WP_CONTENT_DIR . '/languages');
	
	// plugin definitions
	define( 'FB_DT_BASENAME', plugin_basename(__FILE__) );
	define( 'FB_DT_BASEDIR', dirname( plugin_basename(__FILE__) ) );
	define( 'FB_DT_TEXTDOMAIN', 'different-types' );
}

if ( !class_exists( 'DifferentType' ) ) {
	class DifferentType {
		
		// constructor
		function DifferentType() {
			
			if (is_admin() ) {
				add_action( 'admin_init', array(&$this, 'on_admin_init') );
				add_action( 'wp_insert_post', array(&$this, 'on_wp_insert_post'), 10, 2 );
				add_action( 'init', array(&$this, 'textdomain') );
				register_uninstall_hook( __FILE__, array(&$this, 'uninstall') );
				add_action( "admin_print_scripts-post.php", array($this, 'enqueue_script') );
				add_action( "admin_print_scripts-post-new.php", array($this, 'enqueue_script') );
				add_action( "admin_print_scripts-page.php", array($this, 'enqueue_script') );
				add_action( "admin_print_scripts-page-new.php", array($this, 'enqueue_script') );
			}
		}
		
		// active for multilanguage
		function textdomain() {
			
			if ( function_exists('load_plugin_textdomain') )
				load_plugin_textdomain( FB_DT_TEXTDOMAIN, false, dirname( FB_DT_BASENAME ) . '/languages' );
		}
		
		// unsintall all postmetadata
		function uninstall() {
			
			$all_posts = get_posts('numberposts=0&post_type=post&post_status=');

			

			foreach( $all_posts as $postinfo) {

				delete_post_meta($postinfo->ID, '_different-types');

			}
		}
		
		// add script
		function enqueue_script() {
			wp_enqueue_script( 'tinymce4dt', WP_PLUGIN_URL . '/' . FB_DT_BASEDIR . '/js/script.js', array('jquery') );
		}
		
		// admin init
		function on_admin_init() {
			
			if ( !current_user_can( 'publish_posts' ) )
				return;
			
			add_meta_box( 'different_types',
									__( 'Different Types', FB_DT_TEXTDOMAIN ),
									array( &$this, 'meta_box' ),
									'post', 'normal', 'high'
									);
									
			// remove meta box for trackbacks
			remove_meta_box('trackbacksdiv', 'post', 'normal');
			// remove meta box for custom fields
			remove_meta_box('postcustom', 'post', 'normal');
		}
		
		// check for preview
		function is_page_preview() {
			$id = (int)$_GET['preview_id'];
			if ($id == 0) $id = (int)$_GET['post_id'];
			$preview = $_GET['preview'];
			if ($id > 0 && $preview == 'true') {
				global $wpdb;
				$type = $wpdb->get_results("SELECT post_type FROM $wpdb->posts WHERE ID=$id");
				if ( count($type) && ($type[0]->post_type == 'page') && current_user_can('edit_page') )
					return true;
			}
			return false;
		}
		
		// after save post, save meta data for plugin
		function on_wp_insert_post($id) {
			global $id;
			
			if ( !isset($id) )
				$id = (int)$_REQUEST['post_ID'];
			if ( $this->is_page_preview() && !isset($id) )
				$id = (int)$_GET['preview_id'];
			
			if ( !current_user_can('edit_post') )
				return;
			
			if ( isset($_POST['dt-heading']) && $_POST['dt-heading'] != '' )
				$this->data['heading'] = esc_attr( $_POST['dt-heading'] );
			if ( isset($_POST['dt-additional-info']) && $_POST['dt-additional-info'] != '' )
				$this->data['additional-info'] = $_POST['dt-additional-info'];
			if ( isset($_POST['dt-listdata']) && $_POST['dt-listdata'] != '' )
				$this->data['listdata'] = esc_attr( $_POST['dt-listdata'] );
			
			if ( isset($this->data) && $this->data != '' )
				update_post_meta($id, '_different-types', $this->data);
		}

		// load post_meta_data
		function load_post_meta($id) {
			
			return get_post_meta($id, '_different-types', true);
		}

		// meta box on post/page
		function meta_box($data) {
			
			$value = $this->load_post_meta($data->ID);
			?>
			<table id="dt-page-definition" width="100%" cellspacing="5px">
				<tr valign="top">
					<td style="width:20%;"><label for="dt-heading"><?php _e( 'Subtitle:', FB_DT_TEXTDOMAIN ); ?></label></td>
					<td><input type="text" id="dt-heading" name="dt-heading" class="heading form-input-tip" size="16" autocomplete="off" value="<?php echo $value['heading']; ?>" tabindex="6" style="width:99.5%"/></td>
				</tr>
				<tr valign="top">
					<td><label for="dt-additional-info"><?php _e( 'Additional information:', FB_DT_TEXTDOMAIN ); ?></label></td>
					<td><textarea cols="16" rows="5" id="dt-additional-info" name="dt-additional-info" class="additional-info form-input-tip code" size="20" autocomplete="off" tabindex="6" style="width:90%"/><?php echo wpautop( $value['additional-info'] ); ?></textarea>
						<table id="post-status-info" cellspacing="0" style="line-height: 24px;">
							<tbody>
								<tr>
									<td>&nbsp;</td>
									<td>&nbsp;</td>
								</tr>
							</tbody>
						</table>
					</td>
				</tr>
				<tr valign="top">
					<td><label for="dt-listdata"><?php _e( 'Listdata:', FB_DT_TEXTDOMAIN ); ?></label></td>
					<td><textarea cols="16" rows="10" id="dt-listdata" name="dt-listdata" class="listdata form-input-tip" size="20" autocomplete="off" tabindex="6" style="width:99.5%"/><?php echo $value['listdata']; ?></textarea><br /><small><?php _e( 'One list per line', FB_DT_TEXTDOMAIN ) ?></small></td>
				</tr>
			</table>
			<?php
		}

		// return facts incl. markup
		function get_DifferentTypeFacts($id, $type, $value) {
			
			if (!$value)
				return false;
			if ( $type == '' )
				return false;
			
			if ( 'heading' == $type && '' != $value['heading'] )
				return $value['heading'];
			if ( 'additional-info' == $type && '' != $value['additional-info'] )
				return wpautop( wptexturize($value['additional-info']) );
			if ( 'listdata' == $type && '' != $value['listdata'] ) {
				$return = '';
				$listdatas = preg_split("/\r\n/", $value['listdata'] );

				foreach ( (array) $listdatas as $key => $listdata ) {

					$return .= '<li>' . trim($listdata) . '</li>';

				}
				return '<ul>' . $return . '</ul>'. "\n";
			}
		}
		
		// echo facts, if exists
		function DifferentTypeFacts($id, $type, $string) {
		
			if ( $id ) {
				$value = $this->load_post_meta($id);
				
				echo $this->get_DifferentTypeFacts($id, $type, $value);
			}
		}

	} // End class
	
	// instance class
	$DifferentType = new DifferentType();
	
	
	// use in template
	function the_DifferentTypeFacts($id, $type = '', $string = '') {
		global $DifferentType;
		
		$DifferentType->DifferentTypeFacts($id, $type, $string);
	}
	
} // End if class exists statement
?>

Download als zip-Datei: github.com/bueltge/different-type/zipball/master - 40 kByte
Das Plugin liegt in einer gepflegten Version bei github.com und kann dort besichtigt, geforkt und gezogen werden.

Ich wünsche viel Spass damit und vielleicht wird das einen oder andere Projekt mit WordPress damit in diesem Bereich ein wenig klarer und logischer für die Autoren.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

WordPress bringt im Standard die jQuery Bibliothek mit und so müssen wir uns um die nicht kümmern, sondern nutzen sie lediglich. Dabei findet der Aufruf aller nötigen Dateien und Scripte innerhalb des Templates statt, welches sich im Anschluss um die Ausgabe des Kontaktformulars kümmert. Dieses Aufruf erledigen wir mit den Funktionen von WordPress - so gehen wir sicher, dass die Dateien wirklich nur einmal geladen werden. WordPress kümmert sich um die richtige Reihenfolge und um die Abhängigkeiten. Zu diesem Thema habe ich bereits einiges an Infos hinterlegt und verweise auf diesen Beitrag.

Als erstes erstellen wir ein Template, ich nenne es contact-page.php und es muss im Ordner eures Themes abgelegt werden. Dies enthält den Aufruf der nötigen Scripte und der dazugehörigen Stylesheets. Im Grunde benötigt ihr nur diese vier Aufrufe in der page.php eures Theme abzulegen, einen neuen Namen für die Datei zu vergeben und den Kommentar zum Erkennen durch WordPress im Page-Bereich des Backend abzulegen (ganz am Anfang der Datei). Im folgenden die Syntax am Beispiel der page.php aus dem Standard-Theme Kubrick.

<?php
/**
 * Template Name: Contact Page
 *
 * @package WordPress
 * @subpackage Default_Theme
 */

wp_enqueue_script( 'jquery.contactable', get_bloginfo('template_directory') . '/contactable/jquery.contactable.js', array('jquery') , 3.1, true );
wp_enqueue_script( 'jquery.validate', get_bloginfo('template_directory') . '/contactable/jquery.validate.pack.js', array('jquery') , 3.1, true );
wp_enqueue_script( 'my_contactable', get_bloginfo('template_directory') . '/contactable/my_contactable.js', array('jquery') , 3.1, true );
wp_enqueue_style( 'contactable', get_bloginfo('template_directory') . '/contactable/contactable.css' );

get_header(); ?>

	<div id="content" class="narrowcolumn" role="main">

		<div class="post" id="post-<?php the_ID(); ?>">
		<h2><?php the_title(); ?></h2>

			<div class="entry">
				<?php the_content('<p class="serif">Read the rest of this page &raquo;</p>'); ?>
				
				<div id="mycontactform"> </div>
				
			</div>
		</div>
	
	</div>

<?php get_sidebar(); ?>

<?php get_footer(); ?>

Wie in der Syntax zu erkennen, habe ich alle Dateien des jQuery-Formular-Plugnis im Ordner contactable im Ordner des Themes abgelegt. Eventuell müssen daher eure Pfade angepasst werden. Aktuell sieht es in meinem Theme wie folgt aus:

• default
  • contactable
    • jquery.contactable.js
    • jquery.validate.pack.jss
    • my.contactable.js
    • contactable.css
  • style.css
  • contact-page.php
  • ...

Einzig die Datei my.contactable.js habe ich hinzugefügt; diese kümmert sich um den Aufruf des Formulars und kann mit Parametern gefüllt werden. Inhaltlich sieht sie wie folgt aus:

jQuery(document).ready( function($){
	$('#mycontactform').contactable({
		name: 'Name',
		email: 'E-Mail',
		message : 'Nachricht',
		recipient: 'example@domain.com',
		subject: 'Kontaktformular',
		recievedMsg : 'Vielen Dank für Ihre Nachricht.'
	});
});

Sind alle Dateien gespeichert und an eure Bedürfnisse angepasst, dann muss lediglich im Admin-Bereich von WordPress eine Seite angelegt werden. Dieser Seite gebt ihr einen Namen, eventuell Inhalt und ihr müsst das Template auswählen - in unserem Fall die Contact Page. Nachdem Speichern sollte die Seite im Frontend des Blog aufzurufen sein und mit einem Klick auf das kleine Label fährt das Formular in die Sicht und kann ausgefüllt werden.

Durch die Aufrufe mit Hilfe von WordPress Funktionen und den richtigen Parametern, sind nun die Scripte im Footer der Site integriert. Die Bibliothek jQuery muss nicht aufgerufen werden, sie wird von WordPress hinzugefügt, wenn sie noch nicht da ist, durch die Abhängigkeit der Parameter zum Schlüssel jquery. Durch die Nutzung eines Templates mit allen Aufrufen werden sämtliche Scripte und StyleSheets nur eingebunden, wenn diese Seite von WordPress aufgerufen wird. Wer das Formular-Schnippsel auf allen Seiten möchte, der macht den Aufruf bspw. in der header.php oder functions.php.

Möchte man diese Funktion nicht nutzen, so kann entweder dass CSS nicht genutzt werden, bzw. ein eigenes Design hinzugefügt werden oder man passt das JS an seine eigenen Bedürfnisse an. Gleiches gilt für zusätzliche Felder im Formular, dazu muss der Inhalt der Dateien angepasst werden.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

query_posts('posts_per_page=5&offset=1&orderby=comment_count');
if ( have_posts() ) :
	while ( have_posts() ) : the_post(); ?>

Alternativ kann man beispielsweise auch via Zufall sortieren lassen; nützlich bei kleinen Gimmicks in der Sidebar; auch dazu ein Beispiel mit anderer Syntax.

<?php
$i = new WP_Query( array('category_name' => 'referenzen', 'showposts' => 10, 'nopaging' => 0, 'post_status' => 'publish', 'caller_get_posts' => 1, 'orderby' => 'rand') );
if ( $i->have_posts() ) : ?>

Ebenso kann man seit Version 2.8 von WordPress die Sortierung deaktivieren - orderby=none.

Viele weitere Tipps gibt es in einem Quick Tipp von mir und natürlich im Codex von WordPress.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Aber auch bei dieser Funktion sollte man auf das Vorhandensein der Funktion prüfen und eine Alternative anbieten. Nur so kann man dem Nutzer die Freiheit der WordPress Version überlassen. Die Funktionen von Erweiterungen, Plugins und Themes gehröen einer Prüfung unterzogen; so ist die Funktion des Themes abgesichert, auch wenn eine Funktion nicht zur Verfügung steht. Ähnlich sehe ich es mit dieser Funktion für die Thumbnails zum Beitrag, auch wenn sie Funktionen aus dem Core nutzen.

Zwei Anregungen für Alternativen möchte ich im folgenden kurz aufzeigen und ich verweise auf den ausführlichen Artikel zum Thema Bilder in Themes mit Benutzerdef. Feldern oder der Mediathek von WordPress nutzen.

Nach Hinzufügen der folgenden Syntax in der functions.php des Themes steht die MetaBox im Bereich Schreiben eines Beitrags bzw. Seite bereit und kann einfach via Aufruf der Mediathek aus dieser MetaBox genutzt werden.

if ( function_exists('add_theme_support') )
	add_theme_support('post-thumbnails');

Alternativ kann man zwischen Beiträgen und Seiten trennen:

add_theme_support( 'post-thumbnails', array( 'post' ) ); //Beiträge
add_theme_support( 'post-thumbnails', array( 'page' ) ); //Seiten

Man kann im übrigen auch Größen definieren, zum einen direkt für Thumbnails ...

set_post_thumbnail_size( 150, 150, true ); // Breite, Höhe, true für kein crop mode; beschneiden

... und ebenso andere Größen, in dem man zusätzlich einen Namen vergibt. Im obigen Code ist der Standard-Name post-thumbnail übergeben.

add_image_size('my-single-picture', 150, 150, false);

Die Ausgabe des Bildes wird dann im Theme an der Stelle, wo es erscheinen soll, einfach mit Hilfe des Template Tag erzeugt: the_post_thumbnail().

if ( current_theme_supports( 'post-thumbnails' ) )
	the_post_thumbnail( array(300,200) );

Alternativ kann man dann auch wieder die eigenen Typen abfragen:

the_post_thumbnail( 'my-single-picture' );

Wichtig, arbeitet man mit zusätzlichem Markup, dann gehört die Abfrage dazu, ob es denn ein Thumbnail zum Beitrag gibt. Ansonsten wird unnötig Markup ausgegeben, welches keinen Inhalt hat.

<?php
if ( has_post_thumbnail() ) { ?>
	<span class="my_image">
		<?php the_post_thumbnail(array(600, 400)); ?>
	</span>
} ?>

Um nun aber eine Alternative für Installationen kleiner WP 2.9 zu haben, kann man verschiedene Ansätze gehen. Die zwei folgenden Beispiele sind daher als Ideengeber zu verstehen: entweder mit Hilfe der benutzerdefinierten Felder, Feldname ist post-image ...

if ( function_exists('has_post_thumbnail') && has_post_thumbnail() ) {
	the_post_thumbnail(); // @parameter: array(height, width)
} else {
	$myimage = get_post_meta($post->ID, 'post-image', true); // via custom field
	if ($myimage) {
		echo '<img class="wp-post-image" src="'.$postimage.'" alt="Post Iage" />';
	}
}

... oder im nachfolgenden Beispiel das erste Bild aus der Mediathek. Mehr dazu gibt es in einem separaten Beitrag.

if ( function_exists('has_post_thumbnail') && has_post_thumbnail() ) {
	the_post_thumbnail(); // @paramter: array(height, width)
} else {
	// via mediathek
	$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 );
	}
}

Prüfen ob das Theme die Funktion unterstützt ist ebenso möglich:

if ( current_theme_supports( 'post-thumbnails' ) ) {
	...

Zusätzlich kann man prüfen, ob das Theme die Funktion unterstützt und explizit für Beiträge (post) oder Seiten (page) nutzen. Sehr interessant, wenn man zusätzliche Funktionen in den Schreiben-Bereich des Backend bringen möchte, welcher abhängig von diesem Feature innerhalb des Theme ist.:

if ( current_theme_supports( 'post-thumbnails', array( 'page' ) ) ) {
	add_meta_box( ...

In diesem Zusammenhang kann man auch extern Dateien mit neuen Funktionen einbinden.

require_if_theme_supports( 'post-thumbnails', ABSPATH . WPINC . '/my-post-thumbnail-funktion.php' );

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

function is_sidebar_active($index) {
	global $wp_registered_sidebars;

	$widgetcolums = wp_get_sidebars_widgets();

	if ($widgetcolums[$index])
		return true;

	return false;
}

Damit wird die Ausgabe des Widget-Bereiches nur genutzt, wenn es auch Inhalte gibt.
Im Template könnte die Abfrage beispielsweise wie folgt aussehen.

<?php if ( function_exists('is_sidebar_active') && is_sidebar_active('sidebar') ) { ?>
	<div id="sidebar">
		<ul>
			<?php dynamic_sidebar('sidebar'); ?>
		</ul>
	</div>
<?php } ?>

Das obige Beispiel lädt den Inhalt nur, wenn der Widget-Bereich mit der ID sidebar Inhalte hat, also wenn Widgets in diesem Bereich genutzt werden.

Seit WordPress Version 2.8 gibt es dazu auch eine Funktion im Core und man muss die obige Funktion nicht eigens hinzu bringen is_active_sidebar(). Damit geht die Prüfung ebenso einfach und sicher.

<?php if ( function_exists('is_active_sidebar') && is_active_sidebar('sidebar') ) { ?>
	<div id="sidebar">
		<ul>
			<?php dynamic_sidebar('sidebar'); ?>
		</ul>
	</div>
<?php } ?>

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

if ( function_exists('register_sidebar') ) {
	register_sidebar(array(
		'name' => 'My Lorem Ipsum Sidebar',
		'description' => __('Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo.', 'your_textdomain'),
		'before_widget' => '<li id="%1$s" class="widget %2$s">',
		'after_widget' => '</li>',
		'before_title' => '<h2 class="widgettitle">',
		'after_title' => '</h2>',
	));
}

Ein etwas umfassendes Beispiel mit zwei Widgetbereichen, ein Bereich für den Sidebar und ein Bereich für den Footer; in der Regle also in die footer.php.

if ( function_exists('register_sidebar') ) {
	register_sidebar(array(
		'id' => 'mysidebar',
		'name' => 'My Lorem Ipsum Sidebar',
		'description' => __('Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo.', 'your_textdomain'),
		'before_widget' => '<li id="%1$s" class="widget %2$s">',
		'after_widget' => '</li>',
		'before_title' => '<h2 class="widgettitle">',
		'after_title' => '</h2>',
	));

	register_sidebar(array(
		'id' => 'myfooter',
		'name' => 'My Lorem Ipsum Footer',
		'description' => __('Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo.', 'your_textdomain'),
		'before_widget' => '<li id="%1$s" class="widget %2$s">',
		'after_widget' => '</li>',
		'before_title' => '<h2 class="widgettitle">',
		'after_title' => '</h2>',
	));
}

Diesen kann man im einfachsten Fall dann wie folgt in den Templates nutzen; im folgendem mal die Nutzung in der footer.php des Widget-Bereiches My Lorem Ipsum Footer.

<div id="myfooter">
	<ul>
		<?php dynamic_sidebar('myfooter'); ?>
	</ul>
</div>

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Die Darstellung dieser Beiträge in der Kategorie-Übersicht soll eine andere sein. Bisher musste man dazu folgenden Abfrage integrieren:

if ( is_category('microblog') ) {
	// hier die Ausgabe oder Integration des Stylesheet für Kategorie Microblog
}

Mit WordPress 2.9 reicht das entsprechende Template category-microblog.php und dieses Template wird gezogen, wenn man in der Kategorie des Slug microblog ist. Alternativ geht es auch weiterhin mit der ID, die sich aber ändern kann. Über den Namen des Slug ist die Identifizierung eindeutig und einfach.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

<form action="<?php echo wp_login_url( get_permalink() ); ?>" method="post">
	<label for="log">
		<input type="text" name="log" id="log" value="<?php echo wp_specialchars(stripslashes($user_login), 1) ?>" size="22" /> User
	</label><br />
	<label for="pwd">
		<input type="password" name="pwd" id="pwd" size="22" /> Password
	</label><br />
	<input type="submit" name="submit" value="Send" class="button" />
	<label for="rememberme"><input name="rememberme" id="rememberme" type="checkbox" checked="checked" value="forever" /> Remember me</label>
</form>

Nun ist das nicht immer ausreichend und abhängig von den Usern, die geloggt sind, und ob man sich überhaupt im Theme registrieren kann, habe ich ein kleines Beispiel geschrieben, welches diverse Aspekte beachtet.
Mit der folgenden Syntax ist dabei die Ansicht für geloggte User (if ( $user_ID )) eine völlig andere und neue User bekommen das Formular nur dann, wenn sie sich registrieren dürfen (get_option('users_can_register')); abhängig von den Einstellungen im Backend von WordPress.
Ebenso bekommen User, die ein User_Level größer 1 (if ( $user_level >= 1 )) haben, einen Link mehr, direkt zum Schreiben eines Artikels. Alternativ kann hier auch mit der Funktion current_user_can() gearbeitet werden und daher explizit das Objekt der Rolle abgefragt werden.

<?php
global $user_ID, $user_identity, $user_level;
if ( $user_ID ) { ?>

	<h3><?php _e( 'Control panel', FB_BASIS_TEXTDOMAIN ); ?></h3>
	<ul>
		<li><?php _e( 'Identified as', FB_BASIS_TEXTDOMAIN ); ?> <strong><?php echo $user_identity ?></strong>.
			<ul>
				<li><a href="<?php bloginfo('url') ?>/wp-admin/"><?php _e( 'Dashboard', FB_BASIS_TEXTDOMAIN ); ?></a></li>

				<?php if ( $user_level >= 1 ) { ?>
					<li><a href="<?php bloginfo('url') ?>/wp-admin/post-new.php"><?php _e( 'Write an article', FB_BASIS_TEXTDOMAIN ); ?></a></li>
				<?php } ?>

				<li><a href="<?php bloginfo('url') ?>/wp-admin/profile.php"><?php _e( 'Profile', FB_BASIS_TEXTDOMAIN ); ?></a></li>
				<li><a href="<?php wp_logout_url( urlencode($_SERVER['REQUEST_URI']) ); ?>"><?php _e( 'Exit', FB_BASIS_TEXTDOMAIN ); ?></a></li>
			</ul>
		</li>
	</ul>

<?php } elseif ( get_option('users_can_register') ) { ?>

		<h3><?php _e( 'Identification', FB_BASIS_TEXTDOMAIN ); ?></h3>
		<ul>
			<li>
				<form action="<?php echo wp_login_url(get_permalink()); ?>" method="post">
					<p>
						<label for="log">
							<?php _e( 'User', FB_BASIS_TEXTDOMAIN ); ?>
							<input type="text" name="log" id="log" value="<?php echo wp_specialchars(stripslashes($user_login), 1) ?>" size="22" />
						</label><br />
						<label for="pwd">
							<?php _e( 'Password', FB_BASIS_TEXTDOMAIN ); ?>
							<input type="password" name="pwd" id="pwd" size="22" />
						</label><br />
						<input type="submit" name="submit" value="<?php _e( 'Send', FB_BASIS_TEXTDOMAIN ); ?>" class="button" />
						<label for="rememberme">
							<input name="rememberme" id="rememberme" type="checkbox" checked="checked" value="forever" /><?php _e( 'Remember me', FB_BASIS_TEXTDOMAIN ); ?>
						</label><br />
						<input type="hidden" name="redirect_to" value="<?php echo $_SERVER['REQUEST_URI']; ?>"/>
					</p>
				</form>
			</li>
			<li>
				<a href="<?php echo site_url('wp-login.php?action=register', 'login'); ?>"><?php _e( 'Register', FB_BASIS_TEXTDOMAIN ); ?></a>
			</li>
			<li>
				<a href="<?php echo site_url('wp-login.php?action=lostpassword', 'login');	 ?>"><?php _e( 'Recover password', FB_BASIS_TEXTDOMAIN ); ?></a>
			</li>
		</ul>

<?php } ?>

Wem die User-Level nicht ausreichen, der kann WordPress auch erweitern, entweder via Code, hier erklärt, oder mit Hilfe eines Plugins.
Mit Hilfe von einigen Zeilen PHP kann schnell ein Berechtigungsobjekt einer Rolle zugewiesen werden, beispielsweise in beim Aktivieren des Theme wie folgt.

function my_new_object() {
	global $wp_roles;

	$wp_roles->add_cap('administrator', 'MyObject');
}

// start an activation theme
if ( is_admin() && isset($_GET['activated'] ) && $pagenow == 'themes.php' )
	my_new_object();

Das Objekt kann dann einfach via Standard angefragt werden.
if ( current_user_can('MyObject') )

Alternativ kann man natürlich auch neue Rollen anlegen: add_role('Neue_Rolle', 'Neuer Name der Rolle');. Die Funktion erlaubt auch das gleichzeitige übernehmen von Rechten, dazu steht der dritte optionale Parameter bereit, der mehrere Werte in einem Array erwartet. Ansonsten die Objekte via add_cap() hinzufügen.

Das ist nur ein kleiner Ansatz, viele Möglichkeiten ergeben sich - viel Erfolg beim Nutzen der Möglichkeiten.

Ab WordPress 3.0

Ab der Version 3.0 geht das alles ein wenig einfacher und es gibt eine Funktion für das Formular um den User das Einloggen zu ermöglichen. Folgende Parameter sind möglich.

wp_login_form(array(
    'echo' => true,
    'redirect' => site_url($_SERVER['REQUEST_URI']), 
    'form_id' => 'loginform',
    'label_username' => __('Username'),
    'label_password' => __('Password'),
    'label_remember' => __('Remember Me'),
    'label_log_in' => __('Log In'),
    'id_username' => 'user_login',
    'id_password' => 'user_pass',
    'id_remember' => 'rememberme',
    'id_submit' => 'wp-submit',
    'remember' => true,
    'value_username' => ,
    'value_remember' => false
));

Damit könnte ein Login wie folgt aussehen:

global $user_login;

if (is_user_logged_in()) {
    echo __( 'Hello', FB_BASIS_TEXTDOMAIN ) . $user_login . '<a href="' . wp_logout_url() . '" title="' . __( 'Logout', FB_BASIS_TEXTDOMAIN ) . '">' . __( 'Logout', FB_BASIS_TEXTDOMAIN ) . '</a>';
} else {
    wp_login_form();
}

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Mit Hilfe der benutzerdefinierten Felder

Im ersten Fall soll die Lösung mit Hilfe eines benutzerdefinierten Feldes dargestellt werden, dabei müssen die Daten in diesem Feld zu einem Schlüssel gepflegt werden.

In Version 1 wird zum Schlüssel authorlink der Wert des Autors gespeichert, so ist, so hoffe ich, die Nutzung der Felder leicht zu verstehen. Weitere Infos dazu findet man im Codex.

Version 1

Die Ausgabe zum Schlüssel wird mir Hilfe des Template Tag get_post_meta() übergeben. Die Funktion erwartet die Id des Beitrags und den Schlüssel als Pflichtwert, alternativ kann übergeben werden, ob ein Wert oder auch Arrays als Rückgabe erlaubt sind. Setze auf true und es kommt nur ein String zurück.

/**
 * @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>Foto von <a href="<?php echo get_post_meta($post->ID, $key, true); ?>"></a>.</p>

Im nächsten Schritt ist das im Grunde nichts anderes, nur dass wir nun als Wert zu einem anderen Schlüssel die Adresse ablegen, wo das Bild liegt. Dazu muss der Autor die Adresse wissen und die URL speichern.

In Version 2 gehen wir aber einen Schritt weiter und legen eine Funktion in der functions.php ab, die sich später darum kümmert und die wir mit Daten füttern können. Auch dies ist nur ein Beispiel und braucht in der Version den Schlüssel des benutzerdefinierten Feldes, die Breite und Höhe des Bildes. Diese drei Beispielwerte schreiben wir dann in den Tag zur Ausgabe des Bildes.

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;
	}
}

Die Ausgabe im Template ist durch die obige Funktion dann wie folgt.

<?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 } ?>

Damit kann man einige schöne Sachen machen und je nach Kenntnis umsetzen. Viele Theme-Autoren möchten aber einfach ein Bild zum Beitrag haben, was direkt an diversen Stellen gezogen wird und eventuell keine Verwendung im Inhalt des Beitrags hat. Oft wird dies über die obige Lösung realisiert. Dies sorgt aber dafür, dass die Autoren der Beiträge die Felder kennen und pflegen müssen, also Schlüssel des Feldes und URL zum Bild.

Nicht sehr komfortabel und daher möchte ich eine Lösung zeigen, wie man an das Bild kommt, welches zum Beitrag hoch geladen wurde, welches man quasi in der Gallery zum Beitrag wieder findet.

WordPress eigene Funktionen für Bilder

Eine der vielen Möglichkeiten ist die Funktion wp_get_attachment_image(), welche aus meiner Sicht die einfachste Lösung darstellt. Dazu ein Beispiel, was es näher erklärt.

Zu erst holen wir einfach mal alle Bilder, nicht alle Attachments zum Beitrag, die man direkt zum Beitrag hoch geladen hat. Diese Bilder lassen wir direkt ausgeben. Die Syntax muss immer im Loop sein.

<?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);
} ?>

Zur Erklärung ist zu sagen, dass in dem obigen Beispiel über die Schleife alle Bilder geladen werden und direkt ausgegeben werden. Dabei kümmern wir uns aktuell nicht um die Größe des Bildes, es wird im Standard das Thumbnail ausgegeben. Durch die Festlegung post_mime_type = image, werden auch wirklich nur Bilder geholt und nicht noch andere Anhänge zum Beitrag.
Die Funktion von WordPress, welches uns dann das Bild mit dem HTML ausgibt, benötigt zwingend die ID des Attachment, daher muss im Vorfeld diese ID zum Beitrag geholt werden, erledigen wir mit get_children().

Einige Worte nun zur Funktion wp_get_attachment_image() von WP zum Ausgaben des Bildes. Wie schon angesprochen, es gibt mehrere Funktionen, alle haben einen ähnlichen Aufbau und geben entweder anderes Markup zurück oder lassen andere Parameter zu. Zur einfache Ausgabe eignet sich diese Funktion am besten. Sie ist auch im Codex beschrieben.

Die Funktion lässt 3 Parameter zu:

/**
 * 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)

Zurück bekommt man das Markup zum img-Tag, wie das folgende Beispiel.

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

Der letzte der drei Parameter ist im Zusammenhang mit Bildern eigentlich wenig interessant, da er ein Icon ausgibt. Aber der zweite Parameter ist da schon spannender, denn dieser lässt die Übergabe der Größe des Bildes zu. Dabei kann man entweder einer der vorkonfigurierten Größen mitgeben, quasi die Größen, die WP in den Einstellungen konfigurieren lässt und die beim Upload über die Mediathek angelegt werden. Folgende Möglichkeiten stehen zur Verfügung.

• Standard-Werte: thumbnail, medium, large oder full
• Eigene Größen via Array: array( Breite, Höhe ) Bsp.: array(100, 100)

Wenn man eigene Werte übergibt, dann zieht WordPress in Abhängigkeit dieser Werte das jeweils passende Bild. Also wenn man bspw. 100x100 übergibt und die Thumbnails sind 150px150px, dann werden diese Bilder dafür gezogen und bei einem eigenen Array von 200x200 wird dann das Medium-Bild gezogen, da das Thumbnail zu klein wäre.

<?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) );
} ?>

Bilder mit Links

Nun will aber nicht immer nur die Bilder zum Beitrag, sondern eventuell das Bild mit einem Link zum Bild in Originalgröße haben. Auch dazu gibt es eine Funktion wp_get_attachment_link() und man muss das Markup nicht zusammen stellen. Beispielsweise könnte die Nutzung der Funktion analog der obigen Beschreibung aussehen.

<?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' );
} ?>

Das HTML sieht dann wie folgt aus.

<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>

Damit wird das Bild in der angeforderten Größe ausgegeben und der Link zum Bild in Originalgröße gesetzt.

Größe der Bilder bestimmen

mitunter will man im Vorfeld wissen, wie groß das Bild ist, abhängig von der Übergabe des Typ der Größe. Dazu gibt es eine Funktion, die die Werte als Array zurück gibt. Auch dazu ein Beispiel mit der Ausgabe.

<?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);
} ?>

Diese einfache Schleife zur Ausgabe der Werte gibt ein Array zurück.

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

Die Reihenfolge im Array wird wie folgt zugeordnet.

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

Somit kann auf die Größe reagiert werden, je nach Anforderung. Alternativ kann mit der Funktion image_get_intermediate_size($post_id, $size='thumbnail') gearbeitet werden, die noch einige Werte mehr zurück gibt. Ein Ausgabebeispiel bei der Übergabe 'medium' dazu:

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)

Weitere Funktionen und Möglichkeiten

In diesem Zusammenhang gibt es noch einige weitere Funktion, die die Arbeit mit Anhängen bzw. Bildern zu Beiträgen ermöglichen. Ich möchte nicht jede einzelne erklären und stelle nachfolgend eine kleine Schleife zum Testen zur Verfügung. Damit sind recht viele Möglichkeiten abgedeckt und erklären sich in einem Test sicher selbst.

<?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 des Attachment: ' . apply_filters( 'the_title', $attachment->post_title ) . '<br />';
	echo 'Link zum Beitrag: ' . get_permalink($image->post_parent) . '<br />';
	echo '<hr style="clear:both;" /></p>';
} ?>

Bitte daran denken, die Syntax muss im Loop von WordPress sein.

Nur ein Bild zum Beitrag

Nun habe ich schon einige Punkte zum Holen der Bilder erklärt und in der Regel wird man wohl nicht alle Bilder zum Beitrag benötigen, sondern man möchte ein Bild. Dies findet zum Beispiel Anwendung in Magazin-Themes, wo ein kleines Bild Lust auf den Beitrag machen soll. Durch diese Funktionen kann ich damit dem Autor der jeweiligen Beiträge die Kontrolle über dieses Bild in die Hand geben. In der Regel mache ich das so, das explizit das erste Bild aus der Galerie zum Beitrag gezogen wird. Damit kann der Autor in der Galerie das Bild per Drag&Drop an die richtige Stelle bewegen.

Dies ist keine eigene Funktion, dazu muss die Funktion get_children() entsprechend gefüttert werden. Die Ausgabe des Bildes und andere Werte zum Bild ist dann wieder wie oben beschrieben.

Im ersten Wurf holen wir nur das erste Bild aus der Galerie.

<?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 );
} ?>

Nun kann der Autor des Beitrages immer das erste Bild festlegen, was er nutzen möchte.

Alternativ drehen wir den Spieß um und holen das letzte Bild aus der Galerie.

<?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 );
} ?>

Mit Hilfe von numberposts legen wir fest, wie viele Bilder geholt werden sollen. So holen wir im folgenden Beispiel die ersten 2 Bilder und im Anschluss die letzten 2 Bilder.

<?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'          => 'ASC',
				'orderby'        => 'menu_order ASC'
				) );
foreach ( $attachments as $attachment_id => $attachment ) {
	echo wp_get_attachment_image( $attachment_id );
} ?>

Nun also die letzten beiden Bilder, beginnend mit dem letzten Bild.

<?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-Daten zu Bildern

Nun werden durch WordPress zu den Bildern diverse Meta-Daten gespeichert. Ab und an sind diese sehr nützlich und warum nicht einfach darauf zugreifen und nutzen.

Auch dazu erstmal ein Beispiel um an die Daten zu kommen. Dies machen wir mit der Funktion wp_get_attachment_metadata(). Diese Funktion gibt recht viele Daten zurück und so kann man mit dieser auf die Größe der Bilder, auf deren Pfad und ebenso die Meta-Daten zugreifen.

<?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'];
} ?>

Im obige Code ist zur Ausgabe aller Wert ein var_dump() drin. Damit erkennt man recht schnell, welche Inahtle im Array existieren und an welcher Stelle man zugreifen kann.
Alle Werte der Meta-Daten habe ich beispielhaft in jeweils eine Variable geschrieben, so dass auch nicht so versierte Nutzer damit zurecht kommen sollten.

Bei einem einfachen Bild, was via Handy-Kamera entstanden ist würde beispielsweise das Array wie folgt aussehen.

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 ab WordPress 2.9

Mit WordPress Version 2.9 gibt es einen Template Tag genau für diese Anforderung, damit wird es einfacher und verständlicher. Man nutze einfach die Funktion the_post_thumbnail() und kann die Größe mitgeben. Standard ist thumbnail, möglich ist thumbnail, medium, large oder full.

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

Als kleine Alternative steht noch get_the_post_image() zur Verfügung, wobei die Funktion kein echo hat und optional die ID des Post bekommen kann.
get_the_post_thumbnail( $post_id = NULL, $size = 'post-thumbnail', $attr = '' )

Fazit

WordPress bietet sehr viele unterschiedliche Funktionen um auf Anhänge, ob Bilder oder andere Art ist egal, zuzugreifen. Ebenso wird ein Teil an Meta-Daten gespeichert, die man nutzen kann. Viele Ansätze findet man im Code, vorrangig in der wp-includes/media.php. Vielleicht konnte ich einige Lösungen aufzeigen, leicht ist es nicht. Aber es stellt aus meiner Sicht eine bessere Alternative dar als die Nutzung der Benutzerdefinierten Felder oder gar dem Scannen des Content.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Loop Nr.1

<?php
$do_not_duplicate = array(); // vor den Loops Variable als Array setzen  

// 1. Loop
query_posts('ca=1,2,3&showposts=5');
while ( have_posts() ) : the_post();
    $do_not_duplicate[] = $post->ID; // IDs im Loop merken 
    // Post ausgeben ...
    the_title();
endwhile;
?>

Nach dem nun durch die obige Loop 5 Artikel ausgegeben wurden, haben wir im Array 5 IDs, mit denen wir nun arbeiten können. Im Übrigen kann man sich das Array mit der PHP-Funktion var_dump() anschauen.

In der kommenden Loop Nr.2 sollen nun 15 Beiträge ausgegeben werden, wobei die schon aus Loop Nr. 1 bekannten IDs nicht nochmal erscheinen sollen. Dies könnte sein, wenn Beiträge mehreren Kategorien zugeordnet sind, da beide Loops unterschiedliche Kategorien ausgeben. Ich prüfe nun mit der Funktion in_array(), ob die aktuelle ID $post->ID im Array $do_not_duplicate vorhanden ist. Nur wenn die ID nicht ( !in_array() ) im Array vorhanden, dann wird im Loop Nr. 2 Inhalt ausgegeben.

Loop Nr.2

<?php
// 2. Loop
query_posts( 'cat=4,5,6&showposts=15' );
while (have_posts()) : the_post();
    if ( !in_array( $post->ID, $do_not_duplicate ) ) { // IDs prüfen
        // Post ausgeben ...
        the_title();
    }
endwhile;
?>

Wie so oft, gibt es eine Alternative und dazu stellt WordPress einen Parameter im Query bereit - post__not_in, siehe Codex. Auch diesem Parameter übergebe ich alternativ den Array und in diesem Query sind dann die IDs nicht enthalten. Je nach dem, welchen Weg man geht, stehen damit zwei unterschiedliche Syntax bereit, um doppelten Content zu vermeiden.

<?php
// weiterer Loop ohne Duplikat
query_posts( array(
    'cat' => 456,
    'post__not_in' => $do_not_duplicate 
    )
);
while ( have_posts() ) : the_post();
    // Post ausgeben ...
        the_title();
endwhile;
?>

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

WordPress stellt eine Funktion bereit, die es einfach erlaubt, das Suchformular zu nutzen: get_search_form(). Ist genauso zu verstehen wie beispielsweise die Template Tags get_sidebar() oder get_header(), die die meisten Themes nutzen. Verfügbar ist die Funktion seit WordPress Version 2.7 und ist zu finden in wp-includes/general-template.php.

HTML-Resultat

Die Ausgabe ohne Veränderung der Funktion sieht dann im HTML wie folgt aus.

<form role="search" method="get" id="searchform" action="http://example.com/">
	<div>
		<label class="screen-reader-text" for="s">' . __('Search for:') . '</label>
		<input type="text" value="" name="s" id="s" />
		<input type="submit" id="searchsubmit" value="Suche" />
	</div>
</form>

Inhalt im Inputfeld

Nun bietet die Funktion einen Hook an, um auf das Suchfeld Einfluss zu nehmen. In diesem Beispiel soll der Text im Suchfeld beeinflusst werden, so dass der User eine Info dort vorfindet.
Dies wird über Filter Hook the_search_query realisiert. Innerhalb der Funktion, die an diesen Hook übergeben wird, wird zusätzlich noch geprüft, ob schon ein Wert im Feld steht und wenn dies nicht der Standard-Wert ist, sondern zum Beispiel der zurückgegeben Wert aus der Suche, dann wird nicht der Wert im Suchfeld gesetzt, sondern unverändert gelassen.
Diese Funktion gehört klassisch in die functions.php des Themes und kann natürlich an die eigenen Bedürfnisse angepasst werden.

function fb_get_search_query() {
	$return = stripslashes( get_query_var( 's' ) );
	if ( $return == '' )
		$return = __( 'Hier Suchbegriff eingeben...', FB_BASIS_TEXTDOMAIN );
	else
		$return = apply_filters( 'get_search_query', $return );
	
	return $return;
}
add_filter( 'the_search_query', 'fb_get_search_query' );

Suchfeld und eigene Bedürfnisse

Nun ist das Suchformular aber eventuell nicht immer, wie man sich das wünscht und daher bietet es sich an, ein eigenes Suchfeld zu erstellen und zu nutzen. Um dabei aber die Möglichkeiten von WordPress weiterhin anzubieten, ist es sinnvoll, auch diese Möglichkeit als Funktion oder auch Template mit dem Namen searchform.php, siehe nähere Infos weiter unten, im Theme einzubinden und die Hooks mit vorzusehen. So können eventuell genutzte Plugins darauf zugreifen. Auch dazu ein kleines Beispiel, bei dem als Veränderung eine kleine JavaScript-Funktion eingebunden werden soll.

Als erstes die Funktion für die functions.php des Themes.

function fb_get_search_form() {
	do_action( 'get_search_form' );

	$form = '<form method="get" id="searchform" action="' . get_option('home') . '/" >
	<div><label class="screen-reader-text" for="s">' . __('Search for:') . '</label>
	<input type="text" value="' . esc_attr(apply_filters('the_search_query', get_search_query())) . '" name="s" id="s" onfocus="clearSearch();" />
	<input type="submit" id="searchsubmit" value="'. esc_attr__('Search') .'" />
	</div>
	</form>';

	echo apply_filters('get_search_form', $form);
}

Die Funktion ernthält den schon oben angesprochenen Hook the_search_query und außerdem die Erweiterung des JavaScript onfocus="clearSearch();". Dies kleine Funktion sorgt nur dafür, dass der Inhalt des Suchfeldes gelöscht wird, wenn man in die Box klickt. Wobei ich den Inhalt prüfe und nur dann lösche, wenn der Inhalt explizit dem vorgegebenen Syntax Hier Suchbegriff eingeben... entspricht.

function clearSearch() {
	queryBox = document.getElementById('s');

	if ( queryBox.value == 'Hier Suchbegriff eingeben...' ) {
		queryBox.value = '';
	}
	queryBox.style.color = '#292929';
}

Das kleine Script ist in einer Datei abgelegt und wird ebenfalls aus der functions.php des Themes geladen. Dazu dient der folgende Aufruf; nähere Infos zur Funktion wp_enqueue_script finet ihr beispielsweise im Artikel JavaScript-Bibliotheken in und aus WordPress nutzen.
wp_enqueue_script( 'fb_scripts', get_bloginfo('template_directory') . '/js/script.js', '', '', true );


Alternativ eine Lösung mit Hilfe von jQuery

$(document).ready(function() {  
$("input#s").val("Enter your search text here");  
   textFill($('input.text1'));  
});  
    function textFill(input){ //input focus text function  
    var originalvalue = input.val();  
    input.focus( function(){  
        if( $.trim(input.val()) == originalvalue ){ input.val(''); }  
    });  
    input.blur( function(){  
        if( $.trim(input.val()) == '' ){ input.val(originalvalue); }  
    });  
} 

Das Template searchform.php

Natürlich besteht auch weiterhin die Möglichkeit extra ein Template für das Suchformular anzulegen. Dabei sucht WordPress nach dem Template searchform.php im Theme. Dabei sucht WordPress im ersten Schritt nach diesem Template, wird dies nicht gefunden, dann wird seit Version 2.7 von WordPress das Formular aus dem Template Tag get_search_form() genutzt.

Welchen Weg man geht, das ist sicher von der Arbeitsweise und Gewohnheit abhängig, aber damit ist ein Standard vorhanden, der einfach als Template Tag zur Verfügung steht und es kann bei nicht sonderlich ausgefallenen Anwendungen ein Template gespart werden.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Die folgende kleine Funktion, abgelegt als Plugin oder in der functions.php des Themes, gibt Beiträge in Abhängigkeit der Kategorie aus. Die Funktion lässt drei Parameter zu:

• $limit (int) Anzahl der auszugebenden Beiträge
• $catName (bool) Kategoriename ausgeben, TRUE oder FALSE
• $title (string) String für einen Text über allen auszugebenden Beiträgen

Sie hat keine direkte Ausgabe, so dass man die Inhalte auch übergeben kann. Will man sie im einfachsten Fall in einem Template einsetzen, zum Beispiel im Sidebar, dann die sidebar.php, ist folgende Syntax aufzurufen: echo fb_cat_related_posts();.

function fb_get_cat_related_posts( $limit = 5, $catName = TRUE, $title = '<h3>Recent Pages</h3>' ) {
	
	if ( !is_single() ) // nur bei Beiträgen eine Ausgabe, kann angepasst/gelöscht werden
		return;
	
	$limit = (int) $limit;
	$output  = '';
	$output .= $title;
	
	$category = get_the_category();
	$category = (int) $category[0]->cat_ID;
	
	if ( $catName )
		$output .= __( 'Kategorie: ' ) . get_cat_name($category) . ' ';
	
	$output .= '<ul>';
	
	$args = array(
		'numberposts' => $limit,
		'category' => $category,
	); 
	
	$recentposts = get_posts( $args );
	foreach($recentposts as $post) {
		setup_postdata($post);
		$output .= '<li><a href="' . get_permalink($post->ID) . '">' . get_the_title($post->ID) . '</a></li>';
	}
	
	$output .= '</ul>';
	
	return $output;
}

Die Funktion stellt nur eine Basis dar und kann natürlich beliebig erweitert werden. Ebenso könnte man diverse Abfragen integrieren, so dass wenn es keine Artikel gibt, auch keine Überschrift ausgegeben wird.
Aktuell werden auch die Beiträge der Unterkategorien gelistet.

Viel Spass damit, vielleicht hat der eine oder andere nützliche Erweiterungen und legt die dann hier in den Kommentaren ab.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

• PHP
• Speichernutzung
• Betriebssystem
• Server
• WordPress Version
• Sprache
• sehr umfangreiche Definitionen von diversen Konstanten
• Cookie Definitionen
• Dateirechte
• Eigene User- und Usermeta-Tabellen
• FTP- und SSH Definitionen
• Query informationen
• Conditional Tags; wert des Tags
• Theme informationen
• Template informationen
• Cache inhalte
• Hooks und Filter
• Funktionen, die auf Hooks und Filter ansprechen
• inhalte von Arrays zu Hooks und Filtern
• alle definierten Konstanten

Das Plugin kann mit meinem Plugin Debug Queries zusammen arbeiten und damit die Analyse und Optimierung des Blog genutzt werden. Debug Queries wird in die Ausleitung integriert und ist auch nur für User mit den entsprechenden Rechten möglich. Damit kann die Analyse und Optimierung der Performance an WordPress verbessert werden.

Das Plugin filtert keinerlei Werte und sollte nur zur Information und Optimierung eingesetzt werden, es ist nicht im Livebetrieb des Blog empfohlen. Für Entwickler kann es schnell Daten liefern, die die Einsatz in einer Entwicklungsumgebung befürworten.

Beispielscreenshot des ersten Tab

Download:

Ist die Arbeit nicht 1 Euro wert?
Jede Spende wird dankbar angenommen und ermöglicht das weitere Arbeiten an freier Software.
Möchtest du mehr oder anders spenden, so besuche meine Wunschliste.

Der Download ist im offiziellen Repository von WP zu finden: wordpress.org/extend/plugins/debug-objects/ oder nutzt den Installer direkt im Administrationsbereich von WordPress

Historie

Seit geraumer Zeit bietet das WordPress Plugin Repository die Möglichkeit der Ausgabe des Changelog an und so werde ich direkt am Plugin, in der Readme die Historie pflegen - daher bitte ich, dass ihr euch dort die Änderungen anschaut, so dass ich ein wenig hier pflegen muss: Changelog.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Um die Möglichkeit der Hooks zu nutzen, kann man die gleiche Funktion wie WordPress (do_action()) einsetzen und muss sich nicht eigene Funktionen oder Methoden erstellen.

In der folgenden Beispiel-Funktion, welche ich beim Theme in der functions.php ablege, meines Footer my_footer() wird ein Hook definiert mit Hilfe der Funktion do_action(). Dieser kann nun genutzt werden und das einhaken ist von Außen möglich.

function my_footer() {
    do_action('my_footer');
}

Die eigentliche Funktion rufen ich im Template des Theme auf, in diesem Fall natürlich in der footer.php des Themes, im Beispiel direkt vor dem schließenden body-Tag.

<?php my_footer(); ?>

</body>
</html>

Nun möchte ich bei einem Plugin oder einer beliebigen Funktion im Theme auf diesen Bereich zugreifen und hake mich dort ein. Dazu schreibe ich meine eigene Funktion, zum Beispiel eine Funktion um die ganzen Code-Schnipsel für die Statistik-Tools zu hinterlegen und lege diese Schnipsel in dieser einen Funktion ab. Diese neue Funktion nenne ich example_function(). Um nun diese Funktion an der betreffenden Stelle meines Hooks einzuhaken, muss ich lediglich die klassische Hook-Funktionalität von WordPress nutzen. Mit Hilfe von add_action() wähle ich also den Hook, der es sein soll und übergebe die Funktion, die ich erstellt habe. Im Anschluss gebe ich noch einen dritten Parameter mit, der mir die Priorität des Einhaken gewährleistet, was nicht zwingend ist. Der Standard-Wert für die Priorität ist 10 und hat hier weiter keinen Einfluss, da ich bisher nur diese eine Funktion via Hook anspreche.

add_action('my_footer', 'example_function', 1);

Um das Verständnis der Priorität besser zu verstehen, erstellen wir eine weitere Funktion, die mir weiteren Inhalt an die Stelle meines Hook bringt und haken diesen Funktion example_function_2() ebenso ein, aber mit einer niedrigeren Priorität als die erste Funktion und damit wird sie nach der Funktion example_function() gehakt.

add_action('my_footer', 'example_function_2', 2);

Nicht selten können mit Hilfe dieser Möglichkeit sehr saubere Lösungen geschaffen werden und so ist es vielleicht für den einen oder anderen Leser nützlich. Gerade viele kleine Code-Schnipsel, die man im Footer ablegt, können so sauber in eine Funktion ausgelagert werden und je nach Bedarf einfacher deaktiviert werden. gesteuert wird damit alles über Hooks und in der functions.php oder gar einer Options-Seite zum Theme im Backend.
Diese Möglichkeit steht im übrigen in allen WordPress Versionen zur Verfügung, einschließlich der kommenden Version 2.8.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Immer wieder kamen Fragen rein, ob das alte Theme aktualisiert wird und wann - daher hier nun die Info, ich habe einen Stand erreicht, der stabil ist und das Theme ist mit der aktuellen Version 2.7 und der kommenden Version 2.8 von WordPress kompatibel. Ebenso ist es abwärtskompatibel, getestet bis Version 1.5 von WordPress. Daher hier nun offiziell die Freigabe zum Download und Nutzen.

• Projektsite
• SVN Repository mit Diskussionsplattform

Ein Hinweis, das Theme ist kein Framework es ist ein einfaches Theme, welches lediglich die Grundlagen eines Theme enthält und diverse Vorzüge aus meiner Arbeit mir WordPress vereint. Es dient also wirklich dazu, dass man ein Theme für Kunden oder sich selbst erstellt, angepasst auf die Anforderungen. Es bringt keinerlei überflüssiges Markup mit, was man dann nicht braucht und wie bei Frameworks zum Teil üblich, mitschleift. Es soll auch so bleiben, keine Child-Themes oder ähnliches, auch keine Hooks zum komfortablen erweitern mit Code. Ich mag diese Art der Arbeit, schlank und schnell, direkt auf die Aufgabe zugeschnitten und daher kann ich mich nicht sonderlich mit Frameworks im WordPress-Theme-Sektor anfreunden; heißt aber nicht, dass andere Entwickler das auch tun sollten!

Wenn euch diese Arbeit liegt und ihr ebenfalls das Theme in erster Linie selbst schreibt, dann steht euch damit eine Grundlage bereit. Durch die Verwaltung im SVN steht euch ebenso eine Möglichkeit zur Verfügung Fehler und Hinweise zu melden, worüber ich mich sehr freuen würde.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Die neue Version bringt viele neue Sachen, fixt eine große Anzahl von Problemen und WordPress gestaltet sich aus meiner Sicht noch offener als in den Versionen zu vor. Eine der Punkte, die Benutzer beachten sollten, ist die Tatsache, dass man die Option für die Unterstützung der my-hacks.php entfernt. 2003 wurde diese Datei noch als Feature angekündigt, geht sie nun wieder still und leise. WordPress hat ein ausgefeiltes Schnittstellen-System; man kann an diversen Punkten ansetzen und neue Funktionalitäten einbringen, so dass man sich dazu entschieden hat, die Lösung nicht mehr zu unterstützen. Alternativen und Möglichkeiten des weiteren Nutzen will hier kurz aufzeigen.

my-hacks.php weiter nutzen

Die Datei mit eigenen Erweiterungen kann auch in 2.8 weiter genutzt werden, sie wird nur nicht mehr per Option aus dem Backend aktiviert. Will man dies tun, so muss man den Eintrag hack_file in der Tabelle options auf 1 setzen.
Dies geschieht entweder direkt in der Datenbank, beispielsweise über phpMyAdmin oder via Code:

update_option( 'hack_file', 1 );

Alternativ kann man die Option via Plugin wieder in das Backend holen, siehe Beitrag und Plugin-Download bei Schurpsel.

Die Abfrage der Datei ist weiterhin im Core und soll auch so bleiben, auch die Abfrage des Felder in der Datenbank soll bleiben.

// Check for hacks file if the option is enabled
if ( get_option('hack_file') ) {
	if ( file_exists(ABSPATH . 'my-hacks.php') )
		require(ABSPATH . 'my-hacks.php');
}

Damit bleibt alles beim alten, wer das möchte. Die Datei weiterhin im Root (ABSPATH) der Installation ablegen und sie wird gezogen.

Die Überlegung die Datei nicht mehr zu unterstützen ist natürlich mit Überlegungen verbunden und da WordPress ausgezeichnete Schnittstellen bietet, ist die Unterstützung nicht mehr als relevant angesehen. Außerdem wird die Datei recht früh gezogen und lässt sich damit nicht immer so sauber steuern, wie man das von anderen Schnittstellen kennt. Eine Prüfung auf Intoleranzen und Probleme ist garnicht vorhanden und die Datei kann auch das System bremsen.

via Plugin

Eine der Schnittstellen ist die Plugin-Schnittstelle und daher bietet es sich an, dass man sich ein Plugin anlegt, in dem man die kleinen Hacks ablegt. Entweder man lernt wie das geht, zum Beispiel in meinem kleinen Tutorial zum Plugin schreiben oder hier die Vorlage.

Einfach eine PHP-Datei anlegen und folgenden Syntax rein, dann die eigenen Hacks dort ablegen und die Datei in das Plugin-Verzeichnis kopieren. Im Backend muss es dann nur noch aktiviert werden.

<?php
/*
Plugin Name: my-hacks.php
Plugin URI: http://
Description: my-hacks.php - Ersatz seit WordPress 2.8
Author: DU
Version: 0.1
Author URI: http://
*/

/**
 * hier die Hacks ablegen
 */

?>

Theme-Funktionen

Das aktive Theme kann immer eigene Funktionen hinzubringen, dazu wird die Datei functions.php genutzt und die kann jedem Theme hinzugefügt werden. Gedacht ist sie, um explizit für das jeweilige Theme, neue Funktionen einzubringen. Daher kann man auch die Hacks dort ablegen, also einfach in die functions.php des Themes schreiben, hochladen in den Theme-Ordner und fertig.

Alternative Sprachordner

Ein dritte Möglichkeit um eigene Funktionen einzubringen ist der Sprachordner, im Standard ist das /wp-content/languages/; wp-content kann seit Version 2.5 verschoben und umbenannt werden. Wenn ein Sprachschlüssel in der wp-config.php gesetzt ist, zum Beispiel de_DE, dann wird durch WordPress in dem Ordner nach einer Sprachdatei .mo- und einer .php-Datei gesucht und wenn vorhanden, gezogen.

define ('WPLANG', 'de_DE');

/**
 * The locale of the blog
 * @since 1.5.0
 */
$locale = get_locale();
$locale_file = WP_LANG_DIR . "/$locale.php";
if ( is_readable($locale_file) )
	require_once($locale_file);

/**
 * Loads the theme's translated strings.
 *
 * If the current locale exists as a .mo file in the theme's root directory, it
 * will be included in the translated strings by the $domain.
 *
 * The .mo files must be named based on the locale exactly.
 *
 * @since 1.5.0
 *
 * @param string $domain Unique identifier for retrieving translated strings
 */
function load_theme_textdomain($domain, $path = false) {
	$locale = get_locale();

	$path = ( empty( $path ) ) ? get_template_directory() : $path;

	$mofile = "$path/$locale.mo";
	load_textdomain($domain, $mofile);
}

Dies sollte natürlich nur für Hacks und Funktionen genutzt werden, die mit der Sprache des Blog zu tun haben und nicht missbraucht werden. Im Grunde kann man aber auch dort Funktionen ablegen. Diese Möglichkeit ist vor allem sehr gut geeignet und sprachtypische Funktionen abzulegen, wie zum Beispiel das die URL bei Permalinks sauber übergeben wird (ue statt u bei ü etc.).

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Alternativ kann man diesen Hook aber auch zu anderen Sachen benutzen. Auch dazu möchte ich hier einige Worte verlieren.

Der Hook posts_where ist eine wichtige Möglichkeit um auf den Query von WordPress Einfluss zu nehmen und daher ein Bestandteil des Query: $where = apply_filters('posts_where', $where);. Er dient beispielsweise dazu, den Query von WordPress zu erweitern. Dabei wird immer ein Parameter übergeben. Dieser kann mit jede Art von SQL-Anweisungen befüllt werden.

Ein bekanntes Beispiel ist eventuell mein Artikel zum verspäteten Veröffentlichen von Feeds: „WordPress Feed zeitversetzt befüllen“.

Eine weitere Möglichkeit ist es, wie schon im Eingang angesprochen, dass bei der Ausgabe innerhalb von Kategorien die Unterkategorien nicht gelistet werden sollen. Die folgende Syntax tut genau dies.

if ( !function_exists('fb_filter_child_cats') ) {
	function fb_filter_child_cats( $cats= '' ) { 
		global $wp_query, $wpdb;
	
		if ( is_category() ) {
			
			// get children ID's
			if ( $excludes = get_categories( "child_of=" . $wp_query->get('cat') ) ) {
				
				// set array with ID's
				foreach ( $excludes as $key => $value ) {
					$exclude[] = $value->cat_ID;
				}
			}
			
			// remove child cats
			if ( isset($exclude) && is_array($exclude) ) {
				$cats .= " AND " . $wpdb->prefix . "term_taxonomy.term_id NOT IN (" . implode(",", $exclude) . ") ";
			}
		}
		
		return $cats;
	}
	
	if ( !is_admin() ) {
		add_filter( 'posts_where', 'fb_filter_child_cats' );
	}
}

Um ein stabileres Ergebnis zu erzielen, sollte man möglichst SQL Selects umgehen und damit stabiler in WP zu bleiben. Daher hier eine weitere Lösung für die Filterung der Kinder-Kategorien:

function fb_filter_child_cats($query) {
	
	$cat = get_term_by('name', $query->query_vars['category_name'], 'category');
	$child_cats = (array) get_term_children( &$cat->term_id, 'category' );
	
	if ( !$query->is_admin )
		$query->set( 'category__not_in', array_merge($child_cats) );
	
	return $query;
}
add_filter( 'pre_get_posts', 'fb_filter_child_cats' );

Ein weiteres Beispiel soll zeigen, wie man den Query erweitert. Dabei beziehe ich mich auf einige Fragen aus der WP Hacker Mailingliste, die eigentlich dort nicht hingehören, dazu ist das Forum da.
In die Funktion habe ich mal drei Beispiele integriert.

• Beiträge der Zukunft im Loop
• Seiten im Loop
• Nur Beiträge im Loop, die älter als 5 Tage sind

Ich hoffe, dass die Möglichkeiten damit recht gut dargestellt werden.

if ( !function_exists('fb_filter_where') ) {
	function fb_filter_where( $where = '' ) {
		global $wpdb;
		
		// allow future posts in loop
		$where .= " OR $wpdb->posts.post_status = 'future' ";
		
		// show pages in loop
		$where .= " OR $wpdb->posts.post_type = 'page' ";
		
		// only older (<) as 5 days
		$where .= " AND post_date < '" . date('Y-m-d', strtotime('-5 days')) . "'";
		
		return $where;
	}
	
	if ( !is_admin() ) {
		add_filter( 'posts_where', 'fb_filter_where' );
	}
}

Die Möglichkeiten sind sehr flexibel und im Grunde nur abhängig von den SQL-Abfragen. Damit sollte der Hook ein wenig verständlicher sein und seine vielseitigen Möglichkeiten lassen sich nur annähernd darstellen. Dieser Hook ist nur einer von vielen Hooks, die die Flexibilität von WordPress auszeichnen.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

$output = apply_filters('wp_list_pages', $output);

Diesen machen wir uns zunutze und erweitern den Inhalt um zwei Beispiellinks, die man sonst im Theme händisch ergänzen müsste. Dazu legen wir den folgenden Code-Schnipsel in die functions.php des Themes. Die Tags müssen mit übergeben werden, da der Hook nach der Ausgabe der Liste integriert ist.

if ( !function_exists('fb_add_page_link') ) {
	function fb_add_page_link($output) {
		$output .= '<li><a href="http://example.com/1/">Example 1</a></li>';
		$output .= '<li><a href="http://example.com/2/"><span>Example</span> 2</a></li>';
	
		return $output;
	}
	
	add_filter('wp_list_pages', 'fb_add_page_link');
}

Nun wird die Ausgabe erweitert um die beiden Beispiellinks. Der folgenden HTML-Syntax soll es verdeutlichen.

<li class="pagenav">
	<h3>Seiten</h3>
	<ul>
		<li class="page_item page-item-2"><a href="http://example.com/?page_id=2" title="About">About</a></li>
		<li class="page_item page-item-64"><a href="http://example.com/?page_id=64" title="Default Form">Default Form</a></li>
		<li class="page_item page-item-40"><a href="http://example.com/?page_id=40" title="Offerings">Offerings</a></li>
		<li class="page_item page-item-12"><a href="http://example.com/?page_id=12" title="Page 2">Page 2</a>
			<ul>
				<li class="page_item page-item-14"><a href="http://example.com/?page_id=14" title="Subpage">Subpage</a>
					<ul>
						<li class="page_item page-item-45"><a href="http://example.com/?page_id=45" title="Subsubpage">Subsubpage</a></li>
					</ul>
				</li>
			</ul>
		</li>
		<li class="page_item page-item-16"><a href="http://example.com/?page_id=16" title="Page 3">Page 3</a></li>
	</ul>
</li>

<li><a href="http://example.com/1/">Example 1</a></li>
<li><a href="http://example.com/2/"><span>Example</span> 2</a></li>

Aufpassen, diese Links werden nach Prüfen der Parameter hinzugefügt und sind damit nicht mehr mit Hilfe der Parameter zu entfernen. Setzt man den Template Tag wp_list_pages() also mehrfach mit unterschiedlicher Ausgabe ein, so ist bei allen Ausgaben die Erweiterung dabei. Unterschiede lassen sich dann nicht ohne weiteres gestalten. Auch nicht mit dem zweiten Template Tag für Pages wp_page_menu(). Dieser Template Tag zieht die Inhalte aus aus der Funktion wp_list_pages()!

Als Hinweis sei noch gesagt, dass man den Template Tag wp_page_menu() erst seit WordPress Version 2.7 einsetzen kann. Dieser Tag kann im Grunde nicht viel mehr außer das automatische Hinzufügen eines Home-Link und die Steuerung der Ausgabe (echo), mehr in Beschreibung oder bei Monikas Artikel. Aber die Funktion unterscheidet sich noch in zwei weiteren Fällen und so kann man an zwei Punkten via Filter Hook einhaken und modifizieren.
Zum einen kann man die Argumente erweitern ...

$args = apply_filters( 'wp_page_menu_args', $args );

... und zum anderen das Menu erweitern.

$menu = apply_filters( 'wp_page_menu', $menu, $args );

Und damit kann man doch wieder unterschiedliche Ausgaben realisieren. So ruft der folgende Syntax wieder die beiden Beispiellinks in die zu letzt genannte Funktion wp_page_menu() und damit kommt wp_list_pages() ohne die Erweiterung der beiden Links aus.

add_filter('wp_page_menu', 'fb_add_page_link');

Mit ein wenig Überlegung kann man so also recht flexibel die Ausgabe gestallten und die Autoren mitwirken lassen, wenn es darum geht, automatisch Seiten zu Navigationen hinzuzufügen.

Die Idee ist aufgefallen bei Sivel.net

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren