diff --git a/dict/src/floatwin.cpp b/dict/src/floatwin.cpp
index aa82fd8..2caa078 100644
--- a/dict/src/floatwin.cpp
+++ b/dict/src/floatwin.cpp
@@ -642,8 +642,9 @@ gboolean FloatWin::vButtonPressCallback (GtkWidget * widget, GdkEventButton * ev
 		if (oFloatWin->content_state == ContentState_NotFound) {
 			std::string QueryingWord(oFloatWin->QueryingWord);
 			gpAppFrame->LookupWithFuzzyToFloatWin(QueryingWord.c_str());
-		} else
+		} else {
 			oFloatWin->Hide();
+		}
 	}
 
 	return true;
diff --git a/dict/src/lib/stardict_client.cpp b/dict/src/lib/stardict_client.cpp
index 8659f70..38c4dd9 100644
--- a/dict/src/lib/stardict_client.cpp
+++ b/dict/src/lib/stardict_client.cpp
@@ -212,6 +212,14 @@ STARDICT::Cmd::Cmd(int cmd, ...)
 		this->lookup_response = NULL;
 		break;
 	}
+	case CMD_FUZZY_QUERY:
+	{
+		std::string earg;
+		arg_escape(earg, va_arg( ap, const char * ));
+		this->data = g_strdup_printf("fuzzyquery %s\n", earg.c_str());
+		this->lookup_response = NULL;
+		break;
+	}
 	case CMD_SMART_QUERY:
 	{
 		std::string earg;
@@ -390,7 +398,7 @@ STARDICT::Cmd::~Cmd()
     } else {
         g_free(this->data);
     }
-    if (this->command == CMD_LOOKUP || this->command == CMD_DEFINE || this->command == CMD_SELECT_QUERY || this->command == CMD_SMART_QUERY) {
+    if (this->command == CMD_LOOKUP || this->command == CMD_DEFINE || this->command == CMD_SELECT_QUERY || this->command == CMD_FUZZY_QUERY || this->command == CMD_SMART_QUERY) {
         delete this->lookup_response;
     } else if (this->command == CMD_PREVIOUS || this->command == CMD_NEXT) {
         if (this->wordlist_response) {
@@ -544,13 +552,14 @@ void StarDictClient::set_auth(const char *user, const char *md5saltpasswd)
 
 bool StarDictClient::try_cache(STARDICT::Cmd *c)
 {
-    if (c->command == STARDICT::CMD_LOOKUP || c->command == STARDICT::CMD_DEFINE || c->command == STARDICT::CMD_SELECT_QUERY || c->command == STARDICT::CMD_SMART_QUERY) {
+    if (c->command == STARDICT::CMD_LOOKUP || c->command == STARDICT::CMD_DEFINE || c->command == STARDICT::CMD_SELECT_QUERY || c->command == STARDICT::CMD_FUZZY_QUERY || c->command == STARDICT::CMD_SMART_QUERY) {
         STARDICT::LookupResponse *res = get_cache_lookup_response(c->data);
         if (res) {
-            if (c->command == STARDICT::CMD_LOOKUP || c->command == STARDICT::CMD_DEFINE)
+            if (c->command == STARDICT::CMD_LOOKUP || c->command == STARDICT::CMD_DEFINE) {
                 on_lookup_end_.emit(res, 0);
-            else if (c->command == STARDICT::CMD_SELECT_QUERY || c->command == STARDICT::CMD_SMART_QUERY)
+            } else if (c->command == STARDICT::CMD_SELECT_QUERY || c->command == STARDICT::CMD_FUZZY_QUERY || c->command == STARDICT::CMD_SMART_QUERY)
                 on_floatwin_lookup_end_.emit(res, 0);
+			}
             delete c;
             return true;
         } else {
@@ -1249,7 +1258,138 @@ int StarDictClient::parse_dict_result(STARDICT::Cmd* cmd, gchar *buf)
                 save_cache_lookup_response(cmd->data, cmd->lookup_response);
                 cmd->lookup_response = NULL;
                 return 1;
-            } else if ( cmd->command == STARDICT::CMD_SELECT_QUERY || cmd->command == STARDICT::CMD_SMART_QUERY) {
+            } else if ( cmd->command == STARDICT::CMD_SELECT_QUERY || cmd->command == STARDICT::CMD_FUZZY_QUERY || cmd->command == STARDICT::CMD_SMART_QUERY) {
+                on_floatwin_lookup_end_.emit(cmd->lookup_response, cmd->seq);
+                save_cache_lookup_response(cmd->data, cmd->lookup_response);
+                cmd->lookup_response = NULL;
+                return 1;
+            }
+            cmd->reading_status = 6;
+            reading_type_ = READ_STRING;
+        } else {
+            struct STARDICT::LookupResponse::DictResponse::DictResult *dict_result = new STARDICT::LookupResponse::DictResponse::DictResult();
+            dict_result->bookname = buf;
+            cmd->lookup_response->dict_response.dict_result_list.push_back(dict_result);
+            cmd->reading_status = 3;
+        }
+    } else if (cmd->reading_status == 3) { // Read word.
+        if (*buf == '\0') {
+            g_free(buf);
+            cmd->reading_status = 2;
+        } else {
+            struct STARDICT::LookupResponse::DictResponse::DictResult::WordResult *word_result = new STARDICT::LookupResponse::DictResponse::DictResult::WordResult();
+            word_result->word = buf;
+            cmd->lookup_response->dict_response.dict_result_list.back()->word_result_list.push_back(word_result);;
+            cmd->reading_status = 4;
+            reading_type_ = READ_SIZE;
+	    size_data = (char *)g_malloc(sizeof(guint32));
+	    size_count = size_left = sizeof(guint32);
+        }
+    } else if (cmd->reading_status == 4) {
+        guint32 datasize = g_ntohl(get_uint32(buf));
+	memcpy(buf, &datasize, sizeof(guint32));
+        if (datasize == 0) {
+	    g_free(buf);
+            cmd->reading_status = 3;
+            reading_type_ = READ_STRING;
+        } else {
+		    if (datasize > 4*1024*1024) {
+		    	g_print(_("Drop data for security. Data too big! More than 4M!\n"));
+				return 1;
+	    	} else {
+			    cmd->reading_status = 5;
+			    size_data = (char *)g_realloc(buf, datasize + sizeof(guint32));
+			    size_count = datasize + sizeof(guint32);
+			    size_left = datasize;
+	    	}
+        }
+    } else if (cmd->reading_status == 5) {
+            cmd->lookup_response->dict_response.dict_result_list.back()->word_result_list.back()->datalist.push_back(buf);
+	    cmd->reading_status = 4;
+	    size_data = (char *)g_malloc(sizeof(guint32));
+	    size_count = size_left = sizeof(guint32);
+    } else if (cmd->reading_status == 6) {
+        if (strcmp(buf, "d") == 0) {
+            cmd->reading_status = 8;
+            cmd->lookup_response->listtype = STARDICT::LookupResponse::ListType_Tree;
+            cmd->lookup_response->wordtree = new std::list<STARDICT::LookupResponse::WordTreeElement *>;
+        } else {
+            cmd->reading_status = 7;
+            if (strcmp(buf, "r") == 0)
+                cmd->lookup_response->listtype = STARDICT::LookupResponse::ListType_Rule_List;
+            else if (strcmp(buf, "g") == 0)
+                cmd->lookup_response->listtype = STARDICT::LookupResponse::ListType_Regex_List;
+            else if (strcmp(buf, "f") == 0)
+                cmd->lookup_response->listtype = STARDICT::LookupResponse::ListType_Fuzzy_List;
+            else 
+                cmd->lookup_response->listtype = STARDICT::LookupResponse::ListType_List;
+            cmd->lookup_response->wordlist = new std::list<char *>;
+        }
+        g_free(buf);
+    } else if (cmd->reading_status == 7) {
+        if (*buf == '\0') {
+            g_free(buf);
+            on_lookup_end_.emit(cmd->lookup_response, cmd->seq);
+            save_cache_lookup_response(cmd->data, cmd->lookup_response);
+            cmd->lookup_response = NULL;
+            return 1;
+        } else {
+            cmd->lookup_response->wordlist->push_back(buf);
+        }
+    } else if (cmd->reading_status == 8) {
+        if (*buf == '\0') {
+            g_free(buf);
+            on_lookup_end_.emit(cmd->lookup_response, cmd->seq);
+            save_cache_lookup_response(cmd->data, cmd->lookup_response);
+            cmd->lookup_response = NULL;
+            return 1;
+        } else {
+            STARDICT::LookupResponse::WordTreeElement *element = new STARDICT::LookupResponse::WordTreeElement();
+            element->bookname = buf;
+            cmd->lookup_response->wordtree->push_back(element);
+            cmd->reading_status = 9;
+        }
+    } else if (cmd->reading_status == 9) {
+        if (*buf == '\0') {
+            g_free(buf);
+            cmd->reading_status = 8;
+        } else {
+            cmd->lookup_response->wordtree->back()->wordlist.push_back(buf);
+        }
+    }
+    return 2;
+}
+
+int StarDictClient::parse_dict_result2(STARDICT::Cmd* cmd, gchar *buf)
+{
+    if (cmd->reading_status == 0) { // Read code.
+        int status;
+        status = atoi(buf);
+        g_free(buf);
+        if (status != CODE_OK) {
+            if (status == CODE_DICTMASK_NOTSET) {
+                on_error_.emit(_("You haven't chosen any dictionaries, please choose some by clicking \"Manage Dict\"->\"Network dictionaries\"->\"Add\"."));
+                return 1;
+            } else {
+                return 0;
+            }
+        }
+        cmd->lookup_response = new STARDICT::LookupResponse();
+        cmd->lookup_response->listtype = STARDICT::LookupResponse::ListType_None;
+        cmd->reading_status = 1;
+        reading_type_ = READ_STRING;
+    } else if (cmd->reading_status == 1) { // Read original word.
+        cmd->lookup_response->dict_response.oword = buf;
+        cmd->reading_status = 2;
+    } else if (cmd->reading_status == 2) { // Read book name.
+        if (*buf == '\0') {
+            g_free(buf);
+            if (cmd->command == STARDICT::CMD_DEFINE) {
+                on_lookup_end_.emit(cmd->lookup_response, cmd->seq);
+                save_cache_lookup_response(cmd->data, cmd->lookup_response);
+                cmd->lookup_response = NULL;
+                return 1;
+            } else if ( cmd->command == STARDICT::CMD_SELECT_QUERY || cmd->command == STARDICT::CMD_FUZZY_QUERY || cmd->command == STARDICT::CMD_SMART_QUERY) {
                 on_floatwin_lookup_end_.emit(cmd->lookup_response, cmd->seq);
                 save_cache_lookup_response(cmd->data, cmd->lookup_response);
                 cmd->lookup_response = NULL;
@@ -1402,6 +1542,9 @@ bool StarDictClient::parse(gchar *line)
         case STARDICT::CMD_SMART_QUERY:
             result = parse_dict_result(cmd, line);
             break;
+        case STARDICT::CMD_FUZZY_QUERY:
+            result = parse_dict_result2(cmd, line);
+            break;
         case STARDICT::CMD_PREVIOUS:
         case STARDICT::CMD_NEXT:
             result = parse_wordlist(cmd, line);
diff --git a/dict/src/lib/stardict_client.h b/dict/src/lib/stardict_client.h
index b45a5c4..c7da618 100644
--- a/dict/src/lib/stardict_client.h
+++ b/dict/src/lib/stardict_client.h
@@ -43,6 +43,7 @@ namespace STARDICT {
 		CMD_NEXT,
 		//CMD_QUERY,
 		CMD_SELECT_QUERY,
+		CMD_FUZZY_QUERY,
 		CMD_SMART_QUERY,
 		CMD_DEFINE,
 		CMD_REGISTER,
@@ -94,6 +95,7 @@ namespace STARDICT {
 			ListType_Regex_List,
 			ListType_Fuzzy_List,
 			ListType_Tree,
+			ListType_FloatWin_Fuzzy_List,
 		};
 		ListType listtype;
 		struct WordTreeElement {
@@ -104,6 +106,8 @@ namespace STARDICT {
 			std::list<char *> *wordlist;
 			std::list<WordTreeElement *> *wordtree;
 		};
+		std::list<char *> *owordlist;
+		std::list<struct DictResponse *> dict_response_list;
 	};
 	class Cmd {
 	public:
@@ -233,6 +237,7 @@ private:
 	int parse_command_maxdictcount(STARDICT::Cmd* cmd, gchar *line);
 	int parse_command_quit(gchar *line);
 	int parse_dict_result(STARDICT::Cmd* cmd, gchar *buf);
+	int parse_dict_result2(STARDICT::Cmd* cmd, gchar *buf);
 	int parse_wordlist(STARDICT::Cmd* cmd, gchar *buf);
 };
 
diff --git a/dict/src/stardict.cpp b/dict/src/stardict.cpp
index 9dcc6d9..c03a969 100644
--- a/dict/src/stardict.cpp
+++ b/dict/src/stardict.cpp
@@ -1372,6 +1372,14 @@ void AppCore::LookupWithFuzzyToFloatWin(const gchar *sWord)
 		for (i=0;i<count;i++)
 			g_free(fuzzy_reslist[i]);
 	}
+	bool enable_netdict = conf->get_bool_at("network/enable_netdict");
+	if (enable_netdict) {
+		STARDICT::Cmd *c = new STARDICT::Cmd(STARDICT::CMD_FUZZY_QUERY, sWord);
+		if (!oStarDictClient.try_cache(c)) {
+			composite_lookup_float_win.send_StarDict_net_request(c->seq);
+			oStarDictClient.send_commands(1, c);
+		}
+	}
 	composite_lookup_float_win.done_lookup();
 	if(composite_lookup_float_win.is_got_all_responses())
 		oFloatWin.EndLookup();
