Eigene Actions in Drupal 7

Oft stoßen wir an die Grenzen der Fähigkeiten von Drupal-Modulen, so dass nur noch über das Rules Modul die Probleme gelöst werden können. Doch was wenn die Programmierer anderer Module erst gar nicht die entsprechenden Actions deklariert haben? Dann wird es endlich Zeit, ein eigenes Modul zu schreiben.

Hier eine kurze Anleitung für Drupal 7.

1. Die Ordnerstruktur:

- site/all/modules/
– mymodule/
—- mymodule.info
—- mymodule.module

2. Inhalt der Datei mymodule.info:

name = My Module
description = "My own Action"
package = Other
core = 7.x
dependencies[] = devel

3. Inhalt der Datei mymodule.module:

<?php
/**
 * @file
 * Demo Module that shows some basic module stuff
 * @date 2011
 * @author Michael Lambertz
 */
 
/**
 * implements hook_rules_action_info()
 */
function mymodule_rules_action_info()
{
  $action = array(
    'mymodule_action' => array(
      'label'	=> t('Demo Action'),
      'group' => t('My Module')
    )
  );
  return $action;
}
 
/**
 * demo action gets a debug output of some experimental content
 */
function mymodule_action()
{
  dpm("Hello World");
}
?>

4. Nun noch das Modul aktivieren und für die eigenen Zwecke anpassen.

Ich hoffe, das hilft einigen hier weiter.
Weitere Tipps zu Drupal Modul-Programmierung einfach hier in den Kommentaren posten…

Im node.tpl.php bzw. im panels-pane.tpl.php des Themes:

/*
// für panels-pane.tpl.php
if (isset($content["#node"])) $node = $content["#node"];
*/
if (isset($node)) // nur wenn Node-Objekt vorhanden (bei Panels nicht automatisch)
{
   $type = $node->type;
   if (user_access("edit any $type content")) // Rechte für den Node Type
   {
      $nid = $node->nid;
      echo l(t('edit'), 'node/' . $nid . '/edit');
   }
}

Freue mich natürlich über Ergänzungen oder Korrekturen. Demnächst poste ich übrigens mal wieder etwas mehr in meinem Blog. Vermutlich aber demnächst dann auch über eine Drupal-Seite.

Javascript kann weitaus mehr als Popups

Klassen in Javascript? Private und öffentliche Funktionen? Ja, das geht. Als ich gerade im phphatesme-Blog den Artikel über objektorientiertes JavaScript [1] gelesen habe, dachte ich an ein Code-Snippet, das ich mir vor einigen Wochen zurechtgelegt hatte. Dieses Snippet kann etwas entscheidendes mehr als das phphatesme-Tutorial und dient mir als Grundlage für Javascript-Applikationen. Hier ist es:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

var meineApplikation = function(){
	var _defaults = {
		"var1": "value1",
		"var2": "value2"
	};
	var _opts;	// Optionen
	var _privateVariable; //Private Variable
 
	// Private Funktionen
	function _myPrivateFunction()
	{
		_privateVariable = "blah";
	}
 
	// Öffentliche Funktionen (public)
	return{
		init: function(options){
			// jQuery Methode zum Mischen der Benutzer-
			// mit den Default-Optionen
			_opts = $.extend(_defaults, options);
			return this;
		},
		test: function(){
			_myPrivateFunction();
			alert("var1="+_ops.var1+", var 2="+_opts.var2);
			return this;
		}
	}
}();
 
// application test
 
// ändere var1, behalte andere
meineApplikation.init({
	"var1": "changed value" 
}); 
 
// Öffentliche Funktion
meineApplikation.test(); 
// funktioniert
 
// Private Funktion
meineApplikation._myPrivateFunction();
// gibt Fehlermeldung zurück

Ich hoffe der Code hilft einigen hier. Über Feedbacks freue ich mich!

92

$db_url = 'mysqli://username:password@localhost/database';

Hier muss natürlich username, password und database durch den Benutzernamen, das Passwort und den Datenbanknamen ersetzt werden. Das war’s schon.

Haml ist eine alternative Template-Engine, ursprünglich entwickelt für Ruby, kann aber auch im PHP-Kontext eingesetzt werden

Seit Jahren auf der Suche nach alternativen Template-Engines bin ich mal wieder auf der Drupal Website fündig geworden. Haml (XHTML Abstraction Markup Language) nennt sich das Grundkonzept, und es kann auch problemlos in Drupal eingesetzt werden. Die Konstruktion neuer Templates ist spielend einfach. Hier eine minimale Anleitung.

1. Als erstes muss die Engine installiert werden. Man lädt sie hier runter, und entpackt sie in das Verzeichnis themes/engines/. Den Ordner sollte man noch umbenennen in “haml”.
2. Dann muss phphaml noch installiert werden. Das Paket lädt man hier runter, und entpackt es in themes/engines/haml/.
3. Nun kann das neue haml-Theme bereits angelegt werden. Wie das Erstellen von Themes in Drupal funktioniert, soll hier nicht im Detail erklärt werden (mehr Infos dazu findet man auf der Drupal-Seite). Wir legen also im Theme-Ordner ein neues Verzeichnis hamltheme/ an. Darin wird erst die Datei hamltheme.info erstellt mit dem Unterschied zu anderen Theme-Info-Dateien, dass wir hier haml als Templateengine aktivieren:
   

   1 2 3 4 5 6 7

   name = Haml Theme description = version = VERSION core = 6.x engine = haml   ; etc.

4. Nun wird noch das Page-Template erstellt. Dazu legen wir eine neue Datei page.haml an. Als Basis-Inhalte fügen wir Folgendes ein (Einrückung beachten!*):
   

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

   !!! %html %head = $head %title= $head_title = $styles = $scripts %body #container / primary links as styled list %ul#primary - foreach($primary_links as $link) %li %a{:href => $base_path.$link[href]}= $link[title] #header= $header #left= $left #main = $tabs = $messages = $help %h2.title= $title #content= $content #right= $right #footer= $footer

5. *Achtung: Bei der haml-Syntax ist die Einrückung (Leerstellen, Tabulator) entscheiden, ob ein Element als children oder als sibling erstellt wird.
6. Danach kann man das Theme bereits unter admin/build/themes aktivieren.
7. Nun müssen natürlich ggf. noch Anpassungen für die anderen Templates (node.haml usw.) gemacht werden.

Interessant ist auch, dass man selbst HTML und PHP-Code in die Templates integrieren kann. Damit sollte am besten jeder selbst einmal etwas rumexperimentieren. Einige Beispiele für die Syntax finden sich im Ordner themes/engines/haml/phpHaml/tpl/.

Viel Spaß!

preg_replace('/<.*>(.*)<\/.*>/', 'Michael', 'Guten Tag, <span>Gast</span>!');

Bei einer Erweiterung ergibt sich jedoch schnell das Problem, dass diese Markierungen entweder nur einmal im gesamten Text ($subject) vorkommen darf. Kommen die Markierungen mehrmals vor, so ersetzt preg_replace() den Inhalt zwischen der allerersten und der allerletzten Markierung. Das ist meistens unerwünscht.

Wer mit regulären Ausdrücken noch nicht sehr erfahren ist, versucht nun durch Modifikation des Suchmusters zu verhindern, dass zwischen den Markierungen die Markierungen nochmals vorkommen, also etwas nach dem Schema: “Finde alles außer die Markierungen zwischen den Markierungen!”. Damit ist man in die Falle getappt und vertrödelt endlos Zeit.

Die Lösung

Stattdessen gibt es den einfachen Modifier U. Dieser steht für ungreedy. Er bewirkt, dass die RegExp-Engine versucht, den kleinstmöglichen Text zu finden. (Standard ist greedy).
Wir suchen also folgendermaßen:

preg_replace('/<.*>(.*)<\/.*>/U', 'Michael', 'Guten Tag, <span>Gast</span>! Auf Wiedersehen, <span>Gast</span>');

Im Player wollen wir debuggen, nicht im Browser!

Ich hab gestern den Flex Builder Alpha 5 für Linux mit Eclipse 3.5 (Galileo) installiert, und immer wieder macht man die gleichen Dinge und findet die Einstellungen nicht. So suchte ich gestern Abend lange Zeit nach einer Lösung, wie man Flex-Applikationen im Player statt im Browser debuggen kann. Hier die Lösung:

1. Beim Erstellen des neuen Flex-Projektes geben wir als “Application Server Type” die Auswahl None an! Nicht PHP, sonst klappt es nicht.

2. In der “Debug Configuration…” muss im Bereich “URL or path to launch” das Häkchen bei “Use defaults” weg, und wir ändern den Dateityp von .html in .swf

3. Falls man die Projekteinstellungen nicht gemacht hat, müssen in der Datei .flexProperties die Attribute des Tags flexProperties angepasst werden:

<flexProperties flexServerType="0" toolCompile="true" useServerFlexSDK="false" version="1"/>

Zum Thema Adobe und Linux

Hmm, weiß nicht, irgendwie mögen sie es nicht, aber dennoch gibt’s nun auch AIR für Adobe. Leider sind doch recht viele Entwickler bei Linux gelandet, und das ist nun mal eine Zielgruppe von Flex. Insofern wollen wir hoffen, dass der FlexBuilder demnächst auch für Linux mal richtig richtig funktioniert

Perspektivisches Verzerren mit Inkscape

Es erstaunt mich immer wieder aufs neue, was Inkscape so alles kann. Seit eben weiß ich nun auch, wie man Pfade perspektivisch verzerren kann. Wer nicht lange suchen will, für den gibt’s hier die Anleitung.

Es gibt nur einige wenige Dinge zu beachten, die sind jedoch sehr wichtig, sonst klappt es nicht:

1. Alle zu verzerrenden Objekte müssen Pfade sein (oder in Pfade konvertiert).
2. Will man mehrere Objekte zusammen verzerren, müssen sie gruppiert (Strg+G) werden.
3. Danach zeichnet man den Verzerrungspfad als Bezierkurve – man muss dabei unten links anfangen, sonst wird die Verzerrung entsprechend verdreht.
4. Nun als erstes das zu verzerrende Objekt auswählen (bzw. die Gruppe), als zweites (mit angehaltener Shift-Taste) den Verzerrungspfad (bei Inkscape 0.47 unter Ubuntu ist das jedenfalls so, und nicht umgekehrt)
5. Unter Erweiterungen->Pfad modifizieren->Perspektive wählen und abwarten

Dieses Video führt das Ganze auch noch vor, aber Achtung, es behauptet, dass man die Objekte genau umgekehrt auswählen muss: Screencast Perspektivisches Verzerren mit Inkscape auf Youtube

Indexed Search – Metatags ignorieren  – typo3-tutorials.org

Ab der TYPO3-Version 4.2 lässt sich das indiziieren von Meta-Tags in der Extension indexed_search endlich per TS-Setup abschalten. Man muss nicht mehr wie in den Versionen zuvor im Quelltext der Extension hardcoden. Hier das TS-Setup:

config.index_metatags =
page.config.index_metatags =