Skip to content

Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.

feat(recording): let the recordings folder be changed

abduznik5d0ba75076cf
diff --git a/electron/electron-env.d.ts b/electron/electron-env.d.ts
index 1466c5139..bbb5a70d6 100644
--- a/electron/electron-env.d.ts
+++ b/electron/electron-env.d.ts
@@ -459,6 +459,14 @@ interface Window {
) => Promise<{ success: boolean; error?: string; message?: string }>;
/** Whether a take can start: refused, with the message to show, when the disk is nearly full. */
checkRecordingStorage: () => Promise<{ success: true } | { success: false; error: string }>;
+ getRecordingsDir: () => Promise<{ path: string; isDefault: boolean }>;
+ /** Opens the native folder picker; the main process never takes a path from the renderer. */
+ chooseRecordingsDir: () => Promise<
+ { success: true; path: string } | { success: false; canceled?: boolean; message?: string }
+ >;
+ resetRecordingsDir: () => Promise<
+ { success: true; path: string } | { success: false; message?: string }
+ >;
getShortcuts: () => Promise<Record<string, unknown> | null>;
saveShortcuts: (shortcuts: unknown) => Promise<{ success: boolean; error?: string }>;
updateGlobalShortcut: (binding: {
diff --git a/electron/ipc/handlers.ts b/electron/ipc/handlers.ts
index 8d242d9b5..cec8b1b7c 100644
--- a/electron/ipc/handlers.ts
+++ b/electron/ipc/handlers.ts
@@ -70,7 +70,7 @@ import { AppSettingsStore } from "../app-settings";
import { isDiagnosticModeEnabled, mainLogBuffer } from "../diagnostics/main-log-buffer";
import { mainT } from "../i18n";
import { getInstallChannel } from "../install-channel";
-import { RECORDINGS_DIR } from "../main";
+import { getRecordingsDirInfo, RECORDINGS_DIR, setRecordingsDir } from "../main";
import { EditorDocumentHost } from "../mcp/editor-document-host";
import { McpController } from "../mcp/mcp-controller";
import { McpSettingsStore } from "../mcp/mcp-settings-store";
@@ -2296,6 +2296,36 @@ export function registerIpcHandlers(
};
});
+ ipcMain.handle("get-recordings-dir", () => getRecordingsDirInfo());
+
+ // The folder comes from the native picker, never from the renderer: everything in it
+ // becomes readable through the media handlers.
+ ipcMain.handle("choose-recordings-dir", async (event) => {
+ const result = await showOpenDialogOver(BrowserWindow.fromWebContents(event.sender), {
+ title: mainT("dialogs", "fileDialogs.selectRecordingsFolder"),
+ defaultPath: RECORDINGS_DIR,
+ properties: ["openDirectory", "createDirectory"],
+ });
+ if (result.canceled || result.filePaths.length === 0) {
+ return { success: false, canceled: true };
+ }
+ try {
+ return { success: true, path: await setRecordingsDir(result.filePaths[0]) };
+ } catch (error) {
+ console.error("Failed to switch recordings folder:", error);
+ return { success: false, message: String(error) };
+ }
+ });
+
+ ipcMain.handle("reset-recordings-dir", async () => {
+ try {
+ return { success: true, path: await setRecordingsDir(null) };
+ } catch (error) {
+ console.error("Failed to reset recordings folder:", error);
+ return { success: false, message: String(error) };
+ }
+ });
+
ipcMain.handle("request-camera-access", async () => {
if (process.platform !== "darwin") {
return { success: true, granted: true, status: "granted" };
diff --git a/electron/main.ts b/electron/main.ts
index 91b36b930..13b8a8ad7 100644
--- a/electron/main.ts
+++ b/electron/main.ts
@@ -1,4 +1,3 @@
-import fs from "node:fs/promises";
import path from "node:path";
import { fileURLToPath } from "node:url";
import {
@@ -68,6 +67,7 @@ import {
showPermissionsWindowIfNeeded,
} from "./permissions";
import { setDisplaySleepBlocked } from "./recording/displaySleepBlocker";
+import { RecordingsDirManager } from "./recording/recordingsDirManager";
import { offersStarPrompt, REPO_URL, storeReviewUrl } from "./star-prompt";
import { registerSttIpc, shutdownStt } from "./stt";
import { checkLatestRelease } from "./update-checker";
@@ -103,11 +103,18 @@ disableHttpCacheForDevServer(app.commandLine, process.env);
installMainProcessErrorGuards();
-export const RECORDINGS_DIR = path.join(app.getPath("userData"), "recordings");
+const recordingsDirManager = new RecordingsDirManager(app.getPath("userData"), () => isRecording);
+
+export const DEFAULT_RECORDINGS_DIR = recordingsDirManager.defaultDir;
+
+// Mutable: reassigned by setRecordingsDir() when the user picks another folder.
+// `handlers.ts` imports this as a live named binding, so every call site there
+// sees the change immediately, with no restart.
+export let RECORDINGS_DIR = recordingsDirManager.dir;
async function ensureRecordingsDir() {
try {
- await fs.mkdir(RECORDINGS_DIR, { recursive: true });
+ await recordingsDirManager.ensureExists();
console.log("RECORDINGS_DIR:", RECORDINGS_DIR);
console.log("User Data Path:", app.getPath("userData"));
} catch (error) {
@@ -115,6 +122,20 @@ async function ensureRecordingsDir() {
}
}
+/**
+ * Switches where new recordings are written. `null` resets to the default
+ * (userData/recordings). Existing files stay where they are. Refused while a
+ * recording is active; see RecordingsDirManager.setDir.
+ */
+export async function setRecordingsDir(customDir: string | null): Promise<string> {
+ RECORDINGS_DIR = await recordingsDirManager.setDir(customDir);
+ return RECORDINGS_DIR;
+}
+
+export function getRecordingsDirInfo() {
+ return recordingsDirManager.getInfo();
+}
+
// The built directory structure
//
// ├─┬─┬ dist
diff --git a/electron/preload.ts b/electron/preload.ts
index 9441718af..802da693b 100644
--- a/electron/preload.ts
+++ b/electron/preload.ts
@@ -495,6 +495,22 @@ contextBridge.exposeInMainWorld("electronAPI", {
{ success: true } | { success: false; error: string }
>;
},
+ getRecordingsDir: () => {
+ return ipcRenderer.invoke("get-recordings-dir") as Promise<{
+ path: string;
+ isDefault: boolean;
+ }>;
+ },
+ chooseRecordingsDir: () => {
+ return ipcRenderer.invoke("choose-recordings-dir") as Promise<
+ { success: true; path: string } | { success: false; canceled?: boolean; message?: string }
+ >;
+ },
+ resetRecordingsDir: () => {
+ return ipcRenderer.invoke("reset-recordings-dir") as Promise<
+ { success: true; path: string } | { success: false; message?: string }
+ >;
+ },
getShortcuts: () => {
return ipcRenderer.invoke("get-shortcuts");
},
diff --git a/electron/recording/recordingsDirManager.test.ts b/electron/recording/recordingsDirManager.test.ts
new file mode 100644
index 000000000..d2ebdfbe1
--- /dev/null
+++ b/electron/recording/recordingsDirManager.test.ts
@@ -0,0 +1,120 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { RecordingsDirManager } from "./recordingsDirManager";
+import type { RecordingsLocationStore } from "./recordingsLocationStore";
+
+/** The private store, reached into to make a write fail or a recording start mid-await. */
+const storeOf = (manager: RecordingsDirManager) =>
+ (manager as unknown as { store: RecordingsLocationStore }).store;
+
+describe("RecordingsDirManager", () => {
+ let userDataDir: string;
+
+ beforeEach(async () => {
+ userDataDir = await mkdtemp(path.join(tmpdir(), "openscreen-recordings-dir-manager-"));
+ });
+
+ afterEach(async () => {
+ await rm(userDataDir, { recursive: true, force: true });
+ });
+
+ it("starts at the default dir when nothing was persisted before", () => {
+ const manager = new RecordingsDirManager(userDataDir, () => false);
+ expect(manager.dir).toBe(manager.defaultDir);
+ expect(manager.getInfo()).toEqual({ path: manager.defaultDir, isDefault: true });
+ });
+
+ it("switches to a custom dir and reports it as non-default", async () => {
+ const manager = new RecordingsDirManager(userDataDir, () => false);
+ const customDir = path.join(userDataDir, "custom-recordings");
+
+ const resolved = await manager.setDir(customDir);
+
+ expect(resolved).toBe(customDir);
+ expect(manager.dir).toBe(customDir);
+ expect(manager.getInfo()).toEqual({ path: customDir, isDefault: false });
+ });
+
+ it("resets to the default dir when passed null", async () => {
+ const manager = new RecordingsDirManager(userDataDir, () => false);
+ await manager.setDir(path.join(userDataDir, "custom-recordings"));
+
+ const resolved = await manager.setDir(null);
+
+ expect(resolved).toBe(manager.defaultDir);
+ expect(manager.getInfo().isDefault).toBe(true);
+ });
+
+ it("refuses to switch while a recording is in progress", async () => {
+ const manager = new RecordingsDirManager(userDataDir, () => true);
+ const before = manager.dir;
+
+ await expect(manager.setDir(path.join(userDataDir, "custom-recordings"))).rejects.toThrow(
+ /recording is in progress/i,
+ );
+ expect(manager.dir).toBe(before);
+ });
+
+ it("persists the choice so a fresh manager picks it up", async () => {
+ const customDir = path.join(userDataDir, "custom-recordings");
+ const manager = new RecordingsDirManager(userDataDir, () => false);
+ await manager.setDir(customDir);
+
+ const reloaded = new RecordingsDirManager(userDataDir, () => false);
+ expect(reloaded.dir).toBe(customDir);
+ });
+
+ // The core ordering fix: if persistence fails, the in-memory directory must
+ // stay on the old (already-saved) value rather than silently running on an
+ // unsaved one until restart.
+ it("does not update the live dir when persistence fails", async () => {
+ const manager = new RecordingsDirManager(userDataDir, () => false);
+ const originalDir = manager.dir;
+
+ const store = storeOf(manager);
+ vi.spyOn(store, "setCustomDir").mockRejectedValueOnce(new Error("disk full"));
+
+ await expect(manager.setDir(path.join(userDataDir, "custom-recordings"))).rejects.toThrow(
+ "disk full",
+ );
+ expect(manager.dir).toBe(originalDir);
+ });
+
+ // A recording that starts mid-switch (after the initial guard, during the
+ // mkdir/persist awaits) must not leave the manager pointed at a directory
+ // that was never actually committed — memory and disk must both roll back.
+ it("rolls back memory and disk if a recording starts during the persist await", async () => {
+ let recording = false;
+ const manager = new RecordingsDirManager(userDataDir, () => recording);
+ const originalDir = manager.dir;
+
+ const store = storeOf(manager);
+ const realSetCustomDir = store.setCustomDir.bind(store);
+ vi.spyOn(store, "setCustomDir").mockImplementation(async (...args: unknown[]) => {
+ recording = true;
+ return realSetCustomDir(...(args as [string | null]));
+ });
+
+ await expect(manager.setDir(path.join(userDataDir, "custom-recordings"))).rejects.toThrow(
+ /recording is in progress/i,
+ );
+ expect(manager.dir).toBe(originalDir);
+ expect(store.getCustomDir()).toBeNull();
+ });
+
+ it("serializes overlapping calls instead of interleaving their writes", async () => {
+ const manager = new RecordingsDirManager(userDataDir, () => false);
+ const dirA = path.join(userDataDir, "dir-a");
+ const dirB = path.join(userDataDir, "dir-b");
+
+ const [resultA, resultB] = await Promise.all([manager.setDir(dirA), manager.setDir(dirB)]);
+
+ // Whichever wins the race, the manager must land on exactly one of them —
+ // not a half-applied mix of both calls' state.
+ expect([dirA, dirB]).toContain(resultA);
+ expect(resultB).toBe(dirB);
+ expect(manager.dir).toBe(dirB);
+ });
+});
diff --git a/electron/recording/recordingsDirManager.ts b/electron/recording/recordingsDirManager.ts
new file mode 100644
index 000000000..ba77fd3e4
--- /dev/null
+++ b/electron/recording/recordingsDirManager.ts
@@ -0,0 +1,85 @@
+// Owns the mutable, persisted "where do recordings live" state so it can be
+// unit-tested without importing all of electron/main.ts (a top-level Electron
+// entrypoint with process-wide side effects — single-instance lock, tray,
+// menus — that a test has no business triggering).
+import fs from "node:fs/promises";
+import path from "node:path";
+import { RecordingsLocationStore } from "./recordingsLocationStore";
+
+export class RecordingsDirManager {
+ readonly defaultDir: string;
+ private readonly store: RecordingsLocationStore;
+ private readonly isRecording: () => boolean;
+ private current: string;
+ // Serializes setDir() calls (e.g. a doubled-up click) so two in-flight
+ // switches can't interleave their filesystem/persistence writes.
+ private pending: Promise<unknown> = Promise.resolve();
+
+ constructor(userDataPath: string, isRecording: () => boolean) {
+ this.defaultDir = path.join(userDataPath, "recordings");
+ this.store = new RecordingsLocationStore(userDataPath);
+ this.isRecording = isRecording;
+ this.current = this.store.getCustomDir() ?? this.defaultDir;
+ }
+
+ get dir(): string {
+ return this.current;
+ }
+
+ getInfo() {
+ return { path: this.current, isDefault: this.current === this.defaultDir };
+ }
+
+ async ensureExists(): Promise<void> {
+ await fs.mkdir(this.current, { recursive: true });
+ }
+
+ /**
+ * Switches where recordings are read from and written to, going forward.
+ * Pass `null` to reset to the default. Does not move any existing files —
+ * the old location is left untouched.
+ *
+ * Refuses to run while a recording is active: a capture in progress builds
+ * its output path from the current directory up front, so swapping it
+ * mid-take would split one session's video and manifest across two
+ * directories. The check runs both before and after the filesystem/persist
+ * awaits (rolling back the persisted value if the second check trips), which
+ * closes the window for a switch that started before a recording did. It
+ * does NOT close the reverse case — a recording that starts, computes its
+ * output path, and flips `isRecording` to true during this function's
+ * awaits — because recording-start in handlers.ts reads `RECORDINGS_DIR`
+ * directly and does not coordinate with this class. Fixing that fully means
+ * every native capture-start path taking the same lock; out of scope here
+ * (see PR discussion). In practice the window is one `fs.mkdir` + one small
+ * JSON write, and a settings change racing the exact instant a recording is
+ * being kicked off is an edge case, not the common "changed the folder
+ * mid-recording" mistake this guard exists to prevent.
+ */
+ async setDir(customDir: string | null): Promise<string> {
+ const run = this.pending.then(() => this.setDirUnserialized(customDir));
+ // Never let a rejection here poison the chain for the next caller.
+ this.pending = run.catch(() => undefined);
+ return run;
+ }
+
+ private async setDirUnserialized(customDir: string | null): Promise<string> {
+ if (this.isRecording()) {
+ throw new Error("Cannot change the recordings folder while a recording is in progress.");
+ }
+ const previousCustomDir = this.store.getCustomDir();
+ const resolved = customDir ? path.resolve(customDir) : this.defaultDir;
+ await fs.mkdir(resolved, { recursive: true });
+ // Persist before committing in-memory state: if this write fails, keep
+ // using the old (already-saved) directory rather than silently running
+ // on an unsaved one until restart.
+ await this.store.setCustomDir(customDir ? resolved : null);
+ if (this.isRecording()) {
+ // A recording started while the above awaited — undo the persisted
+ // change too, so disk and memory don't disagree about the directory.
+ await this.store.setCustomDir(previousCustomDir);
+ throw new Error("Cannot change the recordings folder while a recording is in progress.");
+ }
+ this.current = resolved;
+ return this.current;
+ }
+}
diff --git a/electron/recording/recordingsLocationStore.test.ts b/electron/recording/recordingsLocationStore.test.ts
new file mode 100644
index 000000000..3969aec38
--- /dev/null
+++ b/electron/recording/recordingsLocationStore.test.ts
@@ -0,0 +1,116 @@
+import fsPromises, { mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { RecordingsLocationStore } from "./recordingsLocationStore";
+
+describe("RecordingsLocationStore", () => {
+ let dir: string;
+
+ beforeEach(async () => {
+ dir = await mkdtemp(path.join(tmpdir(), "openscreen-recordings-location-"));
+ });
+
+ afterEach(async () => {
+ await rm(dir, { recursive: true, force: true });
+ });
+
+ it("has no custom dir before anything is saved", () => {
+ const store = new RecordingsLocationStore(dir);
+ expect(store.getCustomDir()).toBeNull();
+ });
+
+ it("persists a custom dir and reloads it in a fresh instance", async () => {
+ const store = new RecordingsLocationStore(dir);
+ const customDir = path.join(dir, "my-recordings");
+ await store.setCustomDir(customDir);
+ expect(store.getCustomDir()).toBe(customDir);
+
+ const reloaded = new RecordingsLocationStore(dir);
+ expect(reloaded.getCustomDir()).toBe(customDir);
+ });
+
+ it("clears the custom dir when set back to null", async () => {
+ const store = new RecordingsLocationStore(dir);
+ await store.setCustomDir(path.join(dir, "my-recordings"));
+ await store.setCustomDir(null);
+
+ const reloaded = new RecordingsLocationStore(dir);
+ expect(reloaded.getCustomDir()).toBeNull();
+ });
+
+ it("ignores an empty string left in the config file", async () => {
+ await writeFile(
+ path.join(dir, "recordings-location.json"),
+ JSON.stringify({ recordingsDir: "" }),
+ "utf8",
+ );
+ const store = new RecordingsLocationStore(dir);
+ expect(store.getCustomDir()).toBeNull();
+ });
+
+ it("ignores a relative path left in the config file", async () => {
+ await writeFile(
+ path.join(dir, "recordings-location.json"),
+ JSON.stringify({ recordingsDir: "relative/recordings" }),
+ "utf8",
+ );
+ const store = new RecordingsLocationStore(dir);
+ expect(store.getCustomDir()).toBeNull();
+ });
+
+ it("ignores a malformed config file", async () => {
+ await writeFile(path.join(dir, "recordings-location.json"), "not json", "utf8");
+ const store = new RecordingsLocationStore(dir);
+ expect(store.getCustomDir()).toBeNull();
+ });
+
+ it("writes valid JSON that round-trips through readFile", async () => {
+ const store = new RecordingsLocationStore(dir);
+ const customDir = path.join(dir, "my-recordings");
+ await store.setCustomDir(customDir);
+
+ const raw = await readFile(path.join(dir, "recordings-location.json"), "utf8");
+ expect(JSON.parse(raw)).toEqual({ recordingsDir: customDir });
+ });
+
+ // The atomicity fix: a crash or power loss can only ever be caught before
+ // the temp file exists or after the rename lands — never partway through
+ // recordings-location.json itself, since the write goes to a distinct
+ // temp path first.
+ it("writes through a temp file and leaves no temp file behind on success", async () => {
+ const store = new RecordingsLocationStore(dir);
+ await store.setCustomDir(path.join(dir, "my-recordings"));
+
+ const entries = await readdir(dir);
+ expect(entries).toEqual(["recordings-location.json"]);
+ });
+
+ // getCustomDir() must never report a directory that failed to reach disk —
+ // a caller (RecordingsDirManager's rollback path in particular) relies on
+ // this to reflect what was actually persisted.
+ it("does not report a new dir as current if the write fails", async () => {
+ const store = new RecordingsLocationStore(dir);
+ const renameSpy = vi.spyOn(fsPromises, "rename").mockRejectedValueOnce(new Error("disk full"));
+
+ await expect(store.setCustomDir(path.join(dir, "my-recordings"))).rejects.toThrow("disk full");
+ expect(store.getCustomDir()).toBeNull();
+
+ renameSpy.mockRestore();
+ });
+
+ // A failed write must not leave a .tmp-* file behind — repeated failures
+ // (e.g. a persistently full disk) would otherwise accumulate garbage in
+ // the user-data directory forever.
+ it("cleans up the temp file when the rename fails", async () => {
+ const store = new RecordingsLocationStore(dir);
+ const renameSpy = vi.spyOn(fsPromises, "rename").mockRejectedValueOnce(new Error("disk full"));
+
+ await expect(store.setCustomDir(path.join(dir, "my-recordings"))).rejects.toThrow("disk full");
+
+ const entries = await readdir(dir);
+ expect(entries).toEqual([]);
+
+ renameSpy.mockRestore();
+ });
+});
diff --git a/electron/recording/recordingsLocationStore.ts b/electron/recording/recordingsLocationStore.ts
new file mode 100644
index 000000000..390c249e9
--- /dev/null
+++ b/electron/recording/recordingsLocationStore.ts
@@ -0,0 +1,68 @@
+// Persists the user's chosen recordings folder across restarts. Stored next to
+// llm-config.json in userData rather than inside the recordings folder itself,
+// since the whole point is that folder can move.
+import { readFileSync } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+interface RecordingsLocationConfig {
+ recordingsDir: string | null;
+}
+
+export class RecordingsLocationStore {
+ private readonly configPath: string;
+ private config: RecordingsLocationConfig = { recordingsDir: null };
+
+ constructor(userDataPath: string) {
+ this.configPath = path.join(userDataPath, "recordings-location.json");
+ this.loadSync();
+ }
+
+ private loadSync(): void {
+ try {
+ const raw = readFileSync(this.configPath, "utf8");
+ const parsed = JSON.parse(raw);
+ const candidate = parsed.recordingsDir;
+ // An empty or relative string would make fs.mkdir("") fail at startup,
+ // or resolve recordings relative to the process's working directory —
+ // neither is a state a hand-edited or corrupted config file should be
+ // able to force. setRecordingsDir() only ever writes an absolute path.
+ this.config = {
+ recordingsDir:
+ typeof candidate === "string" && candidate.length > 0 && path.isAbsolute(candidate)
+ ? candidate
+ : null,
+ };
+ } catch {
+ this.config = { recordingsDir: null };
+ }
+ }
+
+ /** The user's custom folder, or null to use the default (userData/recordings). */
+ getCustomDir(): string | null {
+ return this.config.recordingsDir;
+ }
+
+ async setCustomDir(dir: string | null): Promise<void> {
+ // Build the next config but don't commit it to `this.config` until the
+ // write has actually landed — otherwise getCustomDir() could report a
+ // directory that was never persisted (e.g. RecordingsDirManager's
+ // rollback path reads this value expecting it to reflect disk).
+ const nextConfig: RecordingsLocationConfig = { recordingsDir: dir };
+ // Write-then-rename, not a direct write: fs.rename is atomic on the same
+ // filesystem, so a crash or power loss mid-write can never leave
+ // recordings-location.json truncated or malformed. Same pattern as
+ // mediaLinksRegistry.ts's writeRegistry().
+ const tmpPath = `${this.configPath}.tmp-${process.pid}-${Date.now()}`;
+ try {
+ await fs.writeFile(tmpPath, JSON.stringify(nextConfig, null, 2), "utf8");
+ await fs.rename(tmpPath, this.configPath);
+ this.config = nextConfig;
+ } catch (error) {
+ // Best-effort: don't let a cleanup failure hide the real error, and
+ // don't leave a stale .tmp-* file behind for every failed attempt.
+ await fs.rm(tmpPath, { force: true }).catch(() => undefined);
+ throw error;
+ }
+ }
+}
diff --git a/src/i18n/locales/ar/dialogs.json b/src/i18n/locales/ar/dialogs.json
index 405545261..e65a06b09 100644
--- a/src/i18n/locales/ar/dialogs.json
+++ b/src/i18n/locales/ar/dialogs.json
@@ -87,7 +87,8 @@
"videoFiles": "ملفات فيديو",
"audioFiles": "ملفات الصوت",
"openscreenProject": "مشروع OpenScreen",
- "allFiles": "جميع الملفات"
+ "allFiles": "جميع الملفات",
+ "selectRecordingsFolder": "اختر مجلد التسجيلات"
},
"recording": {
"lowDiskSpace": "لا توجد مساحة تخزين كافية لبدء التسجيل (لا يتوفر سوى {{availableMb}} ميجابايت). حرر بعض المساحة أو اختر مجلد تسجيلات آخر، ثم حاول مرة أخرى."
diff --git a/src/i18n/locales/cs/dialogs.json b/src/i18n/locales/cs/dialogs.json
index 83c04edc8..1f38c4897 100644
--- a/src/i18n/locales/cs/dialogs.json
+++ b/src/i18n/locales/cs/dialogs.json
@@ -87,7 +87,8 @@
"videoFiles": "Video soubory",
"audioFiles": "Zvukové soubory",
"openscreenProject": "Projekt OpenScreen",
- "allFiles": "Všechny soubory"
+ "allFiles": "Všechny soubory",
+ "selectRecordingsFolder": "Vybrat složku pro nahrávky"
},
"recording": {
"lowDiskSpace": "Nedostatek místa na disku pro zahájení nahrávání (volno pouze {{availableMb}} MB). Uvolněte místo nebo vyberte jinou složku pro nahrávky a zkuste to znovu."
diff --git a/src/i18n/locales/de/dialogs.json b/src/i18n/locales/de/dialogs.json
index 7081f5fde..7ad5f6d77 100644
--- a/src/i18n/locales/de/dialogs.json
+++ b/src/i18n/locales/de/dialogs.json
@@ -87,7 +87,8 @@
"videoFiles": "Videodateien",
"audioFiles": "Audiodateien",
"openscreenProject": "OpenScreen-Projekt",
- "allFiles": "Alle Dateien"
+ "allFiles": "Alle Dateien",
+ "selectRecordingsFolder": "Ordner für Aufnahmen auswählen"
},
"recording": {
"lowDiskSpace": "Nicht genügend Speicherplatz, um die Aufnahme zu starten (nur {{availableMb}} MB frei). Gib Speicherplatz frei oder wähle einen anderen Ordner für Aufnahmen und versuche es erneut."
diff --git a/src/i18n/locales/en/dialogs.json b/src/i18n/locales/en/dialogs.json
index 46eccd7f5..1f8e994c0 100644
--- a/src/i18n/locales/en/dialogs.json
+++ b/src/i18n/locales/en/dialogs.json
@@ -87,7 +87,8 @@
"videoFiles": "Video files",
"audioFiles": "Audio files",
"openscreenProject": "OpenScreen project",
- "allFiles": "All files"
+ "allFiles": "All files",
+ "selectRecordingsFolder": "Choose a recordings folder"
},
"recording": {
"lowDiskSpace": "Not enough disk space to start recording (only {{availableMb}} MB free). Free up space or choose a different recordings folder, then try again."
diff --git a/src/i18n/locales/es/dialogs.json b/src/i18n/locales/es/dialogs.json
index 5c0f98430..0c0621c94 100644
--- a/src/i18n/locales/es/dialogs.json
+++ b/src/i18n/locales/es/dialogs.json
@@ -87,7 +87,8 @@
"videoFiles": "Archivos de video",
"audioFiles": "Archivos de audio",
"openscreenProject": "Proyecto OpenScreen",
- "allFiles": "Todos los archivos"
+ "allFiles": "Todos los archivos",
+ "selectRecordingsFolder": "Seleccionar carpeta de grabaciones"
},
"recording": {
"lowDiskSpace": "No hay suficiente espacio en disco para iniciar la grabación (solo quedan {{availableMb}} MB libres). Libera espacio o elige otra carpeta de grabaciones e inténtalo de nuevo."
diff --git a/src/i18n/locales/fr/dialogs.json b/src/i18n/locales/fr/dialogs.json
index 94090d66a..22550fc72 100644
--- a/src/i18n/locales/fr/dialogs.json
+++ b/src/i18n/locales/fr/dialogs.json
@@ -87,7 +87,8 @@
"videoFiles": "Fichiers vidéo",
"audioFiles": "Fichiers audio",
"openscreenProject": "Projet OpenScreen",
- "allFiles": "Tous les fichiers"
+ "allFiles": "Tous les fichiers",
+ "selectRecordingsFolder": "Sélectionner le dossier des enregistrements"
},
"recording": {
"lowDiskSpace": "Espace disque insuffisant pour démarrer l'enregistrement (seulement {{availableMb}} Mo disponibles). Libérez de l'espace ou choisissez un autre dossier d'enregistrements, puis réessayez."
diff --git a/src/i18n/locales/it/dialogs.json b/src/i18n/locales/it/dialogs.json
index 2825c897a..e345dc61b 100644
--- a/src/i18n/locales/it/dialogs.json
+++ b/src/i18n/locales/it/dialogs.json
@@ -87,7 +87,8 @@
"videoFiles": "File video",
"audioFiles": "File audio",
"openscreenProject": "Progetto OpenScreen",
- "allFiles": "Tutti i file"
+ "allFiles": "Tutti i file",
+ "selectRecordingsFolder": "Seleziona cartella registrazioni"
},
"recording": {
"lowDiskSpace": "Spazio su disco insufficiente per avviare la registrazione (solo {{availableMb}} MB disponibili). Libera spazio o scegli un'altra cartella per le registrazioni, quindi riprova."
diff --git a/src/i18n/locales/ja-JP/dialogs.json b/src/i18n/locales/ja-JP/dialogs.json
index 0c97560c1..d81237246 100644
--- a/src/i18n/locales/ja-JP/dialogs.json
+++ b/src/i18n/locales/ja-JP/dialogs.json
@@ -87,7 +87,8 @@
"videoFiles": "動画ファイル",
"audioFiles": "オーディオファイル",
"openscreenProject": "OpenScreen プロジェクト",
- "allFiles": "すべてのファイル"
+ "allFiles": "すべてのファイル",
+ "selectRecordingsFolder": "録画フォルダーを選択"
},
"recording": {
"lowDiskSpace": "録画を開始するのに十分なディスク容量がありません(空き容量は{{availableMb}} MBのみ)。空き容量を確保するか、別の録画フォルダーを選択してから、もう一度お試しください。"
diff --git a/src/i18n/locales/ko-KR/dialogs.json b/src/i18n/locales/ko-KR/dialogs.json
index 747a082d9..4324f1c63 100644
--- a/src/i18n/locales/ko-KR/dialogs.json
+++ b/src/i18n/locales/ko-KR/dialogs.json
@@ -87,7 +87,8 @@
"videoFiles": "비디오 파일",
"audioFiles": "오디오 파일",
"openscreenProject": "OpenScreen 프로젝트",
- "allFiles": "모든 파일"
+ "allFiles": "모든 파일",
+ "selectRecordingsFolder": "녹화 폴더 선택"
},
"recording": {
"lowDiskSpace": "녹화를 시작할 디스크 공간이 부족합니다(사용 가능한 공간 {{availableMb}}MB). 공간을 확보하거나 다른 녹화 폴더를 선택한 후 다시 시도하세요."
diff --git a/src/i18n/locales/pt-BR/dialogs.json b/src/i18n/locales/pt-BR/dialogs.json
index 6a9563e00..33c744eb1 100644
--- a/src/i18n/locales/pt-BR/dialogs.json
+++ b/src/i18n/locales/pt-BR/dialogs.json
@@ -87,7 +87,8 @@
"videoFiles": "Arquivos de Vídeo",
"audioFiles": "Arquivos de áudio",
"openscreenProject": "Projeto OpenScreen",
- "allFiles": "Todos os Arquivos"
+ "allFiles": "Todos os Arquivos",
+ "selectRecordingsFolder": "Selecionar pasta de gravações"
},
"recording": {
"lowDiskSpace": "Espaço em disco insuficiente para iniciar a gravação (apenas {{availableMb}} MB livres). Libere espaço ou escolha outra pasta de gravações e tente novamente."
diff --git a/src/i18n/locales/ru/dialogs.json b/src/i18n/locales/ru/dialogs.json
index 156049987..c25a4e035 100644
--- a/src/i18n/locales/ru/dialogs.json
+++ b/src/i18n/locales/ru/dialogs.json
@@ -87,7 +87,8 @@
"videoFiles": "Видеофайлы",
"audioFiles": "Аудиофайлы",
"openscreenProject": "Проект OpenScreen",
- "allFiles": "Все файлы"
+ "allFiles": "Все файлы",
+ "selectRecordingsFolder": "Выбрать папку для записей"
},
"recording": {
"lowDiskSpace": "Недостаточно места на диске для начала записи (доступно только {{availableMb}} МБ). Освободите место или выберите другую папку для записей и повторите попытку."
diff --git a/src/i18n/locales/tr/dialogs.json b/src/i18n/locales/tr/dialogs.json
index 9cc1f95ae..5dcdb4705 100644
--- a/src/i18n/locales/tr/dialogs.json
+++ b/src/i18n/locales/tr/dialogs.json
@@ -87,7 +87,8 @@
"videoFiles": "Video Dosyaları",
"audioFiles": "Ses dosyaları",
"openscreenProject": "OpenScreen Projesi",
- "allFiles": "Tüm Dosyalar"
+ "allFiles": "Tüm Dosyalar",
+ "selectRecordingsFolder": "Kayıt klasörünü seç"
},
"recording": {
"lowDiskSpace": "Kaydı başlatmak için yeterli disk alanı yok (yalnızca {{availableMb}} MB boş). Alan boşaltın veya farklı bir kayıt klasörü seçip tekrar deneyin."
diff --git a/src/i18n/locales/vi/dialogs.json b/src/i18n/locales/vi/dialogs.json
index 6bb2d313c..e6c130389 100644
--- a/src/i18n/locales/vi/dialogs.json
+++ b/src/i18n/locales/vi/dialogs.json
@@ -87,7 +87,8 @@
"videoFiles": "Tệp Video",
"audioFiles": "Tệp âm thanh",
"openscreenProject": "Dự án OpenScreen",
- "allFiles": "Tất cả các tệp"
+ "allFiles": "Tất cả các tệp",
+ "selectRecordingsFolder": "Chọn thư mục bản ghi"
},
"recording": {
"lowDiskSpace": "Không đủ dung lượng ổ đĩa để bắt đầu quay (chỉ còn {{availableMb}} MB trống). Hãy giải phóng dung lượng hoặc chọn thư mục bản ghi khác rồi thử lại."
diff --git a/src/i18n/locales/zh-CN/dialogs.json b/src/i18n/locales/zh-CN/dialogs.json
index 2d6b3caac..1683c5776 100644
--- a/src/i18n/locales/zh-CN/dialogs.json
+++ b/src/i18n/locales/zh-CN/dialogs.json
@@ -87,7 +87,8 @@
"videoFiles": "视频文件",
"audioFiles": "音频文件",
"openscreenProject": "OpenScreen 项目",
- "allFiles": "所有文件"
+ "allFiles": "所有文件",
+ "selectRecordingsFolder": "选择录制文件夹"
},
"recording": {
"lowDiskSpace": "磁盘空间不足,无法开始录制(仅剩 {{availableMb}} MB 可用空间)。请释放空间或选择其他录制文件夹,然后重试。"
diff --git a/src/i18n/locales/zh-TW/dialogs.json b/src/i18n/locales/zh-TW/dialogs.json
index dee723462..8ee82a4cd 100644
--- a/src/i18n/locales/zh-TW/dialogs.json
+++ b/src/i18n/locales/zh-TW/dialogs.json
@@ -87,7 +87,8 @@
"videoFiles": "影片檔案",
"audioFiles": "音訊檔案",
"openscreenProject": "OpenScreen 專案",
- "allFiles": "所有檔案"
+ "allFiles": "所有檔案",
+ "selectRecordingsFolder": "選擇錄製資料夾"
},
"recording": {
"lowDiskSpace": "磁碟空間不足,無法開始錄製(僅剩 {{availableMb}} MB 可用空間)。請釋放空間或選擇其他錄製資料夾,然後再試一次。"