+
+
+
+
+
+
+
diff --git a/searx/static/themes/simple/fonts/ion.svg b/searx/static/themes/simple/fonts/ion.svg
new file mode 100644
index 000000000..db43668d4
--- /dev/null
+++ b/searx/static/themes/simple/fonts/ion.svg
@@ -0,0 +1,97 @@
+
+
+
+
diff --git a/searx/static/themes/simple/fonts/ion.ttf b/searx/static/themes/simple/fonts/ion.ttf
new file mode 100644
index 000000000..4631e91b8
Binary files /dev/null and b/searx/static/themes/simple/fonts/ion.ttf differ
diff --git a/searx/static/themes/simple/fonts/ion.woff b/searx/static/themes/simple/fonts/ion.woff
new file mode 100644
index 000000000..767c1263a
Binary files /dev/null and b/searx/static/themes/simple/fonts/ion.woff differ
diff --git a/searx/static/themes/simple/fonts/ion.woff2 b/searx/static/themes/simple/fonts/ion.woff2
new file mode 100644
index 000000000..377710b51
Binary files /dev/null and b/searx/static/themes/simple/fonts/ion.woff2 differ
diff --git a/searx/static/themes/simple/gruntfile.js b/searx/static/themes/simple/gruntfile.js
new file mode 100644
index 000000000..288ab6633
--- /dev/null
+++ b/searx/static/themes/simple/gruntfile.js
@@ -0,0 +1,150 @@
+module.exports = function(grunt) {
+
+ const path = require('path');
+
+ grunt.initConfig({
+ pkg: grunt.file.readJSON('package.json'),
+ watch: {
+ scripts: {
+ files: ['<%= jshint.files %>', 'less/*.less'],
+ tasks: ['jshint', 'concat', 'uglify', 'webfont', 'less:development', 'less:production']
+ }
+ },
+ concat: {
+ options: {
+ separator: ';'
+ },
+ dist: {
+ src: ['js/searx_src/*.js'],
+ dest: 'js/searx.js'
+ }
+ },
+ uglify: {
+ options: {
+ banner: '/*! simple/searx.min.js | <%= grunt.template.today("dd-mm-yyyy") %> | https://github.com/asciimoo/searx */\n',
+ preserveComments: 'some',
+ sourceMap: true
+ },
+ dist: {
+ files: {
+ 'js/searx.min.js': ['<%= concat.dist.dest %>']
+ }
+ }
+ },
+ jshint: {
+ files: ['js/searx_src/*.js'],
+ options: {
+ proto: true,
+ // options here to override JSHint defaults
+ globals: {
+ browser: true,
+ jQuery: false,
+ devel: true
+ }
+ }
+ },
+ less: {
+ development: {
+ options: {
+ paths: ["less"],
+ banner: '/*! searx | <%= grunt.template.today("dd-mm-yyyy") %> | https://github.com/asciimoo/searx */\n'
+ },
+ files: {
+ "css/searx.css": "less/style.less",
+ "css/searx-rtl.css": "less/style-rtl.less"
+ }
+ },
+ production: {
+ options: {
+ paths: ["less"],
+ plugins: [
+ new (require('less-plugin-clean-css'))({
+ advanced: true,
+ compatibility: 'ie8'
+ })
+ ],
+ banner: '/*! searx | <%= grunt.template.today("dd-mm-yyyy") %> | https://github.com/asciimoo/searx */\n'
+ },
+ files: {
+ "css/searx.min.css": "less/style.less",
+ "css/searx-rtl.min.css": "less/style-rtl.less"
+ }
+ },
+ },
+ webfont: {
+ icons: {
+ // src: 'node_modules/ionicons-npm/src/*.svg',
+ src: [
+ 'node_modules/ionicons-npm/src/navicon-round.svg',
+ 'node_modules/ionicons-npm/src/search.svg',
+ 'node_modules/ionicons-npm/src/play.svg',
+ 'node_modules/ionicons-npm/src/link.svg',
+ 'node_modules/ionicons-npm/src/chevron-up.svg',
+ 'node_modules/ionicons-npm/src/chevron-left.svg',
+ 'node_modules/ionicons-npm/src/chevron-right.svg',
+ 'node_modules/ionicons-npm/src/arrow-down-a.svg',
+ 'node_modules/ionicons-npm/src/arrow-up-a.svg',
+ 'node_modules/ionicons-npm/src/arrow-swap.svg',
+ 'node_modules/ionicons-npm/src/telephone.svg',
+ 'node_modules/ionicons-npm/src/android-arrow-dropdown.svg',
+ 'node_modules/ionicons-npm/src/android-globe.svg',
+ 'node_modules/ionicons-npm/src/android-time.svg',
+ 'node_modules/ionicons-npm/src/location.svg',
+ 'node_modules/ionicons-npm/src/alert-circled.svg',
+ 'node_modules/ionicons-npm/src/android-alert.svg',
+ 'node_modules/ionicons-npm/src/ios-film-outline.svg',
+ 'node_modules/ionicons-npm/src/music-note.svg',
+ 'node_modules/ionicons-npm/src/ion-close-round.svg',
+ 'node_modules/ionicons-npm/src/android-more-vertical.svg',
+ 'magnet.svg'
+ ],
+ dest: 'fonts',
+ destLess: 'less',
+ options: {
+ font: 'ion',
+ hashes : true,
+ syntax: 'bem',
+ styles : 'font,icon',
+ types : 'eot,woff2,woff,ttf,svg',
+ order : 'eot,woff2,woff,ttf,svg',
+ stylesheets : ['css', 'less'],
+ relativeFontPath : '../fonts/',
+ autoHint : false,
+ normalize : false,
+ // ligatures : true,
+ optimize : true,
+ // fontHeight : 400,
+ rename : function(name) {
+ basename = path.basename(name);
+ if (basename === 'android-alert.svg') {
+ return 'error.svg';
+ }
+ if (basename === 'alert-circled.svg') {
+ return 'warning.svg';
+ }
+ if (basename === 'ion-close-round.svg') {
+ return 'close.svg';
+ }
+ return basename.replace(/(ios|md|android)-/i, '');
+ },
+ templateOptions: {
+ baseClass: 'ion-icon',
+ classPrefix: 'ion-'
+ }
+ }
+ }
+ }
+ });
+
+ grunt.loadNpmTasks('grunt-contrib-watch');
+ grunt.loadNpmTasks('grunt-contrib-uglify');
+ grunt.loadNpmTasks('grunt-contrib-jshint');
+ grunt.loadNpmTasks('grunt-contrib-concat');
+ grunt.loadNpmTasks('grunt-contrib-less');
+ grunt.loadNpmTasks('grunt-contrib-cssmin');
+ grunt.loadNpmTasks('grunt-webfont');
+
+ grunt.registerTask('test', ['jshint']);
+
+ grunt.registerTask('default', ['jshint', 'concat', 'uglify', 'less:development', 'less:production']);
+};
diff --git a/searx/static/themes/simple/img/favicon.png b/searx/static/themes/simple/img/favicon.png
new file mode 100644
index 000000000..36be5fc01
Binary files /dev/null and b/searx/static/themes/simple/img/favicon.png differ
diff --git a/searx/static/themes/simple/img/loader.gif b/searx/static/themes/simple/img/loader.gif
new file mode 100644
index 000000000..419cdeeda
Binary files /dev/null and b/searx/static/themes/simple/img/loader.gif differ
diff --git a/searx/static/themes/simple/img/logo_searx_a.png b/searx/static/themes/simple/img/logo_searx_a.png
new file mode 100644
index 000000000..2db081710
Binary files /dev/null and b/searx/static/themes/simple/img/logo_searx_a.png differ
diff --git a/searx/static/themes/simple/img/searx.png b/searx/static/themes/simple/img/searx.png
new file mode 100644
index 000000000..98538da3a
Binary files /dev/null and b/searx/static/themes/simple/img/searx.png differ
diff --git a/searx/static/themes/simple/img/searx_logo.svg b/searx/static/themes/simple/img/searx_logo.svg
new file mode 100644
index 000000000..67a2d4588
--- /dev/null
+++ b/searx/static/themes/simple/img/searx_logo.svg
@@ -0,0 +1,203 @@
+
+
+
+
diff --git a/searx/static/themes/simple/js/searx.js b/searx/static/themes/simple/js/searx.js
new file mode 100644
index 000000000..64329fde1
--- /dev/null
+++ b/searx/static/themes/simple/js/searx.js
@@ -0,0 +1,1534 @@
+/**
+* searx is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Affero General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* searx is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU Affero General Public License for more details.
+*
+* You should have received a copy of the GNU Affero General Public License
+* along with searx. If not, see < http://www.gnu.org/licenses/ >.
+*
+* (C) 2017 by Alexandre Flament,
+*
+*/
+(function(w, d, searx) {
+
+ 'use strict';
+
+ // not invented here tookit with bugs fixed elsewhere
+ // purposes : be just good enough and as small as possible
+
+ // from https://plainjs.com/javascript/events/live-binding-event-handlers-14/
+ if (w.Element) {
+ (function(ElementPrototype) {
+ ElementPrototype.matches = ElementPrototype.matches ||
+ ElementPrototype.matchesSelector ||
+ ElementPrototype.webkitMatchesSelector ||
+ ElementPrototype.msMatchesSelector ||
+ function(selector) {
+ var node = this, nodes = (node.parentNode || node.document).querySelectorAll(selector), i = -1;
+ while (nodes[++i] && nodes[i] != node);
+ return !!nodes[i];
+ };
+ })(Element.prototype);
+ }
+
+ function callbackSafe(callback, el, e) {
+ try {
+ callback.call(el, e);
+ } catch (exception) {
+ console.log(exception);
+ }
+ }
+
+ searx = searx || {};
+
+ searx.on = function(obj, eventType, callback, useCapture) {
+ useCapture = useCapture || false;
+ if (typeof obj !== 'string') {
+ // obj HTMLElement, HTMLDocument
+ obj.addEventListener(eventType, callback, useCapture);
+ } else {
+ // obj is a selector
+ d.addEventListener(eventType, function(e) {
+ var el = e.target || e.srcElement, found = false;
+ while (el && el.matches && el !== d && !(found = el.matches(obj))) el = el.parentElement;
+ if (found) callbackSafe(callback, el, e);
+ }, useCapture);
+ }
+ };
+
+ searx.ready = function(callback) {
+ if (document.readyState != 'loading') {
+ callback.call(w);
+ } else {
+ w.addEventListener('DOMContentLoaded', callback.bind(w));
+ }
+ };
+
+ searx.http = function(method, url, callback) {
+ var req = new XMLHttpRequest(),
+ resolve = function() {},
+ reject = function() {},
+ promise = {
+ then: function(callback) { resolve = callback; return promise; },
+ catch: function(callback) { reject = callback; return promise; }
+ };
+
+ try {
+ req.open(method, url, true);
+
+ // On load
+ req.onload = function() {
+ if (req.status == 200) {
+ resolve(req.response, req.responseType);
+ } else {
+ reject(Error(req.statusText));
+ }
+ };
+
+ // Handle network errors
+ req.onerror = function() {
+ reject(Error("Network Error"));
+ };
+
+ req.onabort = function() {
+ reject(Error("Transaction is aborted"));
+ };
+
+ // Make the request
+ req.send();
+ } catch (ex) {
+ reject(ex);
+ }
+
+ return promise;
+ };
+
+ searx.loadStyle = function(src) {
+ var path = searx.staticPath + src,
+ id = "style_" + src.replace('.', '_'),
+ s = d.getElementById(id);
+ if (s === null) {
+ s = d.createElement('link');
+ s.setAttribute('id', id);
+ s.setAttribute('rel', 'stylesheet');
+ s.setAttribute('type', 'text/css');
+ s.setAttribute('href', path);
+ d.body.appendChild(s);
+ }
+ };
+
+ searx.loadScript = function(src, callback) {
+ var path = searx.staticPath + src,
+ id = "script_" + src.replace('.', '_'),
+ s = d.getElementById(id);
+ if (s === null) {
+ s = d.createElement('script');
+ s.setAttribute('id', id);
+ s.setAttribute('src', path);
+ s.onload = callback;
+ s.onerror = function() {
+ s.setAttribute('error', '1');
+ };
+ d.body.appendChild(s);
+ } else if (!s.hasAttribute('error')) {
+ try {
+ callback.apply(s, []);
+ } catch (exception) {
+ console.log(exception);
+ }
+ } else {
+ console.log("callback not executed : script '" + path + "' not loaded.");
+ }
+ };
+
+ searx.on('.close', 'click', function(e) {
+ var el = e.target || e.srcElement;
+ this.parentNode.style.display="None";
+ });
+ return searx;
+})(window, document, window.searx);
+;(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.AutoComplete = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o @baptistedonaux
+ */
+var AutoComplete = (function () {
+ // Constructor
+ function AutoComplete(params, selector) {
+ if (params === void 0) { params = {}; }
+ if (selector === void 0) { selector = "[data-autocomplete]"; }
+ if (Array.isArray(selector)) {
+ selector.forEach(function (s) {
+ new AutoComplete(params, s);
+ });
+ }
+ else if (typeof selector == "string") {
+ var elements = document.querySelectorAll(selector);
+ Array.prototype.forEach.call(elements, function (input) {
+ new AutoComplete(params, input);
+ });
+ }
+ else {
+ var specificParams = AutoComplete.merge(AutoComplete.defaults, params, {
+ DOMResults: document.createElement("div")
+ });
+ AutoComplete.prototype.create(specificParams, selector);
+ return specificParams;
+ }
+ }
+ AutoComplete.prototype.create = function (params, element) {
+ params.Input = element;
+ if (params.Input.nodeName.match(/^INPUT$/i) && (params.Input.hasAttribute("type") === false || params.Input.getAttribute("type").match(/^TEXT|SEARCH$/i))) {
+ params.Input.setAttribute("autocomplete", "off");
+ params._Position(params);
+ params.Input.parentNode.appendChild(params.DOMResults);
+ params.$Listeners = {
+ blur: params._Blur.bind(params),
+ destroy: AutoComplete.prototype.destroy.bind(null, params),
+ focus: params._Focus.bind(params),
+ keyup: AutoComplete.prototype.event.bind(null, params, EventType.KEYUP),
+ keydown: AutoComplete.prototype.event.bind(null, params, EventType.KEYDOWN),
+ position: params._Position.bind(params)
+ };
+ for (var event in params.$Listeners) {
+ params.Input.addEventListener(event, params.$Listeners[event]);
+ }
+ }
+ };
+ AutoComplete.prototype.getEventsByType = function (params, type) {
+ var mappings = {};
+ for (var key in params.KeyboardMappings) {
+ var event = EventType.KEYUP;
+ if (params.KeyboardMappings[key].Event !== undefined) {
+ event = params.KeyboardMappings[key].Event;
+ }
+ if (event == type) {
+ mappings[key] = params.KeyboardMappings[key];
+ }
+ }
+ return mappings;
+ };
+ AutoComplete.prototype.event = function (params, type, event) {
+ var eventIdentifier = function (condition) {
+ if ((match === true && mapping.Operator == ConditionOperator.AND) || (match === false && mapping.Operator == ConditionOperator.OR)) {
+ condition = AutoComplete.merge({
+ Not: false
+ }, condition);
+ if (condition.hasOwnProperty("Is")) {
+ if (condition.Is == event.keyCode) {
+ match = !condition.Not;
+ }
+ else {
+ match = condition.Not;
+ }
+ }
+ else if (condition.hasOwnProperty("From") && condition.hasOwnProperty("To")) {
+ if (event.keyCode >= condition.From && event.keyCode <= condition.To) {
+ match = !condition.Not;
+ }
+ else {
+ match = condition.Not;
+ }
+ }
+ }
+ };
+ for (var name in AutoComplete.prototype.getEventsByType(params, type)) {
+ var mapping = AutoComplete.merge({
+ Operator: ConditionOperator.AND
+ }, params.KeyboardMappings[name]), match = ConditionOperator.AND == mapping.Operator;
+ mapping.Conditions.forEach(eventIdentifier);
+ if (match === true) {
+ mapping.Callback.call(params, event);
+ }
+ }
+ };
+ AutoComplete.prototype.makeRequest = function (params, callback) {
+ var propertyHttpHeaders = Object.getOwnPropertyNames(params.HttpHeaders), request = new XMLHttpRequest(), method = params._HttpMethod(), url = params._Url(), queryParams = params._Pre(), queryParamsStringify = encodeURIComponent(params._QueryArg()) + "=" + encodeURIComponent(queryParams);
+ if (method.match(/^GET$/i)) {
+ if (url.indexOf("?") !== -1) {
+ url += "&" + queryParamsStringify;
+ }
+ else {
+ url += "?" + queryParamsStringify;
+ }
+ }
+ request.open(method, url, true);
+ for (var i = propertyHttpHeaders.length - 1; i >= 0; i--) {
+ request.setRequestHeader(propertyHttpHeaders[i], params.HttpHeaders[propertyHttpHeaders[i]]);
+ }
+ request.onreadystatechange = function () {
+ if (request.readyState == 4 && request.status == 200) {
+ params.$Cache[queryParams] = request.response;
+ callback(request.response);
+ }
+ };
+ return request;
+ };
+ AutoComplete.prototype.ajax = function (params, request, timeout) {
+ if (timeout === void 0) { timeout = true; }
+ if (params.$AjaxTimer) {
+ window.clearTimeout(params.$AjaxTimer);
+ }
+ if (timeout === true) {
+ params.$AjaxTimer = window.setTimeout(AutoComplete.prototype.ajax.bind(null, params, request, false), params.Delay);
+ }
+ else {
+ if (params.Request) {
+ params.Request.abort();
+ }
+ params.Request = request;
+ params.Request.send(params._QueryArg() + "=" + params._Pre());
+ }
+ };
+ AutoComplete.prototype.cache = function (params, callback) {
+ var response = params._Cache(params._Pre());
+ if (response === undefined) {
+ var request = AutoComplete.prototype.makeRequest(params, callback);
+ AutoComplete.prototype.ajax(params, request);
+ }
+ else {
+ callback(response);
+ }
+ };
+ AutoComplete.prototype.destroy = function (params) {
+ for (var event in params.$Listeners) {
+ params.Input.removeEventListener(event, params.$Listeners[event]);
+ }
+ params.DOMResults.parentNode.removeChild(params.DOMResults);
+ };
+ return AutoComplete;
+}());
+AutoComplete.merge = function () {
+ var merge = {}, tmp;
+ for (var i = 0; i < arguments.length; i++) {
+ for (tmp in arguments[i]) {
+ merge[tmp] = arguments[i][tmp];
+ }
+ }
+ return merge;
+};
+AutoComplete.defaults = {
+ Delay: 150,
+ EmptyMessage: "No result here",
+ Highlight: {
+ getRegex: function (value) {
+ return new RegExp(value, "ig");
+ },
+ transform: function (value) {
+ return "" + value + "";
+ }
+ },
+ HttpHeaders: {
+ "Content-type": "application/x-www-form-urlencoded"
+ },
+ Limit: 0,
+ MinChars: 0,
+ HttpMethod: "GET",
+ QueryArg: "q",
+ Url: null,
+ KeyboardMappings: {
+ "Enter": {
+ Conditions: [{
+ Is: 13,
+ Not: false
+ }],
+ Callback: function (event) {
+ if (this.DOMResults.getAttribute("class").indexOf("open") != -1) {
+ var liActive = this.DOMResults.querySelector("li.active");
+ if (liActive !== null) {
+ event.preventDefault();
+ this._Select(liActive);
+ this.DOMResults.setAttribute("class", "autocomplete");
+ }
+ }
+ },
+ Operator: ConditionOperator.AND,
+ Event: EventType.KEYDOWN
+ },
+ "KeyUpAndDown_down": {
+ Conditions: [{
+ Is: 38,
+ Not: false
+ },
+ {
+ Is: 40,
+ Not: false
+ }],
+ Callback: function (event) {
+ event.preventDefault();
+ },
+ Operator: ConditionOperator.OR,
+ Event: EventType.KEYDOWN
+ },
+ "KeyUpAndDown_up": {
+ Conditions: [{
+ Is: 38,
+ Not: false
+ },
+ {
+ Is: 40,
+ Not: false
+ }],
+ Callback: function (event) {
+ event.preventDefault();
+ var first = this.DOMResults.querySelector("li:first-child:not(.locked)"), last = this.DOMResults.querySelector("li:last-child:not(.locked)"), active = this.DOMResults.querySelector("li.active");
+ if (active) {
+ var currentIndex = Array.prototype.indexOf.call(active.parentNode.children, active), position = currentIndex + (event.keyCode - 39), lisCount = this.DOMResults.getElementsByTagName("li").length;
+ if (position < 0) {
+ position = lisCount - 1;
+ }
+ else if (position >= lisCount) {
+ position = 0;
+ }
+ active.classList.remove("active");
+ active.parentElement.children.item(position).classList.add("active");
+ }
+ else if (last && event.keyCode == 38) {
+ last.classList.add("active");
+ }
+ else if (first) {
+ first.classList.add("active");
+ }
+ },
+ Operator: ConditionOperator.OR,
+ Event: EventType.KEYUP
+ },
+ "AlphaNum": {
+ Conditions: [{
+ Is: 13,
+ Not: true
+ }, {
+ From: 35,
+ To: 40,
+ Not: true
+ }],
+ Callback: function () {
+ var oldValue = this.Input.getAttribute("data-autocomplete-old-value"), currentValue = this._Pre();
+ if (currentValue !== "" && currentValue.length >= this._MinChars()) {
+ if (!oldValue || currentValue != oldValue) {
+ this.DOMResults.setAttribute("class", "autocomplete open");
+ }
+ AutoComplete.prototype.cache(this, function (response) {
+ this._Render(this._Post(response));
+ this._Open();
+ }.bind(this));
+ }
+ },
+ Operator: ConditionOperator.AND,
+ Event: EventType.KEYUP
+ }
+ },
+ DOMResults: null,
+ Request: null,
+ Input: null,
+ /**
+ * Return the message when no result returns
+ */
+ _EmptyMessage: function () {
+ var emptyMessage = "";
+ if (this.Input.hasAttribute("data-autocomplete-empty-message")) {
+ emptyMessage = this.Input.getAttribute("data-autocomplete-empty-message");
+ }
+ else if (this.EmptyMessage !== false) {
+ emptyMessage = this.EmptyMessage;
+ }
+ else {
+ emptyMessage = "";
+ }
+ return emptyMessage;
+ },
+ /**
+ * Returns the maximum number of results
+ */
+ _Limit: function () {
+ var limit = this.Input.getAttribute("data-autocomplete-limit");
+ if (isNaN(limit) || limit === null) {
+ return this.Limit;
+ }
+ return parseInt(limit, 10);
+ },
+ /**
+ * Returns the minimum number of characters entered before firing ajax
+ */
+ _MinChars: function () {
+ var minchars = this.Input.getAttribute("data-autocomplete-minchars");
+ if (isNaN(minchars) || minchars === null) {
+ return this.MinChars;
+ }
+ return parseInt(minchars, 10);
+ },
+ /**
+ * Apply transformation on labels response
+ */
+ _Highlight: function (label) {
+ return label.replace(this.Highlight.getRegex(this._Pre()), this.Highlight.transform);
+ },
+ /**
+ * Returns the HHTP method to use
+ */
+ _HttpMethod: function () {
+ if (this.Input.hasAttribute("data-autocomplete-method")) {
+ return this.Input.getAttribute("data-autocomplete-method");
+ }
+ return this.HttpMethod;
+ },
+ /**
+ * Returns the query param to use
+ */
+ _QueryArg: function () {
+ if (this.Input.hasAttribute("data-autocomplete-param-name")) {
+ return this.Input.getAttribute("data-autocomplete-param-name");
+ }
+ return this.QueryArg;
+ },
+ /**
+ * Returns the URL to use for AJAX request
+ */
+ _Url: function () {
+ if (this.Input.hasAttribute("data-autocomplete")) {
+ return this.Input.getAttribute("data-autocomplete");
+ }
+ return this.Url;
+ },
+ /**
+ * Manage the close
+ */
+ _Blur: function (now) {
+ if (now === true) {
+ this.DOMResults.setAttribute("class", "autocomplete");
+ this.Input.setAttribute("data-autocomplete-old-value", this.Input.value);
+ }
+ else {
+ var params = this;
+ setTimeout(function () {
+ params._Blur(true);
+ }, 150);
+ }
+ },
+ /**
+ * Manage the cache
+ */
+ _Cache: function (value) {
+ return this.$Cache[value];
+ },
+ /**
+ * Manage the open
+ */
+ _Focus: function () {
+ var oldValue = this.Input.getAttribute("data-autocomplete-old-value");
+ if ((!oldValue || this.Input.value != oldValue) && this._MinChars() <= this.Input.value.length) {
+ this.DOMResults.setAttribute("class", "autocomplete open");
+ }
+ },
+ /**
+ * Bind all results item if one result is opened
+ */
+ _Open: function () {
+ var params = this;
+ Array.prototype.forEach.call(this.DOMResults.getElementsByTagName("li"), function (li) {
+ if (li.getAttribute("class") != "locked") {
+ li.onclick = function (event) {
+ params._Select(li);
+ };
+ li.onmouseenter = function () {
+ var active = params.DOMResults.querySelector("li.active");
+ if (active !== li) {
+ if (active !== null) {
+ active.classList.remove("active");
+ }
+ li.classList.add("active");
+ }
+ };
+ }
+ });
+ },
+ /**
+ * Position the results HTML element
+ */
+ _Position: function () {
+ this.DOMResults.setAttribute("class", "autocomplete");
+ this.DOMResults.setAttribute("style", "top:" + (this.Input.offsetTop + this.Input.offsetHeight) + "px;left:" + this.Input.offsetLeft + "px;width:" + this.Input.clientWidth + "px;");
+ },
+ /**
+ * Execute the render of results DOM element
+ */
+ _Render: function (response) {
+ var ul;
+ if (typeof response == "string") {
+ ul = this._RenderRaw(response);
+ }
+ else {
+ ul = this._RenderResponseItems(response);
+ }
+ if (this.DOMResults.hasChildNodes()) {
+ this.DOMResults.removeChild(this.DOMResults.childNodes[0]);
+ }
+ this.DOMResults.appendChild(ul);
+ },
+ /**
+ * ResponseItems[] rendering
+ */
+ _RenderResponseItems: function (response) {
+ var ul = document.createElement("ul"), li = document.createElement("li"), limit = this._Limit();
+ // Order
+ if (limit < 0) {
+ response = response.reverse();
+ }
+ else if (limit === 0) {
+ limit = response.length;
+ }
+ for (var item = 0; item < Math.min(Math.abs(limit), response.length); item++) {
+ li.innerHTML = response[item].Label;
+ li.setAttribute("data-autocomplete-value", response[item].Value);
+ ul.appendChild(li);
+ li = document.createElement("li");
+ }
+ return ul;
+ },
+ /**
+ * string response rendering (RAW HTML)
+ */
+ _RenderRaw: function (response) {
+ var ul = document.createElement("ul"), li = document.createElement("li");
+ if (response.length > 0) {
+ this.DOMResults.innerHTML = response;
+ }
+ else {
+ var emptyMessage = this._EmptyMessage();
+ if (emptyMessage !== "") {
+ li.innerHTML = emptyMessage;
+ li.setAttribute("class", "locked");
+ ul.appendChild(li);
+ }
+ }
+ return ul;
+ },
+ /**
+ * Deal with request response
+ */
+ _Post: function (response) {
+ try {
+ var returnResponse = [];
+ //JSON return
+ var json = JSON.parse(response);
+ if (Object.keys(json).length === 0) {
+ return "";
+ }
+ if (Array.isArray(json)) {
+ for (var i = 0; i < Object.keys(json).length; i++) {
+ returnResponse[returnResponse.length] = { "Value": json[i], "Label": this._Highlight(json[i]) };
+ }
+ }
+ else {
+ for (var value in json) {
+ returnResponse.push({
+ "Value": value,
+ "Label": this._Highlight(json[value])
+ });
+ }
+ }
+ return returnResponse;
+ }
+ catch (event) {
+ //HTML return
+ return response;
+ }
+ },
+ /**
+ * Return the autocomplete value to send (before request)
+ */
+ _Pre: function () {
+ return this.Input.value;
+ },
+ /**
+ * Choice one result item
+ */
+ _Select: function (item) {
+ console.log('test test test');
+ if (item.hasAttribute("data-autocomplete-value")) {
+ this.Input.value = item.getAttribute("data-autocomplete-value");
+ }
+ else {
+ this.Input.value = item.innerHTML;
+ }
+ this.Input.setAttribute("data-autocomplete-old-value", this.Input.value);
+ },
+ $AjaxTimer: null,
+ $Cache: {},
+ $Listeners: {}
+};
+module.exports = AutoComplete;
+
+},{}]},{},[1])(1)
+});
+;/**
+*
+* Google Image Layout v0.0.1
+* Description, by Anh Trinh.
+* Heavily modified for searx
+* http://trinhtrunganh.com
+*
+* @license Free to use under the MIT License.
+*
+*/
+(function(w, d) {
+ 'use strict';
+
+ function ImageLayout(container_selector, results_selector, img_selector, maxHeight) {
+ this.container_selector = container_selector;
+ this.results_selector = results_selector;
+ this.img_selector = img_selector;
+ this.margin = 10;
+ this.maxHeight = maxHeight;
+ this._alignAllDone = true;
+ }
+
+ /**
+ * Get the height that make all images fit the container
+ *
+ * width = w1 + w2 + w3 + ... = r1*h + r2*h + r3*h + ...
+ *
+ * @param {[type]} images the images to be calculated
+ * @param {[type]} width the container witdth
+ * @param {[type]} margin the margin between each image
+ *
+ * @return {[type]} the height
+ */
+ ImageLayout.prototype._getHeigth = function(images, width) {
+ var r = 0,
+ img;
+
+ width -= images.length * this.margin;
+ for (var i = 0; i < images.length; i++) {
+ img = images[i];
+ if ((img.naturalWidth > 0) && (img.naturalHeight > 0)) {
+ r += img.naturalWidth / img.naturalHeight;
+ } else {
+ // assume that not loaded images are square
+ r += 1;
+ }
+ }
+
+ return width / r; //have to round down because Firefox will automatically roundup value with number of decimals > 3
+ };
+
+ ImageLayout.prototype._setSize = function(images, height) {
+ var img, imgWidth, imagesLength = images.length;
+ for (var i = 0; i < imagesLength; i++) {
+ img = images[i];
+ if ((img.naturalWidth > 0) && (img.naturalHeight > 0)) {
+ imgWidth = height * img.naturalWidth / img.naturalHeight;
+ } else {
+ // not loaded image : make it square as _getHeigth said it
+ imgWidth = height;
+ }
+ img.style.width = imgWidth + 'px';
+ img.style.height = height + 'px';
+ img.style.marginLeft = '3px';
+ img.style.marginTop = '3px';
+ img.style.marginRight = this.margin - 7 + 'px'; // -4 is the negative margin of the inline element
+ img.style.marginBottom = this.margin - 7 + 'px';
+ }
+ };
+
+ ImageLayout.prototype._alignImgs = function(imgGroup) {
+ var slice, h,
+ containerWidth = d.querySelector(this.container_selector).clientWidth;
+
+ w: while (imgGroup.length > 0) {
+ for (var i = 1; i <= imgGroup.length; i++) {
+ slice = imgGroup.slice(0, i);
+ h = this._getHeigth(slice, containerWidth);
+ if (h < this.maxHeight) {
+ this._setSize(slice, h);
+ imgGroup = imgGroup.slice(i);
+ continue w;
+ }
+ }
+ this._setSize(slice, Math.min(this.maxHeight, h));
+ break;
+ }
+ };
+
+ ImageLayout.prototype.align = function(results_selector) {
+ var results_selectorNode = d.querySelectorAll(this.results_selector),
+ results_length = results_selectorNode.length,
+ previous = null,
+ current = null,
+ imgGroup = [];
+ for (var i = 0; i < results_length; i++) {
+ current = results_selectorNode[i];
+ if (current.previousElementSibling !== previous && imgGroup.length > 0) {
+ // the current image is not conected to previous one
+ // so the current image is the start of a new group of images.
+ // so call _alignImgs to align the current group
+ this._alignImgs(imgGroup);
+ // and start a new empty group of images
+ imgGroup = [];
+ }
+ // add the current image to the group (only the img tag)
+ imgGroup.push(current.querySelector(this.img_selector));
+ // update the previous variable
+ previous = current;
+ }
+ // align the remaining images
+ if (imgGroup.length > 0) {
+ this._alignImgs(imgGroup);
+ }
+ };
+
+ ImageLayout.prototype.watch = function() {
+ var i, img, imgGroup, imgNodeLength,
+ obj = this,
+ results_nodes = d.querySelectorAll(this.results_selector),
+ results_length = results_nodes.length;
+
+ function align(e) {
+ obj.align();
+ }
+
+ function throttleAlign(e) {
+ if (obj._alignAllDone) {
+ obj._alignAllDone = false;
+ setTimeout(function() {
+ obj.align();
+ obj._alignAllDone = true;
+ }, 100);
+ }
+ }
+
+ w.addEventListener('resize', throttleAlign);
+ w.addEventListener('pageshow', align);
+
+ for (i = 0; i < results_length; i++) {
+ img = results_nodes[i].querySelector(this.img_selector);
+ if (typeof img !== 'undefined') {
+ img.addEventListener('load', throttleAlign);
+ img.addEventListener('error', throttleAlign);
+ }
+ }
+ };
+
+ w.searx.ImageLayout = ImageLayout;
+
+})(window, document);
+;searx.ready(function() {
+
+ searx.on('.result', 'click', function() {
+ highlightResult(this)(true);
+ });
+
+ searx.on('.result a', 'focus', function(e) {
+ var el = e.target;
+ while (el !== undefined) {
+ if (el.classList.contains('result')) {
+ if (el.getAttribute("data-vim-selected") === null) {
+ highlightResult(el)(true);
+ }
+ break;
+ }
+ el = el.parentNode;
+ }
+ }, true);
+
+ var vimKeys = {
+ 27: {
+ key: 'Escape',
+ fun: removeFocus,
+ des: 'remove focus from the focused input',
+ cat: 'Control'
+ },
+ 73: {
+ key: 'i',
+ fun: searchInputFocus,
+ des: 'focus on the search input',
+ cat: 'Control'
+ },
+ 66: {
+ key: 'b',
+ fun: scrollPage(-window.innerHeight),
+ des: 'scroll one page up',
+ cat: 'Navigation'
+ },
+ 70: {
+ key: 'f',
+ fun: scrollPage(window.innerHeight),
+ des: 'scroll one page down',
+ cat: 'Navigation'
+ },
+ 85: {
+ key: 'u',
+ fun: scrollPage(-window.innerHeight / 2),
+ des: 'scroll half a page up',
+ cat: 'Navigation'
+ },
+ 68: {
+ key: 'd',
+ fun: scrollPage(window.innerHeight / 2),
+ des: 'scroll half a page down',
+ cat: 'Navigation'
+ },
+ 71: {
+ key: 'g',
+ fun: scrollPageTo(-document.body.scrollHeight, 'top'),
+ des: 'scroll to the top of the page',
+ cat: 'Navigation'
+ },
+ 86: {
+ key: 'v',
+ fun: scrollPageTo(document.body.scrollHeight, 'bottom'),
+ des: 'scroll to the bottom of the page',
+ cat: 'Navigation'
+ },
+ 75: {
+ key: 'k',
+ fun: highlightResult('up'),
+ des: 'select previous search result',
+ cat: 'Results'
+ },
+ 74: {
+ key: 'j',
+ fun: highlightResult('down'),
+ des: 'select next search result',
+ cat: 'Results'
+ },
+ 80: {
+ key: 'p',
+ fun: pageButtonClick(0),
+ des: 'go to previous page',
+ cat: 'Results'
+ },
+ 78: {
+ key: 'n',
+ fun: pageButtonClick(1),
+ des: 'go to next page',
+ cat: 'Results'
+ },
+ 79: {
+ key: 'o',
+ fun: openResult(false),
+ des: 'open search result',
+ cat: 'Results'
+ },
+ 84: {
+ key: 't',
+ fun: openResult(true),
+ des: 'open the result in a new tab',
+ cat: 'Results'
+ },
+ 82: {
+ key: 'r',
+ fun: reloadPage,
+ des: 'reload page from the server',
+ cat: 'Control'
+ },
+ 72: {
+ key: 'h',
+ fun: toggleHelp,
+ des: 'toggle help window',
+ cat: 'Other'
+ }
+ };
+
+ searx.on(document, "keyup", function(e) {
+ // check for modifiers so we don't break browser's hotkeys
+ if (vimKeys.hasOwnProperty(e.keyCode) && !e.ctrlKey && !e.altKey && !e.shiftKey && !e.metaKey) {
+ var tagName = e.target.tagName.toLowerCase();
+ if (e.keyCode === 27) {
+ if (tagName === 'input' || tagName === 'select' || tagName === 'textarea') {
+ vimKeys[e.keyCode].fun();
+ }
+ } else {
+ if (e.target === document.body || tagName === 'a' || tagName === 'button') {
+ vimKeys[e.keyCode].fun();
+ }
+ }
+ }
+ });
+
+ function highlightResult(which) {
+ return function(noScroll) {
+ var current = document.querySelector('.result[data-vim-selected]'),
+ effectiveWhich = which;
+ if (current === null) {
+ // no selection : choose the first one
+ current = document.querySelector('.result');
+ if (current === null) {
+ // no first one : there are no results
+ return;
+ }
+ // replace up/down actions by selecting first one
+ if (which === "down" || which === "up") {
+ effectiveWhich = current;
+ }
+ }
+
+ var next, results = document.querySelectorAll('.result');
+
+ if (typeof effectiveWhich !== 'string') {
+ next = effectiveWhich;
+ } else {
+ switch (effectiveWhich) {
+ case 'visible':
+ var top = document.documentElement.scrollTop || document.body.scrollTop;
+ var bot = top + document.documentElement.clientHeight;
+
+ for (var i = 0; i < results.length; i++) {
+ next = results[i];
+ var etop = next.offsetTop;
+ var ebot = etop + next.clientHeight;
+
+ if ((ebot <= bot) && (etop > top)) {
+ break;
+ }
+ }
+ break;
+ case 'down':
+ next = current.nextElementSibling;
+ if (next === null) {
+ next = results[0];
+ }
+ break;
+ case 'up':
+ next = current.previousElementSibling;
+ if (next === null) {
+ next = results[results.length - 1];
+ }
+ break;
+ case 'bottom':
+ next = results[results.length - 1];
+ break;
+ case 'top':
+ /* falls through */
+ default:
+ next = results[0];
+ }
+ }
+
+ if (next) {
+ current.removeAttribute('data-vim-selected');
+ next.setAttribute('data-vim-selected', 'true');
+ var link = next.querySelector('h3 a') || next.querySelector('a');
+ if (link !== null) {
+ link.focus();
+ }
+ if (!noScroll) {
+ scrollPageToSelected();
+ }
+ }
+ };
+ }
+
+ function reloadPage() {
+ document.location.reload(true);
+ }
+
+ function removeFocus() {
+ if (document.activeElement) {
+ document.activeElement.blur();
+ }
+ }
+
+ function pageButtonClick(num) {
+ return function() {
+ var buttons = $('div#pagination button[type="submit"]');
+ if (buttons.length !== 2) {
+ console.log('page navigation with this theme is not supported');
+ return;
+ }
+ if (num >= 0 && num < buttons.length) {
+ buttons[num].click();
+ } else {
+ console.log('pageButtonClick(): invalid argument');
+ }
+ };
+ }
+
+ function scrollPageToSelected() {
+ var sel = document.querySelector('.result[data-vim-selected]');
+ if (sel === null) {
+ return;
+ }
+ var wtop = document.documentElement.scrollTop || document.body.scrollTop,
+ wheight = document.documentElement.clientHeight,
+ etop = sel.offsetTop,
+ ebot = etop + sel.clientHeight,
+ offset = 120;
+ // first element ?
+ if ((sel.previousElementSibling === null) && (ebot < wheight)) {
+ // set to the top of page if the first element
+ // is fully included in the viewport
+ window.scroll(window.scrollX, 0);
+ return;
+ }
+ if (wtop > (etop - offset)) {
+ window.scroll(window.scrollX, etop - offset);
+ } else {
+ var wbot = wtop + wheight;
+ if (wbot < (ebot + offset)) {
+ window.scroll(window.scrollX, ebot - wheight + offset);
+ }
+ }
+ }
+
+ function scrollPage(amount) {
+ return function() {
+ window.scrollBy(0, amount);
+ highlightResult('visible')();
+ };
+ }
+
+ function scrollPageTo(position, nav) {
+ return function() {
+ window.scrollTo(0, position);
+ highlightResult(nav)();
+ };
+ }
+
+ function searchInputFocus() {
+ window.scrollTo(0, 0);
+ document.querySelector('#q').focus();
+ }
+
+ function openResult(newTab) {
+ return function() {
+ var link = document.querySelector('.result[data-vim-selected] h3 a');
+ if (link !== null) {
+ var url = link.getAttribute('href');
+ if (newTab) {
+ window.open(url);
+ } else {
+ window.location.href = url;
+ }
+ }
+ };
+ }
+
+ function toggleHelp() {
+ var helpPanel = document.querySelector('#vim-hotkeys-help');
+ if (helpPanel.length) {
+ helpPanel.classList.toggle('hidden');
+ return;
+ }
+
+ var categories = {};
+
+ for (var k in vimKeys) {
+ var key = vimKeys[k];
+ categories[key.cat] = categories[key.cat] || [];
+ categories[key.cat].push(key);
+ }
+
+ var sorted = Object.keys(categories).sort(function(a, b) {
+ return categories[b].length - categories[a].length;
+ });
+
+ if (sorted.length === 0) {
+ return;
+ }
+
+ var html = '
';
+ html += '
';
+
+ html += '
';
+ html += '
';
+ html += '
How to navigate searx with Vim-like hotkeys
';
+ html += '
'; // col-sm-12
+ html += '
'; // row
+
+ for (var i = 0; i < sorted.length; i++) {
+ var cat = categories[sorted[i]];
+
+ var lastCategory = i === (sorted.length - 1);
+ var first = i % 2 === 0;
+
+ if (first) {
+ html += '
';
+ }
+ html += '
';
+
+ html += '
';
+ html += '
' + cat[0].cat + '
';
+ html += '
';
+ html += '
';
+
+ for (var cj in cat) {
+ html += '
' + cat[cj].key + ' ' + cat[cj].des + '
';
+ }
+
+ html += '
';
+ html += '
'; // panel-body
+ html += '
'; // panel
+ html += '
'; // col-sm-*
+
+ if (!first || lastCategory) {
+ html += '
'; // row
+ }
+ }
+
+ html += '
'; // container-fluid
+ html += '
'; // vim-hotkeys-help
+
+ $('body').append(html);
+ }
+});
+;/**
+* searx is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Affero General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* searx is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU Affero General Public License for more details.
+*
+* You should have received a copy of the GNU Affero General Public License
+* along with searx. If not, see < http://www.gnu.org/licenses/ >.
+*
+* (C) 2014 by Thomas Pointhuber,
+* (C) 2017 by Alexandre Flament,
+*/
+(function (w, d, searx) {
+ 'use strict';
+
+ searx.ready(function () {
+ searx.on('.searx_overpass_request', 'click', function(event) {
+ // no more request
+ this.classList.remove("searx_overpass_request");
+
+ //
+ var overpass_url = "https://overpass-api.de/api/interpreter?data=";
+ var query_start = overpass_url + "[out:json][timeout:25];(";
+ var query_end = ");out meta;";
+
+ var osm_id = this.dataset.osmId;
+ var osm_type = this.dataset.osmType;
+ var result_table = d.querySelector("#" + this.dataset.resultTable);
+ var result_table_loadicon = d.querySelector("#" + this.dataset.resultTableLoadicon);
+
+ // tags which can be ignored
+ var osm_ignore_tags = [ "addr:city", "addr:country", "addr:housenumber", "addr:postcode", "addr:street" ];
+
+ if(osm_id && osm_type && result_table) {
+ var query = null;
+ switch(osm_type) {
+ case 'node':
+ query = query_start + "node(" + osm_id + ");" + query_end;
+ break;
+ case 'way':
+ query = query_start + "way(" + osm_id + ");" + query_end;
+ break;
+ case 'relation':
+ query = query_start + "relation(" + osm_id + ");" + query_end;
+ break;
+ default:
+ break;
+ }
+ if(query) {
+ // console.log(query);
+ searx.http( 'GET', query ).then(function(html, contentType) {
+ html = JSON.parse(html);
+ if(html && html.elements && html.elements[0]) {
+ var element = html.elements[0];
+ var newHtml = "";
+ for (var row in element.tags) {
+ if(element.tags.name === null || osm_ignore_tags.indexOf(row) == -1) {
+ newHtml += "
",c&&!u||(i+="")}i+="",i+="",$("body").append(i)}}},des:"toggle help window",cat:"Other"}};searx.on(document,"keyup",function(t){if(r.hasOwnProperty(t.keyCode)&&!t.ctrlKey&&!t.altKey&&!t.shiftKey&&!t.metaKey){var e=t.target.tagName.toLowerCase();27===t.keyCode?"input"!==e&&"select"!==e&&"textarea"!==e||r[t.keyCode].fun():t.target!==document.body&&"a"!==e&&"button"!==e||r[t.keyCode].fun()}})}),function(t,e,n){"use strict";n.ready(function(){n.on(".searx_overpass_request","click",function(t){this.classList.remove("searx_overpass_request");var o="https://overpass-api.de/api/interpreter?data=[out:json][timeout:25];(",a=this.dataset.osmId,i=this.dataset.osmType,r=e.querySelector("#"+this.dataset.resultTable),s=e.querySelector("#"+this.dataset.resultTableLoadicon),l=["addr:city","addr:country","addr:housenumber","addr:postcode","addr:street"];if(a&&i&&r){var u=null;switch(i){case"node":u=o+"node("+a+"););out meta;";break;case"way":u=o+"way("+a+"););out meta;";break;case"relation":u=o+"relation("+a+"););out meta;"}u&&n.http("GET",u).then(function(t,e){if((t=JSON.parse(t))&&t.elements&&t.elements[0]){var n=t.elements[0],o="";for(var a in n.tags)if(null===n.tags.name||-1==l.indexOf(a)){switch(o+="
'; // row
+
+ for (var i = 0; i < sorted.length; i++) {
+ var cat = categories[sorted[i]];
+
+ var lastCategory = i === (sorted.length - 1);
+ var first = i % 2 === 0;
+
+ if (first) {
+ html += '
';
+ }
+ html += '
';
+
+ html += '
';
+ html += '
' + cat[0].cat + '
';
+ html += '
';
+ html += '
';
+
+ for (var cj in cat) {
+ html += '
' + cat[cj].key + ' ' + cat[cj].des + '
';
+ }
+
+ html += '
';
+ html += '
'; // panel-body
+ html += '
'; // panel
+ html += '
'; // col-sm-*
+
+ if (!first || lastCategory) {
+ html += '
'; // row
+ }
+ }
+
+ html += '
'; // container-fluid
+ html += '
'; // vim-hotkeys-help
+
+ $('body').append(html);
+ }
+});
diff --git a/searx/static/themes/simple/js/searx_src/searx_mapresult.js b/searx/static/themes/simple/js/searx_src/searx_mapresult.js
new file mode 100644
index 000000000..823f64815
--- /dev/null
+++ b/searx/static/themes/simple/js/searx_src/searx_mapresult.js
@@ -0,0 +1,175 @@
+/**
+* searx is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Affero General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* searx is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU Affero General Public License for more details.
+*
+* You should have received a copy of the GNU Affero General Public License
+* along with searx. If not, see < http://www.gnu.org/licenses/ >.
+*
+* (C) 2014 by Thomas Pointhuber,
+* (C) 2017 by Alexandre Flament,
+*/
+(function (w, d, searx) {
+ 'use strict';
+
+ searx.ready(function () {
+ searx.on('.searx_overpass_request', 'click', function(event) {
+ // no more request
+ this.classList.remove("searx_overpass_request");
+
+ //
+ var overpass_url = "https://overpass-api.de/api/interpreter?data=";
+ var query_start = overpass_url + "[out:json][timeout:25];(";
+ var query_end = ");out meta;";
+
+ var osm_id = this.dataset.osmId;
+ var osm_type = this.dataset.osmType;
+ var result_table = d.querySelector("#" + this.dataset.resultTable);
+ var result_table_loadicon = d.querySelector("#" + this.dataset.resultTableLoadicon);
+
+ // tags which can be ignored
+ var osm_ignore_tags = [ "addr:city", "addr:country", "addr:housenumber", "addr:postcode", "addr:street" ];
+
+ if(osm_id && osm_type && result_table) {
+ var query = null;
+ switch(osm_type) {
+ case 'node':
+ query = query_start + "node(" + osm_id + ");" + query_end;
+ break;
+ case 'way':
+ query = query_start + "way(" + osm_id + ");" + query_end;
+ break;
+ case 'relation':
+ query = query_start + "relation(" + osm_id + ");" + query_end;
+ break;
+ default:
+ break;
+ }
+ if(query) {
+ // console.log(query);
+ searx.http( 'GET', query ).then(function(html, contentType) {
+ html = JSON.parse(html);
+ if(html && html.elements && html.elements[0]) {
+ var element = html.elements[0];
+ var newHtml = "";
+ for (var row in element.tags) {
+ if(element.tags.name === null || osm_ignore_tags.indexOf(row) == -1) {
+ newHtml += "
+{%- endmacro %}
+
+{% macro result_open_link(url, classes='') -%}
+