Robert Deutz meistens harmlos

Im Verzeichnis "models" findet man nur die comments.php, der Grund dafür ist, dass wir bei about nur Text ausgeben möchten und keine Daten benötigen.

Dann noch "views", hier sind nun die Dateien zu finden, die für die Ausgabe zuständig sind. Also wieder about.php und comments.php.

Fehlt noch die übergeordnete Ablaufsteuerung, ich hatte im ersten Teil schon erwähnt das Joomla nicht wirklich viel macht, es wird die Datei admin.rdbs_comment.php eingebunden und dabei natürlich der enthaltene php-Code ausgeführt (bzw. interpretiert). In den alten Zeiten hat man hier meistens eine umfangreiche switch-Anweisung für die Steuerung gefunden. Jetzt wird hier fast nur der richtige Controller erzeugt und dann die execute-Methode aufgerufen.

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

<?php
$task = JRequest::getVar('task');
$controllerName = JRequest::getVar( 'section', 'comments' );
 
switch ($controllerName)
{
  // wenn nichts passt dann nimm dies
  default:
    $controllerName = 'comments';
  // die folgenden Bereiche kennen wir
  case 'comments';
  case 'about';
    // die richtige Datei einbinden
    $dir=JPATH_COMPONENT.DS.'controllers'.DS;
    require_once( $dir.$controllerName.'.php' );
    // Controllernamen zusammenbauen
    $controllerName = 'RdbsCommentController'.$controllerName;
 
    // Controller erzeugen
    $controller = new $controllerName();
 
    // und nun den task ausführen
    $controller->execute( $task );
 
    // Wenn der Controller ein Redirect gesetzt hat dann machen wir das auch 
    $controller->redirect();
 
    break;
}
?>
 

Warum so kompliziert? Also ich unterteile hier meine Komponente in unterschiedliche Bereiche. Im Grunde würde es ausreichen nur den Task zur Steuerung zu verwenden, das kann aber, wenn die Erweiterung größer wird, schnell unübersichtlich werden. Deshalb führe ich hier den Begriff Section ein. Um das zu verdeutlichen ein Beispiel:
Nehmen wir an, ich hätte eine Komponente mit der ich unterschiedliche Daten bearbeiten könnte, ganz abstrakt: daten1, daten2, daten3, …. datenN. Diese Daten kann man natürlich Editieren, Löschen, Anlegen. Wenn ich nur den Task zur Steuerung verwenden würde, müsste ich Aktion und Datentyp kombinieren, um das Ganze eindeutig zu halten. Das müsste ich dann auch in der Toolbar durchhalten, außerdem müsste ich den Task auseinanderpflücken um den passenden Controller zu erzeugen und last but not least muss man viel mehr tippen und kann die Dateien nicht einfach kopieren und verwenden.

Momentan ist das sicher oversized, aber die Komponente kann ja größer werden und wir sind dann vorbereitet:-).

Arbeiten wir uns jetzt durch die einzelnen Menüpunkte, zuerst "about". Das ist der einfachere von den beiden und man kann daran schon einiges verstehen. Die Datei about.php im Controller-Verzeichnis enthält den folgenden Programmcode:

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

<?php
jimport( 'joomla.application.component.controller' );
 
class RdbsCommentControllerAbout extends JController
{
  /**
   * Display the about page
   */
  function display()
  {
    require_once(JPATH_COMPONENT.DS.'views'.DS.'about.php');
    RdbsCommentViewAbout::display( );
  }
 
  function cancel ()
  {
    $this->setRedirect( 'index.php?option=com_rdbs_comment' );
  }
}
?>

1

<?phpjimport( 'joomla.application.component.controller' );?

Eine weitere nützliche Sache ist, dass die Klasse (Jcontroller) eine Defaultmethode festlegt, macht man nichts ist das die Methode "display". Wählen wir den Menüpunkt "About" aus, wird der in der Datenbank für diesen gespeicherte link verwendet, hier ist das:
option=com_rdbs_comment&section=about&task=about

Die Section im Link sorgt dafür, dass der About-Controller verwendet wird, über den Task "about" müsste die Methode about verwendet werden. Gibt es nicht(!), also zieht hier die Defaultmethode und display wird verwendet. Man kann also über die execute-Methode der Klasse eine Funktion innerhalb der Klasse ausführen. Gibt es keine passende Funktion wird die Defaultmethode benutzt. In unserer Klasse haben wir die Defaultmethode auch noch überladen (im Zusammenhang mit OOP spricht man hier von Polymorphie) und eine eigene display-Funktion definiert. Des Weiteren haben wir noch eine cancel-Funktion vereinbart, diese setzt aber nur den redirect und macht ansonsten nichts.

Was macht also unser Controller, aktuell bindet er die passende Viewdatei ein und ruft die Display-Methode auf. Die schauen wir uns jetzt an:

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

 
 
  <script language="javascript" type="text/javascript">
  <!--
  function submitbutton(pressbutton) {
    var form = document.adminForm;
    if (pressbutton == 'cancel') {
      submitform( pressbutton );
      return;
    }
  }
  //-->
  </script>
< ?php
  echo '<form action="index.php" method="post" name="adminForm">';
 
..... der Text der ausgegeben werden soll
 
  echo '<input type="hidden" name="section" value="about" />';
  echo '<input type="hidden" name="option" value="com_rdbs_comment" />';
  echo '<input type="hidden" name="task" value="" />';
  echo '';
 
} 
?>
 
 

Damit haben wir den ersten Menüpunkt abgearbeitet!

Den Code für die Toolbar liefere ich jetzt auch zum Abschluss:

1
2
3
4
5
6
7

<?php
function setToolbar ()
{        
  JToolBarHelper::title( JText::_( 'About' ), 'generic.png' );
  JToolBarHelper::cancel( 'cancel' );
}
?>

Den zweiten Menüpunkt machen wir dann in der nächsten Folge. Dann gibt es auch wieder ein Archiv mit den ganzen Dateien.