Attachment #54227 for bug #86379





dnl ******************************

dnl AC_ARG_ENABLE(schemas-install,AC_HELP_STRING([--disable-schemas-install], [Disable installation of the gconf schemas]))
                                             [Disable installation of the gconf
schemas]))

dnl AM_CONDITIONAL(SCHEMAS_INSTALL, test x$enable_schemas_install != xno)

AC_PATH_PROG(GCONFTOOL, gconftool-2, no)
if test x"$GCONFTOOL" = xno; then

fi
AM_GCONF_SOURCE_2

AM_CONDITIONAL(SCHEMAS_INSTALL, test x$schemas_install = xtrue)

dnl
dnl Check popt




		gtk_notebook_set_current_page(GTK_NOTEBOOK(oDictManageDlg->notebook), 1);
}

gboolean DictManageDlg::get_dict_info(gboolean istreedict, const gchar *ifofilename, glong *wordcount, gchar **bookname, gchar **author, gchar **email,
				gchar **website, gchar **date, gchar **description)
{
	struct stat stats;		
	if (stat (ifofilename, &stats) == -1) {
		return false;
	}
		
	FILE *file;
	if (!(file = fopen (ifofilename, "rb"))) {
		return false;
	}
	gchar *buffer = (gchar *)g_malloc (stats.st_size + 1);
	fread (buffer, 1, stats.st_size, file);
	buffer[stats.st_size] = '\0';
	fclose (file);
	
	if (!(istreedict?g_str_has_prefix(buffer, "StarDict's treedict ifo file\nversion=2.4.2\n"):g_str_has_prefix(buffer, "StarDict's dict ifo file\nversion=2.4.2\n"))) {
		g_free(buffer);
		return false;
	}

	gchar *p1,*p2,*p3;
	if (istreedict)
		p1 = buffer + sizeof("StarDict's treedict ifo file\nversion=2.4.2\n") -1 -1;
	else
		p1 = buffer + sizeof("StarDict's dict ifo file\nversion=2.4.2\n") -1 -1;

	p2 = strstr(p1,"\nwordcount=");
	if (p2) {
		p3 = strchr(p2+ sizeof("\nwordcount=")-1,'\n');
		gchar *tmpstr = (gchar *)g_memdup(p2+sizeof("\nwordcount=")-1, p3-(p2+sizeof("\nwordcount=")-1)+1);
		tmpstr[p3-(p2+sizeof("\nwordcount=")-1)] = '\0';
		*wordcount = atol(tmpstr);
		g_free(tmpstr);
	}
	else {
		*wordcount = 0;
	}
	
	p2 = strstr(p1,"\nbookname=");
	if (p2) {
		p2 = p2 + sizeof("\nbookname=") -1;
		p3 = strchr(p2, '\n');
		*bookname = g_strndup(p2, p3-p2);
	}
	else {
		*bookname = NULL;
	}

	p2 = strstr(p1,"\nauthor=");
	if (p2) {
		p2 = p2 + sizeof("\nauthor=") -1;
		p3 = strchr(p2, '\n');
		*author = g_strndup(p2, p3-p2);
	}
	else {
		*author = NULL;
	}

	p2 = strstr(p1,"\nemail=");
	if (p2) {
		p2 = p2 + sizeof("\nemail=") -1;
		p3 = strchr(p2, '\n');
		*email = g_strndup(p2, p3-p2);
	}
	else {
		*email = NULL;
	}

	p2 = strstr(p1,"\nwebsite=");
	if (p2) {
		p2 = p2 + sizeof("\nwebsite=") -1;
		p3 = strchr(p2, '\n');
		*website = g_strndup(p2, p3-p2);
	}
	else {
		*website = NULL;
	}

	p2 = strstr(p1,"\ndate=");
	if (p2) {
		p2 = p2 + sizeof("\ndate=") -1;
		p3 = strchr(p2, '\n');
		*date = g_strndup(p2, p3-p2);
	}
	else {
		*date = NULL;
	}								

	p2 = strstr(p1,"\ndescription=");
	if (p2) {
		p2 = p2 + sizeof("\ndescription=") -1;
		p3 = strchr(p2, '\n');
		*description = g_strndup(p2, p3-p2);
	}
	else {
		*description = NULL;
	}

	g_free(buffer);
	return true;				
}

void DictManageDlg::load_dir(gboolean istreedict, const gchar *dirname, const GSList *order_list, const GSList *disable_list, GtkListStore *model)
{
	GDir *dir = g_dir_open(dirname, 0, NULL);	
  if (dir) {
	{
		GtkTreeIter iter;
		const gchar *filename;	
		gchar fullfilename[256];
		gboolean loaded;
		const GSList *tmplist1,*tmplist2;
		gboolean disabled;
    DictInfo dict_info;
		gchar *bookname, *author, *email, *website, *description, *date;
		while ((filename = g_dir_read_name(dir))!=NULL) {
			sprintf(fullfilename, "%s/%s", dirname, filename);
			if (g_file_test(fullfilename, G_FILE_TEST_IS_DIR)) {
				load_dir(istreedict, fullfilename, order_list, disable_list, model);
      } else if (g_str_has_suffix(filename,".ifo")) {
			else if (g_str_has_suffix(filename,".ifo")) {
				tmplist1 = order_list;
				loaded = false;
				while (tmplist1) {

				}
				if (loaded)
					continue;
	if (dict_info.load_from_ifo_file(fullfilename, istreedict)) {
					tmplist2 = disable_list;
					disabled = false;
					while (tmplist2) {

						tmplist2 = g_slist_next(tmplist2);
					}
					gtk_list_store_append (model, &iter);				
	  gtk_list_store_set (model, &iter, 0, !disabled, 
			      1, dict_info.bookname.c_str(), 
			      2, dict_info.wordcount, 
			      3, dict_info.author.c_str(), 
			      4, dict_info.email.c_str(), 
			      5, dict_info.website.c_str(), 
			      6, dict_info.date.c_str(), 
			      7, dict_info.description.c_str(), 
			      8, fullfilename, 9, true, -1);
				}
			}
		}

    disable_list=conf->get_dict_disable_list();    
	}
	
	glong wordcount;
	gchar *bookname, *author, *email, *website, *description, *date;
	
	GtkTreeIter iter;
	

	while (tmplist1) {
		ifofilename = (gchar *)(tmplist1->data);
		tmplist1 = g_slist_next(tmplist1);
    DictInfo dict_info;
		if (g_file_test(ifofilename, G_FILE_TEST_EXISTS)) {
      if (dict_info.load_from_ifo_file(ifofilename, istreedict)) {
				tmplist2 = disable_list;
				disabled = false;
				while (tmplist2) {

					tmplist2 = g_slist_next(tmplist2);
				}
				gtk_list_store_append (model, &iter);				
	gtk_list_store_set (model, &iter, 0, !disabled, 
			    1, dict_info.bookname.c_str(), 
			    2, dict_info.wordcount, 
			    3, dict_info.author.c_str(), 
			    4, dict_info.email.c_str(), 
			    5, dict_info.website.c_str(),
			    6, dict_info.description.c_str(), 
			    7, dict_info.date.c_str(), 
			    8, ifofilename, 9, true, -1);
			}
		}
	}

Lines 19-26 Link Here

(-)stardict-cur-accepted/src/dictmanagedlg.h (-2 lines)
19		19
20	GtkWidget *create_buttons();	20	GtkWidget *create_buttons();
21		21
22	static gboolean get_dict_info(gboolean istreedict, const gchar ifofilename, glong wordcount, gchar bookname, gchar author, gchar **email,
23	gchar website, gchar date, gchar **description);
24	void write_order_list(gboolean istreedict);	22	void write_order_list(gboolean istreedict);
25		23
26	static void on_wazard_button_toggled(GtkToggleButton button, DictManageDlg oDictManageDlg);	24	static void on_wazard_button_toggled(GtkToggleButton button, DictManageDlg oDictManageDlg);

Lines 32-43 Link Here

(-)stardict-cur-accepted/src/distance.cpp (-1 / +3 lines)
32	* DNA analysis	32	* DNA analysis
33	* Plagiarism detection	33	* Plagiarism detection
34	*/	34	*/
35	#include "distance.h"	35
36		36
37	#include <stdlib.h>	37	#include <stdlib.h>
38	#include <string.h>	38	#include <string.h>
39	//#include <stdio.h>	39	//#include <stdio.h>
40		40
		41	#include "distance.h"
		42
41	#define OPTIMIZE_ED	43	#define OPTIMIZE_ED
42	/*	44	/*
43	Cover transposition, in addition to deletion,	45	Cover transposition, in addition to deletion,

Lines 5-11 Link Here

(-)stardict-cur-accepted/src/distance.h (-1 / +1 lines)
5	#include <config.h>	5	#include <config.h>
6	#endif	6	#endif
7		7
8	#include <gtk/gtk.h>	8	#include <glib.h>
9		9
10	class EditDistance {	10	class EditDistance {
11	private:	11	private:




	mark += "</big></b>";
	
	gchar *p;
  guint32 data_size, sec_size=0;
  for (int i=0;i< gpAppFrame->oAppCore.oLibs.total_libs();i++) {
	{
		if (word[i]) {
			mark += "\n<span foreground=\"blue\">*--- ";
			m_str = g_markup_escape_text(gpAppFrame->oAppCore.oLibs.GetBookname(i),-1);

			}
		}
		if (data[i]) {			
      p=data[i];
      data_size=*reinterpret_cast<guint32 *>(p);
      p+=sizeof(guint32);
      while (guint32(p - (data[i] + sizeof(guint32)))< data_size) {
	switch (*p++) {
				{
					case 'm':
	case 'l'://need more work
	  sec_size = strlen(p);
						if (sec_size) {							
							mark+= "\n";
	    m_str = g_markup_escape_text(p, sec_size);
							mark += m_str;
							g_free(m_str);							
						}
						sec_size++;
						break;
	case 'g':
	  sec_size = strlen(p);
	  if (sec_size) {
	    mark += "\n";
	    mark += p;
	  }
	  sec_size++;
	  break;
					case 't':
	  sec_size = strlen(p);
						if (sec_size) {
							mark += "\n<big>[";
	    m_str = g_markup_escape_text(p, sec_size);
							mark += m_str;
							g_free(m_str);
							mark+= "]</big>";

						sec_size++;
						break;
					case 'y':
	  sec_size = strlen(p);
						if (sec_size) {
							mark += "\n<span foreground=\"red\">[";
	    m_str = g_markup_escape_text(p, sec_size);
							mark += m_str;
							g_free(m_str);
							mark+= "]</span>";

						sec_size++;						
						break;
					case 'W':
	  sec_size=*reinterpret_cast<guint32 *>(p);
	  sec_size=g_ntohl(sec_size);
						//enbale sound button.
	  sec_size+=sizeof(guint32);
						break;
					case 'P':
	  sec_size=*reinterpret_cast<guint32 *>(p);
	  sec_size=g_ntohl(sec_size);
	  sec_size+= sizeof(guint32);
						break;						
	default:
	  /*nothing*/;
				}								
	p += sec_size;
			}
		}		
	}

	gboolean canRead = gpAppFrame->oReadWord.canRead(sOriginWord);
	if (canRead) {
		PronounceWord = sOriginWord;
  } else {
	else {
		for (int i=0;i< gpAppFrame->oAppCore.oLibs.total_libs(); i++) {
			if (word[i] && strcmp(word[i], sOriginWord)) {
				if (gpAppFrame->oReadWord.canRead(word[i])) {

		gpAppFrame->oReadWord.read(PronounceWord.c_str());
}

void FloatWin::ShowText(gchar *** pppWord, gchar *** pppWordData, 
			const gchar ** ppOriginWord, gint count,
			const gchar * sOriginWord)
{
	QueryingWord = sOriginWord;
	found_result = FLOAT_WIN_FUZZY_FOUND;

	mark += _("Found ");
	if (count ==1)
		mark+= _("1 word:\n");
  else {
	{
		m_str=g_strdup_printf("%d",count);
		mark += m_str;
		g_free(m_str);
		mark+= _(" words:\n");
	}
	int j;
  for (j=0; j<count-1; j++) {
	{
		mark += "<b><big>";
    m_str = g_markup_escape_text(ppOriginWord[j], -1);
		mark += m_str;
		g_free(m_str);
		mark += "</big></b> ";

	mark += "</big></b>";
	
	gchar *p;
  guint32 data_size,sec_size;
  for (j=0; j<count; j++) {
	{
		mark += "\n\n<span foreground=\"red\">#----- ";
		m_str = g_markup_escape_text(ppOriginWord[j],-1);
		mark += m_str;
		g_free(m_str);
		mark += " -----#</span>";
		
    for (int i=0; i<gpAppFrame->oAppCore.oLibs.total_libs(); i++) {
		{
			if (pppWord[j][i]) {
				mark += "\n<span foreground=\"blue\">*--- ";
				m_str = g_markup_escape_text(gpAppFrame->oAppCore.oLibs.GetBookname(i),-1);

				}
			}
			if (pppWordData[j][i]) {			
	p=pppWordData[j][i];
	data_size=*reinterpret_cast<guint32 *>(p);
	p+=sizeof(guint32);
	while (guint32(p - (pppWordData[j][i] + sizeof(guint32)))< data_size) {
	  switch (*p++) {
					switch (*p)
					{
						case 'm':
	  case 'l': //need more work...
	    sec_size = strlen(p);
							if (sec_size) {
								mark+= "\n";
	      m_str = g_markup_escape_text(p,sec_size);
								mark += m_str;
								g_free(m_str);
							}
							sec_size++;
							break;
	  case 'g':
	    sec_size = strlen(p);
	    if (sec_size) {
	      mark += "\n";
	      mark += p;
	    }
	    sec_size++;
	    break;
						case 't':
	    sec_size = strlen(p);
							if (sec_size) {
								mark += "\n<big>[";
	      m_str = g_markup_escape_text(p, sec_size);
								mark += m_str;
								g_free(m_str);
								mark+= "]</big>";

							sec_size++;
							break;
						case 'y':
	    sec_size = strlen(p);
							if (sec_size) {
								mark += "\n<span foreground=\"red\">[";
	      m_str = g_markup_escape_text(p, sec_size);
								mark += m_str;
								g_free(m_str);
								mark+= "]</span>";

							sec_size++;						
							break;
						case 'W':
	    sec_size=*reinterpret_cast<guint32 *>(p);
	    sec_size=g_ntohl(sec_size);
							//enbale sound button.
	    sec_size+= sizeof(guint32);
							break;
						case 'P':
	    sec_size=*reinterpret_cast<guint32 *>(p);
	    sec_size=g_ntohl(sec_size);
	    sec_size+= sizeof(guint32);
							break;						
	  default:
	    /*nothing*/;
					}								
	  p += sec_size;
				}				
			}		
		}		




#  include "config.h"
#endif

#include <cstring>
#include <cctype>

#include "lib.h"
#include "stardict.h"
#include <sys/stat.h>
#include <zlib.h>
#include "zlib.h"
#ifdef HAVE_MMAP
#  include <sys/types.h>
#  include <fcntl.h>
#  include <sys/mman.h>
#endif
#include <algorithm>

#include "distance.h"

#include "lib.h"

// Notice: read src/tools/DICTFILE_FORMAT for the dictionary 
// file's format information!

class MapFile {
public:
  MapFile(void) : data(NULL) {}
  ~MapFile();
  bool open(const gchar *file_name, gulong file_size);
  inline gchar *begin(void) { return data; }
private:
  gchar *data;
  gulong size;
#ifdef HAVE_MMAP
  int mmap_fd;
#elif defined(_WIN32)
  HANDLE hFile;
  HANDLE hFileMap;
#endif
};

inline bool MapFile::open(const gchar *file_name, gulong file_size)
{
  size=file_size;
#ifdef HAVE_MMAP
  if ((mmap_fd = ::open(file_name, O_RDONLY)) < 0) {
    //g_print("Open file %s failed!\n",fullfilename);
    return false;
  }
  data = (gchar *)mmap( NULL, file_size, PROT_READ, MAP_SHARED, mmap_fd, 0);
  if ((void *)data == (void *)(-1)) {
    //g_print("mmap file %s failed!\n",idxfilename);
    data=NULL;
    return false;
  }
#else
#  ifdef _WIN32
  hFile = CreateFile(file_name, GENERIC_READ, 0, NULL, OPEN_ALWAYS, 
		     FILE_ATTRIBUTE_NORMAL, 0);
  hFileMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0,  
			       file_size, NULL);
  data = (gchar *)MapViewOfFile(hFileMap, FILE_MAP_READ, 0, 0, file_size);
#  else
  gsize read_len;
  if (!g_file_get_contents(file_name, &data, &read_len, NULL))
    return false;

  if (read_len!=file_size)
    return false;		
#  endif
#endif

  return true;
}

inline MapFile::~MapFile()
{
  if (!data)
    return;
#ifdef HAVE_MMAP
  munmap(data, size);
  close(mmap_fd);
#else
#  ifdef _WIN32
  UnmapViewOfFile(data);
  CloseHandle(hFileMap);
  CloseHandle(hFile);
#  else
		g_free(data);
#  endif
#endif			
}

inline bool bIsVowel(gchar inputchar)
{
  gchar ch = g_ascii_toupper(inputchar);
  return( ch=='A' || ch=='E' || ch=='I' || ch=='O' || ch=='U' );
}

bool bIsPureEnglish(const gchar *str) 
{ 
  // i think this should work even when it is UTF8 string :).
  for (int i=0; str[i]!=0; i++) 
    //if(str[i]<0)
    //if(str[i]<32 || str[i]>126) // tab equal 9,so this is not OK.
    // Better use isascii() but not str[i]<0 while char is default unsigned in arm
    if (!isascii(str[i])) 
            return false;            
  return true;	
}

inline gint stardict_strcmp(const gchar *s1, const gchar *s2) {
  gint a=g_ascii_strcasecmp(s1, s2);
  if (a == 0)
    return strcmp(s1, s2);
  else
    return a;
}

bool DictInfo::load_from_ifo_file(const gchar *ifofilename,
				  bool istreedict)
{
  ifo_file_name=ifofilename;
  gchar *buffer;
  if (!g_file_get_contents(ifofilename, &buffer, NULL, NULL))
    return false;
  
#define TREEDICT_MAGIC_DATA "StarDict's treedict ifo file\nversion=2.4.2\n"
#define DICT_MAGIC_DATA "StarDict's dict ifo file\nversion=2.4.2\n"
  const gchar *magic_data=istreedict ? TREEDICT_MAGIC_DATA : DICT_MAGIC_DATA;
  if (!g_str_has_prefix(buffer, magic_data)) {
    g_free(buffer);
    return false;
  }

  gchar *p1,*p2,*p3;
  
  p1 = buffer + strlen(magic_data)-1;

  p2 = strstr(p1,"\nwordcount=");
  if (!p2) {
    g_free(buffer);
    return false;
  }
  
  p3 = strchr(p2+ sizeof("\nwordcount=")-1,'\n');
  gchar *tmpstr = (gchar *)g_memdup(p2+sizeof("\nwordcount=")-1, p3-(p2+sizeof("\nwordcount=")-1)+1);
  tmpstr[p3-(p2+sizeof("\nwordcount=")-1)] = '\0';
  wordcount = atol(tmpstr);
  g_free(tmpstr);

  if (istreedict) {
    p2 = strstr(p1,"\ntdxfilesize=");
    if (!p2) {
      g_free(buffer);
      return false;
    }
    p3 = strchr(p2+ sizeof("\ntdxfilesize=")-1,'\n');
    tmpstr = (gchar *)g_memdup(p2+sizeof("\ntdxfilesize=")-1, p3-(p2+sizeof("\ntdxfilesize=")-1)+1);
    tmpstr[p3-(p2+sizeof("\ntdxfilesize=")-1)] = '\0';
    index_file_size = atol(tmpstr);
    g_free(tmpstr);
  } else {
  
    p2 = strstr(p1,"\nidxfilesize=");
    if (!p2) {
      g_free(buffer);
      return false;
    }
    
    p3 = strchr(p2+ sizeof("\nidxfilesize=")-1,'\n');
    tmpstr = (gchar *)g_memdup(p2+sizeof("\nidxfilesize=")-1, p3-(p2+sizeof("\nidxfilesize=")-1)+1);
    tmpstr[p3-(p2+sizeof("\nidxfilesize=")-1)] = '\0';
    index_file_size = atol(tmpstr);
    g_free(tmpstr);
  }
	
  p2 = strstr(p1,"\nbookname=");

  if (!p2) {
    g_free(buffer);
    return false;
  }

  p2 = p2 + sizeof("\nbookname=") -1;
  p3 = strchr(p2, '\n');
  bookname.assign(p2, p3-p2);

  p2 = strstr(p1,"\nauthor=");
  if (p2) {
    p2 = p2 + sizeof("\nauthor=") -1;
    p3 = strchr(p2, '\n');
    author.assign(p2, p3-p2);
  }

  p2 = strstr(p1,"\nemail=");
  if (p2) {
    p2 = p2 + sizeof("\nemail=") -1;
    p3 = strchr(p2, '\n');
    email.assign(p2, p3-p2);
  }

  p2 = strstr(p1,"\nwebsite=");
  if (p2) {
    p2 = p2 + sizeof("\nwebsite=") -1;
    p3 = strchr(p2, '\n');
    website.assign(p2, p3-p2);
  }

  p2 = strstr(p1,"\ndate=");
  if (p2) {
    p2 = p2 + sizeof("\ndate=") -1;
    p3 = strchr(p2, '\n');
    date.assign(p2, p3-p2);
  }

  p2 = strstr(p1,"\ndescription=");
  if (p2) {
    p2 = p2 + sizeof("\ndescription=")-1;
    p3 = strchr(p2, '\n');
    description.assign(p2, p3-p2);
  }

  p2 = strstr(p1,"\nsametypesequence=");
  if (p2) {		
    p2+=sizeof("\nsametypesequence=")-1;
    p3 = strchr(p2, '\n');
    sametypesequence.assign(p2, p3-p2);
  }

  g_free(buffer);

  return true;		
}
//===================================================================
DictBase::DictBase()
{

		dict_data_close(dictdzfile);
}

gchar* DictBase::GetWordData(guint32 idxitem_offset, guint32 idxitem_size)
{
  for (int i=0; i<WORDDATA_CACHE_NUM; i++)	
    if (cache[i].data && cache[i].offset == idxitem_offset)
		if ((cache[i].data) && (cache[i].offset == idxitem_offset))
		{
			return cache[i].data;
			
  if (dictfile)
	if (dictfile) {
		fseek(dictfile, idxitem_offset, SEEK_SET);
	
	gchar *data;
	if (sametypesequence) {
    gchar *origin_data = (gchar *)g_malloc(idxitem_size);
		origin_data = (gchar *)g_malloc(idxitem_size);
		
		if (dictfile)
      fread(origin_data, idxitem_size, 1, dictfile);
		else
      dict_data_read(dictdzfile, origin_data, idxitem_offset, idxitem_size);
	
    guint32 data_size;
		gint sametypesequence_len;
		sametypesequence_len = strlen(sametypesequence);
		//there have sametypesequence_len char being omitted.
    data_size = idxitem_size + sizeof(guint32) + sametypesequence_len;
		//if the last item's size is determined by the end up '\0',then +=sizeof(gchar);
    //if the last item's size is determined by the head guint32 type data,then +=sizeof(guint32);
		switch (sametypesequence[sametypesequence_len-1]) {
			case 'm':
			case 't':
			case 'y':
    case 'l':
    case 'g':
				data_size += sizeof(gchar);
				break;
			case 'W':
			case 'P':
      data_size += sizeof(guint32);
				break;
		}			
		data = (gchar *)g_malloc(data_size);
		gchar *p1,*p2;
    p1 = data + sizeof(guint32);
		p2 = origin_data;
    guint32 sec_size;
		//copy the head items.
    for (int i=0; i<sametypesequence_len-1; i++) {
      *p1=sametypesequence[i];
      p1+=sizeof(gchar);
			switch (sametypesequence[i]) {
				case 'm':
				case 't':
				case 'y':
      case 'l':
      case 'g':
					sec_size = strlen(p2)+1;
					memcpy(p1, p2, sec_size);
	p1+=sec_size;
	p2+=sec_size;
					break;
				case 'W':
				case 'P':
	sec_size = *reinterpret_cast<guint32 *>(p2);
	sec_size += sizeof(guint32);
					memcpy(p1, p2, sec_size);
	p1+=sec_size;
	p2+=sec_size;
					break;
			}							
		}	
		//calculate the last item 's size.
		sec_size = idxitem_size - (p2-origin_data);
    *p1=sametypesequence[sametypesequence_len-1];
    p1+=sizeof(gchar);
		switch (sametypesequence[sametypesequence_len-1]) {
			case 'm':
			case 't':
			case 'y':
    case 'l':
    case 'g':
				memcpy(p1, p2, sec_size);
				p1 += sec_size;				
      *p1='\0';//add the end up '\0';
				break;
			case 'W':
			case 'P':
      *reinterpret_cast<guint32 *>(p1)=sec_size;
      p1 += sizeof(guint32);
				memcpy(p1, p2, sec_size);
				break;
		}		
		g_free(origin_data);		
    *reinterpret_cast<guint32 *>(data)=data_size;
  } else {		
    data = (gchar *)g_malloc(idxitem_size + sizeof(guint32));
		if (dictfile)
      fread(data+sizeof(guint32), idxitem_size, 1, dictfile);		
		else
      dict_data_read(dictdzfile, data+sizeof(guint32), idxitem_offset, idxitem_size);
    *reinterpret_cast<guint32 *>(data)=idxitem_size;
	}	
	memcpy(data,&(idxitem_size),sizeof(glong));
	if (cache[cache_cur].data)
	{
		g_free(cache[cache_cur].data);

	cache[cache_cur].data = data;
	cache[cache_cur].offset = idxitem_offset;
	cache_cur++;
	if (cache_cur==WORDDATA_CACHE_NUM)
    cache_cur = 0;
    return data;
}


	bookname = NULL;
	idxfile = NULL;
	wordlist = NULL;
#ifdef HAVE_MMAP
	mmap_fd = -1;
	mmap_idxmap_size = 0;
#endif
	idxdatabuffer = NULL;
}

Lib::~Lib()
{
	if (bookname)
		g_free(bookname);
	if (idxfile) {
		fclose(idxfile);
		if (wordoffset)
			g_free(wordoffset);
  } else {    
	else {
		if (wordlist)
			g_free(wordlist);

#ifdef HAVE_MMAP
		if (mmap_fd >= 0) {
			if (mmap_idxmap_size)
				munmap(idxdatabuffer, mmap_idxmap_size);
			close(mmap_fd);
		}
		else {
			if (idxdatabuffer)
				g_free(idxdatabuffer);
		}
#else
		if (idxdatabuffer)
			g_free(idxdatabuffer);
#endif
	}
}

bool Lib::load(const char *ifofilename)
{	
	gulong idxfilesize;
	if (!load_ifofile(ifofilename, &idxfilesize))
		return false;

  std::string fullfilename(ifofilename);
  fullfilename.replace(fullfilename.length()-sizeof("ifo")+1, sizeof("ifo")-1, "dict.dz");
	strcpy(fullfilename, ifofilename);
	strcpy(fullfilename+strlen(fullfilename)-sizeof("ifo") +1, "dict.dz");	
	
  if (g_file_test(fullfilename.c_str(), G_FILE_TEST_EXISTS)) {
    dictdzfile = dict_data_open(fullfilename.c_str(), 0);
    if (!dictdzfile) {
		{
			//g_print("open file %s failed!\n",fullfilename);
			return false;
		}
  } else {
    fullfilename.erase(fullfilename.length()-sizeof(".dz")+1, sizeof(".dz")-1);
    dictfile = fopen(fullfilename.c_str(),"rb");
    if (!dictfile) {
		if (!dictfile)
		{
			//g_print("open file %s failed!\n",fullfilename);
			return false;
		}
	}

  fullfilename=ifofilename;
  fullfilename.replace(fullfilename.length()-sizeof("ifo")+1, sizeof("ifo")-1, "idx.gz");
	
  if (g_file_test(fullfilename.c_str(), G_FILE_TEST_EXISTS)) {
		gzFile in;	
    in = gzopen(fullfilename.c_str(),"rb");
		if (in == NULL) {
			//g_print("Open file %s failed!\n",fullfilename);
			return false;

		gzclose(in);
		if (len != idxfilesize)
			return false;
  } else {
    fullfilename.erase(fullfilename.length()-sizeof(".gz")+1, sizeof(".gz")-1);
    MapFile map_file;
    if (!map_file.open(fullfilename.c_str(), idxfilesize))
#ifdef HAVE_MMAP
		if ((mmap_fd = open(fullfilename, O_RDONLY )) < 0) {
			//g_print("Open file %s failed!\n",fullfilename);
			return false;
		}
		idxdatabuffer = (gchar *)mmap( NULL, idxfilesize, PROT_READ, MAP_SHARED, mmap_fd, 0);		
		if ((void *)idxdatabuffer == (void *)(-1)) {
			//g_print("mmap file %s failed!\n",idxfilename);
			return false;
		}
		mmap_idxmap_size = idxfilesize;
#else
  #ifdef _WIN32
		HANDLE hFile = CreateFile(fullfilename, GENERIC_READ, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
		HANDLE hFileMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0,  idxfilesize, NULL);
		idxdatabuffer = (gchar *)MapViewOfFile(hFileMap, FILE_MAP_READ, 0, 0, idxfilesize);
  #else
		FILE *file;
		if (!(file = fopen (fullfilename, "rb"))) {
			//g_print("Open file %s failed!\n",fullfilename);
			return false;
		}
		idxdatabuffer = (gchar *)g_malloc(idxfilesize);
		gint read_len;
		read_len = fread (idxdatabuffer, 1, idxfilesize, file);
		fclose (file);
		if (read_len!=idxfilesize)
			return false;		
    idxdatabuffer=map_file.begin();
    
		if (true) {
			loadwordoffset();
    idxdatabuffer=NULL;
    if (!(idxfile = fopen(fullfilename.c_str(), "rb"))) {
			idxdatabuffer = NULL;
			mmap_idxmap_size = 0;
			close(mmap_fd);
			mmap_fd = -1;
#else
  #ifdef _WIN32
			UnmapViewOfFile(idxdatabuffer);
			idxdatabuffer = NULL;
			CloseHandle(hFileMap);
			CloseHandle(hFile);
  #else
			g_free(idxdatabuffer);
			idxdatabuffer = NULL;
  #endif
#endif			
			if (!(idxfile = fopen (fullfilename, "rb"))) {
				if (wordoffset) {
					g_free(wordoffset);
					wordoffset = NULL;

			g_print("bookname: %s , wordcount %ld\n",bookname, wordcount);
			return true;
		}
		else {
			// The .idx file will load into memory. Who need this opinion?
		}
	}

	loadwordlist();
	g_print("bookname: %s , wordcount %ld\n",bookname, wordcount);
	return true;
}

bool Lib::load_ifofile(const char *ifofilename, gulong *idxfilesize)
{
  DictInfo dict_info;
  if (!dict_info.load_from_ifo_file(ifofilename, false))
		//g_print("File: %s don't exist!\n",idxfilename);
		return false;
	}
		
	FILE *file;
	if (!(file = fopen (ifofilename, "rb"))) {
		//g_print("Open file %s failed!\n",idxfilename);
		return false;
	}
	gchar *buffer = (gchar *)g_malloc (stats.st_size + 1);
	fread (buffer, 1, stats.st_size, file);
	buffer[stats.st_size] = '\0';
	fclose (file);
	
	if (!g_str_has_prefix(buffer, "StarDict's dict ifo file\nversion=2.4.2\n")) {
		g_print("Bad dict ifo file %s, skiped!\n", ifofilename);
		g_free(buffer);
		return false;
	}
	gchar *p1= buffer + sizeof("StarDict's dict ifo file\nversion=2.4.2\n")-1 -1;
	
  *idxfilesize = dict_info.index_file_size;	
  wordcount = dict_info.wordcount;
  bookname = g_strdup(dict_info.bookname.c_str());
	if (!p2) {
		g_free(buffer);
		return false;
	}
	p3 = strchr(p2+ sizeof("\nidxfilesize=")-1,'\n');
	gchar *tmpstr = (gchar *)g_memdup(p2+sizeof("\nidxfilesize=")-1, p3-(p2+sizeof("\nidxfilesize=")-1)+1);
	tmpstr[p3-(p2+sizeof("\nidxfilesize=")-1)] = '\0';
	*idxfilesize = atol(tmpstr);
	g_free(tmpstr);

	p2 = strstr(p1,"\nwordcount=");
	if (!p2) {
		g_free(buffer);
		return false;
	}
	p3 = strchr(p2+ sizeof("\nwordcount=")-1,'\n');
	tmpstr = (gchar *)g_memdup(p2+sizeof("\nwordcount=")-1, p3-(p2+sizeof("\nwordcount=")-1)+1);
	tmpstr[p3-(p2+sizeof("\nwordcount=")-1)] = '\0';
	wordcount = atol(tmpstr);
	g_free(tmpstr);

	p2 = strstr(p1,"\nbookname=");
	if (!p2) {
		g_free(buffer);
		return false;
	}
	p3 = strchr(p2+ sizeof("\nbookname=")-1,'\n');
	bookname = (gchar *)g_memdup(p2+sizeof("\nbookname=")-1, p3-(p2+sizeof("\nbookname=")-1)+1);
	bookname[p3-(p2+sizeof("\nbookname=")-1)] = '\0';

  if (!dict_info.sametypesequence.empty())
    sametypesequence=g_strdup(dict_info.sametypesequence.c_str());
		p3 = strchr(p2+sizeof("\nsametypesequence=")-1,'\n');
		sametypesequence = (gchar *)g_memdup(p2+sizeof("\nsametypesequence=")-1, p3-(p2+sizeof("\nsametypesequence=")-1)+1);
		sametypesequence[p3-(p2+sizeof("\nsametypesequence=")-1)] = '\0';
	}

	g_free(buffer);
	return true;
}


	wordoffset[wordcount] = p1;
}*/

bool Lib::Lookup(const char* sWord,glong *pIndex)
{
  bool bFound=false;
    glong iTo=length()-1;
	if (stardict_strcmp(sWord, GetWord(0))<0) {
		*pIndex = 0;
  } else if (stardict_strcmp(sWord, GetWord(iTo)) >0) {
	else if (stardict_strcmp(sWord, GetWord(iTo)) >0 ) {
		*pIndex = INVALID_INDEX;
  } else {
	else {
	    glong iThisIndex=0;
    	glong iFrom=0;

		int cmpint;
    while (iFrom<=iTo) {
    	{
        	iThisIndex=(iFrom+iTo)/2;
			cmpint = stardict_strcmp(sWord, GetWord(iThisIndex));
			//g_print("lookup %s %d\n",GetWord(iThisIndex),cmpint);
      if (cmpint>0)
			{
				bFound=true;
			}
			else if (cmpint > 0)
			{
				iFrom=iThisIndex+1;
      else if (cmpint<0)
			else
			{
				iTo=iThisIndex-1;
      else {	
	bFound=true;
	break;
			}
    	}

    if (!bFound) {
			/*glong len = g_utf8_strlen(sWord, -1);
			gchar *last_str = g_utf8_offset_to_pointer(sWord, len-1);
			gunichar last = g_utf8_get_char(last_str);

            	*pIndex = iFrom;    //next
			*/
			*pIndex = iFrom;    //next
    } else
		else
			*pIndex = iThisIndex;		
	}		

  return bFound;
}

bool Lib::LookupWithRule(GPatternSpec *pspec, glong *aIndex, int iBuffLen)
{
    int iIndexCount=0;
    glong i;
  for(i=0; i<wordcount && iIndexCount<iBuffLen-1; i++)
    if (g_pattern_match_string(pspec, GetWord(i)))        
        if(g_pattern_match_string(pspec, GetWord(i)))
        {
            aIndex[iIndexCount++]=i;
            
    }
    aIndex[iIndexCount]= -1; // -1 is the end.	
	
  return (iIndexCount>0);
}

gchar *
Lib::GetWord(glong index)
{
	if (idxfile) {
    if (index != cur_wordindex+1)
			//needn't fseek().
		}
		// (index == cur_wordindex) seldom happen, so don't determine this here.
		else {
			fseek(idxfile, wordoffset[index], SEEK_SET);
		
		cur_wordindex = index;
		
    fread(wordentry_buf, wordoffset[index+1] - wordoffset[index] - 2*sizeof(guint32), 1, idxfile);
		//g_print("%s\n", wordentry_buf);
    fread(&wordentry_offset, sizeof(guint32), 1, idxfile);
		wordentry_offset = g_ntohl(wordentry_offset);
    fread(&wordentry_size, sizeof(guint32), 1, idxfile);
		wordentry_size = g_ntohl(wordentry_size);
		return wordentry_buf;
  } else {
	else {
		return wordlist[index];
	}
}

Lib::GetWordData(glong index)
{
	if (idxfile) {
    if (index != cur_wordindex) {
			// wordentry_offset and wordentry_size are already cached by GetWord();
		}
		else {
			cur_wordindex = index;
      fseek(idxfile, wordoffset[index+1] - 2*sizeof(guint32), SEEK_SET);
      fread(&wordentry_offset, sizeof(guint32), 1, idxfile);
			wordentry_offset = g_ntohl(wordentry_offset);
      fread(&wordentry_size, sizeof(guint32), 1, idxfile);
			wordentry_size = g_ntohl(wordentry_size);			
		}		
		return DictBase::GetWordData(wordentry_offset, wordentry_size);
  } else {
    gchar *p1 = wordlist[index+1] - 2*sizeof(guint32);
    guint32 offset, size;
    offset=*reinterpret_cast<guint32 *>(p1);
		memcpy(&offset,p1,sizeof(glong));
		offset = g_ntohl(offset);
    p1 += sizeof(guint32);
    size=*reinterpret_cast<guint32 *>(p1);
		size = g_ntohl(size);
		return DictBase::GetWordData(offset, size);
	}

{
	libcount =0;
	oLib = NULL;
	iMaxFuzzyDistance  = MAX_FUZZY_DISTANCE; //need to read from cfg.
}

Libs::~Libs()

}

/********************************************************************/
gboolean Libs::LookdupWordsWithRule(GPatternSpec *pspec,glong* aiIndexes,int iLen,int iLib)
{
	return (oLib[iLib]->LookupWithRule(pspec,aiIndexes,iLen));
}

void Libs::LoadDir(const gchar *dirname, const GSList *order_list, const GSList *disable_list)
{	

    return poCurrentWord;
}

bool Libs::LookupWord(const gchar* sWord,glong& iWordIndex,int iLib)
{
  return oLib[iLib]->Lookup(sWord, &iWordIndex);
}

bool Libs::LookupSimilarWord(const gchar* sWord, glong & iWordIndex, int iLib)
{
    glong iIndex;
  bool bFound=false;
	gchar *casestr;

	if (!bFound) {

		}	
	}
	
  if (bIsPureEnglish(sWord)) {		
    {		
        // If not Found , try other status of sWord.
        int iWordLen=strlen(sWord);
    bool isupcase;
		
		gchar *sNewWord = (gchar *)g_malloc(iWordLen + 1);

        //cut one char "s" or "d"
        if(!bFound && iWordLen>1) {
      isupcase = sWord[iWordLen-1]=='S' || !strncmp(&sWord[iWordLen-2],"ED",2);
      if (isupcase || sWord[iWordLen-1]=='s' || !strncmp(&sWord[iWordLen-2],"ed",2)) {
	            strcpy(sNewWord,sWord);
	            sNewWord[iWordLen-1]='\0'; // cut "s" or "d"
	if (oLib[iLib]->Lookup(sNewWord,&iIndex))
        	        bFound=true;
				else if (isupcase || g_ascii_isupper(sWord[0])) {
					casestr = g_ascii_strdown(sNewWord, -1);

			if (isupcase || (!strncmp(&sWord[iWordLen-2],"ly",2))) {
	            strcpy(sNewWord,sWord);
    	        sNewWord[iWordLen-2]='\0';  // cut "ly"
	if (iWordLen>5 && sNewWord[iWordLen-3]==sNewWord[iWordLen-4]
	    && !bIsVowel(sNewWord[iWordLen-4]) && 
	    bIsVowel(sNewWord[iWordLen-5])) {//doubled
		      
    	            sNewWord[iWordLen-3]='\0';
        	        if( oLib[iLib]->Lookup(sNewWord,&iIndex) )
            	        bFound=true;

	            strcpy(sNewWord,sWord);
    	        sNewWord[iWordLen-3]='\0';
        	    if ( iWordLen>6 && (sNewWord[iWordLen-4]==sNewWord[iWordLen-5])
	     && !bIsVowel(sNewWord[iWordLen-5]) && 
	     bIsVowel(sNewWord[iWordLen-6])) {  //doubled	  
    	            sNewWord[iWordLen-4]='\0';
        	        if (oLib[iLib]->Lookup(sNewWord,&iIndex))
            	        bFound=true;

        //cut two char "es"
        if(!bFound && iWordLen>3) {
			isupcase = (!strncmp(&sWord[iWordLen-2],"ES",2) && 
		  (sWord[iWordLen-3] == 'S' || 
		   sWord[iWordLen-3] == 'X' || 
		   sWord[iWordLen-3] == 'O' || 
		   (iWordLen >4 && sWord[iWordLen-3] == 'H' && 
		    (sWord[iWordLen-4] == 'C' || 
		     sWord[iWordLen-4] == 'S'))));
			if (isupcase || 
				(!strncmp(&sWord[iWordLen-2],"es",2) && 
	   (sWord[iWordLen-3] == 's' || sWord[iWordLen-3] == 'x' || 
	    sWord[iWordLen-3] == 'o' || 
	    (iWordLen >4 && sWord[iWordLen-3] == 'h' && 
	     (sWord[iWordLen-4] == 'c' || sWord[iWordLen-4] == 's'))))) {
            	strcpy(sNewWord,sWord);
	            sNewWord[iWordLen-2]='\0';
    	        if(oLib[iLib]->Lookup(sNewWord,&iIndex))

		}

        //cut "ed"
    if (!bFound && iWordLen>3) {
			isupcase = !strncmp(&sWord[iWordLen-2],"ED",2);
      if (isupcase || !strncmp(&sWord[iWordLen-2],"ed",2)) {
        	{
	            strcpy(sNewWord,sWord);
    	        sNewWord[iWordLen-2]='\0';
	if (iWordLen>5 && (sNewWord[iWordLen-3]==sNewWord[iWordLen-4])
	    && !bIsVowel(sNewWord[iWordLen-4]) && 
	    bIsVowel(sNewWord[iWordLen-5])) {//doubled	            
    	            sNewWord[iWordLen-3]='\0';
	  if (oLib[iLib]->Lookup(sNewWord,&iIndex))
            	        bFound=true;
                	else {
						if (isupcase || g_ascii_isupper(sWord[0])) {

                    		sNewWord[iWordLen-3]=sNewWord[iWordLen-4];  //restore
					}
            	}
	if (!bFound) {
					if (oLib[iLib]->Lookup(sNewWord,&iIndex))
                		bFound=true;
					else if (isupcase || g_ascii_isupper(sWord[0])) {

        }

        // cut "ied" , add "y".
    if (!bFound && iWordLen>3) {
			isupcase = !strncmp(&sWord[iWordLen-3],"IED",3);
      if (isupcase || (!strncmp(&sWord[iWordLen-3],"ied",3))) {
    	    {
				strcpy(sNewWord,sWord);
	            sNewWord[iWordLen-3]='\0';
				if (isupcase)
					strcat(sNewWord,"Y"); // add a char "Y"
				else
    	        	strcat(sNewWord,"y"); // add a char "y"
	if (oLib[iLib]->Lookup(sNewWord,&iIndex))
            	    bFound=true;
				else if (isupcase || g_ascii_isupper(sWord[0])) {
					casestr = g_ascii_strdown(sNewWord, -1);

        }
        
		// cut "ies" , add "y".
    if (!bFound && iWordLen>3) {
			isupcase = !strncmp(&sWord[iWordLen-3],"IES",3);
      if (isupcase || (!strncmp(&sWord[iWordLen-3],"ies",3))) {
    	    {
				strcpy(sNewWord,sWord);
	            sNewWord[iWordLen-3]='\0';
				if (isupcase)

        }

		// cut "er".
    if (!bFound && iWordLen>2) {
			isupcase = !strncmp(&sWord[iWordLen-2],"ER",2);
      if (isupcase || (!strncmp(&sWord[iWordLen-2],"er",2))) {
    	    {
				strcpy(sNewWord,sWord);
	            sNewWord[iWordLen-2]='\0';
        	    if(oLib[iLib]->Lookup(sNewWord,&iIndex))

        }

		// cut "est".
    if (!bFound && iWordLen>3) {
			isupcase = !strncmp(&sWord[iWordLen-3], "EST", 3);
      if (isupcase || (!strncmp(&sWord[iWordLen-3],"est", 3))) {
    	    {
				strcpy(sNewWord,sWord);
	            sNewWord[iWordLen-3]='\0';
        	    if(oLib[iLib]->Lookup(sNewWord,&iIndex))

		//iWordIndex = INVALID_INDEX;
	}

  return bFound;
}

bool Libs::SimpleLookupWord(const gchar* sWord, glong & iWordIndex, int iLib)
{
  bool bFound = oLib[iLib]->Lookup(sWord, &iWordIndex);
	if (!bFound)
		bFound = LookupSimilarWord(sWord, iWordIndex, iLib);
	return bFound;
}

inline bool operator<(const Libs::Fuzzystruct & lh, const Libs::Fuzzystruct & rh) {    
  if (lh.iMatchWordDistance!=rh.iMatchWordDistance)
    return lh.iMatchWordDistance<rh.iMatchWordDistance;

  if (lh.pMatchWord && rh.pMatchWord)
    return stardict_strcmp(lh.pMatchWord, rh.pMatchWord)<0;
  
  return false;
}

bool Libs::LookupWithFuzzy(const gchar *sWord, Fuzzystruct oFuzzystruct[], gint fuzzystruct_amount, TProgressFunc ProgressFunc)
{
  if (sWord[0] == '\0')
    return false;
           
  for (int i=0; i<fuzzystruct_amount; i++) {
    oFuzzystruct[i].pMatchWord = NULL;
    oFuzzystruct[i].iMatchWordDistance = iMaxFuzzyDistance;
  }
  int iMaxDistance = iMaxFuzzyDistance;
  int iDistance;
  bool Found = false;
  EditDistance oEditDistance;

  glong iCheckWordLen;
  int sCheckLen;
  const char *sCheck;
  gunichar *ucs4_str1,*ucs4_str2;
  glong ucs4_str2_len;
  char *sLowerCheckWord;
  gchar *sLowerWord = g_utf8_strdown(sWord, -1);	
  ucs4_str2 = g_utf8_to_ucs4_fast(sLowerWord,-1,&ucs4_str2_len);
  g_free(sLowerWord);
  for (int iLib=0; iLib<libcount; iLib++) {
    if (ProgressFunc)
      ProgressFunc();
    if (stardict_strcmp(sWord, poGetWord(0,iLib))>=0 && 
	stardict_strcmp(sWord, poGetWord(iLength(iLib)-1,iLib))<=0) {
      //there are Chinese dicts and English dicts...        
      const int iwords = iLength(iLib);
      for (int index=0; index<iwords; index++) {
	sCheck = poGetWord(index,iLib);
	// tolower and skip too long or too short words
	sCheckLen = strlen(sCheck);
	iCheckWordLen = g_utf8_strlen(sCheck, sCheckLen);
	if (iCheckWordLen-ucs4_str2_len>=iMaxDistance || 
	    ucs4_str2_len-iCheckWordLen>=iMaxDistance)
	  continue;
	sLowerCheckWord = g_utf8_strdown(sCheck, sCheckLen);
	if (iCheckWordLen > ucs4_str2_len)
	  (*g_utf8_offset_to_pointer(sLowerCheckWord, ucs4_str2_len)) = '\0';
	ucs4_str1 = g_utf8_to_ucs4_fast(sLowerCheckWord, -1,NULL);
	g_free(sLowerCheckWord);
	iDistance = oEditDistance.CalEditDistance(ucs4_str1,ucs4_str2,iMaxDistance);
	g_free(ucs4_str1);								
	if (iDistance<iMaxDistance && iDistance < ucs4_str2_len) {
	  // when ucs4_str2_len=1,2 we need less fuzzy.
	  Found = true;
	  bool bAlreadyInList = false;
	  int iMaxDistanceAt=0;
	  for (int j=0; j<fuzzystruct_amount; j++) {
	    if (oFuzzystruct[j].pMatchWord && 
		strcmp(oFuzzystruct[j].pMatchWord,sCheck)==0 ) {//already in list
	      bAlreadyInList = true;
	      break;
	    }
	    //find the position,it will certainly be found (include the first time) as iMaxDistance is set by last time.
	    if (oFuzzystruct[j].iMatchWordDistance == iMaxDistance ) {
	      iMaxDistanceAt = j;
	    }
	  }
	  if (!bAlreadyInList) {
	    if (oFuzzystruct[iMaxDistanceAt].pMatchWord)
	      g_free(oFuzzystruct[iMaxDistanceAt].pMatchWord);
	    oFuzzystruct[iMaxDistanceAt].pMatchWord = g_strdup(sCheck);
	    oFuzzystruct[iMaxDistanceAt].iMatchWordDistance = iDistance;
	    // calc new iMaxDistance
	    iMaxDistance = iDistance;
	    for (int j=0; j<fuzzystruct_amount; j++) {
	      if (oFuzzystruct[j].iMatchWordDistance > iMaxDistance)
		iMaxDistance = oFuzzystruct[j].iMatchWordDistance;
	    } // calc new iMaxDistance
	  }   // add to list
	}   // find one
      }   // each word
    }   // ok for search
  }   // each lib
  g_free(ucs4_str2);
	
  if (Found)// sort with distance
    std::sort(oFuzzystruct, oFuzzystruct+fuzzystruct_amount);
  
  return Found;
}

inline bool less_for_compare(const char *lh, const char *rh) {
  return stardict_strcmp(lh, rh)<0;
}

gint Libs::LookupWithRule(const gchar *word, TProgressFunc ProgressFunc, gchar **ppMatchWord)
{	
  glong aiIndex[MAX_MATCH_ITEM_PER_LIB+1];
  gint iMatchCount = 0;
  GPatternSpec *pspec = g_pattern_spec_new(word);
	
  for (int iLib=0; iLib<libcount; iLib++) {
    //if(oLibs.LookdupWordsWithRule(pspec,aiIndex,MAX_MATCH_ITEM_PER_LIB+1-iMatchCount,iLib)) 
    // -iMatchCount,so save time,but may got less result and the word may repeat.
    
    if (oLib[iLib]->LookupWithRule(pspec,aiIndex, MAX_MATCH_ITEM_PER_LIB+1)) {
      if (ProgressFunc)
	ProgressFunc();
      for (int i=0; aiIndex[i]!=-1; i++) {
	gchar * sMatchWord = poGetWord(aiIndex[i],iLib);
	bool bAlreadyInList = false;
	for (int j=0; j<iMatchCount; j++) {
	  if (strcmp(ppMatchWord[j],sMatchWord)==0) {//already in list
	    bAlreadyInList = true;
	    break;
	  }
	}
	if (!bAlreadyInList)
	  ppMatchWord[iMatchCount++] = g_strdup(sMatchWord);
      }
    }
  }
  g_pattern_spec_free(pspec);

  if (iMatchCount)// sort it.
    std::sort(ppMatchWord, ppMatchWord+iMatchCount, less_for_compare); 

  return iMatchCount;
}

/**************************************************/
bool TreeDict::load(const char *ifofilename, GtkTreeStore *model)
{
	gulong tdxfilesize;
	if (!load_ifofile(ifofilename, &tdxfilesize))
		return false;

  std::string fullfilename(ifofilename);
  fullfilename.replace(fullfilename.length()-sizeof("ifo")+1, sizeof("ifo")-1, "dict.dz");
	strcpy(fullfilename, ifofilename);
	strcpy(fullfilename+strlen(fullfilename)-sizeof("ifo") +1, "dict.dz");	
	
  if (g_file_test(fullfilename.c_str(), G_FILE_TEST_EXISTS)) {
    dictdzfile = dict_data_open(fullfilename.c_str(), 0);
		if (!dictdzfile) {
			//g_print("open file %s failed!\n",fullfilename);
			return false;
		}
  } else {
    fullfilename.erase(fullfilename.length()-sizeof(".dz")+1, sizeof(".dz")-1);
    dictfile = fopen(fullfilename.c_str(),"rb");
		dictfile = fopen(fullfilename,"rb");
		if (!dictfile) {
			//g_print("open file %s failed!\n",fullfilename);
			return false;
		}
	}

  fullfilename=ifofilename;
  fullfilename.replace(fullfilename.length()-sizeof("ifo")+1, sizeof("ifo")-1, "tdx.gz");
	
	gchar *buffer= NULL;
  if (g_file_test(fullfilename.c_str(), G_FILE_TEST_EXISTS)) {
		gzFile in;	
    in = gzopen(fullfilename.c_str(),"rb");
		if (in == NULL) {
			//g_print("Open file %s failed!\n",idxfilename);
			return false;

			g_free(buffer);
			return false;
		}
  } else {
    fullfilename.erase(fullfilename.length()-sizeof(".gz")+1, sizeof(".gz")-1);
		fullfilename[strlen(fullfilename)-3] = '\0';
		FILE *file;
    if (!(file = fopen (fullfilename.c_str(), "rb"))) {
			//g_print("Open file %s failed!\n",fullfilename);
			return false;
		}
		buffer = (gchar *)g_malloc(tdxfilesize);
		gulong read_len;
    read_len = fread(buffer, 1, tdxfilesize, file);
    fclose(file);
		if (read_len!=tdxfilesize) {
			g_free(buffer);
			return false;

	return true;
}

bool TreeDict::load_ifofile(const char *ifofilename, gulong *tdxfilesize)
{
  DictInfo dict_info;
  if (!dict_info.load_from_ifo_file(ifofilename, true))
		//g_print("File: %s don't exist!\n",idxfilename);
		return false;
	}
		
	FILE *file;
	if (!(file = fopen (ifofilename, "rb"))) {
		//g_print("Open file %s failed!\n",idxfilename);
		return false;
	}
	gchar *buffer = (gchar *)g_malloc (stats.st_size + 1);
	fread (buffer, 1, stats.st_size, file);
	buffer[stats.st_size] = '\0';
	fclose (file);
	
	if (!g_str_has_prefix(buffer, "StarDict's treedict ifo file\nversion=2.4.2\n")) {
		g_print("Bad treedict ifo file %s, skiped!\n", ifofilename);
		g_free(buffer);
		return false;
	}
	gchar *p1= buffer + sizeof("StarDict's treedict ifo file\nversion=2.4.2\n")-1 -1;
	
	gchar *p2,*p3;

	p2 = strstr(p1,"\ntdxfilesize=");
	if (!p2) {
		g_free(buffer);
		return false;
	}
	p3 = strchr(p2+ sizeof("\ntdxfilesize=")-1,'\n');
	gchar *tmpstr = (gchar *)g_memdup(p2+sizeof("\ntdxfilesize=")-1, p3-(p2+sizeof("\ntdxfilesize=")-1)+1);
	tmpstr[p3-(p2+sizeof("\ntdxfilesize=")-1)] = '\0';
	*tdxfilesize = atol(tmpstr);
	g_free(tmpstr);

  *tdxfilesize = dict_info.index_file_size;
  if (!dict_info.sametypesequence.empty())
    sametypesequence=g_strdup(dict_info.sametypesequence.c_str());
		sametypesequence = (gchar *)g_memdup(p2+sizeof("\nsametypesequence=")-1, p3-(p2+sizeof("\nsametypesequence=")-1)+1);
		sametypesequence[p3-(p2+sizeof("\nsametypesequence=")-1)] = '\0';
	}	
	
	g_free(buffer);	
	return true;
}






#include "dictziplib.h"

const int MAX_MATCH_ITEM_PER_LIB=100;
const int MAX_FUZZY_DISTANCE= 3; // at most MAX_FUZZY_DISTANCE-1 differences allowed when find similar words

extern bool bIsPureEnglish(const gchar *str);

struct cacheItem {
  guint32 offset;
	gchar *data;
  //write code here to make it inline
  cacheItem() {data= NULL;}
  ~cacheItem() {g_free(data);}
};

const int WORDDATA_CACHE_NUM = 10;
const int INVALID_INDEX=-100;

class DictBase {
{
public:
	DictBase();
	~DictBase();
  gchar * GetWordData(guint32 idxitem_offset, guint32 idxitem_size);
protected:
	gchar *sametypesequence;
	FILE *dictfile;
	dictData *dictdzfile;
private:
  cacheItem cache[WORDDATA_CACHE_NUM];
	gint cache_cur;	
};

//this structure contain all information about dictionary
struct DictInfo {
  std::string ifo_file_name;
  glong wordcount;
  std::string bookname;
  std::string author;
  std::string email;
  std::string website;
  std::string date;
  std::string description;
  gulong index_file_size;
  std::string sametypesequence;
  bool load_from_ifo_file(const gchar *ifofilename, bool istreedict);
};

class Lib : public DictBase {
private:
	glong wordcount;
	gchar *bookname;

		glong *wordoffset;
	};

#ifdef HAVE_MMAP
	int mmap_fd;
	unsigned long mmap_idxmap_size;
#endif

	union {
		gchar *idxdatabuffer;
		glong cur_wordindex;
	};

	gchar wordentry_buf[256]; // The length of "word_str" should be less than 256. See src/tools/DICTFILE_FORMAT.
  guint32 wordentry_offset;
  guint32 wordentry_size;
	
  bool load_ifofile(const char *ifofilename, gulong *idxfilesize);

	void loadwordlist();
	void loadwordoffset();
public:
	Lib();
    ~Lib();
  bool load(const char *ifofilename);
  inline glong length() { return wordcount; }
  inline gchar* GetBookname() { return bookname; }
  bool Lookup(const char* sWord,glong *pIndex);
  bool LookupWithRule(GPatternSpec *pspec,glong *aIndex,int iBuffLen);
	gchar * GetWord(glong index);
	gchar * GetWordData(glong index);
};

private:
	Lib **oLib; // word library.
	gint libcount;
  int iMaxFuzzyDistance;
	
  void LoadDir(const gchar *dirname, const GSList *order_list, const GSList *disable_list);
public:

  void Load(const gchar *dicts_dir, const GSList *order_list, const GSList *disable_list);
	glong iLength(int iLib);
	gchar* GetBookname(int iLib);
  inline gint total_libs() {return libcount;}
	gchar * poGetWord(glong iIndex,int iLib);
	gchar * poGetWordData(glong iIndex,int iLib);
	gchar * poGetCurrentWord(glong * iCurrent);
	gchar * poGetNextWord(const gchar *word,glong * iCurrent);
	gchar * poGetPreWord(glong * iCurrent);
  bool LookupWord(const gchar* sWord,glong& iWordIndex,int iLib);
  bool LookupSimilarWord(const gchar* sWord, glong & iWordIndex, int iLib);
  bool SimpleLookupWord(const gchar* sWord, glong & iWordIndex, int iLib);

  struct Fuzzystruct {
    char * pMatchWord;
    int iMatchWordDistance;
  };
  typedef void (*TProgressFunc)(void);

  bool LookupWithFuzzy(const gchar *sWord, Fuzzystruct oFuzzystruct[], gint fuzzystruct_amount, TProgressFunc ProgressFunc);
  gint LookupWithRule(const gchar *word, TProgressFunc ProgressFunc, gchar **ppMatchWord);
};

inline gboolean bIsVowel(gchar inputchar);

class TreeDict : public DictBase
{
private:	
	bool load_ifofile(const char *ifofilename, gulong *tdxfilesize);
	void load_model(gchar **buffer, GtkTreeStore *model, GtkTreeIter *parent, gint count);
public:
	bool load(const char *ifofilename, GtkTreeStore *model);
};

class TreeDicts {




	gpAppFrame->oAppCore.oTopWin.InsertHisList(gpAppFrame->oAppCore.oTopWin.GetText());
	gpAppFrame->oAppCore.oTopWin.SetText(((BackListData *)((gpAppFrame->oAppCore.oTopWin.BackList)->data))->word);
	if (((BackListData *)(gpAppFrame->oAppCore.oTopWin.BackList->data))->adjustment_value != -1) {
		ProcessGtkEvent();
		gtk_adjustment_set_value(gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(gpAppFrame->oAppCore.oMidWin.oTextWin.scrolled_window)), ((BackListData *)(gpAppFrame->oAppCore.oTopWin.BackList->data))->adjustment_value);
	}
	g_free(((BackListData *)((gpAppFrame->oAppCore.oTopWin.BackList)->data))->word);

	if (GTK_WIDGET_HAS_FOCUS(GTK_WIDGET(GTK_COMBO(WordCombo)->entry)))
		gtk_editable_select_region(GTK_EDITABLE(GTK_COMBO(WordCombo)->entry),0,-1);
	if (((BackListData *)(list->data))->adjustment_value != -1) {
		ProcessGtkEvent(); // so all the definition text have been inserted.
		gtk_adjustment_set_value(gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(gpAppFrame->oAppCore.oMidWin.oTextWin.scrolled_window)), ((BackListData *)(list->data))->adjustment_value);
	}
	g_free(((BackListData *)(list->data))->word);

void TextWin::Show(gchar **Word, gchar **WordData, const gchar * sOriginWord)
{
	gchar *p;
  guint32 data_size,sec_size=0;
	GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
	gtk_text_buffer_begin_user_action(buffer); // will this speed up the showing?
	

	
	GtkTextIter iter;
	gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
  for (int i=0; i<gpAppFrame->oAppCore.oLibs.total_libs(); i++)	{
	{
		if (Word[i]) {
			gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, "<--- ",-1, "DictNameTag", NULL);
      gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, gpAppFrame->oAppCore.oLibs.GetBookname(i),
					       -1, "DictNameTag", NULL);
			gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, " --->\n",-1, "DictNameTag", NULL);
			gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, Word[i],-1, "WordTag", NULL);	
			gtk_text_buffer_insert (buffer, &iter,"\n", 1);
		}
		if (WordData[i]) {
      p=WordData[i];
      data_size=*reinterpret_cast<guint32 *>(p);
      p+=sizeof(guint32);
      while (guint32(p - (WordData[i] + sizeof(guint32)))< data_size) {
	switch (*p++) {
				{
					case 'm':
	case 'l'://need more work...
	case 'g':
	  sec_size = strlen(p);
	  if (sec_size)
	    gtk_text_buffer_insert(buffer, &iter, p, sec_size);	  
						sec_size++;
						break;
					case 't':
	  sec_size = strlen(p);
						if (sec_size) {
	    gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, "[", 1, "PhoneticTag", NULL);
	    gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, p, sec_size, "PhoneticTag", NULL);
	    gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, "]", 1, "PhoneticTag", NULL);
						}
						sec_size++;						
						break;
					case 'y':
	  sec_size = strlen(p);
						if (sec_size) {
	    gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, "[", 1, "YinBiaoTag", NULL);
	    gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, p, sec_size, "YinBiaoTag", NULL);
	    gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, "]", 1, "YinBiaoTag", NULL);
						}
						sec_size++;
						break;
					case 'W':
	  sec_size=*reinterpret_cast<guint32 *>(p);
	  sec_size=g_ntohl(sec_size);
						//enbale sound button.
	  sec_size += sizeof(guint32);
						break;
					case 'P':
	  sec_size=*reinterpret_cast<guint32 *>(p);
	  sec_size=g_ntohl(sec_size);
						//show this picture.
	  sec_size += sizeof(guint32);
						break;
	default:
	  /*nothing*/;
				}
	gtk_text_buffer_insert(buffer, &iter, "\n", 1);
	p += sec_size;
			}
		}		
	}

	GtkTextIter iter;
	gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);

	const gchar *p;
	glong data_size,sec_size;

  guint32 data_size,sec_size=0;
  const gchar *p=data;
  data_size=*reinterpret_cast<const guint32 *>(p);
  p+=sizeof(guint32);
  while (guint32(p - (data + sizeof(guint32)))< data_size) {
    switch (*p++) {
			case 'm':
    case 'l'://need more work...
    case 'g':
      sec_size = strlen(p);
				if (sec_size)
	gtk_text_buffer_insert(buffer, &iter, p, sec_size);
				sec_size++;
				break;
			case 't':
      sec_size = strlen(p);
				if (sec_size) {
	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, "[", 1, "PhoneticTag", NULL);
	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, p, sec_size, "PhoneticTag", NULL);
	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, "]", 1, "PhoneticTag", NULL);
				}
				sec_size++;						
				break;
			case 'y':
      sec_size = strlen(p);
				if (sec_size) {
	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, "[", 1, "YinBiaoTag", NULL);
	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, p, sec_size, "YinBiaoTag", NULL);
	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, "]", 1, "YinBiaoTag", NULL);
				}
				sec_size++;
				break;
			case 'W':
      sec_size=*reinterpret_cast<const guint32 *>(p);
      sec_size=g_ntohl(sec_size);
				//enbale sound button.
      sec_size += sizeof(guint32);
				break;
			case 'P':
      sec_size=*reinterpret_cast<const guint32 *>(p);
      sec_size=g_ntohl(sec_size);
				//show this picture.
      sec_size += sizeof(guint32);
				break;
    default:
      /*nothing*/;
		}
    gtk_text_buffer_insert(buffer, &iter,"\n", 1);
    p += sec_size;
	}
	gtk_text_buffer_end_user_action(buffer);
}




#  include "stardict-application-server.h"
#  include "GNOME_Stardict.h"
#endif
#include "distance.h"
#include "splash.h"

#ifndef _WIN32

AppCore::AppCore(AppFrame *pAppFrame)
{
	poAppFrame = pAppFrame;
	iMaxFuzzyDistance  = MAX_FUZZY_DISTANCE; //need to read from cfg.
	window = NULL; //need by save_yourself_cb().
	prefs_dlg = NULL;
	dict_manage_dlg = NULL;

	return return_val;
}

bool AppCore::SimpleLookupToFloat(const char* sWord, bool bShowIfNotFound)
{
    if ( sWord==NULL || sWord[0]=='\0')
        return true;

                ppWordData[iLib] = NULL;
			}
        }
        if (bFound)
        {
            ShowDataToFloatWin(ppWord, ppWordData,SearchWord);
            oTopWin.InsertHisList(SearchWord);

    return false;
}

//the input can be:
// (sWord,NULL,false) look up the sWord.
// (sWord,piIndex,false),look up the sWord,and set piIndex to the new indexes that found.
// (sWord,piIndex,true), show word by piIndex's information. it will always found, so bTryMoreIfNotFound is useless.
bool AppCore::SimpleLookupToTextWin(const char* sWord, glong* piIndex, bool piIndexValid, bool bTryMoreIfNotFound)
{
  bool bFound = false;
	// (sWord,NULL,false) look up the sWord.
	// (sWord,piIndex,false),look up the sWord,and set piIndex to the new indexes that found.
	// (sWord,piIndex,true), show word by piIndex's information. it will always found, so bTryMoreIfNotFound is useless.
	gboolean bFound = false;
	gchar **ppWord = (gchar **)g_malloc(sizeof(gchar *) * oLibs.total_libs());
	gchar **ppWordData = (gchar **)g_malloc(sizeof(gchar *) * oLibs.total_libs());
	glong *iIndex;

	else
		iIndex = piIndex;
	    
  for (int iLib=0; iLib<oLibs.total_libs(); iLib++) {
		if (!piIndexValid) {
        	if (oLibs.LookupWord(sWord,iIndex[iLib],iLib)) {
				ppWord[iLib] = oLibs.poGetWord(iIndex[iLib],iLib);
				ppWordData[iLib] = oLibs.poGetWordData(iIndex[iLib],iLib);
            	bFound = true;
      } else {
        	else {
				ppWord[iLib] = NULL;
            	ppWordData[iLib] = NULL;
			}
    } else {
      if (piIndex[iLib] != INVALID_INDEX && 
	  !strcmp((ppWord[iLib] = oLibs.poGetWord(piIndex[iLib],iLib)), sWord)) {
				ppWordData[iLib] = oLibs.poGetWordData(piIndex[iLib],iLib);
				bFound = true;
      }	else {
			else {
				ppWord[iLib] = NULL;
				ppWordData[iLib] = NULL;
			}
		}
    }

  if (!bFound && !piIndexValid) {
    for (int iLib=0; iLib<oLibs.total_libs(); iLib++) {
        	if (oLibs.LookupSimilarWord(sWord,iIndex[iLib],iLib)) {
				ppWord[iLib] = oLibs.poGetWord(iIndex[iLib],iLib);
				ppWordData[iLib] = oLibs.poGetWordData(iIndex[iLib],iLib);
            	bFound = true;
      } else {
        	else {
				ppWord[iLib] = NULL;
            	ppWordData[iLib] = NULL;
			}

			if (*hword) {
				if (!strcmp(hword,sWord)) {
					ShowNotFoundToTextWin(sWord,_("<Not Found!>"), TEXT_WIN_NOT_FOUND);
	} else {
				else {
					for (int iLib=0;iLib<oLibs.total_libs();iLib++) {
			        	if (oLibs.LookupWord(hword,iIndex[iLib],iLib)) {
							ppWord[iLib] = oLibs.poGetWord(iIndex[iLib],iLib);
							ppWordData[iLib] = oLibs.poGetWordData(iIndex[iLib],iLib);
            				bFound = true;
	    } else {
        				else {
							ppWord[iLib] = NULL;
            				ppWordData[iLib] = NULL;
						}
					}
					if (!bFound) {
	    for (int iLib=0; iLib<oLibs.total_libs(); iLib++) {
				        	if (oLibs.LookupSimilarWord(hword,iIndex[iLib],iLib)) {
								ppWord[iLib] = oLibs.poGetWord(iIndex[iLib],iLib);
								ppWordData[iLib] = oLibs.poGetWordData(iIndex[iLib],iLib);
            					bFound = true;
	      } else {
				        	else {
								ppWord[iLib] = NULL;
				            	ppWordData[iLib] = NULL;
							}

					else
						ShowNotFoundToTextWin(sWord,_("<Not Found!>"), TEXT_WIN_NOT_FOUND);		
				}
      } else {
			else {
				ShowNotFoundToTextWin(sWord,_("<Not Found!>"), TEXT_WIN_NOT_FOUND);
			}
			g_free(word);
    } else {
		else {
			ShowNotFoundToTextWin(sWord,_("<Not Found!>"), TEXT_WIN_NOT_FOUND);
		}
	}

	
	g_free(ppWord);
	g_free(ppWordData);
	return bFound;
}

  return bFound;
{
    if (s1==NULL || s2==NULL)
        return 0;
    const struct Fuzzystruct * o1 = (struct Fuzzystruct*)s1;
    const struct Fuzzystruct * o2 = (struct Fuzzystruct*)s2;
    
    if ( o1->iMatchWordDistance > o2->iMatchWordDistance )
        return 1;
    else if ( o1->iMatchWordDistance < o2->iMatchWordDistance )
        return -1;
    else if ( o1->pMatchWord && o2->pMatchWord )
        return stardict_strcmp(o1->pMatchWord, o2->pMatchWord);
    else
        return 0;
}

void AppCore::LookupWithFuzzyToMainWin(const gchar *sWord)

   
	gdk_window_set_cursor (window->window, gpAppFrame->oAppSkin.stardict.watch_cursor.cursor);
        
  Libs::Fuzzystruct oFuzzystruct[MAX_FUZZY_MATCH_ITEM];
  bool Found=oLibs.LookupWithFuzzy(sWord, oFuzzystruct, 
				   MAX_FUZZY_MATCH_ITEM, ProcessGtkEvent);
        oFuzzystruct[i].pMatchWord = NULL;
        oFuzzystruct[i].iMatchWordDistance = iMaxFuzzyDistance;
    }
    int iMaxDistance = iMaxFuzzyDistance;
    int iDistance;
    gboolean Found = false;
    class EditDistance oEditDistance;

    glong iCheckWordLen;
	int sCheckLen;
	const char *sCheck;
	gunichar *ucs4_str1,*ucs4_str2;
	glong ucs4_str2_len;
	char *sLowerCheckWord;
	gchar *sLowerWord = g_utf8_strdown(sWord, -1);	
	ucs4_str2 = g_utf8_to_ucs4_fast(sLowerWord,-1,&ucs4_str2_len);
	g_free(sLowerWord);
    for(int iLib=0;iLib<oLibs.total_libs();iLib++)
    {
        ProcessGtkEvent();
        if((stardict_strcmp(sWord,oLibs.poGetWord(0,iLib))>=0) && (stardict_strcmp(sWord,oLibs.poGetWord(oLibs.iLength(iLib)-1,iLib))<=0)) //there are Chinese dicts and English dicts...
        {
            const int iwords = oLibs.iLength(iLib);
            for (int index=0;index<iwords;index++)
            {
                //ProcessGtkEvent(); // too slow if here
                sCheck = oLibs.poGetWord(index,iLib);
                // tolower and skip too long or too short words
				sCheckLen = strlen(sCheck);
                iCheckWordLen = g_utf8_strlen(sCheck, sCheckLen);
                if (iCheckWordLen-ucs4_str2_len>=iMaxDistance || ucs4_str2_len-iCheckWordLen>=iMaxDistance )
                    continue;				
				sLowerCheckWord = g_utf8_strdown(sCheck, sCheckLen);
				if (iCheckWordLen > ucs4_str2_len)
					(*g_utf8_offset_to_pointer(sLowerCheckWord, ucs4_str2_len)) = '\0';
				ucs4_str1 = g_utf8_to_ucs4_fast(sLowerCheckWord, -1,NULL);
				g_free(sLowerCheckWord);
                iDistance = oEditDistance.CalEditDistance(ucs4_str1,ucs4_str2,iMaxDistance);				
				g_free(ucs4_str1);								
                if ( iDistance < iMaxDistance && iDistance < ucs4_str2_len) // when ucs4_str2_len=1,2 we need less fuzzy.
                {
                    Found = true;
                    gboolean bAlreadyInList = false;
                    int iMaxDistanceAt=0;
                    for (int j=0;j<MAX_FUZZY_MATCH_ITEM;j++)
                    {
                      	if ( oFuzzystruct[j].pMatchWord && strcmp(oFuzzystruct[j].pMatchWord,sCheck)==0 )   //already in list
						{
                            bAlreadyInList = true;
							break;
						}
						//find the position,it will certainly be found (include the first time) as iMaxDistance is set by last time.
                        if ( oFuzzystruct[j].iMatchWordDistance == iMaxDistance )
						{
                            iMaxDistanceAt = j;
						}
                    }
                    if (!bAlreadyInList )
                    {
						if (oFuzzystruct[iMaxDistanceAt].pMatchWord)
							g_free(oFuzzystruct[iMaxDistanceAt].pMatchWord);
                        oFuzzystruct[iMaxDistanceAt].pMatchWord = g_strdup(sCheck);
                        oFuzzystruct[iMaxDistanceAt].iMatchWordDistance = iDistance;
                        // calc new iMaxDistance
                        iMaxDistance = iDistance;
                        for (int j=0;j<MAX_FUZZY_MATCH_ITEM;j++)
                        {
                            if ( oFuzzystruct[j].iMatchWordDistance > iMaxDistance )
                                iMaxDistance = oFuzzystruct[j].iMatchWordDistance;
                        } // calc new iMaxDistance
                    }   // add to list
                }   // find one
            }   // each word
        }   // ok for search
    }   // each lib
    g_free(ucs4_str2);
	
    // show
    oMidWin.oIndexWin.oListWin.Clear();
    if (Found) {		
		oMidWin.oIndexWin.oListWin.list_word_type = LIST_WIN_FUZZY_LIST;
        // sort with distance
        qsort(oFuzzystruct,MAX_FUZZY_MATCH_ITEM,sizeof(Fuzzystruct),FuzzystructCompare);

		//SimpleLookupToTextWin(oFuzzystruct[0].pMatchWord,NULL);
		SimpleLookupToTextWin(oFuzzystruct[0].pMatchWord, iCurrentIndex, false); // so iCurrentIndex is refreshed.

    for (int i=0; i<MAX_FUZZY_MATCH_ITEM; i++) {
      if (oFuzzystruct[i].pMatchWord) {
                oMidWin.oIndexWin.oListWin.InsertLast(oFuzzystruct[i].pMatchWord);
				g_free(oFuzzystruct[i].pMatchWord);
                //printf("fuzzy %s,%d\n",oFuzzystruct[i].pMatchWord,oFuzzystruct[i].iMatchWordDistance);
      } else
			else {
				break;
			}
        }
		oMidWin.oIndexWin.oListWin.ReScroll();
  } else {
    else {
		oMidWin.oIndexWin.oListWin.list_word_type = LIST_WIN_EMPTY;
        ShowNotFoundToTextWin(sWord,_("There are too many spelling errors :-("), TEXT_WIN_FUZZY_NOT_FOUND);
	}	
  gdk_window_set_cursor(window->window, gpAppFrame->oAppSkin.stardict.normal_cursor.cursor);
}

void AppCore::LookupWithFuzzyToFloatWin(const gchar *sWord)

    
	gdk_window_set_cursor (oFloatWin.FloatWindow->window, gpAppFrame->oAppSkin.stardict.watch_cursor.cursor);
	    
  Libs::Fuzzystruct oFuzzystruct[MAX_FLOAT_WINDOW_FUZZY_MATCH_ITEM];
    for (int i=0;i<MAX_FLOAT_WINDOW_FUZZY_MATCH_ITEM;i++)
    {
        oFuzzystruct[i].pMatchWord = NULL;
        oFuzzystruct[i].iMatchWordDistance = iMaxFuzzyDistance;
    }
    int iMaxDistance = iMaxFuzzyDistance;
    int iDistance;
    gboolean Found = false;
    class EditDistance oEditDistance;

  bool Found = oLibs.LookupWithFuzzy(sWord, oFuzzystruct, 
				     MAX_FLOAT_WINDOW_FUZZY_MATCH_ITEM,
				     ProcessGtkEvent);
	
  if (Found) {
    gchar *sLowerCheckWord;
	gchar *sLowerWord = g_utf8_strdown(sWord, -1);
	ucs4_str2 = g_utf8_to_ucs4_fast(sLowerWord, -1,&ucs4_str2_len);
	g_free(sLowerWord);
    for(int iLib=0;iLib<oLibs.total_libs();iLib++)
    {
        ProcessGtkEvent();
        if((stardict_strcmp(sWord,oLibs.poGetWord(0,iLib))>=0) && (stardict_strcmp(sWord,oLibs.poGetWord(oLibs.iLength(iLib)-1,iLib))<=0)) //there are Chinese dicts and English dicts...
        {
            const int iwords = oLibs.iLength(iLib);
            for (int index=0;index<iwords;index++)
            {
                //ProcessGtkEvent(); // too slow if here
                sCheck = oLibs.poGetWord(index,iLib);
                // tolower and skip too long or too short words
				sCheckLen = strlen(sCheck);
                iCheckWordLen = g_utf8_strlen(sCheck, sCheckLen);
                if (iCheckWordLen-ucs4_str2_len>=iMaxDistance || ucs4_str2_len-iCheckWordLen>=iMaxDistance )
                    continue;
				sLowerCheckWord = g_utf8_strdown(sCheck, sCheckLen);
				if (iCheckWordLen > ucs4_str2_len)
					(*g_utf8_offset_to_pointer(sLowerCheckWord, ucs4_str2_len)) = '\0';
				ucs4_str1 = g_utf8_to_ucs4_fast(sLowerCheckWord, -1,NULL);
				g_free(sLowerCheckWord);
                iDistance = oEditDistance.CalEditDistance(ucs4_str1,ucs4_str2,iMaxDistance);				
				g_free(ucs4_str1);				
                if ( iDistance < iMaxDistance && iDistance < ucs4_str2_len) // when ucs4_str2_len=1,2 we need less fuzzy.
                {
                    Found = true;
                    gboolean bAlreadyInList = false;
                    int iMaxDistanceAt=0;
                    for (int j=0;j<MAX_FLOAT_WINDOW_FUZZY_MATCH_ITEM;j++)
                    {
                      	if ( oFuzzystruct[j].pMatchWord && strcmp(oFuzzystruct[j].pMatchWord,sCheck)==0 )   //already in list
						{
                            bAlreadyInList = true;
							break;
						}
                        if ( oFuzzystruct[j].iMatchWordDistance == iMaxDistance )
						{
                            iMaxDistanceAt = j;
						}
                    }
                    if (!bAlreadyInList )
                    {
						if (oFuzzystruct[iMaxDistanceAt].pMatchWord)
							g_free(oFuzzystruct[iMaxDistanceAt].pMatchWord);
                        oFuzzystruct[iMaxDistanceAt].pMatchWord = g_strdup(sCheck);
                        oFuzzystruct[iMaxDistanceAt].iMatchWordDistance = iDistance;
                        // calc new iMaxDistance
                        iMaxDistance = iDistance;
                        for (int j=0;j<MAX_FLOAT_WINDOW_FUZZY_MATCH_ITEM;j++)
                        {
                            if ( oFuzzystruct[j].iMatchWordDistance > iMaxDistance )
                                iMaxDistance = oFuzzystruct[j].iMatchWordDistance;
                        } // calc new iMaxDistance
                    }   // add to list
                }   // find one
            }   // each word
        }   // ok for search
    }   // each lib
    g_free(ucs4_str2);
	
    if (Found)
    {
        // sort with distance
        qsort(oFuzzystruct,MAX_FLOAT_WINDOW_FUZZY_MATCH_ITEM,sizeof(Fuzzystruct),FuzzystructCompare);
		int i,count=0;
    for (i=0;i<MAX_FLOAT_WINDOW_FUZZY_MATCH_ITEM;i++) {
        {
            if (oFuzzystruct[i].pMatchWord)
				count++;
			else

		gchar **ppWord;
		gchar **ppWordData;
		glong iRetIndex;
    for (i=0;i<count;i++) {
      bool bFound = false;
    		gboolean bFound = false;
			ppWord = (gchar **)g_malloc(sizeof(gchar *) * oLibs.total_libs());
			ppWordData = (gchar **)g_malloc(sizeof(gchar *) * oLibs.total_libs());    		
	    
			ppOriginWord[i] = oFuzzystruct[i].pMatchWord;
      for (int iLib=0; iLib<oLibs.total_libs(); iLib++)	{
	if (oLibs.SimpleLookupWord(oFuzzystruct[i].pMatchWord, iRetIndex,iLib))	{
        		if (oLibs.SimpleLookupWord(oFuzzystruct[i].pMatchWord, iRetIndex,iLib))
        		{
					ppWord[iLib] = oLibs.poGetWord(iRetIndex,iLib);
					ppWordData[iLib] = oLibs.poGetWordData(iRetIndex,iLib);
            		bFound = true;
	} else {
        		else {
					ppWord[iLib] = NULL;
            		ppWordData[iLib] = NULL;
				}
    		}
      if (bFound) {// it is certainly be true.			
			{
				pppWord[i]=ppWord;
				pppWordData[i]=ppWordData;
      }	else {
			else
			{
				g_free(ppWord);
				pppWord[i]=NULL;
				g_free(ppWordData);

			}			
		}
		ShowDatasToFloatWin(pppWord, pppWordData, ppOriginWord, count,sWord);
    for (i=0; i<count; i++) {
		{
			if (pppWord[i])
				g_free(pppWord[i]);
			if (pppWordData[i])

		
		for (i=0;i<count;i++)
			g_free(oFuzzystruct[i].pMatchWord);
  } else
    else
		ShowNotFoundToFloatWin(sWord,_("Fuzzy query failed, too :-("), true);
  gdk_window_set_cursor(oFloatWin.FloatWindow->window, gpAppFrame->oAppSkin.stardict.normal_cursor.cursor);
}

int AppCore::MatchWordCompare(const void * s1, const void * s2)
{
	const gchar **o1 = (const gchar **)s1;
	const gchar **o2 = (const gchar **)s2;
	return stardict_strcmp(*o1,*o2);
}

void AppCore::LookupWithRuleToMainWin(const gchar *word)
{
	gdk_window_set_cursor (window->window, gpAppFrame->oAppSkin.stardict.watch_cursor.cursor);
	
    glong aiIndex[MAX_MATCH_ITEM_PER_LIB+1];
    int iMatchCount = 0;
	gchar **ppMatchWord = (gchar **)g_malloc(sizeof(gchar *) * (MAX_MATCH_ITEM_PER_LIB) * oLibs.total_libs());
  gint iMatchCount=oLibs.LookupWithRule(word, ProcessGtkEvent, ppMatchWord);
	
    for(int iLib=0;iLib<oLibs.total_libs();iLib++)
    {
        //if(oLibs.LookdupWordsWithRule(pspec,aiIndex,MAX_MATCH_ITEM_PER_LIB+1-iMatchCount,iLib)) // -iMatchCount,so save time,but may got less result and the word may repeat.
		if(oLibs.LookdupWordsWithRule(pspec,aiIndex,MAX_MATCH_ITEM_PER_LIB+1,iLib))
        {
            ProcessGtkEvent();
            for(int i=0;aiIndex[i]!=-1;i++)
            {
                gchar * sMatchWord = oLibs.poGetWord(aiIndex[i],iLib);
                gboolean bAlreadyInList = false;
                for (int j=0;j<iMatchCount;j++)
                {
                    if ( strcmp(ppMatchWord[j],sMatchWord) == 0 )   //already in list
                    {
                        bAlreadyInList = true;
                        break;
                    }
                }
                if ( !bAlreadyInList)
                    ppMatchWord[iMatchCount++] = g_strdup(sMatchWord);
            }
        }
    }
	g_pattern_spec_free(pspec);
	oMidWin.oIndexWin.oListWin.Clear();
  if (iMatchCount) {		
    {		
		oMidWin.oIndexWin.oListWin.list_word_type = LIST_WIN_PATTERN_LIST;

    for(gint i=0; i<iMatchCount; i++)
            oMidWin.oIndexWin.oListWin.InsertLast(ppMatchWord[i]);
        //memset(iCurrentIndex,'\0',sizeof(iCurrentIndex));    // iCurrentIndex is ineffective now.
        

        //SimpleLookupToTextWin(ppMatchWord[0],NULL);
		SimpleLookupToTextWin(ppMatchWord[0], iCurrentIndex, false); // so iCurrentIndex is refreshed.
		oMidWin.oIndexWin.oListWin.ReScroll();
    for(gint i=0; i<iMatchCount; i++)
			g_free(ppMatchWord[i]);
  } else {
    else
    {
		oMidWin.oIndexWin.oListWin.list_word_type = LIST_WIN_EMPTY;
        ShowNotFoundToTextWin(word,_("Found no words matching this pattern!"), TEXT_WIN_PATTERN_NOT_FOUND);
    }	

	gtk_widget_destroy(window);
}

void AppCore::ProcessGtkEvent()
{
	poAppFrame->ProcessGtkEvent();
}


/***************************************************/
AppFrame::AppFrame():oAppCore(this)

	gtk_main();
}

void AppFrame::ProcessGtkEvent()
{
	while (gtk_events_pending())
	{
		gtk_main_iteration();
	}
}

void AppFrame::Quit()
{   
  gboolean maximized=conf->get_maximized();

    gtk_main_quit ();
}

gint stardict_strcmp(const gchar *s1, const gchar *s2)
{
	gint a;
	a = g_ascii_strcasecmp(s1, s2);
	if (a == 0)
		return strcmp(s1, s2);
	else
		return a;
}

gboolean bContainRule(const char* sWord)
{
    int i;

    return(false);
}

gboolean bIsPureEnglish(const gchar *str) // i think this should work even when it is UTF8 string :).
{
    int i;
    for(i=0;str[i]!=0;i++) {
	//if(str[i]<0)
        //if(str[i]<32 || str[i]>126) // tab equal 9,so this is not OK.
	// Better use isascii() but not str[i]<0 while char is default unsigned in arm
	if (!isascii(str[i]))
        {
            return(false);
        }
    }
    return(true);	
}

gchar* GetPureEnglishAlpha(gchar *str)
{
	while (*str && (!((*str >= 'a' && *str <='z')||(*str >= 'A' && *str <='Z'))))





//notice!!! when you change these DEFAULT const value,remember that you'd better change data/stardict.schemas.in too!

const int MAX_MATCH_ITEM_PER_LIB=100;
const int MAX_FUZZY_MATCH_ITEM=100;
const int MAX_FLOAT_WINDOW_FUZZY_MATCH_ITEM=5;

const int LIST_WIN_ROW_NUM = 30; //how many words show in the list win.
const int MAX_FUZZY_DISTANCE= 3; // at most MAX_FUZZY_DISTANCE-1 differences allowed when find similar words


class AppCore


	PrefsDlg *prefs_dlg;
	DictManageDlg *dict_manage_dlg;
    // struct
    struct Fuzzystruct {
        char * pMatchWord;
        int iMatchWordDistance;
    };
    int iMaxFuzzyDistance;	

	static int FuzzystructCompare(const void * s1, const void * s2);
	static int MatchWordCompare(const void * s1, const void * s2);
	static gboolean on_delete_event(GtkWidget * window, GdkEvent *event , AppCore *oAppCore);
	static gboolean on_window_state_event(GtkWidget * window, GdkEventWindowState *event , AppCore *oAppCore);

	AppCore(AppFrame* pAppFrame);
	~AppCore();
	void Create(gchar *queryword);
	void ProcessGtkEvent();
    void End();
	void Query(const gchar *word);
	bool SimpleLookupToFloat(const gchar* sWord, bool bShowIfNotFound);
	bool SimpleLookupToTextWin(const gchar* sWord,glong* piIndex, bool piIndexValid = false, bool bTryMoreIfNotFound = false);
	void LookupWithFuzzyToMainWin(const gchar* word);
	void LookupWithFuzzyToFloatWin(const gchar * word);
	void LookupWithRuleToMainWin(const gchar* word);

	AppFrame();
	~AppFrame();
	void Init(gchar *queryword);
	void ProcessGtkEvent();
	void Quit();
};


extern gchar stardict_data_dir[256];
#endif

extern gint stardict_strcmp(const gchar *s1, const gchar *s2);
extern gboolean bContainRule(const char* sWord);
extern gboolean bIsPureEnglish(const gchar *str);
extern gchar* GetPureEnglishAlpha(gchar *str);
extern gchar* GetHeadWord(gchar *str);

extern gboolean stardict_on_enter_notify (GtkWidget * widget, GdkEventCrossing * event, gpointer data);

#endif

Lines 54-56 Link Here

(-)stardict-cur-accepted/src/utils.cpp (+6 lines)
54	gnome_url_show(url, NULL);	54	gnome_url_show(url, NULL);
55	#endif	55	#endif
56	}	56	}
		57
		58	void ProcessGtkEvent(void)
		59	{
		60	while (gtk_events_pending())
		61	gtk_main_iteration();
		62	}

Lines 4-8 Link Here

(-)stardict-cur-accepted/src/utils.h (+1 lines)
4	extern void play_wav_file(const gchar *filename);	4	extern void play_wav_file(const gchar *filename);
5	extern void show_help(const gchar *section);	5	extern void show_help(const gchar *section);
6	extern void show_url(const gchar *url);	6	extern void show_url(const gchar *url);
		7	extern void ProcessGtkEvent(void);
7		8
8	#endif/UTILS_H/	9	#endif/UTILS_H/

Return to bug 86379

Lines 44-172 Link Here

(-)stardict-cur-accepted/src/dictmanagedlg.cpp (-129 / +24 lines)
44	gtk_notebook_set_current_page(GTK_NOTEBOOK(oDictManageDlg->notebook), 1);	44	gtk_notebook_set_current_page(GTK_NOTEBOOK(oDictManageDlg->notebook), 1);
45	}	45	}
46		46
47	gboolean DictManageDlg::get_dict_info(gboolean istreedict, const gchar ifofilename, glong wordcount, gchar bookname, gchar author, gchar **email,
48	gchar website, gchar date, gchar **description)
49	{
50	struct stat stats;
51	if (stat (ifofilename, &stats) == -1) {
52	return false;
53	}
54
55	FILE *file;
56	if (!(file = fopen (ifofilename, "rb"))) {
57	return false;
58	}
59	gchar buffer = (gchar )g_malloc (stats.st_size + 1);
60	fread (buffer, 1, stats.st_size, file);
61	buffer[stats.st_size] = '\0';
62	fclose (file);
63
64	if (!(istreedict?g_str_has_prefix(buffer, "StarDict's treedict ifo file\nversion=2.4.2\n"):g_str_has_prefix(buffer, "StarDict's dict ifo file\nversion=2.4.2\n"))) {
65	g_free(buffer);
66	return false;
67	}
68
69	gchar p1,p2,*p3;
70	if (istreedict)
71	p1 = buffer + sizeof("StarDict's treedict ifo file\nversion=2.4.2\n") -1 -1;
72	else
73	p1 = buffer + sizeof("StarDict's dict ifo file\nversion=2.4.2\n") -1 -1;
74
75	p2 = strstr(p1,"\nwordcount=");
76	if (p2) {
77	p3 = strchr(p2+ sizeof("\nwordcount=")-1,'\n');
78	gchar tmpstr = (gchar )g_memdup(p2+sizeof("\nwordcount=")-1, p3-(p2+sizeof("\nwordcount=")-1)+1);
79	tmpstr[p3-(p2+sizeof("\nwordcount=")-1)] = '\0';
80	*wordcount = atol(tmpstr);
81	g_free(tmpstr);
82	}
83	else {
84	*wordcount = 0;
85	}
86
87	p2 = strstr(p1,"\nbookname=");
88	if (p2) {
89	p2 = p2 + sizeof("\nbookname=") -1;
90	p3 = strchr(p2, '\n');
91	*bookname = g_strndup(p2, p3-p2);
92	}
93	else {
94	*bookname = NULL;
95	}
96
97	p2 = strstr(p1,"\nauthor=");
98	if (p2) {
99	p2 = p2 + sizeof("\nauthor=") -1;
100	p3 = strchr(p2, '\n');
101	*author = g_strndup(p2, p3-p2);
102	}
103	else {
104	*author = NULL;
105	}
106
107	p2 = strstr(p1,"\nemail=");
108	if (p2) {
109	p2 = p2 + sizeof("\nemail=") -1;
110	p3 = strchr(p2, '\n');
111	*email = g_strndup(p2, p3-p2);
112	}
113	else {
114	*email = NULL;
115	}
116
117	p2 = strstr(p1,"\nwebsite=");
118	if (p2) {
119	p2 = p2 + sizeof("\nwebsite=") -1;
120	p3 = strchr(p2, '\n');
121	*website = g_strndup(p2, p3-p2);
122	}
123	else {
124	*website = NULL;
125	}
126
127	p2 = strstr(p1,"\ndate=");
128	if (p2) {
129	p2 = p2 + sizeof("\ndate=") -1;
130	p3 = strchr(p2, '\n');
131	*date = g_strndup(p2, p3-p2);
132	}
133	else {
134	*date = NULL;
135	}
136
137	p2 = strstr(p1,"\ndescription=");
138	if (p2) {
139	p2 = p2 + sizeof("\ndescription=") -1;
140	p3 = strchr(p2, '\n');
141	*description = g_strndup(p2, p3-p2);
142	}
143	else {
144	*description = NULL;
145	}
146
147	g_free(buffer);
148	return true;
149	}
150
151	void DictManageDlg::load_dir(gboolean istreedict, const gchar dirname, const GSList order_list, const GSList disable_list, GtkListStore model)	47	void DictManageDlg::load_dir(gboolean istreedict, const gchar dirname, const GSList order_list, const GSList disable_list, GtkListStore model)
152	{	48	{
153	GDir *dir = g_dir_open(dirname, 0, NULL);	49	GDir *dir = g_dir_open(dirname, 0, NULL);
154	if (dir)	50	if (dir) {
155	{
156	GtkTreeIter iter;	51	GtkTreeIter iter;
157	const gchar *filename;	52	const gchar *filename;
158	gchar fullfilename[256];	53	gchar fullfilename[256];
159	gboolean loaded;	54	gboolean loaded;
160	const GSList tmplist1,tmplist2;	55	const GSList tmplist1,tmplist2;
161	gboolean disabled;	56	gboolean disabled;
162	glong wordcount;	57	DictInfo dict_info;
163	gchar bookname, author, email, website, description, date;
164	while ((filename = g_dir_read_name(dir))!=NULL) {	58	while ((filename = g_dir_read_name(dir))!=NULL) {
165	sprintf(fullfilename, "%s/%s", dirname, filename);	59	sprintf(fullfilename, "%s/%s", dirname, filename);
166	if (g_file_test(fullfilename, G_FILE_TEST_IS_DIR)) {	60	if (g_file_test(fullfilename, G_FILE_TEST_IS_DIR)) {
167	load_dir(istreedict, fullfilename, order_list, disable_list, model);	61	load_dir(istreedict, fullfilename, order_list, disable_list, model);
168	}	62	} else if (g_str_has_suffix(filename,".ifo")) {
169	else if (g_str_has_suffix(filename,".ifo")) {
170	tmplist1 = order_list;	63	tmplist1 = order_list;
171	loaded = false;	64	loaded = false;
172	while (tmplist1) {	65	while (tmplist1) {
Lines 178-184 Link Here
178	}	71	}
179	if (loaded)	72	if (loaded)
180	continue;	73	continue;
181	if (get_dict_info(istreedict, fullfilename, &wordcount, &bookname, &author, &email, &website, &description, &date)) {	74	if (dict_info.load_from_ifo_file(fullfilename, istreedict)) {
182	tmplist2 = disable_list;	75	tmplist2 = disable_list;
183	disabled = false;	76	disabled = false;
184	while (tmplist2) {	77	while (tmplist2) {
Lines 189-201 Link Here
189	tmplist2 = g_slist_next(tmplist2);	82	tmplist2 = g_slist_next(tmplist2);
190	}	83	}
191	gtk_list_store_append (model, &iter);	84	gtk_list_store_append (model, &iter);
192	gtk_list_store_set (model, &iter, 0, !disabled, 1, bookname, 2, wordcount, 3, author, 4, email, 5, website, 6, date, 7, description, 8, fullfilename, 9, true, -1);	85	gtk_list_store_set (model, &iter, 0, !disabled,
193	g_free(bookname);	86	1, dict_info.bookname.c_str(),
194	g_free(author);	87	2, dict_info.wordcount,
195	g_free(email);	88	3, dict_info.author.c_str(),
196	g_free(website);	89	4, dict_info.email.c_str(),
197	g_free(description);	90	5, dict_info.website.c_str(),
198	g_free(date);	91	6, dict_info.date.c_str(),
		92	7, dict_info.description.c_str(),
		93	8, fullfilename, 9, true, -1);
199	}	94	}
200	}	95	}
201	}	96	}
Lines 218-225 Link Here
218	disable_list=conf->get_dict_disable_list();	113	disable_list=conf->get_dict_disable_list();
219	}	114	}
220		115
221	glong wordcount;
222	gchar bookname, author, email, website, description, date;
223		116
224	GtkTreeIter iter;	117	GtkTreeIter iter;
225		118
Lines 230-238 Link Here
230	while (tmplist1) {	123	while (tmplist1) {
231	ifofilename = (gchar *)(tmplist1->data);	124	ifofilename = (gchar *)(tmplist1->data);
232	tmplist1 = g_slist_next(tmplist1);	125	tmplist1 = g_slist_next(tmplist1);
233		126	DictInfo dict_info;
234	if (g_file_test(ifofilename, G_FILE_TEST_EXISTS)) {	127	if (g_file_test(ifofilename, G_FILE_TEST_EXISTS)) {
235	if (get_dict_info(istreedict, ifofilename, &wordcount, &bookname, &author, &email, &website, &description, &date)) {	128	if (dict_info.load_from_ifo_file(ifofilename, istreedict)) {
236	tmplist2 = disable_list;	129	tmplist2 = disable_list;
237	disabled = false;	130	disabled = false;
238	while (tmplist2) {	131	while (tmplist2) {
Lines 243-255 Link Here
243	tmplist2 = g_slist_next(tmplist2);	136	tmplist2 = g_slist_next(tmplist2);
244	}	137	}
245	gtk_list_store_append (model, &iter);	138	gtk_list_store_append (model, &iter);
246	gtk_list_store_set (model, &iter, 0, !disabled, 1, bookname, 2, wordcount, 3, author, 4, email, 5, website, 6, date, 7, description, 8, ifofilename, 9, true, -1);	139	gtk_list_store_set (model, &iter, 0, !disabled,
247	g_free(bookname);	140	1, dict_info.bookname.c_str(),
248	g_free(author);	141	2, dict_info.wordcount,
249	g_free(email);	142	3, dict_info.author.c_str(),
250	g_free(website);	143	4, dict_info.email.c_str(),
251	g_free(description);	144	5, dict_info.website.c_str(),
252	g_free(date);	145	6, dict_info.description.c_str(),
		146	7, dict_info.date.c_str(),
		147	8, ifofilename, 9, true, -1);
253	}	148	}
254	}	149	}
255	}	150	}

Lines 198-204 Link Here

(-)stardict-cur-accepted/src/mainwin.cpp (-54 / +62 lines)
198	gpAppFrame->oAppCore.oTopWin.InsertHisList(gpAppFrame->oAppCore.oTopWin.GetText());	198	gpAppFrame->oAppCore.oTopWin.InsertHisList(gpAppFrame->oAppCore.oTopWin.GetText());
199	gpAppFrame->oAppCore.oTopWin.SetText(((BackListData *)((gpAppFrame->oAppCore.oTopWin.BackList)->data))->word);	199	gpAppFrame->oAppCore.oTopWin.SetText(((BackListData *)((gpAppFrame->oAppCore.oTopWin.BackList)->data))->word);
200	if (((BackListData *)(gpAppFrame->oAppCore.oTopWin.BackList->data))->adjustment_value != -1) {	200	if (((BackListData *)(gpAppFrame->oAppCore.oTopWin.BackList->data))->adjustment_value != -1) {
201	gpAppFrame->ProcessGtkEvent();	201	ProcessGtkEvent();
202	gtk_adjustment_set_value(gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(gpAppFrame->oAppCore.oMidWin.oTextWin.scrolled_window)), ((BackListData *)(gpAppFrame->oAppCore.oTopWin.BackList->data))->adjustment_value);	202	gtk_adjustment_set_value(gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(gpAppFrame->oAppCore.oMidWin.oTextWin.scrolled_window)), ((BackListData *)(gpAppFrame->oAppCore.oTopWin.BackList->data))->adjustment_value);
203	}	203	}
204	g_free(((BackListData *)((gpAppFrame->oAppCore.oTopWin.BackList)->data))->word);	204	g_free(((BackListData *)((gpAppFrame->oAppCore.oTopWin.BackList)->data))->word);
Lines 255-261 Link Here
255	if (GTK_WIDGET_HAS_FOCUS(GTK_WIDGET(GTK_COMBO(WordCombo)->entry)))	255	if (GTK_WIDGET_HAS_FOCUS(GTK_WIDGET(GTK_COMBO(WordCombo)->entry)))
256	gtk_editable_select_region(GTK_EDITABLE(GTK_COMBO(WordCombo)->entry),0,-1);	256	gtk_editable_select_region(GTK_EDITABLE(GTK_COMBO(WordCombo)->entry),0,-1);
257	if (((BackListData *)(list->data))->adjustment_value != -1) {	257	if (((BackListData *)(list->data))->adjustment_value != -1) {
258	gpAppFrame->ProcessGtkEvent(); // so all the definition text have been inserted.	258	ProcessGtkEvent(); // so all the definition text have been inserted.
259	gtk_adjustment_set_value(gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(gpAppFrame->oAppCore.oMidWin.oTextWin.scrolled_window)), ((BackListData *)(list->data))->adjustment_value);	259	gtk_adjustment_set_value(gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(gpAppFrame->oAppCore.oMidWin.oTextWin.scrolled_window)), ((BackListData *)(list->data))->adjustment_value);
260	}	260	}
261	g_free(((BackListData *)(list->data))->word);	261	g_free(((BackListData *)(list->data))->word);
Lines 1325-1331 Link Here
1325	void TextWin::Show(gchar Word, gchar WordData, const gchar * sOriginWord)	1325	void TextWin::Show(gchar Word, gchar WordData, const gchar * sOriginWord)
1326	{	1326	{
1327	gchar *p;	1327	gchar *p;
1328	glong data_size,sec_size;	1328	guint32 data_size,sec_size=0;
1329	GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));	1329	GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
1330	gtk_text_buffer_begin_user_action(buffer); // will this speed up the showing?	1330	gtk_text_buffer_begin_user_action(buffer); // will this speed up the showing?
1331		1331
Lines 1336-1396 Link Here
1336		1336
1337	GtkTextIter iter;	1337	GtkTextIter iter;
1338	gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);	1338	gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
1339	for (int i=0;i< gpAppFrame->oAppCore.oLibs.total_libs();i++)	1339	for (int i=0; i<gpAppFrame->oAppCore.oLibs.total_libs(); i++) {
1340	{
1341	if (Word[i]) {	1340	if (Word[i]) {
1342	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, "<--- ",-1, "DictNameTag", NULL);	1341	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, "<--- ",-1, "DictNameTag", NULL);
1343	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, gpAppFrame->oAppCore.oLibs.GetBookname(i),-1, "DictNameTag", NULL);	1342	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, gpAppFrame->oAppCore.oLibs.GetBookname(i),
		1343	-1, "DictNameTag", NULL);
1344	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, " --->\n",-1, "DictNameTag", NULL);	1344	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, " --->\n",-1, "DictNameTag", NULL);
1345	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, Word[i],-1, "WordTag", NULL);	1345	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, Word[i],-1, "WordTag", NULL);
1346	gtk_text_buffer_insert (buffer, &iter,"\n", 1);	1346	gtk_text_buffer_insert (buffer, &iter,"\n", 1);
1347	}	1347	}
1348	if (WordData[i]) {	1348	if (WordData[i]) {
1349	memcpy(&data_size,WordData[i],sizeof(glong));	1349	p=WordData[i];
1350	p=WordData[i]+sizeof(glong);	1350	data_size=reinterpret_cast<guint32 >(p);
1351	while (p - (WordData[i] + sizeof(glong))< data_size)	1351	p+=sizeof(guint32);
1352	{	1352	while (guint32(p - (WordData[i] + sizeof(guint32)))< data_size) {
1353	switch (*p)	1353	switch (*p++) {
1354	{
1355	case 'm':	1354	case 'm':
1356	case 'o': //need more work...	1355	case 'l'://need more work...
1357	sec_size = strlen(p+sizeof(gchar));	1356	case 'g':
1358	if (sec_size) {	1357	sec_size = strlen(p);
1359	gtk_text_buffer_insert (buffer, &iter,p+sizeof(gchar),sec_size);	1358	if (sec_size)
1360	}	1359	gtk_text_buffer_insert(buffer, &iter, p, sec_size);
1361	sec_size++;	1360	sec_size++;
1362	break;	1361	break;
1363	case 't':	1362	case 't':
1364	sec_size = strlen(p+sizeof(gchar));	1363	sec_size = strlen(p);
1365	if (sec_size) {	1364	if (sec_size) {
1366	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,"[",1,"PhoneticTag",NULL);	1365	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, "[", 1, "PhoneticTag", NULL);
1367	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,p+sizeof(gchar),sec_size,"PhoneticTag",NULL);	1366	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, p, sec_size, "PhoneticTag", NULL);
1368	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,"]",1,"PhoneticTag",NULL);	1367	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, "]", 1, "PhoneticTag", NULL);
1369	}	1368	}
1370	sec_size++;	1369	sec_size++;
1371	break;	1370	break;
1372	case 'y':	1371	case 'y':
1373	sec_size = strlen(p+sizeof(gchar));	1372	sec_size = strlen(p);
1374	if (sec_size) {	1373	if (sec_size) {
1375	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,"[",1,"YinBiaoTag",NULL);	1374	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, "[", 1, "YinBiaoTag", NULL);
1376	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,p+sizeof(gchar),sec_size,"YinBiaoTag",NULL);	1375	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, p, sec_size, "YinBiaoTag", NULL);
1377	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,"]",1,"YinBiaoTag",NULL);	1376	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, "]", 1, "YinBiaoTag", NULL);
1378	}	1377	}
1379	sec_size++;	1378	sec_size++;
1380	break;	1379	break;
1381	case 'W':	1380	case 'W':
1382	memcpy(&sec_size,p+sizeof(gchar),sizeof(glong));	1381	sec_size=reinterpret_cast<guint32 >(p);
		1382	sec_size=g_ntohl(sec_size);
1383	//enbale sound button.	1383	//enbale sound button.
1384	sec_size+= sizeof(glong);	1384	sec_size += sizeof(guint32);
1385	break;	1385	break;
1386	case 'P':	1386	case 'P':
1387	memcpy(&sec_size,p+sizeof(gchar),sizeof(glong));	1387	sec_size=reinterpret_cast<guint32 >(p);
		1388	sec_size=g_ntohl(sec_size);
1388	//show this picture.	1389	//show this picture.
1389	sec_size+= sizeof(glong);	1390	sec_size += sizeof(guint32);
1390	break;	1391	break;
		1392	default:
		1393	/nothing/;
1391	}	1394	}
1392	gtk_text_buffer_insert (buffer, &iter,"\n", 1);	1395	gtk_text_buffer_insert(buffer, &iter, "\n", 1);
1393	p = p+sizeof(gchar)+sec_size;	1396	p += sec_size;
1394	}	1397	}
1395	}	1398	}
1396	}	1399	}
Lines 1410-1460 Link Here
1410	GtkTextIter iter;	1413	GtkTextIter iter;
1411	gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);	1414	gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
1412		1415
1413	const gchar *p;
1414	glong data_size,sec_size;
1415		1416
1416	memcpy(&data_size,data,sizeof(glong));	1417	guint32 data_size,sec_size=0;
1417	p=data+sizeof(glong);	1418	const gchar *p=data;
1418	while (p - (data + sizeof(glong))< data_size) {	1419	data_size=reinterpret_cast<const guint32 >(p);
1419	switch (*p) {	1420	p+=sizeof(guint32);
		1421	while (guint32(p - (data + sizeof(guint32)))< data_size) {
		1422	switch (*p++) {
1420	case 'm':	1423	case 'm':
1421	case 'o': //need more work...	1424	case 'l'://need more work...
1422	sec_size = strlen(p+sizeof(gchar));	1425	case 'g':
		1426	sec_size = strlen(p);
1423	if (sec_size)	1427	if (sec_size)
1424	gtk_text_buffer_insert (buffer, &iter,p+sizeof(gchar),sec_size);	1428	gtk_text_buffer_insert(buffer, &iter, p, sec_size);
1425	sec_size++;	1429	sec_size++;
1426	break;	1430	break;
1427	case 't':	1431	case 't':
1428	sec_size = strlen(p+sizeof(gchar));	1432	sec_size = strlen(p);
1429	if (sec_size) {	1433	if (sec_size) {
1430	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,"[",1,"PhoneticTag",NULL);	1434	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, "[", 1, "PhoneticTag", NULL);
1431	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,p+sizeof(gchar),sec_size,"PhoneticTag",NULL);	1435	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, p, sec_size, "PhoneticTag", NULL);
1432	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,"]",1,"PhoneticTag",NULL);	1436	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, "]", 1, "PhoneticTag", NULL);
1433	}	1437	}
1434	sec_size++;	1438	sec_size++;
1435	break;	1439	break;
1436	case 'y':	1440	case 'y':
1437	sec_size = strlen(p+sizeof(gchar));	1441	sec_size = strlen(p);
1438	if (sec_size) {	1442	if (sec_size) {
1439	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,"[",1,"YinBiaoTag",NULL);	1443	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, "[", 1, "YinBiaoTag", NULL);
1440	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,p+sizeof(gchar),sec_size,"YinBiaoTag",NULL);	1444	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, p, sec_size, "YinBiaoTag", NULL);
1441	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,"]",1,"YinBiaoTag",NULL);	1445	gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, "]", 1, "YinBiaoTag", NULL);
1442	}	1446	}
1443	sec_size++;	1447	sec_size++;
1444	break;	1448	break;
1445	case 'W':	1449	case 'W':
1446	memcpy(&sec_size,p+sizeof(gchar),sizeof(glong));	1450	sec_size=reinterpret_cast<const guint32 >(p);
		1451	sec_size=g_ntohl(sec_size);
1447	//enbale sound button.	1452	//enbale sound button.
1448	sec_size+= sizeof(glong);	1453	sec_size += sizeof(guint32);
1449	break;	1454	break;
1450	case 'P':	1455	case 'P':
1451	memcpy(&sec_size,p+sizeof(gchar),sizeof(glong));	1456	sec_size=reinterpret_cast<const guint32 >(p);
		1457	sec_size=g_ntohl(sec_size);
1452	//show this picture.	1458	//show this picture.
1453	sec_size+= sizeof(glong);	1459	sec_size += sizeof(guint32);
1454	break;	1460	break;
		1461	default:
		1462	/nothing/;
1455	}	1463	}
1456	gtk_text_buffer_insert (buffer, &iter,"\n", 1);	1464	gtk_text_buffer_insert(buffer, &iter,"\n", 1);
1457	p = p+sizeof(gchar)+sec_size;	1465	p += sec_size;
1458	}	1466	}
1459	gtk_text_buffer_end_user_action(buffer);	1467	gtk_text_buffer_end_user_action(buffer);
1460	}	1468	}

Lines 55-65 Link Here

(-)stardict-cur-accepted/configure.in (-4 / +3 lines)
55		55
56	dnl ******************************	56	dnl ******************************
57		57
58	AC_ARG_ENABLE(schemas-install,AC_HELP_STRING([--disable-schemas-install],	58	dnl AC_ARG_ENABLE(schemas-install,AC_HELP_STRING([--disable-schemas-install], [Disable installation of the gconf schemas]))
59	[Disable installation of the gconf
60	schemas]))
61		59
62	AM_CONDITIONAL(SCHEMAS_INSTALL, test x$enable_schemas_install != xno)	60	dnl AM_CONDITIONAL(SCHEMAS_INSTALL, test x$enable_schemas_install != xno)
63		61
64	AC_PATH_PROG(GCONFTOOL, gconftool-2, no)	62	AC_PATH_PROG(GCONFTOOL, gconftool-2, no)
65	if test x"$GCONFTOOL" = xno; then	63	if test x"$GCONFTOOL" = xno; then
Lines 68-73 Link Here
68	fi	66	fi
69	AM_GCONF_SOURCE_2	67	AM_GCONF_SOURCE_2
70		68
		69	AM_CONDITIONAL(SCHEMAS_INSTALL, test x$schemas_install = xtrue)
71		70
72	dnl	71	dnl
73	dnl Check popt	72	dnl Check popt

Lines 185-193 Link Here

(-)stardict-cur-accepted/src/floatwin.cpp (-53 / +70 lines)
185	mark += "</big></b>";	185	mark += "</big></b>";
186		186
187	gchar *p;	187	gchar *p;
188	glong data_size,sec_size;	188	guint32 data_size, sec_size=0;
189	for (int i=0;i< gpAppFrame->oAppCore.oLibs.total_libs();i++)	189	for (int i=0;i< gpAppFrame->oAppCore.oLibs.total_libs();i++) {
190	{
191	if (word[i]) {	190	if (word[i]) {
192	mark += "\n<span foreground=\"blue\">*--- ";	191	mark += "\n<span foreground=\"blue\">*--- ";
193	m_str = g_markup_escape_text(gpAppFrame->oAppCore.oLibs.GetBookname(i),-1);	192	m_str = g_markup_escape_text(gpAppFrame->oAppCore.oLibs.GetBookname(i),-1);
Lines 204-231 Link Here
204	}	203	}
205	}	204	}
206	if (data[i]) {	205	if (data[i]) {
207	memcpy(&data_size,data[i],sizeof(glong));	206	p=data[i];
208	p=data[i]+sizeof(glong);	207	data_size=reinterpret_cast<guint32 >(p);
209	while (p - (data[i] + sizeof(glong))< data_size)	208	p+=sizeof(guint32);
210	{	209	while (guint32(p - (data[i] + sizeof(guint32)))< data_size) {
211	switch (*p)	210	switch (*p++) {
212	{
213	case 'm':	211	case 'm':
214	case 'o': //need more work...	212	case 'l'://need more work
215	sec_size = strlen(p+sizeof(gchar));	213	sec_size = strlen(p);
216	if (sec_size) {	214	if (sec_size) {
217	mark+= "\n";	215	mark+= "\n";
218	m_str = g_markup_escape_text(p+sizeof(gchar),sec_size);	216	m_str = g_markup_escape_text(p, sec_size);
219	mark += m_str;	217	mark += m_str;
220	g_free(m_str);	218	g_free(m_str);
221	}	219	}
222	sec_size++;	220	sec_size++;
223	break;	221	break;
		222	case 'g':
		223	sec_size = strlen(p);
		224	if (sec_size) {
		225	mark += "\n";
		226	mark += p;
		227	}
		228	sec_size++;
		229	break;
224	case 't':	230	case 't':
225	sec_size = strlen(p+sizeof(gchar));	231	sec_size = strlen(p);
226	if (sec_size) {	232	if (sec_size) {
227	mark += "\n<big>[";	233	mark += "\n<big>[";
228	m_str = g_markup_escape_text(p+sizeof(gchar),sec_size);	234	m_str = g_markup_escape_text(p, sec_size);
229	mark += m_str;	235	mark += m_str;
230	g_free(m_str);	236	g_free(m_str);
231	mark+= "]</big>";	237	mark+= "]</big>";
Lines 233-242 Link Here
233	sec_size++;	239	sec_size++;
234	break;	240	break;
235	case 'y':	241	case 'y':
236	sec_size = strlen(p+sizeof(gchar));	242	sec_size = strlen(p);
237	if (sec_size) {	243	if (sec_size) {
238	mark += "\n<span foreground=\"red\">[";	244	mark += "\n<span foreground=\"red\">[";
239	m_str = g_markup_escape_text(p+sizeof(gchar),sec_size);	245	m_str = g_markup_escape_text(p, sec_size);
240	mark += m_str;	246	mark += m_str;
241	g_free(m_str);	247	g_free(m_str);
242	mark+= "]</span>";	248	mark+= "]</span>";
Lines 244-259 Link Here
244	sec_size++;	250	sec_size++;
245	break;	251	break;
246	case 'W':	252	case 'W':
247	memcpy(&sec_size,p+sizeof(gchar),sizeof(glong));	253	sec_size=reinterpret_cast<guint32 >(p);
		254	sec_size=g_ntohl(sec_size);
248	//enbale sound button.	255	//enbale sound button.
249	sec_size+= sizeof(glong);	256	sec_size+=sizeof(guint32);
250	break;	257	break;
251	case 'P':	258	case 'P':
252	memcpy(&sec_size,p+sizeof(gchar),sizeof(glong));	259	sec_size=reinterpret_cast<guint32 >(p);
253	sec_size+= sizeof(glong);	260	sec_size=g_ntohl(sec_size);
		261	sec_size+= sizeof(guint32);
254	break;	262	break;
		263	default:
		264	/nothing/;
255	}	265	}
256	p = p+sizeof(gchar)+sec_size;	266	p += sec_size;
257	}	267	}
258	}	268	}
259	}	269	}
Lines 262-269 Link Here
262	gboolean canRead = gpAppFrame->oReadWord.canRead(sOriginWord);	272	gboolean canRead = gpAppFrame->oReadWord.canRead(sOriginWord);
263	if (canRead) {	273	if (canRead) {
264	PronounceWord = sOriginWord;	274	PronounceWord = sOriginWord;
265	}	275	} else {
266	else {
267	for (int i=0;i< gpAppFrame->oAppCore.oLibs.total_libs(); i++) {	276	for (int i=0;i< gpAppFrame->oAppCore.oLibs.total_libs(); i++) {
268	if (word[i] && strcmp(word[i], sOriginWord)) {	277	if (word[i] && strcmp(word[i], sOriginWord)) {
269	if (gpAppFrame->oReadWord.canRead(word[i])) {	278	if (gpAppFrame->oReadWord.canRead(word[i])) {
Lines 281-287 Link Here
281	gpAppFrame->oReadWord.read(PronounceWord.c_str());	290	gpAppFrame->oReadWord.read(PronounceWord.c_str());
282	}	291	}
283		292
284	void FloatWin::ShowText(gchar * pppWord, gchar * pppWordData, const gchar ** ppOriginWord, gint count,const gchar * sOriginWord)	293	void FloatWin::ShowText(gchar * pppWord, gchar * pppWordData,
		294	const gchar ** ppOriginWord, gint count,
		295	const gchar * sOriginWord)
285	{	296	{
286	QueryingWord = sOriginWord;	297	QueryingWord = sOriginWord;
287	found_result = FLOAT_WIN_FUZZY_FOUND;	298	found_result = FLOAT_WIN_FUZZY_FOUND;
Lines 297-314 Link Here
297	mark += _("Found ");	308	mark += _("Found ");
298	if (count ==1)	309	if (count ==1)
299	mark+= _("1 word:\n");	310	mark+= _("1 word:\n");
300	else	311	else {
301	{
302	m_str=g_strdup_printf("%d",count);	312	m_str=g_strdup_printf("%d",count);
303	mark += m_str;	313	mark += m_str;
304	g_free(m_str);	314	g_free(m_str);
305	mark+= _(" words:\n");	315	mark+= _(" words:\n");
306	}	316	}
307	int j;	317	int j;
308	for (j=0;j<count-1;j++)	318	for (j=0; j<count-1; j++) {
309	{
310	mark += "<b><big>";	319	mark += "<b><big>";
311	m_str = g_markup_escape_text(ppOriginWord[j],-1);	320	m_str = g_markup_escape_text(ppOriginWord[j], -1);
312	mark += m_str;	321	mark += m_str;
313	g_free(m_str);	322	g_free(m_str);
314	mark += "</big></b> ";	323	mark += "</big></b> ";
Lines 320-336 Link Here
320	mark += "</big></b>";	329	mark += "</big></b>";
321		330
322	gchar *p;	331	gchar *p;
323	glong data_size,sec_size;	332	guint32 data_size,sec_size;
324	for (j=0;j<count;j++)	333	for (j=0; j<count; j++) {
325	{
326	mark += "\n\n<span foreground=\"red\">#----- ";	334	mark += "\n\n<span foreground=\"red\">#----- ";
327	m_str = g_markup_escape_text(ppOriginWord[j],-1);	335	m_str = g_markup_escape_text(ppOriginWord[j],-1);
328	mark += m_str;	336	mark += m_str;
329	g_free(m_str);	337	g_free(m_str);
330	mark += " -----#</span>";	338	mark += " -----#</span>";
331		339
332	for (int i=0;i< gpAppFrame->oAppCore.oLibs.total_libs();i++)	340	for (int i=0; i<gpAppFrame->oAppCore.oLibs.total_libs(); i++) {
333	{
334	if (pppWord[j][i]) {	341	if (pppWord[j][i]) {
335	mark += "\n<span foreground=\"blue\">*--- ";	342	mark += "\n<span foreground=\"blue\">*--- ";
336	m_str = g_markup_escape_text(gpAppFrame->oAppCore.oLibs.GetBookname(i),-1);	343	m_str = g_markup_escape_text(gpAppFrame->oAppCore.oLibs.GetBookname(i),-1);
Lines 347-375 Link Here
347	}	354	}
348	}	355	}
349	if (pppWordData[j][i]) {	356	if (pppWordData[j][i]) {
350	memcpy(&data_size,pppWordData[j][i],sizeof(glong));	357	p=pppWordData[j][i];
351	p=pppWordData[j][i]+sizeof(glong);	358	data_size=reinterpret_cast<guint32 >(p);
352		359	p+=sizeof(guint32);
353	while (p - (pppWordData[j][i] + sizeof(glong))< data_size)	360	while (guint32(p - (pppWordData[j][i] + sizeof(guint32)))< data_size) {
354	{	361	switch (*p++) {
355	switch (*p)
356	{
357	case 'm':	362	case 'm':
358	case 'o': //need more work...	363	case 'l': //need more work...
359	sec_size = strlen(p+sizeof(gchar));	364	sec_size = strlen(p);
360	if (sec_size) {	365	if (sec_size) {
361	mark+= "\n";	366	mark+= "\n";
362	m_str = g_markup_escape_text(p+sizeof(gchar),sec_size);	367	m_str = g_markup_escape_text(p,sec_size);
363	mark += m_str;	368	mark += m_str;
364	g_free(m_str);	369	g_free(m_str);
365	}	370	}
366	sec_size++;	371	sec_size++;
367	break;	372	break;
		373	case 'g':
		374	sec_size = strlen(p);
		375	if (sec_size) {
		376	mark += "\n";
		377	mark += p;
		378	}
		379	sec_size++;
		380	break;
368	case 't':	381	case 't':
369	sec_size = strlen(p+sizeof(gchar));	382	sec_size = strlen(p);
370	if (sec_size) {	383	if (sec_size) {
371	mark += "\n<big>[";	384	mark += "\n<big>[";
372	m_str = g_markup_escape_text(p+sizeof(gchar),sec_size);	385	m_str = g_markup_escape_text(p, sec_size);
373	mark += m_str;	386	mark += m_str;
374	g_free(m_str);	387	g_free(m_str);
375	mark+= "]</big>";	388	mark+= "]</big>";
Lines 377-386 Link Here
377	sec_size++;	390	sec_size++;
378	break;	391	break;
379	case 'y':	392	case 'y':
380	sec_size = strlen(p+sizeof(gchar));	393	sec_size = strlen(p);
381	if (sec_size) {	394	if (sec_size) {
382	mark += "\n<span foreground=\"red\">[";	395	mark += "\n<span foreground=\"red\">[";
383	m_str = g_markup_escape_text(p+sizeof(gchar),sec_size);	396	m_str = g_markup_escape_text(p, sec_size);
384	mark += m_str;	397	mark += m_str;
385	g_free(m_str);	398	g_free(m_str);
386	mark+= "]</span>";	399	mark+= "]</span>";
Lines 388-403 Link Here
388	sec_size++;	401	sec_size++;
389	break;	402	break;
390	case 'W':	403	case 'W':
391	memcpy(&sec_size,p+sizeof(gchar),sizeof(glong));	404	sec_size=reinterpret_cast<guint32 >(p);
		405	sec_size=g_ntohl(sec_size);
392	//enbale sound button.	406	//enbale sound button.
393	sec_size+= sizeof(glong);	407	sec_size+= sizeof(guint32);
394	break;	408	break;
395	case 'P':	409	case 'P':
396	memcpy(&sec_size,p+sizeof(gchar),sizeof(glong));	410	sec_size=reinterpret_cast<guint32 >(p);
397	sec_size+= sizeof(glong);	411	sec_size=g_ntohl(sec_size);
		412	sec_size+= sizeof(guint32);
398	break;	413	break;
		414	default:
		415	/nothing/;
399	}	416	}
400	p = p+sizeof(gchar)+sec_size;	417	p += sec_size;
401	}	418	}
402	}	419	}
403	}	420	}

Lines 11-45 Link Here

(-)stardict-cur-accepted/src/lib.h (-32 / +52 lines)
11		11
12	#include "dictziplib.h"	12	#include "dictziplib.h"
13		13
		14	const int MAX_MATCH_ITEM_PER_LIB=100;
		15	const int MAX_FUZZY_DISTANCE= 3; // at most MAX_FUZZY_DISTANCE-1 differences allowed when find similar words
14		16
15	struct cacheItem	17	extern bool bIsPureEnglish(const gchar *str);
16	{	18
17	glong offset;	19	struct cacheItem {
		20	guint32 offset;
18	gchar *data;	21	gchar *data;
19	cacheItem();	22	//write code here to make it inline
20	~cacheItem();	23	cacheItem() {data= NULL;}
		24	~cacheItem() {g_free(data);}
21	};	25	};
22		26
23	const int WORDDATA_CACHE_NUM = 10;	27	const int WORDDATA_CACHE_NUM = 10;
24	const int INVALID_INDEX=-100;	28	const int INVALID_INDEX=-100;
25		29
26	class DictBase	30	class DictBase {
27	{
28	public:	31	public:
29	DictBase();	32	DictBase();
30	~DictBase();	33	~DictBase();
31	gchar * GetWordData(glong idxitem_offset, glong idxitem_size);	34	gchar * GetWordData(guint32 idxitem_offset, guint32 idxitem_size);
32	protected:	35	protected:
33	gchar *sametypesequence;	36	gchar *sametypesequence;
34	FILE *dictfile;	37	FILE *dictfile;
35	dictData *dictdzfile;	38	dictData *dictdzfile;
36	private:	39	private:
37	struct cacheItem cache[WORDDATA_CACHE_NUM];	40	cacheItem cache[WORDDATA_CACHE_NUM];
38	gint cache_cur;	41	gint cache_cur;
39	};	42	};
40		43
41	class Lib : public DictBase	44	//this structure contain all information about dictionary
42	{	45	struct DictInfo {
		46	std::string ifo_file_name;
		47	glong wordcount;
		48	std::string bookname;
		49	std::string author;
		50	std::string email;
		51	std::string website;
		52	std::string date;
		53	std::string description;
		54	gulong index_file_size;
		55	std::string sametypesequence;
		56	bool load_from_ifo_file(const gchar *ifofilename, bool istreedict);
		57	};
		58
		59	class Lib : public DictBase {
43	private:	60	private:
44	glong wordcount;	61	glong wordcount;
45	gchar *bookname;	62	gchar *bookname;
Lines 51-82 Link Here
51	glong *wordoffset;	68	glong *wordoffset;
52	};	69	};
53		70
54	#ifdef HAVE_MMAP
55	int mmap_fd;
56	unsigned long mmap_idxmap_size;
57	#endif
58
59	union {	71	union {
60	gchar *idxdatabuffer;	72	gchar *idxdatabuffer;
61	glong cur_wordindex;	73	glong cur_wordindex;
62	};	74	};
63		75
64	gchar wordentry_buf[256]; // The length of "word_str" should be less than 256. See src/tools/DICTFILE_FORMAT.	76	gchar wordentry_buf[256]; // The length of "word_str" should be less than 256. See src/tools/DICTFILE_FORMAT.
65	glong wordentry_offset;	77	guint32 wordentry_offset;
66	glong wordentry_size;	78	guint32 wordentry_size;
67		79
68	gboolean load_ifofile(const char ifofilename, gulong idxfilesize);	80	bool load_ifofile(const char ifofilename, gulong idxfilesize);
69		81
70	void loadwordlist();	82	void loadwordlist();
71	void loadwordoffset();	83	void loadwordoffset();
72	public:	84	public:
73	Lib();	85	Lib();
74	~Lib();	86	~Lib();
75	gboolean load(const char *ifofilename);	87	bool load(const char *ifofilename);
76	inline glong length() { return(wordcount); }	88	inline glong length() { return wordcount; }
77	inline gchar* GetBookname() { return(bookname); }	89	inline gchar* GetBookname() { return bookname; }
78	gboolean Lookup(const char* sWord,glong *pIndex);	90	bool Lookup(const char* sWord,glong *pIndex);
79	gboolean LookupWithRule(GPatternSpec pspec,glong aIndex,int iBuffLen);	91	bool LookupWithRule(GPatternSpec pspec,glong aIndex,int iBuffLen);
80	gchar * GetWord(glong index);	92	gchar * GetWord(glong index);
81	gchar * GetWordData(glong index);	93	gchar * GetWordData(glong index);
82	};	94	};
Lines 86-91 Link Here
86	private:	98	private:
87	Lib **oLib; // word library.	99	Lib **oLib; // word library.
88	gint libcount;	100	gint libcount;
		101	int iMaxFuzzyDistance;
89		102
90	void LoadDir(const gchar dirname, const GSList order_list, const GSList *disable_list);	103	void LoadDir(const gchar dirname, const GSList order_list, const GSList *disable_list);
91	public:	104	public:
Lines 94-120 Link Here
94	void Load(const gchar dicts_dir, const GSList order_list, const GSList *disable_list);	107	void Load(const gchar dicts_dir, const GSList order_list, const GSList *disable_list);
95	glong iLength(int iLib);	108	glong iLength(int iLib);
96	gchar* GetBookname(int iLib);	109	gchar* GetBookname(int iLib);
97	inline gint total_libs() { return(libcount); }	110	inline gint total_libs() {return libcount;}
98	gchar * poGetWord(glong iIndex,int iLib);	111	gchar * poGetWord(glong iIndex,int iLib);
99	gchar * poGetWordData(glong iIndex,int iLib);	112	gchar * poGetWordData(glong iIndex,int iLib);
100	gchar * poGetCurrentWord(glong * iCurrent);	113	gchar * poGetCurrentWord(glong * iCurrent);
101	gchar * poGetNextWord(const gchar word,glong iCurrent);	114	gchar * poGetNextWord(const gchar word,glong iCurrent);
102	gchar * poGetPreWord(glong * iCurrent);	115	gchar * poGetPreWord(glong * iCurrent);
103	gboolean LookupWord(const gchar* sWord,glong& iWordIndex,int iLib);	116	bool LookupWord(const gchar* sWord,glong& iWordIndex,int iLib);
104	gboolean LookupSimilarWord(const gchar* sWord,glong& iWordIndex,int iLib);	117	bool LookupSimilarWord(const gchar* sWord, glong & iWordIndex, int iLib);
105	gboolean SimpleLookupWord(const gchar* sWord,glong& iWordIndex,int iLib);	118	bool SimpleLookupWord(const gchar* sWord, glong & iWordIndex, int iLib);
106	gboolean LookdupWordsWithRule(GPatternSpec pspec,glong aiIndexes,int iLen,int iLib);	119
		120	struct Fuzzystruct {
		121	char * pMatchWord;
		122	int iMatchWordDistance;
		123	};
		124	typedef void (*TProgressFunc)(void);
		125
		126	bool LookupWithFuzzy(const gchar *sWord, Fuzzystruct oFuzzystruct[], gint fuzzystruct_amount, TProgressFunc ProgressFunc);
		127	gint LookupWithRule(const gchar word, TProgressFunc ProgressFunc, gchar *ppMatchWord);
107	};	128	};
108		129
109	inline gboolean bIsVowel(gchar inputchar);
110		130
111	class TreeDict : public DictBase	131	class TreeDict : public DictBase
112	{	132	{
113	private:	133	private:
114	gboolean load_ifofile(const char ifofilename, gulong tdxfilesize);	134	bool load_ifofile(const char ifofilename, gulong tdxfilesize);
115	void load_model(gchar *buffer, GtkTreeStore model, GtkTreeIter *parent, gint count);	135	void load_model(gchar *buffer, GtkTreeStore model, GtkTreeIter *parent, gint count);
116	public:	136	public:
117	gboolean load(const char ifofilename, GtkTreeStore model);	137	bool load(const char ifofilename, GtkTreeStore model);
118	};	138	};
119		139
120	class TreeDicts {	140	class TreeDicts {

Lines 31-42 Link Here

(-)stardict-cur-accepted/src/stardict.h (-16 / +2 lines)
31		31
32	//notice!!! when you change these DEFAULT const value,remember that you'd better change data/stardict.schemas.in too!	32	//notice!!! when you change these DEFAULT const value,remember that you'd better change data/stardict.schemas.in too!
33		33
34	const int MAX_MATCH_ITEM_PER_LIB=100;
35	const int MAX_FUZZY_MATCH_ITEM=100;	34	const int MAX_FUZZY_MATCH_ITEM=100;
36	const int MAX_FLOAT_WINDOW_FUZZY_MATCH_ITEM=5;	35	const int MAX_FLOAT_WINDOW_FUZZY_MATCH_ITEM=5;
37		36
38	const int LIST_WIN_ROW_NUM = 30; //how many words show in the list win.	37	const int LIST_WIN_ROW_NUM = 30; //how many words show in the list win.
39	const int MAX_FUZZY_DISTANCE= 3; // at most MAX_FUZZY_DISTANCE-1 differences allowed when find similar words
40		38
41		39
42	class AppCore	40	class AppCore
Lines 46-59 Link Here
46		44
47	PrefsDlg *prefs_dlg;	45	PrefsDlg *prefs_dlg;
48	DictManageDlg *dict_manage_dlg;	46	DictManageDlg *dict_manage_dlg;
49	// struct
50	struct Fuzzystruct {
51	char * pMatchWord;
52	int iMatchWordDistance;
53	};
54	int iMaxFuzzyDistance;
55		47
56	static int FuzzystructCompare(const void * s1, const void * s2);
57	static int MatchWordCompare(const void * s1, const void * s2);	48	static int MatchWordCompare(const void * s1, const void * s2);
58	static gboolean on_delete_event(GtkWidget * window, GdkEvent event , AppCore oAppCore);	49	static gboolean on_delete_event(GtkWidget * window, GdkEvent event , AppCore oAppCore);
59	static gboolean on_window_state_event(GtkWidget * window, GdkEventWindowState event , AppCore oAppCore);	50	static gboolean on_window_state_event(GtkWidget * window, GdkEventWindowState event , AppCore oAppCore);
Lines 81-91 Link Here
81	AppCore(AppFrame* pAppFrame);	72	AppCore(AppFrame* pAppFrame);
82	~AppCore();	73	~AppCore();
83	void Create(gchar *queryword);	74	void Create(gchar *queryword);
84	void ProcessGtkEvent();
85	void End();	75	void End();
86	void Query(const gchar *word);	76	void Query(const gchar *word);
87	gboolean SimpleLookupToFloat(const gchar* sWord,gboolean bShowIfNotFound);	77	bool SimpleLookupToFloat(const gchar* sWord, bool bShowIfNotFound);
88	gboolean SimpleLookupToTextWin(const gchar* sWord,glong* piIndex, gboolean piIndexValid = false, gboolean bTryMoreIfNotFound = false);	78	bool SimpleLookupToTextWin(const gchar* sWord,glong* piIndex, bool piIndexValid = false, bool bTryMoreIfNotFound = false);
89	void LookupWithFuzzyToMainWin(const gchar* word);	79	void LookupWithFuzzyToMainWin(const gchar* word);
90	void LookupWithFuzzyToFloatWin(const gchar * word);	80	void LookupWithFuzzyToFloatWin(const gchar * word);
91	void LookupWithRuleToMainWin(const gchar* word);	81	void LookupWithRuleToMainWin(const gchar* word);
Lines 122-128 Link Here
122	AppFrame();	112	AppFrame();
123	~AppFrame();	113	~AppFrame();
124	void Init(gchar *queryword);	114	void Init(gchar *queryword);
125	void ProcessGtkEvent();
126	void Quit();	115	void Quit();
127	};	116	};
128		117
Lines 131-142 Link Here
131	extern gchar stardict_data_dir[256];	120	extern gchar stardict_data_dir[256];
132	#endif	121	#endif
133		122
134	extern gint stardict_strcmp(const gchar s1, const gchar s2);
135	extern gboolean bContainRule(const char* sWord);	123	extern gboolean bContainRule(const char* sWord);
136	extern gboolean bIsPureEnglish(const gchar *str);
137	extern gchar* GetPureEnglishAlpha(gchar *str);	124	extern gchar* GetPureEnglishAlpha(gchar *str);
138	extern gchar* GetHeadWord(gchar *str);	125	extern gchar* GetHeadWord(gchar *str);
139
140	extern gboolean stardict_on_enter_notify (GtkWidget * widget, GdkEventCrossing * event, gpointer data);	126	extern gboolean stardict_on_enter_notify (GtkWidget * widget, GdkEventCrossing * event, gpointer data);
141		127
142	#endif	128	#endif