toscho.design» PHP

WordPress: Headergrafik per Plugin ausblenden

Thomas Scholz — Sat, 30 Jul 2011 05:02:18 +0000

Seit Version 2.9 kann man in WordPress-Themes die internen Funktionen für eine eigene Kopfgrafik nutzen mit der Funktion add_custom_image_header(). Jetzt bekommt der Nutzer des Themes im Backend unter Design/Kopfzeile eine nette kleine Bildverwaltung. Leider fehlt dort die Option, das Bild komplett wegzulassen.

Gute Themes bieten dafür eine Option an, TwentyTen und auch TwentyEleven leider nicht. Die nachträgliche Entfernung ist umständlich, wenn man kein Child-Theme erstellen möchte.

Deshalb habe ich ein kleines Plugin geschrieben, das sowohl das Bild im Frontend entfernt als auch den Menu-Eintrag im Backend.

Plugin Remove Header Image

Wie üblich – es gibt ein mindestens zwei Haken: Wenn im Theme nicht geprüft wird, ob überhaupt ein Bild vorhanden ist, ehe der Container dafür ausgegeben wird, bekommt man eine leere Fläche. Das ist dann eben ein Schrott-Theme. Davon gibt es leider zu viele.
Und die Seite im Backend ist immer noch erreichbar, wenn man die URL dahin kennt. Bilder kann man aber nicht mehr hochladen.

Als Beispiel für den Einsatz in der Praxis sei das Videoblog Drehlog genannt. Dort blogge ich mit ein paar Freunden ab und zu … tja … Videos.

Irgendwie werde ich das Gefühl nicht los, einen leichteren Weg übersehen zu haben … sei’s drum.

WordPress: Internet Explorer ohne CSS-Hacks ansprechen

Thomas Scholz — Tue, 28 Sep 2010 07:43:50 +0000

Den Internet Explorer betrachten die meisten Webentwickler zu Recht als chronische Krankheit. Neben anderen Browsern sieht auch die kommende Version 9 eher bedrückend aus. Ehe wir diesem Browser keine Extrawurst mehr braten müssen, wird noch viel Zeit vergehen.

Um den IE im Stylesheet gesondert anzusprechen, brauchen wir weder Hacks im CSS noch eine zusätzliche Datei oder gar (pfui!) eine serverseitige Browserweiche. Wir müssen nur das Element über Conditional Comments anpassen. Diese Idee hatte Paul Irish schon 2008.

Ich habe das neulich in einem WordPress-Theme eingesetzt und mag es so sehr, daß ich künftig all meine Themes damit ausrüsten werde.
Ein wenig umständlich: Die Sprachattribute werden in WordPress mit der Funktion language_attributes() erzeugt – und die hat ein fest eingebautes echo, das man nicht abschalten kann. Ich will nun nicht drei Meter Code in der header.php stehen haben, deshalb habe ich mir zwei kleine Funktionen gebaut. Die Funktion get_language_attributes() ist obendrein etwas schlanker als das Original, und sie gibt das Attribut dir nur aus, wenn der Text von rechts nach links läuft. Andernfalls ist es an dieser Stelle überflüssig.

Doch zum Code, er gehört in die functions.php:

/**
 * html5 start tag + language attribute + conditional tags for IE Win
 * @link   http://paulirish.com/?p=88
 * @param  bool $print
 * @return void|string
 */
function htmlstart($print = TRUE)
{
    $out  = '';
    $lang = get_language_attributes();
    $ies  = array (
        6 => 'lte6 lte7 lte8'
    ,   7 => 'lte7 lte8'
    ,   8 => 'lte8'
    ,   9 => ''
    );

    foreach ( $ies as $n => $class )
    {
        $out .= "";
    }

    $out .= "$lang>";

    if ( ! $print )
    {
        return $out;
    }

    print $out;
}

if ( ! function_exists('get_language_attributes') )
{
    /**
     * Returns the language attributes.
     *
     * Unobstrusive copy from the core.
     * Requires WP 3.0+
     *
     * @param string $doctype The type of html document (xhtml|html).
     */
    function get_language_attributes($doctype = 'html') {
        $output = is_rtl() ? 'dir="rtl"' : '';

        if ( $lang = get_bloginfo('language') )
        {
            $output .= ( ( get_option('html_type') != 'text/html'
                || $doctype == 'xhtml' )
                ? ' xml:' : '') . 'lang="' . $lang . '"';
        }

        return apply_filters('language_attributes', $output);
    }
}

Im Theme rufen wir die Funktion dort auf, wo früher die Doctype-Deklaration und das Start-Tag standen.
Die Ausgabe sieht (hier aufgehübscht) etwa so aus:







    "de-DE">

Nein, das ist kein sehr schönes Markup mehr. Aber so richtig schlimmes auch nicht. Obendrein validiert es.

Im Stylesheet können wir den Internet Explorer jetzt ganz einfach mit der passenden Klasse ansprechen:

.ie8
{
    top:        10px;
}
.lte7
{
    top:        15px;
}

Das kann ich mir viel besser merken als Kommentarhacks oder Spielereien mit ungültigen Selektoren und Eigenschaften.

Mehrere Internet Explorer auf einem Windows kann man sich mit der Utilo IE Collection einrichten. Zum Testen der Conditional Comments habe ich im Labor eine kleine Seite eingerichtet: CC-Test.

WordPress: Sprache der Ausgabe einstellen

Thomas Scholz — Mon, 02 Aug 2010 17:00:52 +0000

Meine Sprache

Ich bin kein viel versprechendes Talent. Aber ein vielversprechendes … nun, lassen wir das. Will sagen: Mich hat die Reform der deutschen Rechtschreibung im Jahre 1996 nicht überzeugt. Die Reformen der Reform ebensowenig. Deshalb halte ich mich heute überwiegend an die klassische Orthographie, die seit dem letzten amtlichen Eingriff 1901 ganz allmählich durch den allgemeinen Sprachgebrauch entwickelt wurde.
Und gerade weil ich den Gedanken einer organischen Entwicklung so mag, halte ich mich nicht immer genau an die Regeln von 1995: Ich übertrete sie, wenn mein Sprachgefühl mir dazu rät.

Im Großen aber muß ich meine Sprache für Maschinen als de-DE-1901 kennzeichnen — der RFC 3066 verlangt es so.

Sprachausgabe in WordPress

In WordPress wird die Sprache des Blogs in der Datei wp-config.php angegeben:

define ('WPLANG', 'de_DE');

Dann holt sich das CMS automagisch die passende Sprachdatei namens de_DE.mo. Deshalb bringt es mir nichts, die präzise Sprache in der wp-config.php zu setzen: Eine Datei de_DE_1901.mo existiert ja leider nicht, und ich möchte auch nicht nach jeder Aktualisierung den Dateinamen hinterherrennen müssen.

Macht nichts.

In der Ausgabe für den Leser, im Frontend also, wird die Sprache nur an zwei Stellen angegeben: Im lang-Attribut des Elementes html:

"de-DE-1901">

Und im Feed, beispielsweise in der Datei /wp-includes/feed-atom.php:

xml:lang="'rss_language'); ?>"

Im Theme kann man diese Angabe entweder konkret in den Code schreiben oder die Funktion language_attributes() verwenden:

Diese Funktion gibt die Schreibrichtung und die Sprache aus. Da ltr der Standardwert für das Attribut dir ist, kann das hier weggefiltert werden.

Die beiden Filter, die wir ansprechen müssen, lauten 'language_attributes' und 'pre_option_rss_language'.

Code zum Anpassen

Ich habe mir dafür eine kleine Klasse geschrieben, die ich in der functions.php des Themes einfach per require aufrufe:

Download class.Toscho_Language_Filter.php

/**
 * Adjust the public visible language declarations.
 *
 * @author "Thomas Scholz" http://toscho.de
 * @version 1.0
 */
class Toscho_Language_Filter
{
    /**
     * @var string
     */
    public static $lang = 'de';

    /**
     * Pseudo constructor.
     *
     * @param  string $lang The language according to …
     * @link   http://www.evertype.com/standards/iso639/iana-lang-assignments.html
     * @return void
     */
    public static function setup($lang = 'de-DE-1901')
    {
        self::$lang = $lang;

        add_filter(
            'language_attributes'
        ,   array ( __CLASS__, 'html' )
        );
        add_filter(
            'pre_option_rss_language'
        ,   array ( __CLASS__, 'get_lang' )
        );
    }

    /**
     * Returns the language string.
     * @return string
     */
    public static function get_lang()
    {
        return self::$lang;
    }

    /**
     * Output for language_attributes().
     * We drop the 'dir' attribute.
     *
     * @return string
     */
    public static function html()
    {
        return 'lang="' . self::$lang . '"';
    }

}
// Adjust this to your needs.
Toscho_Language_Filter::setup('de-DE-1901');

Wer mag, kann die Funktion setup() auch mit einer eigenen Kreation aufrufen. Dann muß man ein -x- davorsetzen, wie Ian Hickson das in den Spezifikationen zu HTML5 macht: lang="en-US-x-hixie".
Über den Nutzen möchte ich lieber nicht diskutieren.

Mehr davon

WordPress als CMS: Hilfreiche Plugins

Thomas Scholz — Mon, 21 Jun 2010 08:44:42 +0000

Es gibt noch mehr als Fußball, ja! Nämlich … WordPress … ähm.
Cindy bittet, man möge seine Plugins vorstellen. Da mach ich mal mit.
Bei dieser Auswahl habe ich mich an zwei Punkten orientiert: Die Plugins sollten noch nicht allzu bekannt sein und den Einsatz WordPress’ als CMS unterstützen. Wer also mit mehreren Autoren arbeitet oder einfach deutlich mehr als ein Blog braucht, findet hier hoffentlich etwas Neues.

Cleverness To-Do List

Cindy M. Kendrick · Pluginseite · Download

Dieses Plugin zeigt offene Aufgaben in einem Dashboard-Widget und auf einer eigenen Seite unter »Werkzeuge«:

Man kann jede Aufgabe einer bestimmten Person zuweisen, die dann per E-Mail informiert wird. Obendrein läßt sich jeder Punkt mit einer Priorität versehen, damit oben steht, was brennt. Die Optionen sind eingedeutscht und mit hilfreichen Links versehen. Vielleicht ein bißchen voll.

Der Code … stinkt. Er verpestet den globalen Namensraum mit Variablen wie $action, $priority oder $id. Meine Güte.
Teste das Plugin erst lokal mit allen anderen Plugins, die du verwendest.

Das Plugin räumt sauber auf: Es entsorgt die Optionen und die Aufgabentabelle $wpdb->prefix . 'todolist' bei der Deinstallation.

Projektmanagement en miniature. Hat fast alles, was ich mir in diesem Rahmen wünsche; nur Markup würde ich gerne noch in der Beschreibung zulassen.

Simply Show IDs

Matt Martz · Pluginseite · Download

Jeder Beitrag, jeder Nutzer und jede Kategorie hat in der Datenbank eine eindeutige Nummer, die ID. Diese Nummer braucht man beispielsweise für wp_list_pages() oder den Shortlink. Das Plugin fügt den Listen im Backend eine (abschaltbare) Spalte hinzu, in der die Nummer steht.

Prozeduraler Code, aber nur ein paar Funktionen mit dem Präfix ssid_.

Das dürfte WordPress ruhig gleich von Haus aus mitbringen. Ich würde die Spalte gerne einfacher für normale Autoren abschalten können.

WP Mail from

Tristan Aston · Download

Wenn WordPress eine Mail verschickt, dann vom frei erfundenen Konto wordpress@$hostname aus. Manche Server verweigern jedoch den Versand von nicht existierenden Konten, und auch sonst möchte man vielleicht lieber eine korrekte Adresse verwenden.

Das Plugin bietet die Option, Namen und Adresse zu ändern. Beide Werte werden in separaten Optionen – site_mail_from_email und site_mail_from_name – gespeichert und bei der Deinstallation nicht aufgeräumt.

Der Code ist prozedural, die Funktionsnamen finde ich nicht ausreichend gegen Kollisionen gesichert: site_mail_from() schreit nach Ärger.

So nützlich und so schlampig … das werde ich mal neu fassen und in mein Standard-Mega-Plugin einbauen.

Bulk Password Reset

Ruben Woudsma · Pluginseite · Download

Hiermit kann man die Passwörter aller Nutzer einer Gruppe zurücksetzen. Sehr hilfreich, wenn man ein gehacktes Blog repariert oder vielen Nutzern auf einen Ruck den Zugang erlauben möchte.

Die Optionsseite sieht sehr unbeholfen aus; hier kann man die zu versendende E-Mail anpassen oder ganz verbieten. Ich empfehle dringend, vorher das Plugin WP Mail from zu installieren, damit Antworten der betroffenen Nutzer an eine reale Adresse gehen.
Die Option – immerhin nur ein Array – heißt bpr_options. Die muß man leider manuell löschen, denn das Plugin räumt beim Deinstallieren nicht auf.

Objektorientierter Code, wirft aber Notizen. OOP allein ist eben auch kein Wundermittel.

In manchen Situationen einfach unersetzbar. Die Optionsseite sollte jedem angehenden Pluginautor als warnendes Beispiel dienen: So bitte nicht!

Custom Post Templates

Simon Wheatley · Pluginseite · Download

Für Seiten oder spezielle Archive kennt WordPress schon lange eigene Templates; für Posts jedoch braucht man dieses Plugin.
Ein Template wird durch folgenden Eintrag am Dateianfang gekennzeichnet:

/*
Template Name Posts: Jungtiere
*/

Dann bekommt man beim Schreiben eines Artikels ein Auswahlfeld wie bei den Seiten.

Zusätzlich stellt das Plugin noch eine Funktion is_post_template($template = '') bereit.

Der Code ist sehr sauber, bis auf die is-Funktion objektorientiert. Optionen müssen bei der Deinstallation nicht aufgeräumt werden, denn das Plugin speichert keine. Das zugeordnete Template wird in einem Meta-Key namens custom_post_template gespeichert, und der bleibt erhalten.

Ich will das im Core haben. Es ist nicht einzusehen, warum ein Blogsystem hier Seiten bevorzugt. Der Code könnte einen Tick besser dokumentiert werden … ansonsten ist er die reine Freude.

Vice Versa

Jason Lau · Pluginseite · Download

Mit diesem Plugin kann man eine Seite in einen Artikel wandeln und umgekehrt – daher der Name. Irre praktisch, wenn man Inhalte aus einer statischen Seite in WordPress integriert und der Kunde sich mehrmals umentscheidet. Man kann auch Elternseiten und -kategorien auswählen. Warum der Autor seine Seite unter den »Einstellungen« aufgehängt hat und nicht unter »Werkzeuge«, bleibt sein Geheimnis. Nun, jedes Kunstwerk birgt ein Rätsel …

Der Code freilich treibt einem die Tränen in die Augen: eregi(), massenhaft Inline-Styles, die der Optionsseite gar nicht gut tun, echo-Orgien … das geht besser. Immerhin werden keine dauerhaften Optionen gesetzt; eine Deinstallation verläuft also schmerzlos.

Die Funktion könnte man auch per Datenbankabfrage direkt übernehmen, aber ich bin im Nachhinein doch dankbar, daß ich das nicht tun mußte. Ich wünsche mir hierfür noch die Umwandlung mehrere Einträge auf einen Ruck.

Insgesamt habe ich mit allen hier vorgestellten Plugins gute Erfahrungen gemacht. Besonders Simply Show IDs und Custom Post Templates füllen offensichtliche Lücken. Hätte ich ein echtes Mitspracherecht, so würde ich sie sofort in den Core einbauen – und dafür anderen Schrott entsorgen.

Leider merkt man auch, daß im Pluginverzeichnis niemand darauf achtet, ob ein Plugin sauber geschrieben wurde. Hier ist vielleicht auch die API zu locker. Ein Widget muß einer festen OO-Struktur folgen; ein Plugin jedoch kann jeder schreiben wie er will. Und genau das passiert auch.

WordPress-Tutorial: Eigenes Widget schreiben

Thomas Scholz — Fri, 04 Jun 2010 13:45:14 +0000

Widgets liegen in der WordPress-Architektur irgendwo zwischen Theme und Plugin: Die eigene Funktionalität und das Aussehen sind meistens eng an vorhandenen Code gebunden, doch können sie auch ganz eigenständig erzeugt werden.
Sie lassen sich in Sidebars einbetten; man kann sie aber auch »manuell« im Theme aufrufen mit der Funktion the_widget().

Die Widgets-API ist die einzige, die objektorientiertes Arbeiten erzwingt – deshalb eignet sie sich gut zum Lernen und gefahrlosen Ausprobieren, finde ich.
Themes und Plugins hingegen dürfen komplett prozedural geschrieben werden. Werden sie leider oft auch.

Ein Widget muß die Klasse WP_Widget erweitern. Ein Konstruktor wird für den Aufruf gebraucht und eine Funktion widget() für die Ausgabe. Um den Speicherfresser create_function() zu umgehen, packe ich noch eine Funktion register() dazu. Das sieht im einfachsten Falle so aus:

add_action(
    'widgets_init'
,   array ('Toscho_Mini_Widget', 'register' )
);
class Toscho_Mini_Widget extends WP_Widget
{
    function Toscho_Mini_Widget()
    {
        $this->WP_Widget(__CLASS__, __CLASS__);
    }

    function widget($args, $instance)
    {
        print 'Juhu, hat geklappt!';
    }

    function register()
    {
        register_widget(__CLASS__);
    }
}

Hier müffelt es noch schlimm nach PHP 4. Wenn der Konstruktor nicht wie die Klasse heißt, läuft der Speicher aus … das müssen wir vorerst wohl hinnehmen.

Das Beispiel oben kann im Backend aktiviert werden, wenn es im Theme eingebunden wird und wenn das Theme mindestens eine Sidebar registriert hat.

Es tut natürlich noch nicht viel.

Im nächsten Schritt sehen wir uns mal ein Beispiel an, das wir tatsächlich einsetzen könnten: Wir wollen die letzten Posts auflisten, dabei aber bestimmte Kategorien ausschließen oder zulassen.

Da können wir uns bei der Klasse WP_Widget_Recent_Posts einigen Code abgucken. Die liegt WordPress schon bei in der default-widgets.php.

Wir brauchen zusätzlich noch eine Eingabemaske für die Kategorien, und wir müssen den Query erweitern. Die nötigen Argumente finden wir in der Dokumentation zu query_posts().

Die beiden letzten Funktionen stammen nicht aus der Elternklasse, sondern ich habe sie eingebaut, um den Rest des Codes lesbar zu halten.

Live läuft genau dieses Widget gerade auf der Website der Interessengemeinschaft Britisch Kurzhaar-Katzen links in der Sidebar; hier werden die Jungtiermeldungen ausgeklammert, weil sie schon sehr prominent auf der Startseite präsentiert werden.

add_action(
    'widgets_init'
,   array ('Restricted_Latest_Posts_Widget', 'register' )
);
/**
 * Restricted Recent Posts widget class.
 *
 * Restricts the list of recent posts to selected categories.
 * Derivate of the default widget.
 *
 * @todo Select post types
 * @todo Select taxonomy
 */
class Restricted_Latest_Posts_Widget extends WP_Widget
{
    // Adjust this to your needs.
    var
        $max_posts = 50
    ,   $wid_name  = 'widget_restricted_recent_posts';

    /**
     * Constructor.
     */
    function Restricted_Latest_Posts_Widget()
    {
        $widget_ops = array(
            'classname'   => $this->wid_name
        ,   'description' => 'Letzte Beiträge per Kategorie ausgewählt.
                                Mit Komma trennen.'
        );
        $this->WP_Widget(
            'restricted-recent-posts'
        ,   'Restricted Recent Posts'
        ,   $widget_ops
        );
        $this->alt_option_name = $this->wid_name;

        add_action( 'save_post',
            array(&$this, 'flush_widget_cache') );
        add_action( 'deleted_post',
            array(&$this, 'flush_widget_cache') );
        add_action( 'switch_theme',
            array(&$this, 'flush_widget_cache') );
    }

    /**
     * Called statically to register the widget.
     *
     * @return void.
     */
    function register()
    {
        register_widget(__CLASS__);
    }

    function widget($args, $instance)
    {
        $cache = wp_cache_get($this->wid_name, 'widget');

        if ( ! is_array($cache) )
        {
            $cache = array();
        }

        if ( isset ( $cache[ $args['widget_id'] ] ) )
        {
            echo $cache[ $args['widget_id'] ];
            return;
        }

        ob_start();
        extract($args);

        $title        = empty ( $instance['title'] )
                        ? 'Restricted Recent Posts'
                        : $instance['title'];
        $title        = apply_filters('widget_title', $title);

        $number       = $this->sanitize_number($instance['number']);

        $include_cats = trim($instance['include_cats']);
        $exclude_cats = trim($instance['exclude_cats']);

        $query_args   = array(
            'showposts'        => $number
        ,   'nopaging'         => 0
        ,   'post_status'      => 'publish'
        ,   'caller_get_posts' => 1
        );

        if ( ! empty ( $include_cats ) )
        {
            $query_args['category__in']
                = $this->catlist_to_array($include_cats);
        }
        elseif ( ! empty ( $exclude_cats ) )
        {
            $query_args['category__not_in']
                = $this->catlist_to_array($exclude_cats);
        }

        $r = new WP_Query($query_args);

        if ( $r->have_posts() )
        {
            print $before_widget
                . ( $title
                        ? $before_title . $title . $after_title : ''
                    )
                . '';

            while ( $r->have_posts() )
            {
                $r->the_post();

                print ''
                    . get_the_title() . '
';
            }

            print "$after_widget";

            // Restore global post data stomped by the_post().
            wp_reset_query();
        }

        $cache[ $args['widget_id'] ] = ob_get_flush();

        wp_cache_add($this->wid_name, $cache, 'widget');
    }

    function update( $new_instance, $old_instance )
    {
        $instance                 = $old_instance;
        $instance['title']        = strip_tags($new_instance['title']);
        $instance['number']       =
                $this->sanitize_number($new_instance['number']);
        $instance['exclude_cats'] = $new_instance['exclude_cats'];
        $instance['include_cats'] = $new_instance['include_cats'];

        $this->flush_widget_cache();

        $alloptions = wp_cache_get( 'alloptions', 'options' );

        if ( isset ( $alloptions[$this->wid_name] ) )
        {
            delete_option($this->wid_name);
        }

        return $instance;
    }

    function flush_widget_cache()
    {
        wp_cache_delete($this->wid_name, 'widget');
    }

    function form( $instance )
    {
        $title = isset ( $instance['title'] )
                ? esc_attr($instance['title']) : '';

        if (   ! isset ( $instance['number'])
            || ! $number = (int) $instance['number']
        )
        {
            $number = 5;
        }

        $incats = isset ( $instance['include_cats'] )
            ? esc_attr($instance['include_cats']) : '';
        $excats = isset ( $instance['exclude_cats'] )
            ? esc_attr($instance['exclude_cats']) : '';
        ?>
        
            
                                    _e('Title:');
                ?>
            
            
        

        
            
                Artikelmenge
            
            
            (maximal                 print $this->max_posts;
            ?>)
        

        
            
                Auf Kategorien beschränken:
            
            
            
oder

            
                Kategorien ausschließen:
            
            
        
            }

    /**
     * Guarantee a number between 1 and max_posts.
     *
     * @return int
     */
    function sanitize_number($nr)
    {
        $nr = (int) $nr;

        if ( $nr > $this->max_posts )
        {
            return $this->max_posts;
        }

        if ( 0 == $nr )
        {
            return 1;
        }

        return $nr;
    }

    /**
     * Used by widget() to fill the category parameter.
     *
     * @param string $catlist
     * @return array
     */
    function catlist_to_array($catlist)
    {
        $tmp_cats = explode(',', $catlist);
        $new_cats = array ();

        foreach ( $tmp_cats as $cat )
        {
            $new_cats[] = (int) trim($cat);
        }

        return $new_cats;
    }
}

Zwei mögliche Erweiterungen habe ich im Kopf angedeutet. Wer will es versuchen?

Eine sehr viel umfangreichere Erweiterung der WordPress-internen Widgets liefert Justin Tadlocks Plugin Widgets Reloaded. Sehr praktisch – und von dem sauberen Code kann man eine Menge lernen.

Siehe auch:

WordPress: ID anhand des Titels herausfinden

Thomas Scholz — Tue, 25 May 2010 13:31:25 +0000

Viele Template-Funktionen in WordPress erwarten eine ID als Argument – wp_list_pages() beispielsweise schließt damit einzelne Seiten aus.
Damit ich nun nicht immer suchen muß, habe ich mir einen kleinen Helfer in die Template-Tools gesetzt. Auszug:

/**
 * Toscho’s Template Tools
 *
 * Helpers for WordPress templates.
 *
 * @author  Thomas Scholz 
 * @version 1.1
 *
 */
class TTT
{
    /**
     * Retrieves a post/page/custom-type/taxonomy ID by its title.
     *
     * Returns only the first result. If you search for a post title
     * that you have used more than once, restrict the type.
     * Or don’t use this function. :)
     * Simple usage:
     * $page_start_id = TTT::id_by_title('Start');
     *
     * To get the ID of a taxonomy (category, tag, custom) set $tax
     * to the name of this taxonomy.
     * Example:
     * $cat_css_id = TTT::id_by_title('CSS', 0, 'category');
     *
     * The result is cached internally to save db queries.
     *
     * @param  string      $title
     * @param  string      $type Restrict the type.
     * @param  string|bool $tax Taxonomy to search for.
     * @return int         ID or -1 on failure
     */
    static function id_by_title($title, $type = 'any', $tax = FALSE)
    {
        static $cache = array ();

        $title = mysql_real_escape_string( trim($title, '"\'') );

        // Unique index for the cache.
        $index = "$title-$type-" . ( $tax ? $tax : 0 );

        if ( isset ( $cache[$index] ) )
        {
            return $cache[$index];
        }

        if ( $tax )
        {
            $taxonomy      = get_term_by('name', $title, $tax);
            $cache[$index] = $taxonomy ? $taxonomy->term_id : -1;

            return $cache[$index];
        }

        $type_sql = 'any' == $type
            ? ''
            : "AND post_type = '"
                . mysql_real_escape_string($type) . "'";

        global $wpdb;

        $query = "SELECT ID FROM $wpdb->posts
            WHERE (
                    post_status = 'publish'
                AND post_title = '$title'
                $type_sql
            )
            LIMIT 1";

        $result = $wpdb->get_results($query);
        $cache[$index] = empty ( $result ) ? -1 : (int) $result[0]->ID;

        return $cache[$index];
    }
}

Im praktischen Einsatz sieht das dann so aus:

wp_list_pages(
    array (
        'sort_column'   =>  'menu_order',
        'depth'         =>  1,
        'title_li'      =>  '',
        'exclude'       =>  TTT::id_by_title('Start')
    )
);
?>

Vorsicht: Wenn man einen Titel mehrmals verwendet hat, liefert die Funktion eventuell nicht die ID zurück, die man sich erhofft hat.

Im Backend findet man die meisten IDs übrigens am besten mit Hilfe dieses ungeheuer nützlichen Plugins: Simply Show IDs.

Mehr solches Zeug:

WordPress: Moderationslinks für Kommentare

Thomas Scholz — Thu, 29 Apr 2010 20:58:09 +0000

Trotz des Antispam-Plugins schlüpft auch hier manchmal ein Müllkommentar durch den Filter, oder ich vertippe mich … für diese Fälle bietet WordPress an, Kommentare zu bearbeiten, als Spam zu markieren oder ganz zu löschen. Im Backend.

Das ist mir ein wenig zu umständlich; deshalb habe ich in meiner Klasse ›XWP‹, die zusätzliche Templatetags erzeugt, folgenden kleinen Schnipsel eingebaut, den ich von Joost de Valk abgeguckt habe:

    /* Generates comment moderation links.
     *
     * @author Joost de Valk
     * @link   http://yoast.com/wordpress-functions-supercharge-theme/
     * @param  int $id Comment id - use get_comment_ID()
     * @return void
     */
    public static function delete_comment_link($id)
    {
        if ( ! current_user_can('moderate_comments') )
        {
            return;
        }

        global $post;

        $redirect = get_permalink( $post->ID );

        $links = array (
            'delete'  => 'cdc',
            'spam' => 'cdc&dt=spam',
            'edit' => 'editcomment'
        );

        $return = '';

        foreach ( $links as $name => $param )
        {
            $return .= "$name";
        }

        print $return . '';

        return;
    }

In der comments.php rufe ich die Funktion innerhalb des Kommentarloops auf:

XWP::delete_comment_link( get_comment_ID() );

Das erzeugt etwa dieses Markup:

comment_admin">
  delete
  spam
  edit

Mit ein wenig CSS aufgepeppt …

.comment_admin
    {
        float:              right;
        font:               .9em/1 Calibri;
        text-align:         center;
    }
.comment_admin a
    {
        color:              #444;
        background:         #f9f9f9;
        text-decoration:    none;
        border:             1px solid #bbb;
        border-radius:      4px;
        box-shadow:         0 2px 3px rgba(0,0,0,0.2);
        display:            inline-block;
        width:              3em;
        margin:             4px;
        padding:            4px 15px;
    }
#content .comment_admin a:hover
    {
        background:         #666;
        color:              #fff;
        border:             1px solid #222;
    }

… sieht das Ergebnis dann so aus:

Nach einem Klick landet man in der Bearbeitungsmaske im Backend, dann erst wird der Kommentar per Knopfdruck gelöscht oder als Spam markiert.

Mehr so’n Zeug:

Designlinks 12

Thomas Scholz — Wed, 28 Apr 2010 10:19:33 +0000

Wird mal wieder Zeit. Aber zuerst entspannen wir uns ein bißchen:

Quelle: CollegeHumor.

›Do not use PHP references‹, empfiehlt Johannes Schlüter, denn Referenzen kosten Tempo, Übersicht und Flexibilität. Ob seiner klaren und verständlichen Darstellung dieses kniffligen Themas möchte ich den Artikel jetzt schon in die Liste der zehn besten dieses Jahres rücken.

Nicholas C. Zakas: History of the user-agent string. Warum die UA-Strings heute oft so sonderbar aussehen. Die neue Kennung des IE 9 lautet:

Mozilla/5.0 (compatible, MSIE 9.0; Windows NT 6.1; Trident/5.0)

Anhängsel irgendwelcher Zusatzsoftware werden nicht mehr eingebaut; damit schrumpft die Liste der möglichen Kennungen gewaltig – was es Proxys erheblich erleichtert, gespeicherte Versionen einer Webseite auszuliefern. Das erklärt Billy Hoffman gut in: ›The Big Performance Improvement in IE9 No One is Talking About‹. Er rät auch dazu, die gzip-komprimierte Version nur noch anhand des Accept-Headers zu versenden und den User-Agent zu ignorieren, damit beispielsweise ein Safari-Nutzer die Version bekommt, die der Firefox-Nutzer zuvor in den Proxy gehievt hat.

Man kann dezimale Zeichenreferenzen mit beliebig vielen führenden Nullen versehen. So läßt sich das A als A schreiben oder als A
›hakre‹ hat mal ausprobiert, wie weit man damit gehen kann: ›HTML Entity Boundaries – Zero Padding‹.
Ein Experiment, dessen praktischer Nutzen sicher weit unter seinem Unterhaltungswert liegt. Doch zeigt es, wie weit die Entwickler vorausdenken und wo sie die Grenze ziehen zwischen ›das versuche ich noch‹ und ›das wird zu langsam‹. Wenig überraschend frißt Firefox die meisten Nullen – bis zum Erstickungstod.

Anne van Kesteren hat auch ein Experiment mit gewaltigem Geekpotential hingestellt: Live style sheet editing!
Und da muß ich einfach mal den Quelltext zitieren:



 
  Live style sheet editing!

Zum Schluß noch ein Link für die Freunde der Maus: Harmony, ein Zeichenprogramm in Javascript und Canvas. Das macht wirklich Freude.

WordPress-Plugin: Backend Style Enhancements

Thomas Scholz — Fri, 23 Apr 2010 13:16:12 +0000

Zwar läßt sich das WordPress-Backend ganz gut per Userstylesheet über den Selektor body.wp-admin ansprechen – doch technisch unbedarften Leuten hilft das eher wenig. Für eine Freundin, die ebenso wie ich eine Navigation lieber rechts oder oben sieht, habe ich deshalb mal fix ein kleines Plugin erstellt.

Es ist ganz einfach, spricht aber ein paar Dinge an, die ich im Framebreaker-Tutorial nicht berührt habe. So mag es sich vielleicht als Lehrstück eignen. Ich verkneife mir heute einen langen Text; stattdessen habe ich alles ausführlich kommentiert und verlinkt.

Das Stylesheet selbst setzt die Navigation nach rechts, gibt Links bei :hover einen Unterstrich und entsorgt Lucida Grande und Verdana, die ich beide nicht mehr sehen mag. Außerdem repariert es ein paar Breitenangaben – die Entwickler konnten sich wohl nicht vorstellen, daß jemand 14px als Mindestschriftgröße setzt. Das muß man leider als Massenpsychose diagnostizieren.

Im Ganzen sei es bitte nur als Beispiel dafür gesehen, was man ändern kann.

/*
Plugin Name: Backend Style Enhancements
Plugin URI:  http://toscho.de/p1660
Description: Some minor fixes for the WP backend.
Version:     1.0
Author:      Thomas Scholz
Author URI:  http://toscho.de
Created:     22.04.2010
*/

/**
 * We need just the constructor.
 */
new Toscho_Backend_Style;

/**
 * Adds a stylesheet to the WordPress backend.
 *
 * @version 1.0
 */
class Toscho_Backend_Style
{
    /**
     * The address for our stylesheet.
     * Should match [0-9a-z-].
     *
     * @see #add_query_arg()
     * @see #print_link_element()
     * @var string
     */
    protected $query_arg = 'tbecss';

    /**
     * Constructor
     */
    public function __construct()
    {
        /* Register the query argument. */
        add_filter('query_vars', array ( $this, 'add_query_arg') );

        /* What should happen, if we find the query? */
        add_action('template_redirect', array ( $this, 'print_css') );

        /* Like wp_head, just for the backend. */
        add_action('admin_head', array ( $this, 'print_link_element') );

        /* Since this plugin isn’t listed on
         * http://wordpress.org/extend/plugins/
         * we won’t waste the user’s time.
         */
        add_filter('http_request_args',
            array ( $this, 'prevent_plugin_upgrade_check' ), 5, 2);

        return;
    }

    /**
     * Registers the query arg in WordPress
     *
     * @param  array $vars Already registered query args.
     * @return array
     */
    public function add_query_arg( array $vars )
    {
        return array_merge( $vars, array ( $this->query_arg ) );
    }

    /**
     * Prints the CSS content.
     *
     * @return void
     */
    public function print_css()
    {
        if ( ! isset ( $_GET[$this->query_arg] ) )
        {
            return;
        }

        // Don’t waste time in wp-includes/template-loader.php
        define('WP_USE_THEMES', FALSE);

        header('Content-Type: text/css;charset=utf-8', TRUE);

?>@charset "utf-8";
.wrap a:hover
{
    text-decoration:    underline       !important;
}
.wrap a.button:hover
{
    text-decoration:    none            !important;
}
body,
td,
input,
select,
#adminmenu *
{
    font-family:        Calibri         !important;
}
textarea, [type="text"]
{
    font-family:        Consolas        !important;
}
body,
#wpbody,
.form-table .pre
{
    color:              #000            !important;
}
td
{
    vertical-align:     top             !important;
    line-height:        1.4             !important;
}
#adminmenu
{
    float:              right           !important;
    margin:             5px -150px 0 0 !important;
}
#adminmenu .wp-submenu li
{
    width:              151px           !important;
}
#wpbody-content
{
    float:              right           !important;
    width:              100%;
}
#wpbody
{
    margin-left:        0               !important;
    margin-right:       170px           !important;

}
/* Ugly, yes. But if we just return, WP will
         * proceed and append the default page. */
        exit;
    }

    /**
     * Prints the link element into the admin head.
     *
     * @return void
     */
    public function print_link_element()
    {
        $url = get_option('siteurl') . '/?' . $this->query_arg;
        print "";

        return;
    }

    /**
     * Blocks update checks for this plugin.
     *
     * @author Mark Jaquith http://markjaquith.wordpress.com
     * @see    http://wp.me/p56-65
     * @param  array $r Request information
     * @param  string $url
     * @return array
     */
    public function prevent_plugin_upgrade_check($r, $url)
    {
        if ( 0 !== strpos($url,
             'http://api.wordpress.org/plugins/update-check') )
        { // Not a plugin update request. Bail immediately.
            return $r;
        }

        $plugins = unserialize( $r['body']['plugins'] );
        $p_base  = plugin_basename( __FILE__ );

        unset (
            $plugins->plugins[$p_base],
            $plugins->active[array_search($p_base, $plugins->active)]
        );

        $r['body']['plugins'] = serialize($plugins);

        return $r;
    }
}

Als Lohn für das ~~geduldige Lesen~~ schnelle Herunterscrollen:

Download Plugin Backend Style Enhancements

Meine Kommentare ersetzen natürlich nicht eure Fragen. Also stellt sie bitte!

PHP und Google-Maps: Latitude und Longitude finden

Thomas Scholz — Wed, 21 Apr 2010 20:04:19 +0000

Gerade sitze ich an einem Projekt, für das ich etwa 300 statische Google-Karten erzeugen will.

Nichts gefunden

Hierzu habe ich ebenso viele Adressen zur Hand, die ich einfach der API übergeben könnte, auf daß Google selbst die passende Position finde. Problem: Wenn nichts gefunden wird, erfahre ich das im Script nicht, sondern erst beim Ansehen des Bildes.

Da gebe ich doch lieber kein Bild aus.

Also muß ich erst prüfen, ob Google einen Ort auf der Karte finden kann, indem ich die Ortsangabe in Breiten- und Längengrade (Latitude und Longitude) umwandeln lasse. Danke an Fabian Beiner für den Tipp dazu. Meine Googlekompetenz schien gestern so eingebrochen zu sein, daß ich das nicht selbst herausfinden konnte …

/**
 * Gets the coordinates (latitude and longitude) for a place.
 * Keeps the image URI short.
 * Thanks to Fabian Beiner - http://fabian-beiner.de/ - for the tip.
 *
 * @param  string $place
 * @return string|bool
 */
function coords_by_name($place)
{
    $place   = urlencode($place);
    $url     = "http://maps.google.com/maps/geo?output=xml&q=$place";

    $content = file_get_contents($url);

    // Kein Ergebnis
    if ( FALSE == strpos($content, 'Placemark') )
    {
        return FALSE;
    }

    $xml     = new SimpleXMLElement($content);

    return $xml->Response->Placemark->Point->coordinates[0];
}

Das Ergebnis sieht im Erfolgsfall so aus: "11.9658140,51.4821660,0".

Für die statische Karte brauchen wir die letzte Angabe – ,0 – nicht; obendrein akzeptiert die API nur Angaben mit einer Genauigkeit von sechs Dezimalstellen, nicht sieben. Und wir brauchen die beiden Angaben in umgekehrter Reihenfolge für den Mittelpunkt der Karte. Da hat wohl jemand lange nachgedacht und dann Mist gebaut …

Deshalb habe ich mir einen kleinen Helfer geschrieben:

/**
 * Fixes latitude longitude coordinates.
 *
 * @param  string $s
 * @return bool
 */
function fix_coords($s)
{
    $found = (bool) preg_match(
        "~^(-?\d{1,2}\.\d{0,6})\d?,(-?\d{1,2}\.\d{0,6})\d?~",
        $s, $match
    );

    if ( ! $found )
    {
        return FALSE;
    }

    return $match[2] . ',' . $match[1];
}

Das gibt uns "11.965814,51.482166" aus, und damit können wir eine vernünftige Karte bauen.

Aber Achtung: Die Positionen der Marker muß man in umgekehrter Reihenfolge angeben!

Den aktuellen Zwischenstand habe ich eben mal auf GitHub hochgeladen: class.Google_Static_Map. Der Code wurde mir dann doch ein bißchen zu lang für einen Blogbeitrag. Dort gibt es auch einen Bugtracker für eure Hinweise oder Vorschläge, und wer Code beitragen oder einen Fork anlegen möchte, ist dazu herzlich eingeladen.