Source: clickActions.js

  1. "use strict";
  2. // SPDX-License-Identifier: GPL-3.0-or-later
  3. // myMPD (c) 2018-2025 Juergen Mang <mail@jcgames.de>
  4. // https://github.com/jcorporation/mympd
  6. /** @module clickActions_js */
  8. /**
  9.  * Handler for quick remove button
  10.  * @param {EventTarget} target event target
  11.  * @returns {void}
  12.  */
  13. function clickQuickRemove(target) {
  14.     let dataNode = target.parentNode.parentNode;
  15.     if (dataNode.classList.contains('row')) {
  16.         dataNode = dataNode.parentNode;
  17.     }
  18.     switch(app.id) {
  19.         case 'QueueCurrent': {
  20.             const songId = getData(dataNode, 'songid');
  21.             removeFromQueueIDs([songId]);
  22.             break;
  23.         }
  24.         case 'BrowsePlaylistList': {
  25.             const plist = getData(dataNode, 'uri');
  26.             showDelPlaylist([plist]);
  27.             break;
  28.         }
  29.         case 'BrowsePlaylistDetail': {
  30.             const pos = getData(dataNode, 'pos');
  31.             const plist = getDataId('BrowsePlaylistDetailList', 'uri');
  32.             removeFromPlaylistPositions(plist, [pos]);
  33.             break;
  34.         }
  35.         case 'QueueJukeboxSong':
  36.         case 'QueueJukeboxAlbum': {
  37.             const pos = getData(dataNode, 'pos');
  38.             delQueueJukeboxEntries([pos]);
  39.             break;
  40.         }
  41.         default:
  42.             logError('Invalid appid' + app.id);
  43.     }
  44. }
  46. /**
  47.  * Handler for quick play button
  48.  * @param {EventTarget} target event target
  49.  * @returns {void}
  50.  */
  51. function clickQuickPlay(target) {
  52.     let dataNode = target.parentNode.parentNode;
  53.     if (dataNode.classList.contains('row')) {
  54.         dataNode = dataNode.parentNode;
  55.     }
  56.     const type = getData(dataNode, 'type');
  57.     const uri = [];
  58.     switch(type) {
  59.         case 'album':
  60.             uri.push(getData(dataNode, 'AlbumId'));
  61.             break;
  62.         case 'disc':
  63.             uri.push(getData(dataNode, 'AlbumId'), getData(dataNode, 'Disc'));
  64.             break;
  65.         case 'work':
  66.             uri.push(getData(dataNode, 'AlbumId'), getData(dataNode, 'Work'));
  67.             break;
  68.         default:
  69.             uri.push(getData(dataNode, 'uri'));
  70.     }
  71.     switch (settings.webuiSettings.clickQuickPlay) {
  72.         case 'append': return appendQueue(type, uri);
  73.         case 'appendPlay': return appendPlayQueue(type, uri);
  74.         case 'insertAfterCurrent': return insertAfterCurrentQueue(type, uri);
  75.         case 'insertPlayAfterCurrent': return insertPlayAfterCurrentQueue(type, uri);
  76.         case 'replace': return replaceQueue(type, uri);
  77.         case 'replacePlay': return replacePlayQueue(type, uri);
  78.         default: logError('Invalid action: ' + settings.webuiSettings.clickQuickPlay);
  79.     }
  80. }
  82. /**
  83.  * Click song handler
  84.  * @param {string} uri song uri
  85.  * @param {event} event the event
  86.  * @returns {void}
  87.  */
  88. function clickSong(uri, event) {
  89.     switch (settings.webuiSettings.clickSong) {
  90.         case 'append': return appendQueue('song', [uri]);
  91.         case 'appendPlay': return appendPlayQueue('song', [uri]);
  92.         case 'insertAfterCurrent': return insertAfterCurrentQueue('song', [uri]);
  93.         case 'insertPlayAfterCurrent': return insertPlayAfterCurrentQueue('song', [uri]);
  94.         case 'replace': return replaceQueue('song', [uri]);
  95.         case 'replacePlay': return replacePlayQueue('song', [uri]);
  96.         case 'view': return songDetails(uri);
  97.         case 'context': return showContextMenu(event);
  98.         default: logError('Invalid action: ' + settings.webuiSettings.clickSong);
  99.     }
  100. }
  102. /**
  103.  * Handler for webradioDB links
  104.  * @param {string} uri stream uri
  105.  * @param {event} event the event
  106.  * @returns {void}
  107.  */
  108. function clickWebradiodb(uri, event) {
  109.     switch (settings.webuiSettings.clickWebradiodb) {
  110.         case 'append': return appendQueue('song', [uri]);
  111.         case 'appendPlay': return appendPlayQueue('song', [uri]);
  112.         case 'insertAfterCurrent': return insertAfterCurrentQueue('song', [uri]);
  113.         case 'insertPlayAfterCurrent': return insertPlayAfterCurrentQueue('song', [uri]);
  114.         case 'replace': return replaceQueue('song', [uri]);
  115.         case 'replacePlay': return replacePlayQueue('song', [uri]);
  116.         case 'view': return showWebradiodbDetails(uri);
  117.         case 'context': return showContextMenu(event);
  118.         default: logError('Invalid action: ' + settings.webuiSettings.clickWebradiodb);
  119.     }
  120. }
  122. /**
  123.  * Handler for webradio favorites links
  124.  * @param {string} uri webradio favorite uri (filename only)
  125.  * @param {event} event the event
  126.  * @returns {void}
  127.  */
  128. function clickRadioFavorites(uri, event) {
  129.     switch(settings.webuiSettings.clickRadioFavorites) {
  130.         case 'append': return appendQueue('webradio', [uri]);
  131.         case 'appendPlay': return appendPlayQueue('webradio', [uri]);
  132.         case 'insertAfterCurrent': return insertAfterCurrentQueue('webradio', [uri]);
  133.         case 'insertPlayAfterCurrent': return insertPlayAfterCurrentQueue('webradio', [uri]);
  134.         case 'replace': return replaceQueue('webradio', [uri]);
  135.         case 'replacePlay': return replacePlayQueue('webradio', [uri]);
  136.         case 'edit': return editRadioFavorite(uri);
  137.         case 'context': return showContextMenu(event);
  138.         default: logError('Invalid action: ' + settings.webuiSettings.clickRadioFavorites);
  139.     }
  140. }
  142. /**
  143.  * Handler for song links in queue
  144.  * @param {string} songid the song id
  145.  * @param {string} uri the song uri
  146.  * @param {event} event the event
  147.  * @returns {void}
  148.  */
  149. function clickQueueSong(songid, uri, event) {
  150.     switch(settings.webuiSettings.clickQueueSong) {
  151.         case 'play':
  152.             if (songid === null) {
  153.                 return;
  154.             }
  155.             if (currentState.currentSongId === songid) {
  156.                 return clickPlay();
  157.             }
  158.             return sendAPI("MYMPD_API_PLAYER_PLAY_SONG", {
  159.                 "songId": songid
  160.             }, null, false);
  161.         case 'view':
  162.             if (uri === null) {
  163.                 return;
  164.             }
  165.             return songDetails(uri);
  166.         case 'context':
  167.             return showContextMenu(event);
  168.         default: logError('Invalid action: ' + settings.webuiSettings.clickQueueSong);
  169.     }
  170. }
  172. /**
  173.  * Handler for playlist links
  174.  * @param {string} uri playlist uri
  175.  * @param {event} event the event
  176.  * @returns {void}
  177.  */
  178. function clickPlaylist(uri, event) {
  179.     switch(settings.webuiSettings.clickPlaylist) {
  180.         case 'append': return appendQueue('plist', [uri]);
  181.         case 'appendPlay': return appendPlayQueue('plist', [uri]);
  182.         case 'insertAfterCurrent': return insertAfterCurrentQueue('plist', [uri]);
  183.         case 'insertPlayAfterCurrent': return insertPlayAfterCurrentQueue('plist', [uri]);
  184.         case 'replace': return replaceQueue('plist', [uri]);
  185.         case 'replacePlay': return replacePlayQueue('plist', [uri]);
  186.         case 'view': return gotoPlaylist(uri);
  187.         case 'context': return showContextMenu(event);
  188.         default: logError('Invalid action: ' + settings.webuiSettings.clickPlaylist);
  189.     }
  190. }
  192. /**
  193.  * Handler for click on playlists in filesystem view
  194.  * @param {string} uri playlist uri
  195.  * @param {event} event the event
  196.  * @returns {void}
  197.  */
  198. function clickFilesystemPlaylist(uri, event) {
  199.     switch(settings.webuiSettings.clickFilesystemPlaylist) {
  200.         case 'append': return appendQueue('plist', [uri]);
  201.         case 'appendPlay': return appendPlayQueue('plist', [uri]);
  202.         case 'insertAfterCurrent': return insertAfterCurrentQueue('plist', [uri]);
  203.         case 'insertPlayAfterCurrent': return insertPlayAfterCurrentQueue('plist', [uri]);
  204.         case 'replace': return replaceQueue('plist', [uri]);
  205.         case 'replacePlay': return replacePlayQueue('plist', [uri]);
  206.         case 'view':
  207.             //remember offset for current browse uri
  208.             browseFilesystemHistory[app.current.filter] = {
  209.                 "offset": app.current.offset,
  210.                 "scrollPos": document.body.scrollTop ? document.body.scrollTop : document.documentElement.scrollTop
  211.             };
  212.             //reset search and show playlist
  213.             app.current.search = '';
  214.             appGoto('Browse', 'Filesystem', undefined, 0, app.current.limit, uri, app.current.sort, 'plist', '', 0);
  215.             break;
  216.         case 'context': return showContextMenu(event);
  217.         default: logError('Invalid action: ' + settings.webuiSettings.clickFilesystemPlaylist);
  218.     }
  219. }
  221. /**
  222.  * Handler for click on folder in filesystem view
  223.  * @param {string} uri folder uri
  224.  * @returns {void}
  225.  */
  226. function clickFolder(uri) {
  227.     //remember offset for current browse uri
  228.     browseFilesystemHistory[app.current.filter] = {
  229.         "offset": app.current.offset,
  230.         "scrollPos": getScrollPosY()
  231.     };
  232.     //reset search and open folder
  233.     app.current.search = '';
  234.     appGoto('Browse', 'Filesystem', undefined, 0, app.current.limit, uri, app.current.sort, 'dir', '', 0);
  235. }
  237. /**
  238.  * Seeks the current song forward by 5s
  239.  * @returns {void}
  240.  */
  241. function seekRelativeForward() {
  242.     seekRelative(5);
  243. }
  245. /**
  246.  * Seeks the current song backward by 5s
  247.  * @returns {void}
  248.  */
  249. function seekRelativeBackward() {
  250.     seekRelative(-5);
  251. }
  253. /**
  254.  * Seeks the current song by offset seconds
  255.  * @param {number} offset relative seek offset
  256.  * @returns {void}
  257.  */
  258. function seekRelative(offset) {
  259.     sendAPI("MYMPD_API_PLAYER_SEEK_CURRENT", {
  260.         "seek": offset,
  261.         "relative": true
  262.     }, null, false);
  263. }
  265. /**
  266.  * Handler for click on play button
  267.  * @returns {void}
  268.  */
  269. //eslint-disable-next-line no-unused-vars
  270. function clickPlay() {
  271.     switch(currentState.state) {
  272.         case 'play':
  273.             if (settings.webuiSettings.footerPlaybackControls === 'stop') {
  274.                 sendAPI("MYMPD_API_PLAYER_STOP", {}, null, false);
  275.             }
  276.             else {
  277.                 sendAPI("MYMPD_API_PLAYER_PAUSE", {}, null, false);
  278.             }
  279.             break;
  280.         case 'pause':
  281.             sendAPI("MYMPD_API_PLAYER_RESUME", {}, null, false);
  282.             break;
  283.         default:
  284.             //fallback if playstate is stop or unknown
  285.             sendAPI("MYMPD_API_PLAYER_PLAY", {}, null, false);
  286.     }
  287. }
  289. /**
  290.  * Handler for click on stop button
  291.  * @returns {void}
  292.  */
  293. //eslint-disable-next-line no-unused-vars
  294. function clickStop() {
  295.     sendAPI("MYMPD_API_PLAYER_STOP", {}, null, false);
  296. }
  298. /**
  299.  * Handler for click on prev song button
  300.  * @returns {void}
  301.  */
  302. //eslint-disable-next-line no-unused-vars
  303. function clickPrev() {
  304.     sendAPI("MYMPD_API_PLAYER_PREV", {}, null, false);
  305. }
  307. /**
  308.  * Handler for click on next song button
  309.  * @returns {void}
  310.  */
  311. //eslint-disable-next-line no-unused-vars
  312. function clickNext() {
  313.     sendAPI("MYMPD_API_PLAYER_NEXT", {}, null, false);
  314. }
  316. /**
  317.  * Handler for click on fast rewind button
  318.  * @returns {void}
  319.  */
  320. //eslint-disable-next-line no-unused-vars
  321. function clickFastRewind() {
  322.     clickSeek(-settings.webuiSettings.seekStep, true);
  323. }
  325. /**
  326.  * Handler for click on fast rewind button in playback controls popover
  327.  * @returns {void}
  328.  */
  329. //eslint-disable-next-line no-unused-vars
  330. function clickFastRewindValue() {
  331.     lastSeekStep = parseToSeconds(elGetById('popoverFooterSeekInput').value);
  332.     clickSeek(-lastSeekStep, true);
  333. }
  335. /**
  336.  * Handler for click on fast rewind button
  337.  * @returns {void}
  338.  */
  339. //eslint-disable-next-line no-unused-vars
  340. function clickFastForward() {
  341.     clickSeek(settings.webuiSettings.seekStep, true);
  342. }
  344. /**
  345.  * Handler for click on fast rewind button in playback controls popover
  346.  * @returns {void}
  347.  */
  348. //eslint-disable-next-line no-unused-vars
  349. function clickFastForwardValue() {
  350.     lastSeekStep = parseToSeconds(elGetById('popoverFooterSeekInput').value);
  351.     clickSeek(lastSeekStep, true);
  352. }
  354. /**
  355.  * Handler for click on goto position button in playback controls popover
  356.  * @returns {void}
  357.  */
  358. //eslint-disable-next-line no-unused-vars
  359. function clickGotoPos() {
  360.     const seekToPos = parseToSeconds(elGetById('popoverFooterGotoInput').value);
  361.     clickSeek(seekToPos, false);
  362. }
  364. /**
  365.  * Shows the advanced playback control popover
  366.  * @param {Event} event triggering event
  367.  * @returns {void}
  368.  */
  369. function toggleAdvPlaycontrolsPopover(event) {
  370.     if (event.target.closest('.dropdown-menu') !== null) {
  371.         return;
  372.     }
  373.     event.preventDefault();
  374.     event.stopPropagation();
  375.     if (domCache.footer.getAttribute('aria-describedby') === null) {
  376.         showPopover(domCache.footer, 'footer');
  377.     }
  378.     else {
  379.         hidePopover();
  380.     }
  381. }
  383. /**
  384.  * Seek handler
  385.  * @param {number} value seek by/to value
  386.  * @param {boolean} relative true = number is relative
  387.  * @returns {void}
  388.  */
  389. function clickSeek(value, relative) {
  390.     sendAPI("MYMPD_API_PLAYER_SEEK_CURRENT", {
  391.         "seek": value,
  392.         "relative": relative
  393.     }, null, false);
  394. }
  396. /**
  397.  * Handler for click on single button
  398.  * @param {string} mode single mode: "0" = off, "1" = single, "oneshot" = single one shot
  399.  * @returns {void}
  400.  */
  401. //eslint-disable-next-line no-unused-vars
  402. function clickSingle(mode) {
  403.     sendAPI("MYMPD_API_PLAYER_OPTIONS_SET", {
  404.         "single": mode
  405.     }, null, false);
  406. }
  408. /**
  409.  * Handler for click on consume button
  410.  * @param {string} mode single mode: "0" = off, "1" = consume, "oneshot" = consume one shot
  411.  * @returns {void}
  412.  */
  413. //eslint-disable-next-line no-unused-vars
  414. function clickConsume(mode) {
  415.     sendAPI("MYMPD_API_PLAYER_OPTIONS_SET", {
  416.         "consume": mode
  417.     }, null, false);
  418. }
  420. /**
  421.  * Handler for resume song dropdown actions
  422.  * @param {Event} event Click event
  423.  * @returns {void}
  424.  */
  425. function clickResumeSong(event) {
  426.     event.preventDefault();
  427.     if (event.target.nodeName !== 'BUTTON') {
  428.         return;
  429.     }
  430.     const dataNode = event.target.closest('.btn-group');
  431.     const uri = getData(dataNode, 'uri');
  432.     const action = event.target.getAttribute('data-action');
  433.     resumeSong(uri, action);
  434. }
  436. /**
  437.  * Handler for song resume - click on resume indicator
  438.  * @param {EventTarget} target event target
  439.  * @returns {void}
  440.  */
  441. function clickQuickResumeSong(target) {
  442.     const uri = getData(target, 'uri');
  443.     resumeSong(uri, settings.webuiSettings.clickQuickPlay);
  444. }
  446. /**
  447.  * Handler for resume playlist dropdown actions
  448.  * @param {Event} event Click event
  449.  * @returns {void}
  450.  */
  451. function clickResumePlist(event) {
  452.     event.preventDefault();
  453.     if (event.target.nodeName !== 'BUTTON') {
  454.         return;
  455.     }
  456.     const dataNode = event.target.closest('.btn-group');
  457.     const pos = getData(dataNode, 'pos');
  458.     const uri = getDataId('BrowsePlaylistDetailList', 'uri');
  459.     const action = event.target.getAttribute('data-action');
  460.     resumePlist(uri, pos, action);
  461. }
  463. /**
  464.  * Handler for resume album dropdown actions
  465.  * @param {Event} event Click event
  466.  * @returns {void}
  467.  */
  468. function clickResumeAlbum(event) {
  469.     event.preventDefault();
  470.     if (event.target.nodeName !== 'BUTTON') {
  471.         return;
  472.     }
  473.     const dataNode = event.target.closest('.btn-group');
  474.     const pos = getData(dataNode, 'pos');
  475.     const albumId = getDataId('viewDatabaseAlbumDetailCover', 'AlbumId');
  476.     const action = event.target.getAttribute('data-action');
  477.     resumeAlbum(albumId, pos, action);
  478. }