toscho.design

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

Kommentare moderieren: Meine Richtlinien

Thomas Scholz — Thu, 01 Jul 2010 11:09:22 +0000

Ich halte die Kommentare in diesem Blog für ebenso wichtig wie meine Artikel. Mag die Diskussion mal das ursprüngliche Thema verlassen – stört mich nicht. Doch wenn sie von Backlinkjunkies zerfasert wird, schreite ich ein.

Den klassischen Spam für Mädels oder Hilfsmittel, um sie zu beeindrucken, fängt der automatische Filter ab. Kein Problem.

Für den Rest habe ich ein paar Kriterien gefunden, die mich zum Löschen bewegen:

Offensichtliche SEO-Namen: Firmen- oder Berufsbezeichnungen, auch als angebliche Namensteile. Das schwimmt natürlich: Kurt Schuster nehme ich noch hin, Klara Modevertrieb hingegen … kann mich mal.
E-Mail-Adressen in der Art pr@example.comn. Solche Leute gibt es tatsächlich. Internetversteher.
Kommentare mit Backlinks auf verdächtige Seiten: Hätte ich dahin freiwillig einen Link gesetzt? Nein? Weg damit! Steck dir deine Spartricks, deine Cycle-Page und dein Spamblog bitte dorthin, wo es wehtut.
Alle paar Wochen schreibt hier auch jemand mit einem wechselnden Frauennamen: Der Inhalt ist gerade so etwas zu lang für Spam und hat gerade so noch einen Bezug zum Artikel. Die verlinkte Website könnte man gerade so noch durchgehen lassen.
Kindchen, ich bin Autor! Ich erkenne dich unter jedem Namen wieder, und wenn ich überhaupt ein Talent habe, dann für das Erkennen von Sprachmustern. Dafür habe ich sogar ein gutes Gedächtnis. Das hätte ich gerne woanders …

Manche Kommentare kennzeichne ich nicht als Spam, aber ich entferne sie zugunsten der allgemeinen Übersicht:

Nackte Ichbotschaften: »Kannte ich noch nicht.«, »Probier ich mal.« und Ähnliches. Benutz’ einen Spiegel.
Nur »Danke!« Ich freue mich, wenn ich dir geholfen habe, und ich brauche auch ein wenig Anerkennung. Allerdings stelle ich die Bedürfnisse meiner Leser in diesem Punkt über meine eigenen.
Mit einer E-Mail oder einer Empfehlung in deinem Blog kannst du mir das Lächeln auch zurückgeben, das ich dir hoffentlich entlockt habe.
Völlig sachfremde Fragen oder Hinweise, die keinen Bezug zum Artikel oder zu einem anderen Kommentar herstellen. Wenn ich sie dennoch interessant finde, melde ich mich bei dir per E-Mail.
Kommentare, die sich auf gelöschte Kommentare beziehen. Da bitte ich dich um Nachsicht.
Beschimpfungen und andere juristische Fallgruben. Dafür gibt’s das Heise-Forum.

Natürlich kann ich mich auch irren. Also hebe ich einen manuell entfernten Kommentar eine Woche auf. Meldet sich der Autor nicht binnen dieser Zeit, lösche ich den ganzen Eintrag.

Bei manchen Kommentaren nehme ich nur einen Link heraus, ohne die Aussage zu zerstören, wenn ich ihn für fragwürdig halte oder das Ziel nicht mehr existiert.

Insgesamt werde ich künftig etwas strenger urteilen, denn meine Nachsicht ist in den letzten Wochen ein paar Mal zu oft ausgenutzt worden.
Das ging so weit, daß folgende zwei Zeilen in meine .htaccess Einzug fanden:

RewriteCond %{HTTP_REFERER} do-follow-blogs\.de
RewriteRule ^ http://www.do-follow-blogs.de/ [L,R=301]

Wenn du dich zu Unrecht wegmoderiert siehst, dann schreib mir eine freundliche E-Mail. Wenn du aber weißt, daß du Spam geschrieben hast, dann geh Sterben.

Weiterschmökern

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

Browser-ABC

Thomas Scholz — Sun, 16 May 2010 06:35:03 +0000

Ich bin gerade erst darüber gestolpert – Sonntagmorgen, fragt nicht! – Christian Leu listet auf, welche Seite ihm der Browser für jeden einzelnen Buchstaben vorschlägt. Find’ ich lustig, also steige ich verspätet noch ein. Das Ergebnis entlarvt mich vermutlich als langweiligen Fachmenschen. Und doch stehe ich dazu.

Wer spielt mit?

Opera: Der Colorpicker

Thomas Scholz — Tue, 04 May 2010 21:20:35 +0000

Seltsamerweise ist bei all der Presse um Opera 10.5 ein Detail nahezu untergegangen, über das ich mich sehr gefreut habe: Der Farbwähler in Opera Dragonfly.

Wir finden ihn im Reiter Utilities in Dragonfly, das wir bei ausgeblendeter Menuleiste am leichtesten erreichen, wenn wir irgendwo im Dokument das Kontextmenu aufrufen und dort ›Element untersuchen‹ auswählen (im Englischen ›Inspect Element‹).

Fahren wir jetzt mit der Maus über die Seite, so wird in einem Vorschaufenster die Fläche unter der Maus stark vergrößert dargestellt.

Ganz links können wir festlegen, wie groß die jeweilige Auswahl sein soll, die von der Maus erfaßt wird, und wie stark die Vergrößerung ist.

Das finde ich noch nicht sehr verständlich, und mit Scale 1 fährt sich der Auswahlmodus auch manchmal fest. Mit einem einem kleinen Trick gießen wir Öl ins Getriebe: Kurz den Reiter wechseln; dann läuft es wieder. Langfristig hilft wie bei jedem technischen Problem natürlich nur mehr RAM.

Auf der linken Fläche finden wir noch ein anderes Feature: Gespeicherte Farben. Hier können wir einmal ausgewählte Farben dauerhaft merken. Der Button ›Manage stored colors‹ bietet derzeit nur das Löschen an. Ich wünsche mir noch das Benennen und eine Sortierung nach Schlagworten oder Verzeichnissen. Ansonsten ist das schon sehr praktisch.

Rechts des Vorschaufensters können wir innerhalb der Auswahl noch einmal wählen: Wir können ein Quadrat festlegen, das wir mit der Maus auf dem Vorschaufeld plazieren. Der durchschnittliche Farbwert des Quadrates wird dann in drei Notationen ausgegeben: als RGB, als HSL und als Hexwert. Und speichern können wir die Farbe natürlich auch.
Die Maximalgröße des Quadrates beträgt 9×9 Pixel – das finde ich für einige Verläufe und Fotos etwas zu klein. Die Minimalgröße beträgt 1×1 Pixel. Klein genug. Subpixel sieht man ohnehin nicht.

Die Funktionsweise mal Schritt für Schritt zum Mitmachen:

Eine Seite öffnen, beispielsweise diese hier.
Rechtsklick auf ein Element (das Auge) und im Kontextmenu ›Element untersuchen‹ auswählen.
Jetzt öffent sich Dragonfly unten im Browserfenster mit dem Reiter ›DOM‹
Zum Reiter ›Utilities‹ wechseln und mit der Maus über das Auge fahren.
Über einer besonders schönen Stelle einmal links klicken, damit das Vorschaubild die Auswahl festhält.
In Color Select eine Größe wählen (7×7) und im Vorschaubild auf die Stelle klicken, deren durschnittlichen Farbwert man gerne haben möchte.
Wenn der richtige gefunden wurde, auf ›Store color‹ klicken.
Fertig.

Brauchen wir später eine gespeicherte Farbe, so klicken wir einfach darauf. Der Wert steht dann im rechten Feld.

Fazit: Die Oberfläche kann durchaus klarer werden, und ein paar Features fehlen mir noch: ein Export und Variieren der Farben beispielsweise. Aber im Ganzen ist das schon eine schöne Demonstration der Möglichkeiten, die die neue API Dragonflys bietet. Dragonfly ist übrigens Open Source, seit heute unter einer Apache-2.0-Lizenz. Es muß nicht extra installiert werden, womit eine Last wegfällt, die man mit externen Werkzeugen ja meistens hat.

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.

Text-rendering: illegibility

Thomas Scholz — Mon, 26 Apr 2010 05:11:26 +0000

Wenn zwischen Absicht und Ergebnis fremder Code steht, dann braucht der geübte Binärschubser seine wichtigste Kompetenz: Fluchen. So auch ich, als ich gestern von Christoph Schnieder dieses kleine Horrorstück zugesandt bekam:

Tatort war ein Palm Pre WebOS, Tatwerkzeug der eingebaute Browser auf WebKit-Basis.

Um das überhaupt nachzuvollziehen, habe ich den MobiOne Emulator für Palm Pre installiert. Das ging verdächtig leicht, und das Ergebnis half mir überhaupt nicht. Es war nämlich in Ordnung:

Dieser Emulator ist im Wesentlichen ein zurechtgestutztes Eclipse; seine Abhängigkeit vom Gastsystem erkennt man schon daran, daß er dessen Schriften benutzt. Unbrauchbar.

Dann habe ich das Palm webOS SDK installiert, das in einer virtuellen Maschine läuft – und das Problem ganz genau wiedergibt. Das scheint also ein recht realistisch arbeitendes Werkzeug zu sein. Etwas umständlich finde ich nur das englische Tastaturlayout, das ich nicht umstellen konnte.

Nach allerlei Tests habe ich endlich die Ursache gefunden: Ich hatte im Stylesheet eine Deklaration stehen, von der ich annahm, sie werde nur von Gecko interpretiert.

p,
address,
li
    {
        text-rendering:optimizeLegibility;
    }

Diese Eigenschaft stammt aus SVG, wie man leicht an der dämlichen Binnenmajuskel erkennt. Sie sollte Firefox dazu anregen, auch bei kleineren Schriftgraden als 20px das Kerning zu respektieren.
Was genau der Palm Browser hier versucht, vermag ich nicht zu sagen. Vielleicht hängt es mit der Schriftgröße zusammen, denn Überschriften, die mindestens 20px groß sind, werden noch gezeigt.

Ich habe die ganze Regel jetzt weggeworfen und einen Bugreport geschrieben.

Sicher ließe sich das auch hinter einem proprietären Selektor für Mozilla verstecken, aber davon will ich eigentlich weg. Und wenn ich damit leben kann, daß Mozilla-Nutzer noch keine abgerundeten Ecken sehen, dann darf ich genauso gut unterstellen, daß sie sich an schlampiges Kerning gewöhnt haben. Also nehmt es mir nicht übel, ja?

Ach ja, das aktuelle Ergebnis:

Da der Browser jetzt nur die Systemschriften des Palm OS verwendet, setzt er keine Kursivschnitte für serifenlose Schriften mehr um, und eine Monospace-Schrift findet oder nutzt er auch nicht. Das ist nicht schlimm, aber man kann es unter »Aha. Mist!« ablegen.