uio--WebPageHeader-Module
uio--WebPageMain-Module
Components, Blueprints, Component Types, Component Instances, WebSite, WebPages, Content Elements: Das UDS bietet für die Formulierung von digitalen Dokumenten wie mitunter damit auch für Webseiten eine ganze Reihe von Komponenten und Elementen. Vereinfacht formuliert kann man diese als Bausteine oder englischsprachig als Building Blocks des Design Systems verstehen.

Components

PART 1: OVERVIEW

Components

The Building Blocks of Design Systems


HINWEIS: Diese Section Components dokumentiert derzeit im Schwerpunkt nur Content Element Components, zu erkennen am Namespace-Prefix ce: wie beispielsweise <ce:InlineLink>. Es sind diese Komponenten, mit denen die Informations- und Datenstruktur von WebSite-Clustern, WebPages, Layouts sowie deren Inhalten formuliert werden können.

Zum Verständnis erforderliche Begriffe


Syntax und Aufbau von Komponenten

Keywords: <comment>

Grundlegende Syntax

Grundprinzip von Semantik und Objektorientierung verstehen

Keywords: <comment> <ce:ContentInstance> <ce:ContentReference> <doc>

Fundamentale Elemente

Realm, WebSite, WebPage

Keywords: Realm, WebSite, WebPage

WebPage Structure

Primäre technische und semantische Komponenten einer Einzelseite

HeaderNavigationModule

Struktur einfacher und komplexer Menüs

ce:HeaderNavigationModule

Themes, Styles, Skins, Variants

Einfluss auf Gestaltung, Pattern, Flow nehmen

Sections einer WebPage

Abschnitte in Einzelnseiten einer Webseite

Layout und Content

Komponenten für Layouts und Content Elements

Complex Containers

List Containers

Redaktionelle Inline-Elemente

Stichworte: ce:CodeSample, ce:InlineLink, ce:KeyboardKey

Elemente "under Construction"

Die nachfolgenden Elemente sind aktuell in Planung. Das zugehörige Rendering der Daten ist zum Teil noch nicht programmiert.


Ein Standard ce:InlineLink

Zum Vergleich der späteren neuen Varianten zeigen wir zuerst einen Standard ce:InlineLink.



<ce:Paragraph-02>
 <ce:InlineLink>
 <ce:config>
 <ce:label>
 <text lang="de">Die Label</text>
 </ce:label>
 <ce:uri>https://url.example.com</ce:uri>
 </ce:config>
 </ce:InlineLink>
</ce:Paragraph-02>

 

ce:TextBuilder findet/rendert referenzierte Organization



<ce:Paragraph-02>
 <ce:TextBuilder>
 <ce:find><ce:Organization ref="org-001"/></ce:find>
 <ce:property>name</ce:property>
 </ce:TextBuilder>
</ce:Paragraph-02>

 

Fixmann


ce:CardBuilder findet und rendert referenzierte Organization

name url
Beta Corporation https://beta-corp.example.com


(In Planung: PrepareInlineLink mit ce:DefinedTerm)


ce:InlineLink mi fn-get-Organization Functions konfigurieren.


ce:InlineLink ohne Variablen

Klick mich

InlineLink mit Variablen 2

Die Variante bei welcher wir nur den Namen einer Organization in einem Text in fetter Schreibweise mit ce:InlineStrong ohne weiteren Link haben möchten, nutzt als Wert einen ce:TextBuilder-Node und gibt dort als Wert für ce:find dann eine Referenz auf eine ce:Organization an. Damit ce:TextBuilder weiß, welche Property der ce:Organization als Text-Wert benötigt wird, muss mit ce:property noch name angegeben werden.

Die Ausgabe für ref="org-002" als Demo ist: Beta Corporation

Wenn wir aber einen ce:InlineLink haben möchten, so können wir auch in diesem Fall die Eigenschaften ebenso über ce:TextBuilder von einer ce:Organization in eine Textausgabe als String umwandeln, wobei ce:property dann die passende Eigenschaft wie name oder url angeben muss.


Verwendung von Variablen wie var-002 mit Wert aus dem Repo


Grundlagen

Damit die Templates die zugehörigen Files mit den referenzierten Nodes finden können, ist es erforderlich, dass der Processor diese Files kennt.

Die zu Beginn vermeintlich einfachste Option besteht darin, ein <ce:Mapping>.. Element in einem Index-Document wie DocumentFindById.xml zu haben. Auf dieser Grundlage lassen sich dann id-Werte und deren Stereotype auf Dokumente und Nodes mappen.

Die Alternative aber besteht darin, als Teil eines Processing einen XML-File erzeugen, welcher bereits alle XML-Files unterhalb eines Realm erfasst hat.

Eine Lösung in PHP 8.x könnte beispielsweise wie folgt aussehen:



<?php
declare(strict_types=1);

namespace Quadrat\Indexer;

use DOMDocument;
use DOMElement;

final class IndexBuilder
{
 private DOMDocument $doc;

 public function __construct()
 {
 $this->doc = new DOMDocument('1.0', 'UTF-8');
 $this->doc->formatOutput = true;
 }

 /**
 * Baut das Root-Element <df:FileStructure>.
 */
 public function build(array $structure): DOMDocument
 {
 $root = $this->doc->createElementNS('http://example.com/df', 'df:FileStructure');
 $this->doc->appendChild($root);

 foreach ($structure as $folder) {
 $root->appendChild(
 $this->createFolder($folder['name'], $folder['files'] ?? [], $folder['folders'] ?? [])
 );
 }

 return $this->doc;
 }

 /**
 * Erzeugt einen <ce:Folder>-Knoten.
 */
 private function createFolder(string $name, array $files, array $subFolders): DOMElement
 {
 $folder = $this->doc->createElementNS('http://example.com/ce', 'ce:Folder');
 $folder->setAttribute('n', $name); // kompakt: "n" = name

 foreach ($files as $file) {
 $folder->appendChild(
 $this->createFile($file['name'], $file['lastModified'] ?? null, $file['type'] ?? null)
 );
 }

 foreach ($subFolders as $sub) {
 $folder->appendChild(
 $this->createFolder($sub['name'], $sub['files'] ?? [], $sub['folders'] ?? [])
 );
 }

 return $folder;
 }

 /**
 * Erzeugt einen <ce:File>-Knoten.
 */
 private function createFile(string $name, ?string $lastModified, ?string $type): DOMElement
 {
 $file = $this->doc->createElementNS('http://example.com/ce', 'ce:File');
 $file->setAttribute('n', $name);

 if ($lastModified !== null) {
 $file->setAttribute('lm', $lastModified); // "lm" = lastModified
 }

 if ($type !== null) {
 $file->setAttribute('t', $type); // "t" = type (z. B. schema.org Datentyp)
 }

 return $file;
 }
}


== USAGE ==

use Quadrat\Indexer\IndexBuilder;

$builder = new IndexBuilder();

$structure = [
 [
 'name' => 'courses',
 'files' => [
 ['name' => 'java.xml', 'lastModified' => '2025-11-06', 'type' => 'Course'],
 ['name' => 'csharp.xml', 'lastModified' => '2025-11-01', 'type' => 'Course'],
 ],
 'folders' => [
 [
 'name' => 'advanced',
 'files' => [
 ['name' => 'php.xml', 'lastModified' => '2025-10-28', 'type' => 'Course'],
 ]
 ]
 ]
 ]
];

$doc = $builder->build($structure);
echo $doc->saveXML();

==

<?xml version="1.0" encoding="UTF-8"?>
<df:FileStructure xmlns:df="http://example.com/df" xmlns:ce="http://example.com/ce">
 <ce:Folder n="courses">
 <ce:File n="java.xml" lm="2025-11-06" t="Course"/>
 <ce:File n="csharp.xml" lm="2025-11-01" t="Course"/>
 <ce:Folder n="advanced">
 <ce:File n="php.xml" lm="2025-10-28" t="Course"/>
 </ce:Folder>
 </ce:Folder>
</df:FileStructure>


 

Zu Beginn muss man allerdings die Verzeichnisse rekursiv lesen.



<?php
declare(strict_types=1);

namespace Quadrat\Crawler;

use DOMDocument;
use DOMElement;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;

final class RealmCrawler
{
 private DOMDocument $doc;

 public function __construct()
 {
 $this->doc = new DOMDocument('1.0', 'UTF-8');
 $this->doc->formatOutput = true;
 }

 public function crawl(string $realmPath): DOMDocument
 {
 $root = $this->doc->createElementNS('http://example.com/df', 'df:FileStructure');
 $this->doc->appendChild($root);

 $iterator = new RecursiveIteratorIterator(
 new RecursiveDirectoryIterator($realmPath, RecursiveDirectoryIterator::SKIP_DOTS),
 RecursiveIteratorIterator::SELF_FIRST
 );

 foreach ($iterator as $item) {
 if ($item->isDir()) {
 $folder = $this->doc->createElementNS('http://example.com/ce', 'ce:Folder');
 $folder->setAttribute('n', $item->getFilename());
 $root->appendChild($folder);
 } else {
 $file = $this->doc->createElementNS('http://example.com/ce', 'ce:File');
 $file->setAttribute('n', $item->getFilename());
 $file->setAttribute('lm', date('Y-m-d H:i:s', $item->getMTime()));
 // Typisierung: wenn XML-Endung, dann type="xml"
 if (str_ends_with($item->getFilename(), '.xml')) {
 $file->setAttribute('t', 'xml');
 }
 $root->appendChild($file);
 }
 }

 return $this->doc;
 }
}

XML-Text, Number, Date

Ein Sonderfall in UDS XML ist die Bedeutung von Text. Während redaktionelle Inhalte in Absatzkomponenten wie zumeist <ce:Paragraph-02> und <ce:Paragraph-01> direkt als XML-Text-Knoten innerhalb dieses XML Elements geschrieben werden kann, sieht es bei Text für Buttons, Labels und andere Komponenten anders aus.

Mit <text lang="de">Text</text> werden Text-Literale als Wert einer Objekt-Eigenschaft und damit auch einem Konfigurationsparameter von Komponenten zugeordnet.

Der technische und semantische Hintergrund hierbei ist der, dass manche Parameter eine sehr spezielle Form von Text erfordern. Damit man in XML Dokumenten deren Bedeutung immer erkennen kann, bedeutet es im Umkehrschluss, das auch Standard-Text-Literale dahingehend ein eigenes Element bekommen.

Hinzukam allerdings einst, dass die semantische Auszeichnung von LinkedData Informationen, die man mitunter für SEO verwendet, inzwischen Text-Werte mit parallel mehreren Sprachen in LD+JSON einführte, um bei Texten nicht nur den Text zu erfassen sondern auch zu marktieren, in welcher Sprache dieser erstellt wurde.


Der UDS Server kann bei HTTP Requests von Browsern tatsächlich die gewünschte Sprache des Nutzers erkennen und war in der Lage, basierend auf Sprach-Attributen wie lang="de" oder "en" die passende Sprache anzuzeigen. Mit Einführung des URI-Segments /de und /en wurde diese Auszeichnung von lang-Werten aber obsolet.

FN-Function-Elements

Function Elements sind zuerst einmal normale Content Elements in UIO3 und haben deshalb auch das XML-Namespace-Prefix ce:. Sie unterscheiden sich allerdings von anderen Inhalten dahingehend, dass deren Inhalte zum Zeitpunkt der Abfrage abgefragt wird, sei es nun das aktuelle Datum mit einer Jahreszahl, dem Wochentag, die Anzahl der aktuell eingeloggten User oder auch schlichtweg eine vom Server erzeugte Zufallszahl.

So kann man mit <ce:fn-getdate-year-actual/> beispielsweise das aktuelle Jahr ausgeben: 2026.

Die Dokumenation dieser Elemente befindet sich in Bearbeitung. <ce:fn-getdate-year-actual/> möglich sind.


Component Index

Die nachfolgende Liste von Components wurde bereits dokumentiert.

A

<ce:Accordeon> (@since 1.5.2.*, compatible 1.5.2.90) - An ItemList like element which ListItems each contain a Button and a Panel element. When rendering as HTML output panels are usually closed, however, can be opened by clicking onto the appropriate button. IDs for ce:Accordeon elements and their items are automatically rendered. ce:Accordeon should NOT be used as an alternative to navigation. | ce:Accordeon/ce:contents/ce:Button/ce:label/text@lang=de, ce:Accordeon/ce:contents/ce:Panel/CEContainer

B

<ce:Block> (1.*.*.* stable, compatible v.1.5.2.90) - Used an element in XML files to group several XML elements. The ce:Block element itself is not rendered. Only its children are rendered. Might be compared to { ... } blocks in programming languages to create a local scope.

<ce:BlockQuote> (1.5.2.* Beta, compatible 1.5.2.90) - Used to a layout block with a quote, testimonial.

<ce:BookingForm> (1.5.2.55 prototype) - Used to render an HTML formular section with booking data which can be send by email.

<ce:BoxAbsolute> (1.5.2.40 prototype) - Layout element which can be used within CECol columns of a layout for absolute positioning of elements based upon the container element in which this ce:BoxAbsolute element is used.

<ce:BoxRelative> (1.5.2.40 prototype) - Layout element which can be used within CECol columns of a layout for relative positioning of elements based upon the container element in which this ce:BoxAbsolute element is used.

<ce:BreadCrumbList> (1.5.2.* Beta, compatible 1.5.2.90) - Used as a module to add a Breadcrumb List manually within a webpage additional to menues and navigation elements that are part of a theme, template, subtheme, subtemplate or generated by post processing.

<ce:BreakLine/> (1.*.*.* stable, compatible v.1.5.2.90) - Used to force a new line at a certain position. Usually rendered as <br /> element in HTML5, XHTML 1.x etc. which will later be translated into simple HTML5 <br> elements. Annotation: The UDS core renders XML conform HTML5 content that can be processed by XML DOM tools.

C

<ce:Card> (1.5.3.* beta, compatible v.1.5.3.119) - Used for Card-Layouts with a CardDeck or CardGroup component. @see Card

<ce:CardDeck> (1.5.3.* beta, compatible v.1.5.3.119) - Used for Card-Layouts with a CardDeck component as a container für Card as items. @see CardDeck

ce:

The ce-namespace of <ce:*> elements like <ce:InlineLink> in UDS is usually used for content elements in UDS. There are still some older elements with a default namespace where element names began with CE like <CECol*> or even without a prefix like <inline-link>. All UDS without the <ce:*> are marked deprecated since UDS v.1.5.* and will replaced with UDS 1.6.*. More information about UDS content elements @see Page

CE*

UDS element names beginning with <CE*> like <CECol*> are depricated and will be replaced by elements of a ce:*> namespace.

ce:Column, CECol

<CECol> (1.5.2.* Beta, compatible 1.5.2.90) - Used for defining columns within CERow as part of CEContainer. Note: This UDS element will be replaced with <ce:Column>. Column-Elements are used for layout purposes and are thus always a child element of Row-Elements. For more information @see Layout Container

<ce:CodeSample> (1.5.2.* beta, compatible v.1.5.2.90) - Used for samples of programming code, variables, method names or code snippets with a ce:Paragraph-02 and other block elements when writing content. Usuallys rendered as HTML code element with a monotype font.

<ce:Collapsible> (1.5.4.* early alpha) - A ce:Collapsible element is a block element used as a container to encapsulate a longer vertical passage of content. A ce:Collapsible consists of two subcomponents, a button which is used to open and to close and/or to toggle the second subcomponent: The panel. An alternative component is an ce:Accordeon element. ce:Collapsible

<ce:ContentInstance> (1.5.2.* beta, compatible v.1.5.2.90) - Used within doc-element within an xml-file to be referenced by ce:ContentReference elements by @uri attribute. This is an option to store offen used layouted content in files.

<ce:ContentReference> (1.5.2..* beta, compatible v.1.5.2.90) - Used to refer to XML documents which contents you would like to copy from doc/ce:ContentInstance/ce:contents from the via @uri referenced file.

D

DB: DB is a common abbreviation for «data base».

DB DB, abbreviation für «Die Bahn», formerly known as «Deutsche Bahn» or «Deutsche Bundesbahn».

DB DB, abbreviation für «Deutsche Bank».

define: \define('NAME','Beispielname' PHP command for the definition of a global PHP constant. This pattern should be replaced by using class constants resp. public static final class members.

Declaration Node: A declaration node is declaring a value for a defined variable or a sequence of commands for a defined function or the structure and members for a defined type.

DefinedTerm: <ce:DefinedTerm id/ref=".."> is a semantic content element used as a container for redactional content to define and describe a certain term. A ce:DefinedTerm is often bound to a ce:DefinedTermSet as a context because some terms like «Java» have several meanings as an island, a programming language, a technology, or a coffee brand.

Definition Node: A definition node is a certain node in a program which will define a new variable, function or type and will lexically register its name in the actual scope.

div: <div> An important HTML Tag without semantic meaning; it's a common block element which often contains other <div> block elements or <span> inline-elements.

Dreidimensional, 3D: <ce:Scene3D> UDS components that are rendered in 3D and thus three dimensional.

E

Element: In HTML, XML, SVG and similiar coding languages an element is meant a certain node in a document, often represented with a single tag like <whatever/> or an opening <whatever> and closing </whatever> tag. These elements are instances of certain building blocks of HTML documents (Webpages), SVG documents (Graphics) or the building blocks of UDS contents with elements like <ce:Accordeon>, <ce:InlineLink>, <ce:ImageObject> or other components. @see UDS Components

F

F: A programming language.

<ce:FixedHeading-01>, <ce:FixedHeading-02>, <ce:FixedHeading-03>, <ce:FixedHeading-04>, <ce:FixedHeading-05>, <ce:FixedHeading-06>, <ce:FixedHeading-07> (1.5.2.* Stable) - Used for common headlines for normal contents that are not meant to use a representative style. Use FluidHeading-** elements if you need a more representative style.

<ce:FluidHeading-01>, <ce:FluidHeading-02>, <ce:FluidHeading-03>, <ce:FluidHeading-04>, <ce:FluidHeading-05>, <ce:FluidHeading-06>, <ce:FluidHeading-07> (1.5.2.* Stable) - Used for representative headlines in cases where the fontsize will grow with width of the browser window and/or a print layout while FixedHeading-** elements raise sizes just limited.

<ce:FluidImageSVG> (1.5.2.89 Prototype) - Used to define a certain ImageObject type that is meant to store and display SVG vector graphics. The important part about SVG files that SVG files can be formatted and styled by CSS and JS code of the webpage.

<ce:FootNote> (@since 1.5.2.*, compatible 1.5.2.89) - Displays all contents of ce:FootNote within a ce:WebPage.

<ce:FootNodeCollectionModule> (@since 1.5.2.*, compatible 1.5.2.89) - Displays all contents of ce:FootNote within a ce:WebPage.

ce_FormSignupSigninReset_v001 (@since 1.0.0.* concept) - This group of components will provide buttons and dialogs for a signup, password reset etc. process for frontend and users. CONCEPT.

G

<ce:GridLayout> (1.5.2.89 Alpha, compatible v.1.5.2.89) - A ce:GridLayout element is an alternative layout concept based upon the HTML5 grid concept. Place ce:GridCell elements within ce:contents of a ce:GridLayout element, configurate their position by col and row or it's spanning size by cols and rows. @see ce_GridLayout_v001.xsl @see ce_GridLayoutTable.xsl (DEMO CODE)

<ce:GridCell> - @see ce:GridLayout

<ce:GridRow> - This is element exists to encapsule grid rows, however, for rendering purposes of ce:GridCell elements it's not required - @see ce:GridLayout

<ce:GridColumn> - This is element exists to encapsule grid columns, however, for rendering purposes of ce:GridCell elements it's not required - @see ce:GridLayout

<ce:Grid/> - There is actually NO Grid-element. @see ce:GridLayout.

<ce:Group/> - There is actually NO Group-element although there are many components that are used to group elements. @see ce:ButtonGroup, ce:CardGroup.

H

<ce:HeaderCarousel> (@since 1.3.5.20, compatible 1.5.2.89) - Used to add a SlideShow to a ce:WebPageHeader and to configurate its Slides. This element has several sub components.

<ce:HeaderNavigationModule> <ce:Nav-L1-MainNavigation><ce:items> <ce:Nav-L2-MenuItem style="1"> <ce:Nav-L2-MegaMenu style="1"><ce:items> <ce:Nav-MegaColumn-1> <ce:MegaMenuContentBlock> <ce:Nav-MegaSection style="1"><ce:header> <ce:Nav-MegaSection style="1"><ce:items> <ce:Nav-L1-MainNavigation> <ce:Nav-L2-MenuItem> <ce:Nav-L2-MegaMenu> <ce:Nav-MegaSection> <ce:Nav-L3-MenuItem> .. (1.1.1.1 alpha) - These Nav-* elements are used within the ce:HeaderNavigationModule which is defined as a SiteNavigationElement to greate large menus for the header of WebPages of a certain WebSite. These elements are not part of the common Content Elements of WebPages but of the definition of HeaderNavigationModule structures that are referenced by ce:WebSite configuration.

<ce:HorizontalTabsPanelGroup> (1.5.2.* Concept, ****) - The ce:HorizontalTabsPanelGroup is layout container component with a horiontal menu of "tab" buttons above or below an area for panels. If the user clicks onto a tab the appropriate panel is shown.

The more common element is the <ce:VerticalTabsPanelGroup> Element.

<HTMLBODY_MAIN_CONTENT_010_Section_Overview> (@since 1.0.0.*, compatible 1.5.2.90) - Placed within ce:WebPageMain/ce:contents as a container for sections like ce:Section.

<HTMLBODY_HEADLINE_010_Section_Breadcrumb_Title> (@since 1.0.0.*, compatible 1.5.2.90) - Placed within ce:WebPageMain/ce:contents to show information about breadcrumb, title, buttons for previous or next page, buttons to jump to the content of a page or move upwards in the page hierarchy to the chapter or page index of a chapter. | Contains several elements <Headline> <Paragraph> <BackgroundImage> <Navigation> <Continue> <Link> <text lang="de"> <AncestorUp> <Previous> <Next>

I

Icon-Templates.xsl (@since 1.5.4.35, alpha) - This template is a container for several named icon templates what wrap SVG icons with HTML span elements. This approach is deprecated and will be replaced by a more generic Icon rendering approach. Icons contained within this xsl stylesheet are used by other XSL templates by call-template only.

<ce:ImageBlock> (@since 1.5.2.*, compatible 1.5.2.90) - Used as a container and frame to contain and display ce:ImageObject or other MediaType elements like ce:SVG* elements.

"ImageBlockModal" (@since 1.0.0.* concept) - This element will be used to load an image on request instead of loading it directly. Used to reduce download traffic. CONCEPT.

<ce:ImageObject> (@since 1.5.2.*, compatible 1.5.2.90) - Used as an information node within a WebPage UDS XML document to edit the configuration of an image that should be loaded and/or rendered on the serverside. Usually rendered as an HTML <img .. /> tag which will later be converted to simple HTML5 by removing the slash in UDS PostProcessing.

"ImageGallery" (@since 1.0.0.* prototype) - This element is used as a container for images like ce:ImageBlock and ce:ImageObject elements. This element requires recoding due to changes to JS libraries. It will later provide sorting and tagging of images and should support a FAL file abstraction layer for referencing files and/or IDs.

"InlineBox" (@since 1.5.3.* alpha) - This element is used as an inline-container to encapsulate content within a paragraph section. ce:InlineBox

<ce:InlineLink> (@since 1.5.2.* beta) - This element is used to create links within block elements like ce:Paragraph-02 and ce:Paragraph-02 elements. Since 1.5.2.* link properties are edited within ce:config with text-elements within ce:label and ce:uri.

<ce:InlineLink_PageAnchorLinks> (@since 1.5.2.* beta) - This is a special inline-link-element that creates a link within a text passage back to the PageAnchorLinks menu.

J

Java: An important programming language and technology; the name «Java» is a registered trademark of Oracle.

JavaScript: An important programming language also officially known by its standard «ECMAScript», often mentioned in combination with a certain version like «ECMAScript ES 5» (JavaScript until approx. 2015) and «ECMAScript ES 6» (JavaScript after 2016 which added classes based object orientation).

JavaScript Runtime: A JavaScript runtime is a program which is able to run and thus execute JavaScript Code like those engines in common Browsers (Google Chrome, Microsoft Edge, Mozilla Firefox) or engines on serverside (NodeJS, GraalVM/Oracle, Rhino, Deno, ..).

<ce:JumpLanding> (@since 1.1.1.1 stable, v.1.5.2.90) - Used to manually place anchors in documents which will be rendered in HTML as <a id="example"></a> elements. You can link to these elements by URLs/URIs by adding #example to a link for the appropriate URL/URI of its webpage.

K

<ce:KeyboardKey> (1.5.2.45 Stable) - Used to add a keyboard-key-like border and background for chars, letters and special signs that represent keys on a keyboard like CTRL, +, \ and more.

<ce:KeyboardLayout>
<ce:KeyboardGraphics>
<ce:Keyboard-1>
<ce:MusicKeyboard-1>
<ce:Keyboard-2-L21>
<ce:Keyboard-2-Q11 >
(Prototypes, Concept) - These components are meant to display the keyboard layouts for computer keyboards, keys of a piano, and other hardware which keys, pads, etc. Should be used to visualize the position of keys and key-combinations in games, informatics, music, and more.

L

<ce:JumpLanding> (@since 1.1.1.1 stable, v.1.5.2.90) - Used to manually place anchors in documents which will be rendered in HTML as <a id="example"></a> elements. You can link to these elements by URLs/URIs by adding #example to a link for the appropriate URL/URI of its webpage.

<ce:LinkGlossary> (1.5.2.* Concept, compatible 1.5.2.90) - ???

M

<ce:Map> (1.5.2.* Concept) - This element was meant to be used to place a geographic map, game map, a plan, and more based upon rending of contents as SVG and/or HTML/CSS and/or Canvas/WebGL and/or serverside generation of jpg/png files. We flagged this element as deprecated because the concept contains to many variants for this elements and has a naming conflict with "map", "hash map", "linked hash map" that we used to describe data structures in code and in XML. DEPRECATED.

<ce:Modal> (1.5.2.* Concept) - This element is a container for a panel with layout and contents that can be opened and shown above the actual page content if users click onto the appropriate button to open it. A modal dialog can be be closed. Note: The content of this modal element is already loaded with a page. RENDERING BUG.

<df:Module-CallActionFinally> (1.3.6.1 alpha) - Used as a section at the end of a webpage to add a call-to-action CTA button contained in a section with a certain style. These elements are usually defined within doc/ce:ContentInstance/ce:contents of XML files to be referenced later by ce:ContentReference with @uri attributes. | Will get new configuration when migrated to ce:CallActionFinallyModule.

N

<ce:Nav-L1-MainNavigation> <ce:Nav-L2-MenuItem> <ce:Nav-L2-MegaMenu> <ce:Nav-MegaSection> <ce:Nav-L3-MenuItem> .. (1.1.1.1 alhpa) - These Nav-* elements are used within the ce:HeaderNavigationModule which is defined as a SiteNavigationElement to greate large menus for the header of WebPages of a certain WebSite. @see ce:HeaderNavigationModule.

O

<ce:OtherActionButton> (1.5.2.* Beta, compatible 1.5.2.90) - An alternative ActionButton element, see ViewActionButton. While the ViewActionButton is the primary button that a used might be interested in the OtherActionButton is used to provide one or two more secondary buttons. Example: First button for a page about a product and another button for a page where you may call the support team.

<ce:OuterContainer> (1.5.2.* Beta, compatible 1.5.2.90) - Used as container for CEContainer layout elements for formatting purposes.

P

<ce:PageAnchor> (1.5.2.* Beta, compatible 1.5.2.90) - Used to add links to PageAnchorMenu

<ce:PageDescription> (1.5.2.* Beta, changed 1.5.2.96 compatible 1.5.2.97) - This is a layout element and content container that should be used to write a short summary of the contents on a certain webpage. This content will be used in cases if the ce:description of a ce:WebPage is missing.

<ce:PageIntro> (1.5.2.97 Beta, compatible 1.5.2.97) - This layout compontent is used in the top of a ce:WebPage/ce:contents Section Container and contains a short intro text usally within a text element instead of a common ce:Paragraph-03 element. The size of the content is rendered automatically for a certain style.

Paragraph: A paragraph is a common block element and thus a part of layouts, containing text and other elements as inline-element elements, also known in HTML as the <p> Element. The most often used paragraph component in UDS is the <ce:Paragraph-02> content element, however, there are more sizes: <ce:Paragraph-00>, <ce:Paragraph-01>, <ce:Paragraph-02>, <ce:Paragraph-03>, <ce:Paragraph-04>, <ce:Paragraph-05>, <ce:Paragraph-06>, <ce:Paragraph-07> (1.5.2.* Stable) - Used for content in paragraphs. Numbers 01 and 02 of paragraph elements match with their appropriate FixedHeading-01 and FixedHeading-02 styles. Larger paragraphs are meant for represantive texts for example within headers and/or on covers. It is usually follewed by a PageAnchorLinksModule which provides links to certain sections on the same webpage the user actually sees in his browser.

PopOver: <ce:Popover> (@since 1.1.0.2.* prototype, CHANGE!) - A ce:Popover Element is usually an inline element. It contains a label as that part of the content the user can see and a contents part that is displayed if the user clicks onto this element. The ce:Popover element will change its structure to ce:config.


Popover:


Q

Quotes: <ce:Quotes> <ce:SingleQuotes> <ce:DoubleQuotes> (@since 1.5.2.* Beta) - IMPORTANT: Each type of quotes is meant an inline block with a certain meaning and a certain formatting for its content and/or the appropriate quote chars. «Quotes», „DoubleQuotes“, 'SingleQuotes', «Quotes». NOTE: We will try to recognize common double quotes in contents by postprocessing, however, content in single quotes is problem because the ' char is used as apostroph.

R

<RawXML>CDATA...CDATA</RawXML> (1.0..* Beta) - This element can be used in cases where you would like to publish a new html, css and js elmement for a webpage very quickly while template coding is not finished yet.

"Realm" (1.0..* Beta) - There is actually no Realm Element yet because Realms are represented by folders resp. directories. A Realm is thus no ordinary ce: Content Element but part of the configuration.

<ce:reflection-run/> (UDS ~v.1.5.4.20 prototype) - Element for developers which is able to list templates with match-, name-, mode- and priority-attributes.

<RoutingDefinition>, RoutingDefinition.xml <CERow> (1.0.* Beta, compatible 1.5.4.*) - The RoutingDefinition is used to define how URIs are matched on which file in which folder. The document file name for documents in UDS requires RootNode, BranchNode, SectionNode, TopicNode and AspectNode files, however, this strict naming concept might change later when the auto document detection comes into effect. Each Realm actually must have a RoutingDefinition.xml file. If it is missing, a default file of the UDS installation or 404 template will find another page that should be rendered instead. Keep in mind that a routing_config_Realms file is required before documents of a Realm are used to answer HTTP requests.

routing_config_Realms> (1.0.* Beta) | This file contains the registration of Realms. Use it to remove Realms or add Realms.

<ce:Row> <CERow> (1.5.2.* Beta, compatible 1.5.2.90) - Used for defining layout rows within CEContainer and as container for CECol columns.

S

<ce:SidePanel>, <ce:SideControlPanel> (1.5.4.28 Beta) - These SidePanel* elements are meant to be used as panels on the left or right side of the main content of a ce:WebPage and its ce:WebPageMain part. The primary use should be the placement of additional menus, forms or maybe a chat tool.

<ce:Scare Quotes> (1.5.2.* Beta) - The ce:ScareQuotes element is an inline element used as a container of text that will be start with a special type of quote which is meant to be «funny» or outline a term as «scary». IMPORTANT: Do always use ce:Quotes elements in UDS instead of placing quotes manually. See Quotes. ANNOTATION: ScareQuotes are disabled and replaced by ce:Quotes temporarily.

<CESection> <ce:Section> (1.5.2.* Beta, compatible 1.5.2.90) - Used within ce:WebPageMain/ce:contents as container for CEOuterContainer oder CEContainer.

<ce:SingleQuotes> (1.5.2.* Alpha) - IMPORTANT: Quotes in UDS are inline elements as a container for contents with a certain meaning. To differ an apostroph ' from the beginning or ending char of contents in single quotes you should use the 'ce:SingleQuotes' element. @see Quotes

<ce:Slider13> (1.0.0.* Concept, @depricated) - This slider is no longer used.

<ce:SocialMediaLinkGroup> <ce_SocialMediaPosting_ListView> <ce_SocialMediaPosting_SingleView> (1.5.2.* prototype, v.1.5.2.90) - These elements are used to place a list of SocialMedia teasers as links and their contents on a webpage by reading these news from files within a directory. This concept is quite simple, however, its rather a prototype. SocialMediaPosting elements have become quite complex as WebPage Elements to offer linking with tags, categories and adding additional information like publishing dates or even comments.

<CESoftwareSourceCode> (1.5.2.* Beta, compatible 1.5.2.90) - Used as a container for programming code with many lines of sourcecode. It's very important to use CDATA blocks. Structure: CESoftwareSourceCode/text/CDATA.

T

<ce:TableHTML> (1.5.2.88 Prototype, ***) - A ce:TableHTML element is meant to help to use common HTML table tr td tags to describe the structure of a table layout in UDS. A simple copy-paste solution of HTML code is not provider due to other HTML elements, SVG and CSS within HTML code. Alternatives: ce:GridLayout

<ce:TeaserGroup_5050-CNT-IMG> (1.5.2.* Beta, compatible 1.5.2.90) - A ce:TeaserGroup is an ItemList as layout container. Every ListItem contains a panel with an image and another panel with contents and a button. When rendering this ItemList the orientation of content and image panel with change every ListItem, so by placing a new item within a list the order of panels is automatically corrected, so you can easily move ListItems within this group.

theme.xsl> (1.0.0.*) - Der theme.xsl File ist in UDS bislang das für ein Processing von XML Files mit ce:WebPage Elementen zu HTML5 maßgebende XSL Stylesheet. Weitere erforderliche Templates werden über xsl:include nachgeladen.

<ce:Timeline> (1.5.2.* Prototype, ***) - A ce:Timeline element is a special type of ItemList where each ListItem is meant to be a certain position in time and/or a version of a software. CONTEPT

U

<ce:UnorderedList> (1.5.2.* Beta, compatible 1.5.2.90) - Used as an ItemList with ListItem elements with ce:FixedHeading-** and ce:Paragraph-** elements. Similiar to UL/LI lists in HTML, however, each ListItem should be a block element.

V

<ce:VerticalTabsPanelGroup> (1.5.2.* Prototype, @stable) - The ce:VerticalTabsPanelGroup is common layout container component with a vertical menu of "tab" button on the left side an area of on the right side where the appropriate panel for each tab button is shown if you press the tab. This element helps to reduce and compact the visual size of contents within a webpage. It should NOT be used as a replacement for menu- and navigation elements.

There is a <ce:HorizontalTabsPanelGroup> under construction where those tabs used for navigation are above or below of those panels.

<ce:ViewActionButton> (1.5.2.* Beta, compatible 1.5.2.90) - This is the typical primary button component that is used when creating call-to-action like buttons, however, ViewActionButton elements are meant to visit a page that a user wants to see/view. @see also <ce:OtherActionButton>

W

<ce:WebPage> (1.5.2.* Beta, compatible 1.5.2.90) - Used within the <doc> element of an UDS XML File. Represents a WebPage node of a WebSite. Will be rendered in HTML5 as an HTML <html>..</html> element including <head>, <body> and code for referencing CSS, JS, and more.

<ce:WebPageFooter> (1.5.2.* Beta, compatible 1.5.2.90) - Represents the placement position of a footer of the actual webpage within ce:Webpage/ce:contents. Will be represented in HTML5 output as <footer>.

<ce:WebPageHeader> (1.5.2.* Beta, compatible 1.5.2.90) - Represents the placement position of a header of the actual webpage within ce:Webpage/ce:contents. Will be represented in HTML5 output as <header>.

<ce:WebPageMain> (1.5.2.* Beta, compatible 1.5.2.90) - Used within ce:WebPage/ce:contents as a container for HTML* blocks that may contain ce:Section sections with layouts and content of a webpage. Is usually rendered semantically rendered as HTML <main>..</main> block.

<ce:WebPageSidebar> (1.5.2.* Idea) - This element might be used according to HTML5 standards among head, main, footer and aside, however, a sidebar is meant to be an element on the left or the right side of the browser window that can be opened and closed somehow. The element can already be used. It is rendered with a CSS class uio--WebPageSidebar-Module you might use in template design and coding.

X

x: One of the typical three kartesian 2d coordinates X and Y as also 3D coordinates with a Z value, used in UI components rendered with HTML5 (using z-index) and WebGL (3D rendering in most browsers).

Y

Y: The letter Y is spoken like «why» in English and «Üp-see-lonn» in German.

Z

z-index: The z-index is a CSS-property which is used to edit the position of a block element above or below other elements; an element with a higher z-index is positioned above elements with a lower z-index when ever their positions intersect. Note: In UDS you cannot change the z-index of elements. You have to use ce:PositionFrame content Elements in combination with relative and absolute coordinates to be able to place two content or layout elements at the same position.

0 (null)

0 The 0 (null) is the first index in arrays in all programming languages, and it's thus also the first index in NodeLists when elements are selected in XSL by XPATH expressions. When using function elements with the index 0 can often be adressed as the «first» element selector.

3

1 The number 1 is the first not-null positive number. In arrays the index 1 adresses the second element, because the first elements in arrays in programming languages is adressed with 0.

1-to-1 relations describe the relation or link or semantical subject-predicate-object relation between two objects. The same aspect can be found in common SQL data base design.

1-to-n, 1-to-manyrelations describe the relation or link or semantical subject-predicate-object relation between one object on the left side and many objects on the right side. In Linked Data terms a 1-to-many relation is often realized as a a certain property «a» of an A-object and a value which is an «Array», this means that the array is a container of 0 to n and thus many values for this property. In Java, C#, and C++ STL usually generic collection classes are used as a container for those many values and thus relations between one object on the left and many objects on the right. In SQL data-base design a 1-to-many relation usually requires an additional table as a table to gather relations.

2

2 The number 2 is the third index in arrays.

2D, 2-dimensional means a two-dimensional coordinates system with two axis like «X» and «Y». When creating or refering to additional coordinates systems different axis names are used, for example «N» and «M» or «UV» in WebGL when working with textures and shaders.

3

3D (@since 1.5.4.*, compatible 1.5.4.*) - A new type of renderer for components which will render elements by means of WebGL technologies in three dimensions in a browser. |

4

4-dimensional: When speaking of 4-dimensional systems in most cases people think of a 3D coordinates systems (X, Y, Z) in combination with time (T). However, the 4th dimension might also be an addition parameter like temperature level, threat level, version. When speaking of colours the first three values are RGB red green blue with a 4th value alpha for opacity or alpha-transparency.

4-sided: There several 4-sided geometries like the quadrat (all sides have the same length, and the angle is 90°), rectangulars, and other shapes. In vector graphics programming these shapes can be realized a certain types like Rect or also genenerically as Polygon.

4-point-geometry: Additional to rectangular 2D-shapes with for corners there is also a 3-dimensional geometry defined by 4 nodes in 3 dimensions: A pyramide with a 3-sided base.

5

5-sided shape: A 5-sided shape is called a «Pentagon». When programming such a shape in vector graphics usually polygons are used.

6

6-sided shape: A 6-sided shape is called a «Hexagon». When programming such a shape in vector graphics usually polygons are used. Hexagons are a common approach for grids in strategy cames: Each field of the game map offers movement in six directions instead of 4 or 8 when using quadratic squares as tiles.

7

7: The 7 (seven) is an important number when designing menues and/or to define the limit of the maximum number a user can remember: The human brain can only process and store a limited number of elements in a certain step. This is why menus or groups of items are often designed for 3 to 7 elements.

8

8-sided shapes: A shape with 8 sides is called an «Octagon». In informatics in some cases octal numbers are used; 1 Byte in informatics consists of 8 Bit with an index of 0 to 7.

9

9: The 9 is often known as the maximum number of lives a cat has. In informatics the index 9 addresses the 10th element in an Array or NodeList because the first index is 0.

@todo Upcomming: GridLayout, GridLayoutRow, GridLayoutColumn, GridLayoutHeader, GridLayoutBody, GridLayoutLegend, GridLayoutTable

Panel A Header

Content for Panel A

Dieses SidePanel A befindet sich aktuell in Entwicklung und wird als Container mitunter für einen Buchstaben-Index als Kurzwahl dienen.

Panel B Header

Content for Panel B

Panel C Header

Content for Panel C

Panel D Header

Content for Panel D

PART 4: Fußnoten

Sind Sie jemand der Inhalte von hinten aufzäumt und zu anderen Fußnoten den Text sucht, wo diese erstellt wurden? Das ist zwar schon etwas seltener zu finden. Aber warum eigentlich nicht?


    Object, Serialisierung, JSON, XML, ce:WebPage, RoutingDefinition.xml, WebPage, HeaderNavigationCluster, HeaderNavigationSwitcher, Gestaltung von Webseiten, Medien, rendern, Style, DefaultStyle, Styling, Skin, Layout-Variant, Skin-Variante,

    SO IST'S BESSER.

    Entdecke SNEWMEDIA. Es ist einfacher als Du denkst.

    Stelle noch heute Deine Anfrage.

    uio--WebPageFooter-Module