Skip to content

jQuery UI Spickzettel

Kuratiertes Set an UI-Interaktionen und Widgets auf Basis von jQuery.

01

Einstieg

Installation via CDN

jQuery UI hängt von jQuery core ab — immer zuerst jQuery laden, dann jquery-ui.js. Das CSS liefert das default theming und ist Pflicht, damit widgets wie Datepicker und Dialog korrekt erscheinen. Version 1.13.x unterstützt jQuery 1.8+.

jquery-ui
<!-- jQuery UI requires jQuery core first -->
<link rel="stylesheet"
      href="https://code.jquery.com/ui/1.13.2/themes/base/jquery-ui.css">
<script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
<script src="https://code.jquery.com/ui/1.13.2/jquery-ui.min.js"></script>

npm Installation

Installation via npm erlaubt tree-shaking, indem nur die benötigten widgets importiert werden (z. B. jquery-ui/ui/widgets/datepicker). Das volle 'jquery-ui'-Bundle enthält jedes widget und jeden effect. Das CSS theme muss separat importiert werden.

jquery-ui
# Install via npm
npm install jquery jquery-ui

# Import in your bundle
import $ from "jquery";
import "jquery-ui/ui/widgets/datepicker";
import "jquery-ui/themes/base/all.css";

// Or import the full bundle
import "jquery-ui";

Grundlegende widget-initialisierung

Alle jQuery UI widgets folgen demselben plugin muster: $(selector).widgetName(options). Ein options-objekt zur konfiguration übergeben, methoden über die string-syntax aufrufen ('methodName', args...). Initialisierung immer in $(function(){}) wickeln oder das skript an das ende von body stellen.

jquery-ui
$(function () {
  // Initialize a widget on a selector
  $("#datepicker").datepicker();
  $("#dialog").dialog();

  // Pass options as an object
  $("#accordion").accordion({
    active: false,
    collapsible: true,
  });

  // Get or set an option after init
  $("#accordion").accordion("option", "active", 1);
});

widget methoden-muster

Die string-basierte api ist über alle widgets hinweg konsistent. 'option' getter/setter, 'enable'/'disable', 'widget' (gibt das äußerste element zurück) und 'destroy' (stellt das original markup wieder her) unterstützt jedes widget. destroy beim entfernen von elementen nutzen, um speicherlecks zu vermeiden.

jquery-ui
// All widgets share the same API conventions
$("#dialog").dialog("open");              // call a method
$("#dialog").dialog("option", "title");   // get an option
$("#dialog").dialog("option", "modal", true); // set an option
$("#dialog").dialog("disable");           // disable widget
$("#dialog").dialog("enable");            // enable widget
$("#dialog").dialog("widget");            // get the wrapper element
$("#dialog").dialog("destroy");           // remove widget entirely

theme konfiguration

jQuery UI bringt ~24 vorgebaute themes mit. Das 'base'-theme ist der default. ThemeRoller (themroller.jqueryui.com) erzeugt eigene themes. das eigene CSS nach dem base laden, um konkrete klassen wie .ui-widget-header oder .ui-state-default zu übersteuern.

jquery-ui
<!-- Default base theme -->
<link rel="stylesheet"
      href="https://code.jquery.com/ui/1.13.2/themes/base/jquery-ui.css">

<!-- Other bundled themes: ui-lightness, ui-darkness, smoothness, redmond, ... -->
<link rel="stylesheet"
      href="https://code.jquery.com/ui/1.13.2/themes/smoothness/jquery-ui.css">

<!-- Override theme with your own CSS -->
<link rel="stylesheet" href="jquery-ui.css">
<link rel="stylesheet" href="my-theme-overrides.css">

klassen-namenskonvention

Das CSS framework nutzt eine konsistente ui-*-namenskonvention. interaktions-zustände (default, hover, active, focus) wenden widgets automatisch an. diese klassen lassen sich direkt im eigenen markup verwenden, um dem jQuery UI styling zu entsprechen.

jquery-ui
/* jQuery UI CSS classes are namespaced with ui- */
.ui-widget         /* base widget class */
.ui-widget-header  /* header bar (accordion, datepicker) */
.ui-widget-content /* content area */
.ui-state-default  /* default interactive state */
.ui-state-hover    /* mouse-over state */
.ui-state-active   /* active/selected state */
.ui-state-focus    /* keyboard focus state */
.ui-state-disabled /* disabled state */
.ui-corner-all     /* rounded corners (themable) */
.ui-icon           /* base icon class */
02

Draggable

einfacher draggable

Ein element draggable zu machen ist ein einzelner aufruf. das element lässt sich dann mit der maus bewegen. die klasse ui-widget-content wendet das default theme styling an. draggable übernimmt die positionierung — relative/absolute wird je bedarf angewandt.

jquery-ui
<!-- HTML -->
<div id="box" class="ui-widget-content" style="width:100px;height:100px;">
  Drag me
</div>

<!-- JS -->
<script>
  $(function () {
    $("#box").draggable();
  });
</script>

draggable optionen

optionen steuern das ziehverhalten. 'axis' begrenzt die bewegung auf eine achse, 'containment' den zieh-bereich, 'grid' rastet auf intervalle, und 'revert' bringt das element zur startposition zurück. 'helper: clone' zieht eine kopie statt des originals.

jquery-ui
$("#box").draggable({
  axis: "x",              // constrain to x or y axis
  containment: "parent",  // or "window", "document", or selector
  cursor: "move",         // cursor while dragging
  cursorAt: { left: 5 },  // offset cursor from drag handle
  grid: [20, 20],         // snap to grid
  delay: 100,             // ms delay before drag starts
  distance: 5,            // px before drag starts
  revert: true,           // snap back to start
  revertDuration: 200,    // revert animation duration
  scroll: false,          // prevent auto-scroll
  helper: "clone",        // "original", "clone", or function
  opacity: 0.6,           // opacity while dragging
  zIndex: 1000,           // z-index while dragging
});

drag events

drei events feuern während des ziehens: 'start' (einmal am anfang), 'drag' (fortlaufend bei bewegung) und 'stop' (einmal am ende). das ui objekt liefert position (relativ zum parent) und offset (relativ zur seite). schwere arbeit in 'drag' kostet performance.

jquery-ui
$("#box").draggable({
  start: function (event, ui) {
    console.log("Drag started", ui.position);
  },
  drag: function (event, ui) {
    // Fires continuously during drag
    console.log(ui.position.left, ui.position.top);
  },
  stop: function (event, ui) {
    console.log("Drag stopped at", ui.position);
    console.log("Offset:", ui.offset);
  },
});

handle & cancel

'handle' beschränkt den zieh-start auf ein konkretes kind-element — nützlich, wenn die ganze box beweglich sein soll, aber nur über eine titelleiste. 'cancel' verhindert das ziehen von bestimmten elementen wie inputs oder textareas, wo die maus-interaktion fürs bearbeiten gebraucht wird.

jquery-ui
<!-- Only the header acts as the drag handle -->
<div id="box" class="ui-widget-content">
  <div class="drag-handle">Drag from here</div>
  <div class="content">Some content here</div>
  <textarea>Editable content</textarea>
</div>

<script>
  $("#box").draggable({
    handle: ".drag-handle",   // only this starts the drag
    cancel: "textarea",       // these elements never start a drag
  });
</script>

bewegung begrenzen

containment beschränkt, wohin das element gezogen werden kann. 'parent', 'window', 'document', ein selektor oder ein explizites [x1,y1,x2,y2]-array funktionieren. mit 'grid' kombiniert entstehen präzise, gerastete positionierungen für layout editoren oder dashboards.

jquery-ui
// Constrain within a parent element
$("#box").draggable({ containment: "parent" });

// Constrain within the window
$("#box").draggable({ containment: "window" });

// Constrain within a specific selector
$("#box").draggable({ containment: "#drag-area" });

// Constrain to an explicit bounding box [x1, y1, x2, y2]
$("#box").draggable({ containment: [0, 0, 500, 300] });

// Snap to a 50px grid
$("#box").draggable({ grid: [50, 50] });

an elemente snappen

'snap' lässt den draggable auf ziel-elemente einrasten, wenn er nah genug ist. 'snapMode' steuert die ausrichtung: 'inner' (innerhalb des ziels), 'outer' (außerhalb) oder 'both'. nützlich für diagramm-werkzeuge oder dashboard layouts, wo sich elemente ausrichten sollen.

jquery-ui
$(".card").draggable({
  snap: ".snap-target",     // selector of elements to snap to
  snapMode: "inner",        // "inner", "outer", or "both"
  snapTolerance: 30,        // px distance to trigger snap
});

// Snap to all siblings of the same class
$(".card").draggable({
  snap: ".card",
  snapTolerance: 20,
});
03

Droppable

einfacher droppable

droppable definiert eine ziel-fläche, die gezogene elemente akzeptiert. der 'drop' callback feuert, wenn ein draggable darüber losgelassen wird. ui.draggable liefert eine referenz auf das gezogene element, um es zu bewegen oder zu verarbeiten.

jquery-ui
<div id="draggable" class="ui-widget-content">Drag me</div>
<div id="droppable" class="ui-widget-header">Drop here</div>

<script>
  $(function () {
    $("#draggable").draggable();
    $("#droppable").droppable({
      drop: function (event, ui) {
        $(this).addClass("ui-state-highlight")
               .html("Dropped!");
      },
    });
  });
</script>

droppable optionen

'accept' filtert, welche draggables erlaubt sind — ein selektor oder eine funktion. 'activeClass' und 'hoverClass' liefern visuelles feedback. 'greedy: true' verhindert, dass verschachtelte droppables beide das drop event erhalten — praktisch für verschachtelte drop-zonen.

jquery-ui
$("#droppable").droppable({
  accept: ".special",       // only accept matching draggables
  activeClass: "ui-state-default",  // class while a drag is active
  hoverClass: "ui-state-hover",     // class while draggable is over
  tolerance: "fit",         // drop detection mode
  greedy: true,             // stop event propagation
  disabled: false,          // disable the droppable
});

drop events

fünf events decken den ganzen drop lebenszyklus ab. 'activate'/'deactivate' feuern, wenn ein passender drag beginnt/endet. 'over'/'out' feuern, wenn der draggable die zone betritt/verlässt. 'drop' feuert nur bei erfolgreichem loslassen. damit progressives visuelles feedback bauen.

jquery-ui
$("#droppable").droppable({
  activate: function (event, ui) {
    // Fires when an accepted draggable starts moving
    $(this).addClass("ui-state-default");
  },
  deactivate: function (event, ui) {
    // Fires when the drag ends (drop or cancel)
    $(this).removeClass("ui-state-default");
  },
  over: function (event, ui) {
    // Draggable entered the drop zone
    $(this).addClass("ui-state-hover");
  },
  out: function (event, ui) {
    // Draggable left the drop zone
    $(this).removeClass("ui-state-hover");
  },
  drop: function (event, ui) {
    // Draggable was released here
    console.log("Dropped:", ui.draggable);
  },
});

accept selektor

'accept' kann ein selektor-string oder eine funktion sein, die einen boolean liefert. die funktion erhält das gezogene element und läuft für jeden kandidaten — so sind runtime-logiken wie data attribute oder berechnete zustände möglich. nicht akzeptierte draggables triggern keine drop events.

jquery-ui
<!-- HTML: red and blue boxes -->
<div class="red draggable">Red</div>
<div class="blue draggable">Blue</div>

<div id="red-bin" class="bin">Red bin</div>
<div id="blue-bin" class="bin">Blue bin</div>

<script>
  // Only accept elements matching the selector
  $("#red-bin").droppable({ accept: ".red" });
  $("#blue-bin").droppable({ accept: ".blue" });

  // Or use a function for dynamic logic
  $("#any-bin").droppable({
    accept: function (drag) {
      return $(drag).data("category") === "recyclable";
    },
  });
</script>

toleranz-modi

tolerance definiert, wie viel überlappung für einen drop nötig ist. 'fit' ist am strengsten (ganzes element innen). 'pointer' richtet sich nach dem maus-cursor. 'intersect' (50% überlappung) ist ein guter mittweg für die meisten UIs. 'touch' ist am großzügigsten.

jquery-ui
$("#droppable").droppable({
  // "fit": draggable must be fully inside (default)
  tolerance: "fit",

  // "intersect": at least 50% overlap
  tolerance: "intersect",

  // "pointer": mouse pointer must be inside
  tolerance: "pointer",

  // "touch": any edge touching counts
  tolerance: "touch",
});

visuelles feedback mit klassen

activeClass (erscheint, solange ein akzeptierter drag läuft) und hoverClass (erscheint, wenn der draggable über der zone ist) kombinieren, um nutzern klares feedback zu geben. im drop handler hängt man den draggable typischerweise an, um ihn in die drop zone umzuhängen.

jquery-ui
<!-- CSS -->
<style>
  .drop-active { border: 2px dashed #ccc; }
  .drop-hover  { border: 2px solid #0a0; background: #efe; }
</style>

<!-- JS -->
$("#zone").droppable({
  accept: ".item",
  activeClass: "drop-active",
  hoverClass: "drop-hover",
  drop: function (event, ui) {
    $(this).append(ui.draggable);
    ui.draggable.css({ top: 0, left: 0 });
  },
});
04

Resizable

einfacher resizable

resizable ergänzt resize griffe an einem element. per default erscheint ein griff an der ecke unten rechts (se). das element braucht positionierung (relative/absolute), damit die griffe korrekt verankern.

jquery-ui
<div id="box" class="ui-widget-content">
  Resize me from the corner
</div>

<script>
  $(function () {
    $("#box").resizable();
  });
</script>

resize griffe

'handles' steuert, welche kanten/ecken resize-grips bekommen. himmelsrichtungen nutzen: n, e, s, w, ne, se, sw, nw. der default ist 'e, s, se'. eigene handle elemente per selektor liefern für volle stil-kontrolle.

jquery-ui
$("#box").resizable({
  handles: "n, e, s, w, ne, se, sw, nw",  // all eight handles
});

// Or specify handle elements
$("#box").resizable({
  handles: {
    n: ".n-handle",
    se: ".se-handle",
  },
});

resizable optionen

optionen begrenzen und passen das resizen an. 'aspectRatio' hält die proportionen (super für bilder/video). 'alsoResize' synchronisiert ein weiteres element. 'ghost' zeigt während des resizens einen schwachen preview, die echte größe greift beim loslassen. min/max maße erzwingen grenzen.

jquery-ui
$("#box").resizable({
  alsoResize: "#other",     // resize another element in sync
  animate: true,            // animate to final size
  animateDuration: 200,     // ms
  aspectRatio: 16 / 9,      // preserve width:height ratio
  autoHide: true,           // hide handles until hover
  containment: "parent",    // restrict resize within parent
  grid: [10, 10],           // snap to grid
  maxHeight: 400,
  maxWidth: 600,
  minHeight: 100,
  minWidth: 100,
  ghost: true,              // show a ghost outline while resizing
});

resize events

wie draggable feuert resize start/resize/stop. das ui objekt hat 'size' (width, height) und 'position' (left, top). beim resizen von nord- oder westkanten ändern sich size und position. das resize event nutzen, um abhängige UI wie eine live preview zu aktualisieren.

jquery-ui
$("#box").resizable({
  start: function (event, ui) {
    console.log("Resize start", ui.size, ui.position);
  },
  resize: function (event, ui) {
    // Fires continuously during resize
    ui.size.width;   // new width
    ui.size.height;  // new height
    ui.position.left; // new position (may change for n/w handles)
  },
  stop: function (event, ui) {
    console.log("Final size:", ui.size);
  },
});

aspect ratio & constraints

aspectRatio (eine zahl oder boolean true zum fixieren des aktuellen verhältnisses) für bilder und medien nutzen. kombiniert mit min/max-constraints lassen sich unpassende größen verhindern. grid snapping richtet auf intervalle aus — nützlich für editor-interfaces und layout werkzeuge.

jquery-ui
// Keep a 4:3 ratio
$("#photo").resizable({ aspectRatio: 4 / 3 });

// Keep ratio and stay within bounds
$("#photo").resizable({
  aspectRatio: 4 / 3,
  maxWidth: 800,
  maxHeight: 600,
  minWidth: 100,
  minHeight: 75,
});

// Snap to a grid of 20px
$("#grid-box").resizable({ grid: [20, 20] });

animate & ghost modi

'animate' transitioniert nach dem loslassen geschmeidig zur neuen größe. 'ghost' zeigt während des ziehens einen halbtransparenten preview und wendet die echte änderung erst beim loslassen an. zusammen entsteht ein poliertes, ruckelfreies resize-erlebnis.

jquery-ui
// Animate to the final size after release
$("#box").resizable({
  animate: true,
  animateDuration: "slow",   // or ms number
  animateEasing: "swing",
});

// Show a ghost outline while dragging, apply on release
$("#box").resizable({
  ghost: true,
  helper: "ui-resizable-helper",  // class for the ghost
});

// Combine both
$("#box").resizable({ ghost: true, animate: true });
05

Selectable

einfacher selectable

selectable macht eine liste von kindern zu einer auswählbaren gruppe. klicken wählt aus, oder ein lasso ziehen wählt mehrere. ctrl/cmd ergänzt zur auswahl, shift wählt einen bereich. ausgewählte items bekommen automatisch die klasse ui-selected.

jquery-ui
<ol id="selectable">
  <li class="ui-widget-content">Item 1</li>
  <li class="ui-widget-content">Item 2</li>
  <li class="ui-widget-content">Item 3</li>
</ol>

<script>
  $(function () {
    $("#selectable").selectable();
  });
</script>

selectable optionen

'filter' beschränkt, welche kinder teilnehmen. 'tolerance' steuert das lasso-verhalten: 'touch' wählt bei jeder überlappung (default), 'fit' verlangt volle umschließung. 'autoRefresh: false' bei großen listen setzen für bessere performance — danach $(...).selectable('refresh') manuell nach layout-änderungen aufrufen.

jquery-ui
$("#selectable").selectable({
  filter: "li",            // which children can be selected
  tolerance: "touch",      // "touch" or "fit" for lasso overlap
  distance: 0,             // px before lasso starts
  delay: 0,                // ms delay before lasso starts
  autoRefresh: true,       // recompute positions on each drag
  disabled: false,
  cancel: "a, .no-select", // elements that never start selection
});

select events

events feuern während des auswahl-lebenszyklus: 'selecting'/'unselecting' beim ziehen, 'selected'/'unselected' nach bestätigung, und 'start'/'stop' für die gesamtoperation. jedes ui objekt hat das relevante element (selecting, selected usw.).

jquery-ui
$("#selectable").selectable({
  selecting: function (event, ui) {
    // ui.selecting: element being lassoed
    $(ui.selecting).addClass("highlight");
  },
  selected: function (event, ui) {
    // ui.selected: element just confirmed selected
    console.log("Selected:", $(ui.selected).text());
  },
  unselecting: function (event, ui) {
    $(ui.unselecting).removeClass("highlight");
  },
  unselected: function (event, ui) {
    console.log("Unselected:", $(ui.unselected).text());
  },
  start: function (event, ui) { /* lasso started */ },
  stop: function (event, ui) { /* lasso released */ },
});

items filtern

'filter' erlaubt nur konkrete kinder zur auswahl, 'cancel' schließt andere aus. nützlich für galerien, bei denen manche items (gesperrt, schreibgeschützt) nicht teilnehmen sollen. das lasso ignoriert nicht passende elemente einfach.

jquery-ui
<ul id="gallery">
  <li class="selectable-item">Photo 1</li>
  <li class="locked">Locked</li>
  <li class="selectable-item">Photo 2</li>
</ul>

<script>
  $("#gallery").selectable({
    filter: ".selectable-item",  // only these can be selected
    cancel: ".locked",            // locked items never select
  });
</script>

ausgewählte items stylen

jQuery UI wendet automatisch die klassen ui-selecting (beim ziehen) und ui-selected (nach dem loslassen) an. diese stylen, um feedback zu geben. die aktuelle auswahl jederzeit über $('.ui-selected') innerhalb des containers lesen — praktisch für toolbars und massenaktionen.

jquery-ui
/* CSS */
#selectable .ui-selecting {
  background: #feca40;        /* while dragging */
}
#selectable .ui-selected {
  background: #f39814;        /* confirmed selection */
  color: white;
}
#selectable li {
  margin: 3px; padding: 6px;
  border: 1px solid #ccc;
}

/* selected count badge */
function updateCount() {
  var n = $("#selectable .ui-selected").length;
  $("#count").text(n + " selected");
}
$("#selectable").on("selectablestop", updateCount);

programmatische auswahl

'refresh' nach dem ergänzen/entfernen von items aufrufen, damit das lasso hit-testing korrekt bleibt. eine eingebaute 'select'-methode gibt es nicht, aber die klasse ui-selected lässt sich manuell togglen. leeren durch entfernen der klasse an allen items.

jquery-ui
// Refresh positions after DOM changes
$("#selectable").selectable("refresh");

// Disable / enable
$("#selectable").selectable("disable");
$("#selectable").selectable("enable");

// Remove the widget
$("#selectable").selectable("destroy");

// Manually select an item (set the class)
$("#selectable li").eq(2).addClass("ui-selected");

// Clear all selections
$("#selectable .ui-selected").removeClass("ui-selected");
06

Sortable

einfacher sortable

sortable macht listen-items per drag umsortierbar. items werden beim ziehen visuell bewegt und die DOM reihenfolge beim loslassen aktualisiert. nützlich für task listen, foto-galerien und jeden inhalt mit prioritäts-reihenfolge.

jquery-ui
<ul id="sortable">
  <li class="ui-widget-content">Item 1</li>
  <li class="ui-widget-content">Item 2</li>
  <li class="ui-widget-content">Item 3</li>
</ul>

<script>
  $(function () {
    $("#sortable").sortable();
  });
</script>

sortable optionen

optionen verfeinern das sortierverhalten. 'placeholder' stylt die hinterlassene lücke; forcePlaceholderSize stellt sicher, dass sie den item-maßen entspricht. 'axis' begrenzt auf horizontal/vertikal. 'handle' legt einen zieh-griff fest — ideal, wenn das ganze item interaktive kinder hat.

jquery-ui
$("#sortable").sortable({
  axis: "y",                // constrain to vertical
  cursor: "move",
  handle: ".handle",        // drag from this element only
  placeholder: "sortable-placeholder", // class for the drop preview
  forcePlaceholderSize: true, // match placeholder to item size
  helper: "clone",          // "original" or "clone"
  opacity: 0.7,
  revert: true,             // animate item into place
  tolerance: "pointer",     // "intersect" or "pointer"
  scroll: true,             // auto-scroll the page
  containment: "parent",    // restrict within parent
});

sort events

kern-events: 'start'/'stop' umschließen das sortieren. 'change' feuert, wenn sich die position des items beim ziehen ändert. 'update' feuert nur, wenn die endgültige reihenfolge von der anfangs abweicht — hier die neue reihenfolge persistieren, meist via toArray(), das die item IDs in ordnung liefert.

jquery-ui
$("#sortable").sortable({
  start: function (event, ui) {
    ui.item;            // the dragged element
    ui.placeholder;     // the placeholder element
    ui.helper;          // the helper being dragged
  },
  change: function (event, ui) {
    // Position in list changed during drag
  },
  sort: function (event, ui) {
    // Fires continuously while sorting
  },
  beforeStop: function (event, ui) {
    // Just before the item is placed
  },
  stop: function (event, ui) {
    console.log("Sort ended");
  },
  update: function (event, ui) {
    // Order actually changed — persist it here
    var order = $(this).sortable("toArray");
    saveOrder(order);
  },
});

verbundene listen

'connectWith' verknüpft mehrere sortables, sodass items zwischen ihnen gezogen werden können — super für kanban boards oder pipeline manager. jede liste verfolgt weiterhin ihre eigene reihenfolge via toArray(). die receive/remove events nutzen, um auf listen-übergreifende verschiebungen zu reagieren.

jquery-ui
<ul id="list-a" class="connected">
  <li>Task A1</li><li>Task A2</li>
</ul>
<ul id="list-b" class="connected">
  <li>Task B1</li>
</ul>

<script>
  $(".connected").sortable({
    connectWith: ".connected",  // allow moving between lists
    placeholder: "ui-state-highlight",
  }).disableSelection();
</script>

Platzhalter & Helper

der placeholder ist der leere raum, an dem das item landen wird — stylen für klares drop feedback. forcePlaceholderSize ist wichtig, wenn items verschiedene höhen haben. eine eigene helper funktion erlaubt einen vereinfachten preview beim ziehen.

jquery-ui
$("#sortable").sortable({
  placeholder: "ui-state-highlight",  // class for the gap
  forcePlaceholderSize: true,
  helper: function (event, el) {
    // Return a custom helper element
    return $("<div class='custom-helper'>Moving...</div>");
  },
  cursorAt: { top: 10, left: 10 },
});

// Use a clone as the helper instead of moving the original
$("#sortable").sortable({ helper: "clone" });

sort methoden

toArray() liefert IDs in aktueller reihenfolge — am nützlichsten für persistenz. serialize() baut einen query string, wenn IDs der 'name_number'-konvention folgen. cancel() macht den letzten sort rückgängig. refresh() nach programmatischem ergänzen von items aufrufen.

jquery-ui
// Get current order as an array of IDs
var order = $("#sortable").sortable("toArray");
// ["item-1", "item-3", "item-2"]

// Get option values
var placeholder = $("#sortable").sortable("option", "placeholder");

// Serialize items as a query string (uses id="name_number")
var data = $("#sortable").sortable("serialize");
// "item[]=1&item[]=2&item[]=3"

// Cancel the current sort (revert)
$("#sortable").sortable("cancel");

// Refresh positions after DOM changes
$("#sortable").sortable("refresh");

// Disable / enable / destroy
$("#sortable").sortable("disable");
$("#sortable").sortable("enable");
$("#sortable").sortable("destroy");
07

Accordion

einfaches accordion

accordion erwartet paare aus header + inhalt-elementen (der header muss zuerst kommen). per default ist nur ein abschnitt gleichzeitig offen. das default header element ist h3, änderbar über die header option. inhalt-panels folgen jeweils einem header.

jquery-ui
<div id="accordion">
  <h3>Section 1</h3>
  <div>Content for section 1</div>
  <h3>Section 2</h3>
  <div>Content for section 2</div>
  <h3>Section 3</h3>
  <div>Content for section 3</div>
</div>

<script>
  $(function () {
    $("#accordion").accordion();
  });
</script>

accordion optionen

'collapsible: true' setzen, um alle panels geschlossen zu erlauben (default erzwingt ein offenes). 'heightStyle: content' misst jedes panel an seinem inhalt; 'fill' macht alle panels gleich hoch wie der container; 'auto' nutzt die höhe des größten panels.

jquery-ui
$("#accordion").accordion({
  active: 0,                 // index of open panel (false = all closed)
  collapsible: true,         // allow closing all panels
  disabled: false,
  animate: 200,              // ms or "ease name" or false
  heightStyle: "content",    // "auto", "fill", or "content"
  header: "h3",              // header selector
  icons: {
    header: "ui-icon-triangle-1-e",
    activeHeader: "ui-icon-triangle-1-s",
  },
  event: "click",            // event that toggles panels
});

accordion events

beforeActivate erlaubt es, einen panelwechsel durch false zurückgeben zu verweigern — nützlich bei warnungen vor ungespeicherten änderungen. activate feuert nach ablauf der animation. das ui objekt liefert alte/neue header- und panel-elemente für beide events.

jquery-ui
$("#accordion").accordion({
  beforeActivate: function (event, ui) {
    // ui.oldHeader, ui.oldPanel (closing)
    // ui.newHeader, ui.newPanel (opening)
    // Return false to cancel
    if ($(ui.newHeader).data("locked")) return false;
  },
  activate: function (event, ui) {
    // Fires after a panel finishes opening
    console.log("Opened:", ui.newHeader.text());
  },
  create: function (event, ui) {
    // Fires on initialization
    console.log("Accordion created, open:", ui.header.text());
  },
});

eigene icons

icons mappt die icon-klassen für geschlossen (header) und offen (activeHeader). false übergeben schaltet icons ab. jede icon bibliothek (fontawesome, material icons) ist nutzbar, indem die passenden klassennamen geliefert werden — der icon span entsteht automatisch.

jquery-ui
$("#accordion").accordion({
  icons: {
    header: "ui-icon-circle-arrow-e",
    activeHeader: "ui-icon-circle-arrow-s",
  },
});

// Disable icons entirely
$("#accordion").accordion({ icons: false });

// Use your own icon classes (e.g. with FontAwesome)
$("#accordion").accordion({
  icons: {
    header: "fa fa-plus",
    activeHeader: "fa fa-minus",
  },
});

collapsible & mehrere abschnitte

für ein echtes 'mehrere gleichzeitig offen'-accordion: jQuery UIs accordion unterstützt das nativ nicht — stattdessen je abschnitt separate collapsible accordions initialisieren oder tabs nutzen. 'collapsible: true' erlaubt nur, das aktuell offene panel zu schließen.

jquery-ui
// Allow all panels to be closed
$("#accordion").accordion({
  collapsible: true,
  active: false,   // start with all closed
});

// Make every section independently toggleable
// (a true multi-open accordion = separate collapsibles)
$(".section").each(function () {
  $(this).accordion({
    collapsible: true,
    active: false,
    header: ".section-header",
  });
});

dynamisches accordion

refresh() nach dem ergänzen oder entfernen von panels aufrufen, damit das widget neu bindet. die active option öffnet ein panel programmatisch per index. das beforeActivate muster ist ein sauberer weg, panel-inhalt per AJAX erst beim ersten öffnen nachzuladen.

jquery-ui
// Refresh after adding content
$("#accordion").append("<h3>New</h3><div>Content</div>");
$("#accordion").accordion("refresh");

// Switch the open panel
$("#accordion").accordion("option", "active", 2);

// Disable / enable
$("#accordion").accordion("disable");
$("#accordion").accordion("enable");

// Destroy
$("#accordion").accordion("destroy");

// Load content on demand (AJAX-style)
$("#accordion").accordion({
  beforeActivate: function (event, ui) {
    var panel = ui.newPanel;
    if (panel.is(":empty")) {
      panel.load("/api/section/" + ui.newHeader.data("id"));
    }
  },
});
08

Autocomplete

einfaches autocomplete

ein einfaches array von strings an 'source' übergeben für statische vorschläge. das widget filtert per teilstring, während der nutzer tippt. vorschläge erscheinen in einem dropdown; eine auswahl füllt das input. die liste kann auch {label, value}-objekte enthalten für reichhaltigere anzeige.

jquery-ui
<label for="city">City:</label>
<input id="city" type="text">

<script>
  $(function () {
    var cities = ["London", "Paris", "Berlin", "Madrid", "Rome"];
    $("#city").autocomplete({ source: cities });
  });
</script>

remote datenquelle

ist source eine URL, sendet autocomplete eine GET anfrage mit ?term= dem getippten text und erwartet ein JSON array. minLength schiebt die anfrage auf, bis genug zeichen getippt sind, und senkt die server-last. die delay option debounct schnelles tippen.

jquery-ui
$("#city").autocomplete({
  source: "/api/cities",   // server endpoint
  minLength: 2,            // start suggesting after 2 chars
  delay: 300,              // ms between keystroke and request
});

// The server should return JSON like:
// ["London", "Paris", "Berlin"]
// or [{ "label": "London, UK", "value": "London" }]

autocomplete optionen

autoFocus: true hebt den ersten vorschlag hervor, sodass enter ihn sofort wählt. position konfiguriert die menü-platzierung relativ zum input über jQuery UI position. appendTo ist nützlich, wenn das input in einem absolut positionierten container mit overflow-problemen liegt.

jquery-ui
$("#city").autocomplete({
  source: cities,          // array, URL, or function
  minLength: 1,            // chars before suggestions appear
  delay: 300,              // ms between keystroke and request
  autoFocus: true,         // focus first item automatically
  appendTo: "#container",  // where to render the menu
  position: { my: "left top", at: "left bottom" },
  disabled: false,
});

eigene source funktion

eine funktions-source gibt volle kontrolle — nützlich für caching, eigene filterung oder das kombinieren mehrerer endpunkte. response(results) MUSS mit einem array aufgerufen werden, auch wenn es leer ist. jedes item darf felder jenseits von label/value tragen, erreichbar im select handler.

jquery-ui
$("#city").autocomplete({
  source: function (request, response) {
    // request.term is the typed text
    // response() must be called with the results array
    $.getJSON("/api/cities", { q: request.term })
      .done(function (data) {
        response(data);
      })
      .fail(function () {
        response([]);  // always call response, even on error
      });
  },
  select: function (event, ui) {
    // ui.item.label, ui.item.value
    $("#city-id").val(ui.item.id);
  },
});

autocomplete events

focus feuert, während der nutzer durch die vorschläge wandert (tastatur oder hover). select feuert, wenn ein item gewählt wird. change feuert beim blur und ist der richtige ort zu prüfen, ob der endgültige wert in der source existiert. false zurückgeben verhindert das default eingabefüllen.

jquery-ui
$("#city").autocomplete({
  source: cities,
  focus: function (event, ui) {
    // Fires when an item is highlighted (not selected)
    $("#preview").text(ui.item.label);
    return false;  // prevent setting the input value on focus
  },
  select: function (event, ui) {
    // Fires when an item is chosen
    $("#city").val(ui.item.label);
    $("#city-id").val(ui.item.value);
    return false;  // prevent default behavior
  },
  change: function (event, ui) {
    // Fires when input loses focus
    if (!ui.item) {
      // User typed something not in the list
      console.log("No match:", this.value);
    }
  },
});

kategorien & eigenes rendering

_renderMenu oder _renderItem übersteuern, um das dropdown-layout anzupassen. dieses beispiel gruppiert vorschläge nach kategorie mit header-zeilen. das $.widget muster erweitert das basis-autocomplete, also funktionieren alle original optionen und events weiter. üblich bei such-interfaces.

jquery-ui
$.widget("custom.catcomplete", $.ui.autocomplete, {
  _renderMenu: function (ul, items) {
    var that = this, currentCategory = "";
    $.each(items, function (index, item) {
      if (item.category !== currentCategory) {
        ul.append("<li class='ui-autocomplete-category'>"
          + item.category + "</li>");
        currentCategory = item.category;
      }
      that._renderItemData(ul, item);
    });
  },
});

// Use the new widget
$("#search").catcomplete({
  source: [
    { label: "Java", category: "Languages" },
    { label: "JavaScript", category: "Languages" },
    { label: "React", category: "Frameworks" },
  ],
});
09

Button

einfacher button

das button widget themt jedes klickbare element (button, input[type=submit], a) im jQuery UI stil. es ergänzt die klasse ui-button und verwaltet hover/active/focus zustände. anchors werden button-artig gestylt — praktisch für navigation, die wie buttons aussehen soll.

jquery-ui
<!-- Apply to button, input, or anchor elements -->
<button id="btn">Click me</button>
<input type="submit" id="submit" value="Submit">
<a href="#" id="link" class="btn">Link button</a>

<script>
  $(function () {
    $("#btn").button();
    $("#submit").button();
    $("#link").button();
  });
</script>

button optionen

'icon' und 'showLabel' kombinieren erzeugt icon-only buttons (kompakte toolbars). 'iconPosition' steuert, ob das icon vor oder hinter dem text steht. 'label' setzt den text programmatisch — praktisch, wenn er sich zur laufzeit ändert (z. b. start/stop toggle).

jquery-ui
$("#btn").button({
  disabled: false,
  text: true,              // show the label text
  icon: "ui-icon-gear",    // primary icon class
  iconPosition: "beginning", // "beginning" or "end"
  showLabel: true,         // text or icon only
  label: "Save",           // override the button's text
});

// Icon-only button (must set showLabel: false)
$("#icon-btn").button({
  icon: "ui-icon-disk",
  showLabel: false,
});

buttonset (radio/checkbox groups)

buttonset gruppiert radio buttons oder checkboxes zu einer visuell verbundenen toolbar. in jQuery UI 1.12+ wurde buttonset zugunsten von controlgroup() deprecated, das flexibler ist und mit jedem input typ funktioniert. jedes input braucht ein passendes label.

jquery-ui
<div id="size-set">
  <input type="radio" id="s1" name="size"><label for="s1">S</label>
  <input type="radio" id="s2" name="size" checked><label for="s2">M</label>
  <input type="radio" id="s3" name="size"><label for="s3">L</label>
</div>

<script>
  $("#size-set").buttonset();

  // For checkboxes (multi-select):
  // $("#check-set").controlgroup();  // 1.12+
</script>

icons

jQuery UI bringt einen sprite mit ~170 icons mit, präfixiert mit ui-icon-. häufige: ui-icon-gear, ui-icon-trash, ui-icon-search, ui-icon-close. das volle set auf api.jqueryui.com/theming/icons ansehen. icons zur laufzeit über die option methode umschalten für play/pause-artige toggles.

jquery-ui
// Primary icon
$("#save").button({ icon: "ui-icon-disk" });

// Icon only (no text)
$("#play").button({
  icon: "ui-icon-play",
  showLabel: false,
});

// Change icon at runtime
$("#play").button("option", "icon", "ui-icon-pause");

// Available icons include:
// ui-icon-gear, ui-icon-disk, ui-icon-trash,
// ui-icon-search, ui-icon-close, ui-icon-check,
// ui-icon-arrowthick-1-n/e/s/w, and many more

split button (toolbar)

jQuery UI hat keinen nativen split button — einen aus normalem button, icon-only button und einem versteckten menu kombinieren. der pfeil-button togglest das menü. dieses muster ist bei reichen toolbars üblich, etwa e-mail clients oder dokument-editoren.

jquery-ui
<div class="toolbar">
  <button id="save">Save</button>
  <button id="save-arrow"><span class="ui-icon ui-icon-triangle-1-s"></span></button>
</div>

<script>
  $("#save").button();
  $("#save-arrow").button({ text: false, icon: "ui-icon-triangle-1-s" });

  $("#save-arrow").on("click", function () {
    $("#menu").menu("widget").show();
  });
</script>

<!-- Combine with a Menu for a true split button -->
<ul id="menu" style="display:none;">
  <li><div>Save</div></li>
  <li><div>Save As...</div></li>
  <li><div>Export</div></li>
</ul>

button methoden

über die option methode label, icon oder disabled zur laufzeit ändern — typisch für zustandsbehaftete buttons wie 'senden' → 'lädt...'. refresh liest den elementzustand neu (praktisch bei programmatisch getoggleten checkboxes). destroy entfernt das gesamte styling.

jquery-ui
// Disable / enable
$("#btn").button("disable");
$("#btn").button("enable");

// Change options
$("#btn").button("option", "label", "Loading...");
$("#btn").button("option", "disabled", true);

// Get the button element
$("#btn").button("widget");

// Refresh after DOM changes (e.g. removing a class)
$("#btn").button("refresh");

// Remove the widget
$("#btn").button("destroy");
10

Datepicker

einfacher datepicker

ein klick oder der fokus aufs input öffnet ein kalender-popup. das gewählte datum füllt das input als text. der kalender zeigt den aktuellen monat mit navigations-pfeilen für vorigen/nächsten monat. per default nutzen daten das US format (mm/dd/yy).

jquery-ui
<label for="date">Pick a date:</label>
<input type="text" id="date">

<script>
  $(function () {
    $("#date").datepicker();
  });
</script>

datepicker optionen

minDate/maxDate akzeptieren ein date objekt, eine zahl (tage ab heute) oder einen string ('+1M +1W'). numberOfMonths zeigt mehrere monate — hilfreich für datums-bereichs-picker. changeMonth/changeYear ergänzen dropdowns zum springen zu fernen jahren.

jquery-ui
$("#date").datepicker({
  dateFormat: "yy-mm-dd",     // ISO format
  defaultDate: "+1",          // tomorrow when calendar opens
  minDate: 0,                 // no past dates (today+)
  maxDate: "+1Y",             // up to one year ahead
  numberOfMonths: 2,          // show 2 months side by side
  showButtonPanel: true,      // Today/Done buttons
  changeMonth: true,          // dropdown for month
  changeYear: true,           // dropdown for year
  showAnim: "fadeIn",         // open animation
  duration: "fast",
  firstDay: 1,                // start week on Monday
  showWeek: true,             // show week numbers
});

datumsformat

die dateFormat option nutzt PHP-artige tokens. 'yy' bedeutet vierstelliges jahr (das zusätzliche y ist beabsichtigt). die methode formatDate wandelt ein date in einen string mit denselben tokens, parseDate kehrt das um.

jquery-ui
$("#date").datepicker({
  dateFormat: "yy-mm-dd",  // 2026-07-04
});

// Format tokens:
// d  - day of month, no leading zero (1)
// dd - day, two digits (01)
// D  - short day name (Mon)
// DD - full day name (Monday)
// m  - month, no leading zero (1)
// mm - month, two digits (01)
// M  - short month name (Jan)
// MM - full month name (January)
// y  - two-digit year (26)
// yy - four-digit year (2026)
// @  - Unix timestamp
// ! - Windows ticks

// Common formats:
// "mm/dd/yy"      -> 07/04/2026
// "yy-mm-dd"      -> 2026-07-04
// "DD, MM d, yy"  -> Friday, July 4, 2026

min/max daten & bereiche

für einen datums-bereichs-picker zwei datepicker verknüpfen: wird der start gewählt, minDate des endes setzen; wird das ende gewählt, maxDate des starts setzen. beforeShowDay erlaubt es, einzelne tage zu deaktivieren oder zu stylen — noWeekends ist ein eingebauter blocker für samstag und sonntag.

jquery-ui
// Restrict to a date range
$("#start").datepicker({
  minDate: 0,
  maxDate: "+6M",
  onSelect: function (dateText) {
    // Set the end date's minimum to the start date
    $("#end").datepicker("option", "minDate", dateText);
  },
});
$("#end").datepicker({
  minDate: 0,
  maxDate: "+6M",
  onSelect: function (dateText) {
    $("#start").datepicker("option", "maxDate", dateText);
  },
});

// Disable weekends
$("#date").datepicker({
  beforeShowDay: $.datepicker.noWeekends,
});

lokalisation

jQuery UI bringt regionale dateien im i18n ordner für ~40 locales mit. die datei laden und mit $.datepicker.regional['fr'] anwenden. einzelne strings lassen sich auch inline übersteuern. die regionale datei setzt monatsnamen, tagesnamen, firstDay und dateFormat auf einmal.

jquery-ui
// Set the regionalization
$("#date").datepicker($.datepicker.regional["fr"]);

// Override specific strings
$("#date").datepicker({
  monthNames: ["janvier","février","mars","avril","mai","juin",
               "juillet","août","septembre","octobre","novembre","décembre"],
  dayNamesMin: ["Di","Lu","Ma","Me","Je","Ve","Sa"],
  firstDay: 1,
  dateFormat: "dd/mm/yy",
  prevText: "Précédent",
  nextText: "Suivant",
  closeText: "Fermer",
  currentText: "Aujourd'hui",
});

// Include the regional file for built-in locales:
// <script src="jquery-ui/i18n/datepicker-fr.js"></script>

inline datepicker & events

datepicker auf ein div statt ein input anwenden für einen immer sichtbaren inline kalender — super für buchungs-interfaces. onSelect feuert bei datumsauswahl, onChangeMonthYear beim navigieren der monate. getDate/setDate arbeiten mit date objekten für programmatische kontrolle.

jquery-ui
<!-- Inline (always visible) calendar -->
<div id="inline-calendar"></div>

<script>
  $("#inline-calendar").datepicker({
    onSelect: function (dateText, inst) {
      console.log("Selected:", dateText);
    },
    onChangeMonthYear: function (year, month, inst) {
      console.log("Viewing:", month + "/" + year);
    },
    beforeShow: function (input, inst) {
      // Fires before the popup opens
      return { /* override options */ };
    },
    onClose: function (dateText, inst) {
      // Fires when the popup closes
    },
  });

  // Methods
  $("#date").datepicker("setDate", "+7");  // set to a week from today
  $("#date").datepicker("getDate");        // returns a Date object
  $("#date").datepicker("option", "minDate", new Date(2026, 0, 1));
</script>
11

Dialog

einfacher dialog

das title attribut des elements wird zur dialog titelleiste. der dialog öffnet sich per default automatisch und ist draggable/resizable. das element wandert in einen jQuery UI wrapper mit korrektem z-index stacking. schließen über den x-button oder escape.

jquery-ui
<div id="dialog" title="Basic dialog">
  <p>This is a simple dialog window.</p>
</div>

<script>
  $(function () {
    $("#dialog").dialog();
  });
</script>

dialog optionen

autoOpen: false erzeugt den dialog verborgen, dann bei bedarf dialog('open') aufrufen — das standardmuster für bedarfsgesteuerte dialogs. modal ergänzt ein overlay, das seiteninteraktion blockiert. position nutzt das jQuery UI position utility für präzise platzierung.

jquery-ui
$("#dialog").dialog({
  autoOpen: false,           // don't open on init
  modal: true,               // dim the page behind
  width: 400,
  height: "auto",
  minWidth: 200,
  maxWidth: 600,
  resizable: true,
  draggable: true,
  closeOnEscape: true,
  position: { my: "center", at: "center", of: window },
  title: "Custom Title",     // override the title attr
  show: { effect: "fade", duration: 200 },
  hide: { effect: "fade", duration: 200 },
});

dialog buttons

buttons akzeptiert ein array (bevorzugt, erlaubt icons und optionen je button) oder ein objekt (text: handler). innerhalb eines handlers ist 'this' das dialog element — $(this).dialog('close') aufrufen zum schließen. buttons werden automatisch themt und rechtsbündig ausgerichtet.

jquery-ui
$("#dialog").dialog({
  buttons: [
    {
      text: "Save",
      icon: "ui-icon-disk",
      click: function () {
        saveForm();
        $(this).dialog("close");
      },
    },
    {
      text: "Cancel",
      click: function () {
        $(this).dialog("close");
      },
    },
  ],
});

// Shortcut object form (1.12+)
$("#dialog").dialog({
  buttons: {
    "Save": function () { saveForm(); $(this).dialog("close"); },
    "Cancel": function () { $(this).dialog("close"); },
  },
});

dialog events

beforeClose ist der wächter — false zurückgeben hält den dialog offen (nützlich bei warnungen vor ungespeicherten änderungen). close feuert nach dem schließen, der richtige ort, um formularzustand zurückzusetzen oder ressourcen freizugeben. drag/resize events spiegeln die zugrunde liegenden interaktionen.

jquery-ui
$("#dialog").dialog({
  beforeClose: function (event, ui) {
    // Return false to prevent closing
    if (!confirm("Discard changes?")) return false;
  },
  open: function (event, ui) {
    console.log("Dialog opened");
  },
  close: function (event, ui) {
    console.log("Dialog closed");
    // Clean up form state
    $(this).find("form")[0].reset();
  },
  focus: function (event, ui) {
    // Dialog gained focus
  },
  dragStart: function (event, ui) { /* dragging started */ },
  dragStop: function (event, ui) { /* dragging ended */ },
  resizeStart: function (event, ui) { /* resizing started */ },
  resizeStop: function (event, ui) { /* resizing ended */ },
});

modal & bestätigungsdialog

einen dialog aus einem dynamisch gebauten element für einmalige bestätigungen erzeugen. das modal overlay verhindert interaktion mit dem rest der seite. im close handler das element immer destroyen und entfernen, um beim schließen keine DOM nodes zu leaken.

jquery-ui
function confirmDialog(message, onConfirm) {
  $("<div>" + message + "</div>").dialog({
    modal: true,
    title: "Confirm",
    buttons: {
      "OK": function () {
        onConfirm();
        $(this).dialog("close");
      },
      "Cancel": function () {
        $(this).dialog("close");
      },
    },
    close: function () {
      $(this).dialog("destroy").remove();  // clean up
    },
  });
}

// Usage
confirmDialog("Delete this item?", function () {
  deleteItem();
});

AJAX inhalt & methoden

das open event nutzen, um inhalt per AJAX zu laden und verschachtelte widgets zu initialisieren. den inhalt beim schließen immer leeren, damit das nächste öffnen frisch ist. moveToTop hebt den dialog im z-index über andere — praktisch bei gestapelten dialogs. isOpen ist ein boolean getter für bedingte logik.

jquery-ui
// Load content from a URL when opening
function openEditDialog(id) {
  var $dlg = $("#edit-dialog");
  $dlg.dialog({
    autoOpen: false,
    modal: true,
    open: function () {
      $dlg.load("/api/edit/" + id, function () {
        // Initialize widgets in loaded content
        $dlg.find(".datepicker").datepicker();
      });
    },
    close: function () {
      $dlg.empty();  // clear for next open
    },
  });
  $dlg.dialog("open");
}

// Common methods
$("#dialog").dialog("open");
$("#dialog").dialog("close");
$("#dialog").dialog("isOpen");   // returns boolean
$("#dialog").dialog("moveToTop"); // bring to front
$("#dialog").dialog("option", "title", "New Title");
13

Progressbar

einfache progressbar

progressbar zeigt einen horizontalen balken, gefüllt bis zu einem prozentwert (0-100). die value option setzt den aktuellen fortschritt. der balken themt sich automatisch im jQuery UI stil. die breite des containers bestimmt die gesamtbreite des balkens — per CSS setzen.

jquery-ui
<div id="progress"></div>

<script>
  $(function () {
    $("#progress").progressbar({ value: 37 });
  });
</script>

indeterminierter modus

value auf false gesetzt versetzt den balken in den indeterminierten modus — ein animierter streifen zeigt 'es passiert etwas' ohne konkreten prozentwert. nutzen, wenn die gesamtmenge unbekannt ist (z. b. warten auf einen server). sobald der fortschritt verfolgbar ist, wieder auf eine zahl wechseln.

jquery-ui
<div id="progress"></div>

<script>
  // Set value to false for an indeterminate (animated) bar
  $("#progress").progressbar({ value: false });

  // Switch to determinate later when you know the percent
  $("#progress").progressbar("option", "value", 50);
</script>

progressbar optionen

die 'max' option erlaubt nicht-100-skalen (z. b. max: 1000 für einen download in KB). der wert wird als anteil von max interpretiert. die classes option (1.12+) erlaubt es, eigene klassen an konkrete interne elemente zu hängen für feingranulares theming.

jquery-ui
$("#progress").progressbar({
  value: 0,           // 0-100, or false for indeterminate
  max: 100,           // upper bound (default 100)
  disabled: false,
  // 1.12+ supports a 'classes' option for theming
  classes: {
    "ui-progressbar": "highlight",
    "ui-progressbar-value": "animated",
  },
});

wert aktualisieren

den balken über das setzen der value option aktualisieren. ein setInterval loop simuliert fortschritt für uploads oder langlaufende aufgaben. bei echten uploads das XHR upload progress event nutzen, um value je übertragener bytes zu setzen. den timer am ende immer leeren.

jquery-ui
// Simulate a file upload
var progress = 0;
$("#progress").progressbar({ value: 0 });

var timer = setInterval(function () {
  progress += 5;
  $("#progress").progressbar("option", "value", progress);
  if (progress >= 100) {
    clearInterval(timer);
    console.log("Complete!");
  }
}, 200);

// Get current value
var current = $("#progress").progressbar("option", "value");

change event & eigene labels

change feuert bei jeder wert-aktualisierung, complete bei 100% — beide nützlich für dynamisches styling oder labels. um den prozenttext zu zeigen einen absolut positionierten label über den balken legen. im change handler aktualisieren, damit er synchron bleibt.

jquery-ui
$("#progress").progressbar({
  value: 0,
  change: function () {
    var v = $("#progress").progressbar("value");
    $("#progress .ui-progressbar-value")
      .css("background", v < 50 ? "#fa0" : "#0a0");
  },
  complete: function () {
    $("#progress .ui-progressbar-value").css("background", "#0a0");
    $("#progress-label").text("Done!");
  },
});

// Overlay a text label
$("#progress").append(
  '<div id="progress-label" style="position:absolute;left:50%;top:0;">Loading...</div>'
);
14

Selectmenu

einfaches selectmenu

selectmenu ersetzt den nativen select dropdown durch eine im jQuery UI stil themte version. es unterstützt alle nativen features (selected, disabled optionen) und ergänzt icons, eigenes rendering und einheitliches browserübergreifendes styling. das zugrunde liegende select bleibt synchron, formulare reichern also normal ein.

jquery-ui
<label for="speed">Speed:</label>
<select id="speed">
  <option>Slower</option>
  <option>Slow</option>
  <option selected="selected">Medium</option>
  <option>Fast</option>
  <option>Faster</option>
</select>

<script>
  $(function () {
    $("#speed").selectmenu();
  });
</script>

selectmenu optionen

width auf null setzen für die CSS breite des elements, oder eine zahl für explizite pixel. die default breite passt sich der längsten option an. position steuert die menü-platzierung relativ zum button. appendTo ist nützlich für selectmenus in dialogs oder iframes.

jquery-ui
$("#speed").selectmenu({
  disabled: false,
  width: null,            // null = CSS width, number = px
  icons: { button: "ui-icon-triangle-1-s" },
  appendTo: null,         // where to render the menu
  position: { my: "left top", at: "left bottom" },
});

selectmenu events

change ist das haupt-event — feuert, wenn der nutzer eine andere option wählt. ui.item.value ist das value attribut der option, ui.item.label ihr text. select feuert kurz vor change und lässt sich durch false zurückgeben abbrechen — nützlich für validierung.

jquery-ui
$("#speed").selectmenu({
  change: function (event, ui) {
    // ui.item has the selected option's data
    console.log("Selected:", ui.item.value);
    console.log("Label:", ui.item.label);
  },
  focus: function (event, ui) {
    // Item highlighted in the dropdown
  },
  open: function (event, ui) {
    // Dropdown just opened
  },
  close: function (event, ui) {
    // Dropdown just closed
  },
  select: function (event, ui) {
    // Fires before change; return false to cancel
  },
});

eigenes rendering

_renderItem übersteuern, um icons, beschreibungen oder eigenes HTML zu jeder option zu ergänzen. item.element gibt zugriff auf das originale <option>, um data attribute zu lesen. der standardweg zu reichen dropdowns wie projekt-auswählern mit status-icons.

jquery-ui
$("#projects").selectmenu({
  // Render each item in the dropdown
  format: function (item) {
    // (deprecated in 1.12 — use _renderItem instead)
  },
});

// 1.12+ custom rendering via widget extension
$.widget("custom.iconselectmenu", $.ui.selectmenu, {
  _renderItem: function (ul, item) {
    var li = $("<li>"), wrapper = $("<div>", { text: item.label });
    if (item.disabled) li.addClass("ui-state-disabled");
    $("<span>", { class: "ui-icon " + item.element.data("icon") })
      .appendTo(wrapper);
    return li.append(wrapper).appendTo(ul);
  },
});

$("#projects").iconselectmenu();

methoden

um den wert zu setzen das native .val() am select nutzen und dann refresh() aufrufen, damit die widget-ansicht aktualisiert. refresh() immer nach dem ergänzen, entfernen oder ändern von optionen im zugrunde liegenden select aufrufen, damit das widget den neuen zustand spiegelt.

jquery-ui
// Open / close programmatically
$("#speed").selectmenu("open");
$("#speed").selectmenu("close");

// Get or set the value
var val = $("#speed").selectmenu("option", "value");  // not standard
$("#speed").val("fast").selectmenu("refresh");  // use .val() + refresh

// Refresh after modifying the underlying select
$("#speed").append("<option>New</option>");
$("#speed").selectmenu("refresh");

// Disable / enable
$("#speed").selectmenu("disable");
$("#speed").selectmenu("enable");

// Get the button or menu element
$("#speed").selectmenu("widget");    // the button wrapper
$("#speed").selectmenu("menuWidget"); // the menu ul

// Destroy
$("#speed").selectmenu("destroy");

optgroups & disabled optionen

selectmenu respektiert native <optgroup> elemente — sie rendern als nicht wählbare gruppen-header mit passendem theming. das disabled attribut an einzelnen optionen wird ebenfalls beachtet: sie erscheinen ergraut und sind nicht wählbar. formulare reichern weiterhin den gewählten wert ein.

jquery-ui
<select id="category">
  <optgroup label="Frontend">
    <option value="react">React</option>
    <option value="vue">Vue</option>
  </optgroup>
  <optgroup label="Backend">
    <option value="node">Node.js</option>
    <option value="django" disabled>Django (deprecated)</option>
  </optgroup>
</select>

<script>
  $("#category").selectmenu({
    width: 200,
    change: function (event, ui) {
      console.log("Picked:", ui.item.value);
    },
  });
</script>
15

Slider

einfacher slider

slider erzeugt einen ziehbaren griff auf einer horizontalen spur. der default bereich ist 0-100, der griff startet bei 0. die spur ist voll themt. maße per CSS am container setzen — width für horizontale, height für vertikale slider.

jquery-ui
<div id="slider"></div>

<script>
  $(function () {
    $("#slider").slider();
  });
</script>

slider optionen

'values' (array) statt 'value' für einen zweigriff-range slider nutzen. 'range: true' schattiert die fläche zwischen den griffen; 'range: min' vom griff zum minimum; 'range: max' vom griff zum maximum. 'step' muss sich gleichmäßig in (max - min) teilen.

jquery-ui
$("#slider").slider({
  min: 0,
  max: 100,
  step: 1,                  // increment size
  value: 50,                // single value
  values: [25, 75],         // two-handle range (omit 'value')
  orientation: "horizontal", // or "vertical"
  range: true,              // or "min", "max"
  disabled: false,
  animate: "fast",          // or ms, or false
});

slider events

slide feuert fortlaufend beim ziehen — ideal, um ein label live zu aktualisieren. false innerhalb von slide bricht die bewegung ab — nützlich, um werte dynamisch zu begrenzen. change feuert nach dem loslassen und bei programmatischen option-änderungen; damit den wert persistieren.

jquery-ui
$("#slider").slider({
  start: function (event, ui) {
    // User started dragging a handle
    console.log("Start:", ui.value || ui.values);
  },
  slide: function (event, ui) {
    // Fires continuously during drag
    // Return false to prevent the handle from moving
    $("#label").text(ui.value);
  },
  change: function (event, ui) {
    // Fires after the handle is released (and on programmatic change)
    saveValue(ui.value);
  },
  stop: function (event, ui) {
    // User released the handle
  },
});

range slider

ein zweigriff-range slider entsteht durch range: true und ein values array. ui.values[0] ist der untere griff, ui.values[1] der obere. die griffe können sich nicht kreuzen. das klassische muster für preis- oder datums-bereichs-filter.

jquery-ui
<div id="range-slider"></div>
<p>Price: $<span id="min-price"></span> - $<span id="max-price"></span></p>

<script>
  $("#range-slider").slider({
    range: true,
    min: 0,
    max: 500,
    values: [75, 300],
    slide: function (event, ui) {
      $("#min-price").text(ui.values[0]);
      $("#max-price").text(ui.values[1]);
    },
  });
</script>

vertikal & ausrichtungen

vertikale slider brauchen eine explizite höhe per CSS — width wirkt auf die querachse. der griff bewegt sich auf/ab statt links/rechts. die range-schattierung funktioniert genauso. nützlich für audio mixer, equalizer oder jede UI, wo vertikale ausrichtung natürlicher ist.

jquery-ui
// Vertical slider
$("#vertical").slider({
  orientation: "vertical",
  min: 0,
  max: 100,
  value: 60,
});

// Vertical range
$("#vertical-range").slider({
  orientation: "vertical",
  range: true,
  min: 0,
  max: 100,
  values: [20, 80],
});

/* CSS: vertical sliders need a height */
/* #vertical { height: 200px; } */
</script>

slider methoden

bei range sliders values() (ohne argumente) für ein array nutzen, values(index, value) für einen griff, oder values(array) für beide. min/max/step zur laufzeit zu setzen positioniert die griffe automatisch innerhalb der neuen grenzen um.

jquery-ui
// Get or set the value
$("#slider").slider("value");
$("#slider").slider("value", 75);

// Get or set both handles of a range slider
var vals = $("#slider").slider("values");  // [25, 75]
$("#slider").slider("values", 0, 30);      // set lower handle
$("#slider").slider("values", [30, 90]);   // set both

// Get or set options
$("#slider").slider("option", "max", 200);
$("#slider").slider("option", "disabled", true);

// Disable / enable / destroy
$("#slider").slider("disable");
$("#slider").slider("enable");
$("#slider").slider("destroy");
16

Spinner

einfacher spinner

spinner ergänzt auf/ab buttons an einem text input für numerische eingabe. nutzer tippen direkt, klicken die buttons oder nutzen die pfeiltasten. gehaltener button beschleunigt die schrittweite. der wert des inputs wird bei jeder änderung als zahl geparst.

jquery-ui
<label for="qty">Quantity:</label>
<input id="qty" type="text" value="1">

<script>
  $(function () {
    $("#qty").spinner();
  });
</script>

spinner optionen

min/max erzwingen grenzen — die buttons gehen nicht darüber hinaus. step steuert die schrittweite (dezimalen wie 0.1 für feine kontrolle). numberFormat mit culture aktiviert lokalisierte formatierung (z. b. 'C' mit 'ja-JP' zeigt yen). globalize.js muss für culture support geladen sein.

jquery-ui
$("#qty").spinner({
  min: 0,                   // minimum value
  max: 100,                 // maximum value
  step: 1,                  // increment size
  page: 10,                 // page up/down increment
  numberFormat: "n",        // "n" for number, "C" for currency
  culture: "en-US",         // locale for formatting
  disabled: false,
  incremental: true,        // accelerate while holding
  icons: {
    up: "ui-icon-triangle-1-n",
    down: "ui-icon-triangle-1-s",
  },
});

zahlenformatierung & culture

mit geladenem globalize.js formatiert spinner werte je angegebener culture — währungssymbole, dezimaltrenner und gruppierung lokalisieren sich alle. numberFormat 'C' ist währung, 'n' eine zahl mit optionaler dezimalzahl (n2 = 2 dezimalen). nützlich für internationalisierte formulare.

jquery-ui
<!-- Requires Globalize.js for culture support -->
<script src="globalize.js"></script>
<script src="globalize.culture.ja-JP.js"></script>

<script>
  // Currency spinner (Japanese yen)
  $("#price").spinner({
    numberFormat: "C",
    culture: "ja-JP",
    step: 100,
    min: 0,
  });

  // Decimal spinner
  $("#weight").spinner({
    step: 0.01,
    numberFormat: "n2",  // 2 decimal places
    min: 0,
  });
</script>

spinner events

spin feuert bei jedem increment/decrement (button klick oder pfeiltaste). false zurückgeben bricht die änderung ab — ideal für eigene validierung. change feuert beim blur; ui.value ist null, wenn sich der input nicht als gültige zahl parsen lässt — der ort für validierungsfehler.

jquery-ui
$("#qty").spinner({
  spin: function (event, ui) {
    // Fires when a button is clicked or arrow pressed
    // ui.value is the new value
    // Return false to cancel the change
    if (ui.value > 10) {
      alert("Max 10 per order");
      return false;
    }
  },
  change: function (event, ui) {
    // Fires when the value changes and input loses focus
    // ui.value may be null if invalid
    if (ui.value === null) {
      alert("Please enter a valid number");
    }
  },
  start: function (event, ui) { /* spin started */ },
  stop: function (event, ui) { /* spin stopped */ },
});

eigene schritte & methoden

stepUp/stepDown/pageUp/pageDown simulieren button drücke programmatisch. value() ohne argument ist ein getter; mit argument ein setter, der durch die validierung läuft. eigene spin handler erlauben nicht-numerische spinner wie zeiten, farben oder eigene einheiten.

jquery-ui
// Time spinner (steps of 15 minutes)
$("#time").spinner({
  step: 15,
  min: 0,
  max: 1439,  // 24 * 60 - 1
  numberFormat: "n0",
  spin: function (event, ui) {
    // Wrap around at midnight
    if (ui.value > 1439) return false;  // or wrap: $(this).spinner("value", 0);
  },
});

// Methods
$("#qty").spinner("value");        // get current value
$("#qty").spinner("value", 5);     // set value
$("#qty").spinner("stepUp");       // increment by one step
$("#qty").spinner("stepDown");     // decrement by one step
$("#qty").spinner("pageUp");       // increment by 'page' steps
$("#qty").spinner("pageDown");
$("#qty").spinner("disable");
$("#qty").spinner("enable");
$("#qty").spinner("destroy");

validierung & eigenes parsen

_parse und _format übersteuern, um spinner für nicht-dezimale werte zu bauen — hex farben, zeiten, winkel oder jede eigene einheit. _parse wandelt den input-text in eine zahl; _format für die anzeige zurück. der sauberste weg, spinner für domänenspezifische inputs zu erweitern.

jquery-ui
// Custom spinner for hexadecimal colors
$.widget("custom.hexspinner", $.ui.spinner, {
  _parse: function (value) {
    // String -> number
    return parseInt(value, 16);
  },
  _format: function (value) {
    // number -> string
    return value.toString(16).toUpperCase().padStart(6, "0");
  },
});

$("#color").hexspinner({
  min: 0x000000,
  max: 0xffffff,
  step: 0x10,
});

// Prevent invalid input
$("#qty").on("keydown", function (e) {
  if (e.key === "-" && $(this).spinner("option", "min") >= 0) {
    e.preventDefault();
  }
});
17

Tabs

einfache tabs

tabs erwartet ein ul mit links auf inhalts-panel IDs, gefolgt von den panels selbst. die link hrefs (#tab-1) verbinden tabs mit panels. der erste tab ist per default aktiv. tabs sind tastaturnavigierbar (pfeile, home, end) und ARIA-konform.

jquery-ui
<div id="tabs">
  <ul>
    <li><a href="#tab-1">First</a></li>
    <li><a href="#tab-2">Second</a></li>
    <li><a href="#tab-3">Third</a></li>
  </ul>
  <div id="tab-1">Content 1</div>
  <div id="tab-2">Content 2</div>
  <div id="tab-3">Content 3</div>
</div>

<script>
  $(function () {
    $("#tabs").tabs();
  });
</script>

tabs optionen

active setzt den anfangs offenen tab per index (oder false für zusammengeklappten start). heightStyle 'fill' macht alle panels so hoch wie der container; 'content' misst jedes an seinem inhalt (default). 'event: mouseover' erzeugt hover-aktivierte tabs.

jquery-ui
$("#tabs").tabs({
  active: 0,            // index of active tab (false = all hidden)
  collapsible: false,   // allow closing the active tab
  disabled: [],         // array of disabled indices
  event: "click",       // event to switch tabs ("mouseover" etc.)
  heightStyle: "content", // "auto", "fill", or "content"
  show: { effect: "fadeIn", duration: 200 },
  hide: { effect: "fadeOut", duration: 200 },
});

tabs events

beforeActivate ist der wächter — false zurückgeben blockiert den wechsel (z. b. warnung bei ungespeicherten änderungen). activate feuert nach abgeschlossenem wechsel. beforeLoad/load sind für AJAX tabs — beforeLoad erlaubt es, die anfrage anzupassen oder abzubrechen; load feuert bei erfolg.

jquery-ui
$("#tabs").tabs({
  beforeActivate: function (event, ui) {
    // ui.newTab, ui.newPanel (opening)
    // ui.oldTab, ui.oldPanel (closing)
    // Return false to cancel the switch
    if ($(ui.newPanel).find("form").hasUnsavedChanges()) {
      return confirm("Discard changes?");
    }
  },
  activate: function (event, ui) {
    // Fires after the new tab is shown
    console.log("Now on:", ui.newTab.text());
  },
  beforeLoad: function (event, ui) {
    // For AJAX tabs — fires before loading remote content
    ui.jqXHR.error(function () {
      ui.panel.text("Failed to load content.");
    });
  },
  load: function (event, ui) {
    // AJAX content finished loading
  },
});

AJAX tabs

ist der href eines tabs eine URL (kein anker), lädt tabs den inhalt bei aktivierung per AJAX. die antwort ersetzt das panel. beforeLoad erlaubt einen spinner zu zeigen, die AJAX anfrage zu konfigurieren oder abzubrechen. geladener inhalt wird ab 1.12+ für die sitzung gecacht.

jquery-ui
<div id="tabs">
  <ul>
    <li><a href="#local">Local</a></li>
    <li><a href="remote.html">Remote (AJAX)</a></li>
    <li><a href="api/data.json">API Data</a></li>
  </ul>
  <div id="local">This content is in the page.</div>
  <!-- Remote panels are created automatically -->
</div>

<script>
  $("#tabs").tabs({
    beforeLoad: function (event, ui) {
      // Show a loading indicator
      ui.panel.html("Loading...");
      // Cache the loaded content
      ui.ajaxSettings.cache = true;
    },
  });
</script>

collapsible & sortable tabs

mit collapsible: true schließt ein klick auf den aktiven tab ihn (kein tab bleibt offen). tabs mit sortable an der nav gepaart erlauben das umordnen der tabs durch ziehen. nach dem ergänzen oder entfernen von tabs/panels refresh() aufrufen, damit das widget die neue struktur neu bindet.

jquery-ui
// Allow collapsing the active tab
$("#tabs").tabs({ collapsible: true });

// Make tabs reorderable by drag
$("#tabs").tabs().find(".ui-tabs-nav").sortable({
  axis: "x",
  stop: function () {
    $("#tabs").tabs("refresh");
  },
});

// Dynamically add a new tab
function addTab(id, label, content) {
  var nav = $("#tabs .ui-tabs-nav");
  nav.append('<li><a href="#' + id + '">' + label + '</a></li>');
  $("#tabs").append('<div id="' + id + '">' + content + '</div>');
  $("#tabs").tabs("refresh");
}

tabs methoden

disable/enable akzeptieren einen index oder ein array von indizes. die active option ist getter und setter für den aktuellen tab — damit programmatisch wechseln. load() lädt AJAX inhalt eines tabs neu. refresh() ist pflicht nach dem ergänzen, entfernen oder umordnen von tabs.

jquery-ui
// Disable / enable specific tabs
$("#tabs").tabs("disable", 1);       // disable second tab
$("#tabs").tabs("enable", 1);
$("#tabs").tabs("option", "disabled", [0, 2]);  // disable multiple

// Switch to a tab by index
$("#tabs").tabs("option", "active", 2);

// Reload an AJAX tab
$("#tabs").tabs("load", 1);

// Refresh after structural changes
$("#tabs").tabs("refresh");

// Get the active tab index
var active = $("#tabs").tabs("option", "active");

// Destroy
$("#tabs").tabs("destroy");
18

Tooltip

einfacher tooltip

tooltip() am document aufzurufen ersetzt alle nativen title tooltips durch themte jQuery UI versionen. der inhalt des title attributs wird zum tooltip text. tooltips erscheinen beim hover und verschwinden bei mouseout, per default mit geschmeidiger fade animation.

jquery-ui
<label for="age">Age:</label>
<input id="age" title="Please enter your age in years">

<script>
  $(function () {
    $(document).tooltip();
  });
</script>

tooltip optionen

'content' als funktion übersteuern, um dynamischen tooltip HTML zu erzeugen (etwa aus data attribute oder AJAX). 'items' ist ein selektor, der steuert, welche elemente tooltips auslösen. 'track: true' lässt den tooltip dem cursor folgen — nützlich für detaillierte hilfetexte an diagrammen.

jquery-ui
$(document).tooltip({
  content: function () {
    // Default: returns the element's title attribute
    return $(this).attr("title");
  },
  items: "[title]",       // which elements get tooltips
  position: { my: "left top+15", at: "left bottom" },
  show: { effect: "fadeIn", duration: 200 },
  hide: { effect: "fadeOut", duration: 200 },
  tooltipClass: "custom-tooltip",  // class for the tooltip div
  track: false,           // follow the mouse cursor
  disabled: false,
  close: null,            // (event defaults handle this)
});

eigener inhalt

die content funktion erlaubt reiche tooltips mit HTML, bildern oder AJAX-geladenem inhalt. einen string zurückgeben (HTML erlaubt). tooltipClass ergänzt eine eigene klasse fürs styling. das standardmuster für thumbnail previews oder hilfe-bubbles an formularfeldern.

jquery-ui
<!-- HTML with data attributes -->
<a href="#" class="help" data-help="Click to save your changes">Save</a>
<a href="#" class="help" data-help="Undo the last action">Undo</a>

<script>
  $(".help").tooltip({
    content: function () {
      return "<strong>Help:</strong> " + $(this).data("help");
    },
    tooltipClass: "help-tooltip",
  });
</script>

<!-- With an image preview -->
$(".thumb").tooltip({
  content: function () {
    var src = $(this).attr("href");
    return "<img src='" + src + "' width='200'>";
  },
});

tooltip events

open und close feuern, wenn tooltips erscheinen und verschwinden. ui.tooltip liefert das tooltip element zur anpassung. ein übliches muster ist, den tooltip offen zu halten, solange der nutzer über ihn hovert — nützlich, wenn der tooltip interaktiven inhalt wie links enthält.

jquery-ui
$(".help").tooltip({
  open: function (event, ui) {
    // Tooltip just appeared
    ui.tooltip;  // the tooltip element
  },
  close: function (event, ui) {
    // Tooltip just disappeared
    ui.tooltip.one("transitionend", function () {
      // Cleanup after the hide animation
    });
  },
  create: function (event, ui) {
    // Widget initialized
  },
});

// Prevent tooltip from closing on hover
$(".help").tooltip({
  close: function (event, ui) {
    ui.tooltip.hover(
      function () { $(this).stop(true).fadeIn(); },
      function () { $(this).fadeOut(); }
    );
  },
});

position & methoden

position nutzt das jQuery UI position utility: 'my' ist der anker des tooltips, 'at' der des ziels. collision behandelt randfälle — 'flip' wechselt die seite, wenn es überlaufen würde. open()/close() zeigen/verbergen tooltips programmatisch — praktisch für validierungsfehler.

jquery-ui
$("#target").tooltip({
  position: {
    my: "center top",       // tooltip's anchor point
    at: "center bottom",    // target's anchor point
    of: "#target",          // optional: position relative to this
    collision: "flip",      // "flip", "fit", "flipfit", "none"
    using: function (pos, feedback) {
      $(this).css(pos);
      console.log(feedback.horizontal, feedback.vertical);
    },
  },
});

// Methods
$("#target").tooltip("open");   // show programmatically
$("#target").tooltip("close");  // hide programmatically
$("#target").tooltip("disable");
$("#target").tooltip("enable");
$("#target").tooltip("widget");  // get the tooltip div
$("#target").tooltip("destroy");

formular-validierungs-tooltips

tooltips sind ein sauberer weg, inline validierungsfehler zu zeigen. die fehlermeldung in einem data attribut speichern, content zum lesen setzen und open() aufrufen. false im open handler verhindert den tooltip, wenn kein fehler vorliegt. mit tooltipClass für rotes fehler-styling arbeiten.

jquery-ui
<!-- Show validation errors as tooltips -->
<form id="form">
  <input id="email" type="text" placeholder="Email">
  <input id="submit" type="submit" value="Submit">
</form>

<script>
  $("#form").tooltip({
    items: "input",
    content: function () {
      return $(this).data("error") || "";
    },
    position: { my: "left top", at: "left bottom+5" },
    tooltipClass: "error-tooltip",
    open: function (event, ui) {
      var el = $(event.originalEvent.target);
      if (!el.data("error")) return false;  // don't show if no error
    },
  });

  $("#submit").on("click", function (e) {
    var email = $("#email").val();
    if (!email.includes("@")) {
      e.preventDefault();
      $("#email").data("error", "Please enter a valid email")
                 .tooltip("open");
    }
  });
</script>
19

Effekte

core effekte

jQuery UI erweitert jQuerys show/hide/toggle um benannte effekte und ergänzt die methode .effect() für nicht-verbergende animationen. jeder nimmt ein options-objekt, eine dauer und einen callback. 'transfer' erzeugt einen transfer element umriss — nützlich für drag-zum-warenkorb-Animationen.

jquery-ui
// Built-in effects (beyond jQuery's show/hide/toggle)
$("#box").hide("fade", {}, 1000);    // fade out
$("#box").show("slide", {}, 500);    // slide in
$("#box").toggle("explode", {}, 800); // explode toggle
$("#box").effect("bounce", { times: 3 }, 300);

// Available effect names:
// blind, bounce, clip, drop, explode, fade, fold,
// highlight, puff, pulsate, scale, shake, size, slide, transfer

easing funktionen

jQuery UIs effects core ergänzt ~30 robert penner easing funktionen über jquerys default 'swing' und 'linear' hinaus. nutzbar in jedem .animate() aufruf, der easing option von show/hide/toggle oder als drittes argument. 'easeOutBounce' und 'easeOutElastic' sind beliebt für verspielte UIs.

jquery-ui
// jQuery core provides: swing (default), linear
// jQuery UI adds ~30 more easing functions
$("#box").animate({ width: 500 }, 1000, "easeInOutBounce");

// Available easings (subset):
// easeInQuad, easeOutQuad, easeInOutQuad
// easeInCubic, easeOutCubic, easeInOutCubic
// easeInQuart, easeOutQuart, easeInOutQuart
// easeInExpo, easeOutExpo, easeInOutExpo
// easeInBack, easeOutBack, easeInOutBack
// easeInBounce, easeOutBounce, easeInOutBounce
// easeInElastic, easeOutElastic, easeInOutElastic

show/hide/toggle mit effekten

einen effekt-namen als erstes argument an show/hide/toggle übergeben, um zu animieren. das zweite argument ist ein options-objekt (direction, distance, percent usw., je effekt). das dritte ist die dauer; das vierte ein callback. effekte an verborgenen elementen wirken weiterhin via show().

jquery-ui
// show with an effect
$("#box").show("drop", { direction: "left" }, 500);

// hide with an effect
$("#box").hide("puff", {}, 500);

// toggle with an effect
$("#box").toggle("scale", { percent: 0 }, 500);

// With a callback
$("#box").hide("blind", 500, function () {
  console.log("Animation complete");
});

// Direction option (where applicable)
$("#box").hide("slide", { direction: "up" });

farb-animationen

jquery core kann farben nicht animieren — jQuery UIs effects core ergänzt das. backgroundColor, color und borderColor werden animierbar. switchClass und toggleClass akzeptieren eine dauer, um geschmeidig zwischen klassen zu transitionieren und alle geänderten CSS eigenschaften zu interpolieren.

jquery-ui
// jQuery UI extends animate() to support colors
$("#box").animate({
  backgroundColor: "#ff0000",
  color: "#ffffff",
  borderColor: "#000000",
}, 1000);

// Animate through the theme states
$("#box").animate(
  { backgroundColor: $.Color("#0a0") },
  { duration: 500 }
);

// Toggle class with smooth transitions
$("#box").switchClass("old-class", "new-class", 500);
$("#box").toggleClass("active", 500);  // duration = animated

klassen-transitions

addClass, removeClass und toggleClass bekommen durch jQuery UI ein optionales dauer-argument — alle CSS eigenschaften, die zwischen zuständen abweichen, animieren geschmeidig. switchClass transitioniert explizit zwischen zwei klassen. der sauberste weg, zwischen themten zuständen zu animieren.

jquery-ui
// Add/remove classes with animation
$("#box").addClass("highlight", 500);    // animate to new class
$("#box").removeClass("highlight", 500);
$("#box").toggleClass("highlight", 500);

// switchClass: smoothly transition from one class to another
$("#box").switchClass("state-default", "state-active", 500);

// All accept a callback
$("#box").addClass("expanded", 500, function () {
  console.log("Done expanding");
});

effekt methoden referenz

.effect() wendet einen benannten effekt an, ohne die sichtbarkeit zu ändern (shake, bounce, pulsate sind reine effekte). .transfer() animiert einen box umriss von einem element zu einem anderen — klassisch für 'in den warenkorb'-feedback. easing arrays je eigenschaft erlauben verschiedene easings für verschiedene eigenschaften.

jquery-ui
// .effect() — run an effect without hiding
$("#box").effect("shake", { times: 3 }, 300);

// .transfer() — animate a transfer outline to another element
$("#product").effect("transfer", { to: "#cart" }, 500);

// .animate() with colors and easing
$("#box").animate({ left: 200, opacity: 0.5 }, "slow", "easeOutBounce");

// Custom animation with step
$("#box").animate({
  width: ["toggle", "swing"],   // [value, easing] per property
  height: ["toggle", "linear"],
}, 1000);
20

ThemeRoller

ThemeRoller grundlagen

ThemeRoller ist die offizielle web app zum bauen eigener jQuery UI themes. farben, fonts, eckenradius und texturen mit live preview anpassen, dann ein ZIP mit dem themten CSS und den image sprites herunterladen. vorgebaute themes (smoothness, ui-lightness usw.) sind auch auf dem CDN verfügbar.

jquery-ui
<!-- Use a prebuilt theme from the CDN -->
<link rel="stylesheet"
      href="https://code.jquery.com/ui/1.13.2/themes/smoothness/jquery-ui.css">

<!-- Or a custom theme from ThemeRoller (jqueryui.com/themeroller) -->
<!-- 1. Visit the ThemeRoller app -->
<!-- 2. Customize colors, fonts, corner radius, etc. -->
<!-- 3. Download the generated CSS file -->
<link rel="stylesheet" href="my-custom-theme/jquery-ui.css">

CSS framework klassen

das CSS framework ist unabhängig von den javascript widgets — ui-widget, ui-widget-header, ui-widget-content und die zustands-klassen (ui-state-default, ui-state-hover, ui-state-active) im eigenen markup nutzen, um dem jQuery UI styling zu entsprechen, ganz ohne widget-initialisierung.

jquery-ui
<!-- The jQuery UI CSS framework is reusable for custom markup -->
<div class="ui-widget">
  <div class="ui-widget-header ui-corner-top">
    <h3>Panel Header</h3>
  </div>
  <div class="ui-widget-content ui-corner-bottom">
    <p>Panel content with themed styling.</p>
    <button class="ui-button ui-widget ui-state-default ui-corner-all">
      <span class="ui-icon ui-icon-gear"></span> Action
    </button>
  </div>
</div>

theme variablen & struktur

jedes theme definiert dieselbe klassenmenge mit verschiedenen farben und texturen. ui-state-highlight (gelb) ist für hinweise; ui-state-error (rot) für fehler. die corner klassen (ui-corner-all, ui-corner-top usw.) machen den border-radius thembar — ThemeRoller setzt alle auf einmal.

jquery-ui
/* ThemeRoller generates CSS with these key classes */
.ui-widget {
  font-family: Arial, sans-serif;   /* font family */
  font-size: 1em;                    /* base font size */
}
.ui-widget-content { border: 1px solid #aaa; background: #fff; color: #222; }
.ui-widget-header  { border: 1px solid #aaa; background: #ccc; color: #222; }
.ui-state-default  { border: 1px solid #d3d3d3; background: #e6e6e6; }
.ui-state-hover    { border: 1px solid #999;    background: #dadada; }
.ui-state-active   { border: 1px solid #aaa;    background: #fff; }
.ui-state-focus    { border: 1px solid #999;    background: #dadada; }
.ui-state-highlight { border: 1px solid #fcefa1; background: #fbf9ee; }
.ui-state-error     { border: 1px solid #cd0a0a; background: #fef1ec; }
.ui-corner-all { border-radius: 4px; }  /* themable radius */

eigenes theme übersteuern

ein base theme laden, dann mit spezifischerer CSS übersteuern. das ist schneller als ThemeRoller erneut laufen zu lassen für kleine anpassungen. die framework klassen zielen (ui-widget-header, ui-state-default usw.), um alle widgets auf einmal umzustylten. den eckenradius entfernen für einen flachen, modernen look.

jquery-ui
/* Load the base theme first */
@import url("https://code.jquery.com/ui/1.13.2/themes/base/jquery-ui.css");

/* Override specific elements */
.ui-widget-header {
  background: linear-gradient(to bottom, #2c3e50, #34495e);
  color: #ecf0f1;
}
.ui-state-default {
  background: #3498db;
  border-color: #2980b9;
  color: #fff;
}
.ui-state-hover { background: #2980b9; }
.ui-state-active { background: #1abc9c; border-color: #16a085; }
.ui-corner-all { border-radius: 0; }  /* sharper look */

theme wechsel zur laufzeit

um themes zur laufzeit zu wechseln mehrere theme CSS dateien laden und deren 'disabled'-eigenschaft togglen — nur die aktive greift. die wahl im localStorage persistieren. die widgets übernehmen das neue styling sofort. für eine single-CSS lösung stattdessen das href attribut tauschen.

jquery-ui
<!-- Two theme stylesheets; toggle the disabled attribute -->
<link id="theme-light" rel="stylesheet"
      href="themes/ui-lightness/jquery-ui.css">
<link id="theme-dark" rel="stylesheet"
      href="themes/ui-darkness/jquery-ui.css" disabled>

<script>
  function switchTheme(name) {
    $("#theme-light").prop("disabled", name !== "light");
    $("#theme-dark").prop("disabled", name !== "dark");
    localStorage.setItem("theme", name);
  }

  // Restore on load
  $(function () {
    var saved = localStorage.getItem("theme") || "light";
    switchTheme(saved);
  });
</script>

konkrete widgets themen

widget-spezifische klassen zielen (ui-datepicker, ui-dialog, ui-accordion-header), um einzelne widgets umzustylten, ohne andere zu berühren. die 'classes'-option ab 1.12+ ist sauberer — sie ergänzt eigene klassen an konkrete interne elemente, die man im eigenen CSS stylt. wo möglich statt globaler overrides nutzen.

jquery-ui
/* Datepicker: style the calendar popup */
.ui-datepicker {
  box-shadow: 0 4px 12px rgba(0,0,0,0.2);
  border-radius: 0;
}
.ui-datepicker .ui-state-highlight { /* today */ background: #ffd; }
.ui-datepicker .ui-state-active {    /* selected */ background: #2c3e50; }

/* Dialog: remove the default rounded corners */
.ui-dialog { border-radius: 0; box-shadow: 0 8px 30px rgba(0,0,0,0.3); }

/* Accordion: modernize the headers */
.ui-accordion .ui-accordion-header {
  background: #f5f5f5;
  border: none;
  border-bottom: 1px solid #ddd;
  font-weight: bold;
}

/* Use the 'classes' option (1.12+) for per-widget theming */
$("#dialog").dialog({
  classes: { "ui-dialog": "my-dialog", "ui-dialog-titlebar": "my-title" },
});

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.