diff --git a/src/controls/Editor.qml b/src/controls/Editor.qml
index 592d3ff..f89d309 100644
--- a/src/controls/Editor.qml
+++ b/src/controls/Editor.qml
@@ -1,343 +1,344 @@
 import QtQuick 2.10
 import QtQuick.Controls 2.10
 import QtQuick.Layouts 1.3
 import org.kde.mauikit 1.0 as Maui
 import org.kde.kirigami 2.7 as Kirigami
 import "private"
 
 Maui.Page
 {
 	id: control
 	Kirigami.Theme.inherit: false
 	Kirigami.Theme.colorSet: Kirigami.Theme.View
 	
 	property bool showLineCount : true
 	property bool showSyntaxHighlighting: true
 	
 	property alias body : body
 	property alias document : document
 	property alias scrollView: _scrollView
 	
 	property alias text: body.text
 	property alias uppercase: document.uppercase
 	property alias underline: document.underline
 	property alias italic: document.italic
 	property alias bold: document.bold
 	property alias canRedo: body.canRedo
 	
 	property alias fileUrl : document.fileUrl
 	
     focus: true
 
     Maui.DocumentHandler
 	{
 		id: document
 		document: body.textDocument
 		cursorPosition: body.cursorPosition
 		selectionStart: body.selectionStart
 		selectionEnd: body.selectionEnd
 // 		textColor: control.Kirigami.Theme.textColor
 		backgroundColor: control.Kirigami.Theme.backgroundColor
 // 		
 		onError:
 		{
 			body.text = message
 			body.visible = true
 		}
 	}
 	
 	Row
 	{
 		z: _scrollView.z +1
 		visible: showLineCount
 		anchors
 		{
 			right: parent.right
 			bottom: parent.bottom
 			margins: Maui.Style.space.big
 		}
 		
 		width: implicitWidth
 		height: implicitHeight
 		
 		Label
 		{
 			text: body.length + " / " + body.lineCount
 			color: control.Kirigami.Theme.textColor
 			opacity: 0.5
 			font.pointSize: Maui.Style.fontSizes.medium
 		}		
 	}
 	
 	Menu
 	{
 		id: documentMenu
 		z: 999
 		
 		MenuItem
 		{
 			text: qsTr("Copy")
 			onTriggered: body.copy()
 			enabled: body.selectedText.length
 		}
 		
 		MenuItem
 		{
 			text: qsTr("Cut")
 			onTriggered: body.cut()	
 			enabled: !body.readOnly && body.selectedText.length					
 		}
 		
 		MenuItem
 		{
 			text: qsTr("Paste")
 			onTriggered: body.paste()
 			enabled: !body.readOnly					
 		}
 		
 		MenuItem
 		{
 			text: qsTr("Select all")
 			onTriggered: body.selectAll()
 		}
 		
 		MenuItem
 		{
 			text: qsTr("Web search")
 			onTriggered: Qt.openUrlExternally("https://www.google.com/search?q="+body.selectedText)
 			enabled: body.selectedText.length			
 		}
 	}	
 	
 	
 	headBar.visible: !body.readOnly
 	
 	headBar.leftContent: [				
 	
 	ToolButton
 	{
 		icon.name: "edit-undo"
 		enabled: body.canUndo
 		onClicked: body.undo()
 		opacity: enabled ? 1 : 0.5			
 	},
 	
 	ToolButton
 	{
 		icon.name: "edit-redo"
 		enabled: body.canRedo
 		onClicked: body.redo()
 		opacity: enabled ? 1 : 0.5
 	},
 	
 	Row
 	{
 		id: _editingActions
 		visible: (document.isRich || body.textFormat === Text.RichText) && !body.readOnly
 		
 		ToolButton
 		{
 			icon.name: "format-text-bold"
 			focusPolicy: Qt.TabFocus
 			icon.color: checked ? control.Kirigami.Theme.highlightColor : control.Kirigami.Theme.textColor
 			checkable: false
 			checked: document.bold
 			onClicked: document.bold = !document.bold
 		}
 		
 		ToolButton
 		{
 			icon.name: "format-text-italic"
 			icon.color: checked ? control.Kirigami.Theme.highlightColor : control.Kirigami.Theme.textColor
 			focusPolicy: Qt.TabFocus
 			checkable: false
 			checked: document.italic
 			onClicked: document.italic = !document.italic
 		}
 		
 		ToolButton
 		{
 			icon.name: "format-text-underline"
 			icon.color: checked ? control.Kirigami.Theme.highlightColor : control.Kirigami.Theme.textColor
 			focusPolicy: Qt.TabFocus
 			checkable: true
 			checked: document.underline
 			onClicked: document.underline = !document.underline
 		}
 		
 		ToolButton
 		{
 			icon.name: "format-text-uppercase"
 			icon.color: checked ? control.Kirigami.Theme.highlightColor : control.Kirigami.Theme.textColor
 			focusPolicy: Qt.TabFocus
 			checkable: true
 			checked: document.uppercase
 			onClicked: document.uppercase = !document.uppercase
 		}					
 	}
 	]		
 	
 	// 	footBar.visible: !body.readOnly
 	footBar.rightContent: [
 	ToolButton
 	{
 		icon.name: "zoom-in"
 		onClicked: zoomIn()
 	},
 	
 	ToolButton
 	{
 		icon.name: "zoom-out"
 		onClicked: zoomOut()
 	},
 	
 	ComboBox
 	{
 		visible: control.showSyntaxHighlighting
 		model: document.getLanguageNameList()
 		currentIndex: -1
 		onCurrentIndexChanged: document.formatName = model[currentIndex]		
 	}	
 	]
 	
 	ColumnLayout
 	{
 		anchors.fill: parent
 		spacing: 0
 		
 		Repeater
 		{
 			model: document.alerts
 			
 			Maui.ToolBar
 			{
 				id: _alertBar
 				property var alert : model.alert
 				readonly property int index_ : index
 				Layout.fillWidth: true
 				
 				Kirigami.Theme.backgroundColor: 
 				{
 					switch(alert.level)
 					{
 						case 0: return Kirigami.Theme.positiveTextColor
 						case 1: return Kirigami.Theme.neutralTextColor
 						case 2: return Kirigami.Theme.negativeTextColor							
 					}
 				}
 				
 				leftContent: Maui.ListItemTemplate
 				{
 					Layout.fillWidth: true
 					Layout.fillHeight: true
 					
 					label1.text: alert.title
 					label2.text: alert.body
 				}
 				
 				rightContent: Repeater
 				{
 					model: alert.actionLabels()
 					
 					Button
 					{
 						id: _alertAction						
 						property int index_ : index						
 						text: modelData
 						onClicked: alert.triggerAction(_alertAction.index_, _alertBar.index_)
 						
 						Kirigami.Theme.backgroundColor: Qt.rgba(Kirigami.Theme.backgroundColor.r, Kirigami.Theme.backgroundColor.g, Kirigami.Theme.backgroundColor.b, 0.2)
 						Kirigami.Theme.textColor: Kirigami.Theme.textColor
 					}
 				}
 			}
 		}
 		
         PinchArea
         {
             id: pinchArea
             Layout.fillWidth: true
             Layout.fillHeight: true
 // 			enabled: Maui.Handy.hasTouch
             property real minScale: 1.0
             property real maxScale: 3.0
 
 // 			anchors.fill: parent
             pinch.minimumScale: minScale
             pinch.maximumScale: maxScale
             pinch.dragAxis: Pinch.XandYAxis
 			
             onPinchFinished:
             {
                 console.log("pinch.scale", pinch.scale)
 				
                 if(pinch.scale > 1.5)
                     control.zoomIn()
                     else control.zoomOut()
             }
 			
             MouseArea{ anchors.fill: parent}
 			
             Kirigami.ScrollablePage
 			{
 				id: _scrollView
                 focus: true
                 anchors.fill: parent
+                flickable.interactive: true
 
 				contentWidth: control.width
 				contentHeight: body.height
 				
 				leftPadding: 0
 				rightPadding: 0
 				topPadding: 0
 				bottomPadding: 0				
 				
 				TextArea
 				{
 					id: body
 					implicitWidth: control.width
 					text: document.text
 // 					font.family: "Source Code Pro"
 					placeholderText: qsTr("Body")
                     selectByKeyboard: !Kirigami.Settings.isMobile
                     selectByMouse : !Kirigami.Settings.isMobile
 					textFormat: TextEdit.AutoText			
 // 					font.pointSize: Maui.Style.fontSizes.large
 					wrapMode: TextEdit.WrapAnywhere
 					
 					activeFocusOnPress: true
 					activeFocusOnTab: true
 					persistentSelection: true
 					
 					background: Rectangle
 					{
 						color: document.backgroundColor
 						implicitWidth: body.implicitWidth
 						implicitHeight: control.height
 					}				
 					
 					onPressed:
 					{
 						if(!Kirigami.Settings.isMobile && event.button === Qt.RightButton)
 							documentMenu.popup()
 					}
 				}
 			}
 			// 		ScrollBar.vertical.height: _scrollView.height - body.topPadding
 			// 		ScrollBar.vertical.y: body.topPadding
         }
 	}
 	
 	
 	
 	function zoomIn()
 	{
 		body.font.pointSize = body.font.pointSize *1.5
 	}
 	
 	function zoomOut()
 	{
 		body.font.pointSize = body.font.pointSize / 1.5
 		
 	}
 }
diff --git a/src/controls/FileBrowser.qml b/src/controls/FileBrowser.qml
index 756ce79..182abf4 100644
--- a/src/controls/FileBrowser.qml
+++ b/src/controls/FileBrowser.qml
@@ -1,1184 +1,1184 @@
 /*
  *   Copyright 2018 Camilo Higuita <milo.h@aol.com>
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU Library General Public License as
  *   published by the Free Software Foundation; either version 2, or
  *   (at your option) any later version.
  *
  *   This program 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 General Public License for more details
  *
  *   You should have received a copy of the GNU Library General Public
  *   License along with this program; if not, write to the
  *   Free Software Foundation, Inc.,
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 import QtQuick 2.10
 import QtQuick.Controls 2.10
 import QtQuick.Layouts 1.3
 import QtQml.Models 2.3
 import QtQml 2.1
 
 import org.kde.kirigami 2.8 as Kirigami
 import org.kde.mauikit 1.0 as Maui
 import org.kde.mauikit 1.1 as MauiLab
 
 import "private"
 
 Maui.Page
 {
 	id: control
 	
 	property url currentPath
     onCurrentPathChanged:
     {
         if(control.browserView)
             control.browserView.path = control.currentPath
     }
 	
 	property int viewType : Maui.FMList.LIST_VIEW
 	onViewTypeChanged: browserView.viewType = control.viewType
 	
 	property int thumbnailsSize : Maui.Style.iconSizes.large * 1.7
 	
 	property var indexHistory : []
 	
 	property bool isCopy : false
 	property bool isCut : false
 	
 	property bool group : false
 	
 	//group properties from the browser since the browser views are loaded async and
 	//their properties can not be accesed inmediately, so they are stored here and then when completed they are set
 	property BrowserSettings settings : BrowserSettings {}
 	
 	property alias selectionBar : selectionBarLoader.item
 	property alias browserView : _browserList.currentItem
 	readonly property Maui.FMList currentFMList : browserView.currentFMList
 	
 	property alias previewer : previewer
 	property alias menu : browserMenu.contentData
 	property alias itemMenu: itemMenu
 	property alias dialog : dialogLoader.item
 	
 	signal itemClicked(int index)
 	signal itemDoubleClicked(int index)
 	signal itemRightClicked(int index)
 	signal itemLeftEmblemClicked(int index)
 	signal itemRightEmblemClicked(int index)
 	signal rightClicked()
 	signal newBookmark(var paths)
 	
 	Kirigami.Theme.colorSet: Kirigami.Theme.View
 	Kirigami.Theme.inherit: false
 	
 	onGoBackTriggered: control.goBack()
 	onGoForwardTriggered: control.goNext()
 	
 	focus: true
 	
 	footBar.visible: false ||  String(control.currentPath).startsWith("trash:/")
 	footBar.leftContent: Label
 	{
 		Layout.fillWidth: true
 		text: control.currentFMList.count + " " + qsTr("items")
 	}
 	
 	footBar.rightContent: [
 	
 	ToolButton
 	{
 		icon.name: "zoom-in"
 		onClicked: zoomIn()
 	},
 	
 	ToolButton
 	{
 		icon.name: "zoom-out"
 		onClicked: zoomOut()
 	},
 	
 	ToolButton
 	{
 		visible: String(control.currentPath).startsWith("trash:/")
 		icon.name: "trash-empty"	
 		text: qsTr("Empty trash")
 		onClicked: Maui.FM.emptyTrash()
 	}
 	]
 	
 	headBar.position: Kirigami.Settings.isMobile ? ToolBar.Footer : ToolBar.Header
 	
 	headBar.rightContent:[
 	
 	ToolButton
 	{
 		icon.name: "item-select"
 		checkable: true
 		checked: settings.selectionMode
 		onClicked: settings.selectionMode = !settings.selectionMode
 	},
 	
 	Maui.ToolButtonMenu
 	{
 		icon.name: "view-sort"  
 		
 		MenuItem
 		{
 			text: qsTr("Folders first")
 			checked: control.currentFMList.foldersFirst
 			checkable: true
 			onTriggered: control.currentFMList.foldersFirst = !control.currentFMList.foldersFirst
 		}
 		
 		MenuSeparator {}
 		
 		MenuItem
 		{
 			text: qsTr("Type")
 			checked: control.currentFMList.sortBy === Maui.FMList.MIME
 			checkable: true
 			onTriggered: control.currentFMList.sortBy = Maui.FMList.MIME
 			autoExclusive: true
 		}
 		
 		MenuItem
 		{
 			text: qsTr("Date")
 			checked: control.currentFMList.sortBy === Maui.FMList.DATE
 			checkable: true
 			onTriggered: control.currentFMList.sortBy = Maui.FMList.DATE
 			autoExclusive: true
 		}
 		
 		MenuItem
 		{
 			text: qsTr("Modified")
 			checkable: true
 			checked: control.currentFMList.sortBy === Maui.FMList.MODIFIED
 			onTriggered: control.currentFMList.sortBy = Maui.FMList.MODIFIED
 			autoExclusive: true
 		}
 		
 		MenuItem
 		{
 			text: qsTr("Size")
 			checkable: true
 			checked: control.currentFMList.sortBy === Maui.FMList.SIZE
 			onTriggered: control.currentFMList.sortBy = Maui.FMList.SIZE
 			autoExclusive: true
 		}
 		
 		MenuItem
 		{
 			text: qsTr("Name")
 			checkable: true
 			checked: control.currentFMList.sortBy === Maui.FMList.LABEL
 			onTriggered: control.currentFMList.sortBy = Maui.FMList.LABEL
 			autoExclusive: true
 		}
 		
 		MenuSeparator{}
 		
 		MenuItem
 		{
 			id: groupAction
 			text: qsTr("Group")
 			checkable: true
 			checked: control.group
 			onTriggered:
 			{
 				control.group = !control.group
 				if(control.group)
 					control.groupBy()
 					else
 						browserView.currentView.section.property = ""
 			}
 		}
 		
 	},
 	
 	ToolButton
 	{
 		id: _optionsButton
 		icon.name: "overflow-menu"
 		enabled: currentFMList.pathType !== Maui.FMList.TAGS_PATH && currentFMList.pathType !== Maui.FMList.TRASH_PATH && currentFMList.pathType !== Maui.FMList.APPS_PATH
 		onClicked:
 		{
 			if(browserMenu.visible)
 				browserMenu.close()
 				else
 					browserMenu.show(_optionsButton, 0, height)
 		}
 		checked: browserMenu.visible
 		checkable: false
 	}
 	]
 	
 	headBar.leftContent: [
 	ToolButton
 	{
 		icon.name: "go-previous"
 		onClicked: control.goBack()
 	},
 	
 	ToolButton
 	{
 		icon.name: "go-next"
 		onClicked: control.goNext()
 	},
 	
 	Maui.ToolActions
 	{
 		direction: Qt.Vertical
 		
 		currentAction: switch(browserView.viewType)
 		{
 			case Maui.FMList.ICON_VIEW: return actions[0]
 			case Maui.FMList.LIST_VIEW: return actions[1]
 			case Maui.FMList.MILLERS_VIEW: return actions[2]
 		}
 		
 		Action
 		{
 			icon.name: "view-list-icons"
 			text: qsTr("Grid")
 			onTriggered: control.viewType = Maui.FMList.ICON_VIEW
 			checked: browserView.viewType === Maui.FMList.ICON_VIEW
 			icon.width: Maui.Style.iconSizes.medium
 		}
 		
 		Action
 		{
 			icon.name: "view-list-details"
 			text: qsTr("List")
 			onTriggered: control.viewType = Maui.FMList.LIST_VIEW
 			icon.width: Maui.Style.iconSizes.medium
 			checkable: true
 			checked: browserView.viewType === Maui.FMList.LIST_VIEW
 		}
 		
 		Action
 		{
 			icon.name: "view-file-columns"
 			text: qsTr("Columns")
 			onTriggered: control.viewType = Maui.FMList.MILLERS_VIEW
 			icon.width: Maui.Style.iconSizes.medium
 			checkable: true
 			checked: browserView.viewType === Maui.FMList.MILLERS_VIEW
 		}
 	}
 	]
 	
 	Loader { id: dialogLoader }
 	
 	Component
 	{
 		id: removeDialogComponent
 		
 		Maui.Dialog
 		{
 			property var urls: []
 			
 			title: qsTr(String("Removing %1 files").arg(urls.length.toString()))
 			message: Maui.Handy.isAndroid ?  qsTr("This action will completely remove your files from your system. This action can not be undone.") : qsTr("You can move the file to the Trash or Delete it completely from your system. Which one you preffer?")
 			rejectButton.text: qsTr("Delete")
 			acceptButton.text: qsTr("Trash")
 			acceptButton.visible: !Kirigami.Settings.isMobile
 			page.padding: Maui.Style.space.huge
 			
 			onRejected:
 			{
 				if(control.selectionBar && control.selectionBar.visible)
 				{
 					control.selectionBar.animate()
 					control.clearSelection()
 				}
 				
 				for(var i in urls)
 					Maui.FM.removeFile(urls[i])
 					
 					close()
 			}
 			
 			onAccepted:
 			{
 				if(control.selectionBar && control.selectionBar.visible)
 				{
 					control.selectionBar.animate()
 					control.clearSelection()
 				}
 				
 				for(var i in urls)
 					Maui.FM.moveToTrash(urls[i])
 					close()
 			}
 		}
 	}
 	
 	Component
 	{
 		id: newFolderDialogComponent
 		
 		Maui.NewDialog
 		{
 			title: qsTr("New folder")
 			message: qsTr("Create a new folder with a custom name")
 			acceptButton.text: qsTr("Create")
 			onFinished: control.currentFMList.createDir(text)
 			rejectButton.visible: false
 			textEntry.placeholderText: qsTr("Folder name...")
 		}
 	}
 	
 	Component
 	{
 		id: newFileDialogComponent
 		
 		Maui.NewDialog
 		{
 			title: qsTr("New file")
 			message: qsTr("Create a new file with a custom name and extension")
 			acceptButton.text: qsTr("Create")
 			onFinished: Maui.FM.createFile(control.currentPath, text)
 			rejectButton.visible: false
 			textEntry.placeholderText: qsTr("File name...")
 		}
 	}
 	
 	Component
 	{
 		id: renameDialogComponent
 		Maui.NewDialog
 		{
 			title: qsTr("Rename file")
 			message: qsTr("Rename a file or folder to a new custom name")
 			textEntry.text: itemMenu.item.label
 			textEntry.placeholderText: qsTr("New name...")
 			onFinished: Maui.FM.rename(itemMenu.item.path, textEntry.text)
 			onRejected: close()
 			acceptText: qsTr("Rename")
 			rejectText: qsTr("Cancel")
 		}
 	}
 	
 	Component
 	{
 		id: shareDialogComponent
 		MauiLab.ShareDialog {}
 	}
 	
 	Component
 	{
 		id: tagsDialogComponent
 		Maui.TagsDialog
 		{
 			taglist.strict: false
 			onTagsReady:
 			{
 				composerList.updateToUrls(tags)
 				if(control.previewer.visible)
 					control.previewer.tagBar.list.refresh()
 			}
 		}
 	}
 	
 	Component
 	{
 		id: _configDialogComponent
 		
 		Maui.Dialog
 		{
 			maxHeight: _configLayout.implicitHeight * 1.5
 			maxWidth: 300
 			defaultButtons: false
 				
 				Kirigami.FormLayout
 				{
 					id: _configLayout
 					width: parent.width
 					anchors.centerIn: parent
 					
 					Kirigami.Separator
 					{
 						Kirigami.FormData.label: qsTr("Navigation")
 						Kirigami.FormData.isSection: true
 					}
 					
 					Switch
 					{
 						icon.name: "image-preview"
 						checkable: true
 						checked: settings.showThumbnails
 						Kirigami.FormData.label: qsTr("Thumbnails")
 						onToggled: settings.showThumbnails = !settings.showThumbnails
 					}
 					
 					Switch
 					{
 						Kirigami.FormData.label: qsTr("Hidden files")
 						checkable: true
 						checked: control.currentFMList.hidden
 						onToggled: control.currentFMList.hidden = !control.currentFMList.hidden
 					}
 					
 					Kirigami.Separator
 					{
 						Kirigami.FormData.label: qsTr("Others")
 						Kirigami.FormData.isSection: true
 					}
 					
 					Switch
 					{
 						Kirigami.FormData.label: qsTr("Status bar")
 						checkable: true
 						checked: control.footBar.visible
 						onToggled: control.footBar.visible = !control.footBar.visible					
 					}
 				}
 		}
 	}
 	
 	Maui.FilePreviewer
 	{
 		id: previewer
 		onShareButtonClicked: control.shareFiles([url])
 	}
 	
 	BrowserMenu { id: browserMenu }
 	
 	FileMenu
 	{
 		id: itemMenu
 		width: Maui.Style.unit *200
 		onBookmarkClicked: control.bookmarkFolder([item.path])
 		onCopyClicked:
 		{
 			if(item)
 				control.copy([item.path])
 		}
 		
 		onCutClicked:
 		{
 			if(item)
 				control.cut([item.path])
 		}
 		
 		onTagsClicked:
 		{
 			if(item)
 			{
 				dialogLoader.sourceComponent = tagsDialogComponent
 				dialog.composerList.urls = [item.path]
 				dialog.open()
 			}
 		}
 		
 		onRenameClicked:
 		{
 			dialogLoader.sourceComponent = renameDialogComponent
 			dialog.open()
 		}
 		
 		onRemoveClicked:
 		{
 			control.remove([item.path])
 		}
 		
 		onShareClicked: control.shareFiles([item.path])
 	}
 	
 	Connections
 	{
 		target: browserView.currentView
 		
 		onKeyPress:
 		{
 			const index = browserView.currentView.currentIndex
 			const item = control.currentFMList.get(index)
 			
 			// Shortcuts for refreshing
 			if((event.key == Qt.Key_F5))
 			{
 				control.currentFMList.refresh()
 			}
 			
 			// Shortcuts for selecting file
 			if((event.key == Qt.Key_A) && (event.modifiers & Qt.ControlModifier))
 			{
 				control.selectAll()
 			}
 			
 			if(event.key == Qt.Key_S)
 			{
 				if(control.selectionBar && control.selectionBar.contains(item.path))
 				{
 					control.selectionBar.removeAtUri(item.path)
 				}else
 				{
 					control.addToSelection(item)
 				}
 			}
 			
 			if((event.key == Qt.Key_Left || event.key == Qt.Key_Right || event.key == Qt.Key_Down || event.key == Qt.Key_Up) && (event.modifiers & Qt.ControlModifier) && (event.modifiers & Qt.ShiftModifier))
 			{
 				if(control.selectionBar && control.selectionBar.contains(item.path))
 				{
 					control.selectionBar.removeAtUri(item.path)
 				}else
 				{
 					control.addToSelection(item)
 				}
 			}
 			
 			// Shortcut for pasting an item
 			if((event.key == Qt.Key_V) && (event.modifiers & Qt.ControlModifier))
 			{
 				control.paste(Maui.Handy.getClipboard().urls)
 			}
 			
 			// Shortcut for cutting an item
 			if((event.key == Qt.Key_X) && (event.modifiers & Qt.ControlModifier))
 			{
 				var urls = []
 				if(control.selectionBar)
 				{
 					urls = control.selectionBar.uris
 				}
 				else
 				{
 					urls = [item.path]
 				}
 				control.cut(urls)
 			}
 			
 			// Shortcut for copying an item
 			if((event.key == Qt.Key_C) && (event.modifiers & Qt.ControlModifier))
 			{
 				var urls = []
 				if(control.selectionBar)
 				{
 					urls = control.selectionBar.uris
 				}
 				else
 				{
 					urls = [item.path]
 				}
 				control.copy(urls)
 			}
 			
 			// Shortcut for removing an item
 			if(event.key == Qt.Key_Delete)
 			{
 				var urls = []
 				if(control.selectionBar)
 				{
 					urls = control.selectionBar.uris
 				}
 				else
 				{
 					urls = [item.path]
 				}
 				control.remove(urls)
 			}
 			
 			// Shortcut for opening new tab
 			if((event.key == Qt.Key_T) && (event.modifiers & Qt.ControlModifier))
 			{
 				console.log("OPEN TAB")
 				control.openTab(currentPath)
 			}
 			
 			// Shortcut for closing tab
 			if((event.key == Qt.Key_W) && (event.modifiers & Qt.ControlModifier))
 			{
 				if(tabsBar.count > 1)
 					control.closeTab(tabsBar.currentIndex)
 			}
 			
 			// Shortcut for opening files in new tab , previewing or launching
 			if((event.key == Qt.Key_Return) && (event.modifiers & Qt.ControlModifier))
 			{
 				if(item.isdir == "true")
 					control.openTab(item.path)
 					
 			}else if((event.key == Qt.Key_Return) && (event.modifiers & Qt.AltModifier))
 			{
 				control.previewer.show(control.currentFMList.get(index).path)
 			}else if(event.key == Qt.Key_Return)
 			{
 				indexHistory.push(index)
 				control.itemClicked(index)
 			}
 			
 			// Shortcut for going back in browsing history
 			if(event.key == Qt.Key_Backspace || event.key == Qt.Key_Back)
 			{
 				if(control.selectionBar)
 					control.clearSelection()
 					else
 						control.goBack()
 			}
 			
 			// Shortcut for clearing selection
 			if(event.key == Qt.Key_Escape)
 			{
 				if(control.selectionBar)
 					control.clearSelection()
 			}
 		}
 		
 		onItemClicked:
 		{
 			browserView.currentView.currentIndex = index
 			indexHistory.push(index)
 			control.itemClicked(index)
 		}
 		
 		onItemDoubleClicked:
 		{
 			browserView.currentView.currentIndex = index
 			indexHistory.push(index)
 			control.itemDoubleClicked(index)
 		}
 		
 		onItemRightClicked:
 		{
 			if(control.currentFMList.pathType !== Maui.FMList.TRASH_PATH && control.currentFMList.pathType !== Maui.FMList.REMOTE_PATH)
 				itemMenu.show(index)
 				control.itemRightClicked(index)
 		}
 		
 		onLeftEmblemClicked:
 		{
 			const item = control.currentFMList.get(index)
 			
 			if(control.selectionBar && control.selectionBar.contains(item.path))
 			{
 				control.selectionBar.removeAtUri(item.path)
 			}else
 			{
 				control.addToSelection(item)
 			}
 			control.itemLeftEmblemClicked(index)
 		}
 		
 		onRightEmblemClicked:
 		{
 			Maui.Handy.isAndroid ? Maui.Android.shareDialog([control.currentFMList.get(index).path]) : shareDialog.show([control.currentFMList.get(index).path])
 			control.itemRightEmblemClicked(index)
 		}
 		
 		onAreaClicked:
 		{
 			if(!Kirigami.Settings.isMobile && mouse.button === Qt.RightButton)
 				browserMenu.show(control)
 				else return
 					
 					control.rightClicked()
 		}
 		
 		onAreaRightClicked: browserMenu.show(control)
 		
 		//        onWarning:
 		//        {
 		//            notify("dialog-information", "An error happened", message)
 		//        }
 		
 		//        onProgress:
 		//        {
 		//            if(percent === 100)
 		//                _progressBar.value = 0
 		//            else
 		//                _progressBar.value = percent/100
 		//        }
 	}
 	
 	Component
 	{
 		id: selectionBarComponent
 		
 		MauiLab.SelectionBar
 		{
 			id: _selectionBar			
 			singleSelection: settings.singleSelection
 			
 			onCountChanged:
 			{
 				if(_selectionBar.count < 1)
 					control.clearSelection()
 			}
 
             onExitClicked: control.clearSelection()
 			
 			listDelegate: ListBrowserDelegate
 			{
 				Kirigami.Theme.inherit: true
 				width: parent.width
 				height: Maui.Style.iconSizes.big + Maui.Style.space.big
 				label1.text: model.label
 				label2.text: model.path
 				showEmblem: true
 				showThumbnails: true
 				leftEmblem: "list-remove"
 				folderSize: Maui.Style.iconSizes.big
 				onLeftEmblemClicked: _selectionBar.removeAtIndex(index)
-                keepEmblemOverlay: Kirigami.Settings.isMobile
+                keepEmblemOverlay: Maui.Handy.isTouch
 				background: null
 				
 				onClicked: control.previewer.show(model.path)
 				
 				onPressAndHold: removeAtIndex(index)      
 			}
 			
 			Action
 			{
 				text: qsTr("Open")
 				icon.name: "document-open"
 				onTriggered:
 				{
 					if(control.selectionBar)
 					{
 						for(var i in uris)
 							openFile(uris[i])
 					}
 				}
 			}
 			
 			Action
 			{
 				text: qsTr("Copy")
 				icon.name: "edit-copy"
 				onTriggered: if(control.selectionBar)
 				{
 					control.selectionBar.animate()
 					control.copy(uris)
 				}
 			}
 			
 			Action
 			{
 				text: qsTr("Cut")
 				icon.name: "edit-cut"
 				onTriggered: if(control.selectionBar)
 				{
 					control.selectionBar.animate()
 					control.cut(uris)
 				}					
 			}				
 			
 			Action
 			{
 				text: qsTr("Tags")
 				icon.name: "tag"
 				onTriggered: if(control.selectionBar)
 				{
 					dialogLoader.sourceComponent = tagsDialogComponent
 					dialog.composerList.urls = uris
 					dialog.open()
 				}
 			}
 			
 			Action
 			{
 				text: qsTr("Share")
 				icon.name: "document-share"
 				onTriggered:
 				{
 					control.shareFiles(uris)
 				}
 			}              
 			
 			
 			Action
 			{
 				text: qsTr("Remove")
 				icon.name: "edit-delete"
 				Kirigami.Theme.textColor: Kirigami.Theme.negativeTextColor
 				
 				onTriggered:
 				{
 					control.remove(uris)
 				}
 			}
 			
 		}
 	}
 	
 	ObjectModel { id: tabsObjectModel }
 	
 	ColumnLayout
 	{
 		id: _layout
 		anchors.fill: parent
 		spacing: 0
 		
 		Maui.TabBar
 		{
 			id: tabsBar
 			visible: _browserList.count > 1
 			Layout.fillWidth: true
 			Layout.preferredHeight: tabsBar.implicitHeight
 			position: TabBar.Header
 			currentIndex : _browserList.currentIndex
 			
 			ListModel { id: tabsListModel }
 			
 			Keys.onPressed:
 			{
 				if(event.key == Qt.Key_Return)
 				{
 					_browserList.currentIndex = currentIndex
 					control.currentPath =  tabsObjectModel.get(currentIndex).path
 				}
 			}
 			
 			Repeater
 			{
 				id: _repeater
 				model: tabsListModel
 				
 				Maui.TabButton
 				{
 					id: _tabButton
 					implicitHeight: tabsBar.implicitHeight
 					implicitWidth: Math.max(control.width / _repeater.count, 120)
 					checked: index === _browserList.currentIndex
 					
 					text: tabsObjectModel.get(index).currentFMList.pathName
 					
 					onClicked:
 					{
 						_browserList.currentIndex = index
 						control.currentPath =  tabsObjectModel.get(index).path
 					}
 					
 					onCloseClicked: control.closeTab(index)
 				}
 			}
 		}
 		
 		ListView
 		{
 			id: _browserList
 			Layout.margins: 0
 			Layout.fillWidth: true
 			Layout.fillHeight: true
 			clip: true
 			focus: true
 			orientation: ListView.Horizontal
 			model: tabsObjectModel
 			snapMode: ListView.SnapOneItem
 			spacing: 0
-			interactive: Kirigami.Settings.isMobile && tabsObjectModel.count > 1
+			interactive: Maui.Handy.isTouch && tabsObjectModel.count > 1
 			highlightFollowsCurrentItem: true
 			highlightMoveDuration: 0
 			onMovementEnded: _browserList.currentIndex = indexAt(contentX, contentY)
 			
 			// 			DropArea
 			// 			{
 			// 				id: _dropArea
 			// 				anchors.fill: parent
 			// 				z: parent.z -2
 			// 				onDropped:
 			// 				{
 			// 					const urls = drop.urls
 			// 					for(var i in urls)
 			// 					{
 			// 						const item = Maui.FM.getFileInfo(urls[i])
 			// 						if(item.isdir == "true")
 			// 						{
 			// 							control.openTab(urls[i])
 			// 						}
 			// 					}
 			// 				}
 			// 			}
 		}
 		
 		Loader
 		{
 			id: selectionBarLoader
 			Layout.alignment: Qt.AlignCenter
             Layout.margins: Maui.Style.space.medium
 			Layout.preferredHeight: control.selectionBar && control.selectionBar.visible ? control.selectionBar.barHeight: 0
 			Layout.maximumWidth: 500
 			Layout.minimumWidth: 100
 			Layout.fillWidth: true
 			Layout.bottomMargin: control.selectionBar && control.selectionBar.visible ? Maui.Style.contentMargins*2 : 0
 		}
 		
 		ProgressBar
 		{
 			id: _progressBar
 			Layout.fillWidth: true
 			Layout.alignment: Qt.AlignBottom
 			Layout.preferredHeight: visible ? Maui.Style.iconSizes.medium : 0
 			visible: value > 0
 		}
 	}
 	
 	Component.onCompleted:
 	{
 		openTab(Maui.FM.homePath())
 		browserView.currentView.forceActiveFocus()
 	}
 	
 	onThumbnailsSizeChanged:
 	{
 		if(settings.trackChanges && settings.saveDirProps)
 			Maui.FM.setDirConf(currentPath+"/.directory", "MAUIFM", "IconSize", thumbnailsSize)
 			else
 				Maui.FM.saveSettings("IconSize", thumbnailsSize, "SETTINGS")
 				
 				if(control.viewType === Maui.FMList.ICON_VIEW)
 					browserView.currentView.adaptGrid()
 	}
 	
 	function closeTab(index)
 	{
 		tabsObjectModel.remove(index)
 		tabsListModel.remove(index)
 	}
 	
 	function openTab(path)
 	{
 		if(path)
 		{    
 			const component = Qt.createComponent("private/BrowserView.qml");
 			if (component.status === Component.Ready)
 			{
                 const object = component.createObject(tabsObjectModel, {'path': path});
 				tabsObjectModel.append(object)
                 
                 tabsListModel.append({"path": path})
                 _browserList.currentIndex = tabsObjectModel.count - 1
                 
                 browserView.viewType = control.viewType 
                 control.currentPath = path
 			}		
 		}
 	}
 	
 	function shareFiles(urls)
 	{
 		if(urls.length <= 0)
 			return;
 		
 		dialogLoader.sourceComponent= shareDialogComponent
 		dialog.urls = urls
 		dialog.open()
 	}
 	
 	function openItem(index)
 	{
 		const item = control.currentFMList.get(index)
 		const path = item.path
 		
 		switch(control.currentFMList.pathType)
 		{
 			case Maui.FMList.CLOUD_PATH:
 				if(item.isdir === "true")
 				{
 					control.openFolder(path)
 				}
 				else
 				{
 					Maui.FM.openCloudItem(item)
 				}
 				break;
 			default:
 				if(settings.selectionMode && item.isdir == "false")
 				{
 					if(control.selectionBar && control.selectionBar.contains(item.path))
 					{
 						control.selectionBar.removeAtPath(item.path)
 					}else
 					{
 						control.addToSelection(item)
 					}
 				}
 				else
 				{
 					if(item.isdir == "true")
 					{
 						control.openFolder(path)
 					}
 					else
 					{
 						if (Kirigami.Settings.isMobile)
 						{
 							control.previewer.show(path)
 						}
 						else
 						{
 							control.openFile(path)
 						}
 					}
 				}
 		}
 	}
 	
 	function openFile(path)
 	{
 		Maui.FM.openUrl(path)
 	}
 	
 	function openFolder(path)
 	{
 		if(!String(path).length)
 			return;
 		
 		control.currentPath = path
 	}
 	
 	function goBack()
 	{
 		openFolder(control.currentFMList.previousPath)
 		//        browserView.currentView.currentIndex = indexHistory.pop()
 	}
 	
 	function goNext()
 	{
 		openFolder(control.currentFMList.posteriorPath)
 	}
 	
 	function goUp()
 	{
 		openFolder(control.currentFMList.parentPath)
 	}
 	
 	function refresh()
 	{
 		const pos = browserView.currentView.contentY
 		browserView.currentView.contentY = pos
 	}
 	
 	function addToSelection(item)
 	{
 		if(item.path.startsWith("tags://") || item.path.startsWith("applications://") )
 			return
 			
 			if(!control.selectionBar)
 				selectionBarLoader.sourceComponent = selectionBarComponent
 				
 				control.selectionBar.append(item.path, item)
 	}
 	
 	function clearSelection()
 	{
 		if(control.selectionBar)
 		{
 			control.selectionBar.clear()
 			selectionBarLoader.sourceComponent = null
 			settings.selectionMode = false
 		}
 	}
 	
 	function copy(urls)
 	{
 		Maui.Handy.copyToClipboard({"urls": urls})
 		control.isCut = false
 		control.isCopy = true
 	}
 	
 	function cut(urls)
 	{
 		Maui.Handy.copyToClipboard({"urls": urls})
 		control.isCut = true
 		control.isCopy = false
 	}
 	
 	function paste()
 	{
 		const urls = Maui.Handy.getClipboard().urls
 		
 		if(!urls)
 			return
 			
 			if(control.isCut)
 			{
 				control.currentFMList.cutInto(urls)
 				control.clearSelection()
 			}else
 			{
 				control.currentFMList.copyInto(urls)
 			}
 	}
 	
 	function remove(urls)
 	{
 		dialogLoader.sourceComponent= removeDialogComponent
 		dialog.urls = urls
 		dialog.open()
 	}
 	
 	function selectAll() //TODO for now dont select more than 100 items so things dont freeze or break
 	{
 		for(var i = 0; i < Math.min(control.currentFMList.count, 100); i++)
 			addToSelection(control.currentFMList.get(i))
 	}
 	
 	function bookmarkFolder(paths) //multiple paths
 	{
 		control.newBookmark(paths)
 	}
 	
 	function zoomIn()
 	{
 		control.thumbnailsSize = control.thumbnailsSize + 8
 	}
 	
 	function zoomOut()
 	{
 		const newSize = control.thumbnailsSize - 8
 		
 		if(newSize >= Maui.Style.iconSizes.small)
 			control.thumbnailsSize = newSize
 	}
 	
 	function groupBy()
 	{
 		var prop = ""
 		var criteria = ViewSection.FullString
 		
 		switch(control.currentFMList.sortBy)
 		{
 			case Maui.FMList.LABEL:
 				prop = "label"
 				criteria = ViewSection.FirstCharacter
 				break;
 			case Maui.FMList.MIME:
 				prop = "mime"
 				break;
 			case Maui.FMList.SIZE:
 				prop = "size"
 				break;
 			case Maui.FMList.DATE:
 				prop = "date"
 				break;
 			case Maui.FMList.MODIFIED:
 				prop = "modified"
 				break;
 		}
 		
 		if(!prop)
 		{
 			control.browserView.currentView.section.property = ""
 			return
 		}
 		
 		control.browserView.viewType = Maui.FMList.LIST_VIEW
 		control.browserView.currentView.section.property = prop
 		control.browserView.currentView.section.criteria = criteria
 	}
 	
 	function openConfigDialog()
 	{
 		dialogLoader.sourceComponent = _configDialogComponent
 		control.dialog.open()
 	}
 }
diff --git a/src/controls/private/FileMenu.qml b/src/controls/private/FileMenu.qml
index d919298..9ba6ec8 100644
--- a/src/controls/private/FileMenu.qml
+++ b/src/controls/private/FileMenu.qml
@@ -1,194 +1,194 @@
 import QtQuick 2.9
 import QtQuick.Controls 2.3
 import QtQuick.Layouts 1.3
 import org.kde.mauikit 1.0 as Maui
 import org.kde.kirigami 2.2 as Kirigami
 
 Menu
 {
 	id: control
 	implicitWidth: colorBar.implicitWidth + Maui.Style.space.big
 	
     property var item : ({})
 	property int index : -1
 	property bool isDir : false
 	property bool isExec : false
 	property bool isFav: false
 	
 	signal bookmarkClicked(var item)
 	signal removeClicked(var item)
 	signal shareClicked(var item)
 	signal copyClicked(var item)
 	signal cutClicked(var item)
 	signal renameClicked(var item)
 	signal tagsClicked(var item)	
 	
 	MenuItem
 	{
 		visible: !control.isExec
 		text: qsTr("Select")
 		icon.name: "edit-select"		
 		onTriggered:
 		{			
 			addToSelection(currentFMList.get(index))
-            if(Kirigami.Settings.isMobile)
+            if(Maui.Handy.isTouch)
                 settings.selectionMode = true
 		}
 	}
 	
 	MenuItem
 	{
 		text: control.isFav ? qsTr("UnFav") : qsTr("Fav")
 		icon.name: "love"		
 		onTriggered:
 		{			
 			if(currentFMList.favItem(item.path))
 				control.isFav = !control.isFav
 		}
 	}
 	MenuSeparator{}
 	
 	MenuItem
 	{
 		visible: control.isDir
 		icon.name: "tab-new"
 		text: qsTr("Open in tab")
 		onTriggered: openTab(item.path)
 	}
 	
     MenuSeparator{visible: isDir}
 	MenuItem
 	{
 		visible: !control.isExec
         text: qsTr("Copy")
 		icon.name: "edit-copy"
 		onTriggered:
 		{
 			copyClicked(control.item)
 			close()
 		}
 	}
 	
 	MenuItem
 	{
 		visible: !control.isExec
         text: qsTr("Cut")
 		icon.name: "edit-cut"
 		onTriggered:
 		{
 			cutClicked(control.item)
 			close()
 		}
 	}
 	
 	MenuItem
 	{
 		visible: !control.isExec
         text: qsTr("Rename")
 		icon.name: "edit-rename"
 		onTriggered:
 		{
 			renameClicked(control.item)
 			close()
 		}
 	}	
 	
 	MenuSeparator{}
 	
 	MenuItem
 	{
 		visible: !control.isExec && control.isDir
 		text: qsTr("Bookmark")
 		icon.name: "bookmark-new"
 		onTriggered:
 		{
 			bookmarkClicked(control.item)
 			close()
 		}
 	}
 	
 	MenuItem
 	{
 		visible: !control.isExec
         text: qsTr("Tags")
 		icon.name: "tag"
 		onTriggered:
 		{
 			tagsClicked(control.item)
 			close()
 		}
 	}
 	
 	MenuItem
 	{
 		visible: !control.isExec		
         text: qsTr("Share")
 		icon.name: "document-share"
 		onTriggered:
 		{
 			shareClicked(control.item)
 			close()
 		}
 	}
 		
 	MenuItem
 	{
 		visible: !control.isExec
         text: qsTr("Preview")
 		icon.name: "view-preview"
 		onTriggered:
 		{
 			previewer.show(control.item.path)
 			close()
 		}
 	}
 	
 	MenuSeparator{}
 	
 	MenuItem
 	{
         text: qsTr("Remove")
 		Kirigami.Theme.textColor: Kirigami.Theme.negativeTextColor
 		icon.name: "edit-delete"
 		onTriggered:
 		{
 			removeClicked(control.item)
 			close()
 		}
 	}
 	
 	MenuSeparator{ visible: colorBar.visible }	
 	
 	MenuItem
 	{		
 		width: parent.width
 		height: visible ? Maui.Style.iconSizes.medium + Maui.Style.space.big : 0
 		visible: control.isDir
 		Maui.ColorsBar
         {
 			id: colorBar
 			
 			visible: parent.visible
             anchors.centerIn: parent
             size: Maui.Style.iconSizes.medium
 			onColorPicked: currentFMList.setDirIcon(index, color)
 		}
 	}	
 	
 	function show(index)
 	{		
 		control.item = currentFMList.get(index)
 
 		if(item.path.startsWith("tags://") || item.path.startsWith("applications://") )
 			return
 		
 		if(item)
 		{
 			control.index = index
 			control.isDir = item.isdir == true || item.isdir == "true"
 			control.isExec = item.executable == true || item.executable == "true"
 			control.isFav = currentFMList.itemIsFav(item.path)
 			popup()
 		}
 	}
 }