加入完整 mdict 查询功能

imradv3.sln

@@ -21,6 +21,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ScreenGrab", "src\ScreenGra
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ScreenGrab.Sample", "src\ScreenGrab.Sample\ScreenGrab.Sample.csproj", "{34691787-AE69-7042-FB4F-9EE5535A4D5A}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EchoDictLib", "src\EchoDictLib\EchoDictLib.csproj", "{014E5B08-E0B3-44D3-9AE3-510EE0691604}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -139,6 +141,18 @@ Global
 		{34691787-AE69-7042-FB4F-9EE5535A4D5A}.Release|x64.Build.0 = Release|Any CPU
 		{34691787-AE69-7042-FB4F-9EE5535A4D5A}.Release|x86.ActiveCfg = Release|Any CPU
 		{34691787-AE69-7042-FB4F-9EE5535A4D5A}.Release|x86.Build.0 = Release|Any CPU
+		{014E5B08-E0B3-44D3-9AE3-510EE0691604}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{014E5B08-E0B3-44D3-9AE3-510EE0691604}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{014E5B08-E0B3-44D3-9AE3-510EE0691604}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{014E5B08-E0B3-44D3-9AE3-510EE0691604}.Debug|x64.Build.0 = Debug|Any CPU
+		{014E5B08-E0B3-44D3-9AE3-510EE0691604}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{014E5B08-E0B3-44D3-9AE3-510EE0691604}.Debug|x86.Build.0 = Debug|Any CPU
+		{014E5B08-E0B3-44D3-9AE3-510EE0691604}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{014E5B08-E0B3-44D3-9AE3-510EE0691604}.Release|Any CPU.Build.0 = Release|Any CPU
+		{014E5B08-E0B3-44D3-9AE3-510EE0691604}.Release|x64.ActiveCfg = Release|Any CPU
+		{014E5B08-E0B3-44D3-9AE3-510EE0691604}.Release|x64.Build.0 = Release|Any CPU
+		{014E5B08-E0B3-44D3-9AE3-510EE0691604}.Release|x86.ActiveCfg = Release|Any CPU
+		{014E5B08-E0B3-44D3-9AE3-510EE0691604}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

reame.txt

@@ -1,4 +1,7 @@
 
+see E:\huggingface\goldendict-ng\wpfmdict
+	# mdict 的 C# 版是用 trae + gemini 3 pro 从 goldendict-ng 项目仿的
+
 see github\echodict\cut\wpf\ScreenGrab\ScreenGrabber.cs
 
 

src/EchoDictLib/Adler32.cs

@@ -0,0 +1,49 @@
+using System;
+
+namespace Echodict
+{
+    public class Adler32
+    {
+        private uint _checksum;
+
+        public Adler32()
+        {
+            _checksum = 1;
+        }
+
+        public void Update(byte[] data, int offset, int length)
+        {
+            uint s1 = _checksum & 0xFFFF;
+            uint s2 = (_checksum >> 16) & 0xFFFF;
+
+            for (int i = 0; i < length; i++)
+            {
+                s1 = (s1 + data[offset + i]) % 65521;
+                s2 = (s2 + s1) % 65521;
+            }
+
+            _checksum = (s2 << 16) | s1;
+        }
+
+        public void Update(byte[] data)
+        {
+            Update(data, 0, data.Length);
+        }
+
+        public uint Value => _checksum;
+
+        public static uint Compute(byte[] data)
+        {
+            var adler = new Adler32();
+            adler.Update(data);
+            return adler.Value;
+        }
+        
+        public static uint Compute(byte[] data, int offset, int length)
+        {
+            var adler = new Adler32();
+            adler.Update(data, offset, length);
+            return adler.Value;
+        }
+    }
+}

src/EchoDictLib/DictGroup.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace Echodict
+{
+    public class DictGroup
+    {
+        public string Name { get; set; } = string.Empty;
+        public List<string> DictionaryPaths { get; set; } = new List<string>();
+    }
+}

src/EchoDictLib/DictRequestHandler.cs

@@ -0,0 +1,150 @@
+using CefSharp;
+using CefSharp.Handler;
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Echodict
+{
+    public class DictRequestHandler : RequestHandler
+    {
+        private DictResourceRequestHandler _resourceRequestHandler;
+        private Action<string> _searchAction;
+
+        public DictRequestHandler(List<Dictionary> dicts, Action<string> searchAction = null)
+        {
+            _resourceRequestHandler = new DictResourceRequestHandler(dicts);
+            _searchAction = searchAction;
+        }
+
+        public void SetSearchHtml(string html)
+        {
+            _resourceRequestHandler.SearchHtml = html;
+        }
+
+        protected override bool OnBeforeBrowse(IWebBrowser chromiumWebBrowser, IBrowser browser, IFrame frame, IRequest request, bool userGesture, bool isRedirect)
+        {
+            if (request.Url.StartsWith("entry://", StringComparison.OrdinalIgnoreCase))
+            {
+                string word = request.Url.Substring(8);
+                // Remove trailing slash if present
+                if (word.EndsWith("/")) word = word.Substring(0, word.Length - 1);
+                
+                word = Uri.UnescapeDataString(word);
+
+                _searchAction?.Invoke(word);
+                return true;
+            }
+            return base.OnBeforeBrowse(chromiumWebBrowser, browser, frame, request, userGesture, isRedirect);
+        }
+
+        protected override IResourceRequestHandler GetResourceRequestHandler(IWebBrowser chromiumWebBrowser, IBrowser browser, IFrame frame, IRequest request, bool isNavigation, bool isDownload, string requestInitiator, ref bool disableDefaultHandling)
+        {
+            return _resourceRequestHandler;
+        }
+    }
+
+    public class DictResourceRequestHandler : ResourceRequestHandler
+    {
+        private List<Dictionary> _dicts;
+        public string? SearchHtml { get; set; }
+
+        public DictResourceRequestHandler(List<Dictionary> dicts)
+        {
+            _dicts = dicts;
+        }
+
+        protected override IResourceHandler GetResourceHandler(IWebBrowser chromiumWebBrowser, IBrowser browser, IFrame frame, IRequest request)
+        {
+             if (request.Url.StartsWith("http://custom-rendering/", StringComparison.OrdinalIgnoreCase))
+             {
+                 // Serve the search result page
+                 if (request.Url.Equals("http://custom-rendering/result.html", StringComparison.OrdinalIgnoreCase) ||
+                     request.Url.Equals("http://custom-rendering/", StringComparison.OrdinalIgnoreCase))
+                 {
+                     if (SearchHtml != null)
+                     {
+                         return ResourceHandler.FromByteArray(System.Text.Encoding.UTF8.GetBytes(SearchHtml), "text/html");
+                     }
+                 }
+
+                 if (!Uri.TryCreate(request.Url, UriKind.Absolute, out Uri? uri))
+                 {
+                     var handler = ResourceHandler.FromByteArray(System.Text.Encoding.UTF8.GetBytes("Invalid URL"), "text/plain");
+                     return handler;
+                 }
+
+                 // Parse path to extract dictionary ID if present
+                 // Expected format: /<dictId>/path/to/resource
+                 string path = Uri.UnescapeDataString(uri.AbsolutePath);
+                 string? dictId = null;
+                 string resourcePath = path;
+
+                 // Check if the first segment is a dictionary ID (32 hex chars)
+                 var segments = path.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
+                 if (segments.Length > 0 && segments[0].Length == 32 && System.Text.RegularExpressions.Regex.IsMatch(segments[0], "^[a-fA-F0-9]{32}$"))
+                 {
+                     dictId = segments[0];
+                     // Reconstruct path without the ID
+                     resourcePath = string.Join("/", segments, 1, segments.Length - 1);
+                 }
+
+                 if (dictId != null)
+                 {
+                     // Search in specific dictionary
+                     var dict = _dicts.Find(d => d.Id.Equals(dictId, StringComparison.OrdinalIgnoreCase));
+                     if (dict != null)
+                     {
+                         var data = dict.GetResource(resourcePath);
+                         if (data != null)
+                         {
+                             string mime = GetMimeType(resourcePath);
+                             return ResourceHandler.FromByteArray(data, mime);
+                         }
+                     }
+                 }
+                 else
+                 {
+                     // Fallback: Search in all dictionaries (legacy/global lookup)
+                     foreach (var dict in _dicts)
+                     {
+                         var data = dict.GetResource(path);
+                         if (data != null)
+                         {
+                             string mime = GetMimeType(path);
+                             return ResourceHandler.FromByteArray(data, mime);
+                         }
+                     }
+                 }
+                 
+                 // Resource not found: return 404 to avoid network/DNS lookup which causes "Site can't be reached"
+                 // We return 200 OK with "Not Found" body because setting StatusCode on IResourceHandler is tricky in some versions
+                 var notFoundHandler = ResourceHandler.FromByteArray(System.Text.Encoding.UTF8.GetBytes("Not Found"), "text/plain");
+                 return notFoundHandler;
+             }
+             return base.GetResourceHandler(chromiumWebBrowser, browser, frame, request);
+        }
+        
+        private string GetMimeType(string path)
+        {
+            string ext = Path.GetExtension(path).ToLower();
+            switch (ext)
+            {
+                case ".css": return "text/css";
+                case ".js": return "text/javascript";
+                case ".png": return "image/png";
+                case ".jpg": return "image/jpeg";
+                case ".jpeg": return "image/jpeg";
+                case ".gif": return "image/gif";
+                case ".bmp": return "image/bmp";
+                case ".svg": return "image/svg+xml";
+                case ".wav": return "audio/wav";
+                case ".mp3": return "audio/mpeg";
+                case ".ttf": return "font/ttf";
+                case ".woff": return "font/woff";
+                case ".woff2": return "font/woff2";
+                default: return "application/octet-stream";
+            }
+        }
+    }
+}

src/EchoDictLib/Dictionary.cs

@@ -0,0 +1,145 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace Echodict
+{
+    public class Dictionary : IDisposable
+    {
+        public string Id { get; private set; }
+        public string Name { get; private set; }
+        public MdxReader Mdx { get; private set; }
+        public List<MdxReader> Mdds { get; private set; } = new List<MdxReader>();
+
+        public Dictionary(string mdxPath, string? cacheDir = null, bool forceRebuild = false)
+        {
+            if (!File.Exists(mdxPath))
+                throw new FileNotFoundException("MDX file not found", mdxPath);
+
+            // Generate ID first (needed for cache filename)
+            Id = CreateId(mdxPath);
+            Name = Path.GetFileNameWithoutExtension(mdxPath);
+
+            // Prepare Cache Path
+            string? mdxCachePath = null;
+            if (!string.IsNullOrEmpty(cacheDir))
+            {
+                if (!Directory.Exists(cacheDir)) Directory.CreateDirectory(cacheDir);
+                mdxCachePath = Path.Combine(cacheDir, Id + ".idx");
+            }
+
+            // Load MDX
+            Mdx = new MdxReader(mdxPath);
+            if (!Mdx.Open())
+                throw new Exception("Failed to open MDX file");
+            
+            Mdx.LoadIndex(mdxCachePath, forceRebuild);
+            
+            // Load associated MDDs
+            LoadMdds(mdxPath, cacheDir, forceRebuild);
+        }
+
+        private void LoadMdds(string mdxPath, string? cacheDir, bool forceRebuild)
+        {
+            string baseName = Path.Combine(Path.GetDirectoryName(mdxPath)!, Path.GetFileNameWithoutExtension(mdxPath));
+            
+            // 1. Check base.mdd
+            string mddPath = baseName + ".mdd";
+            if (File.Exists(mddPath))
+            {
+                AddMdd(mddPath, cacheDir, forceRebuild);
+            }
+
+            // 2. Check base.1.mdd, base.2.mdd, etc.
+            int vol = 1;
+            while (true)
+            {
+                string volPath = $"{baseName}.{vol}.mdd";
+                if (File.Exists(volPath))
+                {
+                    AddMdd(volPath, cacheDir, forceRebuild);
+                    vol++;
+                }
+                else
+                {
+                    break;
+                }
+            }
+        }
+
+        private void AddMdd(string path, string? cacheDir, bool forceRebuild)
+        {
+            try 
+            {
+                var reader = new MdxReader(path);
+                if (reader.Open())
+                {
+                    // Calculate cache path for MDD
+                    string? mddCachePath = null;
+                    if (!string.IsNullOrEmpty(cacheDir))
+                    {
+                        string id = CreateId(path);
+                        mddCachePath = Path.Combine(cacheDir, id + ".idx");
+                    }
+
+                    reader.LoadIndex(mddCachePath, forceRebuild);
+                    Mdds.Add(reader);
+                }
+            }
+            catch (Exception)
+            {
+                // Log or ignore broken MDDs
+            }
+        }
+
+        private string CreateId(string path)
+        {
+            // Simple ID generation
+            using (var md5 = System.Security.Cryptography.MD5.Create())
+            {
+                byte[] inputBytes = System.Text.Encoding.UTF8.GetBytes(path.ToLowerInvariant());
+                byte[] hashBytes = md5.ComputeHash(inputBytes);
+                return BitConverter.ToString(hashBytes).Replace("-", "").ToLower();
+            }
+        }
+
+        public byte[]? GetResource(string path)
+        {
+            // Normalize path (remove leading /)
+            string relPath = path.TrimStart('/', '\\');
+
+            // 1. Check File System (Relative to MDX)
+            string dictDir = Path.GetDirectoryName(Mdx.Filename)!;
+            string localPath = Path.Combine(dictDir, relPath);
+            
+            if (File.Exists(localPath))
+            {
+                try 
+                {
+                    return File.ReadAllBytes(localPath);
+                }
+                catch { /* Ignore read errors */ }
+            }
+
+            // 2. Check MDDs
+            // MDict keys usually use backslash or forward slash. MdxReader.GetResource handles variations.
+            foreach (var mdd in Mdds)
+            {
+                var data = mdd.GetResource(relPath);
+                if (data != null) return data;
+            }
+
+            return null;
+        }
+
+        public void Dispose()
+        {
+            Mdx?.Dispose();
+            foreach (var mdd in Mdds)
+            {
+                mdd.Dispose();
+            }
+        }
+    }
+}

src/EchoDictLib/EchoDictLib.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0-windows</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="CefSharp.Wpf.NETCore" Version="141.0.110" />
+		<PackageReference Include="System.Text.Encoding.CodePages" Version="10.0.1" />
+	</ItemGroup>
+
+</Project>

src/EchoDictLib/EchodictConfig.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+
+namespace Echodict
+{
+    public class EchodictConfig
+    {
+        public List<string> SourcePaths { get; set; } = new List<string>();
+        public List<DictGroup> Groups { get; set; } = new List<DictGroup>();
+        public string LastSelectedDictId { get; set; } = "ALL";
+        public List<string> History { get; set; } = new List<string>();
+    }
+}

src/EchoDictLib/Lzo.cs

@@ -0,0 +1,209 @@
+using System;
+
+namespace Echodict
+{
+    public static class Lzo
+    {
+        public static byte[] Decompress(byte[] src, int decompressedSize)
+        {
+            byte[] dst = new byte[decompressedSize];
+            int srcLen = src.Length;
+            int dstLen = decompressedSize;
+            int result = Decompress(src, 0, srcLen, dst, 0, ref dstLen);
+            
+            if (result != 0)
+            {
+                throw new Exception($"LZO decompression failed with error code {result}");
+            }
+            return dst;
+        }
+
+        private static int Decompress(byte[] inBuf, int inPos, int inLen, byte[] outBuf, int outPos, ref int outLen)
+        {
+            int ip = inPos;
+            int op = outPos;
+            int inEnd = inPos + inLen;
+            int outEnd = outPos + outLen;
+            
+            int t = 0;
+            int mPos = 0;
+            
+            bool firstRun = true;
+
+            while (true)
+            {
+                if (firstRun)
+                {
+                    firstRun = false;
+                    if (inLen > 17 && inBuf[ip] <= 17)
+                    {
+                        t = inBuf[ip++] - 17;
+                        if (t < 4)
+                        {
+                            do {
+                                outBuf[op++] = inBuf[ip++];
+                            } while (--t > 0);
+                            t = inBuf[ip++];
+                            goto match_done;
+                        }
+                        else
+                        {
+                            do {
+                                outBuf[op++] = inBuf[ip++];
+                            } while (--t > 0);
+                            goto first_literal_run;
+                        }
+                    }
+                }
+
+                t = inBuf[ip++];
+                if (t >= 16)
+                {
+                    goto match;
+                }
+
+                if (t == 0)
+                {
+                    while (inBuf[ip] == 0)
+                    {
+                        t += 255;
+                        ip++;
+                    }
+                    t += 15 + inBuf[ip++];
+                }
+
+                t += 3;
+                if (op + t > outEnd || ip + t > inEnd) return -1;
+
+                do
+                {
+                    outBuf[op++] = inBuf[ip++];
+                } while (--t > 0);
+
+first_literal_run:
+                t = inBuf[ip++];
+                if (t >= 16)
+                {
+                    goto match;
+                }
+                
+                // M = 0
+                mPos = op - (1 + 0x0800); 
+                mPos -= t >> 2;
+                mPos -= inBuf[ip++] << 2;
+                
+                if (mPos < outPos || mPos >= op) return -2;
+                
+                outBuf[op++] = outBuf[mPos++];
+                outBuf[op++] = outBuf[mPos++];
+                outBuf[op++] = outBuf[mPos];
+                
+                goto match_done;
+
+match:
+                if (t >= 64)
+                {
+                    // M = 1
+                    mPos = op - 1;
+                    mPos -= (t >> 2) & 7;
+                    mPos -= inBuf[ip++] << 3;
+                    t = (t >> 5) - 1;
+                    
+                    if (mPos < outPos || mPos >= op) return -2;
+                    
+                    // Copy match inline
+                    outBuf[op++] = outBuf[mPos++];
+                    outBuf[op++] = outBuf[mPos++];
+                    do {
+                        outBuf[op++] = outBuf[mPos++];
+                    } while (--t > 0);
+                    goto match_done;
+                }
+                else if (t >= 32)
+                {
+                    // M = 2
+                    t &= 31;
+                    if (t == 0)
+                    {
+                        while (inBuf[ip] == 0)
+                        {
+                            t += 255;
+                            ip++;
+                        }
+                        t += 31 + inBuf[ip++];
+                    }
+                    
+                    mPos = op - 1;
+                    mPos -= (inBuf[ip] >> 2) + (inBuf[ip+1] << 6); 
+                    ip += 2;
+                }
+                else if (t >= 16)
+                {
+                    // M = 3
+                    mPos = op;
+                    mPos -= (t & 8) << 11;
+                    t &= 7;
+                    if (t == 0)
+                    {
+                        while (inBuf[ip] == 0)
+                        {
+                            t += 255;
+                            ip++;
+                        }
+                        t += 7 + inBuf[ip++];
+                    }
+                    
+                    mPos -= (inBuf[ip] >> 2) + (inBuf[ip+1] << 6);
+                    ip += 2;
+                    
+                    if (mPos == op)
+                    {
+                        outLen = op - outPos;
+                        return 0; // EOF
+                    }
+                    mPos -= 0x4000;
+                }
+                else
+                {
+                    return -3;
+                }
+                
+                if (mPos < outPos || mPos >= op) return -2;
+                
+                if (t >= 6 && (op - mPos) >= 4)
+                {
+                    outBuf[op++] = outBuf[mPos++];
+                    outBuf[op++] = outBuf[mPos++];
+                    outBuf[op++] = outBuf[mPos++];
+                    outBuf[op++] = outBuf[mPos++];
+                    t -= 2;
+                    do {
+                        outBuf[op++] = outBuf[mPos++];
+                    } while (--t > 0);
+                }
+                else
+                {
+                    outBuf[op++] = outBuf[mPos++];
+                    outBuf[op++] = outBuf[mPos++];
+                    do {
+                        outBuf[op++] = outBuf[mPos++];
+                    } while (--t > 0);
+                }
+
+match_done:
+                t = inBuf[ip++] & 3;
+                if (t == 0) continue;
+                
+                outBuf[op++] = inBuf[ip++];
+                if (t > 1) {
+                    outBuf[op++] = inBuf[ip++];
+                    if (t > 2) {
+                        outBuf[op++] = inBuf[ip++];
+                    }
+                }
+                
+                t = inBuf[ip++];
+            }
+        }
+    }
+}

src/EchoDictLib/MdxReader.cs

@@ -0,0 +1,765 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Linq;
+
+namespace Echodict
+{
+    public class MdxReader : IDisposable
+    {
+        private FileStream _fs;
+        private BinaryReader _reader;
+        public string Filename { get; private set; }
+        
+        public string Encoding { get; private set; } = "UTF-16LE";
+        public double Version { get; private set; }
+        private int _numberWidth;
+        public bool IsEncrypted { get; private set; }
+        private int _encryptedFlag;
+        public List<string> Headwords { get; private set; } = new List<string>();
+        public Dictionary<string, long> Index { get; private set; } = new Dictionary<string, long>(StringComparer.OrdinalIgnoreCase);
+
+        // Basic stats
+        public long NumHeadWordBlocks;
+        public long WordCount;
+        
+        public MdxReader(string filename)
+        {
+            Filename = filename;
+        }
+
+        // Record Block Infos
+        private List<RecordBlockInfo> _recordBlocks = new List<RecordBlockInfo>();
+        private long _totalRecordSize;
+
+        // Parser state
+        private long _headWordBlockInfoPos;
+        private long _headWordBlockInfoSize;
+        private long _headWordBlockSize;
+        private long _headWordPos;
+        private List<Tuple<long, long>> _headWordBlockInfos;
+
+        public struct RecordBlockInfo
+        {
+            public long CompressedSize;
+            public long DecompressedSize;
+            public long StartPos; // File Position
+            public long EndPos;
+            public long ShadowStartPos; // Global Decompressed Offset Start
+            public long ShadowEndPos;
+        }
+
+        public bool Open()
+        {
+            try
+            {
+                if (_fs != null)
+                {
+                    _fs.Close();
+                    _fs.Dispose();
+                }
+
+                _fs = new FileStream(Filename, FileMode.Open, FileAccess.Read, FileShare.Read);
+                _reader = new BinaryReader(_fs);
+
+                ReadHeader();
+
+                // Adjust Encoding based on header info if needed
+                // Sometimes Encoding is not explicitly set in header but inferred.
+                // But let's rely on Header "Encoding" attribute first.
+
+                ReadHeadWordBlockInfos();
+                ReadRecordBlockInfos();
+
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        public bool LoadIndex(string? cachePath = null, bool forceRebuild = false)
+        {
+            if (_headWordBlockInfos == null) return false;
+
+            // Try to load from cache
+            if (!forceRebuild && !string.IsNullOrEmpty(cachePath) && File.Exists(cachePath))
+            {
+                // Check timestamp: Cache must be newer than MDX file
+                try 
+                {
+                    var mdxTime = File.GetLastWriteTimeUtc(Filename);
+                    var cacheTime = File.GetLastWriteTimeUtc(cachePath);
+                    
+                    if (cacheTime > mdxTime)
+                    {
+                        if (LoadIndexFromCache(cachePath))
+                        {
+                            return true;
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    System.Diagnostics.Debug.WriteLine($"Error checking cache timestamp: {ex.Message}");
+                }
+            }
+
+            _fs.Seek(_headWordPos, SeekOrigin.Begin);
+
+            bool v2 = Version >= 2.0;
+
+            foreach (var block in _headWordBlockInfos)
+            {
+                long compressedSize = block.Item1;
+                long decompressedSize = block.Item2;
+
+                byte[] compressedBlock = _reader.ReadBytes((int)compressedSize);
+                byte[] decompressedBlock = Decompress(compressedBlock, (int)decompressedSize);
+
+                SplitHeadBlock(decompressedBlock, v2);
+            }
+
+            // Save to cache if path provided
+            if (!string.IsNullOrEmpty(cachePath))
+            {
+                SaveIndexToCache(cachePath);
+            }
+
+            return true;
+        }
+
+        private bool LoadIndexFromCache(string path)
+        {
+            try
+            {
+                using (var fs = new FileStream(path, FileMode.Open, FileAccess.Read))
+                using (var br = new BinaryReader(fs))
+                {
+                    string magic = new string(br.ReadChars(8));
+                    if (magic != "MDXIDX01") return false;
+
+                    long savedWordCount = br.ReadInt64();
+                    Headwords = new List<string>((int)savedWordCount);
+                    Index = new Dictionary<string, long>((int)savedWordCount, StringComparer.OrdinalIgnoreCase);
+
+                    for (int i = 0; i < savedWordCount; i++)
+                    {
+                        string headword = br.ReadString();
+                        long offset = br.ReadInt64();
+                        
+                        Headwords.Add(headword);
+                        if (!Index.ContainsKey(headword))
+                        {
+                            Index[headword] = offset;
+                        }
+                    }
+                    return true;
+                }
+            }
+            catch (Exception)
+            {
+                // Cache corrupted or incompatible
+                return false;
+            }
+        }
+
+        private void SaveIndexToCache(string path)
+        {
+            try
+            {
+                using (var fs = new FileStream(path, FileMode.Create, FileAccess.Write))
+                using (var bw = new BinaryWriter(fs))
+                {
+                    bw.Write("MDXIDX01".ToCharArray());
+                    bw.Write((long)Headwords.Count);
+                    
+                    // We iterate Headwords list because it preserves order (important for GetRecordData size calc)
+                    foreach (var hw in Headwords)
+                    {
+                        bw.Write(hw);
+                        if (Index.TryGetValue(hw, out long offset))
+                        {
+                            bw.Write(offset);
+                        }
+                        else
+                        {
+                            bw.Write((long)0); // Should not happen
+                        }
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                System.Diagnostics.Debug.WriteLine($"Failed to save cache: {ex.Message}");
+            }
+        }
+
+        private void ReadRecordBlockInfos()
+        {
+            // Position should be at the end of HeadWordBlockInfos (or we need to seek)
+            // C++: file_->seek( headWordBlockInfoPos_ + headWordBlockInfoSize_ + headWordBlockSize_ );
+            
+            long targetPos = _headWordBlockInfoPos + _headWordBlockInfoSize + _headWordBlockSize;
+            _fs.Seek(targetPos, SeekOrigin.Begin);
+
+            long numRecordBlocks = ReadNumber(_reader, Version >= 2.0);
+             long numEntries = ReadNumber(_reader, Version >= 2.0);
+             long recordInfoSize = ReadNumber(_reader, Version >= 2.0);
+             _totalRecordSize = ReadNumber(_reader, Version >= 2.0);
+             
+             long startOfIndex = _fs.Position;
+             long startOfData = startOfIndex + recordInfoSize;
+             
+             long currentShadow = 0;
+             long currentFilePos = startOfData;
+             
+             for (int i = 0; i < numRecordBlocks; i++)
+            {
+                long comp = GetRecordBlockCompressedSize();
+                long decomp = ReadNumber(_reader, Version >= 2.0);
+                
+                _recordBlocks.Add(new RecordBlockInfo
+                {
+                    CompressedSize = comp,
+                    DecompressedSize = decomp,
+                    StartPos = currentFilePos,
+                    EndPos = currentFilePos + comp,
+                    ShadowStartPos = currentShadow,
+                    ShadowEndPos = currentShadow + decomp
+                });
+                
+                currentShadow += decomp;
+                currentFilePos += comp;
+            }
+        }
+        
+        public byte[]? GetResource(string key)
+        {
+             // Try exact match
+             if (Index.ContainsKey(key)) return GetRecordData(key);
+             
+             // Try with backslash
+             if (!key.StartsWith("\\") && !key.StartsWith("/"))
+             {
+                 string k = "\\" + key;
+                 if (Index.ContainsKey(k)) return GetRecordData(k);
+                 
+                 k = "/" + key;
+                 if (Index.ContainsKey(k)) return GetRecordData(k);
+             }
+             
+             // Try replacing / with \
+             string k2 = key.Replace("/", "\\");
+             if (Index.ContainsKey(k2)) return GetRecordData(k2);
+             
+             // Try replacing \ with /
+             string k3 = key.Replace("\\", "/");
+             if (Index.ContainsKey(k3)) return GetRecordData(k3);
+             
+             return null;
+        }
+
+        public byte[]? GetRecordData(string key)
+        {
+            if (!Index.ContainsKey(key)) return null;
+            long offset = Index[key];
+            
+            // Find size
+            long size = -1;
+            int idx = Headwords.IndexOf(key); 
+            
+            if (idx != -1 && idx < Headwords.Count - 1)
+            {
+                string nextKey = Headwords[idx + 1];
+                long nextOffset = Index[nextKey];
+                size = nextOffset - offset;
+            }
+            
+            return GetRecordData(offset, size);
+        }
+
+        public string? GetDefinition(string key)
+        {
+            return GetDefinitionInternal(key, new HashSet<string>());
+        }
+
+        private string? GetDefinitionInternal(string key, HashSet<string> visited)
+        {
+            if (visited.Contains(key)) return null; // Cycle detection
+            visited.Add(key);
+
+            var data = GetRecordData(key);
+            if (data == null) return null;
+            
+            // Try to detect encoding or use the one from header
+            Encoding enc;
+            try 
+            {
+                enc = System.Text.Encoding.GetEncoding(Encoding == "GB18030" ? "GB18030" : "UTF-8");
+            }
+            catch
+            {
+                enc = System.Text.Encoding.UTF8;
+            }
+
+            // If header says UTF-16LE, we should use it.
+            if (Encoding == "UTF-16LE")
+            {
+                enc = System.Text.Encoding.Unicode;
+            }
+
+            string text;
+            try {
+                 text = enc.GetString(data);
+            } catch {
+                 // Fallback
+                 text = System.Text.Encoding.UTF8.GetString(data);
+            }
+
+            // Handle internal redirects
+            if (text.StartsWith("@@@LINK="))
+            {
+                // Check for multiple links
+                if (text.IndexOf("@@@LINK=", 1) != -1)
+                {
+                    return text;
+                }
+
+                string target = text.Substring(8).Trim();
+                // Remove null terminator if present
+                int nullIndex = target.IndexOf('\0');
+                if (nullIndex != -1) target = target.Substring(0, nullIndex);
+                target = target.Trim();
+
+                var targetDef = GetDefinitionInternal(target, visited);
+                if (targetDef != null) return targetDef;
+            } else if (text.Contains("@@@LINK=")) {
+                int a = 1;
+            }
+
+            return text;
+        }
+
+        public byte[] GetRecordData(long offset, long size)
+        {
+            // Find Block
+            var block = _recordBlocks.FirstOrDefault(b => offset >= b.ShadowStartPos && offset < b.ShadowEndPos);
+            if (block.DecompressedSize == 0) return new byte[0];
+            
+            // Read Block
+            // In a real app, we should cache the last accessed block to avoid re-reading/decompressing for every word if they are in same block.
+            _fs.Seek(block.StartPos, SeekOrigin.Begin);
+            byte[] compressed = _reader.ReadBytes((int)block.CompressedSize);
+            byte[] decompressed = Decompress(compressed, (int)block.DecompressedSize);
+            
+            // Extract Record
+            long localOffset = offset - block.ShadowStartPos;
+            if (localOffset >= decompressed.Length) return new byte[0];
+            
+            int readLen = (int)size;
+            if (readLen <= 0 || localOffset + readLen > decompressed.Length)
+            {
+                readLen = decompressed.Length - (int)localOffset;
+            }
+            
+            byte[] result = new byte[readLen];
+            Array.Copy(decompressed, localOffset, result, 0, readLen);
+            return result;
+        }
+
+        private void ReadHeader()
+        {
+            int headerTextSize = _reader.ReadInt32(); // Little Endian by default in C# BinaryReader? Wait.
+            // MDX is Big Endian usually. The C++ code says: in.setByteOrder( QDataStream::BigEndian );
+            // So we need to read Big Endian.
+            
+            // Let's reset and read properly.
+            _fs.Position = 0;
+            headerTextSize = ReadInt32BE();
+            
+            byte[] headerBytes = _reader.ReadBytes(headerTextSize);
+            
+            // Calculate Checksum
+            uint checksum = ReadInt32LE(); // Checksum is Little Endian per code: in.setByteOrder( QDataStream::LittleEndian );
+            
+            // Verify checksum (Adler32) - Skipped for MVP to ensure we just load valid files.
+            
+            string headerText = System.Text.Encoding.Unicode.GetString(headerBytes); // UTF-16LE
+            
+            // Parse Attributes
+            var attrs = ParseXmlAttributes(headerText);
+            
+            if (attrs.ContainsKey("Encoding"))
+            {
+                Encoding = attrs["Encoding"];
+                if (Encoding == "GBK" || Encoding == "GB2312") Encoding = "GB18030";
+                if (string.IsNullOrEmpty(Encoding) || Encoding == "UTF-16") Encoding = "UTF-16LE";
+            }
+            
+            if (attrs.ContainsKey("GeneratedByEngineVersion"))
+            {
+                Version = double.Parse(attrs["GeneratedByEngineVersion"]);
+            }
+            
+            if (attrs.ContainsKey("Encrypted"))
+            {
+                string enc = attrs["Encrypted"];
+                if (enc == "Yes")
+                {
+                    _encryptedFlag |= 1;
+                }
+                else
+                {
+                    int val;
+                    if (int.TryParse(enc, out val))
+                        _encryptedFlag |= val;
+                }
+                IsEncrypted = _encryptedFlag != 0;
+            }
+
+            _numberWidth = Version >= 2.0 ? 8 : 4;
+        }
+
+        private void ReadHeadWordBlockInfos()
+        {
+            // Read Header of Block Infos
+            // version >= 2.0 uses 8 bytes for numbers, otherwise 4.
+            bool v2 = Version >= 2.0;
+            int numBytes = v2 ? 8 : 4;
+            
+            // Just skip the block info header for a moment to see structure... 
+            // C++: QByteArray header = file_->read( version_ >= 2.0 ? ( numberTypeSize_ * 5 ) : ( numberTypeSize_ * 4 ) );
+            int headerLen = v2 ? 40 : 16; // 8*5 vs 4*4
+            byte[] infoHeader = _reader.ReadBytes(headerLen);
+            
+            using (var ms = new MemoryStream(infoHeader))
+            using (var br = new BinaryReader(ms))
+            {
+                NumHeadWordBlocks = ReadNumber(br, v2);
+                WordCount = ReadNumber(br, v2);
+                long decompressedInfoSize = 0;
+                if (v2) decompressedInfoSize = ReadNumber(br, v2);
+                _headWordBlockInfoSize = ReadNumber(br, v2);
+                _headWordBlockSize = ReadNumber(br, v2);
+                
+                // If v2, checksum follows (4 bytes)
+                if (v2) _reader.ReadInt32();
+
+                _headWordBlockInfoPos = _fs.Position;
+                
+                // Read HeadWord Block Info (Compressed)
+                byte[] blockInfoCompressed = _reader.ReadBytes((int)_headWordBlockInfoSize);
+
+                byte[] debugBefore = new byte[Math.Min(32, blockInfoCompressed.Length)];
+                Array.Copy(blockInfoCompressed, debugBefore, debugBefore.Length);
+                
+                // Decrypt if needed
+                if ((_encryptedFlag & 2) == 2)
+                {
+                    // For debugging, we can calculate the key here to show in exception if needed
+                    // But DecryptHeadWordIndex will do it internally
+                    DecryptHeadWordIndex(blockInfoCompressed);
+                }
+
+                // Decompress Block Info
+                // It contains the list of (CompressedSize, DecompressedSize) for each block.
+                byte[] blockInfoDecompressed;
+                try 
+                {
+                    blockInfoDecompressed = Decompress(blockInfoCompressed, (int)decompressedInfoSize);
+                }
+                catch (Exception ex)
+                {
+                    // Recalculate key for debug info
+                    var ripemd = new Ripemd128();
+                    ripemd.Update(debugBefore, 4, 4); // use saved original bytes
+                    ripemd.Update(new byte[] { 0x95, 0x36, 0x00, 0x00 }, 0, 4);
+                    byte[] key = ripemd.Digest();
+                    string keyHex = BitConverter.ToString(key);
+
+                    string beforeHex = BitConverter.ToString(debugBefore);
+                    string afterHex = BitConverter.ToString(blockInfoCompressed.Take(32).ToArray());
+                    
+                    throw new Exception($"Decompression failed. Version={Version}, EncryptedFlag={_encryptedFlag}, InfoSize={_headWordBlockInfoSize}. \nBefore: {beforeHex}\nAfter: {afterHex}\nKey: {keyHex}\nEx: {ex.Message}");
+                }
+                
+                // Decode Block Info
+                _headWordBlockInfos = DecodeBlockInfo(blockInfoDecompressed, v2);
+
+                _headWordPos = _fs.Position;
+            }
+        }
+        
+        private void DecryptHeadWordIndex(byte[] buffer)
+        {
+            var ripemd = new Ripemd128();
+            ripemd.Update(buffer, 4, 4);
+            ripemd.Update(new byte[] { 0x95, 0x36, 0x00, 0x00 }, 0, 4);
+            byte[] key = ripemd.Digest();
+
+            int len = buffer.Length - 8;
+            int offset = 8;
+            byte prev = 0x36;
+
+            for (int i = 0; i < len; i++)
+            {
+                byte b = buffer[offset + i];
+                byte originalB = b;
+
+                b = (byte)((b >> 4) | (b << 4));
+                b = (byte)(b ^ prev ^ (i & 0xFF) ^ key[i % 16]);
+
+                prev = originalB;
+                buffer[offset + i] = b;
+            }
+        }
+
+        private List<Tuple<long, long>> DecodeBlockInfo(byte[] data, bool v2)
+        {
+            var list = new List<Tuple<long, long>>();
+            int numberTypeSize = v2 ? 8 : 4;
+            bool isU16 = v2;
+            int textTermSize = v2 ? 1 : 0; // C++: if version >= 2.0 textTermSize = 1; else 0.
+            
+            using (var ms = new MemoryStream(data))
+            using (var br = new BinaryReader(ms))
+            {
+                while (ms.Position < ms.Length)
+                {
+                    // Number of keywords in the block (Skip)
+                    ms.Seek(numberTypeSize, SeekOrigin.Current);
+                    
+                    // Size of first headword
+                    int textHeadSize = ReadU8OrU16(br, isU16);
+                    
+                    // Skip first headword
+                    int skipLen = 0;
+                    if (Encoding == "UTF-16LE")
+                        skipLen = (textHeadSize + textTermSize) * 2;
+                    else
+                        skipLen = (textHeadSize + textTermSize);
+                    ms.Seek(skipLen, SeekOrigin.Current);
+                    
+                    // Size of last headword
+                    int textTailSize = ReadU8OrU16(br, isU16);
+                    
+                    // Skip last headword
+                    if (Encoding == "UTF-16LE")
+                        skipLen = (textTailSize + textTermSize) * 2;
+                    else
+                        skipLen = (textTailSize + textTermSize);
+                    ms.Seek(skipLen, SeekOrigin.Current);
+                    
+                    // Sizes
+                    long comp = ReadNumber(br, v2);
+                    long decomp = ReadNumber(br, v2);
+                    
+                    list.Add(new Tuple<long, long>(comp, decomp));
+                }
+            }
+            return list;
+        }
+        
+        private int ReadU8OrU16(BinaryReader br, bool isU16)
+        {
+            if (isU16)
+            {
+                var b = br.ReadBytes(2);
+                Array.Reverse(b);
+                return BitConverter.ToUInt16(b, 0);
+            }
+            else
+                return br.ReadByte();
+        }
+
+        private void SplitHeadBlock(byte[] data, bool v2)
+        {
+            int numberTypeSize = v2 ? 8 : 4;
+            int offset = 0;
+            
+            while (offset < data.Length)
+            {
+                // Read Offset
+                long recordOffset = 0;
+                if (numberTypeSize == 8)
+                {
+                    if (offset + 8 > data.Length) break;
+                    // BigEndian
+                    recordOffset = BitConverter.ToInt64(data.Skip(offset).Take(8).Reverse().ToArray(), 0);
+                    offset += 8;
+                }
+                else
+                {
+                    if (offset + 4 > data.Length) break;
+                    recordOffset = BitConverter.ToUInt32(data.Skip(offset).Take(4).Reverse().ToArray(), 0);
+                    offset += 4;
+                }
+                
+                // Read Text (Null terminated)
+                // If UTF-16LE, null terminator is \0\0
+                string text = "";
+                if (Encoding == "UTF-16LE")
+                {
+                    int start = offset;
+                    while (offset + 1 < data.Length)
+                    {
+                        if (data[offset] == 0 && data[offset+1] == 0)
+                        {
+                            break;
+                        }
+                        offset += 2;
+                    }
+                    int len = offset - start;
+                    text = System.Text.Encoding.Unicode.GetString(data, start, len);
+                    offset += 2; // Skip \0\0
+                }
+                else
+                {
+                    int start = offset;
+                    while (offset < data.Length)
+                    {
+                        if (data[offset] == 0) break;
+                        offset++;
+                    }
+                    int len = offset - start;
+                    // Assume encoding
+                    var enc = System.Text.Encoding.GetEncoding(Encoding == "GB18030" ? "GB18030" : "UTF-8"); // Fallback
+                    // Note: .NET might not support GB18030 out of the box without registration, using UTF8 as fallback or just GetEncoding if available.
+                    // For now let's assume standard encodings.
+                    try {
+                       text = enc.GetString(data, start, len);
+                    } catch {
+                       text = System.Text.Encoding.UTF8.GetString(data, start, len);
+                    }
+                    offset++; // Skip \0
+                }
+                
+                // Add to Index
+                if (!Index.ContainsKey(text))
+                {
+                    Index[text] = recordOffset;
+                    Headwords.Add(text);
+                }
+            }
+        }
+
+        private byte[] Decompress(byte[] input, int outputSize)
+        {
+            // Check type
+            // 4 bytes header: type (0=none, 1=lzo, 2=zlib)
+            // 4 bytes checksum
+            if (input.Length < 8) return input;
+            
+            int type = BitConverter.ToInt32(input.Take(4).Reverse().ToArray(), 0);
+            uint checksum = BitConverter.ToUInt32(input.Skip(4).Take(4).Reverse().ToArray(), 0);
+            
+            byte[] result = null;
+
+            if (type == 0) // No compression
+            {
+                result = input.Skip(8).ToArray();
+            }
+            else if (type == 0x02000000) // Zlib
+            {
+                using (var ms = new MemoryStream(input, 8, input.Length - 8))
+                using (var zs = new ZLibStream(ms, CompressionMode.Decompress))
+                using (var outMs = new MemoryStream(outputSize))
+                {
+                     zs.CopyTo(outMs);
+                     result = outMs.ToArray();
+                }
+            }
+            else if (type == 0x01000000) // LZO
+            {
+                byte[] compressedPayload = new byte[input.Length - 8];
+                Array.Copy(input, 8, compressedPayload, 0, input.Length - 8);
+                try 
+                {
+                    result = Lzo.Decompress(compressedPayload, outputSize);
+                }
+                catch (Exception ex)
+                {
+                     // Fallback or rethrow
+                     throw new Exception($"LZO Decompression failed: {ex.Message}");
+                }
+            }
+            
+            if (result != null)
+            {
+                var adler = new Adler32();
+                adler.Update(result, 0, result.Length);
+                if (adler.Value != checksum)
+                {
+                    throw new Exception($"Checksum mismatch. Expected {checksum:X8}, got {adler.Value:X8}");
+                }
+                return result;
+            }
+            
+            return new byte[0];
+        }
+
+        private long GetRecordBlockCompressedSize()
+        {
+            if (_numberWidth == 8)
+                return (long)ReadUInt64BE(_reader);
+            else
+                return (long)ReadUInt32BE(_reader);
+        }
+
+        private long ReadNumber(BinaryReader br, bool v2)
+        {
+            if (v2) return (long)ReadUInt64BE(br);
+            return (long)ReadUInt32BE(br);
+        }
+        
+        private int ReadInt32BE()
+        {
+            var b = _reader.ReadBytes(4);
+            Array.Reverse(b);
+            return BitConverter.ToInt32(b, 0);
+        }
+        
+        private uint ReadInt32LE()
+        {
+            return _reader.ReadUInt32();
+        }
+
+        private uint ReadUInt32BE(BinaryReader br)
+        {
+            var b = br.ReadBytes(4);
+            Array.Reverse(b);
+            return BitConverter.ToUInt32(b, 0);
+        }
+        
+        private ulong ReadUInt64BE(BinaryReader br)
+        {
+            var b = br.ReadBytes(8);
+            Array.Reverse(b);
+            return BitConverter.ToUInt64(b, 0);
+        }
+
+        private Dictionary<string, string> ParseXmlAttributes(string xml)
+        {
+            var dict = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            // Regex to find attributes key="value"
+            var matches = Regex.Matches(xml, "(\\w+)=\"([^\"]*)\"");
+            foreach (Match m in matches)
+            {
+                dict[m.Groups[1].Value] = m.Groups[2].Value;
+            }
+            return dict;
+        }
+
+        public void Dispose()
+        {
+            _reader?.Close();
+            _fs?.Close();
+        }
+    }
+}

src/EchoDictLib/Ripemd128.cs

@@ -0,0 +1,243 @@
+using System;
+
+namespace Echodict
+{
+    public class Ripemd128
+    {
+        private static readonly uint[] KA = { 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e };
+        private static readonly uint[] KB = { 0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9 };
+
+        private static readonly int[] ROTA = {
+            11, 14, 15, 12, 5, 8,  7,  9,  11, 13, 14, 15, 6,  7,  9,  8,  7,  6,  8,  13,
+            11, 9,  7,  15, 7, 12, 15, 9,  11, 7,  13, 12, 11, 13, 6,  7,  14, 9,  13, 15,
+            14, 8,  13, 6,  5, 12, 7,  5,  11, 12, 14, 15, 14, 15, 9,  8,  9,  14, 5,  6,
+            8,  6,  5,  12, 9, 15, 5,  11, 6,  8,  13, 12, 5,  12, 13, 14, 11, 8,  5,  6
+        };
+
+        private static readonly int[] ROTB = {
+            8,  9,  9,  11, 13, 15, 15, 5, 7,  7,  8,  11, 14, 14, 12, 6,  9,  13, 15, 7,
+            12, 8,  9,  11, 7,  7,  12, 7, 6,  15, 13, 11, 9,  7,  15, 11, 8,  6,  6,  14,
+            12, 13, 5,  14, 13, 13, 7,  5, 15, 5,  8,  11, 14, 14, 6,  14, 6,  9,  12, 9,
+            12, 5,  15, 8,  8,  5,  12, 9, 12, 5,  14, 6,  8,  13, 6,  5,  15, 13, 11, 11
+        };
+
+        private static readonly int[] WA = {
+            0,  1, 2,  3, 4,  5,  6, 7,  8, 9,  10, 11, 12, 13, 14, 15, 7,  4,  13, 1,
+            10, 6, 15, 3, 12, 0,  9, 5,  2, 14, 11, 8,  3,  10, 14, 4,  9,  15, 8,  1,
+            2,  7, 0,  6, 13, 11, 5, 12, 1, 9,  11, 10, 0,  8,  12, 4,  13, 3,  7,  15,
+            14, 5, 6,  2, 4,  0,  5, 9,  7, 12, 2,  10, 14, 1,  3,  8,  11, 6,  15, 13
+        };
+
+        private static readonly int[] WB = {
+            5,  14, 7,  0,  9,  2,  11, 4,  13, 6, 15, 8, 1,  10, 3,  12, 6, 11, 3, 7,
+            0,  13, 5,  10, 14, 15, 8,  12, 4,  9, 1,  2, 15, 5,  1,  3,  7, 14, 6, 9,
+            11, 8,  12, 2,  10, 0,  4,  13, 8,  6, 4,  1, 3,  11, 15, 0,  5, 12, 2, 13,
+            9,  7,  10, 14, 12, 15, 10, 4,  1,  5, 8,  7, 6,  2,  13, 14, 0, 3,  9, 11
+        };
+
+        private ulong _count;
+        private byte[] _buffer = new byte[64];
+        private uint[] _state = new uint[4];
+
+        public Ripemd128()
+        {
+            _state[0] = 0x67452301;
+            _state[1] = 0xEFCDAB89;
+            _state[2] = 0x98BADCFE;
+            _state[3] = 0x10325476;
+            _count = 0;
+        }
+
+        private static uint Rol(uint value, int bits)
+        {
+            return (value << bits) | (value >> (32 - bits));
+        }
+
+        private void Transform(byte[] buffer, int offset = 0)
+        {
+            uint a = _state[0];
+            uint b = _state[1];
+            uint c = _state[2];
+            uint d = _state[3];
+            uint e = _state[0];
+            uint f = _state[1];
+            uint g = _state[2];
+            uint h = _state[3];
+            
+            uint[] block = new uint[16];
+            for (int i = 0; i < 16; i++)
+            {
+                block[i] = BitConverter.ToUInt32(buffer, offset + 4 * i);
+            }
+
+            int n = 0;
+            // Round 1 (0-15)
+            // R128_0
+            for (int k = 0; k < 4; k++)
+            {
+                // Round0To15(a, b, c, d, e, f, g, h)
+                a = Rol(a + ((b ^ c ^ d) + block[WA[n]]), ROTA[n]);
+                e = Rol(e + ((((f ^ g) & h) ^ g) + block[WB[n]] + KB[0]), ROTB[n]);
+                n++;
+                
+                // Round0To15(d, a, b, c, h, e, f, g)
+                d = Rol(d + ((a ^ b ^ c) + block[WA[n]]), ROTA[n]);
+                h = Rol(h + ((((e ^ f) & g) ^ f) + block[WB[n]] + KB[0]), ROTB[n]);
+                n++;
+                
+                // Round0To15(c, d, a, b, g, h, e, f)
+                c = Rol(c + ((d ^ a ^ b) + block[WA[n]]), ROTA[n]);
+                g = Rol(g + ((((h ^ e) & f) ^ e) + block[WB[n]] + KB[0]), ROTB[n]);
+                n++;
+                
+                // Round0To15(b, c, d, a, f, g, h, e)
+                b = Rol(b + ((c ^ d ^ a) + block[WA[n]]), ROTA[n]);
+                f = Rol(f + ((((g ^ h) & e) ^ h) + block[WB[n]] + KB[0]), ROTB[n]);
+                n++;
+            }
+
+            // Round 2 (16-31)
+            // R128_16
+            for (int k = 0; k < 4; k++)
+            {
+                // Round16To31(a, b, c, d, e, f, g, h)
+                // f1 = ((c^d)&b)^d; f2 = (~g|f)^h
+                a = Rol(a + ((((c ^ d) & b) ^ d) + block[WA[n]] + KA[0]), ROTA[n]);
+                e = Rol(e + (((~g | f) ^ h) + block[WB[n]] + KB[1]), ROTB[n]);
+                n++;
+
+                // Round16To31(d, a, b, c, h, e, f, g)
+                // f1 = ((b^c)&a)^c; f2 = (~f|e)^g
+                d = Rol(d + ((((b ^ c) & a) ^ c) + block[WA[n]] + KA[0]), ROTA[n]);
+                h = Rol(h + (((~f | e) ^ g) + block[WB[n]] + KB[1]), ROTB[n]);
+                n++;
+
+                // Round16To31(c, d, a, b, g, h, e, f)
+                // f1 = ((a^b)&d)^b; f2 = (~e|h)^f
+                c = Rol(c + ((((a ^ b) & d) ^ b) + block[WA[n]] + KA[0]), ROTA[n]);
+                g = Rol(g + (((~e | h) ^ f) + block[WB[n]] + KB[1]), ROTB[n]);
+                n++;
+
+                // Round16To31(b, c, d, a, f, g, h, e)
+                // f1 = ((d^a)&c)^a; f2 = (~h|g)^e
+                b = Rol(b + ((((d ^ a) & c) ^ a) + block[WA[n]] + KA[0]), ROTA[n]);
+                f = Rol(f + (((~h | g) ^ e) + block[WB[n]] + KB[1]), ROTB[n]);
+                n++;
+            }
+
+            // Round 3 (32-47)
+            // R128_32
+            for (int k = 0; k < 4; k++)
+            {
+                // Round32To47(a, b, c, d, e, f, g, h)
+                // f1 = (~c|b)^d; f2 = ((g^h)&f)^h
+                a = Rol(a + (((~c | b) ^ d) + block[WA[n]] + KA[1]), ROTA[n]);
+                e = Rol(e + ((((g ^ h) & f) ^ h) + block[WB[n]] + KB[2]), ROTB[n]);
+                n++;
+
+                // Round32To47(d, a, b, c, h, e, f, g)
+                // f1 = (~b|a)^c; f2 = ((f^g)&e)^g
+                d = Rol(d + (((~b | a) ^ c) + block[WA[n]] + KA[1]), ROTA[n]);
+                h = Rol(h + ((((f ^ g) & e) ^ g) + block[WB[n]] + KB[2]), ROTB[n]);
+                n++;
+
+                // Round32To47(c, d, a, b, g, h, e, f)
+                // f1 = (~a|d)^b; f2 = ((e^f)&h)^f
+                c = Rol(c + (((~a | d) ^ b) + block[WA[n]] + KA[1]), ROTA[n]);
+                g = Rol(g + ((((e ^ f) & h) ^ f) + block[WB[n]] + KB[2]), ROTB[n]);
+                n++;
+
+                // Round32To47(b, c, d, a, f, g, h, e)
+                // f1 = (~d|c)^a; f2 = ((h^e)&g)^e
+                b = Rol(b + (((~d | c) ^ a) + block[WA[n]] + KA[1]), ROTA[n]);
+                f = Rol(f + ((((h ^ e) & g) ^ e) + block[WB[n]] + KB[2]), ROTB[n]);
+                n++;
+            }
+
+            // Round 4 (48-63)
+            // R128_48
+            for (int k = 0; k < 4; k++)
+            {
+                // Round48To63(a, b, c, d, e, f, g, h)
+                // f1 = ((b^c)&d)^c; f2 = f^g^h
+                a = Rol(a + ((((b ^ c) & d) ^ c) + block[WA[n]] + KA[2]), ROTA[n]);
+                e = Rol(e + ((f ^ g ^ h) + block[WB[n]]), ROTB[n]);
+                n++;
+
+                // Round48To63(d, a, b, c, h, e, f, g)
+                // f1 = ((a^b)&c)^b; f2 = e^f^g
+                d = Rol(d + ((((a ^ b) & c) ^ b) + block[WA[n]] + KA[2]), ROTA[n]);
+                h = Rol(h + ((e ^ f ^ g) + block[WB[n]]), ROTB[n]);
+                n++;
+
+                // Round48To63(c, d, a, b, g, h, e, f)
+                // f1 = ((d^a)&b)^a; f2 = h^e^f
+                c = Rol(c + ((((d ^ a) & b) ^ a) + block[WA[n]] + KA[2]), ROTA[n]);
+                g = Rol(g + ((h ^ e ^ f) + block[WB[n]]), ROTB[n]);
+                n++;
+
+                // Round48To63(b, c, d, a, f, g, h, e)
+                // f1 = ((c^d)&a)^d; f2 = g^h^e
+                b = Rol(b + ((((c ^ d) & a) ^ d) + block[WA[n]] + KA[2]), ROTA[n]);
+                f = Rol(f + ((g ^ h ^ e) + block[WB[n]]), ROTB[n]);
+                n++;
+            }
+
+            h += c + _state[1];
+            _state[1] = _state[2] + d + e;
+            _state[2] = _state[3] + a + f;
+            _state[3] = _state[0] + b + g;
+            _state[0] = h;
+        }
+
+        public void Update(byte[] data, int offset, int len)
+        {
+            int i, j;
+            j = (int)(_count & 63);
+            _count += (ulong)len;
+
+            if ((j + len) > 63)
+            {
+                Array.Copy(data, offset, _buffer, j, 64 - j);
+                Transform(_buffer);
+                i = 64 - j;
+                for (; i + 63 < len; i += 64)
+                {
+                    Transform(data, offset + i);
+                }
+                j = 0;
+            }
+            else
+            {
+                i = 0;
+            }
+            Array.Copy(data, offset + i, _buffer, j, len - i);
+        }
+        
+        public void Update(byte[] data)
+        {
+            Update(data, 0, data.Length);
+        }
+
+        public byte[] Digest()
+        {
+            ulong finalcount = _count << 3;
+            Update(new byte[] { 0x80 }, 0, 1);
+            while ((_count & 63) != 56)
+            {
+                Update(new byte[] { 0 }, 0, 1);
+            }
+            
+            byte[] countBytes = BitConverter.GetBytes(finalcount); // Little endian
+            Update(countBytes, 0, 8);
+            
+            byte[] digest = new byte[16];
+            for (int i = 0; i < 4; i++)
+            {
+                byte[] b = BitConverter.GetBytes(_state[i]);
+                Array.Copy(b, 0, digest, i * 4, 4);
+            }
+            return digest;
+        }
+    }
+}

src/WpfEditor/EchoDictWindow.xaml

@@ -1,8 +1,157 @@
-<Window x:Class="WpfEditor.EchoDictWindow"
+<Window x:Class="Echodict.EchodictWindow"
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-        Title="Echodict" Height="200" Width="400">
-    <Grid>
-        <TextBlock x:Name="textBlock" TextWrapping="Wrap" VerticalAlignment="Center" HorizontalAlignment="Center" FontSize="16" />
-    </Grid>
-</Window>
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        xmlns:cef="clr-namespace:CefSharp.Wpf;assembly=CefSharp.Wpf"
+        xmlns:local="clr-namespace:Echodict"
+        mc:Ignorable="d"
+        Title="EchoDict" Height="538" Width="800">
+    <DockPanel>
+        <!-- Menu Bar -->
+        <Menu DockPanel.Dock="Top">
+            <MenuItem Header="_File">
+                <MenuItem Header="New Tab" InputGestureText="Ctrl+T" />
+                <Separator />
+                <MenuItem Header="Page Setup..." />
+                <MenuItem Header="Print Preview..." />
+                <MenuItem Header="Print..." InputGestureText="Ctrl+P" />
+                <Separator />
+                <MenuItem Header="Save Article..." InputGestureText="F2" />
+                <Separator />
+                <MenuItem Header="Rescan Files" InputGestureText="Ctrl+F5" Click="BtnRescan_Click"/>
+                <Separator />
+                <MenuItem Header="Close To Tray" InputGestureText="Ctrl+F4" />
+                <MenuItem Header="Quit" InputGestureText="Ctrl+Q" Click="BtnQuit_Click"/>
+            </MenuItem>
+            <MenuItem Header="_Edit">
+                <MenuItem Header="Dictionaries..." InputGestureText="F3" Click="BtnAddDict_Click"/>
+                <MenuItem Header="Preferences..." InputGestureText="F4" />
+            </MenuItem>
+            <MenuItem Header="_View">
+                <MenuItem Header="Zoom">
+                    <MenuItem Header="Zoom In" InputGestureText="Ctrl++" />
+                    <MenuItem Header="Zoom Out" InputGestureText="Ctrl+-" />
+                    <MenuItem Header="Normal Size" InputGestureText="Ctrl+0" />
+                </MenuItem>
+                <Separator />
+                <MenuItem Header="Show Small Icons in Toolbars" IsCheckable="True" />
+                <MenuItem Header="Show Large Icons in Toolbars" IsCheckable="True" />
+                <MenuItem Header="Show Normal Icons in Toolbars" IsCheckable="True" IsChecked="True" />
+            </MenuItem>
+            <MenuItem Header="_History">
+                <MenuItem Header="Show" InputGestureText="Ctrl+H" />
+                <MenuItem Header="Export" />
+                <MenuItem Header="Import" />
+                <Separator />
+                <MenuItem Header="Clear" Click="BtnClearHistory_Click"/>
+            </MenuItem>
+            <MenuItem Header="S_earch">
+                <MenuItem Header="Search in page" InputGestureText="Ctrl+F" />
+                <MenuItem Header="Full-text search" InputGestureText="Ctrl+Shift+F" />
+            </MenuItem>
+            <MenuItem Header="Favo_rites">
+                <MenuItem Header="Show" InputGestureText="Ctrl+I" />
+                <MenuItem Header="Export" />
+                <MenuItem Header="Import" />
+                <Separator />
+                <MenuItem Header="Add" InputGestureText="Ctrl+E" />
+            </MenuItem>
+            <MenuItem Header="_Help">
+                <MenuItem Header="EchoDict reference" InputGestureText="F1" />
+                <Separator />
+                <MenuItem Header="Homepage" />
+                <MenuItem Header="Forum" />
+                <Separator />
+                <MenuItem Header="Configuration Folder" InputGestureText="F11" />
+                <Separator />
+                <MenuItem Header="About" />
+            </MenuItem>
+        </Menu>
+
+        <!-- Toolbar -->
+        <ToolBarTray DockPanel.Dock="Top">
+            <ToolBar>
+                <Button Content="Back" ToolTip="Back" Click="BtnBack_Click" />
+                <Button Content="Forward" ToolTip="Forward" Click="BtnForward_Click" />
+                <Separator />
+                <ComboBox x:Name="DictSelector" Width="150" IsEditable="False" SelectionChanged="DictSelector_SelectionChanged">
+                </ComboBox>
+                <Separator />
+                <Button Content="Scan" ToolTip="Toggle clipboard monitoring" />
+                <Separator />
+                <Button Content="Pronounce" ToolTip="Pronounce Word (Alt+S)" IsEnabled="False" />
+                <Separator />
+                <Button Content="In" ToolTip="Zoom In" />
+                <Button Content="Out" ToolTip="Zoom Out" />
+                <Button Content="1:1" ToolTip="Normal Size" />
+                <Separator />
+                <Button Content="Save" ToolTip="Save Article" />
+                <Button Content="Print" ToolTip="Print" />
+                <Separator />
+                <Button Content="Fav" ToolTip="Add current tab to Favorites" />
+            </ToolBar>
+        </ToolBarTray>
+
+        <!-- Main Content Grid -->
+        <Grid>
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="200" MinWidth="100" />
+                <ColumnDefinition Width="Auto" />
+                <ColumnDefinition Width="*" />
+                <ColumnDefinition Width="Auto" />
+                <ColumnDefinition Width="200" MinWidth="100" />
+            </Grid.ColumnDefinitions>
+
+            <!-- Left Pane: Search Pane -->
+            <Grid Grid.Column="0">
+                <Grid.RowDefinitions>
+                    <RowDefinition Height="Auto" />
+                    <RowDefinition Height="*" />
+                </Grid.RowDefinitions>
+                <!-- Title Bar Simulation -->
+                <Border Background="{DynamicResource {x:Static SystemColors.ActiveCaptionBrushKey}}" Padding="2">
+                    <TextBlock Text="Search Pane" Foreground="{DynamicResource {x:Static SystemColors.ActiveCaptionTextBrushKey}}" FontWeight="Bold"/>
+                </Border>
+                
+                <DockPanel Grid.Row="1" LastChildFill="True">
+                    <TextBox DockPanel.Dock="Top" x:Name="SideSearchBox" Margin="2" KeyUp="TxtSearch_KeyUp" />
+                    <ListBox x:Name="WordList" Margin="2" SelectionChanged="WordList_SelectionChanged" />
+                </DockPanel>
+            </Grid>
+
+            <!-- Splitter 1 -->
+            <GridSplitter Grid.Column="1" HorizontalAlignment="Center" VerticalAlignment="Stretch" Width="3" Background="LightGray" />
+
+            <!-- Center Pane: Tab Widget -->
+            <TabControl Grid.Column="2" x:Name="MainTabControl">
+                <TabItem Header="New Tab">
+                    <cef:ChromiumWebBrowser x:Name="Browser" />
+                </TabItem>
+            </TabControl>
+
+            <!-- Splitter 2 -->
+            <GridSplitter Grid.Column="3" HorizontalAlignment="Center" VerticalAlignment="Stretch" Width="3" Background="LightGray" />
+
+            <!-- Right Pane: Results/Favorites/History -->
+            <Grid Grid.Column="4">
+                <TabControl>
+                    <TabItem Header="Results">
+                         <DockPanel>
+                             <Border DockPanel.Dock="Top" Background="{DynamicResource {x:Static SystemColors.ActiveCaptionBrushKey}}" Padding="2">
+                                <TextBlock Text="Found in Dictionaries:" Foreground="{DynamicResource {x:Static SystemColors.ActiveCaptionTextBrushKey}}" FontWeight="Bold"/>
+                            </Border>
+                            <ListBox x:Name="DictsList" Margin="2" />
+                        </DockPanel>
+                    </TabItem>
+                    <TabItem Header="Favorites">
+                        <TreeView x:Name="FavoritesTree" Margin="2" />
+                    </TabItem>
+                    <TabItem Header="History">
+                        <ListBox x:Name="HistoryList" Margin="2" SelectionChanged="HistoryList_SelectionChanged" />
+                    </TabItem>
+                </TabControl>
+            </Grid>
+        </Grid>
+    </DockPanel>
+</Window>

src/WpfEditor/EchoDictWindow.xaml.cs

@@ -1,13 +1,509 @@
+using System;
+using System.Text;
 using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Navigation;
+using System.Windows.Shapes;
+using Microsoft.Win32;
+using System.Collections.Generic;
+using System.Linq;
+using CefSharp;
+using CefSharp.Wpf;
+using System.Text.Json;
 
-namespace WpfEditor
+namespace Echodict
 {
-    public partial class EchoDictWindow : Window
+    /// <summary>
+    /// Interaction logic for EchodictWindow.xaml
+    /// </summary>
+    public partial class EchodictWindow : Window
     {
-        public EchoDictWindow(string text)
+        private List<Dictionary> _dicts = new List<Dictionary>();
+        private List<string> _sourcePaths = new List<string>();
+        private List<DictGroup> _groups = new List<DictGroup>();
+        private string _currentSelectionId = "ALL";
+        private bool _isReady = false;
+
+        public EchodictWindow()
         {
             InitializeComponent();
-            textBlock.Text = text;
+            LoadConfig();
+            
+            // Initial scan if we have paths but no dicts loaded yet
+            if (_sourcePaths.Count > 0)
+            {
+                Loaded += (s, e) => ScanAndLoadDictionaries();
+            }
+            else
+            {
+                // Initialize empty selector
+                RefreshDictSelector();
+            }
+
+            Browser.RequestHandler = new DictRequestHandler(_dicts, (query) =>
+            {
+                Dispatcher.Invoke(() =>
+                {
+                    SideSearchBox.Text = query;
+                    Search(query, true);
+                });
+            });
+
+            _isReady = true;
+        }
+
+        private void LoadConfig()
+        {
+            try
+            {
+                string path = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "echodictconfig.json");
+                if (System.IO.File.Exists(path))
+                {
+                    string json = System.IO.File.ReadAllText(path);
+                    var config = JsonSerializer.Deserialize<EchodictConfig>(json);
+                    if (config != null)
+                    {
+                        _sourcePaths = config.SourcePaths ?? new List<string>();
+                        _groups = config.Groups ?? new List<DictGroup>();
+                        _currentSelectionId = config.LastSelectedDictId ?? "ALL";
+                        
+                        if (config.History != null)
+                        {
+                            foreach (var item in config.History)
+                            {
+                                HistoryList.Items.Add(item);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                System.Diagnostics.Debug.WriteLine($"Error loading config: {ex.Message}");
+            }
+        }
+
+        private void SaveConfig()
+        {
+            try
+            {
+                var config = new EchodictConfig
+                {
+                    SourcePaths = _sourcePaths,
+                    Groups = _groups,
+                    LastSelectedDictId = _currentSelectionId,
+                    History = HistoryList.Items.Cast<string>().ToList()
+                };
+                var options = new JsonSerializerOptions 
+                { 
+                    WriteIndented = true,
+                    Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping
+                };
+                string json = JsonSerializer.Serialize(config, options);
+                string path = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "echodictconfig.json");
+                System.IO.File.WriteAllText(path, json, Encoding.UTF8);
+            }
+            catch (Exception ex)
+            {
+                 System.Diagnostics.Debug.WriteLine($"Error saving config: {ex.Message}");
+            }
+        }
+
+        private void BtnAddDict_Click(object sender, RoutedEventArgs e)
+        {
+            var dlg = new EditDictionaries(_sourcePaths, _groups, _dicts);
+            dlg.Owner = this;
+            if (dlg.ShowDialog() == true)
+            {
+                _sourcePaths = dlg.SourcePaths;
+                _groups = dlg.Groups;
+                
+                // Save immediately
+                SaveConfig();
+
+                if (dlg.NeedsRescan)
+                {
+                    ScanAndLoadDictionaries();
+                }
+                else
+                {
+                    // If groups changed but no rescan needed, just refresh selector
+                    RefreshDictSelector();
+                }
+            }
+        }
+
+        private void BtnRescan_Click(object sender, RoutedEventArgs e)
+        {
+             bool force = (Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control;
+             if (force)
+             {
+                 if (MessageBox.Show("Force rebuild all indexes? This may take time.", "Rebuild Indexes", MessageBoxButton.YesNo) != MessageBoxResult.Yes)
+                 {
+                     return;
+                 }
+             }
+             ScanAndLoadDictionaries(force);
+        }
+
+        private void ScanAndLoadDictionaries(bool forceRebuild = false)
+        {
+            // Dispose existing dictionaries
+            foreach (var dict in _dicts)
+            {
+                dict.Dispose();
+            }
+            _dicts.Clear();
+            DictsList.Items.Clear();
+            
+            string cacheDir = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Cache");
+            if (!System.IO.Directory.Exists(cacheDir))
+            {
+                System.IO.Directory.CreateDirectory(cacheDir);
+            }
+
+            foreach (var path in _sourcePaths)
+            {
+                if (System.IO.Directory.Exists(path))
+                {
+                    try
+                    {
+                        var files = System.IO.Directory.GetFiles(path, "*.mdx", System.IO.SearchOption.AllDirectories);
+                        foreach (var file in files)
+                        {
+                            try
+                            {
+                                LoadDictionary(file, cacheDir, forceRebuild);
+                            }
+                            catch (Exception ex)
+                            {
+                                System.Diagnostics.Debug.WriteLine($"Failed to load {file}: {ex.Message}");
+                            }
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        System.Diagnostics.Debug.WriteLine($"Failed to scan {path}: {ex.Message}");
+                    }
+                }
+            }
+            
+            RefreshDictSelector();
+            SaveConfig(); // Save to persist any state if needed, though mostly redundant here
+            
+            // MessageBox.Show($"Loaded {_dicts.Count} dictionaries.", "Scan Complete");
+        }
+        
+        private void RefreshDictSelector()
+        {
+            // Preserve selection if possible?
+            // For now reset to All
+            DictSelector.Items.Clear();
+            
+            var allItem = new ComboBoxItem { Content = "All Dictionaries", Tag = "ALL" };
+            DictSelector.Items.Add(allItem);
+            
+            // Groups
+            foreach (var group in _groups)
+            {
+                DictSelector.Items.Add(new ComboBoxItem { Content = $"[Group] {group.Name}", Tag = group });
+            }
+            
+            // Individual Dictionaries
+            foreach (var dict in _dicts)
+            {
+                DictSelector.Items.Add(new ComboBoxItem { Content = dict.Name, Tag = dict });
+            }
+            
+            // Restore selection
+            bool matched = false;
+            foreach (ComboBoxItem item in DictSelector.Items)
+            {
+                if (GetItemId(item) == _currentSelectionId)
+                {
+                    DictSelector.SelectedItem = item;
+                    matched = true;
+                    break;
+                }
+            }
+
+            if (!matched)
+            {
+                DictSelector.SelectedIndex = 0;
+            }
+        }
+
+        private string GetItemId(ComboBoxItem item)
+        {
+            if (item.Tag is string s && s == "ALL") return "ALL";
+            if (item.Tag is DictGroup g) return "GROUP:" + g.Name;
+            if (item.Tag is Dictionary d) return "DICT:" + d.Id;
+            return "";
+        }
+
+        private void BtnClearHistory_Click(object sender, RoutedEventArgs e)
+        {
+            if (MessageBox.Show("Are you sure you want to clear the history?", "Clear History", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes)
+            {
+                HistoryList.Items.Clear();
+                SaveConfig();
+            }
+        }
+
+        private void BtnBack_Click(object sender, RoutedEventArgs e)
+        {
+            if (HistoryList.Items.Count == 0) return;
+
+            int newIndex = HistoryList.SelectedIndex + 1;
+            
+            // If nothing is selected, we assume we are at the "latest" state (conceptually index 0 is current),
+            // so Back should go to index 1.
+            // Note: If we just added an item, it is at index 0 but typically not selected.
+            if (HistoryList.SelectedIndex == -1)
+            {
+                newIndex = 1;
+            }
+
+            if (newIndex < HistoryList.Items.Count)
+            {
+                HistoryList.SelectedIndex = newIndex;
+                HistoryList.ScrollIntoView(HistoryList.SelectedItem);
+            }
+        }
+
+        private void BtnForward_Click(object sender, RoutedEventArgs e)
+        {
+            if (HistoryList.Items.Count == 0) return;
+
+            if (HistoryList.SelectedIndex > 0)
+            {
+                HistoryList.SelectedIndex = HistoryList.SelectedIndex - 1;
+                HistoryList.ScrollIntoView(HistoryList.SelectedItem);
+            }
+            // If SelectedIndex is -1 or 0, we are already at the latest, so do nothing.
+        }
+
+        private void BtnQuit_Click(object sender, RoutedEventArgs e)
+        {
+            Close();
+        }
+
+        private void LoadDictionary(string path, string cacheDir, bool forceRebuild)
+        {
+            Dictionary dict = new Dictionary(path, cacheDir, forceRebuild);
+            _dicts.Add(dict);
+        }
+
+        private void TxtSearch_KeyUp(object sender, KeyEventArgs e)
+        {
+            if (e.Key == Key.Enter)
+            {
+                Search(SideSearchBox.Text.Trim(), true);
+            }
+        }
+
+        private void Search(string query, bool updateWordList, bool updateHistory = true)
+        {
+            if (string.IsNullOrEmpty(query)) return;
+
+            if (updateWordList)
+            {
+                WordList.Items.Clear();
+            }
+
+            // Clear the dictionary list in the result panel
+            DictsList.Items.Clear();
+
+            StringBuilder sb = new StringBuilder();
+            sb.Append("<!DOCTYPE html><html><head><meta charset=\"UTF-8\"><style>img { max-width: 100%; }</style></head><body>");
+
+            bool found = false;
+
+            // Determine which dictionaries to search
+            List<Dictionary> targetDicts = new List<Dictionary>();
+            
+            if (DictSelector.SelectedItem is ComboBoxItem selectedItem)
+            {
+                if (selectedItem.Tag is string s && s == "ALL")
+                {
+                    targetDicts = _dicts;
+                }
+                else if (selectedItem.Tag is DictGroup group)
+                {
+                    targetDicts = _dicts.Where(d => group.DictionaryPaths.Contains(d.Mdx.Filename)).ToList();
+                }
+                else if (selectedItem.Tag is Dictionary dict)
+                {
+                    targetDicts = new List<Dictionary> { dict };
+                }
+            }
+            else
+            {
+                // Fallback
+                targetDicts = _dicts;
+            }
+
+            foreach (var dict in targetDicts)
+            {
+                if (dict.Mdx.Index.ContainsKey(query))
+                {
+                    found = true;
+                    // Create an anchor name for this dictionary
+                    string anchorName = $"dict_{dict.Id}";
+                    
+                    // Add dictionary to the result panel list
+                    ListBoxItem resultItem = new ListBoxItem();
+                    resultItem.Content = dict.Name;
+                    resultItem.Tag = anchorName;
+                    resultItem.MouseDoubleClick += ResultItem_MouseDoubleClick;
+                    DictsList.Items.Add(resultItem);
+
+                    string? def = dict.Mdx.GetDefinition(query);
+                    if (!string.IsNullOrEmpty(def))
+                    {
+                        // Check for multiple redirects
+                        if (def.StartsWith("@@@LINK=") && def.IndexOf("@@@LINK=", 1) != -1)
+                        {
+                            if (updateWordList)
+                            {
+                                // Parse candidates
+                                var links = def.Split(new[] { "@@@LINK=" }, StringSplitOptions.RemoveEmptyEntries);
+                                foreach (var link in links)
+                                {
+                                    string target = link.Trim();
+                                    int nullIndex = target.IndexOf('\0');
+                                    if (nullIndex != -1) target = target.Substring(0, nullIndex);
+                                    target = target.Trim();
+                                    if (!string.IsNullOrEmpty(target) && !WordList.Items.Contains(target))
+                                    {
+                                        WordList.Items.Add(target);
+                                    }
+                                }
+                            }
+                            sb.Append($"<a name=\"{anchorName}\"></a>");
+                            sb.Append($"<h3>{query} <small>({dict.Name})</small></h3>");
+                            sb.Append("<p><i>Multiple candidates found. Please select from the list.</i></p>");
+                            sb.Append("<hr/>");
+                            continue;
+                        }
+
+                        // Rewrite relative links to include dictionary ID for isolation
+                        // Matches src="..." or href="..." where value doesn't start with http, https, data:, #, or entry:
+                        string pattern = @"(?i)(src|href)=[""'](?!http|https|data:|#|entry:)([^""']+)[""']";
+                        string replacement = $"$1=\"http://custom-rendering/{dict.Id}/$2\"";
+                        def = System.Text.RegularExpressions.Regex.Replace(def, pattern, replacement);
+                    }
+
+                    sb.Append($"<a name=\"{anchorName}\"></a>");
+                    sb.Append($"<h3>{query} <small>({dict.Name})</small></h3>"); 
+                    sb.Append("<hr/>");
+                    sb.Append(def);
+                    sb.Append("<br/><br/>");
+                }
+            }
+
+            if (found && updateHistory)
+            {
+                AddToHistory(query);
+            }
+
+            if (!found)
+            {
+                sb.Append($"<h3>No results found for '{query}'</h3>");
+            }
+
+            sb.Append("</body></html>");
+            
+            // Use RequestHandler to serve the content
+            if (Browser.RequestHandler is DictRequestHandler handler)
+            {
+                handler.SetSearchHtml(sb.ToString());
+                Browser.Load("http://custom-rendering/result.html");
+            }
+            else
+            {
+                // Fallback (should not happen if initialized correctly)
+                Browser.LoadHtml(sb.ToString(), "http://custom-rendering/");
+            }
+        }
+
+        private void DictSelector_SelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            if (!_isReady) return;
+
+            if (DictSelector.SelectedItem is ComboBoxItem item)
+            {
+                _currentSelectionId = GetItemId(item);
+                SaveConfig();
+            }
+
+            // Check if SideSearchBox is initialized (FIX for NRE)
+            if (SideSearchBox == null) return;
+
+            // Re-search if we have a query
+            if (!string.IsNullOrEmpty(SideSearchBox.Text))
+            {
+                Search(SideSearchBox.Text, false); 
+            }
+        }
+
+        private void WordList_SelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+             if (WordList.SelectedItem != null)
+             {
+                 Search(WordList.SelectedItem.ToString(), false);
+             }
+        }
+
+        private void ResultItem_MouseDoubleClick(object sender, MouseButtonEventArgs e)
+        {
+            if (sender is ListBoxItem item && item.Tag is string anchorName)
+            {
+                // Execute JavaScript to scroll to the anchor
+                string script = $@"
+                    var element = document.getElementsByName('{anchorName}')[0];
+                    if (element) {{
+                        element.scrollIntoView({{ behavior: 'smooth', block: 'start' }});
+                    }}
+                ";
+                Browser.ExecuteScriptAsync(script);
+            }
+        }
+
+        private void AddToHistory(string query)
+        {
+            if (HistoryList.Items.Contains(query))
+            {
+                HistoryList.Items.Remove(query);
+            }
+            HistoryList.Items.Insert(0, query);
+            
+            // Limit history size to prevent config bloat
+            while (HistoryList.Items.Count > 100)
+            {
+                HistoryList.Items.RemoveAt(HistoryList.Items.Count - 1);
+            }
+
+            SaveConfig();
+        }
+
+        private void HistoryList_SelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            if (HistoryList.SelectedItem != null)
+            {
+                string? query = HistoryList.SelectedItem.ToString();
+                if (!string.IsNullOrEmpty(query))
+                {
+                    SideSearchBox.Text = query;
+                    // Do not update history (reorder) when navigating history
+                    Search(query, true, false);
+                }
+            }
         }
     }
-}
+}

src/WpfEditor/EditDictionaries.xaml

@@ -0,0 +1,75 @@
+<Window x:Class="Echodict.EditDictionaries"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Title="Edit Dictionaries" Height="400" Width="600" WindowStartupLocation="CenterOwner">
+    <Grid Margin="10">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="Auto"/>
+        </Grid.RowDefinitions>
+
+        <TabControl Grid.Row="0" Margin="0,0,0,10">
+            <TabItem Header="Sources">
+                <Grid Margin="5">
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto"/>
+                        <RowDefinition Height="*"/>
+                        <RowDefinition Height="Auto"/>
+                    </Grid.RowDefinitions>
+                    <Label Content="Dictionary Sources (Folders):" Grid.Row="0" FontWeight="Bold"/>
+                    <ListBox x:Name="PathsList" Grid.Row="1" Margin="0,5"/>
+                    <StackPanel Grid.Row="2" Orientation="Horizontal" HorizontalAlignment="Right">
+                        <Button x:Name="BtnAdd" Content="Add Folder..." Width="100" Margin="0,0,10,0" Click="BtnAdd_Click"/>
+                        <Button x:Name="BtnRemove" Content="Remove" Width="80" Click="BtnRemove_Click"/>
+                    </StackPanel>
+                </Grid>
+            </TabItem>
+            
+            <TabItem Header="Groups">
+                <Grid Margin="5">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="*"/>
+                        <ColumnDefinition Width="10"/>
+                        <ColumnDefinition Width="*"/>
+                    </Grid.ColumnDefinitions>
+                    
+                    <!-- Left: Groups List -->
+                    <Grid Grid.Column="0">
+                        <Grid.RowDefinitions>
+                            <RowDefinition Height="Auto"/>
+                            <RowDefinition Height="*"/>
+                            <RowDefinition Height="Auto"/>
+                        </Grid.RowDefinitions>
+                        <Label Content="Groups:" Grid.Row="0" FontWeight="Bold"/>
+                        <ListBox x:Name="GroupsList" Grid.Row="1" Margin="0,5" SelectionChanged="GroupsList_SelectionChanged"/>
+                        <StackPanel Grid.Row="2" Orientation="Horizontal">
+                            <Button x:Name="BtnAddGroup" Content="Add" Width="60" Margin="0,0,5,0" Click="BtnAddGroup_Click"/>
+                            <Button x:Name="BtnRemoveGroup" Content="Remove" Width="60" Click="BtnRemoveGroup_Click"/>
+                        </StackPanel>
+                    </Grid>
+                    
+                    <!-- Right: Dictionaries in Group -->
+                    <Grid Grid.Column="2">
+                        <Grid.RowDefinitions>
+                            <RowDefinition Height="Auto"/>
+                            <RowDefinition Height="*"/>
+                        </Grid.RowDefinitions>
+                        <Label Content="Dictionaries in Group:" Grid.Row="0" FontWeight="Bold"/>
+                        <ListBox x:Name="GroupDictsList" Grid.Row="1" Margin="0,5">
+                            <ListBox.ItemTemplate>
+                                <DataTemplate>
+                                    <CheckBox Content="{Binding Name}" IsChecked="{Binding IsSelected}" Click="DictInGroup_Click" Tag="{Binding Path}"/>
+                                </DataTemplate>
+                            </ListBox.ItemTemplate>
+                        </ListBox>
+                    </Grid>
+                </Grid>
+            </TabItem>
+        </TabControl>
+        
+        <StackPanel Grid.Row="1" Orientation="Horizontal" HorizontalAlignment="Right">
+            <Button x:Name="BtnRescan" Content="Rescan &amp; Apply" Width="120" Margin="0,0,10,0" Click="BtnRescan_Click"/>
+            <Button x:Name="BtnCancel" Content="Cancel" Width="80" Click="BtnCancel_Click"/>
+        </StackPanel>
+    </Grid>
+</Window>

src/WpfEditor/EditDictionaries.xaml.cs

@@ -0,0 +1,195 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using Microsoft.Win32;
+
+namespace Echodict
+{
+    public partial class EditDictionaries : Window
+    {
+        public List<string> SourcePaths { get; private set; }
+        public List<DictGroup> Groups { get; private set; }
+        public bool NeedsRescan { get; private set; } = false;
+
+        private List<Dictionary> _availableDicts;
+
+        public EditDictionaries(List<string> currentPaths, List<DictGroup> currentGroups, List<Dictionary> availableDicts)
+        {
+            InitializeComponent();
+            SourcePaths = new List<string>(currentPaths);
+            
+            // Clone groups
+            Groups = new List<DictGroup>();
+            if (currentGroups != null)
+            {
+                foreach (var g in currentGroups)
+                {
+                    Groups.Add(new DictGroup
+                    {
+                        Name = g.Name,
+                        DictionaryPaths = new List<string>(g.DictionaryPaths)
+                    });
+                }
+            }
+
+            _availableDicts = availableDicts ?? new List<Dictionary>();
+
+            RefreshPathsList();
+            RefreshGroupsList();
+        }
+
+        private void RefreshPathsList()
+        {
+            PathsList.ItemsSource = null;
+            PathsList.ItemsSource = SourcePaths;
+        }
+
+        private void RefreshGroupsList()
+        {
+            var selected = GroupsList.SelectedItem;
+            GroupsList.ItemsSource = null;
+            GroupsList.ItemsSource = Groups;
+            GroupsList.DisplayMemberPath = "Name";
+            if (selected != null && Groups.Contains(selected))
+            {
+                GroupsList.SelectedItem = selected;
+            }
+        }
+
+        private void GroupsList_SelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            if (GroupsList.SelectedItem is DictGroup group)
+            {
+                // Populate GroupDictsList
+                var viewModels = _availableDicts.Select(d => new DictSelectionViewModel
+                {
+                    Name = d.Name,
+                    Path = d.Mdx.Filename, // Assuming Mdx.Filename is the unique path
+                    IsSelected = group.DictionaryPaths.Contains(d.Mdx.Filename)
+                }).ToList();
+
+                GroupDictsList.ItemsSource = viewModels;
+            }
+            else
+            {
+                GroupDictsList.ItemsSource = null;
+            }
+        }
+
+        private void DictInGroup_Click(object sender, RoutedEventArgs e)
+        {
+            if (GroupsList.SelectedItem is DictGroup group && sender is CheckBox cb && cb.Tag is string path)
+            {
+                if (cb.IsChecked == true)
+                {
+                    if (!group.DictionaryPaths.Contains(path))
+                        group.DictionaryPaths.Add(path);
+                }
+                else
+                {
+                    group.DictionaryPaths.Remove(path);
+                }
+            }
+        }
+
+        private void BtnAdd_Click(object sender, RoutedEventArgs e)
+        {
+            var dialog = new OpenFolderDialog();
+            dialog.Title = "Select Dictionary Folder";
+            dialog.Multiselect = false;
+            
+            if (dialog.ShowDialog() == true)
+            {
+                string path = dialog.FolderName;
+                if (!SourcePaths.Contains(path))
+                {
+                    SourcePaths.Add(path);
+                    RefreshPathsList();
+                }
+            }
+        }
+
+        private void BtnRemove_Click(object sender, RoutedEventArgs e)
+        {
+            if (PathsList.SelectedItem is string path)
+            {
+                SourcePaths.Remove(path);
+                RefreshPathsList();
+            }
+        }
+
+        private void BtnAddGroup_Click(object sender, RoutedEventArgs e)
+        {
+            string name = SimpleInput.ShowDialog("Enter Group Name:", "New Group");
+            if (!string.IsNullOrWhiteSpace(name))
+            {
+                Groups.Add(new DictGroup { Name = name });
+                RefreshGroupsList();
+                GroupsList.SelectedIndex = Groups.Count - 1;
+            }
+        }
+
+        private void BtnRemoveGroup_Click(object sender, RoutedEventArgs e)
+        {
+            if (GroupsList.SelectedItem is DictGroup group)
+            {
+                Groups.Remove(group);
+                RefreshGroupsList();
+            }
+        }
+        
+        private void BtnRescan_Click(object sender, RoutedEventArgs e)
+        {
+             NeedsRescan = true;
+             DialogResult = true;
+             Close();
+        }
+
+        private void BtnCancel_Click(object sender, RoutedEventArgs e)
+        {
+            DialogResult = false;
+            Close();
+        }
+    }
+
+    public class DictSelectionViewModel
+    {
+        public string Name { get; set; } = string.Empty;
+        public string Path { get; set; } = string.Empty;
+        public bool IsSelected { get; set; }
+    }
+
+    public static class SimpleInput
+    {
+        public static string ShowDialog(string text, string caption)
+        {
+            Window prompt = new Window()
+            {
+                Width = 300,
+                Height = 150,
+                Title = caption,
+                WindowStartupLocation = WindowStartupLocation.CenterScreen,
+                ResizeMode = ResizeMode.NoResize
+            };
+            StackPanel sp = new StackPanel() { Margin = new Thickness(10) };
+            Label lbl = new Label() { Content = text };
+            TextBox txt = new TextBox();
+            Button btn = new Button() { Content = "OK", Width = 80, Margin = new Thickness(0, 10, 0, 0), HorizontalAlignment = HorizontalAlignment.Center };
+            btn.Click += (sender, e) => { prompt.DialogResult = true; prompt.Close(); };
+            
+            sp.Children.Add(lbl);
+            sp.Children.Add(txt);
+            sp.Children.Add(btn);
+            prompt.Content = sp;
+            
+            txt.Focus();
+
+            if (prompt.ShowDialog() == true)
+                return txt.Text;
+            else
+                return "";
+        }
+    }
+}

src/WpfEditor/OCRResultWindow.xaml.cs

@@ -83,8 +83,8 @@ namespace WpfEditor
 
         private void EchodictMenuItem_Click(object sender, RoutedEventArgs e)
         {
-            var win = new EchoDictWindow(selectText);
-            win.Show();
+            //var win = new EchoDictWindow(selectText);
+            //win.Show();
         }
 
     }

src/WpfEditor/TextEditorControl.cs

@@ -1,3 +1,4 @@
+using Echodict;
 using Microsoft.Win32;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
@@ -313,7 +314,15 @@ namespace WpfEditor
             Command = ApplicationCommands.SelectAll
         };
         ContextMenu.Items.Add(selectAllMenuItem);
-        
+
+        // 查询菜单项
+        MenuItem QeryMenuItem = new MenuItem
+        {
+            Header = "查询"
+        };
+        QeryMenuItem.Click += OnQeryMenuItemClick;
+        ContextMenu.Items.Add(QeryMenuItem);
+
         // 翻译菜单项
         MenuItem translateMenuItem = new MenuItem
         {
@@ -374,6 +383,20 @@ namespace WpfEditor
             }
         }
 
+        // "翻译"菜单项点击事件处理
+        private async void OnQeryMenuItemClick(object sender, RoutedEventArgs e)
+        {
+            if (HasSelection())
+            {
+                string text = GetSelectedText();
+
+                var win = new Echodict.EchodictWindow();
+                win.Owner = Window.GetWindow(this);
+                win.WindowStartupLocation = WindowStartupLocation.CenterOwner;
+                win.ShowDialog();
+            }
+        }
+
         #region 属性
 
         public string Text

src/WpfEditor/TreeMenuPage.xaml

@@ -4,7 +4,7 @@
         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
         mc:Ignorable="d"
-        Title="EchoDict" Height="600" Width="800">
+        Title="EchoEditor" Height="600" Width="800">
     <Grid>
         <!-- 主容器 -->
         <Grid.ColumnDefinitions>

src/WpfEditor/WpfEditor.csproj

@@ -24,6 +24,7 @@
       </ItemGroup>
 
     <ItemGroup>
+      <ProjectReference Include="..\EchoDictLib\EchoDictLib.csproj" />
       <ProjectReference Include="..\ScreenGrab\ScreenGrab.csproj" />
       <ProjectReference Include="..\WeChatOcrCpp\WeChatOcrCpp.vcxproj" />
     </ItemGroup>