The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
feat(settings): import JetBrains settings.zip (colour schemes, editor font and options) (#1709)
LU XIANGRUI1ab4edc0d773
diff --git a/crates/ide-workspace/Cargo.toml b/crates/ide-workspace/Cargo.tomlindex 5ebf071f4..92e264dc4 100644--- a/crates/ide-workspace/Cargo.toml+++ b/crates/ide-workspace/Cargo.toml@@ -22,8 +22,8 @@ tracing.workspace = truetempfile.workspace = trueglobset.workspace = trueuuid.workspace = true+zip.workspace = true[dev-dependencies]tempfile.workspace = trueencoding_rs.workspace = true-zip.workspace = truediff --git a/crates/ide-workspace/src/settings.rs b/crates/ide-workspace/src/settings.rsindex 8327f134f..bc3b72603 100644--- a/crates/ide-workspace/src/settings.rs+++ b/crates/ide-workspace/src/settings.rs@@ -316,6 +316,48 @@ impl SettingsStore {}}+/// A JetBrains IDE's File › Manage IDE Settings › Export Settings… archive: every+/// entry name, and the text of the entries OpenIDEA maps (the frontend does the mapping).+#[derive(serde::Serialize, specta::Type)]+#[serde(rename_all = "camelCase")]+pub struct JetBrainsSettings {+ pub entries: Vec<String>,+ /// Entry name → text, for `colors/*.icls` and the `options/*.xml` files OpenIDEA reads.+ pub files: BTreeMap<String, String>,+}++const JETBRAINS_MARKER: &str = "IntelliJ IDEA Global Settings";+const JETBRAINS_OPTIONS: [&str; 4] =+ ["options/editor-font.xml", "options/colors.scheme.xml", "options/editor.xml", "options/ide.general.xml"];+const JETBRAINS_MAX_TEXT: u64 = 4 << 20;++pub fn read_jetbrains_settings(path: &Path) -> IdeResult<JetBrainsSettings> {+ use std::io::Read;+ let not_jetbrains = || IdeError::invalid("not a JetBrains settings archive");+ let mut archive = zip::ZipArchive::new(std::fs::File::open(path)?).map_err(|_| not_jetbrains())?;+ let mut entries = Vec::with_capacity(archive.len());+ let mut files = BTreeMap::new();+ for i in 0..archive.len() {+ let entry = archive.by_index(i).map_err(|_| not_jetbrains())?;+ let name = entry.name().map_err(|_| not_jetbrains())?.into_owned();+ let wanted = JETBRAINS_OPTIONS.contains(&name.as_str())+ || name.strip_prefix("colors/").is_some_and(|n| !n.contains('/') && n.ends_with(".icls"));+ if wanted {+ let mut text = String::new();+ entry+ .take(JETBRAINS_MAX_TEXT)+ .read_to_string(&mut text)+ .map_err(|e| IdeError::invalid(format!("{name}: {e}")))?;+ files.insert(name.clone(), text);+ }+ entries.push(name);+ }+ if !entries.iter().any(|e| e == JETBRAINS_MARKER) {+ return Err(not_jetbrains());+ }+ Ok(JetBrainsSettings { entries, files })+}+const BUNDLE_FORMAT: &str = "openidea-settings";const BUNDLE_VERSION: u32 = 1;@@ -546,6 +588,38 @@ mod tests {assert_eq!(target.effective().editor.font_size, 17.0);}+ #[test]+ fn reads_jetbrains_settings_archives() {+ use std::io::Write;+ let tmp = tempfile::tempdir().unwrap();+ let write = |name: &str, entries: &[(&str, &str)]| {+ let path = tmp.path().join(name);+ let mut zip = zip::ZipWriter::new(std::fs::File::create(&path).unwrap());+ for (entry, text) in entries {+ zip.start_file(*entry, zip::write::SimpleFileOptions::default()).unwrap();+ zip.write_all(text.as_bytes()).unwrap();+ }+ zip.finish().unwrap();+ path+ };+ let ok = write(+ "settings.zip",+ &[+ (JETBRAINS_MARKER, ""),+ ("colors/_@user_Darcula.icls", "<scheme name=\"_@user_Darcula\"/>"),+ ("options/editor-font.xml", "<application/>"),+ ("options/vcs.xml", "<application/>"),+ ("keymaps/macOS.xml", "<keymap/>"),+ ],+ );+ let read = read_jetbrains_settings(&ok).unwrap();+ assert_eq!(read.entries.len(), 5);+ assert_eq!(read.files.keys().collect::<Vec<_>>(), ["colors/_@user_Darcula.icls", "options/editor-font.xml"]);+ assert!(read_jetbrains_settings(&write("other.zip", &[("options/editor.xml", "")])).is_err());+ std::fs::write(tmp.path().join("plain.zip"), "not a zip").unwrap();+ assert!(read_jetbrains_settings(&tmp.path().join("plain.zip")).is_err());+ }+#[test]fn main_toolbar_can_be_set_and_reset() {let tmp = tempfile::tempdir().unwrap();diff --git a/src-tauri/src/commands/app.rs b/src-tauri/src/commands/app.rsindex a817273da..3774611e4 100644--- a/src-tauri/src/commands/app.rs+++ b/src-tauri/src/commands/app.rs@@ -237,6 +237,15 @@ pub async fn settings_import(window: Window, state: State<'_, AppState>, path: POk(SettingsImport { settings, storage })}+/// Import Settings… with a JetBrains `settings.zip`: reads it; the frontend maps and applies it.+#[tauri::command]+#[specta::specta]+pub async fn settings_read_jetbrains(path: PathBuf) -> IdeResult<ide_workspace::settings::JetBrainsSettings> {+ tauri::async_runtime::spawn_blocking(move || ide_workspace::settings::read_jetbrains_settings(&path))+ .await+ .map_err(|e| IdeError::internal(e.to_string()))?+}+/// Effective source / test / resource / excluded roots of the window's project:/// auto-detected from build files, overridden by Settings › Project Structure.#[tauri::command]diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rsindex d42a117fa..ecb5fd3a8 100644--- a/src-tauri/src/commands/mod.rs+++ b/src-tauri/src/commands/mod.rs@@ -98,6 +98,7 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {app::settings_set,app::settings_export,app::settings_import,+ app::settings_read_jetbrains,app::project_rename,app::project_roots,app::cancel_request,diff --git a/src/bindings.ts b/src/bindings.tsindex 06f7b2cfe..91103e03b 100644--- a/src/bindings.ts+++ b/src/bindings.ts@@ -81,6 +81,8 @@ export const commands = {settingsExport: (path: string, storage: { [key in string]: string }) => typedError<null, IdeError>(__TAURI_INVOKE("settings_export", { path, storage })),/** Import Settings…: replaces the global settings with the file's; every window re-reads them. */settingsImport: (path: string) => typedError<SettingsImport_Serialize, IdeError>(__TAURI_INVOKE("settings_import", { path })),+ /** Import Settings… with a JetBrains `settings.zip`: reads it; the frontend maps and applies it. */+ settingsReadJetbrains: (path: string) => typedError<JetBrainsSettings, IdeError>(__TAURI_INVOKE("settings_read_jetbrains", { path })),/*** File › Rename Project…: the project's display name (title bar, recent* projects); an empty `name` restores the folder name. Stored in the project's settings.@@ -4919,6 +4921,16 @@ export type JdkVendor = {name: string,};+/**+ * A JetBrains IDE's File › Manage IDE Settings › Export Settings… archive: every+ * entry name, and the text of the entries OpenIDEA maps (the frontend does the mapping).+ */+export type JetBrainsSettings = {+ entries: string[],+ /** Entry name → text, for `colors/*.icls` and the `options/*.xml` files OpenIDEA reads. */+ files: { [key in string]: string },+};+export type JvmFilePresentation = {path: string,presentation: JvmPresentation,diff --git a/src/features/app/__tests__/jetbrainsSettings.test.ts b/src/features/app/__tests__/jetbrainsSettings.test.tsnew file mode 100644index 000000000..cee640330--- /dev/null+++ b/src/features/app/__tests__/jetbrainsSettings.test.ts@@ -0,0 +1,130 @@+import { describe, expect, it } from "vitest";+import { planJetBrainsImport } from "../jetbrainsSettings";++const icls = (name: string) =>+ `<scheme name="${name}" version="142" parent_scheme="Darcula"><attributes>` ++ `<option name="DEFAULT_KEYWORD"><value><option name="FOREGROUND" value="cc856b" /></value></option>` ++ `</attributes></scheme>`;++const component = (name: string, options: Record<string, string>) =>+ `<application><component name="${name}">${Object.entries(options)+ .map(([k, v]) => `<option name="${k}" value="${v}" />`)+ .join("")}</component></application>`;++const editor = { fontSize: 13, customSchemes: {}, colorOverrides: {} };++/** A WebStorm export, trimmed to what the import reads. */+const webstorm = {+ entries: [+ "IntelliJ IDEA Global Settings",+ "colors/_@user_Darcula.icls",+ "options/editor-font.xml",+ "options/colors.scheme.xml",+ "options/editor.xml",+ "options/ide.general.xml",+ "options/vcs.xml",+ "keymaps/macOS.xml",+ "codestyles/Default.xml",+ "inspection/Default.xml",+ "installed.txt",+ ],+ files: {+ "colors/_@user_Darcula.icls": icls("_@user_Darcula"),+ "options/colors.scheme.xml":+ '<application><component name="EditorColorsManagerImpl"><global_color_scheme name="_@user_Darcula" /></component></application>',+ "options/editor-font.xml": component("DefaultFont", {+ FONT_SIZE: "17",+ FONT_FAMILY: "JetBrains Maple Mono",+ USE_LIGATURES: "true",+ }),+ "options/editor.xml": component("EditorSettings", {+ USE_SOFT_WRAPS: "CONSOLE",+ STRIP_TRAILING_SPACES: "Whole",+ IS_ENSURE_NEWLINE_AT_EOF: "true",+ SHOW_STICKY_LINES: "false",+ }),+ "options/ide.general.xml": component("GeneralSettings", {+ showTipsOnStartup: "false",+ confirmExit: "false",+ }),+ },+};++describe("planJetBrainsImport", () => {+ it("maps a WebStorm export to the settings it has, and lists what is left out", () => {+ const plan = planJetBrainsImport(webstorm, editor);+ const writes = Object.fromEntries(plan.writes);+ const schemes = writes["editor.customSchemes"] as Record<string, { name: string; parent: string }>;+ const [id, scheme] = Object.entries(schemes)[0]!;+ expect(scheme).toMatchObject({ name: "Darcula", parent: "dark" });+ expect(writes).toEqual({+ "editor.customSchemes": schemes,+ "editor.colorScheme": id,+ "editor.fontFamily": "JetBrains Maple Mono",+ "editor.fontSize": 17,+ "editor.ligatures": true,+ "files.trimTrailingWhitespace": true,+ "editor.general.stripTrailingScope": "all",+ "files.ensureFinalNewline": true,+ "editor.stickyScroll": false,+ "editor.softWrap": false,+ "general.confirmExit": false,+ });+ expect(plan.rows).toContainEqual({+ label: "Color Scheme",+ value: "Darcula",+ });+ expect(plan.rows).toContainEqual({ label: "Size", value: "17" });+ expect(plan.rows).toContainEqual({+ label: "Remove trailing spaces on:",+ value: "All lines",+ });+ expect(plan.skipped).toEqual(["Keymap", "Code Style", "Inspections", "Plugins"]);+ expect(plan.invalid).toEqual([]);+ });++ it("writes only the keys present, and derives the line height from IDEA's spacing", () => {+ const plan = planJetBrainsImport(+ {+ entries: [],+ files: {+ "options/editor-font.xml": component("DefaultFont", {+ LINE_SPACING: "1.5",+ }),+ "options/editor.xml": component("EditorSettings", {+ USE_SOFT_WRAPS: "MAIN_EDITOR,CONSOLE",+ STRIP_TRAILING_SPACES: "None",+ }),+ },+ },+ editor,+ );+ expect(plan.writes).toEqual([+ ["editor.lineHeight", 20],+ ["files.trimTrailingWhitespace", false],+ ["editor.softWrap", true],+ ]);+ expect(plan.skipped).toEqual([]);+ });++ it("re-importing replaces the earlier copy of a scheme and drops its edits", () => {+ const first = Object.fromEntries(planJetBrainsImport(webstorm, editor).writes);+ const customs = first["editor.customSchemes"] as typeof editor.customSchemes;+ const [id] = Object.keys(customs);+ const again = planJetBrainsImport(webstorm, {+ ...editor,+ customSchemes: customs,+ colorOverrides: { [id!]: { keyword: { bold: true } }, other: {} },+ });+ const writes = Object.fromEntries(again.writes);+ expect(Object.keys(writes["editor.customSchemes"] as object)).toEqual([id]);+ expect(writes["editor.colorOverrides"]).toEqual({ other: {} });+ expect(writes["editor.colorScheme"]).toBe(id);+ });++ it("skips colour schemes that cannot be read", () => {+ const plan = planJetBrainsImport({ entries: [], files: { "colors/broken.icls": "<nope" } }, editor);+ expect(plan.invalid).toEqual(["broken.icls"]);+ expect(plan.writes).toEqual([]);+ });+});diff --git a/src/features/app/app.module.css b/src/features/app/app.module.cssindex e62740c74..bcbf2614c 100644--- a/src/features/app/app.module.css+++ b/src/features/app/app.module.css@@ -214,3 +214,24 @@font-size: var(--fs-small);overflow-wrap: anywhere;}++/* Import Settings… › JetBrains settings.zip confirmation */+.importSummary {+ display: flex;+ flex-direction: column;+ gap: 8px;+}+.importList {+ margin: 0;+ display: grid;+ grid-template-columns: max-content 1fr;+ gap: 2px 16px;+}+.importList dt {+ color: var(--fg-muted);+}+.importList dd {+ margin: 0;+ color: var(--fg-strong);+ overflow-wrap: anywhere;+}diff --git a/src/features/app/jetbrainsSettings.tsx b/src/features/app/jetbrainsSettings.tsxnew file mode 100644index 000000000..c7a3d109b--- /dev/null+++ b/src/features/app/jetbrainsSettings.tsx@@ -0,0 +1,198 @@+/**+ * Import Settings… with a JetBrains `settings.zip`: maps the archive's colour+ * schemes and the editor / general options OpenIDEA has to settings writes, after+ * a confirmation listing them. Only keys present in the archive are written+ * (JetBrains leaves defaults out). Keymaps, code styles and the rest are listed+ * as not imported.+ */+import { Fragment } from "react";+import type { JetBrainsSettings } from "@/bindings";+import { customSchemes } from "@/platform/colorScheme";+import { tx } from "@/platform/i18n";+import { importScheme, parseIcls } from "@/platform/icls";+import { call, commands } from "@/platform/ipc";+import { useProject } from "@/platform/project";+import { notifications } from "@/workbench/contributions";+import { ask } from "@/workbench/messages";+import styles from "./app.module.css";++export interface JetBrainsImportPlan {+ /** Settings writes, in order: `settingsSet("global", key, JSON.stringify(value))`. */+ writes: [key: string, value: unknown][];+ /** What the confirmation lists (translated): the setting and its imported value. */+ rows: { label: string; value: string }[];+ /** Categories present in the archive that are not imported (translated). */+ skipped: string[];+ /** `.icls` files that could not be read. */+ invalid: string[];+}++interface EditorState {+ fontSize: number | null;+ customSchemes: unknown;+ colorOverrides: Record<string, unknown>;+}++const USER_PREFIX = "_@user_";++/**+ * `<option name value>` of `<component name>`; empty when the file or component is+ * absent. With `tag`, the `name` of that child element instead, under key "".+ */+function options(xml: string | undefined, component: string, tag?: string): Map<string, string> {+ const out = new Map<string, string>();+ if (!xml) return out;+ const doc = new DOMParser().parseFromString(xml, "application/xml");+ if (doc.querySelector("parsererror")) return out;+ for (const c of Array.from(doc.documentElement.children))+ if (c.tagName === "component" && c.getAttribute("name") === component)+ for (const o of Array.from(c.children)) {+ const name = o.getAttribute("name");+ const value = o.getAttribute("value");+ if (tag && o.tagName === tag && name !== null) out.set("", name);+ else if (!tag && o.tagName === "option" && name && value !== null) out.set(name, value);+ }+ return out;+}++const bool = (v: string | undefined) => (v === undefined ? undefined : v === "true");+const num = (v: string | undefined) => {+ const n = v === undefined ? NaN : Number(v);+ return Number.isFinite(n) && n > 0 ? n : undefined;+};++const onOff = (v: boolean) => (v ? tx("On") : tx("Off"));++export function planJetBrainsImport(bundle: JetBrainsSettings, editor: EditorState): JetBrainsImportPlan {+ const plan: JetBrainsImportPlan = { writes: [], rows: [], skipped: [], invalid: [] };+ const add = (key: string, value: string | number | boolean | undefined, label: string, shown?: string) => {+ if (value === undefined) return;+ plan.writes.push([key, value]);+ plan.rows.push({ label, value: shown ?? (typeof value === "boolean" ? onOff(value) : String(value)) });+ };++ let customs = customSchemes(editor.customSchemes);+ let overrides = editor.colorOverrides;+ const imported = new Map<string, string>(); // name in the .icls → scheme id+ for (const [file, text] of Object.entries(bundle.files)) {+ if (!file.startsWith("colors/")) continue;+ let parsed;+ try {+ parsed = parseIcls(text);+ } catch {+ plan.invalid.push(file.slice("colors/".length));+ continue;+ }+ const original = parsed.scheme.name;+ const name = original.startsWith(USER_PREFIX) ? original.slice(USER_PREFIX.length) : original;+ // Overwrites an earlier import of the same scheme instead of adding "Name (2)".+ const next = importScheme(customs, { ...parsed.scheme, name }, true);+ customs = next.customs;+ if (overrides[next.id]) overrides = Object.fromEntries(Object.entries(overrides).filter(([id]) => id !== next.id));+ imported.set(original, next.id);+ plan.rows.push({ label: tx("Color Scheme"), value: customs[next.id]?.name ?? name });+ }+ if (imported.size) {+ plan.writes.push(["editor.customSchemes", customs]);+ if (overrides !== editor.colorOverrides) plan.writes.push(["editor.colorOverrides", overrides]);+ const global = options(bundle.files["options/colors.scheme.xml"], "EditorColorsManagerImpl", "global_color_scheme");+ const id = imported.get(global.get("") ?? "");+ if (id) add("editor.colorScheme", id, tx("Current color scheme"), customs[id]?.name);+ }++ const font = options(bundle.files["options/editor-font.xml"], "DefaultFont");+ add("editor.fontFamily", font.get("FONT_FAMILY")?.trim() || undefined, tx("Font"));+ const size = num(font.get("FONT_SIZE"));+ add("editor.fontSize", size, tx("Size"));+ const spacing = num(font.get("LINE_SPACING"));+ const base = size ?? editor.fontSize;+ add("editor.lineHeight", spacing && base ? Math.round(base * spacing) : undefined, tx("Line height"));+ add("editor.ligatures", bool(font.get("USE_LIGATURES")), tx("Enable ligatures"));++ const ed = options(bundle.files["options/editor.xml"], "EditorSettings");+ const strip = ed.get("STRIP_TRAILING_SPACES"); // None | Changed | Whole+ if (strip === "Changed" || strip === "Whole") {+ const scope = strip === "Whole" ? "all" : "modified";+ plan.writes.push(["files.trimTrailingWhitespace", true]);+ add(+ "editor.general.stripTrailingScope",+ scope,+ tx("Remove trailing spaces on:"),+ tx(strip === "Whole" ? "All lines" : "Modified lines"),+ );+ } else if (strip === "None") add("files.trimTrailingWhitespace", false, tx("Remove trailing spaces on:"));+ add(+ "files.ensureFinalNewline",+ bool(ed.get("IS_ENSURE_NEWLINE_AT_EOF")),+ tx("Ensure every saved file ends with a line break"),+ );+ add("editor.stickyScroll", bool(ed.get("SHOW_STICKY_LINES")), tx("Show sticky lines while scrolling"));+ add("editor.showWhitespace", bool(ed.get("IS_WHITESPACES_SHOWN")), tx("Show whitespaces"));+ // A comma-separated list of places: MAIN_EDITOR, CONSOLE, PREVIEW.+ const wraps = ed.get("USE_SOFT_WRAPS");+ add(+ "editor.softWrap",+ wraps === undefined ? undefined : wraps.split(",").includes("MAIN_EDITOR"),+ tx("Soft-wrap files"),+ );++ const general = options(bundle.files["options/ide.general.xml"], "GeneralSettings");+ add("general.confirmExit", bool(general.get("confirmExit")), tx("Confirm before exiting the IDE"));++ const has = (prefix: string) => bundle.entries.some((e) => e.startsWith(prefix));+ if (has("keymaps/")) plan.skipped.push(tx("Keymap"));+ if (has("codestyles/")) plan.skipped.push(tx("Code Style"));+ if (has("templates/")) plan.skipped.push(tx("Live templates"));+ if (has("inspection/")) plan.skipped.push(tx("Inspections"));+ if (has("installed.txt")) plan.skipped.push(tx("Plugins"));+ return plan;+}++function Summary({ plan }: { plan: JetBrainsImportPlan }) {+ const left = [...plan.skipped, ...plan.invalid];+ return (+ <div className={styles.importSummary}>+ <div>{tx("These settings will be imported:")}</div>+ <dl className={styles.importList}>+ {plan.rows.map((row, i) => (+ <Fragment key={i}>+ <dt>{row.label}</dt>+ <dd>{row.value}</dd>+ </Fragment>+ ))}+ </dl>+ {left.length > 0 && (+ <div>+ {tx("Not imported:")} {left.join(", ")}+ </div>+ )}+ </div>+ );+}++/** Reads `path`, asks, then writes the mapped settings to the global layer. */+export async function importJetBrainsSettings(path: string) {+ const bundle = await call(commands.settingsReadJetbrains(path));+ const { editor } = await commands.settingsGetGlobal();+ const plan = planJetBrainsImport(bundle, editor);+ if (!plan.writes.length) {+ notifications().notify({+ level: "warning",+ title: "No settings OpenIDEA can import were found in this archive",+ key: "app.settingsImport",+ });+ return;+ }+ const { button } = await ask({+ title: tx("Import JetBrains Settings"),+ body: <Summary plan={plan} />,+ buttons: [{ id: "import", label: tx("Import"), primary: true }],+ width: 520,+ });+ if (button !== "import") return;+ let settings = useProject.getState().settings;+ for (const [key, value] of plan.writes)+ settings = await call(commands.settingsSet("global", key, JSON.stringify(value)));+ useProject.setState({ settings });+ notifications().notify({ level: "info", title: "Settings imported", body: path, key: "app.settingsImport" });+}diff --git a/src/features/app/projectActions.ts b/src/features/app/projectActions.tsindex 1308ed2e1..29d1be9b0 100644--- a/src/features/app/projectActions.ts+++ b/src/features/app/projectActions.ts@@ -9,6 +9,7 @@ import { call, commands, isTauri } from "@/platform/ipc";import { useProject } from "@/platform/project";import { notifications, registerEditorBanner } from "@/workbench/contributions";import { promptInput } from "@/workbench/inputDialogs";+import { importJetBrainsSettings } from "./jetbrainsSettings";import { showNewProject } from "./NewProject";import { tx } from "@/platform/i18n";@@ -80,11 +81,12 @@ async function importSettings() {const picked = await open({title: "Import Settings",multiple: false,- filters: [{ name: "OpenIDEA settings", extensions: ["json"] }],+ filters: [{ name: "OpenIDEA or JetBrains settings", extensions: ["json", "zip"] }],});const path = Array.isArray(picked) ? picked[0] : picked;if (!path) return;try {+ if (/\.zip$/i.test(path)) return await importJetBrainsSettings(path);const result = await call(commands.settingsImport(path));for (const [key, value] of Object.entries(result.storage))if (isExported(key))diff --git a/src/platform/locales/text/en.json b/src/platform/locales/text/en.jsonindex c362bdcaa..f4911f285 100644--- a/src/platform/locales/text/en.json+++ b/src/platform/locales/text/en.json@@ -1,4 +1,10 @@{+ "OpenIDEA or JetBrains settings": "OpenIDEA or JetBrains settings",+ "Import JetBrains Settings": "Import JetBrains Settings",+ "These settings will be imported:": "These settings will be imported:",+ "Not imported:": "Not imported:",+ "Current color scheme": "Current color scheme",+ "No settings OpenIDEA can import were found in this archive": "No settings OpenIDEA can import were found in this archive","Overwrite existing branch": "Overwrite existing branch","Branch '{n}' already exists": "Branch '{n}' already exists","Cannot copy reference": "Cannot copy reference",diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.jsonindex cb4e3df66..2cb6af139 100644--- a/src/platform/locales/text/zh.json+++ b/src/platform/locales/text/zh.json@@ -3016,6 +3016,12 @@"Settings imported": "设置已导入","Restart to apply imported templates, macros, layouts and view options.": "重启以应用导入的模板、宏、布局和视图选项。","Cannot import settings": "无法导入设置",+ "OpenIDEA or JetBrains settings": "OpenIDEA 或 JetBrains 设置",+ "Import JetBrains Settings": "导入 JetBrains 设置",+ "These settings will be imported:": "将导入以下设置:",+ "Not imported:": "不导入:",+ "Current color scheme": "当前配色方案",+ "No settings OpenIDEA can import were found in this archive": "此压缩包中没有 OpenIDEA 可以导入的设置","Rename Project": "重命名项目","Rename Project…": "重命名项目…","New project name:": "新项目名称:",