From 1416c1cbc5246a24bff35528baec5f1bf20b13aa Mon Sep 17 00:00:00 2001
From: Crustack <crustackk@gmail.com>
Date: Thu, 5 Mar 2026 12:08:06 +0100
Subject: [PATCH 1/2] Add manual sort for notes via drag and drop

---
 .../10.json                                   | 179 ++++++
 .../philkes/notallyx/data/NotallyDatabase.kt  |  18 +-
 .../philkes/notallyx/data/dao/BaseNoteDao.kt  |  35 +-
 .../philkes/notallyx/data/model/BaseNote.kt   |  11 +-
 .../notallyx/data/model/ModelExtensions.kt    |  10 +
 .../notallyx/presentation/UiExtensions.kt     |   4 +-
 .../activity/main/ActionModeBinding.kt        | 323 +++++++++++
 .../activity/main/MainActivity.kt             | 534 ++++++++----------
 .../activity/main/fragment/NotallyFragment.kt | 152 ++++-
 .../settings/PreferenceBindingExtensions.kt   |  13 +-
 .../fragment/settings/SettingsFragment.kt     |   9 -
 .../activity/note/RecordAudioActivity.kt      |  33 +-
 .../presentation/view/main/BaseNoteAdapter.kt | 245 +++++++-
 .../view/main/sorting/BaseNoteManualSort.kt   |  19 +
 .../presentation/viewmodel/BaseNoteModel.kt   |  14 +
 .../presentation/viewmodel/NotallyModel.kt    |   1 +
 .../viewmodel/preference/NotesSorting.kt      |   9 +-
 .../com/philkes/notallyx/utils/ActionMode.kt  |   6 +
 .../notallyx/utils/backup/ImportExtensions.kt |   7 +
 app/src/main/res/drawable/sort.xml            |  11 +
 app/src/main/res/layout/activity_main.xml     |   1 +
 app/src/main/res/layout/dialog_notes_sort.xml |   1 +
 app/src/main/res/layout/fragment_settings.xml |   4 -
 app/src/main/res/values/strings.xml           |   2 +
 app/src/main/res/values/themes.xml            |   1 -
 25 files changed, 1261 insertions(+), 381 deletions(-)
 create mode 100644 app/schemas/com.philkes.notallyx.data.NotallyDatabase/10.json
 create mode 100644 app/src/main/java/com/philkes/notallyx/presentation/activity/main/ActionModeBinding.kt
 create mode 100644 app/src/main/java/com/philkes/notallyx/presentation/view/main/sorting/BaseNoteManualSort.kt
 create mode 100644 app/src/main/res/drawable/sort.xml

diff --git a/app/schemas/com.philkes.notallyx.data.NotallyDatabase/10.json b/app/schemas/com.philkes.notallyx.data.NotallyDatabase/10.json
new file mode 100644
index 00000000..5dfd5500
--- /dev/null
+++ b/app/schemas/com.philkes.notallyx.data.NotallyDatabase/10.json
@@ -0,0 +1,179 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 10,
+    "identityHash": "6cdd7edd0a8e7bc0b6ba1a706986c6a2",
+    "entities": [
+      {
+        "tableName": "BaseNote",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `type` TEXT NOT NULL, `folder` TEXT NOT NULL, `color` TEXT NOT NULL, `title` TEXT NOT NULL, `pinned` INTEGER NOT NULL, `timestamp` INTEGER NOT NULL, `modifiedTimestamp` INTEGER NOT NULL, `labels` TEXT NOT NULL, `body` TEXT NOT NULL, `spans` TEXT NOT NULL, `items` TEXT NOT NULL, `images` TEXT NOT NULL, `files` TEXT NOT NULL, `audios` TEXT NOT NULL, `reminders` TEXT NOT NULL, `viewMode` TEXT NOT NULL, `sortIdx` INTEGER)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "folder",
+            "columnName": "folder",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "color",
+            "columnName": "color",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "title",
+            "columnName": "title",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "pinned",
+            "columnName": "pinned",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "timestamp",
+            "columnName": "timestamp",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "modifiedTimestamp",
+            "columnName": "modifiedTimestamp",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "labels",
+            "columnName": "labels",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "body",
+            "columnName": "body",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "spans",
+            "columnName": "spans",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "items",
+            "columnName": "items",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "images",
+            "columnName": "images",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "files",
+            "columnName": "files",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "audios",
+            "columnName": "audios",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "reminders",
+            "columnName": "reminders",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "viewMode",
+            "columnName": "viewMode",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "sortIdx",
+            "columnName": "sortIdx",
+            "affinity": "INTEGER",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_BaseNote_id_folder_pinned_timestamp_labels",
+            "unique": false,
+            "columnNames": [
+              "id",
+              "folder",
+              "pinned",
+              "timestamp",
+              "labels"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_BaseNote_id_folder_pinned_timestamp_labels` ON `${TABLE_NAME}` (`id`, `folder`, `pinned`, `timestamp`, `labels`)"
+          },
+          {
+            "name": "index_BaseNote_sortIdx",
+            "unique": false,
+            "columnNames": [
+              "sortIdx"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_BaseNote_sortIdx` ON `${TABLE_NAME}` (`sortIdx`)"
+          }
+        ],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "Label",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`value` TEXT NOT NULL, PRIMARY KEY(`value`))",
+        "fields": [
+          {
+            "fieldPath": "value",
+            "columnName": "value",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "value"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '6cdd7edd0a8e7bc0b6ba1a706986c6a2')"
+    ]
+  }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/philkes/notallyx/data/NotallyDatabase.kt b/app/src/main/java/com/philkes/notallyx/data/NotallyDatabase.kt
index 5e40774e..2e1c3a35 100644
--- a/app/src/main/java/com/philkes/notallyx/data/NotallyDatabase.kt
+++ b/app/src/main/java/com/philkes/notallyx/data/NotallyDatabase.kt
@@ -33,7 +33,7 @@ import java.io.File
 import net.zetetic.database.sqlcipher.SupportOpenHelperFactory
 
 @TypeConverters(Converters::class)
-@Database(entities = [BaseNote::class, Label::class], version = 9)
+@Database(entities = [BaseNote::class, Label::class], version = 10)
 abstract class NotallyDatabase : RoomDatabase() {
 
     abstract fun getLabelDao(): LabelDao
@@ -161,6 +161,7 @@ abstract class NotallyDatabase : RoomDatabase() {
                         Migration7,
                         Migration8,
                         Migration9,
+                        Migration10,
                     )
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                 System.loadLibrary("sqlcipher")
@@ -300,5 +301,20 @@ abstract class NotallyDatabase : RoomDatabase() {
                 )
             }
         }
+
+        object Migration10 : Migration(9, 10) {
+            override fun migrate(db: SupportSQLiteDatabase) {
+                db.execSQL("ALTER TABLE `BaseNote` ADD COLUMN `sortIdx` INTEGER")
+                db.execSQL(
+                    "CREATE INDEX IF NOT EXISTS `index_BaseNote_sortIdx` ON `BaseNote` (`sortIdx`)"
+                )
+                db.execSQL(
+                    "DROP INDEX IF EXISTS `index_BaseNote_id_folder_pinned_timestamp_labels_sortIdx` "
+                )
+                db.execSQL(
+                    "CREATE INDEX IF NOT EXISTS `index_BaseNote_id_folder_pinned_timestamp_labels` ON `BaseNote` (`id`, `folder`, `pinned`, `timestamp`, `labels`)"
+                )
+            }
+        }
     }
 }
diff --git a/app/src/main/java/com/philkes/notallyx/data/dao/BaseNoteDao.kt b/app/src/main/java/com/philkes/notallyx/data/dao/BaseNoteDao.kt
index cae40fff..050735ca 100644
--- a/app/src/main/java/com/philkes/notallyx/data/dao/BaseNoteDao.kt
+++ b/app/src/main/java/com/philkes/notallyx/data/dao/BaseNoteDao.kt
@@ -7,6 +7,7 @@ import androidx.room.Insert
 import androidx.room.OnConflictStrategy
 import androidx.room.Query
 import androidx.room.RawQuery
+import androidx.room.Transaction
 import androidx.room.Update
 import androidx.sqlite.db.SupportSQLiteQuery
 import com.philkes.notallyx.R
@@ -57,6 +58,10 @@ interface BaseNoteDao {
     }
 
     suspend fun insertSafe(context: ContextWrapper, baseNote: BaseNote): Long {
+        if (baseNote.sortIdx == null) {
+            val maxSortIdx = getMaxSortIdx() ?: 0
+            baseNote.sortIdx = maxSortIdx + 1
+        }
         val (truncated, note) = baseNote.truncated()
         if (truncated) {
             context.log(
@@ -75,17 +80,19 @@ interface BaseNoteDao {
     }
 
     suspend fun insertSafe(context: ContextWrapper, baseNotes: List<BaseNote>): List<Long> {
+        val maxSortIdx = getMaxSortIdx() ?: 0
         val truncatedNotes = mutableListOf<BaseNote>()
         var truncatedCharacterSize = 0
-        val notes =
-            baseNotes.map { baseNote ->
-                val (truncated, note) = baseNote.truncated()
-                if (truncated) {
-                    truncatedCharacterSize += baseNote.body.length
-                    truncatedNotes.add(note)
-                }
-                note
+        baseNotes.forEachIndexed { index, baseNote ->
+            if (baseNote.sortIdx == null) {
+                baseNote.sortIdx = (maxSortIdx + 1 + index)
+            }
+            val (truncated, note) = baseNote.truncated()
+            if (truncated) {
+                truncatedCharacterSize += baseNote.body.length
+                truncatedNotes.add(note)
             }
+        }
         if (truncatedNotes.isNotEmpty()) {
             context.log(
                 TAG,
@@ -99,7 +106,7 @@ interface BaseNoteDao {
                 )
             )
         }
-        return insert(notes)
+        return insert(baseNotes)
     }
 
     @Insert suspend fun insert(baseNotes: List<BaseNote>): List<Long>
@@ -244,6 +251,16 @@ interface BaseNoteDao {
      *
      * In this case, an exception will be thrown. It is the caller's responsibility to handle it.
      */
+    @Query("UPDATE BaseNote SET sortIdx = :sortIdx WHERE id = :id")
+    fun updateSortIdx(id: Long, sortIdx: Int)
+
+    @Transaction
+    fun updateSortIndices(idToIdx: Map<Long, Int>) {
+        idToIdx.forEach { (id, idx) -> updateSortIdx(id, idx) }
+    }
+
+    @Query("SELECT MAX(sortIdx) FROM BaseNote") fun getMaxSortIdx(): Int?
+
     suspend fun updateChecked(id: Long, position: Int, checked: Boolean) {
         val items =
             requireNotNull(get(id), { "updateChecked: Note with id '$id' does not exist" }).items
diff --git a/app/src/main/java/com/philkes/notallyx/data/model/BaseNote.kt b/app/src/main/java/com/philkes/notallyx/data/model/BaseNote.kt
index 7563796b..f737557e 100644
--- a/app/src/main/java/com/philkes/notallyx/data/model/BaseNote.kt
+++ b/app/src/main/java/com/philkes/notallyx/data/model/BaseNote.kt
@@ -7,7 +7,13 @@ import androidx.room.PrimaryKey
 /** Format: `#RRGGBB` or `#AARRGGBB` or [BaseNote.COLOR_DEFAULT] */
 typealias ColorString = String
 
-@Entity(indices = [Index(value = ["id", "folder", "pinned", "timestamp", "labels"])])
+@Entity(
+    indices =
+        [
+            Index(value = ["id", "folder", "pinned", "timestamp", "labels"]),
+            Index(value = ["sortIdx"]),
+        ]
+)
 data class BaseNote(
     @PrimaryKey(autoGenerate = true) val id: Long,
     val type: Type,
@@ -26,6 +32,7 @@ data class BaseNote(
     val audios: List<Audio>,
     val reminders: List<Reminder>,
     val viewMode: NoteViewMode,
+    var sortIdx: Int? = null,
 ) : Item {
 
     companion object {
@@ -55,6 +62,7 @@ data class BaseNote(
         if (audios != other.audios) return false
         if (reminders != other.reminders) return false
         if (viewMode != other.viewMode) return false
+        if (sortIdx != other.sortIdx) return false
 
         return true
     }
@@ -76,6 +84,7 @@ data class BaseNote(
         result = 31 * result + audios.hashCode()
         result = 31 * result + reminders.hashCode()
         result = 31 * result + viewMode.hashCode()
+        result = 31 * result + (sortIdx ?: 0)
         return result
     }
 }
diff --git a/app/src/main/java/com/philkes/notallyx/data/model/ModelExtensions.kt b/app/src/main/java/com/philkes/notallyx/data/model/ModelExtensions.kt
index a6aae87e..3765b1d8 100644
--- a/app/src/main/java/com/philkes/notallyx/data/model/ModelExtensions.kt
+++ b/app/src/main/java/com/philkes/notallyx/data/model/ModelExtensions.kt
@@ -134,6 +134,7 @@ fun String.toBaseNote(): BaseNote {
     val audios = Converters.jsonToAudios(jsonObject.getArrayOrEmpty("audios"))
     val reminders = Converters.jsonToReminders(jsonObject.getArrayOrEmpty("reminders"))
     val viewMode = NoteViewMode.valueOfOrDefault(jsonObject.getStringOrDefault("viewMode", ""))
+    val sortIdx = jsonObject.getIntOrNull("sortIdx")
     return BaseNote(
         id,
         type,
@@ -152,6 +153,7 @@ fun String.toBaseNote(): BaseNote {
         audios,
         reminders,
         viewMode,
+        sortIdx,
     )
 }
 
@@ -163,6 +165,14 @@ private fun JSONObject.getStringOrDefault(key: String, defaultValue: String): St
     }
 }
 
+private fun JSONObject.getIntOrNull(key: String): Int? {
+    return try {
+        getInt(key)
+    } catch (exception: JSONException) {
+        null
+    }
+}
+
 private fun JSONObject.getArrayOrEmpty(key: String): JSONArray {
     return try {
         getJSONArray(key)
diff --git a/app/src/main/java/com/philkes/notallyx/presentation/UiExtensions.kt b/app/src/main/java/com/philkes/notallyx/presentation/UiExtensions.kt
index 4e0f1a3a..258224cc 100644
--- a/app/src/main/java/com/philkes/notallyx/presentation/UiExtensions.kt
+++ b/app/src/main/java/com/philkes/notallyx/presentation/UiExtensions.kt
@@ -235,7 +235,7 @@ fun Menu.add(
     showAsAction: Int = MenuItem.SHOW_AS_ACTION_IF_ROOM,
     groupId: Int = Menu.NONE,
     itemId: Int = Menu.NONE,
-    order: Int = Menu.NONE,
+    order: Int = Menu.FIRST,
     onClick: (item: MenuItem) -> Unit,
 ): MenuItem {
     val menuItem =
@@ -399,7 +399,7 @@ fun Folder.movedToResId(): Int {
 }
 
 fun RadioGroup.checkedTag(): Any {
-    return this.findViewById<RadioButton?>(this.checkedRadioButtonId).tag
+    return this.findViewById<RadioButton>(this.checkedRadioButtonId).tag
 }
 
 fun Context.showKeyboard(view: View) {
diff --git a/app/src/main/java/com/philkes/notallyx/presentation/activity/main/ActionModeBinding.kt b/app/src/main/java/com/philkes/notallyx/presentation/activity/main/ActionModeBinding.kt
new file mode 100644
index 00000000..b75c55e1
--- /dev/null
+++ b/app/src/main/java/com/philkes/notallyx/presentation/activity/main/ActionModeBinding.kt
@@ -0,0 +1,323 @@
+package com.philkes.notallyx.presentation.activity.main
+
+import android.transition.TransitionManager
+import android.view.Menu
+import android.view.MenuItem
+import android.view.View
+import androidx.activity.OnBackPressedCallback
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.Observer
+import androidx.lifecycle.lifecycleScope
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import com.google.android.material.snackbar.Snackbar
+import com.google.android.material.transition.platform.MaterialFade
+import com.philkes.notallyx.R
+import com.philkes.notallyx.data.NotallyDatabase
+import com.philkes.notallyx.data.model.Folder
+import com.philkes.notallyx.databinding.ActivityMainBinding
+import com.philkes.notallyx.presentation.activity.main.fragment.NotallyFragment
+import com.philkes.notallyx.presentation.add
+import com.philkes.notallyx.presentation.getQuantityString
+import com.philkes.notallyx.presentation.setCancelButton
+import com.philkes.notallyx.presentation.view.misc.NotNullLiveData
+import com.philkes.notallyx.presentation.viewmodel.BaseNoteModel
+import com.philkes.notallyx.presentation.viewmodel.ExportMimeType
+import com.philkes.notallyx.presentation.viewmodel.preference.NotesSortPreference
+import com.philkes.notallyx.presentation.viewmodel.preference.isManualSort
+import com.philkes.notallyx.utils.shareNote
+import com.philkes.notallyx.utils.showColorSelectDialog
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+/** Helper class to manage the action mode menu */
+class ActionModeBinding(
+    private val baseModel: BaseNoteModel,
+    private val binding: ActivityMainBinding,
+    private val context: MainActivity,
+    notesSorting: NotesSortPreference,
+    private val currentFragment: () -> NotallyFragment?,
+    private val onExportNotes: (mimeType: ExportMimeType) -> Unit,
+) {
+
+    private val actionModeToolbar = binding.ActionMode
+
+    private val actionModeCancelCallback =
+        object : OnBackPressedCallback(true) {
+            override fun handleOnBackPressed() {
+                baseModel.actionMode.close(true)
+            }
+        }
+
+    init {
+        actionModeToolbar.setNavigationOnClickListener { baseModel.actionMode.close(true) }
+        val transition =
+            MaterialFade().apply {
+                secondaryAnimatorProvider = null
+                excludeTarget(binding.NavHostFragment, true)
+                excludeChildren(binding.NavHostFragment, true)
+                excludeTarget(binding.TakeNote, true)
+                excludeTarget(binding.MakeList, true)
+                excludeTarget(binding.NavigationView, true)
+            }
+        baseModel.actionMode.enabled.observe(context) { enabled ->
+            TransitionManager.beginDelayedTransition(binding.RelativeLayout, transition)
+            binding.apply {
+                if (enabled) {
+                    Toolbar.visibility = View.GONE
+                    actionModeToolbar.visibility = View.VISIBLE
+                } else {
+                    Toolbar.visibility = View.VISIBLE
+                    actionModeToolbar.visibility = View.GONE
+                }
+            }
+            actionModeCancelCallback.isEnabled = enabled
+        }
+        baseModel.actionMode.loading.observe(context) { loading ->
+            binding.ActionMode.menu.setGroupEnabled(Menu.NONE, !loading)
+        }
+
+        notesSorting.observe(context) { refreshActionModeMenu(baseModel.folder.value) }
+        baseModel.folder.observe(context, Observer { value -> refreshActionModeMenu(value) })
+    }
+
+    fun close() {
+        baseModel.actionMode.close(true)
+    }
+
+    val enabled
+        get() = baseModel.actionMode.enabled
+
+    fun enabled() = enabled.value
+
+    var loading
+        get() = baseModel.actionMode.loading.value
+        set(value) {
+            baseModel.actionMode.loading.value = value
+        }
+
+    val mode
+        get() = baseModel.actionMode
+
+    fun refreshActionModeMenu(value: Folder) {
+        val menu = actionModeToolbar.menu
+        menu.clear()
+        baseModel.actionMode.count.removeObservers(context)
+
+        menu.add(
+            R.string.select_all,
+            R.drawable.select_all,
+            showAsAction = MenuItem.SHOW_AS_ACTION_ALWAYS,
+        ) {
+            context.getCurrentFragmentNotes?.invoke()?.let { baseModel.actionMode.add(it) }
+        }
+        when (value) {
+            Folder.NOTES -> {
+                val pinned = menu.addPinned(MenuItem.SHOW_AS_ACTION_ALWAYS)
+                addManualSortActions()
+                menu.add(R.string.duplicate, R.drawable.content_copy) {
+                    baseModel.duplicateSelectedBaseNotes()
+                }
+                menu.add(R.string.archive, R.drawable.archive) {
+                    context.moveNotes(Folder.ARCHIVED)
+                }
+                menu.addChangeColor()
+                val share = menu.addShare()
+                menu.addExportMenu()
+                baseModel.actionMode.count.observeCountAndPinned(context, share, pinned)
+            }
+
+            Folder.ARCHIVED -> {
+                addManualSortActions()
+                menu.add(
+                    R.string.unarchive,
+                    R.drawable.unarchive,
+                    MenuItem.SHOW_AS_ACTION_ALWAYS,
+                    itemId = Menu.NONE,
+                ) {
+                    context.moveNotes(Folder.NOTES)
+                }
+                menu.add(R.string.duplicate, R.drawable.content_copy) {
+                    baseModel.duplicateSelectedBaseNotes()
+                }
+                menu.addExportMenu(MenuItem.SHOW_AS_ACTION_ALWAYS)
+                val pinned = menu.addPinned()
+                menu.addChangeColor()
+                val share = menu.addShare()
+                baseModel.actionMode.count.observeCountAndPinned(context, share, pinned)
+            }
+
+            Folder.DELETED -> {
+                addManualSortActions()
+                menu.add(
+                    R.string.restore,
+                    R.drawable.restore,
+                    MenuItem.SHOW_AS_ACTION_ALWAYS,
+                    itemId = Menu.NONE,
+                ) {
+                    context.moveNotes(Folder.NOTES)
+                }
+                menu.add(
+                    R.string.delete_forever,
+                    R.drawable.delete,
+                    MenuItem.SHOW_AS_ACTION_ALWAYS,
+                    itemId = Menu.NONE,
+                ) {
+                    deleteForever()
+                }
+                menu.addExportMenu()
+                menu.addChangeColor()
+                val share = menu.add(R.string.share, R.drawable.share) { share() }
+                baseModel.actionMode.count.observeCount(context, share)
+            }
+        }
+    }
+
+    private fun addManualSortActions() {
+        if (baseModel.preferences.notesSorting.value.isManualSort) {
+            actionModeToolbar.menu.apply {
+                removeItem(11)
+                removeItem(12)
+                add(
+                    R.string.previous,
+                    R.drawable.arrow_upward,
+                    showAsAction = MenuItem.SHOW_AS_ACTION_ALWAYS,
+                    order = Menu.NONE,
+                    itemId = 11,
+                ) {
+                    currentFragment()?.moveSelectedNotesUp()
+                }
+                add(
+                    R.string.next,
+                    R.drawable.arrow_downward,
+                    showAsAction = MenuItem.SHOW_AS_ACTION_ALWAYS,
+                    order = Menu.NONE,
+                    itemId = 12,
+                ) {
+                    currentFragment()?.moveSelectedNotesDown()
+                }
+            }
+        }
+    }
+
+    private fun Menu.addPinned(showAsAction: Int = MenuItem.SHOW_AS_ACTION_IF_ROOM): MenuItem {
+        return add(R.string.pin, R.drawable.pin, showAsAction) {}
+    }
+
+    private fun Menu.addChangeColor(showAsAction: Int = MenuItem.SHOW_AS_ACTION_IF_ROOM): MenuItem {
+        return add(
+            R.string.change_color,
+            R.drawable.change_color,
+            showAsAction,
+            itemId = Menu.NONE,
+        ) {
+            context.lifecycleScope.launch {
+                val colors =
+                    withContext(Dispatchers.IO) {
+                        NotallyDatabase.getDatabase(context, observePreferences = false)
+                            .value
+                            .getBaseNoteDao()
+                            .getAllColors()
+                    }
+                // Show color as selected only if all selected notes have the same color
+                val currentColor =
+                    baseModel.actionMode.selectedNotes.values
+                        .map { it.color }
+                        .distinct()
+                        .takeIf { it.size == 1 }
+                        ?.firstOrNull()
+                context.showColorSelectDialog(
+                    colors,
+                    currentColor,
+                    null,
+                    { selectedColor, oldColor ->
+                        if (oldColor != null) {
+                            baseModel.changeColor(oldColor, selectedColor)
+                        }
+                        baseModel.colorBaseNote(selectedColor)
+                    },
+                ) { colorToDelete, newColor ->
+                    baseModel.changeColor(colorToDelete, newColor)
+                }
+            }
+        }
+    }
+
+    private fun Menu.addShare(showAsAction: Int = MenuItem.SHOW_AS_ACTION_IF_ROOM): MenuItem {
+        return add(R.string.share, R.drawable.share, showAsAction) { share() }
+    }
+
+    private fun share() {
+        val baseNote = baseModel.actionMode.getFirstNote()
+        context.shareNote(baseNote)
+    }
+
+    private fun deleteForever() {
+        MaterialAlertDialogBuilder(context)
+            .setMessage(R.string.delete_selected_notes)
+            .setPositiveButton(R.string.delete) { _, _ ->
+                val removedNotes = baseModel.actionMode.selectedNotes.values.toList()
+                baseModel.deleteSelectedBaseNotes()
+                Snackbar.make(
+                        binding.root,
+                        context.getQuantityString(
+                            R.plurals.deleted_selected_notes,
+                            removedNotes.size,
+                        ),
+                        Snackbar.LENGTH_SHORT,
+                    )
+                    .apply { setAction(R.string.undo) { baseModel.saveNotes(removedNotes) } }
+                    .show()
+            }
+            .setCancelButton()
+            .show()
+    }
+
+    private fun Menu.addExportMenu(showAsAction: Int = MenuItem.SHOW_AS_ACTION_IF_ROOM): MenuItem {
+        return addSubMenu(R.string.export)
+            .apply {
+                setIcon(R.drawable.export)
+                item.setShowAsAction(showAsAction)
+                ExportMimeType.entries.forEach { add(it.name).onClick { onExportNotes(it) } }
+            }
+            .item
+    }
+
+    private fun MenuItem.onClick(function: () -> Unit) {
+        setOnMenuItemClickListener {
+            function()
+            return@setOnMenuItemClickListener false
+        }
+    }
+
+    private fun NotNullLiveData<Int>.observeCount(
+        lifecycleOwner: LifecycleOwner,
+        share: MenuItem,
+        onCountChange: ((Int) -> Unit)? = null,
+    ) {
+        observe(lifecycleOwner) { count ->
+            actionModeToolbar.title = count.toString()
+            onCountChange?.invoke(count)
+            share.isVisible = count == 1
+        }
+    }
+
+    private fun NotNullLiveData<Int>.observeCountAndPinned(
+        lifecycleOwner: LifecycleOwner,
+        share: MenuItem,
+        pinned: MenuItem,
+    ) {
+        observeCount(lifecycleOwner, share) {
+            val baseNotes = baseModel.actionMode.selectedNotes.values
+            if (baseNotes.any { !it.pinned }) {
+                pinned.setTitle(R.string.pin).setIcon(R.drawable.pin).onClick {
+                    baseModel.pinBaseNotes(true)
+                }
+            } else {
+                pinned.setTitle(R.string.unpin).setIcon(R.drawable.unpin).onClick {
+                    baseModel.pinBaseNotes(false)
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/com/philkes/notallyx/presentation/activity/main/MainActivity.kt b/app/src/main/java/com/philkes/notallyx/presentation/activity/main/MainActivity.kt
index 1c5355f8..c735dcc0 100644
--- a/app/src/main/java/com/philkes/notallyx/presentation/activity/main/MainActivity.kt
+++ b/app/src/main/java/com/philkes/notallyx/presentation/activity/main/MainActivity.kt
@@ -1,8 +1,9 @@
 package com.philkes.notallyx.presentation.activity.main
 
 import android.content.Intent
+import android.content.res.ColorStateList
 import android.os.Bundle
-import android.transition.TransitionManager
+import android.util.Log
 import android.view.Menu
 import android.view.Menu.CATEGORY_CONTAINER
 import android.view.Menu.CATEGORY_SYSTEM
@@ -12,16 +13,16 @@ import android.view.ViewGroup
 import androidx.activity.OnBackPressedCallback
 import androidx.activity.result.ActivityResultLauncher
 import androidx.activity.result.contract.ActivityResultContracts
+import androidx.core.content.ContextCompat
 import androidx.core.view.GravityCompat
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.children
+import androidx.core.view.isVisible
 import androidx.drawerlayout.widget.DrawerLayout
-import androidx.lifecycle.LifecycleOwner
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.MutableLiveData
-import androidx.lifecycle.Observer
 import androidx.lifecycle.lifecycleScope
 import androidx.navigation.NavController
 import androidx.navigation.fragment.NavHostFragment
@@ -31,42 +32,41 @@ import androidx.navigation.ui.navigateUp
 import androidx.navigation.ui.setupActionBarWithNavController
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import com.google.android.material.snackbar.Snackbar
-import com.google.android.material.transition.platform.MaterialFade
 import com.philkes.notallyx.R
 import com.philkes.notallyx.data.NotallyDatabase
 import com.philkes.notallyx.data.model.BaseNote
 import com.philkes.notallyx.data.model.Folder
 import com.philkes.notallyx.databinding.ActivityMainBinding
+import com.philkes.notallyx.databinding.ChoiceItemBinding
+import com.philkes.notallyx.databinding.DialogNotesSortBinding
 import com.philkes.notallyx.presentation.activity.LockedActivity
 import com.philkes.notallyx.presentation.activity.main.fragment.DisplayLabelFragment.Companion.EXTRA_DISPLAYED_LABEL
 import com.philkes.notallyx.presentation.activity.main.fragment.NotallyFragment
 import com.philkes.notallyx.presentation.activity.main.fragment.SearchFragment
 import com.philkes.notallyx.presentation.activity.note.EditListActivity
 import com.philkes.notallyx.presentation.activity.note.EditNoteActivity
-import com.philkes.notallyx.presentation.add
+import com.philkes.notallyx.presentation.checkedTag
 import com.philkes.notallyx.presentation.dp
 import com.philkes.notallyx.presentation.getQuantityString
 import com.philkes.notallyx.presentation.movedToResId
 import com.philkes.notallyx.presentation.setCancelButton
 import com.philkes.notallyx.presentation.setupProgressDialog
-import com.philkes.notallyx.presentation.view.misc.NotNullLiveData
 import com.philkes.notallyx.presentation.view.misc.tristatecheckbox.TriStateCheckBox
 import com.philkes.notallyx.presentation.view.misc.tristatecheckbox.setMultiChoiceTriStateItems
-import com.philkes.notallyx.presentation.viewmodel.BaseNoteModel
 import com.philkes.notallyx.presentation.viewmodel.BaseNoteModel.Companion.CURRENT_LABEL_EMPTY
 import com.philkes.notallyx.presentation.viewmodel.BaseNoteModel.Companion.CURRENT_LABEL_NONE
 import com.philkes.notallyx.presentation.viewmodel.ExportMimeType
 import com.philkes.notallyx.presentation.viewmodel.preference.NotallyXPreferences.Companion.START_VIEW_DEFAULT
 import com.philkes.notallyx.presentation.viewmodel.preference.NotallyXPreferences.Companion.START_VIEW_UNLABELED
+import com.philkes.notallyx.presentation.viewmodel.preference.NotesSort
+import com.philkes.notallyx.presentation.viewmodel.preference.NotesSortBy
+import com.philkes.notallyx.presentation.viewmodel.preference.SortDirection
+import com.philkes.notallyx.presentation.viewmodel.preference.isManualSort
 import com.philkes.notallyx.presentation.viewmodel.progress.MigrationProgress
 import com.philkes.notallyx.utils.LATEST_DATA_SCHEMA
 import com.philkes.notallyx.utils.backup.exportNotes
 import com.philkes.notallyx.utils.runMigrations
-import com.philkes.notallyx.utils.shareNote
-import com.philkes.notallyx.utils.showColorSelectDialog
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
 
 class MainActivity : LockedActivity<ActivityMainBinding>() {
 
@@ -74,12 +74,13 @@ class MainActivity : LockedActivity<ActivityMainBinding>() {
     private lateinit var configuration: AppBarConfiguration
     private lateinit var exportFileActivityResultLauncher: ActivityResultLauncher<Intent>
     private lateinit var exportNotesActivityResultLauncher: ActivityResultLauncher<Intent>
+    lateinit var actionModeBinding: ActionModeBinding
 
     private var isStartViewFragment = false
     private val actionModeCancelCallback =
         object : OnBackPressedCallback(true) {
             override fun handleOnBackPressed() {
-                baseModel.actionMode.close(true)
+                actionModeBinding.close()
             }
         }
 
@@ -112,13 +113,14 @@ class MainActivity : LockedActivity<ActivityMainBinding>() {
             this,
             object : OnBackPressedCallback(true) {
                 override fun handleOnBackPressed() {
-                    if (baseModel.actionMode.enabled.value) {
+                    if (actionModeBinding.enabled()) {
                         return
                     }
                     if (
                         !isStartViewFragment &&
                             !intent.getBooleanExtra(EXTRA_SKIP_START_VIEW_ON_BACK, false)
                     ) {
+                        actionModeBinding.close()
                         navigateToStartView()
                     } else {
                         finish()
@@ -133,6 +135,17 @@ class MainActivity : LockedActivity<ActivityMainBinding>() {
 
     override fun initViewModel() {}
 
+    override fun onStop() {
+        super.onStop()
+        Log.d("MainActivity", "onStop:")
+        if (baseModel.keyword.isNotEmpty()) {
+            baseModel.keyword = ""
+        }
+        if (actionModeBinding.enabled()) {
+            actionModeBinding.close()
+        }
+    }
+
     private fun checkForMigrations(savedInstanceState: Bundle?) {
         // Run migrations first (blocking dialog), then proceed with initial navigation
         val proceed: () -> Unit = {
@@ -169,7 +182,7 @@ class MainActivity : LockedActivity<ActivityMainBinding>() {
     private fun configureEdgeToEdgeInsets() {
         WindowCompat.setDecorFitsSystemWindows(window, false)
         val navHostFragment = binding.NavHostFragment
-        ViewCompat.setOnApplyWindowInsetsListener(binding.RelativeLayout) { view, insets ->
+        ViewCompat.setOnApplyWindowInsetsListener(binding.RelativeLayout) { _, insets ->
             val systemBarsInsets = insets.getInsets(WindowInsetsCompat.Type.systemBars())
             val imeInsets = insets.getInsets(WindowInsetsCompat.Type.ime())
 
@@ -236,26 +249,73 @@ class MainActivity : LockedActivity<ActivityMainBinding>() {
 
     private fun setupFAB() {
         binding.TakeNote.setOnClickListener {
-            val intent = Intent(this, EditNoteActivity::class.java)
-            startActivity(prepareNewNoteIntent(intent))
+            if (actionModeBinding.enabled()) {
+                moveNotes(Folder.DELETED)
+            } else {
+                actionModeBinding.close()
+                val intent = Intent(this, EditNoteActivity::class.java)
+                startActivity(prepareNewNoteIntent(intent))
+            }
         }
         binding.MakeList.setOnClickListener {
-            val intent = Intent(this, EditListActivity::class.java)
-            startActivity(prepareNewNoteIntent(intent))
+            if (actionModeBinding.enabled()) {
+                label()
+            } else {
+                actionModeBinding.close()
+                val intent = Intent(this, EditListActivity::class.java)
+                startActivity(prepareNewNoteIntent(intent))
+            }
+        }
+    }
+
+    private fun updateFABs() {
+        if (actionModeBinding.enabled()) {
+            binding.TakeNote.apply {
+                setImageResource(R.drawable.delete)
+                backgroundTintList =
+                    ColorStateList.valueOf(
+                        ContextCompat.getColor(this@MainActivity, R.color.md_theme_error)
+                    )
+                contentDescription = getString(R.string.delete)
+                show()
+            }
+
+            binding.MakeList.apply {
+                setImageResource(R.drawable.label)
+                contentDescription = getString(R.string.labels)
+                show()
+            }
+        } else {
+            binding.TakeNote.apply {
+                setImageResource(R.drawable.edit)
+                backgroundTintList =
+                    ColorStateList.valueOf(
+                        ContextCompat.getColor(this@MainActivity, R.color.md_theme_primary)
+                    )
+                contentDescription = getString(R.string.take_note)
+            }
+
+            binding.MakeList.apply {
+                setImageResource(R.drawable.checkbox)
+                backgroundTintList =
+                    ColorStateList.valueOf(
+                        ContextCompat.getColor(this@MainActivity, R.color.md_theme_primary)
+                    )
+                contentDescription = getString(R.string.make_list)
+            }
+
+            if (navController.currentDestination?.id in FRAGMENTS_WITHOUT_NOTES) {
+                binding.TakeNote.hide()
+                binding.MakeList.hide()
+            } else {
+                binding.TakeNote.show()
+                binding.MakeList.show()
+            }
         }
     }
 
     private fun prepareNewNoteIntent(intent: Intent): Intent {
-        return supportFragmentManager
-            .findFragmentById(R.id.NavHostFragment)
-            ?.childFragmentManager
-            ?.fragments
-            ?.firstOrNull()
-            ?.let { fragment ->
-                return if (fragment is NotallyFragment) {
-                    fragment.prepareNewNoteIntent(intent)
-                } else intent
-            } ?: intent
+        return currentFragment()?.prepareNewNoteIntent(intent) ?: intent
     }
 
     private var labelsMenuItems: List<MenuItem> = listOf()
@@ -345,6 +405,7 @@ class MainActivity : LockedActivity<ActivityMainBinding>() {
     }
 
     private fun navigateToLabel(label: String) {
+        actionModeBinding.close()
         val bundle = Bundle().apply { putString(EXTRA_DISPLAYED_LABEL, label) }
         navController.navigate(R.id.DisplayLabel, bundle)
     }
@@ -354,89 +415,35 @@ class MainActivity : LockedActivity<ActivityMainBinding>() {
         labelsMenuItems.forEach { menuItem ->
             val visible =
                 !hiddenLabels.contains(menuItem.title) && visibleLabels < maxLabelsToDisplay
-            menuItem.setVisible(visible)
+            menuItem.isVisible = visible
             if (visible) {
                 visibleLabels++
             }
         }
-        labelsMoreMenuItem?.setTitle(getString(R.string.more, labels.size - visibleLabels))
+        labelsMoreMenuItem?.title = getString(R.string.more, labels.size - visibleLabels)
     }
 
     private fun setupActionMode() {
-        binding.ActionMode.setNavigationOnClickListener { baseModel.actionMode.close(true) }
-
-        val transition =
-            MaterialFade().apply {
-                secondaryAnimatorProvider = null
-                excludeTarget(binding.NavHostFragment, true)
-                excludeChildren(binding.NavHostFragment, true)
-                excludeTarget(binding.TakeNote, true)
-                excludeTarget(binding.MakeList, true)
-                excludeTarget(binding.NavigationView, true)
-            }
-
-        baseModel.actionMode.enabled.observe(this) { enabled ->
-            TransitionManager.beginDelayedTransition(binding.RelativeLayout, transition)
-            if (enabled) {
-                binding.Toolbar.visibility = View.GONE
-                binding.ActionMode.visibility = View.VISIBLE
-                binding.DrawerLayout.setDrawerLockMode(DrawerLayout.LOCK_MODE_LOCKED_CLOSED)
-            } else {
-                binding.Toolbar.visibility = View.VISIBLE
-                binding.ActionMode.visibility = View.GONE
-                binding.DrawerLayout.setDrawerLockMode(DrawerLayout.LOCK_MODE_UNDEFINED)
-            }
-            actionModeCancelCallback.isEnabled = enabled
-        }
-
-        val menu = binding.ActionMode.menu
-        baseModel.folder.observe(this@MainActivity, ModelFolderObserver(menu, baseModel))
-        baseModel.actionMode.loading.observe(this@MainActivity) { loading ->
-            menu.setGroupEnabled(Menu.NONE, !loading)
-        }
+        actionModeBinding =
+            ActionModeBinding(
+                baseModel,
+                binding,
+                this,
+                preferences.notesSorting,
+                ::currentFragment,
+                ::exportSelectedNotes,
+            )
+        preferences.notesSorting.observe(this) { updateFABs() }
+        actionModeBinding.enabled.observe(this) { _ -> updateFABs() }
     }
 
-    private fun moveNotes(folderTo: Folder) {
-        if (baseModel.actionMode.loading.value || baseModel.actionMode.isEmpty()) {
-            return
-        }
-        try {
-            baseModel.actionMode.loading.value = true
-            val folderFrom = baseModel.actionMode.getFirstNote().folder
-            val ids = baseModel.moveBaseNotes(folderTo)
-            Snackbar.make(
-                    findViewById(R.id.DrawerLayout),
-                    getQuantityString(folderTo.movedToResId(), ids.size),
-                    Snackbar.LENGTH_SHORT,
-                )
-                .apply { setAction(R.string.undo) { baseModel.moveBaseNotes(ids, folderFrom) } }
-                .show()
-        } finally {
-            baseModel.actionMode.loading.value = false
-        }
-    }
-
-    private fun share() {
-        val baseNote = baseModel.actionMode.getFirstNote()
-        this.shareNote(baseNote)
-    }
-
-    private fun deleteForever() {
-        MaterialAlertDialogBuilder(this)
-            .setMessage(R.string.delete_selected_notes)
-            .setPositiveButton(R.string.delete) { _, _ ->
-                val removedNotes = baseModel.actionMode.selectedNotes.values.toList()
-                baseModel.deleteSelectedBaseNotes()
-                Snackbar.make(
-                        findViewById(R.id.DrawerLayout),
-                        getQuantityString(R.plurals.deleted_selected_notes, removedNotes.size),
-                        Snackbar.LENGTH_SHORT,
-                    )
-                    .apply { setAction(R.string.undo) { baseModel.saveNotes(removedNotes) } }
-                    .show()
-            }
-            .setCancelButton()
-            .show()
+    private fun exportSelectedNotes(mimeType: ExportMimeType) {
+        exportNotes(
+            baseModel.actionMode.selectedNotes.values,
+            mimeType,
+            exportFileActivityResultLauncher,
+            exportNotesActivityResultLauncher,
+        )
     }
 
     private fun label() {
@@ -507,15 +514,6 @@ class MainActivity : LockedActivity<ActivityMainBinding>() {
             .show()
     }
 
-    private fun exportSelectedNotes(mimeType: ExportMimeType) {
-        exportNotes(
-            baseModel.actionMode.selectedNotes.values,
-            mimeType,
-            exportFileActivityResultLauncher,
-            exportNotesActivityResultLauncher,
-        )
-    }
-
     private fun setupNavigation() {
         val navHostFragment =
             supportFragmentManager.findFragmentById(R.id.NavHostFragment) as NavHostFragment
@@ -525,6 +523,7 @@ class MainActivity : LockedActivity<ActivityMainBinding>() {
 
         var fragmentIdToLoad: Int? = null
         binding.NavigationView.setNavigationItemSelectedListener { item ->
+            baseModel.actionMode.close(true)
             fragmentIdToLoad = item.itemId
             binding.DrawerLayout.closeDrawer(GravityCompat.START)
             return@setNavigationItemSelectedListener true
@@ -565,20 +564,8 @@ class MainActivity : LockedActivity<ActivityMainBinding>() {
                     binding.NavigationView.setCheckedItem(destination.id)
                 }
             }
-            when (destination.id) {
-                R.id.Notes,
-                R.id.DisplayLabel,
-                R.id.Unlabeled -> {
-                    binding.TakeNote.show()
-                    binding.MakeList.show()
-                }
-
-                else -> {
-                    binding.TakeNote.hide()
-                    binding.MakeList.hide()
-                }
-            }
             isStartViewFragment = isStartViewFragment(destination.id, bundle)
+            updateFABs()
         }
     }
 
@@ -590,6 +577,7 @@ class MainActivity : LockedActivity<ActivityMainBinding>() {
     }
 
     private fun navigateWithAnimation(id: Int) {
+        baseModel.actionMode.close(true)
         val options = navOptions {
             launchSingleTop = true
             anim {
@@ -622,194 +610,22 @@ class MainActivity : LockedActivity<ActivityMainBinding>() {
             }
     }
 
-    private inner class ModelFolderObserver(
-        private val menu: Menu,
-        private val model: BaseNoteModel,
-    ) : Observer<Folder> {
-        override fun onChanged(value: Folder) {
-            menu.clear()
-            model.actionMode.count.removeObservers(this@MainActivity)
-
-            menu.add(
-                R.string.select_all,
-                R.drawable.select_all,
-                showAsAction = MenuItem.SHOW_AS_ACTION_ALWAYS,
-            ) {
-                getCurrentFragmentNotes?.invoke()?.let { model.actionMode.add(it) }
-            }
-            when (value) {
-                Folder.NOTES -> {
-                    val pinned = menu.addPinned(MenuItem.SHOW_AS_ACTION_ALWAYS)
-                    menu.addLabels(MenuItem.SHOW_AS_ACTION_ALWAYS)
-                    menu.addDelete(MenuItem.SHOW_AS_ACTION_ALWAYS)
-                    menu.add(R.string.duplicate, R.drawable.content_copy) {
-                        baseModel.duplicateSelectedBaseNotes()
-                    }
-                    menu.add(R.string.archive, R.drawable.archive) { moveNotes(Folder.ARCHIVED) }
-                    menu.addChangeColor()
-                    val share = menu.addShare()
-                    menu.addExportMenu()
-                    model.actionMode.count.observeCountAndPinned(this@MainActivity, share, pinned)
-                }
-
-                Folder.ARCHIVED -> {
-                    menu.add(
-                        R.string.unarchive,
-                        R.drawable.unarchive,
-                        MenuItem.SHOW_AS_ACTION_ALWAYS,
-                    ) {
-                        moveNotes(Folder.NOTES)
-                    }
-                    menu.addDelete(MenuItem.SHOW_AS_ACTION_ALWAYS)
-                    menu.add(R.string.duplicate, R.drawable.content_copy) {
-                        baseModel.duplicateSelectedBaseNotes()
-                    }
-                    menu.addExportMenu(MenuItem.SHOW_AS_ACTION_ALWAYS)
-                    val pinned = menu.addPinned()
-                    menu.addLabels()
-                    menu.addChangeColor()
-                    val share = menu.addShare()
-                    model.actionMode.count.observeCountAndPinned(this@MainActivity, share, pinned)
-                }
-
-                Folder.DELETED -> {
-                    menu.add(R.string.restore, R.drawable.restore, MenuItem.SHOW_AS_ACTION_ALWAYS) {
-                        moveNotes(Folder.NOTES)
-                    }
-                    menu.add(
-                        R.string.delete_forever,
-                        R.drawable.delete,
-                        MenuItem.SHOW_AS_ACTION_ALWAYS,
-                    ) {
-                        deleteForever()
-                    }
-                    menu.addExportMenu()
-                    menu.addChangeColor()
-                    val share = menu.add(R.string.share, R.drawable.share) { share() }
-                    model.actionMode.count.observeCount(this@MainActivity, share)
-                }
-            }
-        }
-
-        private fun Menu.addPinned(showAsAction: Int = MenuItem.SHOW_AS_ACTION_IF_ROOM): MenuItem {
-            return add(R.string.pin, R.drawable.pin, showAsAction) {}
-        }
-
-        private fun Menu.addLabels(showAsAction: Int = MenuItem.SHOW_AS_ACTION_IF_ROOM): MenuItem {
-            return add(R.string.labels, R.drawable.label, showAsAction) { label() }
-        }
-
-        private fun Menu.addChangeColor(
-            showAsAction: Int = MenuItem.SHOW_AS_ACTION_IF_ROOM
-        ): MenuItem {
-            return add(R.string.change_color, R.drawable.change_color, showAsAction) {
-                lifecycleScope.launch {
-                    val colors =
-                        withContext(Dispatchers.IO) {
-                            NotallyDatabase.getDatabase(
-                                    this@MainActivity,
-                                    observePreferences = false,
-                                )
-                                .value
-                                .getBaseNoteDao()
-                                .getAllColors()
-                        }
-                    // Show color as selected only if all selected notes have the same color
-                    val currentColor =
-                        model.actionMode.selectedNotes.values
-                            .map { it.color }
-                            .distinct()
-                            .takeIf { it.size == 1 }
-                            ?.firstOrNull()
-                    showColorSelectDialog(
-                        colors,
-                        currentColor,
-                        null,
-                        { selectedColor, oldColor ->
-                            if (oldColor != null) {
-                                model.changeColor(oldColor, selectedColor)
-                            }
-                            model.colorBaseNote(selectedColor)
-                        },
-                    ) { colorToDelete, newColor ->
-                        model.changeColor(colorToDelete, newColor)
-                    }
-                }
-            }
-        }
-
-        private fun Menu.addDelete(showAsAction: Int = MenuItem.SHOW_AS_ACTION_IF_ROOM): MenuItem {
-            return add(R.string.delete, R.drawable.delete, showAsAction) {
-                moveNotes(Folder.DELETED)
-            }
-        }
-
-        private fun Menu.addShare(showAsAction: Int = MenuItem.SHOW_AS_ACTION_IF_ROOM): MenuItem {
-            return add(R.string.share, R.drawable.share, showAsAction) { share() }
-        }
-
-        private fun Menu.addExportMenu(
-            showAsAction: Int = MenuItem.SHOW_AS_ACTION_IF_ROOM
-        ): MenuItem {
-            return addSubMenu(R.string.export)
-                .apply {
-                    setIcon(R.drawable.export)
-                    item.setShowAsAction(showAsAction)
-                    ExportMimeType.entries.forEach {
-                        add(it.name).onClick { exportSelectedNotes(it) }
-                    }
-                }
-                .item
-        }
-
-        fun MenuItem.onClick(function: () -> Unit) {
-            setOnMenuItemClickListener {
-                function()
-                return@setOnMenuItemClickListener false
-            }
-        }
-
-        private fun NotNullLiveData<Int>.observeCount(
-            lifecycleOwner: LifecycleOwner,
-            share: MenuItem,
-            onCountChange: ((Int) -> Unit)? = null,
-        ) {
-            observe(lifecycleOwner) { count ->
-                binding.ActionMode.title = count.toString()
-                onCountChange?.invoke(count)
-                share.setVisible(count == 1)
-            }
-        }
-
-        private fun NotNullLiveData<Int>.observeCountAndPinned(
-            lifecycleOwner: LifecycleOwner,
-            share: MenuItem,
-            pinned: MenuItem,
-        ) {
-            observeCount(lifecycleOwner, share) {
-                val baseNotes = model.actionMode.selectedNotes.values
-                if (baseNotes.any { !it.pinned }) {
-                    pinned.setTitle(R.string.pin).setIcon(R.drawable.pin).onClick {
-                        model.pinBaseNotes(true)
-                    }
-                } else {
-                    pinned.setTitle(R.string.unpin).setIcon(R.drawable.unpin).onClick {
-                        model.pinBaseNotes(false)
-                    }
-                }
-            }
-        }
-    }
+    private fun currentFragment(): NotallyFragment? =
+        supportFragmentManager
+            .findFragmentById(R.id.NavHostFragment)
+            ?.childFragmentManager
+            ?.fragments
+            ?.firstOrNull() as? NotallyFragment
 
     override fun onCreateOptionsMenu(menu: Menu): Boolean {
         // Only show search icon if preference is not enabled and not in Reminders or Settings
         // fragments
         val currentDestinationId = navController.currentDestination?.id
+
         if (
             !preferences.alwaysShowSearchBar.value &&
-                !ACTIVITES_WITHOUT_SEARCH.contains(currentDestinationId)
+                !FRAGMENTS_WITHOUT_NOTES.contains(currentDestinationId)
         ) {
-
             // If in Search fragment, show X icon instead of search icon
             val isInSearchFragment = currentDestinationId == R.id.Search
             val iconRes = if (isInSearchFragment) R.drawable.close else R.drawable.search
@@ -821,11 +637,88 @@ class MainActivity : LockedActivity<ActivityMainBinding>() {
                 .setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS)
         }
 
+        if (!FRAGMENTS_WITHOUT_NOTES.contains(currentDestinationId)) {
+            menu
+                .add(Menu.NONE, ACTION_SORT, Menu.NONE, R.string.notes_sorted_by)
+                .setIcon(R.drawable.sort)
+                .setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS)
+        }
+
         return true
     }
 
     override fun onOptionsItemSelected(item: MenuItem): Boolean {
         return when (item.itemId) {
+            ACTION_SORT -> {
+                val value = preferences.notesSorting.value
+                val layout = DialogNotesSortBinding.inflate(layoutInflater, null, false)
+                NotesSortBy.entries.forEachIndexed { idx, notesSortBy ->
+                    ChoiceItemBinding.inflate(layoutInflater).root.apply {
+                        id = idx
+                        text = getString(notesSortBy.textResId)
+                        tag = notesSortBy
+                        layout.NotesSortByRadioGroup.addView(this)
+                        setCompoundDrawablesRelativeWithIntrinsicBounds(
+                            notesSortBy.iconResId,
+                            0,
+                            0,
+                            0,
+                        )
+                        if (notesSortBy == value.sortedBy) {
+                            layout.NotesSortByRadioGroup.check(this.id)
+                        }
+                    }
+                }
+
+                layout.NotesSortDirectionRadioGroup.isVisible = !value.isManualSort
+                layout.NotesSortDirectionRadioGroupLabel.isVisible = !value.isManualSort
+                layout.NotesSortByRadioGroup.setOnCheckedChangeListener { group, _ ->
+                    val selectedSortByIsManual =
+                        (group.checkedTag() as? NotesSortBy)?.isManualSort ?: false
+                    layout.NotesSortDirectionRadioGroup.isVisible = !selectedSortByIsManual
+                    layout.NotesSortDirectionRadioGroupLabel.isVisible = !selectedSortByIsManual
+                }
+
+                SortDirection.entries.forEachIndexed { idx, sortDir ->
+                    ChoiceItemBinding.inflate(layoutInflater).root.apply {
+                        id = idx
+                        text = getString(sortDir.textResId)
+                        tag = sortDir
+                        setCompoundDrawablesRelativeWithIntrinsicBounds(sortDir.iconResId, 0, 0, 0)
+                        layout.NotesSortDirectionRadioGroup.addView(this)
+                        if (sortDir == value.sortDirection) {
+                            layout.NotesSortDirectionRadioGroup.check(this.id)
+                        }
+                    }
+                }
+
+                MaterialAlertDialogBuilder(this)
+                    .setTitle(R.string.notes_sorted_by)
+                    .setView(layout.root)
+                    .setPositiveButton(R.string.save) { dialog, _ ->
+                        dialog.cancel()
+                        val newSortBy = layout.NotesSortByRadioGroup.checkedTag() as NotesSortBy
+                        val newSortDirection =
+                            if (newSortBy.isManualSort) {
+                                SortDirection.DESC
+                            } else {
+                                layout.NotesSortDirectionRadioGroup.checkedTag() as SortDirection
+                            }
+
+                        baseModel.savePreference(
+                            preferences.notesSorting,
+                            NotesSort(newSortBy, newSortDirection),
+                        )
+                        //                        if (newSortBy.isManualSort && !value.isManualSort)
+                        // {
+                        //                            initializeManualSortIdx()
+                        //                        }
+                        invalidateOptionsMenu()
+                    }
+                    .setCancelButton()
+                    .show()
+                true
+            }
             ACTION_SEARCH -> {
                 val isInSearchFragment = navController.currentDestination?.id == R.id.Search
 
@@ -835,14 +728,8 @@ class MainActivity : LockedActivity<ActivityMainBinding>() {
                     navController.popBackStack()
                 } else {
                     // Navigate to search fragment
-                    val currentFragment =
-                        supportFragmentManager
-                            .findFragmentById(R.id.NavHostFragment)
-                            ?.childFragmentManager
-                            ?.fragments
-                            ?.firstOrNull()
-
-                    if (currentFragment is NotallyFragment) {
+                    if (currentFragment() is NotallyFragment) {
+                        baseModel.actionMode.close(true)
                         navController.navigate(
                             R.id.Search,
                             Bundle().apply {
@@ -868,6 +755,27 @@ class MainActivity : LockedActivity<ActivityMainBinding>() {
         const val EXTRA_FRAGMENT_TO_OPEN = "notallyx.intent.extra.FRAGMENT_TO_OPEN"
         const val EXTRA_SKIP_START_VIEW_ON_BACK = "notallyx.intent.extra.SKIP_START_VIEW_ON_BACK"
         private const val ACTION_SEARCH = 1001
-        val ACTIVITES_WITHOUT_SEARCH = setOf(R.id.Settings, R.id.Reminders, R.id.Labels)
+        private const val ACTION_SORT = 1002
+        val FRAGMENTS_WITHOUT_NOTES = setOf(R.id.Settings, R.id.Reminders, R.id.Labels)
+    }
+}
+
+fun MainActivity.moveNotes(folderTo: Folder) {
+    if (actionModeBinding.loading || actionModeBinding.mode.isEmpty()) {
+        return
+    }
+    try {
+        actionModeBinding.loading = true
+        val folderFrom = actionModeBinding.mode.getFirstNote().folder
+        val ids = baseModel.moveBaseNotes(folderTo)
+        Snackbar.make(
+                findViewById(R.id.DrawerLayout),
+                getQuantityString(folderTo.movedToResId(), ids.size),
+                Snackbar.LENGTH_SHORT,
+            )
+            .apply { setAction(R.string.undo) { baseModel.moveBaseNotes(ids, folderFrom) } }
+            .show()
+    } finally {
+        actionModeBinding.loading = false
     }
 }
diff --git a/app/src/main/java/com/philkes/notallyx/presentation/activity/main/fragment/NotallyFragment.kt b/app/src/main/java/com/philkes/notallyx/presentation/activity/main/fragment/NotallyFragment.kt
index 0fcf3b92..656bd78f 100644
--- a/app/src/main/java/com/philkes/notallyx/presentation/activity/main/fragment/NotallyFragment.kt
+++ b/app/src/main/java/com/philkes/notallyx/presentation/activity/main/fragment/NotallyFragment.kt
@@ -2,6 +2,7 @@ package com.philkes.notallyx.presentation.activity.main.fragment
 
 import android.app.Activity.RESULT_OK
 import android.content.Intent
+import android.graphics.Canvas
 import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
@@ -14,6 +15,7 @@ import androidx.fragment.app.Fragment
 import androidx.fragment.app.activityViewModels
 import androidx.lifecycle.LiveData
 import androidx.navigation.findNavController
+import androidx.recyclerview.widget.ItemTouchHelper
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 import androidx.recyclerview.widget.StaggeredGridLayoutManager
@@ -43,7 +45,10 @@ import com.philkes.notallyx.presentation.view.main.BaseNoteAdapter
 import com.philkes.notallyx.presentation.view.main.BaseNoteVHPreferences
 import com.philkes.notallyx.presentation.view.misc.ItemListener
 import com.philkes.notallyx.presentation.viewmodel.BaseNoteModel
+import com.philkes.notallyx.presentation.viewmodel.preference.NotesSort
+import com.philkes.notallyx.presentation.viewmodel.preference.NotesSortBy
 import com.philkes.notallyx.presentation.viewmodel.preference.NotesView
+import com.philkes.notallyx.presentation.viewmodel.preference.isManualSort
 
 abstract class NotallyFragment : Fragment(), ItemListener {
 
@@ -157,7 +162,7 @@ abstract class NotallyFragment : Fragment(), ItemListener {
             onClick(position)
             return
         }
-        if (position != -1) {
+        if (position != RecyclerView.NO_POSITION) {
             notesAdapter?.getItem(position)?.let { item ->
                 if (item is BaseNote) {
                     val intent =
@@ -171,7 +176,7 @@ abstract class NotallyFragment : Fragment(), ItemListener {
     }
 
     override fun onLongClick(position: Int) {
-        if (position != -1) {
+        if (position != RecyclerView.NO_POSITION) {
             if (model.actionMode.selectedNotes.isNotEmpty()) {
                 if (lastSelectedNotePosition > position) {
                         position..lastSelectedNotePosition
@@ -255,6 +260,47 @@ abstract class NotallyFragment : Fragment(), ItemListener {
         notesAdapter?.notifyItemChanged(position, 0)
     }
 
+    fun moveSelectedNotesUp() {
+        val lastSelectedId =
+            notesAdapter?.getItem(lastSelectedNotePosition)?.let { (it as? BaseNote)?.id }
+        notesAdapter?.moveSelectedNotesUp(lastSelectedId)?.let { (topPos, lastSelectedPos) ->
+            binding?.MainListView?.scrollToPosition(topPos)
+            if (lastSelectedPos != -1) {
+                lastSelectedNotePosition = lastSelectedPos
+            }
+            updateActionModeSelectedNotes()
+            updateDatabaseSortIndices()
+        }
+    }
+
+    fun moveSelectedNotesDown() {
+        val lastSelectedId =
+            notesAdapter?.getItem(lastSelectedNotePosition)?.let { (it as? BaseNote)?.id }
+        notesAdapter?.moveSelectedNotesDown(lastSelectedId)?.let { (topPos, lastSelectedPos) ->
+            binding?.MainListView?.scrollToPosition(topPos)
+            if (lastSelectedPos != -1) {
+                lastSelectedNotePosition = lastSelectedPos
+            }
+            updateActionModeSelectedNotes()
+            updateDatabaseSortIndices()
+        }
+    }
+
+    private fun updateActionModeSelectedNotes() {
+        val notes = notesAdapter?.currentList?.filterIsInstance<BaseNote>() ?: return
+        model.actionMode.selectedNotes.keys.forEach { id ->
+            notes
+                .find { it.id == id }
+                ?.let { updatedNote -> model.actionMode.selectedNotes[id] = updatedNote }
+        }
+    }
+
+    private fun updateDatabaseSortIndices() {
+        val notes = notesAdapter?.currentList?.filterIsInstance<BaseNote>() ?: return
+        val idToIdx = notes.mapNotNull { it.id to (it.sortIdx ?: return@mapNotNull null) }.toMap()
+        model.updateNotesSortIndices(idToIdx)
+    }
+
     private fun setupAdapter() {
         notesAdapter =
             with(model.preferences) {
@@ -287,6 +333,7 @@ abstract class NotallyFragment : Fragment(), ItemListener {
         binding?.MainListView?.apply {
             adapter = notesAdapter
             setHasFixedSize(false)
+            updateDragAndDrop(model.preferences.notesSorting.value)
         }
         model.actionMode.addListener = { notesAdapter?.notifyDataSetChanged() }
         if (activity is MainActivity) {
@@ -304,6 +351,7 @@ abstract class NotallyFragment : Fragment(), ItemListener {
 
         model.preferences.notesSorting.observe(viewLifecycleOwner) { notesSort ->
             notesAdapter?.setNotesSort(notesSort)
+            updateDragAndDrop(notesSort)
         }
 
         model.actionMode.closeListener.observe(viewLifecycleOwner) { event ->
@@ -317,6 +365,106 @@ abstract class NotallyFragment : Fragment(), ItemListener {
         }
     }
 
+    private var itemTouchHelper: ItemTouchHelper? = null
+
+    private fun updateDragAndDrop(notesSort: NotesSort) {
+        if (notesSort.isManualSort) {
+            if (itemTouchHelper == null) {
+                itemTouchHelper =
+                    ItemTouchHelper(
+                        object :
+                            ItemTouchHelper.SimpleCallback(
+                                ItemTouchHelper.UP or
+                                    ItemTouchHelper.DOWN or
+                                    ItemTouchHelper.LEFT or
+                                    ItemTouchHelper.RIGHT,
+                                0,
+                            ) {
+                            private var hasMoved = false
+
+                            override fun onChildDraw(
+                                c: Canvas,
+                                recyclerView: RecyclerView,
+                                viewHolder: RecyclerView.ViewHolder,
+                                dX: Float,
+                                dY: Float,
+                                actionState: Int,
+                                isCurrentlyActive: Boolean,
+                            ) {
+                                if (
+                                    actionState == ItemTouchHelper.ACTION_STATE_DRAG &&
+                                        isCurrentlyActive
+                                ) {
+                                    // If dX or dY is non-zero, the user is actively sliding the
+                                    // item
+                                    if (!hasMoved && (Math.abs(dX) > 0 || Math.abs(dY) > 0)) {
+                                        hasMoved = true
+                                        model.actionMode.close(true)
+                                    }
+                                }
+                                super.onChildDraw(
+                                    c,
+                                    recyclerView,
+                                    viewHolder,
+                                    dX,
+                                    dY,
+                                    actionState,
+                                    isCurrentlyActive,
+                                )
+                            }
+
+                            override fun onMove(
+                                recyclerView: RecyclerView,
+                                viewHolder: RecyclerView.ViewHolder,
+                                target: RecyclerView.ViewHolder,
+                            ): Boolean {
+                                val fromPos = viewHolder.bindingAdapterPosition
+                                val toPos = target.bindingAdapterPosition
+                                if (
+                                    fromPos == RecyclerView.NO_POSITION ||
+                                        toPos == RecyclerView.NO_POSITION
+                                ) {
+                                    return false
+                                }
+                                val item1 = notesAdapter?.getItem(fromPos)
+                                val item2 = notesAdapter?.getItem(toPos)
+                                if (item1 is BaseNote && item2 is BaseNote) {
+                                    if (item1.pinned != item2.pinned) {
+                                        return false
+                                    }
+                                    notesAdapter?.onItemMove(fromPos, toPos)
+                                    return true
+                                }
+                                return false
+                            }
+
+                            override fun onSwiped(
+                                viewHolder: RecyclerView.ViewHolder,
+                                direction: Int,
+                            ) {}
+
+                            override fun clearView(
+                                recyclerView: RecyclerView,
+                                viewHolder: RecyclerView.ViewHolder,
+                            ) {
+                                super.clearView(recyclerView, viewHolder)
+                                hasMoved = false
+                                updateDatabaseSortIndices()
+                            }
+
+                            override fun isLongPressDragEnabled(): Boolean {
+                                return model.preferences.notesSorting.value.sortedBy ==
+                                    NotesSortBy.MANUAL && !model.actionMode.enabled.value
+                            }
+                        }
+                    )
+            }
+            itemTouchHelper!!.attachToRecyclerView(binding!!.MainListView)
+        } else {
+            itemTouchHelper?.attachToRecyclerView(null)
+        }
+    }
+
     private fun setupRecyclerView() {
         binding?.MainListView?.layoutManager =
             if (model.preferences.notesView.value == NotesView.GRID) {
diff --git a/app/src/main/java/com/philkes/notallyx/presentation/activity/main/fragment/settings/PreferenceBindingExtensions.kt b/app/src/main/java/com/philkes/notallyx/presentation/activity/main/fragment/settings/PreferenceBindingExtensions.kt
index e7dc7cdf..e3ef3776 100644
--- a/app/src/main/java/com/philkes/notallyx/presentation/activity/main/fragment/settings/PreferenceBindingExtensions.kt
+++ b/app/src/main/java/com/philkes/notallyx/presentation/activity/main/fragment/settings/PreferenceBindingExtensions.kt
@@ -45,6 +45,7 @@ import com.philkes.notallyx.presentation.viewmodel.preference.SortDirection
 import com.philkes.notallyx.presentation.viewmodel.preference.StringPreference
 import com.philkes.notallyx.presentation.viewmodel.preference.TextProvider
 import com.philkes.notallyx.presentation.viewmodel.preference.Theme
+import com.philkes.notallyx.presentation.viewmodel.preference.isManualSort
 import com.philkes.notallyx.utils.canAuthenticateWithBiometrics
 import com.philkes.notallyx.utils.toReadablePath
 
@@ -158,6 +159,14 @@ fun PreferenceBinding.setup(
             }
         }
 
+        layout.NotesSortDirectionRadioGroup.isVisible =
+            (layout.NotesSortByRadioGroup.checkedTag() as? NotesSortBy)?.isManualSort?.not() ?: true
+        layout.NotesSortByRadioGroup.setOnCheckedChangeListener { group, checkedId ->
+            val selectedSortBy = group.checkedTag() as? NotesSortBy
+            layout.NotesSortDirectionRadioGroup.isVisible =
+                selectedSortBy?.isManualSort?.not() ?: true
+        }
+
         SortDirection.entries.forEachIndexed { idx, sortDir ->
             ChoiceItemBinding.inflate(layoutInflater).root.apply {
                 id = idx
@@ -178,7 +187,9 @@ fun PreferenceBinding.setup(
                 dialog.cancel()
                 val newSortBy = layout.NotesSortByRadioGroup.checkedTag() as NotesSortBy
                 val newSortDirection =
-                    layout.NotesSortDirectionRadioGroup.checkedTag() as SortDirection
+                    if (layout.NotesSortDirectionRadioGroup.isVisible)
+                        layout.NotesSortDirectionRadioGroup.checkedTag() as SortDirection
+                    else value.sortDirection
                 model.savePreference(
                     model.preferences.notesSorting,
                     NotesSort(newSortBy, newSortDirection),
diff --git a/app/src/main/java/com/philkes/notallyx/presentation/activity/main/fragment/settings/SettingsFragment.kt b/app/src/main/java/com/philkes/notallyx/presentation/activity/main/fragment/settings/SettingsFragment.kt
index e4af436f..6e416c83 100644
--- a/app/src/main/java/com/philkes/notallyx/presentation/activity/main/fragment/settings/SettingsFragment.kt
+++ b/app/src/main/java/com/philkes/notallyx/presentation/activity/main/fragment/settings/SettingsFragment.kt
@@ -323,15 +323,6 @@ class SettingsFragment : Fragment() {
                 model.savePreference(alwaysShowSearchBar, enabled)
             }
         }
-        notesSorting.observe(viewLifecycleOwner) { notesSort ->
-            binding.NotesSortOrder.setup(
-                notesSorting,
-                notesSort,
-                requireContext(),
-                layoutInflater,
-                model,
-            )
-        }
 
         listItemSorting.observe(viewLifecycleOwner) { value ->
             binding.CheckedListItemSorting.setup(listItemSorting, value, requireContext()) {
diff --git a/app/src/main/java/com/philkes/notallyx/presentation/activity/note/RecordAudioActivity.kt b/app/src/main/java/com/philkes/notallyx/presentation/activity/note/RecordAudioActivity.kt
index f8a9111b..bc54bace 100644
--- a/app/src/main/java/com/philkes/notallyx/presentation/activity/note/RecordAudioActivity.kt
+++ b/app/src/main/java/com/philkes/notallyx/presentation/activity/note/RecordAudioActivity.kt
@@ -146,21 +146,24 @@ class RecordAudioActivity : LockedActivity<ActivityRecordAudioBinding>() {
     }
 
     private fun updateUI(binding: ActivityRecordAudioBinding, service: AudioRecordService) {
-        binding.Timer.base = service.getBase()
-        when (service.status.value) {
-            Status.READY -> {
-                binding.Stop.isEnabled = false
-                binding.Main.setText(R.string.start)
-            }
-            Status.RECORDING -> {
-                binding.Timer.start()
-                binding.Stop.isEnabled = true
-                binding.Main.setText(R.string.pause)
-            }
-            Status.PAUSED -> {
-                binding.Timer.stop()
-                binding.Stop.isEnabled = true
-                binding.Main.setText(R.string.resume)
+        binding.apply {
+            Timer.base = service.getBase()
+            when (service.status.value) {
+                Status.READY -> {
+                    Stop.isEnabled = false
+                    Main.setText(R.string.start)
+                }
+                Status.RECORDING -> {
+                    Timer.start()
+                    Stop.isEnabled = true
+                    Main.setText(R.string.pause)
+                }
+                Status.PAUSED -> {
+                    Timer.stop()
+                    Stop.isEnabled = true
+                    Main.setText(R.string.resume)
+                }
+                else -> {}
             }
         }
     }
diff --git a/app/src/main/java/com/philkes/notallyx/presentation/view/main/BaseNoteAdapter.kt b/app/src/main/java/com/philkes/notallyx/presentation/view/main/BaseNoteAdapter.kt
index 7cdbd2b2..5325fc48 100644
--- a/app/src/main/java/com/philkes/notallyx/presentation/view/main/BaseNoteAdapter.kt
+++ b/app/src/main/java/com/philkes/notallyx/presentation/view/main/BaseNoteAdapter.kt
@@ -1,10 +1,11 @@
 package com.philkes.notallyx.presentation.view.main
 
+import android.util.Log
 import android.view.LayoutInflater
 import android.view.ViewGroup
+import androidx.recyclerview.widget.DiffUtil
 import androidx.recyclerview.widget.RecyclerView
 import androidx.recyclerview.widget.SortedList
-import androidx.recyclerview.widget.SortedListAdapterCallback
 import com.philkes.notallyx.data.model.BaseNote
 import com.philkes.notallyx.data.model.Header
 import com.philkes.notallyx.data.model.Item
@@ -12,6 +13,7 @@ import com.philkes.notallyx.databinding.RecyclerBaseNoteBinding
 import com.philkes.notallyx.databinding.RecyclerHeaderBinding
 import com.philkes.notallyx.presentation.view.main.sorting.BaseNoteColorSort
 import com.philkes.notallyx.presentation.view.main.sorting.BaseNoteCreationDateSort
+import com.philkes.notallyx.presentation.view.main.sorting.BaseNoteManualSort
 import com.philkes.notallyx.presentation.view.main.sorting.BaseNoteModifiedDateSort
 import com.philkes.notallyx.presentation.view.main.sorting.BaseNoteTitleSort
 import com.philkes.notallyx.presentation.view.misc.ItemListener
@@ -31,7 +33,121 @@ class BaseNoteAdapter(
 
     private var searchKeyword: String = ""
 
-    private var list = SortedList(Item::class.java, notesSort.createCallback())
+    private interface ItemListContainer {
+        fun size(): Int
+
+        operator fun get(position: Int): Item
+
+        fun replaceAll(items: List<Item>)
+
+        fun clear()
+
+        fun addAll(items: List<Item>)
+
+        fun toList(): List<Item>
+    }
+
+    private class SortedListContainer(private val list: SortedList<Item>) : ItemListContainer {
+        override fun size(): Int = list.size()
+
+        override fun get(position: Int): Item = list[position]
+
+        override fun replaceAll(items: List<Item>) = list.replaceAll(items)
+
+        override fun clear() = list.clear()
+
+        override fun addAll(items: List<Item>) = list.addAll(items)
+
+        override fun toList(): List<Item> {
+            val result = mutableListOf<Item>()
+            for (i in 0 until list.size()) {
+                result.add(list[i])
+            }
+            return result
+        }
+    }
+
+    private inner class MutableListContainer(
+        private var items: MutableList<Item>,
+        private val sort: NotesSort,
+    ) : ItemListContainer {
+        override fun size(): Int = items.size
+
+        override fun get(position: Int): Item = items[position]
+
+        override fun replaceAll(newItems: List<Item>) {
+            val oldItems = items
+            items = newItems.toMutableList()
+            sortIfNeeded()
+            val diffResult =
+                DiffUtil.calculateDiff(
+                    object : DiffUtil.Callback() {
+                        override fun getOldListSize(): Int = oldItems.size
+
+                        override fun getNewListSize(): Int = items.size
+
+                        override fun areItemsTheSame(
+                            oldItemPosition: Int,
+                            newItemPosition: Int,
+                        ): Boolean {
+                            val oldItem = oldItems[oldItemPosition]
+                            val newItem = items[newItemPosition]
+                            return when {
+                                oldItem is BaseNote && newItem is BaseNote ->
+                                    oldItem.id == newItem.id
+                                oldItem is Header && newItem is Header ->
+                                    oldItem.label == newItem.label
+                                else -> false
+                            }
+                        }
+
+                        override fun areContentsTheSame(
+                            oldItemPosition: Int,
+                            newItemPosition: Int,
+                        ): Boolean {
+                            return oldItems[oldItemPosition] == items[newItemPosition]
+                        }
+                    }
+                )
+            diffResult.dispatchUpdatesTo(this@BaseNoteAdapter)
+        }
+
+        override fun clear() {
+            val oldSize = items.size
+            items.clear()
+            notifyItemRangeRemoved(0, oldSize)
+        }
+
+        override fun addAll(newItems: List<Item>) {
+            val oldSize = items.size
+            items.addAll(newItems)
+            sortIfNeeded()
+            notifyItemRangeInserted(oldSize, items.size - oldSize)
+        }
+
+        override fun toList(): List<Item> = items.toList()
+
+        fun sortIfNeeded() {
+            val callback = sort.createCallback()
+            items.sortWith { a, b -> callback.compare(a, b) }
+        }
+
+        fun move(fromPosition: Int, toPosition: Int) {
+            val fromItem = items.removeAt(fromPosition)
+            items.add(toPosition, fromItem)
+            notifyItemMoved(fromPosition, toPosition)
+        }
+    }
+
+    private var list: ItemListContainer = createListContainer(notesSort)
+
+    private fun createListContainer(sort: NotesSort): ItemListContainer {
+        return if (sort.sortedBy == NotesSortBy.MANUAL) {
+            MutableListContainer(mutableListOf(), sort)
+        } else {
+            SortedListContainer(SortedList(Item::class.java, sort.createCallback()))
+        }
+    }
 
     override fun getItemViewType(position: Int): Int {
         return when (list[position]) {
@@ -57,6 +173,7 @@ class BaseNoteAdapter(
     }
 
     fun setSearchKeyword(keyword: String) {
+        Log.d("SearchResult", "keyword: $keyword")
         if (searchKeyword != keyword) {
             val oldKeyword = searchKeyword
             searchKeyword = keyword
@@ -120,10 +237,17 @@ class BaseNoteAdapter(
 
     fun setNotesSort(notesSort: NotesSort) {
         this.notesSort = notesSort
-        replaceSortCallback(notesSort.createCallback())
+        val mutableList = list.toList()
+        list.clear()
+        list = createListContainer(notesSort)
+        list.addAll(mutableList)
+        notifyDataSetChanged()
     }
 
     fun getItem(position: Int): Item? {
+        if (position == RecyclerView.NO_POSITION || position < 0 || position >= list.size()) {
+            return null
+        }
         return list[position]
     }
 
@@ -134,6 +258,98 @@ class BaseNoteAdapter(
         list.replaceAll(items)
     }
 
+    fun onItemMove(fromPosition: Int, toPosition: Int) {
+        if (list is MutableListContainer) {
+            (list as MutableListContainer).move(fromPosition, toPosition)
+            updateSortIndices()
+        }
+    }
+
+    /**
+     * @return a pair of (top-most moved position, new position of the last selected note). If there
+     *   is no moved position, return null.
+     */
+    fun moveSelectedNotesUp(lastSelectedId: Long?): Pair<Int, Int>? {
+        if (list is MutableListContainer) {
+            val items = list.toList()
+            val selectedIndices =
+                items.mapIndexedNotNull { index, item ->
+                    if (item is BaseNote && selectedIds.contains(item.id)) index else null
+                }
+            if (selectedIndices.isEmpty()) return null
+
+            var moved = false
+            selectedIndices.forEachIndexed { i, index ->
+                if (index > i) {
+                    (list as MutableListContainer).move(index, index - 1)
+                    moved = true
+                }
+            }
+            if (!moved) return null
+
+            val newItems = list.toList()
+            val topMostMovedPosition =
+                newItems
+                    .indexOfFirst { it is BaseNote && selectedIds.contains(it.id) }
+                    .takeIf { it != -1 }
+
+            val newLastSelectedPos =
+                if (lastSelectedId != null) {
+                    newItems.indexOfFirst { it is BaseNote && it.id == lastSelectedId }
+                } else -1
+
+            updateSortIndices()
+            return topMostMovedPosition?.let { it to newLastSelectedPos }
+        }
+        return null
+    }
+
+    /**
+     * @return a pair of (top-most moved position, new position of the last selected note). If there
+     *   is no moved position, return null.
+     */
+    fun moveSelectedNotesDown(lastSelectedId: Long?): Pair<Int, Int>? {
+        if (list is MutableListContainer) {
+            val items = list.toList()
+            val selectedIndices =
+                items.mapIndexedNotNull { index, item ->
+                    if (item is BaseNote && selectedIds.contains(item.id)) index else null
+                }
+            if (selectedIndices.isEmpty()) return null
+
+            var moved = false
+            val n = items.size
+            selectedIndices.reversed().forEachIndexed { i, index ->
+                if (index < n - 1 - i) {
+                    (list as MutableListContainer).move(index, index + 1)
+                    moved = true
+                }
+            }
+            if (!moved) return null
+
+            val newItems = list.toList()
+            val topMostMovedPosition =
+                newItems
+                    .indexOfFirst { it is BaseNote && selectedIds.contains(it.id) }
+                    .takeIf { it != -1 }
+
+            val newLastSelectedPos =
+                if (lastSelectedId != null) {
+                    newItems.indexOfFirst { it is BaseNote && it.id == lastSelectedId }
+                } else -1
+
+            updateSortIndices()
+            return topMostMovedPosition?.let { it to newLastSelectedPos }
+        }
+        return null
+    }
+
+    private fun updateSortIndices() {
+        val currentItems = list.toList()
+        val notes = currentItems.filterIsInstance<BaseNote>()
+        notes.forEachIndexed { index, note -> note.sortIdx = notes.size - 1 - index }
+    }
+
     private fun NotesSort.createCallback() =
         when (sortedBy) {
             NotesSortBy.TITLE -> BaseNoteTitleSort(this@BaseNoteAdapter, sortDirection)
@@ -142,28 +358,13 @@ class BaseNoteAdapter(
             NotesSortBy.CREATION_DATE ->
                 BaseNoteCreationDateSort(this@BaseNoteAdapter, sortDirection)
             NotesSortBy.COLOR -> BaseNoteColorSort(this@BaseNoteAdapter, sortDirection)
+            NotesSortBy.MANUAL -> BaseNoteManualSort(this@BaseNoteAdapter, sortDirection)
         }
 
-    private fun replaceSortCallback(sortCallback: SortedListAdapterCallback<Item>) {
-        val mutableList = mutableListOf<Item>()
-        for (i in 0 until list.size()) {
-            mutableList.add(list[i])
-        }
-        list.clear()
-        list = SortedList(Item::class.java, sortCallback)
-        list.addAll(mutableList)
-    }
-
     private fun handleCheck(holder: RecyclerView.ViewHolder, position: Int) {
-        val baseNote = list[position] as BaseNote
-        (holder as BaseNoteVH).updateCheck(selectedIds.contains(baseNote.id), baseNote.color)
-    }
-
-    private fun <T> SortedList<T>.toList(): List<T> {
-        val mutableList = mutableListOf<T>()
-        for (i in 0 until this.size()) {
-            mutableList.add(this[i])
+        val item = list[position]
+        if (item is BaseNote) {
+            (holder as BaseNoteVH).updateCheck(selectedIds.contains(item.id), item.color)
         }
-        return mutableList.toList()
     }
 }
diff --git a/app/src/main/java/com/philkes/notallyx/presentation/view/main/sorting/BaseNoteManualSort.kt b/app/src/main/java/com/philkes/notallyx/presentation/view/main/sorting/BaseNoteManualSort.kt
new file mode 100644
index 00000000..ac3a9efa
--- /dev/null
+++ b/app/src/main/java/com/philkes/notallyx/presentation/view/main/sorting/BaseNoteManualSort.kt
@@ -0,0 +1,19 @@
+package com.philkes.notallyx.presentation.view.main.sorting
+
+import androidx.recyclerview.widget.RecyclerView
+import com.philkes.notallyx.data.model.BaseNote
+import com.philkes.notallyx.presentation.viewmodel.preference.SortDirection
+
+open class BaseNoteManualSort(adapter: RecyclerView.Adapter<*>?, sortDirection: SortDirection) :
+    ItemSort(adapter, sortDirection) {
+
+    override fun compare(note1: BaseNote, note2: BaseNote, sortDirection: SortDirection): Int {
+        val sortIdx1 = note1.sortIdx ?: Int.MAX_VALUE
+        val sortIdx2 = note2.sortIdx ?: Int.MAX_VALUE
+        return if (sortDirection == SortDirection.ASC) {
+            sortIdx1.compareTo(sortIdx2)
+        } else {
+            sortIdx2.compareTo(sortIdx1)
+        }
+    }
+}
diff --git a/app/src/main/java/com/philkes/notallyx/presentation/viewmodel/BaseNoteModel.kt b/app/src/main/java/com/philkes/notallyx/presentation/viewmodel/BaseNoteModel.kt
index 0845fc37..4809444f 100644
--- a/app/src/main/java/com/philkes/notallyx/presentation/viewmodel/BaseNoteModel.kt
+++ b/app/src/main/java/com/philkes/notallyx/presentation/viewmodel/BaseNoteModel.kt
@@ -657,6 +657,20 @@ class BaseNoteModel(private val app: Application) : AndroidViewModel(app) {
         }
     }
 
+    fun updateNoteSortIdx(id: Long, sortIdx: Int) {
+        viewModelScope.launch {
+            withContext(Dispatchers.IO) { baseNoteDao.updateSortIdx(id, sortIdx) }
+        }
+    }
+
+    fun updateNotesSortIndices(idToIdx: Map<Long, Int>) {
+        viewModelScope.launch {
+            withContext(Dispatchers.IO) { baseNoteDao.updateSortIndices(idToIdx) }
+        }
+    }
+
+    suspend fun getMaxNoteSortIdx() = withContext(Dispatchers.IO) { baseNoteDao.getMaxSortIdx() }
+
     fun updateBaseNoteLabels(labels: List<String>, id: Long) {
         actionMode.close(true)
         viewModelScope.launch(Dispatchers.IO) { baseNoteDao.updateLabels(id, labels) }
diff --git a/app/src/main/java/com/philkes/notallyx/presentation/viewmodel/NotallyModel.kt b/app/src/main/java/com/philkes/notallyx/presentation/viewmodel/NotallyModel.kt
index e7bacce2..611d47e2 100644
--- a/app/src/main/java/com/philkes/notallyx/presentation/viewmodel/NotallyModel.kt
+++ b/app/src/main/java/com/philkes/notallyx/presentation/viewmodel/NotallyModel.kt
@@ -354,6 +354,7 @@ class NotallyModel(private val app: Application) : AndroidViewModel(app) {
             audios.value,
             reminders.value,
             viewMode.value,
+            originalNote?.sortIdx,
         )
     }
 
diff --git a/app/src/main/java/com/philkes/notallyx/presentation/viewmodel/preference/NotesSorting.kt b/app/src/main/java/com/philkes/notallyx/presentation/viewmodel/preference/NotesSorting.kt
index 25cbe9b7..1116a3f1 100644
--- a/app/src/main/java/com/philkes/notallyx/presentation/viewmodel/preference/NotesSorting.kt
+++ b/app/src/main/java/com/philkes/notallyx/presentation/viewmodel/preference/NotesSorting.kt
@@ -50,7 +50,8 @@ enum class NotesSortBy(val textResId: Int, val iconResId: Int, val value: String
     TITLE(R.string.title, R.drawable.sort_by_alpha, "autoSortByTitle"),
     CREATION_DATE(R.string.creation_date, R.drawable.calendar_add_on, "autoSortByCreationDate"),
     MODIFIED_DATE(R.string.modified_date, R.drawable.edit_calendar, "autoSortByModifiedDate"),
-    COLOR(R.string.color, R.drawable.change_color, "autoSortByColor");
+    COLOR(R.string.color, R.drawable.change_color, "autoSortByColor"),
+    MANUAL(R.string.manual, R.drawable.sort, "manualSort");
 
     companion object {
         fun fromValue(value: String): NotesSortBy? {
@@ -67,3 +68,9 @@ data class NotesSort(
         return "${context.getString(sortedBy.textResId)} (${context.getString(sortDirection.textResId)})"
     }
 }
+
+val NotesSort.isManualSort: Boolean
+    get() = sortedBy.isManualSort
+
+val NotesSortBy.isManualSort: Boolean
+    get() = this == NotesSortBy.MANUAL
diff --git a/app/src/main/java/com/philkes/notallyx/utils/ActionMode.kt b/app/src/main/java/com/philkes/notallyx/utils/ActionMode.kt
index d8d87142..2b709511 100644
--- a/app/src/main/java/com/philkes/notallyx/utils/ActionMode.kt
+++ b/app/src/main/java/com/philkes/notallyx/utils/ActionMode.kt
@@ -19,6 +19,12 @@ class ActionMode {
         enabled.value = selectedNotes.size != 0
     }
 
+    fun clear() {
+        enabled.value = false
+        selectedNotes.clear()
+        refresh()
+    }
+
     fun add(id: Long, baseNote: BaseNote) {
         selectedNotes[id] = baseNote
         refresh()
diff --git a/app/src/main/java/com/philkes/notallyx/utils/backup/ImportExtensions.kt b/app/src/main/java/com/philkes/notallyx/utils/backup/ImportExtensions.kt
index 2e4ca6b7..297c7d94 100644
--- a/app/src/main/java/com/philkes/notallyx/utils/backup/ImportExtensions.kt
+++ b/app/src/main/java/com/philkes/notallyx/utils/backup/ImportExtensions.kt
@@ -10,6 +10,7 @@ import android.graphics.BitmapFactory
 import android.media.MediaMetadataRetriever
 import android.net.Uri
 import android.util.Log
+import androidx.core.database.getIntOrNull
 import androidx.core.database.getLongOrNull
 import androidx.documentfile.provider.DocumentFile
 import androidx.lifecycle.MutableLiveData
@@ -356,6 +357,11 @@ private fun Cursor.toBaseNote(sourceDb: SQLiteDatabase): BaseNote {
         if (viewModeIndex != -1) {
             NoteViewMode.valueOfOrDefault(getString(viewModeIndex))
         } else NoteViewMode.EDIT
+    val sortIdxIndex = getColumnIndex("sortIdx")
+    val sortIdx =
+        if (sortIdxIndex != -1) {
+            getIntOrNull(sortIdxIndex)
+        } else null
     return BaseNote(
         0,
         type,
@@ -374,6 +380,7 @@ private fun Cursor.toBaseNote(sourceDb: SQLiteDatabase): BaseNote {
         audios,
         reminders,
         viewMode,
+        sortIdx,
     )
 }
 
diff --git a/app/src/main/res/drawable/sort.xml b/app/src/main/res/drawable/sort.xml
new file mode 100644
index 00000000..1f06ff75
--- /dev/null
+++ b/app/src/main/res/drawable/sort.xml
@@ -0,0 +1,11 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960"
+    android:tint="?attr/colorControlNormal"
+    android:autoMirrored="true">
+  <path
+      android:fillColor="@android:color/white"
+      android:pathData="M120,720L120,640L360,640L360,720L120,720ZM120,520L120,440L600,440L600,520L120,520ZM120,320L120,240L840,240L840,320L120,320Z"/>
+</vector>
diff --git a/app/src/main/res/layout/activity_main.xml b/app/src/main/res/layout/activity_main.xml
index 0620c756..243d0af5 100644
--- a/app/src/main/res/layout/activity_main.xml
+++ b/app/src/main/res/layout/activity_main.xml
@@ -63,6 +63,7 @@
             android:contentDescription="@string/take_note"
             android:tooltipText="@string/take_note"
             style="@style/FloatingActionButtonPrimary"
+            app:backgroundTint="@color/md_theme_primary"
             app:srcCompat="@drawable/edit" />
 
     </RelativeLayout>
diff --git a/app/src/main/res/layout/dialog_notes_sort.xml b/app/src/main/res/layout/dialog_notes_sort.xml
index ba573d69..9960700a 100644
--- a/app/src/main/res/layout/dialog_notes_sort.xml
+++ b/app/src/main/res/layout/dialog_notes_sort.xml
@@ -17,6 +17,7 @@
         />
 
     <TextView
+        android:id="@+id/NotesSortDirectionRadioGroupLabel"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:text="@string/sort_direction"
diff --git a/app/src/main/res/layout/fragment_settings.xml b/app/src/main/res/layout/fragment_settings.xml
index cd65d9b7..a01337ca 100644
--- a/app/src/main/res/layout/fragment_settings.xml
+++ b/app/src/main/res/layout/fragment_settings.xml
@@ -45,10 +45,6 @@
           android:layout_height="wrap_content"
           android:text="@string/behaviour" />
 
-        <include
-            android:id="@+id/NotesSortOrder"
-            layout="@layout/preference" />
-
         <include
             android:id="@+id/CheckedListItemSorting"
             layout="@layout/preference" />
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index 6b445f60..dc9d930d 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -234,6 +234,8 @@
     <string name="locked">Locked</string>
     <string name="make_feature_request">Make a feature request</string>
     <string name="make_list">Make list</string>
+    <string name="manual">Manual</string>
+    <string name="manual_sort_dialog_message">To manually sort notes, you must first set the sort order to Manual. Would you like to do that now\?</string>
     <string name="max_backups">Amount of backups to keep</string>
     <string name="max_items_to_display">Max items to display in list</string>
     <string name="max_labels_to_display">Max labels to display in Navigation</string>
diff --git a/app/src/main/res/values/themes.xml b/app/src/main/res/values/themes.xml
index 130ffb27..d093951f 100644
--- a/app/src/main/res/values/themes.xml
+++ b/app/src/main/res/values/themes.xml
@@ -133,7 +133,6 @@
     </style>
 
     <style name="FloatingActionButtonPrimary" parent="Widget.Material3.FloatingActionButton.Primary">
-        <item name="android:backgroundTint">?attr/colorPrimary</item>
         <item name="tint">?attr/colorOnPrimary</item>
     </style>
 

From b7488cb7767ed4aeaa5e666d7610d20bb24c23ae Mon Sep 17 00:00:00 2001
From: Crustack <39240633+Crustack@users.noreply.github.com>
Date: Sun, 8 Mar 2026 13:02:42 +0000
Subject: [PATCH 2/2] Updated translation coverage

---
 TRANSLATIONS.md | 60 ++++++++++++++++++++++++-------------------------
 1 file changed, 30 insertions(+), 30 deletions(-)

diff --git a/TRANSLATIONS.md b/TRANSLATIONS.md
index 50fdb9c6..c0cec2ab 100644
--- a/TRANSLATIONS.md
+++ b/TRANSLATIONS.md
@@ -19,34 +19,34 @@ See [Android Translations Converter](https://github.com/Crustack/android-transla
 <!-- translations:start -->
 | Language | Coverage |
 |----------|----------|
-| 🇺🇸 English | 100% (337/337) |
-| 🇪🇸 Catalan | 19% (65/337) |
-| 🇨🇿 Czech | 92% (313/337) |
-| 🇩🇰 Danish | 20% (69/337) |
-| 🇩🇪 German | 99% (335/337) |
-| 🇬🇷 Greek | 21% (72/337) |
-| 🇪🇸 Spanish | 93% (314/337) |
-| 🇫🇷 French | 97% (327/337) |
-| 🇭🇺 Hungarian | 19% (65/337) |
-| 🇮🇩 Indonesian | 22% (75/337) |
-| 🇮🇹 Italian | 86% (291/337) |
-| 🇯🇵 Japanese | 21% (73/337) |
-| 🇲🇲 Burmese | 26% (90/337) |
-| 🇳🇴 Norwegian Bokmål | 31% (106/337) |
-| 🇳🇱 Dutch | 62% (212/337) |
-| 🇳🇴 Norwegian Nynorsk | 31% (106/337) |
-| 🇵🇱 Polish | 89% (300/337) |
-| 🇧🇷 Portuguese (Brazil) | 92% (312/337) |
-| 🇵🇹 Portuguese (Portugal) | 21% (71/337) |
-| 🇷🇴 Romanian | 89% (301/337) |
-| 🇷🇺 Russian | 90% (305/337) |
-| 🇸🇰 Slovak | 19% (65/337) |
-| 🇸🇮 Slovenian | 32% (109/337) |
-| 🇸🇪 Swedish | 18% (63/337) |
-| 🇵🇭 Tagalog | 19% (65/337) |
-| 🇹🇷 Turkish | 21% (73/337) |
-| 🇺🇦 Ukrainian | 98% (331/337) |
-| 🇻🇳 Vietnamese | 31% (107/337) |
-| 🇨🇳 Chinese (Simplified) | 97% (328/337) |
-| 🇹🇼 Chinese (Traditional) | 87% (294/337) |
+| 🇺🇸 English | 100% (339/339) |
+| 🇪🇸 Catalan | 19% (65/339) |
+| 🇨🇿 Czech | 92% (313/339) |
+| 🇩🇰 Danish | 20% (69/339) |
+| 🇩🇪 German | 98% (335/339) |
+| 🇬🇷 Greek | 21% (72/339) |
+| 🇪🇸 Spanish | 92% (314/339) |
+| 🇫🇷 French | 96% (327/339) |
+| 🇭🇺 Hungarian | 19% (65/339) |
+| 🇮🇩 Indonesian | 22% (75/339) |
+| 🇮🇹 Italian | 85% (291/339) |
+| 🇯🇵 Japanese | 21% (73/339) |
+| 🇲🇲 Burmese | 26% (90/339) |
+| 🇳🇴 Norwegian Bokmål | 31% (106/339) |
+| 🇳🇱 Dutch | 62% (212/339) |
+| 🇳🇴 Norwegian Nynorsk | 31% (106/339) |
+| 🇵🇱 Polish | 88% (300/339) |
+| 🇧🇷 Portuguese (Brazil) | 92% (312/339) |
+| 🇵🇹 Portuguese (Portugal) | 20% (71/339) |
+| 🇷🇴 Romanian | 88% (301/339) |
+| 🇷🇺 Russian | 89% (305/339) |
+| 🇸🇰 Slovak | 19% (65/339) |
+| 🇸🇮 Slovenian | 32% (109/339) |
+| 🇸🇪 Swedish | 18% (63/339) |
+| 🇵🇭 Tagalog | 19% (65/339) |
+| 🇹🇷 Turkish | 21% (73/339) |
+| 🇺🇦 Ukrainian | 97% (331/339) |
+| 🇻🇳 Vietnamese | 31% (107/339) |
+| 🇨🇳 Chinese (Simplified) | 96% (328/339) |
+| 🇹🇼 Chinese (Traditional) | 86% (294/339) |
 <!-- translations:end -->
\ No newline at end of file