Merge lp:~guillaume-chereau/stellarium/no-kde into lp:stellarium

[Alexander Wolf]

[Alexander Wolf (alexwolf)]

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-06-14 00:05:12 +0000
+++ CMakeLists.txt	2014-06-14 08:34:53 +0000
@@ -456,7 +456,7 @@
 	${CMAKE_SOURCE_DIR}/src/core/modules
 	${CMAKE_SOURCE_DIR}/src/core/planetsephems
 	${CMAKE_SOURCE_DIR}/src/core/external
-	${CMAKE_SOURCE_DIR}/src/core/external/kfilter
+	${CMAKE_SOURCE_DIR}/src/core/external/qtcompress
 	${CMAKE_SOURCE_DIR}/src/core/external/glues_stel/source/
 	${CMAKE_SOURCE_DIR}/src/core/external/glues_stel/source/libtess
 	${CMAKE_SOURCE_DIR}/src/gui

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2014-06-14 00:05:12 +0000
+++ src/CMakeLists.txt	2014-06-14 08:34:53 +0000
@@ -158,19 +158,6 @@
 
 	${gl_lib_SRCS}
 
-	core/external/kfilter/kfilterdev.h
-	core/external/kfilter/kfilterdev.cpp
-	core/external/kfilter/kfilterbase.h
-	core/external/kfilter/kfilterbase.cpp
-	core/external/kfilter/kgzipfilter.h
-	core/external/kfilter/kgzipfilter.cpp
-	core/external/kfilter/kzip.h
-	core/external/kfilter/kzip.cpp
-	core/external/kfilter/klimitediodevice.h
-	core/external/kfilter/klimitediodevice.cpp
-	core/external/kfilter/karchive.h
-	core/external/kfilter/karchive.cpp
-
 	${glues_lib_SRCS}
 
 	core/planetsephems/calc_interpolated_elements.c
@@ -254,6 +241,15 @@
 	config.h
 )
 
+# On windows, QZipReader is already included in the lib
+IF(!WIN32)
+	SET(stellarium_lib_SRCS ${stellarium_lib_SRCS}
+		core/external/qtcompress/qzip.cpp
+		core/external/qtcompress/qzipreader.h
+		core/external/qtcompress/qzipwriter.h
+	)
+ENDIF()
+
 IF(ENABLE_SCRIPTING)
 	SET(stellarium_lib_SRCS ${stellarium_lib_SRCS}
 		scripting/StelScriptMgr.cpp
@@ -268,6 +264,7 @@
 	)
 ENDIF()
 
+<<<<<<< TREE
 IF(WIN32)
 	SET(stellarium_lib_SRCS ${stellarium_lib_SRCS}
 		${zlib_SRCS}
@@ -280,6 +277,8 @@
 	)
 ENDIF()
 
+=======
+>>>>>>> MERGE-SOURCE
 SET(stellarium_exe_SRCS main.cpp)
 
 ################# compiles resources files ############

=== modified file 'src/core/MultiLevelJsonBase.cpp'
--- src/core/MultiLevelJsonBase.cpp	2014-04-13 20:54:51 +0000
+++ src/core/MultiLevelJsonBase.cpp	2014-06-14 08:34:53 +0000
@@ -22,7 +22,6 @@
 #include "StelFileMgr.hpp"
 #include "StelProjector.hpp"
 #include "StelCore.hpp"
-#include "kfilterdev.h"
 #include "StelUtils.hpp"
 
 #include <QDebug>
@@ -274,11 +273,9 @@
 	}
 	else if (gzCompressed)
 	{
-		QIODevice* d = KFilterDev::device(&input, "application/x-gzip", false);
-		d->open(QIODevice::ReadOnly);
-		map = parser.parse(d).toMap();
-		d->close();
-		delete d;
+		QByteArray ar = StelUtils::uncompress(input.readAll());
+		input.close();
+		map = parser.parse(ar).toMap();
 	}
 	else
 	{

=== modified file 'src/core/StelLocationMgr.cpp'
--- src/core/StelLocationMgr.cpp	2014-05-18 12:09:31 +0000
+++ src/core/StelLocationMgr.cpp	2014-06-14 08:34:53 +0000
@@ -20,7 +20,6 @@
 #include "StelFileMgr.hpp"
 #include "StelLocationMgr.hpp"
 #include "StelUtils.hpp"
-#include "kfilterdev.h"
 
 #include <QStringListModel>
 #include <QDebug>
@@ -72,14 +71,9 @@
 	if (fileName.endsWith(".gz"))
 	{
 		// FIXME: This code doesn't work with MSVC2012 -- need fix! --AW
-		QIODevice* d = KFilterDev::device(&sourcefile, "application/x-gzip", false);
-		d->open(QIODevice::ReadOnly);
-		QByteArray arr = d->readAll();
-		QDataStream in(&arr, QIODevice::ReadOnly);
+		QDataStream in(StelUtils::uncompress(sourcefile.readAll()));
 		in.setVersion(QDataStream::Qt_4_6);
 		in >> res;
-		d->close();
-		delete d;
 		return res;
 	}
 	else

=== modified file 'src/core/StelUtils.cpp'
--- src/core/StelUtils.cpp	2014-06-11 15:48:31 +0000
+++ src/core/StelUtils.cpp	2014-06-14 08:34:53 +0000
@@ -33,6 +33,7 @@
 #include <QProcess>
 #include <QSysInfo>
 #include <cmath> // std::fmod
+#include <zlib.h>
 
 namespace StelUtils
 {
@@ -1879,5 +1880,43 @@
 	return cos_sin_rho;
 }
 
+//! Uncompress gzip or zlib compressed data.
+QByteArray uncompress(const QByteArray& data)
+{
+	if (data.size() <= 4)
+		return QByteArray();
+	static const int CHUNK = 1024;
+	QByteArray buffer(CHUNK, 0);
+	QByteArray out;
+	z_stream strm;
+	strm.zalloc = Z_NULL;
+	strm.zfree = Z_NULL;
+	strm.opaque = Z_NULL;
+	strm.avail_in = data.size();
+	strm.next_in = (Bytef*)(data.data());
+
+	// 15 + 32 for gzip automatic header detection.
+	int ret = inflateInit2(&strm, 15 +  32);
+	if (ret != Z_OK) return QByteArray();
+
+	do
+	{
+		strm.avail_out = CHUNK;
+		strm.next_out = (Bytef*)(buffer.data());
+		ret = inflate(&strm, Z_NO_FLUSH);
+		Q_ASSERT(ret != Z_STREAM_ERROR);
+		if (ret < 0)
+		{
+			out.clear();
+			break;
+		}
+		out.append(buffer.data(), CHUNK - strm.avail_out);
+	}
+	while (strm.avail_out == 0);
+
+    inflateEnd(&strm);
+	return out;
+}
+
 } // end of the StelUtils namespace
 

=== modified file 'src/core/StelUtils.hpp'
--- src/core/StelUtils.hpp	2014-06-11 15:48:31 +0000
+++ src/core/StelUtils.hpp	2014-06-14 08:34:53 +0000
@@ -591,6 +591,9 @@
 	//! @param segments number of segments
 	//! @param minAngle start angle inside the half-circle. maxAngle=minAngle+segments*phi
 	float* ComputeCosSinRhoZone(const float dRho, const int segments, const float minAngle);
+
+	//! Uncompress gzip or zlib compressed data.
+	QByteArray uncompress(const QByteArray& data);
 }
 
 #endif // _STELUTILS_HPP_

=== removed directory 'src/core/external/kdewin32'
=== removed file 'src/core/external/kdewin32/errno.h'
--- src/core/external/kdewin32/errno.h	2010-11-28 04:24:13 +0000
+++ src/core/external/kdewin32/errno.h	1970-01-01 00:00:00 +0000
@@ -1,36 +0,0 @@
-/* This file is part of the KDE project
-   Copyright (C) 2006 Ralf Habacker <[e-mail]>
-
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this program; see the file COPYING.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
-*/
-
-#ifndef _KDEWIN_ERRNO_H
-#define _KDEWIN_ERRNO_H
-
-#include "kdewin32/sys/types.h"
-#include <../include/errno.h>
-
-int __cdecl _set_errno(int value);
-
-#ifndef ENOFILE
-#define ENOFILE ENOENT
-#endif
-
-#ifndef ENOTSUP
-#define ENOTSUP ENOSYS
-#endif
-
-#endif

=== removed file 'src/core/external/kdewin32/grp.c'
--- src/core/external/kdewin32/grp.c	2010-11-28 04:24:13 +0000
+++ src/core/external/kdewin32/grp.c	1970-01-01 00:00:00 +0000
@@ -1,48 +0,0 @@
-/* This file is part of the KDE project
-   Copyright (C) 2003-2004 Jaroslaw Staniek <[e-mail]>
-
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this program; see the file COPYING.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
-*/
-
-#include "kdewin32/grp.h"
-#include <windows.h>
-
-
-/* these functions always fail. for win32 */
-
-struct group *getgrnam (const char *name)
-{
-	return 0;
-}
-
-struct group *getgrgid (gid_t gid)
-{
-	return 0;
-}
-
-struct group *getgrent(void)
-{
-	return 0;
-}
-
-void setgrent(void)
-{
-}
-
-void endgrent(void)
-{
-}
-

=== removed file 'src/core/external/kdewin32/grp.h'
--- src/core/external/kdewin32/grp.h	2010-11-28 04:24:13 +0000
+++ src/core/external/kdewin32/grp.h	1970-01-01 00:00:00 +0000
@@ -1,47 +0,0 @@
-/* This file is part of the KDE project
-   Copyright (C) 2003-2004 Jaroslaw Staniek <[e-mail]>
-
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this program; see the file COPYING.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
-*/
-
-#ifndef GRP_H_
-#define GRP_H_
-
-#include "kdewin32/sys/types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct group {
-	char *gr_name; /* group name */
-	char *gr_passwd; /* group password */
-	gid_t gr_gid; /* group id */ 
-	char **gr_mem; /* group members */
-};
-
-struct group *getgrnam (const char *name); 
-struct group *getgrgid (gid_t gid);
-struct group *getgrent(void);
-void setgrent(void);
-void endgrent(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* GRP_H_ */
-

=== removed file 'src/core/external/kdewin32/pwd.c'
--- src/core/external/kdewin32/pwd.c	2013-06-05 05:59:53 +0000
+++ src/core/external/kdewin32/pwd.c	1970-01-01 00:00:00 +0000
@@ -1,62 +0,0 @@
-/* This file is part of the KDE project
-   Copyright (C) 2003-2004 Jaroslaw Staniek <[e-mail]>
-
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this program; see the file COPYING.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
-*/
-
-#include <windows.h>
-
-#ifdef _MSC_BUILD 
-#include <stdlib.h>
-#include "kdewin32/pwd.h"
-#include <stdio.h>
-#include <errno.h>
-#else
-#include "kdewin32/stdlib.h"
-#include "kdewin32/pwd.h"
-#include "kdewin32/stdio.h"
-#include "kdewin32/errno.h"
-#endif
-
-/* these functions always fail for win32 */
-
-struct passwd * getpwnam (const char *name)
-{
-	return 0;
-}
-
-
-struct passwd * getpwuid (uid_t uid)
-{
-	return 0;
-}
-
-
-void setpwent (void)
-{
-}
-
-
-struct passwd *getpwent()
-{
-	return 0;
-}
-
-
-void endpwent()
-{
-}
-

=== removed file 'src/core/external/kdewin32/pwd.h'
--- src/core/external/kdewin32/pwd.h	2010-11-28 04:24:13 +0000
+++ src/core/external/kdewin32/pwd.h	1970-01-01 00:00:00 +0000
@@ -1,71 +0,0 @@
-/* This file is part of the KDE project
- * Copyright (c) 1989 The Regents of the University of California.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgment:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)pwd.h	5.13 (Berkeley) 5/28/91
- */
-
-#ifndef _KDEWIN_PWD_H_
-#define _KDEWIN_PWD_H_
-
-#include "kdewin32/sys/types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-struct passwd {
-	char	*pw_name;		/* user name */
-	char	*pw_passwd;		/* encrypted password */
-	int	pw_uid;			/* user uid */
-	int	pw_gid;			/* user gid */
-	char	*pw_comment;		/* comment */
-	char	*pw_gecos;		/* Honeywell login info */
-	char	*pw_dir;		/* home directory */
-	char	*pw_shell;		/* default shell */
-};
-
-struct passwd	*getpwuid (uid_t);
-struct passwd	*getpwnam (const char *);
-int getpwnam_r (const char *, struct passwd *,
-			char *, size_t , struct passwd **);
-int	getpwuid_r (uid_t, struct passwd *, char *,
-			size_t, struct passwd **);
-
-struct passwd	*getpwent (void);
-void		 setpwent (void);
-void		 endpwent (void);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* _PWD_H_ */

=== removed file 'src/core/external/kdewin32/stdio.h'
--- src/core/external/kdewin32/stdio.h	2010-11-28 04:24:13 +0000
+++ src/core/external/kdewin32/stdio.h	1970-01-01 00:00:00 +0000
@@ -1,37 +0,0 @@
-/*
-   This file is part of the KDE libraries
-   Copyright (C) 2003-2004 Jaroslaw Staniek <[e-mail]>
-   Copyright (C) 2005 Ralf Habacker <[e-mail]>
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License version 2 as published by the Free Software Foundation.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this library; see the file COPYING.LIB.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
-*/
-
-/*
- * Definitions for common types, variables, and functions.
- */
-
-#ifndef KDE_STDIO_H
-#define KDE_STDIO_H
-
-// stdio.h includes sys/types.h in an extern "C" context, which fails for c++ definitions 
-#include "kdewin32/sys/types.h"
-#include <../include/stdio.h>
-
-#define snprintf _snprintf
-#define vsnprintf _vsnprintf
-#define popen _popen
-#define pclose _pclose
-
-#endif /* KDE_STDIO_H_ */

=== removed file 'src/core/external/kdewin32/stdlib.h'
--- src/core/external/kdewin32/stdlib.h	2010-11-28 04:24:13 +0000
+++ src/core/external/kdewin32/stdlib.h	1970-01-01 00:00:00 +0000
@@ -1,71 +0,0 @@
-/*
-   This file is part of the KDE libraries
-   Copyright (C) 2003-2004 Jaroslaw Staniek <[e-mail]>
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License version 2 as published by the Free Software Foundation.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this library; see the file COPYING.LIB.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
-*/
-
-/*
- * Definitions for common types, variables, and functions.
- */
-
-#ifndef KDE_STDLIB_H
-#define KDE_STDLIB_H
-
-#include "kdewin32/sys/types.h"
-#include <../include/stdlib.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif 
-/*
-#define __need_size_t
-#define __need_wchar_t
-#include <stddef.h>
-
-#ifndef _STDLIB_H_
-#endif
-#define _STDLIB_H_
-
-#ifndef NULL
-#define NULL 0
-#endif
-
-#define EXIT_FAILURE 1
-#define EXIT_SUCCESS 0
-*/
-
-long int random();
-
-void srandom(unsigned int seed);
-
-double drand48(void);
-
-int rand_r(unsigned *seed);
-
-char* realpath(const char *path,char *resolved_path);
-
-/* from kdecore/fakes.c */
-
-int setenv(const char *__string, const char *__value, int __overwrite);
-
-void unsetenv(const char *__string);
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* KDE_STDLIB_H_ */

=== removed directory 'src/core/external/kdewin32/sys'
=== removed file 'src/core/external/kdewin32/sys/stat.h'
--- src/core/external/kdewin32/sys/stat.h	2010-11-28 04:24:13 +0000
+++ src/core/external/kdewin32/sys/stat.h	1970-01-01 00:00:00 +0000
@@ -1,50 +0,0 @@
-/*
- * stat.h
- * This file has no copyright assigned and is placed in the Public Domain.
- * This file is a part of the mingw-runtime package.
- * No warranty is given; refer to the file DISCLAIMER within the package.
- *
- * Symbolic constants for opening and creating files, also stat, fstat and
- * chmod functions.
- *
- */
-#ifndef KDEWIN_SYS_STAT_H
-#define KDEWIN_SYS_STAT_H
-
-#include "kdewin32/sys/types.h"
-#include <../include/sys/stat.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define _S_IFLNK  0xF000    /* Pretend */
-#define S_IFLNK   _S_IFLNK  /* kio/kio/kzip.cpp */ 
-#define _S_IFSOCK 0140000   /* socket */
-
-#define S_ISLNK(m)  (((m) & _S_IFMT) == _S_IFLNK) /* Should always be zero.*/
-#define S_ISSOCK(m) (((m)&_S_IFMT) == _S_IFSOCK)
-
-#define S_IRWXG (S_IRGRP | S_IWGRP | S_IXGRP)
-#define S_IRGRP 0000040  /* read permission, group */
-#define S_IWGRP 0000020  /* write permission, grougroup */
-#define S_IXGRP 0000010  /* execute/search permission, group */
-#define S_IRWXO (S_IROTH | S_IWOTH | S_IXOTH)
-#define S_IROTH 0000004  /* read permission, other */
-#define S_IWOTH 0000002  /* write permission, other */
-#define S_IXOTH 0000001  /* execute/search permission, other */
-
-#define S_ISUID 0004000  /* set user id on execution */
-#define S_ISGID 0002000  /* set group id on execution */
-#define S_ISVTX 0001000  /* save swapped text even after use */
-
-#define S_IFSOCK _S_IFSOCK
-
-int lstat( const char *__path, struct stat *__buf);
-int fchmod(int __fd, mode_t __mode);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // KDEWIN_SYS_STAT_H

=== removed file 'src/core/external/kdewin32/sys/types.h'
--- src/core/external/kdewin32/sys/types.h	2013-06-05 05:59:53 +0000
+++ src/core/external/kdewin32/sys/types.h	1970-01-01 00:00:00 +0000
@@ -1,48 +0,0 @@
-/* This file is part of the KDE project
-   Copyright (C) 2005 Ralf Habacker <[e-mail]>
-
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this program; see the file COPYING.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
-*/
-
-#ifndef KDEWIN_SYS_TYPES_H
-#define KDEWIN_SYS_TYPES_H
-
-#ifdef _MSC_BUILD
-
-typedef unsigned int uid_t;
-typedef unsigned int gid_t;
-typedef unsigned int pid_t;
-typedef unsigned short mode_t;
-typedef int caddr_t;
-typedef unsigned int nlink_t;
-
-#else
-
-#include <../include/sys/types.h>
-
-typedef unsigned int uid_t;
-typedef unsigned int gid_t;
-typedef int caddr_t;
-
-typedef unsigned int nlink_t;
-
-#endif
-
-// uint32
-#include <stdint.h>
-
-#endif  // KDEWIN_SYS_TYPES_H
-

=== removed file 'src/core/external/kdewin32/unistd.c'
--- src/core/external/kdewin32/unistd.c	2013-11-12 18:24:13 +0000
+++ src/core/external/kdewin32/unistd.c	1970-01-01 00:00:00 +0000
@@ -1,48 +0,0 @@
-/* This file is part of the KDE project
-   Copyright (C) 2003-2004 Jaroslaw Staniek <[e-mail]>
-
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this program; see the file COPYING.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
-*/
-
-// Note: I removed most of the code from the original file, I just keep enough
-// to be able to compile kfilter, needed by Stellarium.
-
-#include "kdewin32/unistd.h"
-
-/* Get the real user ID of the calling process.  */
-uid_t getuid()
-{
-  return -2;    // keep in sync with Qt!
-}
-
-/* Get the effective user ID of the calling process.  */
-uid_t geteuid (void)
-{
-  return -2;    // keep in sync with Qt!
-}
-
-/* Get the real group ID of the calling process.  */
-gid_t getgid (void)
-{
-  return -2;    // keep in sync with Qt!
-}
-
-/* Get the effective group ID of the calling process.  */
-gid_t getegid (void)
-{
-  return -2;    // keep in sync with Qt!
-}
-

=== removed file 'src/core/external/kdewin32/unistd.h'
--- src/core/external/kdewin32/unistd.h	2013-11-12 18:24:13 +0000
+++ src/core/external/kdewin32/unistd.h	1970-01-01 00:00:00 +0000
@@ -1,45 +0,0 @@
-/* This file is part of the KDE project
-   Copyright (C) 2003-2004 Jaroslaw Staniek <[e-mail]>
-
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this program; see the file COPYING.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
-*/
-
-#ifndef _KDEWIN_UNISTD_H
-#define _KDEWIN_UNISTD_H
-
-#include "kdewin32/sys/types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Get the real user ID of the calling process.  */
-uid_t getuid (void);
-
-/* Get the effective user ID of the calling process.  */
-uid_t geteuid (void);
-
-/* Get the real group ID of the calling process.  */
-gid_t getgid (void);
-
-/* Get the effective group ID of the calling process.  */
-gid_t getegid (void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _KDEWIN_UNISTD_H */

=== removed directory 'src/core/external/kfilter'
=== removed file 'src/core/external/kfilter/karchive.cpp'
--- src/core/external/kfilter/karchive.cpp	2013-06-05 05:59:53 +0000
+++ src/core/external/kfilter/karchive.cpp	1970-01-01 00:00:00 +0000
@@ -1,828 +0,0 @@
-/* This file is part of the KDE libraries
-   Copyright (C) 2000-2005 David Faure <[e-mail]>
-   Copyright (C) 2003 Leo Savernik <[e-mail]>
-
-   Moved from ktar.cpp by Roberto Teixeira <[e-mail]>
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License version 2 as published by the Free Software Foundation.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this library; see the file COPYING.LIB.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
-*/
-
-#include "karchive.h"
-#include "klimitediodevice.h"
-
-#include <QStack>
-#include <QtCore/QMap>
-#include <QtCore/QDir>
-#include <QtCore/QFile>
-#include <QDebug>
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <time.h>
-#ifdef Q_OS_UNIX
-#include <unistd.h>
-#endif
-#include <errno.h>
-#include <assert.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#ifdef Q_OS_UNIX
-#include <limits.h>  // PATH_MAX
-#endif
-
-#ifndef Q_OS_WIN
-#include <grp.h>
-#include <pwd.h>
-#else
-#include "kdewin32/grp.h"
-#include "kdewin32/pwd.h"
-#include "kdewin32/unistd.h"
-#endif
-
-class KArchivePrivate
-{
-public:
-	KArchivePrivate()
-		: rootDir( 0 ),
-//          saveFile( 0 ),
-		  dev ( 0 ),
-		  fileName(),
-		  mode( QIODevice::NotOpen ),
-		  deviceOwned( false )
-	{}
-	~KArchivePrivate()
-	{
-//        delete saveFile;
-		delete rootDir;
-	}
-	void abortWriting();
-
-	KArchiveDirectory* rootDir;
-//    KSaveFile* saveFile;
-	QIODevice * dev;
-	QString fileName;
-	QIODevice::OpenMode mode;
-	bool deviceOwned; // if true, we (KArchive) own dev and must delete it
-};
-
-
-////////////////////////////////////////////////////////////////////////
-/////////////////////////// KArchive ///////////////////////////////////
-////////////////////////////////////////////////////////////////////////
-
-KArchive::KArchive( const QString& fileName )
-	: d(new KArchivePrivate)
-{
-	Q_ASSERT( !fileName.isEmpty() );
-	d->fileName = fileName;
-	// This constructor leaves the device set to 0.
-	// This is for the use of KSaveFile, see open().
-}
-
-KArchive::KArchive( QIODevice * dev )
-	: d(new KArchivePrivate)
-{
-	d->dev = dev;
-}
-
-KArchive::~KArchive()
-{
-	if ( isOpen() )
-		close(); // WARNING: won't call the virtual method close in the derived class!!!
-
-	delete d;
-}
-
-bool KArchive::open( QIODevice::OpenMode mode )
-{
-	Q_ASSERT( mode != QIODevice::NotOpen );
-
-	if ( isOpen() )
-		close();
-
-	if ( !d->fileName.isEmpty() )
-	{
-		Q_ASSERT( !d->dev );
-		if ( !createDevice( mode ) )
-			return false;
-	}
-
-	Q_ASSERT( d->dev );
-
-	if ( !d->dev->isOpen() && !d->dev->open( mode ) )
-		return false;
-
-	d->mode = mode;
-
-	Q_ASSERT( !d->rootDir );
-	d->rootDir = 0;
-
-	return openArchive( mode );
-}
-
-bool KArchive::createDevice( QIODevice::OpenMode mode )
-{
-	switch( mode ) {
-	case QIODevice::WriteOnly:
-//         if ( !d->fileName.isEmpty() ) {
-//             // The use of KSaveFile can't be done in the ctor (no mode known yet)
-//             //qDebug() << "Writing to a file using KSaveFile";
-//             d->saveFile = new KSaveFile( d->fileName );
-//             if ( !d->saveFile->open() ) {
-//                 qWarning() << "KSaveFile creation for " << d->fileName << " failed, " << d->saveFile->errorString();
-//                 delete d->saveFile;
-//                 d->saveFile = 0;
-//                 return false;
-//             }
-//             d->dev = d->saveFile;
-//             Q_ASSERT( d->dev );
-//         }
-		Q_ASSERT(0); // Unsupported for Stellarium
-		break;
-	case QIODevice::ReadOnly:
-	case QIODevice::ReadWrite:
-		// ReadWrite mode still uses QFile for now; we'd need to copy to the tempfile, in fact.
-		if ( !d->fileName.isEmpty() ) {
-			d->dev = new QFile( d->fileName );
-			d->deviceOwned = true;
-		}
-		break; // continued below
-	default:
-		qWarning() << "Unsupported mode " << d->mode;
-		return false;
-	}
-	return true;
-}
-
-bool KArchive::close()
-{
-	if ( !isOpen() )
-		return false; // already closed (return false or true? arguable...)
-
-	// moved by holger to allow kzip to write the zip central dir
-	// to the file in closeArchive()
-	// DF: added d->dev so that we skip closeArchive if saving aborted.
-	bool closeSucceeded = true;
-	if ( d->dev ) {
-		closeSucceeded = closeArchive();
-		if ( d->mode == QIODevice::WriteOnly && !closeSucceeded )
-			d->abortWriting();
-	}
-
-	if ( d->dev )
-		d->dev->close();
-
-	if ( d->deviceOwned ) {
-		delete d->dev; // we created it ourselves in open()
-	}
-// Disabled for Stellarium
-//     if ( d->saveFile ) {
-//         closeSucceeded = d->saveFile->finalize();
-//         delete d->saveFile;
-//         d->saveFile = 0;
-//     }
-
-	delete d->rootDir;
-	d->rootDir = 0;
-	d->mode = QIODevice::NotOpen;
-	d->dev = 0;
-	return closeSucceeded;
-}
-
-const KArchiveDirectory* KArchive::directory() const
-{
-	// rootDir isn't const so that parsing-on-demand is possible
-	return const_cast<KArchive *>(this)->rootDir();
-}
-
-
-bool KArchive::addLocalFile(const QString&, const QString&)
-{
-	Q_ASSERT(0);  // Disabled for Stellarium
-	return true;
-//     QFileInfo fileInfo( fileName );
-//     if ( !fileInfo.isFile() && !fileInfo.isSymLink() )
-//     {
-//         qWarning() << fileName << "doesn't exist or is not a regular file.";
-//         return false;
-//     }
-//
-//     KDE_struct_stat fi;
-//     if (KDE_lstat(QFile::encodeName(fileName),&fi) == -1) {
-//         qWarning() << "stat'ing" << fileName
-//         	<< "failed:" << strerror(errno);
-//         return false;
-//     }
-//
-//     if (fileInfo.isSymLink()) {
-//         QString symLinkTarget;
-//         // Do NOT use fileInfo.readLink() for unix symlinks!
-//         // It returns the -full- path to the target, while we want the target string "as is".
-// #if defined(Q_OS_UNIX) && !defined(Q_OS_OS2EMX)
-//         QByteArray s;
-//         s.resize(PATH_MAX+1);
-//         int len = readlink( QFile::encodeName(fileName).data(), s.data(), PATH_MAX );
-//         if ( len >= 0 ) {
-//             s[len] = '\0';
-//             symLinkTarget = QFile::decodeName(s);
-//         }
-// #endif
-//         if (symLinkTarget.isEmpty()) // Mac or Windows
-//             symLinkTarget = fileInfo.symLinkTarget();
-//         return writeSymLink(destName, symLinkTarget, fileInfo.owner(),
-//                             fileInfo.group(), fi.st_mode, fi.st_atime, fi.st_mtime,
-//                             fi.st_ctime);
-//     }/*end if*/
-//
-//     qint64 size = fileInfo.size();
-//
-//     // the file must be opened before prepareWriting is called, otherwise
-//     // if the opening fails, no content will follow the already written
-//     // header and the tar file is effectively f*cked up
-//     QFile file( fileName );
-//     if ( !file.open( QIODevice::ReadOnly ) )
-//     {
-//         qWarning() << "couldn't open file " << fileName;
-//         return false;
-//     }
-//
-//     if ( !prepareWriting( destName, fileInfo.owner(), fileInfo.group(), size,
-//     		fi.st_mode, fi.st_atime, fi.st_mtime, fi.st_ctime ) )
-//     {
-//         qWarning() << " prepareWriting" << destName << "failed";
-//         return false;
-//     }
-//
-//     // Read and write data in chunks to minimize memory usage
-//     QByteArray array;
-//     array.resize(8*1024);
-//     qint64 n;
-//     qint64 total = 0;
-//     while ( ( n = file.read( array.data(), array.size() ) ) > 0 )
-//     {
-//         if ( !writeData( array.data(), n ) )
-//         {
-//             qWarning() << "writeData failed";
-//             return false;
-//         }
-//         total += n;
-//     }
-//     Q_ASSERT( total == size );
-//
-//     if ( !finishWriting( size ) )
-//     {
-//         qWarning() << "finishWriting failed";
-//         return false;
-//     }
-//     return true;
-}
-
-bool KArchive::addLocalDirectory( const QString& path, const QString& destName )
-{
-	QDir dir( path );
-	if ( !dir.exists() )
-		return false;
-	dir.setFilter(dir.filter() | QDir::Hidden);
-	const QStringList files = dir.entryList();
-	for ( QStringList::ConstIterator it = files.begin(); it != files.end(); ++it )
-	{
-		if ( *it != "." && *it != ".." )
-		{
-			QString fileName = path + '/' + *it;
-//            qDebug() << "storing " << fileName;
-			QString dest = destName.isEmpty() ? *it : (destName + '/' + *it);
-			QFileInfo fileInfo( fileName );
-
-			if ( fileInfo.isFile() || fileInfo.isSymLink() )
-				addLocalFile( fileName, dest );
-			else if ( fileInfo.isDir() )
-				addLocalDirectory( fileName, dest );
-			// We omit sockets
-		}
-	}
-	return true;
-}
-
-bool KArchive::writeFile( const QString& name, const QString& user,
-						  const QString& group, const char* data, qint64 size,
-						  mode_t perm, time_t atime, time_t mtime, time_t ctime )
-{
-	if ( !prepareWriting( name, user, group, size, perm, atime, mtime, ctime ) )
-	{
-		qWarning() << "prepareWriting failed";
-		return false;
-	}
-
-	// Write data
-	// Note: if data is 0L, don't call write, it would terminate the KFilterDev
-	if ( data && size && !writeData( data, size ) )
-	{
-		qWarning() << "writeData failed";
-		return false;
-	}
-
-	if ( !finishWriting( size ) )
-	{
-		qWarning() << "finishWriting failed";
-		return false;
-	}
-	return true;
-}
-
-bool KArchive::writeData( const char* data, qint64 size )
-{
-	bool ok = device()->write( data, size ) == size;
-	if ( !ok )
-		d->abortWriting();
-	return ok;
-}
-
-// The writeDir -> doWriteDir pattern allows to avoid propagating the default
-// values into all virtual methods of subclasses, and it allows more extensibility:
-// if a new argument is needed, we can add a writeDir overload which stores the
-// additional argument in the d pointer, and doWriteDir reimplementations can fetch
-// it from there.
-
-bool KArchive::writeDir( const QString& name, const QString& user, const QString& group,
-						 mode_t perm, time_t atime,
-						 time_t mtime, time_t ctime )
-{
-	return doWriteDir( name, user, group, perm, atime, mtime, ctime );
-}
-
-bool KArchive::writeSymLink(const QString &name, const QString &target,
-							const QString &user, const QString &group,
-							mode_t perm, time_t atime,
-							time_t mtime, time_t ctime )
-{
-	return doWriteSymLink( name, target, user, group, perm, atime, mtime, ctime );
-}
-
-
-bool KArchive::prepareWriting( const QString& name, const QString& user,
-							   const QString& group, qint64 size,
-							   mode_t perm, time_t atime,
-							   time_t mtime, time_t ctime )
-{
-	bool ok = doPrepareWriting( name, user, group, size, perm, atime, mtime, ctime );
-	if ( !ok )
-		d->abortWriting();
-	return ok;
-}
-
-bool KArchive::finishWriting( qint64 size )
-{
-	return doFinishWriting( size );
-}
-
-KArchiveDirectory * KArchive::rootDir()
-{
-	if ( !d->rootDir )
-	{
-		//qDebug() << "Making root dir ";
-		struct passwd* pw =  getpwuid( getuid() );
-		struct group* grp = getgrgid( getgid() );
-		QString username = pw ? QFile::decodeName(pw->pw_name) : QString::number( getuid() );
-		QString groupname = grp ? QFile::decodeName(grp->gr_name) : QString::number( getgid() );
-
-		d->rootDir = new KArchiveDirectory( this, QLatin1String("/"), (int)(0777 + S_IFDIR), 0, username, groupname, QString() );
-	}
-	return d->rootDir;
-}
-
-KArchiveDirectory * KArchive::findOrCreate( const QString & path )
-{
-	//qDebug() << path;
-	if ( path.isEmpty() || path == "/" || path == "." ) // root dir => found
-	{
-		//qDebug() << "returning rootdir";
-		return rootDir();
-	}
-	// Important note : for tar files containing absolute paths
-	// (i.e. beginning with "/"), this means the leading "/" will
-	// be removed (no KDirectory for it), which is exactly the way
-	// the "tar" program works (though it displays a warning about it)
-	// See also KArchiveDirectory::entry().
-
-	// Already created ? => found
-	const KArchiveEntry* ent = rootDir()->entry( path );
-	if ( ent )
-	{
-		if ( ent->isDirectory() )
-			//qDebug() << "found it";
-			return (KArchiveDirectory *) ent;
-		else
-			qWarning() << "Found" << path << "but it's not a directory";
-	}
-
-	// Otherwise go up and try again
-	int pos = path.lastIndexOf( '/' );
-	KArchiveDirectory * parent;
-	QString dirname;
-	if ( pos == -1 ) // no more slash => create in root dir
-	{
-		parent =  rootDir();
-		dirname = path;
-	}
-	else
-	{
-		QString left = path.left( pos );
-		dirname = path.mid( pos + 1 );
-		parent = findOrCreate( left ); // recursive call... until we find an existing dir.
-	}
-
-	//qDebug() << "found parent " << parent->name() << " adding " << dirname << " to ensure " << path;
-	// Found -> add the missing piece
-	KArchiveDirectory * e = new KArchiveDirectory( this, dirname, d->rootDir->permissions(),
-												   d->rootDir->date(), d->rootDir->user(),
-												   d->rootDir->group(), QString() );
-	parent->addEntry( e );
-	return e; // now a directory to <path> exists
-}
-
-void KArchive::setDevice( QIODevice * dev )
-{
-	if ( d->deviceOwned )
-		delete d->dev;
-	d->dev = dev;
-	d->deviceOwned = false;
-}
-
-void KArchive::setRootDir( KArchiveDirectory *rootDir )
-{
-	Q_ASSERT( !d->rootDir ); // Call setRootDir only once during parsing please ;)
-	d->rootDir = rootDir;
-}
-
-QIODevice::OpenMode KArchive::mode() const
-{
-	return d->mode;
-}
-
-QIODevice * KArchive::device() const
-{
-	return d->dev;
-}
-
-bool KArchive::isOpen() const
-{
-	return d->mode != QIODevice::NotOpen;
-}
-
-QString KArchive::fileName() const
-{
-	return d->fileName;
-}
-
-void KArchivePrivate::abortWriting()
-{
-// Disabled for Stellarium
-//     if ( saveFile ) {
-//         saveFile->abort();
-//         delete saveFile;
-//         saveFile = 0;
-//         dev = 0;
-//     }
-}
-
-////////////////////////////////////////////////////////////////////////
-/////////////////////// KArchiveEntry //////////////////////////////////
-////////////////////////////////////////////////////////////////////////
-
-class KArchiveEntryPrivate
-{
-public:
-	KArchiveEntryPrivate( KArchive* _archive, const QString& _name, int _access,
-						  int _date, const QString& _user, const QString& _group,
-						  const QString& _symlink) :
-		name(_name),
-		date(_date),
-		access(_access),
-		user(_user),
-		group(_group),
-		symlink(_symlink),
-		archive(_archive)
-	{}
-	QString name;
-	int date;
-	mode_t access;
-	QString user;
-	QString group;
-	QString symlink;
-	KArchive* archive;
-};
-
-KArchiveEntry::KArchiveEntry( KArchive* t, const QString& name, int access, int date,
-					  const QString& user, const QString& group, const
-					  QString& symlink) :
-	d(new KArchiveEntryPrivate(t,name,access,date,user,group,symlink))
-{
-}
-
-KArchiveEntry::~KArchiveEntry()
-{
-	delete d;
-}
-
-QDateTime KArchiveEntry::datetime() const
-{
-  QDateTime datetimeobj;
-  datetimeobj.setTime_t( d->date );
-  return datetimeobj;
-}
-
-int KArchiveEntry::date() const
-{
-	return d->date;
-}
-
-QString KArchiveEntry::name() const
-{
-	return d->name;
-}
-
-mode_t KArchiveEntry::permissions() const
-{
-	return d->access;
-}
-
-QString KArchiveEntry::user() const
-{
-	return d->user;
-}
-
-QString KArchiveEntry::group() const
-{
-	return d->group;
-}
-
-QString KArchiveEntry::symLinkTarget() const
-{
-	return d->symlink;
-}
-
-bool KArchiveEntry::isFile() const
-{
-	return false;
-}
-
-bool KArchiveEntry::isDirectory() const
-{
-	return false;
-}
-
-KArchive* KArchiveEntry::archive() const
-{
-	return d->archive;
-}
-
-////////////////////////////////////////////////////////////////////////
-/////////////////////// KArchiveFile ///////////////////////////////////
-////////////////////////////////////////////////////////////////////////
-
-class KArchiveFilePrivate
-{
-public:
-	KArchiveFilePrivate( qint64 _pos, qint64 _size ) :
-		pos(_pos),
-		size(_size)
-	{}
-	qint64 pos;
-	qint64 size;
-};
-
-KArchiveFile::KArchiveFile( KArchive* t, const QString& name, int access, int date,
-							const QString& user, const QString& group,
-							const QString & symlink,
-							qint64 pos, qint64 size )
-  : KArchiveEntry( t, name, access, date, user, group, symlink ),
-	d( new KArchiveFilePrivate(pos, size) )
-{
-}
-
-KArchiveFile::~KArchiveFile()
-{
-	delete d;
-}
-
-qint64 KArchiveFile::position() const
-{
-  return d->pos;
-}
-
-qint64 KArchiveFile::size() const
-{
-  return d->size;
-}
-
-void KArchiveFile::setSize( qint64 s )
-{
-	d->size = s;
-}
-
-QByteArray KArchiveFile::data() const
-{
-  archive()->device()->seek( d->pos );
-
-  // Read content
-  QByteArray arr;
-  if ( d->size )
-  {
-	assert( arr.data() );
-	arr = archive()->device()->read( d->size );
-	Q_ASSERT( arr.size() == d->size );
-  }
-  return arr;
-}
-
-QIODevice * KArchiveFile::createDevice() const
-{
-  return new KLimitedIODevice( archive()->device(), d->pos, d->size );
-}
-
-bool KArchiveFile::isFile() const
-{
-	return true;
-}
-
-void KArchiveFile::copyTo(const QString& dest) const
-{
-  QFile f( dest + '/'  + name() );
-  if ( f.open( QIODevice::ReadWrite | QIODevice::Truncate ) )
-  {
-	  f.write( data() );
-	  f.close();
-  }
-}
-
-////////////////////////////////////////////////////////////////////////
-//////////////////////// KArchiveDirectory /////////////////////////////////
-////////////////////////////////////////////////////////////////////////
-
-class KArchiveDirectoryPrivate
-{
-public:
-	~KArchiveDirectoryPrivate()
-	{
-		qDeleteAll(entries);
-	}
-	QHash<QString, KArchiveEntry *> entries;
-};
-
-KArchiveDirectory::KArchiveDirectory( KArchive* t, const QString& name, int access,
-							  int date,
-							  const QString& user, const QString& group,
-							  const QString &symlink)
-  : KArchiveEntry( t, name, access, date, user, group, symlink ),
-	d( new KArchiveDirectoryPrivate )
-{
-}
-
-KArchiveDirectory::~KArchiveDirectory()
-{
-  delete d;
-}
-
-QStringList KArchiveDirectory::entries() const
-{
-  return d->entries.keys();
-}
-
-const KArchiveEntry* KArchiveDirectory::entry( const QString& _name ) const
-{
-  QString name = _name;
-  int pos = name.indexOf( '/' );
-  if ( pos == 0 ) // ouch absolute path (see also KArchive::findOrCreate)
-  {
-	if (name.length()>1)
-	{
-	  name = name.mid( 1 ); // remove leading slash
-	  pos = name.indexOf( '/' ); // look again
-	}
-	else // "/"
-	  return this;
-  }
-  // trailing slash ? -> remove
-  if ( pos != -1 && pos == name.length()-1 )
-  {
-	name = name.left( pos );
-	pos = name.indexOf( '/' ); // look again
-  }
-  if ( pos != -1 )
-  {
-	QString left = name.left( pos );
-	QString right = name.mid( pos + 1 );
-
-	//qDebug() << "left=" << left << "right=" << right;
-
-	const KArchiveEntry* e = d->entries.value( left );
-	if ( !e || !e->isDirectory() )
-	  return 0;
-	return static_cast<const KArchiveDirectory*>(e)->entry( right );
-  }
-
-  return d->entries.value( name );
-}
-
-void KArchiveDirectory::addEntry( KArchiveEntry* entry )
-{
-  Q_ASSERT( !entry->name().isEmpty() );
-  if( d->entries.value( entry->name() ) ) {
-	  qWarning() << "directory " << name()
-				  << "has entry" << entry->name() << "already";
-  }
-  d->entries.insert( entry->name(), entry );
-}
-
-bool KArchiveDirectory::isDirectory() const
-{
-	return true;
-}
-
-static int sortByPosition( const KArchiveFile* file1, const KArchiveFile* file2 ) {
-	return file1->position() - file2->position();
-}
-
-void KArchiveDirectory::copyTo(const QString& dest, bool recursiveCopy ) const
-{
-  QDir root;
-
-  QList<const KArchiveFile*> fileList;
-  QMap<qint64, QString> fileToDir;
-
-  // placeholders for iterated items
-  QStack<const KArchiveDirectory *> dirStack;
-  QStack<QString> dirNameStack;
-
-  dirStack.push( this );     // init stack at current directory
-  dirNameStack.push( dest ); // ... with given path
-  do {
-	const KArchiveDirectory* curDir = dirStack.pop();
-	const QString curDirName = dirNameStack.pop();
-	root.mkdir(curDirName);
-
-	const QStringList dirEntries = curDir->entries();
-	for ( QStringList::const_iterator it = dirEntries.begin(); it != dirEntries.end(); ++it ) {
-	  const KArchiveEntry* curEntry = curDir->entry(*it);
-	  if (!curEntry->symLinkTarget().isEmpty()) {
-		  const QString linkName = curDirName+'/'+curEntry->name();
-#ifdef Q_OS_UNIX
-		  if (!::symlink(curEntry->symLinkTarget().toLocal8Bit(), linkName.toLocal8Bit())) {
-			  qDebug() << "symlink(" << curEntry->symLinkTarget() << ',' << linkName << ") failed:" << strerror(errno);
-		  }
-#else
-		  // TODO - how to create symlinks on other platforms?
-#endif
-	  } else {
-		  if ( curEntry->isFile() ) {
-			  const KArchiveFile* curFile = dynamic_cast<const KArchiveFile*>( curEntry );
-			  if (curFile) {
-				  fileList.append( curFile );
-				  fileToDir.insert( curFile->position(), curDirName );
-			  }
-		  }
-
-		  if ( curEntry->isDirectory() && recursiveCopy ) {
-			  const KArchiveDirectory *ad = dynamic_cast<const KArchiveDirectory*>( curEntry );
-			  if (ad) {
-				  dirStack.push( ad );
-				  dirNameStack.push( curDirName + '/' + curEntry->name() );
-			  }
-		  }
-	  }
-	}
-  } while (!dirStack.isEmpty());
-
-  qSort( fileList.begin(), fileList.end(), sortByPosition );  // sort on d->pos, so we have a linear access
-
-  for ( QList<const KArchiveFile*>::const_iterator it = fileList.constBegin(), end = fileList.constEnd() ;
-		it != end ; ++it ) {
-	  const KArchiveFile* f = *it;
-	  qint64 pos = f->position();
-	  f->copyTo( fileToDir[pos] );
-  }
-}
-
-void KArchive::virtual_hook( int, void* )
-{ /*BASE::virtual_hook( id, data )*/; }
-
-void KArchiveEntry::virtual_hook( int, void* )
-{ /*BASE::virtual_hook( id, data );*/ }
-
-void KArchiveFile::virtual_hook( int id, void* data )
-{ KArchiveEntry::virtual_hook( id, data ); }
-
-void KArchiveDirectory::virtual_hook( int id, void* data )
-{ KArchiveEntry::virtual_hook( id, data ); }

=== removed file 'src/core/external/kfilter/karchive.h'
--- src/core/external/kfilter/karchive.h	2013-06-05 05:59:53 +0000
+++ src/core/external/kfilter/karchive.h	1970-01-01 00:00:00 +0000
@@ -1,603 +0,0 @@
-/* This file is part of the KDE libraries
-   Copyright (C) 2000-2005 David Faure <[e-mail]>
-   Copyright (C) 2003 Leo Savernik <[e-mail]>
-
-   Moved from ktar.h by Roberto Teixeira <[e-mail]>
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License version 2 as published by the Free Software Foundation.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this library; see the file COPYING.LIB.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
-*/
-#ifndef KARCHIVE_H
-#define KARCHIVE_H
-
-#ifdef _MSC_BUILD
-#include "kdewin32/sys/types.h"
-#else
-#include <sys/types.h>
-#endif
-
-#include <QtCore/QDate>
-#include <QtCore/QString>
-#include <QtCore/QStringList>
-#include <QtCore/QHash>
-
-class KArchiveDirectory;
-class KArchiveFile;
-
-class KArchivePrivate;
-/**
- * KArchive is a base class for reading and writing archives.
- * @short generic class for reading/writing archives
- * @author David Faure <[e-mail]>
- */
-class KArchive
-{
-protected:
-    /**
-     * Base constructor (protected since this is a pure virtual class).
-     * @param fileName is a local path (e.g. "/tmp/myfile.ext"),
-     * from which the archive will be read from, or into which the archive
-     * will be written, depending on the mode given to open().
-     */
-    KArchive( const QString& fileName );
-
-    /**
-     * Base constructor (protected since this is a pure virtual class).
-     * @param dev the I/O device where the archive reads its data
-     * Note that this can be a file, but also a data buffer, a compression filter, etc.
-     * For a file in writing mode it is better to use the other constructor
-     * though, to benefit from the use of KSaveFile when saving.
-     */
-    KArchive( QIODevice * dev );
-
-public:
-    virtual ~KArchive();
-
-    /**
-     * Opens the archive for reading or writing.
-     * Inherited classes might want to reimplement openArchive instead.
-     * @param mode may be QIODevice::ReadOnly or QIODevice::WriteOnly
-     * @see close
-     */
-    virtual bool open( QIODevice::OpenMode mode );
-
-    /**
-     * Closes the archive.
-     * Inherited classes might want to reimplement closeArchive instead.
-     *
-     * @return true if close succeeded without problems
-     * @see open
-     */
-    virtual bool close();
-
-    /**
-     * Checks whether the archive is open.
-     * @return true if the archive is opened
-     */
-    bool isOpen() const;
-
-    /**
-     * Returns the mode in which the archive was opened
-     * @return the mode in which the archive was opened (QIODevice::ReadOnly or QIODevice::WriteOnly)
-     * @see open()
-     */
-    QIODevice::OpenMode mode() const;
-
-    /**
-     * The underlying device.
-     * @return the underlying device.
-     */
-    QIODevice * device() const;
-
-    /**
-     * The name of the archive file, as passed to the constructor that takes a
-     * fileName, or an empty string if you used the QIODevice constructor.
-     * @return the name of the file, or QString() if unknown
-     */
-    QString fileName() const;
-
-    /**
-     * If an archive is opened for reading, then the contents
-     * of the archive can be accessed via this function.
-     * @return the directory of the archive
-     */
-    const KArchiveDirectory* directory() const;
-
-    /**
-     * Writes a local file into the archive. The main difference with writeFile,
-     * is that this method minimizes memory usage, by not loading the whole file
-     * into memory in one go.
-     *
-     * If @p fileName is a symbolic link, it will be written as is, i. e.
-     * it will not be resolved before.
-     * @param fileName full path to an existing local file, to be added to the archive.
-     * @param destName the resulting name (or relative path) of the file in the archive.
-     */
-    bool addLocalFile( const QString& fileName, const QString& destName );
-
-    /**
-     * Writes a local directory into the archive, including all its contents, recursively.
-     * Calls addLocalFile for each file to be added.
-     *
-     * Since KDE 3.2 it will also add a @p path that is a symbolic link to a
-     * directory. The symbolic link will be dereferenced and the content of the
-     * directory it is pointing to added recursively. However, symbolic links
-     * *under* @p path will be stored as is.
-     * @param path full path to an existing local directory, to be added to the archive.
-     * @param destName the resulting name (or relative path) of the file in the archive.
-     */
-    bool addLocalDirectory( const QString& path, const QString& destName );
-
-    enum { UnknownTime = static_cast<time_t>( -1 ) };
-
-    /**
-     * If an archive is opened for writing then you can add new directories
-     * using this function. KArchive won't write one directory twice.
-     *
-     * This method also allows some file metadata to be set.
-     * However, depending on the archive type not all metadata might be regarded.
-     *
-     * @param name the name of the directory
-     * @param user the user that owns the directory
-     * @param group the group that owns the directory
-     * @param perm permissions of the directory
-     * @param atime time the file was last accessed
-     * @param mtime modification time of the file
-     * @param ctime time of last status change
-     */
-    virtual bool writeDir( const QString& name, const QString& user, const QString& group,
-                           mode_t perm = 040755, time_t atime = UnknownTime,
-                           time_t mtime = UnknownTime, time_t ctime = UnknownTime );
-
-    /**
-     * Writes a symbolic link to the archive if supported.
-     * The archive must be opened for writing.
-     *
-     * @param name name of symbolic link
-     * @param target target of symbolic link
-     * @param user the user that owns the directory
-     * @param group the group that owns the directory
-     * @param perm permissions of the directory
-     * @param atime time the file was last accessed
-     * @param mtime modification time of the file
-     * @param ctime time of last status change
-     */
-    virtual bool writeSymLink(const QString &name, const QString &target,
-                              const QString &user, const QString &group,
-                              mode_t perm = 0120755, time_t atime = UnknownTime,
-                              time_t mtime = UnknownTime, time_t ctime = UnknownTime );
-
-    /**
-     * If an archive is opened for writing then you can add a new file
-     * using this function. If the file name is for example "mydir/test1" then
-     * the directory "mydir" is automatically appended first if that did not
-     * happen yet.
-     *
-     * This method also allows some file metadata to be
-     * set. However, depending on the archive type not all metadata might be
-     * regarded.
-     * @param name the name of the file
-     * @param user the user that owns the file
-     * @param group the group that owns the file
-     * @param data the data to write (@p size bytes)
-     * @param size the size of the file
-     * @param perm permissions of the file
-     * @param atime time the file was last accessed
-     * @param mtime modification time of the file
-     * @param ctime time of last status change
-     */
-    virtual bool writeFile( const QString& name, const QString& user, const QString& group,
-                            const char* data, qint64 size,
-                            mode_t perm = 0100644, time_t atime = UnknownTime,
-                            time_t mtime = UnknownTime, time_t ctime = UnknownTime );
-
-    /**
-     * Here's another way of writing a file into an archive:
-     * Call prepareWriting(), then call writeData()
-     * as many times as wanted then call finishWriting( totalSize ).
-     * For tar.gz files, you need to know the size before hand, it is needed in the header!
-     * For zip files, size isn't used.
-     *
-     * This method also allows some file metadata to be
-     * set. However, depending on the archive type not all metadata might be
-     * regarded.
-     * @param name the name of the file
-     * @param user the user that owns the file
-     * @param group the group that owns the file
-     * @param size the size of the file
-     * @param perm permissions of the file
-     * @param atime time the file was last accessed
-     * @param mtime modification time of the file
-     * @param ctime time of last status change
-     */
-    virtual bool prepareWriting( const QString& name, const QString& user,
-                                 const QString& group, qint64 size,
-                                 mode_t perm = 0100644, time_t atime = UnknownTime,
-                                 time_t mtime = UnknownTime, time_t ctime = UnknownTime );
-
-    /**
-     * Write data into the current file - to be called after calling prepareWriting
-     */
-    virtual bool writeData( const char* data, qint64 size );
-
-    /**
-     * Call finishWriting after writing the data.
-     * @param size the size of the file
-     * @see prepareWriting()
-     */
-    virtual bool finishWriting( qint64 size );
-
-protected:
-    /**
-     * Opens an archive for reading or writing.
-     * Called by open.
-     * @param mode may be QIODevice::ReadOnly or QIODevice::WriteOnly
-     */
-    virtual bool openArchive( QIODevice::OpenMode mode ) = 0;
-
-    /**
-     * Closes the archive.
-     * Called by close.
-     */
-    virtual bool closeArchive() = 0;
-
-    /**
-     * Retrieves or create the root directory.
-     * The default implementation assumes that openArchive() did the parsing,
-     * so it creates a dummy rootdir if none was set (write mode, or no '/' in the archive).
-     * Reimplement this to provide parsing/listing on demand.
-     * @return the root directory
-     */
-    virtual KArchiveDirectory* rootDir();
-
-    /**
-     * Write a directory to the archive.
-     * This virtual method must be implemented by subclasses.
-     *
-     * Depending on the archive type not all metadata might be used.
-     *
-     * @param name the name of the directory
-     * @param user the user that owns the directory
-     * @param group the group that owns the directory
-     * @param perm permissions of the directory. Use 040755 if you don't have any other information.
-     * @param atime time the file was last accessed
-     * @param mtime modification time of the file
-     * @param ctime time of last status change
-     * @see writeDir
-     */
-    virtual bool doWriteDir( const QString& name, const QString& user, const QString& group,
-                             mode_t perm, time_t atime, time_t mtime, time_t ctime ) = 0;
-
-    /**
-     * Writes a symbolic link to the archive.
-     * This virtual method must be implemented by subclasses.
-     *
-     * @param name name of symbolic link
-     * @param target target of symbolic link
-     * @param user the user that owns the directory
-     * @param group the group that owns the directory
-     * @param perm permissions of the directory
-     * @param atime time the file was last accessed
-     * @param mtime modification time of the file
-     * @param ctime time of last status change
-     * @see writeSymLink
-     */
-    virtual bool doWriteSymLink(const QString &name, const QString &target,
-                                const QString &user, const QString &group,
-                                mode_t perm, time_t atime, time_t mtime, time_t ctime) = 0;
-
-    /**
-     * This virtual method must be implemented by subclasses.
-     *
-     * Depending on the archive type not all metadata might be used.
-     *
-     * @param name the name of the file
-     * @param user the user that owns the file
-     * @param group the group that owns the file
-     * @param size the size of the file
-     * @param perm permissions of the file. Use 0100644 if you don't have any more specific permissions to set.
-     * @param atime time the file was last accessed
-     * @param mtime modification time of the file
-     * @param ctime time of last status change
-     * @see prepareWriting
-     */
-    virtual bool doPrepareWriting( const QString& name, const QString& user,
-                                   const QString& group, qint64 size, mode_t perm,
-                                   time_t atime, time_t mtime, time_t ctime ) = 0;
-
-    /**
-     * Called after writing the data.
-     * This virtual method must be implemented by subclasses.
-     *
-     * @param size the size of the file
-     * @see finishWriting()
-     */
-    virtual bool doFinishWriting( qint64 size ) = 0;
-
-    /**
-     * Ensures that @p path exists, create otherwise.
-     * This handles e.g. tar files missing directory entries, like mico-2.3.0.tar.gz :)
-     * @param path the path of the directory
-     * @return the directory with the given @p path
-     */
-    KArchiveDirectory * findOrCreate( const QString & path );
-
-    /**
-     * Can be reimplemented in order to change the creation of the device
-     * (when using the fileName constructor). By default this method uses
-     * KSaveFile when saving, and a simple QFile on reading.
-     * This method is called by open().
-     */
-    virtual bool createDevice( QIODevice::OpenMode mode );
-
-    /**
-     * Can be called by derived classes in order to set the underlying device.
-     * Note that KArchive will -not- own the device, it must be deleted by the derived class.
-     */
-    void setDevice( QIODevice *dev );
-
-    /**
-     * Derived classes call setRootDir from openArchive,
-     * to set the root directory after parsing an existing archive.
-     */
-    void setRootDir( KArchiveDirectory *rootDir );
-
-protected:
-    virtual void virtual_hook( int id, void* data );
-private:
-    KArchivePrivate* const d;
-};
-
-class KArchiveEntryPrivate;
-/**
- * A base class for entries in an KArchive.
- * @short Base class for the archive-file's directory structure.
- *
- * @see KArchiveFile
- * @see KArchiveDirectory
- */
-class KArchiveEntry
-{
-public:
-    /**
-     * Creates a new entry.
-     * @param archive the entries archive
-     * @param name the name of the entry
-     * @param access the permissions in unix format
-     * @param date the date (in seconds since 1970)
-     * @param user the user that owns the entry
-     * @param group the group that owns the entry
-     * @param symlink the symlink, or QString()
-     */
-    KArchiveEntry( KArchive* archive, const QString& name, int access, int date,
-                   const QString& user, const QString& group,
-                   const QString& symlink );
-
-    virtual ~KArchiveEntry();
-
-    /**
-     * Creation date of the file.
-     * @return the creation date
-     */
-    QDateTime datetime() const;
-
-    /**
-     * Creation date of the file.
-     * @return the creation date in seconds since 1970
-     */
-    int date() const;
-
-    /**
-     * Name of the file without path.
-     * @return the file name without path
-     */
-    QString name() const;
-    /**
-     * The permissions and mode flags as returned by the stat() function
-     * in st_mode.
-     * @return the permissions
-     */
-    mode_t permissions() const;
-    /**
-     * User who created the file.
-     * @return the owner of the file
-     */
-    QString user() const;
-    /**
-     * Group of the user who created the file.
-     * @return the group of the file
-     */
-    QString group() const;
-
-    /**
-     * Symlink if there is one.
-     * @return the symlink, or QString()
-     */
-    QString symLinkTarget() const;
-
-    /**
-     * Checks whether the entry is a file.
-     * @return true if this entry is a file
-     */
-    virtual bool isFile() const;
-
-    /**
-     * Checks whether the entry is a directory.
-     * @return true if this entry is a directory
-     */
-    virtual bool isDirectory() const;
-
-protected:
-    KArchive* archive() const;
-
-protected:
-    virtual void virtual_hook( int id, void* data );
-private:
-    KArchiveEntryPrivate* const d;
-};
-
-class KArchiveFilePrivate;
-/**
- * Represents a file entry in a KArchive.
- * @short A file in an archive.
- *
- * @see KArchive
- * @see KArchiveDirectory
- */
-class KArchiveFile : public KArchiveEntry
-{
-public:
-    /**
-     * Creates a new file entry. Do not call this, KArchive takes care of it.
-     * @param archive the entries archive
-     * @param name the name of the entry
-     * @param access the permissions in unix format
-     * @param date the date (in seconds since 1970)
-     * @param user the user that owns the entry
-     * @param group the group that owns the entry
-     * @param symlink the symlink, or QString()
-     * @param pos the position of the file in the directory
-     * @param size the size of the file
-     */
-    KArchiveFile( KArchive* archive, const QString& name, int access, int date,
-                  const QString& user, const QString& group, const QString &symlink,
-                  qint64 pos, qint64 size );
-
-    /**
-     * Destructor. Do not call this, KArchive takes care of it.
-     */
-    virtual ~KArchiveFile();
-
-    /**
-     * Position of the data in the [uncompressed] archive.
-     * @return the position of the file
-     */
-    qint64 position() const;
-    /**
-     * Size of the data.
-     * @return the size of the file
-     */
-    qint64 size() const;
-    /**
-     * Set size of data, usually after writing the file.
-     * @param s the new size of the file
-     */
-    void setSize( qint64 s );
-
-    /**
-     * Returns the data of the file.
-     * Call data() with care (only once per file), this data isn't cached.
-     * @return the content of this file.
-     */
-    virtual QByteArray data() const;
-
-    /**
-     * This method returns QIODevice (internal class: KLimitedIODevice)
-     * on top of the underlying QIODevice. This is obviously for reading only.
-     *
-     * WARNING: Note that the ownership of the device is being transferred to the caller,
-     * who will have to delete it.
-     *
-     * The returned device auto-opens (in readonly mode), no need to open it.
-     * @return the QIODevice of the file
-     */
-    virtual QIODevice *createDevice() const;
-
-    /**
-     * Checks whether this entry is a file.
-     * @return true, since this entry is a file
-     */
-    virtual bool isFile() const;
-
-    /**
-     * Extracts the file to the directory @p dest
-     * @param dest the directory to extract to
-     */
-    void copyTo(const QString& dest) const;
-
-protected:
-    virtual void virtual_hook( int id, void* data );
-private:
-    KArchiveFilePrivate* const d;
-};
-
-class KArchiveDirectoryPrivate;
-/**
- * Represents a directory entry in a KArchive.
- * @short A directory in an archive.
- *
- * @see KArchive
- * @see KArchiveFile
- */
-class KArchiveDirectory : public KArchiveEntry
-{
-public:
-    /**
-     * Creates a new directory entry.
-     * @param archive the entries archive
-     * @param name the name of the entry
-     * @param access the permissions in unix format
-     * @param date the date (in seconds since 1970)
-     * @param user the user that owns the entry
-     * @param group the group that owns the entry
-     * @param symlink the symlink, or QString()
-     */
-    KArchiveDirectory( KArchive* archive, const QString& name, int access, int date,
-                   const QString& user, const QString& group,
-                   const QString& symlink);
-
-    virtual ~KArchiveDirectory();
-
-    /**
-     * Returns a list of sub-entries.
-     * Note that the list is not sorted, it's even in random order (due to using a hashtable).
-     * Use sort() on the result to sort the list by filename.
-     *
-     * @return the names of all entries in this directory (filenames, no path).
-     */
-    QStringList entries() const;
-    /**
-     * Returns the entry with the given name.
-     * @param name may be "test1", "mydir/test3", "mydir/mysubdir/test3", etc.
-     * @return a pointer to the entry in the directory.
-     */
-    const KArchiveEntry* entry( const QString& name ) const;
-
-    /**
-     * @internal
-     * Adds a new entry to the directory.
-     */
-    void addEntry( KArchiveEntry* );
-
-    /**
-     * Checks whether this entry is a directory.
-     * @return true, since this entry is a directory
-     */
-    virtual bool isDirectory() const;
-
-    /**
-     * Extracts all entries in this archive directory to the directory
-     * @p dest.
-     * @param dest the directory to extract to
-     * @param recursive if set to true, subdirectories are extracted as well
-     */
-     void copyTo(const QString& dest, bool recursive = true) const;
-
-protected:
-    virtual void virtual_hook( int id, void* data );
-private:
-    KArchiveDirectoryPrivate* const d;
-};
-
-#endif

=== removed file 'src/core/external/kfilter/kfilterbase.cpp'
--- src/core/external/kfilter/kfilterbase.cpp	2010-04-30 17:27:42 +0000
+++ src/core/external/kfilter/kfilterbase.cpp	1970-01-01 00:00:00 +0000
@@ -1,113 +0,0 @@
-/* This file is part of the KDE libraries
-   Copyright (C) 2000-2005 David Faure <[e-mail]>
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License version 2 as published by the Free Software Foundation.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this library; see the file COPYING.LIB.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
-*/
-
-#include "kfilterbase.h"
-
-#include <QDebug>
-#include <QtCore/QIODevice>
-#include "kgzipfilter.h"
-
-KFilterBase::KFilterBase()
-    : m_dev( 0L ), m_bAutoDel( false ), d(0)
-{
-}
-
-KFilterBase::~KFilterBase()
-{
-    if ( m_bAutoDel )
-        delete m_dev;
-}
-
-void KFilterBase::setDevice( QIODevice * dev, bool autodelete )
-{
-    m_dev = dev;
-    m_bAutoDel = autodelete;
-}
-
-QIODevice * KFilterBase::device()
-{
-    return m_dev;
-}
-
-bool KFilterBase::inBufferEmpty() const
-{
-    return inBufferAvailable() == 0;
-}
-
-bool KFilterBase::outBufferFull() const
-{
-    return outBufferAvailable() == 0;
-}
-
-KFilterBase * KFilterBase::findFilterByFileName( const QString & fileName )
-{
-    if ( fileName.endsWith( ".gz", Qt::CaseInsensitive ) )
-    {
-        return new KGzipFilter;
-    }
-#ifdef HAVE_BZIP2_SUPPORT
-    if ( fileName.endsWith( ".bz2", Qt::CaseInsensitive ) )
-    {
-        return new KBzip2Filter;
-    }
-#endif
-    else
-    {
-        // not a warning, since this is called often with other mimetypes (see #88574)...
-        // maybe we can avoid that though?
-        qDebug() << "KFilterBase::findFilterByFileName : no filter found for " << fileName;
-    }
-
-    return 0;
-}
-
-KFilterBase * KFilterBase::findFilterByMimeType( const QString & mimeType )
-{
-    if ( mimeType == QLatin1String( "application/x-gzip" ) )
-    {
-        return new KGzipFilter;
-    }
-#ifdef HAVE_BZIP2_SUPPORT
-    else if ( mimeType == QLatin1String( "application/x-bzip" )
-              || mimeType == QLatin1String( "application/x-bzip2" ) // old name, kept for compatibility
-              || (mime && mime->is("application/x-bzip")) )
-    {
-        return new KBzip2Filter;
-    }
-#endif
-    else
-    {
-        // not a warning, since this is called often with other mimetypes (see #88574)...
-        // maybe we can avoid that though?
-        qDebug() << "KFilterBase::findFilterByMimeType : no filter found for " << mimeType;
-    }
-
-    return 0;
-}
-
-void KFilterBase::terminate()
-{
-}
-
-void KFilterBase::reset()
-{
-}
-
-void KFilterBase::virtual_hook( int, void* )
-{ /*BASE::virtual_hook( id, data );*/ }
-

=== removed file 'src/core/external/kfilter/kfilterbase.h'
--- src/core/external/kfilter/kfilterbase.h	2010-04-15 12:28:34 +0000
+++ src/core/external/kfilter/kfilterbase.h	1970-01-01 00:00:00 +0000
@@ -1,115 +0,0 @@
-/* This file is part of the KDE libraries
-   Copyright (C) 2000 David Faure <[e-mail]>
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License version 2 as published by the Free Software Foundation.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this library; see the file COPYING.LIB.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
-*/
-
-#ifndef __kfilterbase__h
-#define __kfilterbase__h
-
-#include <QtCore/QObject>
-#include <QtCore/QString>
-
-class QIODevice;
-
-/**
- * This is the base class for compression filters
- * such as gzip and bzip2. It's pretty much internal.
- * Don't use directly, use KFilterDev instead.
- * @internal
- */
-class KFilterBase
-{
-public:
-    KFilterBase();
-    virtual ~KFilterBase();
-
-    /**
-     * Sets the device on which the filter will work
-     * @param dev the device on which the filter will work
-     * @param autodelete if true, @p dev is deleted when the filter is deleted
-     */
-    void setDevice( QIODevice * dev, bool autodelete = false );
-    // Note that this isn't in the constructor, because of KLibFactory::create,
-    // but it should be called before using the filterbase !
-
-    /**
-     * Returns the device on which the filter will work.
-     * @returns the device on which the filter will work
-     */
-    QIODevice * device();
-    /** \internal */
-    virtual void init( int mode ) = 0;
-    /** \internal */
-    virtual int mode() const = 0;
-    /** \internal */
-    virtual void terminate();
-    /** \internal */
-    virtual void reset();
-    /** \internal */
-    virtual bool readHeader() = 0;
-    /** \internal */
-    virtual bool writeHeader( const QByteArray & filename ) = 0;
-    /** \internal */
-    virtual void setOutBuffer( char * data, uint maxlen ) = 0;
-    /** \internal */
-    virtual void setInBuffer( const char * data, uint size ) = 0;
-    /** \internal */
-    virtual bool inBufferEmpty() const;
-    /** \internal */
-    virtual int  inBufferAvailable() const = 0;
-    /** \internal */
-    virtual bool outBufferFull() const;
-    /** \internal */
-    virtual int  outBufferAvailable() const = 0;
-
-    /** \internal */
-    enum Result { Ok, End, Error };
-    /** \internal */
-    virtual Result uncompress() = 0;
-    /** \internal */
-    virtual Result compress( bool finish ) = 0;
-
-    /**
-     * Call this to create the appropriate filter for the file
-     * named @p fileName.
-     * @param fileName the name of the file to filter
-     * @return the filter for the @p fileName, or 0 if not found
-     */
-    static KFilterBase * findFilterByFileName( const QString & fileName );
-
-    /**
-     * Call this to create the appropriate filter for the mimetype
-     * @p mimeType. For instance application/x-gzip.
-     * @param mimeType the mime type of the file to filter
-     * @return the filter for the @p mimeType, or 0 if not found
-     */
-    static KFilterBase * findFilterByMimeType( const QString & mimeType );
-
-protected:
-    QIODevice * m_dev;
-    bool m_bAutoDel;
-protected:
-    /** Virtual hook, used to add new "virtual" functions while maintaining
-	binary compatibility. Unused in this class.
-    */
-    virtual void virtual_hook( int id, void* data );
-private:
-    Q_DISABLE_COPY( KFilterBase )
-    class Private;
-    Private * const d;
-};
-
-#endif

=== removed file 'src/core/external/kfilter/kfilterdev.cpp'
--- src/core/external/kfilter/kfilterdev.cpp	2010-04-15 12:28:34 +0000
+++ src/core/external/kfilter/kfilterdev.cpp	1970-01-01 00:00:00 +0000
@@ -1,372 +0,0 @@
-/* This file is part of the KDE libraries
-   Copyright (C) 2000, 2006 David Faure <[e-mail]>
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License version 2 as published by the Free Software Foundation.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this library; see the file COPYING.LIB.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
-*/
-
-#include "kfilterdev.h"
-#include "kfilterbase.h"
-#include <stdio.h> // for EOF
-#include <stdlib.h>
-#include <assert.h>
-#include <QtCore/QFile>
-#include <QDebug>
-
-#define BUFFER_SIZE 8*1024
-
-class KFilterDev::Private
-{
-public:
-    Private() : bNeedHeader(true), bSkipHeaders(false),
-                          autoDeleteFilterBase(false), bOpenedUnderlyingDevice(false),
-                          bIgnoreData(false){}
-    bool bNeedHeader;
-    bool bSkipHeaders;
-    bool autoDeleteFilterBase;
-    bool bOpenedUnderlyingDevice;
-    bool bIgnoreData;
-    QByteArray buffer; // Used as 'input buffer' when reading, as 'output buffer' when writing
-    QByteArray origFileName;
-    KFilterBase::Result result;
-    KFilterBase *filter;
-};
-
-KFilterDev::KFilterDev( KFilterBase * _filter, bool autoDeleteFilterBase )
-    : d(new Private)
-{
-    assert(_filter);
-    d->filter = _filter;
-    d->autoDeleteFilterBase = autoDeleteFilterBase;
-}
-
-KFilterDev::~KFilterDev()
-{
-    if ( isOpen() )
-        close();
-    if ( d->autoDeleteFilterBase )
-        delete d->filter;
-    delete d;
-}
-
-//static
-QIODevice * KFilterDev::deviceForFile( const QString & fileName, const QString & mimetype,
-                                       bool forceFilter )
-{
-    QFile * f = new QFile( fileName );
-    KFilterBase * base = mimetype.isEmpty() ? KFilterBase::findFilterByFileName( fileName )
-                         : KFilterBase::findFilterByMimeType( mimetype );
-    if ( base )
-    {
-        base->setDevice(f, true);
-        return new KFilterDev(base, true);
-    }
-    if(!forceFilter)
-        return f;
-    else
-    {
-        delete f;
-        return 0L;
-    }
-}
-
-QIODevice * KFilterDev::device( QIODevice* inDevice, const QString & mimetype, bool autoDeleteInDevice )
-{
-   if (inDevice==0)
-      return 0;
-   KFilterBase * base = KFilterBase::findFilterByMimeType(mimetype);
-   if ( base )
-   {
-      base->setDevice(inDevice, autoDeleteInDevice);
-      return new KFilterDev(base, true /* auto-delete "base" */);
-   }
-   return 0;
-}
-
-bool KFilterDev::open( QIODevice::OpenMode mode )
-{
-    //qDebug() << "KFilterDev::open " << mode;
-    if ( mode == QIODevice::ReadOnly )
-    {
-        d->buffer.resize(0);
-    }
-    else
-    {
-        d->buffer.resize( BUFFER_SIZE );
-        d->filter->setOutBuffer( d->buffer.data(), d->buffer.size() );
-    }
-    d->bNeedHeader = !d->bSkipHeaders;
-    d->filter->init( mode );
-    d->bOpenedUnderlyingDevice = !d->filter->device()->isOpen();
-    bool ret = d->bOpenedUnderlyingDevice ? d->filter->device()->open( mode ) : true;
-    d->result = KFilterBase::Ok;
-
-    if ( !ret )
-        qWarning() << "KFilterDev::open: Couldn't open underlying device";
-    else
-        setOpenMode( mode );
-
-    return ret;
-}
-
-void KFilterDev::close()
-{
-    if ( !isOpen() )
-        return;
-    //qDebug() << "KFilterDev::close";
-    if ( d->filter->mode() == QIODevice::WriteOnly )
-        write( 0L, 0 ); // finish writing
-    //qDebug() << "KFilterDev::close. Calling terminate().";
-
-    d->filter->terminate();
-    if ( d->bOpenedUnderlyingDevice )
-        d->filter->device()->close();
-    setOpenMode( QIODevice::NotOpen );
-}
-
-bool KFilterDev::seek( qint64 pos )
-{
-    qint64 ioIndex = this->pos(); // current position
-    if ( ioIndex == pos )
-        return true;
-
-    qDebug() << "KFilterDev::seek(" << pos << ") called";
-
-    Q_ASSERT ( d->filter->mode() == QIODevice::ReadOnly );
-
-    if ( pos == 0 )
-    {
-        // We can forget about the cached data
-        d->bNeedHeader = !d->bSkipHeaders;
-        d->result = KFilterBase::Ok;
-        d->filter->setInBuffer(0L,0);
-        d->filter->reset();
-        QIODevice::seek(pos);
-        return d->filter->device()->reset();
-    }
-
-    if ( ioIndex > pos ) // we can start from here
-        pos = pos - ioIndex;
-    else
-    {
-        // we have to start from 0 ! Ugly and slow, but better than the previous
-        // solution (KTarGz was allocating everything into memory)
-        if (!seek(0)) // recursive
-            return false;
-    }
-
-    //qDebug() << "KFilterDev::at : reading " << pos << " dummy bytes";
-    QByteArray dummy( qMin( pos, (qint64)3*BUFFER_SIZE ), 0 );
-    d->bIgnoreData = true;
-    bool result = ( read( dummy.data(), pos ) == pos );
-    d->bIgnoreData = false;
-    QIODevice::seek(pos);
-    return result;
-}
-
-bool KFilterDev::atEnd() const
-{
-    return (d->result == KFilterBase::End)
-        && QIODevice::atEnd() // take QIODevice's internal buffer into account
-        && d->filter->device()->atEnd();
-}
-
-qint64 KFilterDev::readData( char *data, qint64 maxlen )
-{
-    Q_ASSERT ( d->filter->mode() == QIODevice::ReadOnly );
-    //qDebug() << "KFilterDev::read maxlen=" << maxlen;
-    KFilterBase* filter = d->filter;
-
-    uint dataReceived = 0;
-
-    // We came to the end of the stream
-    if ( d->result == KFilterBase::End )
-        return dataReceived;
-
-    // If we had an error, return -1.
-    if ( d->result != KFilterBase::Ok )
-        return -1;
-
-
-    qint64 outBufferSize;
-    if ( d->bIgnoreData )
-    {
-        outBufferSize = qMin( maxlen, (qint64)3*BUFFER_SIZE );
-    }
-    else
-    {
-        outBufferSize = maxlen;
-    }
-    outBufferSize -= dataReceived;
-    qint64 availOut = outBufferSize;
-    filter->setOutBuffer( data, outBufferSize );
-
-    bool decompressedAll = false;
-    while ( dataReceived < maxlen )
-    {
-        if (filter->inBufferEmpty())
-        {
-            // Not sure about the best size to set there.
-            // For sure, it should be bigger than the header size (see comment in readHeader)
-            d->buffer.resize( BUFFER_SIZE );
-            // Request data from underlying device
-            int size = filter->device()->read( d->buffer.data(),
-                                               d->buffer.size() );
-            if ( size )
-                filter->setInBuffer( d->buffer.data(), size );
-            else {
-                if ( decompressedAll )
-                {
-                    // We decoded everything there was to decode. So -> done.
-                    //qDebug() << "Seems we're done. dataReceived=" << dataReceived;
-                    d->result = KFilterBase::End;
-                    break;
-                }
-            }
-            //qDebug() << "KFilterDev::read got " << size << " bytes from device";
-        }
-        if (d->bNeedHeader)
-        {
-            (void) filter->readHeader();
-            d->bNeedHeader = false;
-        }
-
-        d->result = filter->uncompress();
-
-        if (d->result == KFilterBase::Error)
-        {
-            qWarning() << "KFilterDev: Error when uncompressing data";
-            break;
-        }
-
-        // We got that much data since the last time we went here
-        uint outReceived = availOut - filter->outBufferAvailable();
-        //qDebug() << "avail_out = " << filter->outBufferAvailable() << " result=" << d->result << " outReceived=" << outReceived;
-        if( availOut < (uint)filter->outBufferAvailable() )
-            qWarning() << " last availOut " << availOut << " smaller than new avail_out=" << filter->outBufferAvailable() << " !";
-
-        dataReceived += outReceived;
-        if ( !d->bIgnoreData )  // Move on in the output buffer
-        {
-            data += outReceived;
-            availOut = maxlen - dataReceived;
-        }
-        else if ( maxlen - dataReceived < outBufferSize )
-        {
-            availOut = maxlen - dataReceived;
-        }
-        if (d->result == KFilterBase::End)
-        {
-            //qDebug() << "KFilterDev::read got END. dataReceived=" << dataReceived;
-            break; // Finished.
-        }
-        if (filter->inBufferEmpty() && filter->outBufferAvailable() != 0 )
-        {
-            decompressedAll = true;
-        }
-        filter->setOutBuffer( data, availOut );
-    }
-
-    return dataReceived;
-}
-
-qint64 KFilterDev::writeData( const char *data /*0 to finish*/, qint64 len )
-{
-    KFilterBase* filter = d->filter;
-    Q_ASSERT ( filter->mode() == QIODevice::WriteOnly );
-    // If we had an error, return 0.
-    if ( d->result != KFilterBase::Ok )
-        return 0;
-
-    bool finish = (data == 0L);
-    if (!finish)
-    {
-        filter->setInBuffer( data, len );
-        if (d->bNeedHeader)
-        {
-            (void)filter->writeHeader( d->origFileName );
-            d->bNeedHeader = false;
-        }
-    }
-
-    uint dataWritten = 0;
-    uint availIn = len;
-    while ( dataWritten < len || finish )
-    {
-
-        d->result = filter->compress( finish );
-
-        if (d->result == KFilterBase::Error)
-        {
-            qWarning() << "KFilterDev: Error when compressing data";
-            // What to do ?
-            break;
-        }
-
-        // Wrote everything ?
-        if (filter->inBufferEmpty() || (d->result == KFilterBase::End))
-        {
-            // We got that much data since the last time we went here
-            uint wrote = availIn - filter->inBufferAvailable();
-
-            //qDebug() << " Wrote everything for now. avail_in = " << filter->inBufferAvailable() << " result=" << d->result << " wrote=" << wrote;
-
-            // Move on in the input buffer
-            data += wrote;
-            dataWritten += wrote;
-
-            availIn = len - dataWritten;
-            //qDebug() << " KFilterDev::write availIn=" << availIn << " dataWritten=" << dataWritten << " ioIndex=" << pos();
-            if ( availIn > 0 ) // Not sure this will ever happen
-                filter->setInBuffer( data, availIn );
-        }
-
-        if (filter->outBufferFull() || (d->result == KFilterBase::End))
-        {
-            //qDebug() << " KFilterDev::write writing to underlying. avail_out=" << filter->outBufferAvailable();
-            int towrite = d->buffer.size() - filter->outBufferAvailable();
-            if ( towrite > 0 )
-            {
-                // Write compressed data to underlying device
-                int size = filter->device()->write( d->buffer.data(), towrite );
-                if ( size != towrite ) {
-                    qWarning() << "KFilterDev::write. Could only write " << size << " out of " << towrite << " bytes";
-                    return 0; // indicate an error (happens on disk full)
-                }
-                //else
-                    //qDebug() << " KFilterDev::write wrote " << size << " bytes";
-            }
-            d->buffer.resize( 8*1024 );
-            filter->setOutBuffer( d->buffer.data(), d->buffer.size() );
-            if (d->result == KFilterBase::End)
-            {
-                //qDebug() << " KFilterDev::write END";
-                Q_ASSERT(finish); // hopefully we don't get end before finishing
-                break;
-            }
-        }
-    }
-
-    return dataWritten;
-}
-
-void KFilterDev::setOrigFileName( const QByteArray & fileName )
-{
-    d->origFileName = fileName;
-}
-
-void KFilterDev::setSkipHeaders()
-{
-    d->bSkipHeaders = true;
-}

=== removed file 'src/core/external/kfilter/kfilterdev.h'
--- src/core/external/kfilter/kfilterdev.h	2010-04-15 12:28:34 +0000
+++ src/core/external/kfilter/kfilterdev.h	1970-01-01 00:00:00 +0000
@@ -1,153 +0,0 @@
-/* This file is part of the KDE libraries
-   Copyright (C) 2000 David Faure <[e-mail]>
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License version 2 as published by the Free Software Foundation.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this library; see the file COPYING.LIB.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
-*/
-#ifndef __kfilterdev_h
-#define __kfilterdev_h
-
-#include <QtCore/QIODevice>
-#include <QtCore/QString>
-
-class QFile;
-class KFilterBase;
-
-/**
- * A class for reading and writing compressed data onto a device
- * (e.g. file, but other usages are possible, like a buffer or a socket).
- *
- * To simply read/write compressed files, see deviceForFile.
- *
- * @author David Faure <[e-mail]>
- */
-class KFilterDev : public QIODevice
-{
-public:
-    /**
-     * Destructs the KFilterDev.
-     * Calls close() if the filter device is still open.
-     */
-    virtual ~KFilterDev();
-
-    /**
-     * Open for reading or writing.
-     * If the KFilterBase's device is not opened, it will be opened.
-     */
-    virtual bool open( QIODevice::OpenMode mode );
-    /**
-     * Close after reading or writing.
-     * If the KFilterBase's device was opened by open(), it will be closed.
-     */
-    virtual void close();
-
-    /**
-     * For writing gzip compressed files only:
-     * set the name of the original file, to be used in the gzip header.
-     * @param fileName the name of the original file
-     */
-    void setOrigFileName( const QByteArray & fileName );
-
-    /**
-     * Call this let this device skip the gzip headers when reading/writing.
-     * This way KFilterDev (with gzip filter) can be used as a direct wrapper
-     * around zlib - this is used by KZip.
-     */
-    void setSkipHeaders();
-
-    /**
-     * That one can be quite slow, when going back. Use with care.
-     */
-    virtual bool seek( qint64 );
-
-    virtual bool atEnd() const;
-
-    /// Reimplemented to return true. KFilterDev is a sequential QIODevice.
-    /// Well, not really, since it supports seeking and KZip uses that.
-    //virtual bool isSequential() const { return true; }
-
-public:
-
-
-    // KDE4 TODO: turn those static methods into constructors
-
-    /**
-     * Creates an i/o device that is able to read from @p fileName,
-     * whether it's compressed or not. Available compression filters
-     * (gzip/bzip2 etc.) will automatically be used.
-     *
-     * The compression filter to be used is determined from the @p fileName
-     * if @p mimetype is empty. Pass "application/x-gzip" or "application/x-bzip"
-     * to force the corresponding decompression filter, if available.
-     *
-     * Warning: application/x-bzip may not be available.
-     * In that case a QFile opened on the compressed data will be returned !
-     * Use KFilterBase::findFilterByMimeType and code similar to what
-     * deviceForFile is doing, to better control what's happening.
-     *
-     * The returned QIODevice has to be deleted after using.
-     *
-     * @param fileName the name of the file to filter
-     * @param mimetype the mime type of the file to filter, or QString() if unknown
-     * @param forceFilter if true, the function will either find a compression filter, or return 0.
-     *                    If false, it will always return a QIODevice. If no
-     *                    filter is available it will return a simple QFile.
-     *                    This can be useful if the file is usable without a filter.
-     * @return if a filter has been found, the QIODevice for the filter. If the
-     *         filter does not exist, the return value depends on @p forceFilter.
-     *         The returned QIODevice has to be deleted after using.
-     */
-    static QIODevice * deviceForFile( const QString & fileName, const QString & mimetype = QString(),
-                                      bool forceFilter = false );
-
-    /**
-     * Creates an i/o device that is able to read from the QIODevice @p inDevice,
-     * whether the data is compressed or not. Available compression filters
-     * (gzip/bzip2 etc.) will automatically be used.
-     *
-     * The compression filter to be used is determined @p mimetype .
-     * Pass "application/x-gzip" or "application/x-bzip"
-     * to use the corresponding decompression filter.
-     *
-     * Warning: application/x-bzip may not be available.
-     * In that case 0 will be returned !
-     *
-     * The returned QIODevice has to be deleted after using.
-     * @param inDevice input device. Won't be deleted if @p autoDeleteInDevice = false
-     * @param mimetype the mime type for the filter
-     * @param autoDeleteInDevice if true, @p inDevice will be deleted automatically
-     * @return a QIODevice that filters the original stream. Must be deleted after
-     *         using
-     */
-    static QIODevice * device( QIODevice* inDevice, const QString & mimetype, bool autoDeleteInDevice = true );
-
-protected:
-    virtual qint64 readData( char *data, qint64 maxlen );
-    virtual qint64 writeData( const char *data, qint64 len );
-
-private:
-    /**
-     * Constructs a KFilterDev for a given filter (e.g. gzip, bzip2 etc.).
-     * @param filter the KFilterBase to use
-     * @param autoDeleteFilterBase when true this object will become the
-     * owner of @p filter.
-     */
-    explicit KFilterDev( KFilterBase * filter, bool autoDeleteFilterBase = false );
-private:
-    class Private;
-    Private* const d;
-};
-
-
-#endif

=== removed file 'src/core/external/kfilter/kgzipfilter.cpp'
--- src/core/external/kfilter/kgzipfilter.cpp	2010-04-15 12:28:34 +0000
+++ src/core/external/kfilter/kgzipfilter.cpp	1970-01-01 00:00:00 +0000
@@ -1,333 +0,0 @@
-/* This file is part of the KDE libraries
-   Copyright (C) 2000-2005 David Faure <[e-mail]>
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License version 2 as published by the Free Software Foundation.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this library; see the file COPYING.LIB.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
-*/
-
-#include "kgzipfilter.h"
-
-#include <time.h>
-#include <zlib.h>
-#include <QtCore/QIODevice>
-#include <QDebug>
-
-/* gzip flag byte */
-#define ASCII_FLAG   0x01 /* bit 0 set: file probably ascii text */
-#define HEAD_CRC     0x02 /* bit 1 set: header CRC present */
-#define EXTRA_FIELD  0x04 /* bit 2 set: extra field present */
-#define ORIG_NAME    0x08 /* bit 3 set: original file name present */
-#define COMMENT      0x10 /* bit 4 set: file comment present */
-#define RESERVED     0xE0 /* bits 5..7: reserved */
-
-// #define DEBUG_GZIP
-
-class KGzipFilter::Private
-{
-public:
-    Private()
-    {
-        zStream.zalloc = (alloc_func)0;
-        zStream.zfree = (free_func)0;
-        zStream.opaque = (voidpf)0;
-        headerWritten = false;
-        compressed = false;
-        mode = 0;
-    }
-
-    z_stream zStream;
-    bool headerWritten;
-    bool compressed;
-    int mode;
-    ulong crc;
-};
-
-KGzipFilter::KGzipFilter()
-    : d(new Private)
-{
-}
-
-
-KGzipFilter::~KGzipFilter()
-{
-    delete d;
-}
-
-void KGzipFilter::init( int mode )
-{
-    d->zStream.next_in = Z_NULL;
-    d->zStream.avail_in = 0;
-    if ( mode == QIODevice::ReadOnly )
-    {
-        int result = inflateInit2(&d->zStream, -MAX_WBITS); // windowBits is passed < 0 to suppress zlib header
-        if ( result != Z_OK )
-            qDebug() << "inflateInit returned " << result;
-        // No idea what to do with result :)
-    } else if ( mode == QIODevice::WriteOnly )
-    {
-        int result = deflateInit2(&d->zStream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, -MAX_WBITS, 8, Z_DEFAULT_STRATEGY); // same here
-        if ( result != Z_OK )
-            qDebug() << "deflateInit returned " << result;
-    } else {
-        qWarning() << "KGzipFilter: Unsupported mode " << mode << ". Only QIODevice::ReadOnly and QIODevice::WriteOnly supported";
-    }
-    d->mode = mode;
-    d->compressed = true;
-    d->headerWritten = false;
-}
-
-int KGzipFilter::mode() const
-{
-    return d->mode;
-}
-
-void KGzipFilter::terminate()
-{
-    if ( d->mode == QIODevice::ReadOnly )
-    {
-        int result = inflateEnd(&d->zStream);
-        if ( result != Z_OK )
-            qDebug() << "inflateEnd returned " << result;
-    } else if ( d->mode == QIODevice::WriteOnly )
-    {
-        int result = deflateEnd(&d->zStream);
-        if ( result != Z_OK )
-            qDebug() << "deflateEnd returned " << result;
-    }
-}
-
-
-void KGzipFilter::reset()
-{
-    if ( d->mode == QIODevice::ReadOnly )
-    {
-        int result = inflateReset(&d->zStream);
-        if ( result != Z_OK )
-            qDebug() << "inflateReset returned " << result;
-    } else if ( d->mode == QIODevice::WriteOnly ) {
-        int result = deflateReset(&d->zStream);
-        if ( result != Z_OK )
-            qDebug() << "deflateReset returned " << result;
-        d->headerWritten = false;
-    }
-}
-
-bool KGzipFilter::readHeader()
-{
-#ifdef DEBUG_GZIP
-    qDebug() << "KGzipFilter::readHeader avail=" << d->zStream.avail_in;
-#endif
-    // Assume not compressed until we successfully decode the header
-    d->compressed = false;
-    // Assume the first block of data contains the whole header.
-    // The right way is to build this as a big state machine which
-    // is a pain in the ass.
-    // With 8K-blocks, we don't risk much anyway.
-    Bytef *p = d->zStream.next_in;
-    int i = d->zStream.avail_in;
-    if ((i -= 10)  < 0) return false; // Need at least 10 bytes
-#ifdef DEBUG_GZIP
-    qDebug() << "KGzipFilter::readHeader first byte is " << QString::number(*p,16);
-#endif
-    if (*p++ != 0x1f) return false; // GZip magic
-#ifdef DEBUG_GZIP
-    qDebug() << "KGzipFilter::readHeader second byte is " << QString::number(*p,16);
-#endif
-    if (*p++ != 0x8b) return false;
-    int method = *p++;
-    int flags = *p++;
-    if ((method != Z_DEFLATED) || (flags & RESERVED) != 0) return false;
-    p += 6;
-    if ((flags & EXTRA_FIELD) != 0) // skip extra field
-    {
-        if ((i -= 2) < 0) return false; // Need at least 2 bytes
-        int len = *p++;
-        len += (*p++) << 8;
-        if ((i -= len) < 0) return false; // Need at least len bytes
-        p += len;
-    }
-    if ((flags & ORIG_NAME) != 0) // skip original file name
-    {
-#ifdef DEBUG_GZIP
-        qDebug() << "ORIG_NAME=" << (char*)p;
-#endif
-        while( (i > 0) && (*p))
-        {
-            i--; p++;
-        }
-        if (--i <= 0) return false;
-        p++;
-    }
-    if ((flags & COMMENT) != 0) // skip comment
-    {
-        while( (i > 0) && (*p))
-        {
-            i--; p++;
-        }
-        if (--i <= 0) return false;
-        p++;
-    }
-    if ((flags & HEAD_CRC) != 0) // skip the header crc
-    {
-        if ((i-=2) < 0) return false;
-        p += 2;
-    }
-
-    d->zStream.avail_in = i;
-    d->zStream.next_in = p;
-    d->compressed = true;
-#ifdef DEBUG_GZIP
-    qDebug() << "header OK";
-#endif
-    return true;
-}
-
-/* Output a 16 bit value, lsb first */
-#define put_short(w) \
-    *p++ = (uchar) ((w) & 0xff); \
-    *p++ = (uchar) ((ushort)(w) >> 8);
-
-/* Output a 32 bit value to the bit stream, lsb first */
-#define put_long(n) \
-    put_short((n) & 0xffff); \
-    put_short(((ulong)(n)) >> 16);
-
-bool KGzipFilter::writeHeader( const QByteArray & fileName )
-{
-    Bytef *p = d->zStream.next_out;
-    int i = d->zStream.avail_out;
-    *p++ = 0x1f;
-    *p++ = 0x8b;
-    *p++ = Z_DEFLATED;
-    *p++ = ORIG_NAME;
-    put_long( time( 0L ) ); // Modification time (in unix format)
-    *p++ = 0; // Extra flags (2=max compress, 4=fastest compress)
-    *p++ = 3; // Unix
-
-    uint len = fileName.length();
-    for ( uint j = 0 ; j < len ; ++j )
-        *p++ = fileName[j];
-    *p++ = 0;
-    int headerSize = p - d->zStream.next_out;
-    i -= headerSize;
-    Q_ASSERT(i>0);
-    d->crc = crc32(0L, Z_NULL, 0);
-    d->zStream.next_out = p;
-    d->zStream.avail_out = i;
-    d->headerWritten = true;
-    return true;
-}
-
-void KGzipFilter::writeFooter()
-{
-    Q_ASSERT( d->headerWritten );
-    //if (!d->headerWritten) qDebug() << kBacktrace();
-    Bytef *p = d->zStream.next_out;
-    int i = d->zStream.avail_out;
-    //qDebug() << "KGzipFilter::writeFooter writing CRC= " << QString::number( d->crc, 16 );
-    put_long( d->crc );
-    //qDebug() << "KGzipFilter::writing writing totalin= " << d->zStream.total_in;
-    put_long( d->zStream.total_in );
-    i -= p - d->zStream.next_out;
-    d->zStream.next_out = p;
-    d->zStream.avail_out = i;
-}
-
-void KGzipFilter::setOutBuffer( char * data, uint maxlen )
-{
-    d->zStream.avail_out = maxlen;
-    d->zStream.next_out = (Bytef *) data;
-}
-void KGzipFilter::setInBuffer( const char * data, uint size )
-{
-#ifdef DEBUG_GZIP
-    qDebug() << "KGzipFilter::setInBuffer avail_in=" << size;
-#endif
-    d->zStream.avail_in = size;
-    d->zStream.next_in = (Bytef*) data;
-}
-int KGzipFilter::inBufferAvailable() const
-{
-    return d->zStream.avail_in;
-}
-int KGzipFilter::outBufferAvailable() const
-{
-    return d->zStream.avail_out;
-}
-
-KGzipFilter::Result KGzipFilter::uncompress_noop()
-{
-    // I'm not sure we really need support for that (uncompressed streams),
-    // but why not, it can't hurt to have it. One case I can think of is someone
-    // naming a tar file "blah.tar.gz" :-)
-    if ( d->zStream.avail_in > 0 )
-    {
-        int n = (d->zStream.avail_in < d->zStream.avail_out) ? d->zStream.avail_in : d->zStream.avail_out;
-        memcpy( d->zStream.next_out, d->zStream.next_in, n );
-        d->zStream.avail_out -= n;
-        d->zStream.next_in += n;
-        d->zStream.avail_in -= n;
-        return KFilterBase::Ok;
-    } else
-        return KFilterBase::End;
-}
-
-KGzipFilter::Result KGzipFilter::uncompress()
-{
-    Q_ASSERT ( d->mode == QIODevice::ReadOnly );
-    if ( d->compressed )
-    {
-#ifdef DEBUG_GZIP
-        qDebug() << "Calling inflate with avail_in=" << inBufferAvailable() << " avail_out=" << outBufferAvailable();
-        qDebug() << "    next_in=" << d->zStream.next_in;
-#endif
-        int result = inflate(&d->zStream, Z_SYNC_FLUSH);
-#ifdef DEBUG_GZIP
-        qDebug() << " -> inflate returned " << result;
-        qDebug() << "Now avail_in=" << inBufferAvailable() << " avail_out=" << outBufferAvailable();
-        qDebug() << "    next_in=" << d->zStream.next_in;
-#else
-        if ( result != Z_OK && result != Z_STREAM_END )
-            qDebug() << "Warning: inflate() returned " << result;
-#endif
-        return ( result == Z_OK ? KFilterBase::Ok : ( result == Z_STREAM_END ? KFilterBase::End : KFilterBase::Error ) );
-    } else
-        return uncompress_noop();
-}
-
-KGzipFilter::Result KGzipFilter::compress( bool finish )
-{
-    Q_ASSERT ( d->compressed );
-    Q_ASSERT ( d->mode == QIODevice::WriteOnly );
-
-    Bytef* p = d->zStream.next_in;
-    ulong len = d->zStream.avail_in;
-#ifdef DEBUG_GZIP
-    qDebug() << "  calling deflate with avail_in=" << inBufferAvailable() << " avail_out=" << outBufferAvailable();
-#endif
-    int result = deflate(&d->zStream, finish ? Z_FINISH : Z_NO_FLUSH);
-    if ( result != Z_OK && result != Z_STREAM_END )
-        qDebug() << "  deflate returned " << result;
-    if ( d->headerWritten )
-    {
-        //qDebug() << "Computing CRC for the next " << len - d->zStream.avail_in << " bytes";
-        d->crc = crc32(d->crc, p, len - d->zStream.avail_in);
-    }
-    if ( result == Z_STREAM_END && d->headerWritten )
-    {
-        //qDebug() << "KGzipFilter::compress finished, write footer";
-        writeFooter();
-    }
-    return ( result == Z_OK ? KFilterBase::Ok : ( result == Z_STREAM_END ? KFilterBase::End : KFilterBase::Error ) );
-}

=== removed file 'src/core/external/kfilter/kgzipfilter.h'
--- src/core/external/kfilter/kgzipfilter.h	2010-04-15 12:28:34 +0000
+++ src/core/external/kfilter/kgzipfilter.h	1970-01-01 00:00:00 +0000
@@ -1,54 +0,0 @@
-/* This file is part of the KDE libraries
-   Copyright (C) 2000 David Faure <[e-mail]>
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License version 2 as published by the Free Software Foundation.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this library; see the file COPYING.LIB.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
-*/
-
-#ifndef __kgzipfilter__h
-#define __kgzipfilter__h
-
-#include "kfilterbase.h"
-
-/**
- * Internal class used by KFilterDev
- * @internal
- */
-class KGzipFilter : public KFilterBase
-{
-public:
-    KGzipFilter();
-    virtual ~KGzipFilter();
-
-    virtual void init( int mode );
-    virtual int mode() const;
-    virtual void terminate();
-    virtual void reset();
-    virtual bool readHeader();
-    virtual bool writeHeader( const QByteArray & fileName );
-    void writeFooter();
-    virtual void setOutBuffer( char * data, uint maxlen );
-    virtual void setInBuffer( const char * data, uint size );
-    virtual int  inBufferAvailable() const;
-    virtual int  outBufferAvailable() const;
-    virtual Result uncompress();
-    virtual Result compress( bool finish );
-
-private:
-    Result uncompress_noop();
-    class Private;
-    Private* const d;
-};
-
-#endif

=== removed file 'src/core/external/kfilter/klimitediodevice.cpp'
--- src/core/external/kfilter/klimitediodevice.cpp	2010-04-15 12:28:34 +0000
+++ src/core/external/kfilter/klimitediodevice.cpp	1970-01-01 00:00:00 +0000
@@ -1,77 +0,0 @@
-/* This file is part of the KDE libraries
-   Copyright (C) 2001, 2002, 2007 David Faure <[e-mail]>
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License version 2 as published by the Free Software Foundation.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this library; see the file COPYING.LIB.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
-*/
-
-#include "klimitediodevice.h"
-#include <QDebug>
-
-KLimitedIODevice::KLimitedIODevice( QIODevice *dev, int start, int length )
-    : m_dev( dev ), m_start( start ), m_length( length )
-{
-    //kDebug(7005) << "start=" << start << "length=" << length;
-    open( QIODevice::ReadOnly ); //krazy:exclude=syscalls
-}
-
-bool KLimitedIODevice::open( QIODevice::OpenMode m )
-{
-    //kDebug(7005) << "m=" << m;
-    if ( m & QIODevice::ReadOnly ) {
-        /*bool ok = false;
-          if ( m_dev->isOpen() )
-          ok = ( m_dev->mode() == QIODevice::ReadOnly );
-          else
-          ok = m_dev->open( m );
-          if ( ok )*/
-        m_dev->seek( m_start ); // No concurrent access !
-    }
-    else
-        qWarning() << "KLimitedIODevice::open only supports QIODevice::ReadOnly!";
-    setOpenMode( QIODevice::ReadOnly );
-    return true;
-}
-
-void KLimitedIODevice::close()
-{
-}
-
-qint64 KLimitedIODevice::size() const
-{
-    return m_length;
-}
-
-qint64 KLimitedIODevice::readData( char * data, qint64 maxlen )
-{
-    maxlen = qMin( maxlen, m_length - pos() ); // Apply upper limit
-    return m_dev->read( data, maxlen );
-}
-
-bool KLimitedIODevice::seek( qint64 pos )
-{
-    Q_ASSERT( pos <= m_length );
-    pos = qMin( pos, m_length ); // Apply upper limit
-    return m_dev->seek( m_start + pos );
-}
-
-qint64 KLimitedIODevice::bytesAvailable() const
-{
-     return m_length + QIODevice::bytesAvailable();
-}
-
-bool KLimitedIODevice::isSequential() const
-{
-    return m_dev->isSequential();
-}

=== removed file 'src/core/external/kfilter/klimitediodevice.h'
--- src/core/external/kfilter/klimitediodevice.h	2010-04-15 12:28:34 +0000
+++ src/core/external/kfilter/klimitediodevice.h	1970-01-01 00:00:00 +0000
@@ -1,63 +0,0 @@
-/* This file is part of the KDE libraries
-   Copyright (C) 2001, 2002, 2007 David Faure <[e-mail]>
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License version 2 as published by the Free Software Foundation.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this library; see the file COPYING.LIB.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
-*/
-
-#ifndef klimitediodevice_h
-#define klimitediodevice_h
-
-#include <QtCore/QIODevice>
-/**
- * A readonly device that reads from an underlying device
- * from a given point to another (e.g. to give access to a single
- * file inside an archive).
- * @author David Faure <[e-mail]>
- * @internal - used by KArchive
- */
-class KLimitedIODevice : public QIODevice
-{
-public:
-    /**
-     * Creates a new KLimitedIODevice.
-     * @param dev the underlying device, opened or not
-     * This device itself auto-opens (in readonly mode), no need to open it.
-     * @param start where to start reading (position in bytes)
-     * @param length the length of the data to read (in bytes)
-     */
-    KLimitedIODevice( QIODevice *dev, int start, int length );
-    virtual ~KLimitedIODevice() {}
-
-    virtual bool isSequential() const;
-
-    virtual bool open( QIODevice::OpenMode m );
-    virtual void close();
-
-    virtual qint64 size() const;
-
-    virtual qint64 readData ( char * data, qint64 maxlen );
-    virtual qint64 writeData ( const char *, qint64 ) { return -1; } // unsupported
-    virtual int putChar( int ) { return -1; } // unsupported
-
-    //virtual qint64 pos() const { return m_dev->pos() - m_start; }
-    virtual bool seek( qint64 pos );
-    virtual qint64 bytesAvailable() const;
-private:
-    QIODevice* m_dev;
-    qint64 m_start;
-    qint64 m_length;
-};
-
-#endif

=== removed file 'src/core/external/kfilter/kzip.cpp'
--- src/core/external/kfilter/kzip.cpp	2013-01-08 17:47:37 +0000
+++ src/core/external/kfilter/kzip.cpp	1970-01-01 00:00:00 +0000
@@ -1,1402 +0,0 @@
-/* This file is part of the KDE libraries
-   Copyright (C) 2000 David Faure <[e-mail]>
-   Copyright (C) 2002 Holger Schroeder <[e-mail]>
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License version 2 as published by the Free Software Foundation.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this library; see the file COPYING.LIB.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
-*/
-
-/*
-	This class implements a kioslave to access ZIP files from KDE.
-	you can use it in QIODevice::ReadOnly or in QIODevice::WriteOnly mode, and it
-	behaves just as expected (i hope ;-) ).
-	It can also be used in QIODevice::ReadWrite mode, in this case one can
-	append files to an existing zip archive. when you append new files, which
-	are not yet in the zip, it works as expected, they are appended at the end.
-	when you append a file, which is already in the file, the reference to the
-	old file is dropped and the new one is added to the zip. but the
-	old data from the file itself is not deleted, it is still in the
-	zipfile. so when you want to have a small and garbagefree zipfile,
-	just read the contents of the appended zipfile and write it to a new one
-	in QIODevice::WriteOnly mode. especially take care of this, when you don't want
-	to leak information of how intermediate versions of files in the zip
-	were looking.
-	For more information on the zip fileformat go to
-	http://www.pkware.com/support/appnote.html .
-
-*/
-
-#include "kzip.h"
-#include "kfilterdev.h"
-#include "klimitediodevice.h"
-
-#include <QtCore/QHash>
-#include <QtCore/QByteArray>
-#include <QtCore/QFile>
-#include <QtCore/QDir>
-#include <QtCore/QDate>
-#include <QtCore/QList>
-#include <QDebug>
-
-#include <zlib.h>
-#include <time.h>
-#include <string.h>
-#include <sys/stat.h>
-
-#ifdef Q_OS_WIN
-#include "kdewin32/sys/stat.h"
-#endif
-
-const int max_path_len = 4095;	// maximum number of character a path may contain
-
-static void transformToMsDos(const QDateTime& dt, char* buffer)
-{
-	if ( dt.isValid() )
-	{
-		const quint16 time =
-			 ( dt.time().hour() << 11 )    // 5 bit hour
-		   | ( dt.time().minute() << 5 )   // 6 bit minute
-		   | ( dt.time().second() >> 1 );  // 5 bit double seconds
-
-		buffer[0] = char(time);
-		buffer[1] = char(time >> 8);
-
-		const quint16 date =
-			 ( ( dt.date().year() - 1980 ) << 9 ) // 7 bit year 1980-based
-		   | ( dt.date().month() << 5 )           // 4 bit month
-		   | ( dt.date().day() );                 // 5 bit day
-
-		buffer[2] = char(date);
-		buffer[3] = char(date >> 8);
-	}
-	else // !dt.isValid(), assume 1980-01-01 midnight
-	{
-		buffer[0] = 0;
-		buffer[1] = 0;
-		buffer[2] = 33;
-		buffer[3] = 0;
-	}
-}
-
-static time_t transformFromMsDos(const char* buffer)
-{
-	quint16 time = (uchar)buffer[0] | ( (uchar)buffer[1] << 8 );
-	int h = time >> 11;
-	int m = ( time & 0x7ff ) >> 5;
-	int s = ( time & 0x1f ) * 2 ;
-	QTime qt(h, m, s);
-
-	quint16 date = (uchar)buffer[2] | ( (uchar)buffer[3] << 8 );
-	int y = ( date >> 9 ) + 1980;
-	int o = ( date & 0x1ff ) >> 5;
-	int d = ( date & 0x1f );
-	QDate qd(y, o, d);
-
-	QDateTime dt( qd, qt );
-	return dt.toTime_t();
-}
-
-// == parsing routines for zip headers
-
-/** all relevant information about parsing file information */
-struct ParseFileInfo {
-  // file related info
-  mode_t perm;			// permissions of this file
-  time_t atime;			// last access time (UNIX format)
-  time_t mtime;			// modification time (UNIX format)
-  time_t ctime;			// creation time (UNIX format)
-  int uid;			// user id (-1 if not specified)
-  int gid;			// group id (-1 if not specified)
-  QByteArray guessed_symlink;	// guessed symlink target
-  int extralen;			// length of extra field
-
-  // parsing related info
-  bool exttimestamp_seen;	// true if extended timestamp extra field
-				// has been parsed
-  bool newinfounix_seen;	// true if Info-ZIP Unix New extra field has
-				// been parsed
-
-  ParseFileInfo() : perm(0100644), uid(-1), gid(-1), extralen(0),
-	exttimestamp_seen(false), newinfounix_seen(false) {
-	ctime = mtime = atime = time(0);
-  }
-};
-
-/** updates the parse information with the given extended timestamp extra field.
-  * @param buffer start content of buffer known to contain an extended
-  *	timestamp extra field (without magic & size)
-  * @param size size of field content (must not count magic and size entries)
-  * @param islocal true if this is a local field, false if central
-  * @param pfi ParseFileInfo object to be updated
-  * @return true if processing was successful
-  */
-static bool parseExtTimestamp(const char *buffer, int size, bool islocal,
-			ParseFileInfo &pfi) {
-  if (size < 1) {
-	qDebug() << "premature end of extended timestamp (#1)";
-	return false;
-  }/*end if*/
-  int flags = *buffer;		// read flags
-  buffer += 1;
-  size -= 1;
-
-  if (flags & 1) {		// contains modification time
-	if (size < 4) {
-	  qDebug() << "premature end of extended timestamp (#2)";
-	  return false;
-	}/*end if*/
-	pfi.mtime = time_t((uchar)buffer[0] | (uchar)buffer[1] << 8
-				| (uchar)buffer[2] << 16 | (uchar)buffer[3] << 24);
-	buffer += 4;
-	size -= 4;
-  }/*end if*/
-  // central extended field cannot contain more than the modification time
-  // even if other flags are set
-  if (!islocal) {
-	pfi.exttimestamp_seen = true;
-	return true;
-  }/*end if*/
-
-  if (flags & 2) {		// contains last access time
-	if (size < 4) {
-	  qDebug() << "premature end of extended timestamp (#3)";
-	  return true;
-	}/*end if*/
-	pfi.atime = time_t((uchar)buffer[0] | (uchar)buffer[1] << 8
-				| (uchar)buffer[2] << 16 | (uchar)buffer[3] << 24);
-	buffer += 4;
-	size -= 4;
-  }/*end if*/
-
-  if (flags & 4) {		// contains creation time
-	if (size < 4) {
-	  qDebug() << "premature end of extended timestamp (#4)";
-	  return true;
-	}/*end if*/
-	pfi.ctime = time_t((uchar)buffer[0] | (uchar)buffer[1] << 8
-				| (uchar)buffer[2] << 16 | (uchar)buffer[3] << 24);
-	buffer += 4;
-  }/*end if*/
-
-  pfi.exttimestamp_seen = true;
-  return true;
-}
-
-/** updates the parse information with the given Info-ZIP Unix old extra field.
-  * @param buffer start of content of buffer known to contain an Info-ZIP
-  *	Unix old extra field (without magic & size)
-  * @param size size of field content (must not count magic and size entries)
-  * @param islocal true if this is a local field, false if central
-  * @param pfi ParseFileInfo object to be updated
-  * @return true if processing was successful
-  */
-static bool parseInfoZipUnixOld(const char *buffer, int size, bool islocal,
-			ParseFileInfo &pfi) {
-  // spec mandates to omit this field if one of the newer fields are available
-  if (pfi.exttimestamp_seen || pfi.newinfounix_seen) return true;
-
-  if (size < 8) {
-	qDebug() << "premature end of Info-ZIP unix extra field old";
-	return false;
-  }/*end if*/
-
-  pfi.atime = time_t((uchar)buffer[0] | (uchar)buffer[1] << 8
-				| (uchar)buffer[2] << 16 | (uchar)buffer[3] << 24);
-  buffer += 4;
-  pfi.mtime = time_t((uchar)buffer[0] | (uchar)buffer[1] << 8
-				| (uchar)buffer[2] << 16 | (uchar)buffer[3] << 24);
-  buffer += 4;
-  if (islocal && size >= 12) {
-	pfi.uid = (uchar)buffer[0] | (uchar)buffer[1] << 8;
-	buffer += 2;
-	pfi.gid = (uchar)buffer[0] | (uchar)buffer[1] << 8;
-	buffer += 2;
-  }/*end if*/
-  return true;
-}
-
-#if 0 // not needed yet
-/** updates the parse information with the given Info-ZIP Unix new extra field.
-  * @param buffer start of content of buffer known to contain an Info-ZIP
-  *		Unix new extra field (without magic & size)
-  * @param size size of field content (must not count magic and size entries)
-  * @param islocal true if this is a local field, false if central
-  * @param pfi ParseFileInfo object to be updated
-  * @return true if processing was successful
-  */
-static bool parseInfoZipUnixNew(const char *buffer, int size, bool islocal,
-			ParseFileInfo &pfi) {
-  if (!islocal) {	// contains nothing in central field
-	pfi.newinfounix = true;
-	return true;
-  }/*end if*/
-
-  if (size < 4) {
-	qDebug() << "premature end of Info-ZIP unix extra field new";
-	return false;
-  }/*end if*/
-
-  pfi.uid = (uchar)buffer[0] | (uchar)buffer[1] << 8;
-  buffer += 2;
-  pfi.gid = (uchar)buffer[0] | (uchar)buffer[1] << 8;
-  buffer += 2;
-
-  pfi.newinfounix = true;
-  return true;
-}
-#endif
-
-/**
- * parses the extra field
- * @param buffer start of buffer where the extra field is to be found
- * @param size size of the extra field
- * @param islocal true if this is part of a local header, false if of central
- * @param pfi ParseFileInfo object which to write the results into
- * @return true if parsing was successful
- */
-static bool parseExtraField(const char *buffer, int size, bool islocal,
-			ParseFileInfo &pfi) {
-  // extra field in central directory doesn't contain useful data, so we
-  // don't bother parsing it
-  if (!islocal) return true;
-
-  while (size >= 4) {	// as long as a potential extra field can be read
-	int magic = (uchar)buffer[0] | (uchar)buffer[1] << 8;
-	buffer += 2;
-	int fieldsize = (uchar)buffer[0] | (uchar)buffer[1] << 8;
-	buffer += 2;
-	size -= 4;
-
-	if (fieldsize > size) {
-	  //qDebug() << "fieldsize: " << fieldsize << " size: " << size;
-	  qDebug() << "premature end of extra fields reached";
-	  break;
-	}/*end if*/
-
-	switch (magic) {
-	  case 0x5455:		// extended timestamp
-		if (!parseExtTimestamp(buffer, fieldsize, islocal, pfi)) return false;
-	break;
-	  case 0x5855:		// old Info-ZIP unix extra field
-		if (!parseInfoZipUnixOld(buffer, fieldsize, islocal, pfi)) return false;
-	break;
-#if 0	// not needed yet
-	  case 0x7855:		// new Info-ZIP unix extra field
-		if (!parseInfoZipUnixNew(buffer, fieldsize, islocal, pfi)) return false;
-	break;
-#endif
-	  default:
-		/* ignore everything else */;
-	}/*end switch*/
-
-	buffer += fieldsize;
-	size -= fieldsize;
-  }/*wend*/
-  return true;
-}
-
-////////////////////////////////////////////////////////////////////////
-/////////////////////////// KZip ///////////////////////////////////////
-////////////////////////////////////////////////////////////////////////
-
-class KZip::KZipPrivate
-{
-public:
-	KZipPrivate()
-		: m_crc( 0 ),
-		  m_currentFile( 0 ),
-		  m_currentDev( 0 ),
-		  m_compression( 8 ),
-		  m_extraField( KZip::NoExtraField ),
-	  m_offset( 0 )
-	{}
-
-	unsigned long           m_crc;         // checksum
-	KZipFileEntry*          m_currentFile; // file currently being written
-	QIODevice*              m_currentDev;  // filterdev used to write to the above file
-	QList<KZipFileEntry*> m_fileList;    // flat list of all files, for the index (saves a recursive method ;)
-	int                     m_compression;
-	KZip::ExtraField        m_extraField;
-	// m_offset holds the offset of the place in the zip,
-	// where new data can be appended. after openarchive it points to 0, when in
-	// writeonly mode, or it points to the beginning of the central directory.
-	// each call to writefile updates this value.
-	unsigned int            m_offset;
-};
-
-KZip::KZip( const QString& fileName )
-	: KArchive( fileName ),d(new KZipPrivate)
-{
-}
-
-KZip::KZip( QIODevice * dev )
-	: KArchive( dev ),d(new KZipPrivate)
-{
-}
-
-KZip::~KZip()
-{
-	//qDebug() << this;
-	if( isOpen() )
-		close();
-	delete d;
-}
-
-bool KZip::openArchive( QIODevice::OpenMode mode )
-{
-	//qDebug();
-	d->m_fileList.clear();
-
-	if ( mode == QIODevice::WriteOnly )
-		return true;
-
-	char buffer[47];
-
-	// Check that it's a valid ZIP file
-	// KArchive::open() opened the underlying device already.
-
-	uint offset = 0; // holds offset, where we read
-	int n;
-
-	// contains information gathered from the local file headers
-	QHash<QByteArray, ParseFileInfo> pfi_map;
-
-	QIODevice* dev = device();
-
-	// We set a bool for knowing if we are allowed to skip the start of the file
-	bool startOfFile = true;
-
-	for (;;) // repeat until 'end of entries' signature is reached
-	{
-		//qDebug() << "loop starts";
-		//qDebug() << "dev->pos() now : " << dev->pos();
-		n = dev->read( buffer, 4 );
-
-		if (n < 4)
-		{
-			qWarning() << "Invalid ZIP file. Unexpected end of file. (#1)";
-
-			return false;
-		}
-
-		if ( !memcmp( buffer, "PK\5\6", 4 ) ) // 'end of entries'
-		{
-		//qDebug() << "PK56 found end of archive";
-			startOfFile = false;
-		break;
-	}
-
-	if ( !memcmp( buffer, "PK\3\4", 4 ) ) // local file header
-		{
-		//qDebug() << "PK34 found local file header";
-			startOfFile = false;
-			// can this fail ???
-		dev->seek( dev->pos() + 2 ); // skip 'version needed to extract'
-
-		// read static header stuff
-			n = dev->read( buffer, 24 );
-		if (n < 24) {
-				qWarning() << "Invalid ZIP file. Unexpected end of file. (#4)";
-				return false;
-		}
-
-		int gpf = (uchar)buffer[0];	// "general purpose flag" not "general protection fault" ;-)
-		int compression_mode = (uchar)buffer[2] | (uchar)buffer[3] << 8;
-		time_t mtime = transformFromMsDos( buffer+4 );
-
-		qint64 compr_size = (uchar)buffer[12] | (uchar)buffer[13] << 8
-					| (uchar)buffer[14] << 16 | (uchar)buffer[15] << 24;
-		qint64 uncomp_size = (uchar)buffer[16] | (uchar)buffer[17] << 8
-					| (uchar)buffer[18] << 16 | (uchar)buffer[19] << 24;
-		int namelen = (uchar)buffer[20] | (uchar)buffer[21] << 8;
-		int extralen = (uchar)buffer[22] | (uchar)buffer[23] << 8;
-
-			/*
-		qDebug() << "general purpose bit flag: " << gpf;
-		qDebug() << "compressed size: " << compr_size;
-		qDebug() << "uncompressed size: " << uncomp_size;
-		qDebug() << "namelen: " << namelen;
-		qDebug() << "extralen: " << extralen;
-		qDebug() << "archive size: " << dev->size();
-		*/
-
-		// read fileName
-			Q_ASSERT( namelen > 0 );
-		QByteArray fileName = dev->read(namelen);
-			if ( fileName.size() < namelen ) {
-				qWarning() << "Invalid ZIP file. Name not completely read (#2)";
-		return false;
-		}
-
-		ParseFileInfo pfi;
-		pfi.mtime = mtime;
-
-			// read and parse the beginning of the extra field,
-			// skip rest of extra field in case it is too long
-			unsigned int extraFieldEnd = dev->pos() + extralen;
-		pfi.extralen = extralen;
-		int handledextralen = qMin(extralen, (int)sizeof buffer);
-
-			//if ( handledextralen )
-			//    qDebug() << "handledextralen: " << handledextralen;
-
-		n = dev->read(buffer, handledextralen);
-		// no error msg necessary as we deliberately truncate the extra field
-		if (!parseExtraField(buffer, handledextralen, true, pfi))
-		{
-			qWarning() << "Invalid ZIP File. Broken ExtraField.";
-			return false;
-		}
-
-			// jump to end of extra field
-			dev->seek( extraFieldEnd );
-
-		// we have to take care of the 'general purpose bit flag'.
-			// if bit 3 is set, the header doesn't contain the length of
-			// the file and we look for the signature 'PK\7\8'.
-			if ( gpf & 8 )
-			{
-			// here we have to read through the compressed data to find
-		// the next PKxx
-			qDebug() << "trying to seek for next PK78";
-				bool foundSignature = false;
-
-				while (!foundSignature)
-				{
-					n = dev->read( buffer, 1 );
-					if (n < 1)
-					{
-						qWarning() << "Invalid ZIP file. Unexpected end of file. (#2)";
-						return false;
-					}
-
-					if ( buffer[0] != 'P' )
-						continue;
-
-					n = dev->read( buffer, 3 );
-					if (n < 3)
-					{
-						qWarning() << "Invalid ZIP file. Unexpected end of file. (#3)";
-						return false;
-					}
-
-					// we have to detect three magic tokens here:
-			// PK34 for the next local header in case there is no data descriptor
-			// PK12 for the central header in case there is no data descriptor
-			// PK78 for the data descriptor in case it is following the compressed data
-
-			if ( buffer[0] == 'K' && buffer[1] == 7 && buffer[2] == 8 )
-					{
-						foundSignature = true;
-						dev->seek( dev->pos() + 12 ); // skip the 'data_descriptor'
-					}
-			else if ( ( buffer[0] == 'K' && buffer[1] == 1 && buffer[2] == 2 )
-				 || ( buffer[0] == 'K' && buffer[1] == 3 && buffer[2] == 4 ) )
-					{
-						foundSignature = true;
-						dev->seek( dev->pos() - 4 ); // go back 4 bytes, so that the magic bytes can be found...
-					}
-					else if ( buffer[0] == 'P' || buffer[1] == 'P' || buffer[2] == 'P' )
-					{
-						// We have another P character so we must go back a little to check if it is a magic
-						dev->seek( dev->pos() - 3 );
-					}
-
-				}
-			}
-			else
-			{
-			// here we skip the compressed data and jump to the next header
-			//qDebug() << "general purpose bit flag indicates, that local file header contains valid size";
-		// check if this could be a symbolic link
-		if (compression_mode == NoCompression
-				&& uncomp_size <= max_path_len
-			&& uncomp_size > 0) {
-			// read content and store it
-					// If it's not a symlink, then we'll just discard the data for now.
-			pfi.guessed_symlink = dev->read(uncomp_size);
-			if (pfi.guessed_symlink.size() < uncomp_size) {
-			qWarning() << "Invalid ZIP file. Unexpected end of file. (#5)";
-			return false;
-			}
-		} else {
-
-				if ( compr_size > dev->size() )
-			{
-				// here we cannot trust the compressed size, so scan through the compressed
-			// data to find the next header
-			bool foundSignature = false;
-
-			while (!foundSignature)
-			{
-				n = dev->read( buffer, 1 );
-				if (n < 1)
-				{
-					qWarning() << "Invalid ZIP file. Unexpected end of file. (#2)";
-					return false;
-				}
-
-				if ( buffer[0] != 'P' )
-					continue;
-
-				n = dev->read( buffer, 3 );
-				if (n < 3)
-				{
-					qWarning() << "Invalid ZIP file. Unexpected end of file. (#3)";
-					return false;
-				}
-
-				// we have to detect three magic tokens here:
-				// PK34 for the next local header in case there is no data descriptor
-				// PK12 for the central header in case there is no data descriptor
-				// PK78 for the data descriptor in case it is following the compressed data
-
-				if ( buffer[0] == 'K' && buffer[1] == 7 && buffer[2] == 8 )
-				{
-					foundSignature = true;
-					dev->seek( dev->pos() + 12 ); // skip the 'data_descriptor'
-				}
-
-				if ( ( buffer[0] == 'K' && buffer[1] == 1 && buffer[2] == 2 )
-					|| ( buffer[0] == 'K' && buffer[1] == 3 && buffer[2] == 4 ) )
-				{
-					foundSignature = true;
-					dev->seek( dev->pos() - 4 );
-					// go back 4 bytes, so that the magic bytes can be found
-					// in the next cycle...
-				}
-			}
-			}
-			else
-			{
-// 			qDebug() << "before interesting dev->pos(): " << dev->pos();
-			bool success = dev->seek( dev->pos() + compr_size ); // can this fail ???
-			static_cast<void>(success); // annoying unused variable warning
-						Q_ASSERT( success ); // let's see...
-/*			qDebug() << "after interesting dev->pos(): " << dev->pos();
-			if ( success )
-				qDebug() << "dev->at was successful... ";
-			else
-				qDebug() << "dev->at failed... ";*/
-			}
-
-		}
-
-// not needed any more
-/*                // here we calculate the length of the file in the zip
-				// with headers and jump to the next header.
-				uint skip = compr_size + namelen + extralen;
-				offset += 30 + skip;*/
-			}
-			pfi_map.insert(fileName, pfi);
-		}
-		else if ( !memcmp( buffer, "PK\1\2", 4 ) ) // central block
-		{
-		//qDebug() << "PK12 found central block";
-			startOfFile = false;
-
-			// so we reached the central header at the end of the zip file
-			// here we get all interesting data out of the central header
-			// of a file
-			offset = dev->pos() - 4;
-
-			//set offset for appending new files
-			if ( d->m_offset == 0L ) d->m_offset = offset;
-
-			n = dev->read( buffer + 4, 42 );
-			if (n < 42) {
-				qWarning() << "Invalid ZIP file, central entry too short"; // not long enough for valid entry
-				return false;
-			}
-
-			//int gpf = (uchar)buffer[9] << 8 | (uchar)buffer[10];
-			//kDebug() << "general purpose flag=" << gpf;
-			// length of the fileName (well, pathname indeed)
-			int namelen = (uchar)buffer[29] << 8 | (uchar)buffer[28];
-			Q_ASSERT( namelen > 0 );
-			QByteArray bufferName = dev->read( namelen );
-			if ( bufferName.size() < namelen )
-				qWarning() << "Invalid ZIP file. Name not completely read";
-
-			ParseFileInfo pfi = pfi_map.value( bufferName, ParseFileInfo() );
-
-			QString name( QFile::decodeName(bufferName) );
-
-			//qDebug() << "name: " << name;
-			// only in central header ! see below.
-			// length of extra attributes
-			int extralen = (uchar)buffer[31] << 8 | (uchar)buffer[30];
-			// length of comment for this file
-			int commlen =  (uchar)buffer[33] << 8 | (uchar)buffer[32];
-			// compression method of this file
-			int cmethod =  (uchar)buffer[11] << 8 | (uchar)buffer[10];
-
-			//qDebug() << "cmethod: " << cmethod;
-			//qDebug() << "extralen: " << extralen;
-
-			// crc32 of the file
-			uint crc32 = (uchar)buffer[19] << 24 | (uchar)buffer[18] << 16 |
-					   (uchar)buffer[17] << 8 | (uchar)buffer[16];
-
-			// uncompressed file size
-			uint ucsize = (uchar)buffer[27] << 24 | (uchar)buffer[26] << 16 |
-				(uchar)buffer[25] << 8 | (uchar)buffer[24];
-			// compressed file size
-			uint csize = (uchar)buffer[23] << 24 | (uchar)buffer[22] << 16 |
-				(uchar)buffer[21] << 8 | (uchar)buffer[20];
-
-			// offset of local header
-			uint localheaderoffset = (uchar)buffer[45] << 24 | (uchar)buffer[44] << 16 |
-				(uchar)buffer[43] << 8 | (uchar)buffer[42];
-
-			// some clever people use different extra field lengths
-			// in the central header and in the local header... funny.
-			// so we need to get the localextralen to calculate the offset
-			// from localheaderstart to dataoffset
-			int localextralen = pfi.extralen; // FIXME: this will not work if
-							// no local header exists
-
-			//qDebug() << "localextralen: " << localextralen;
-
-			// offset, where the real data for uncompression starts
-			uint dataoffset = localheaderoffset + 30 + localextralen + namelen; //comment only in central header
-
-			//qDebug() << "esize: " << esize;
-			//qDebug() << "eoffset: " << eoffset;
-			//qDebug() << "csize: " << csize;
-
-		int os_madeby = (uchar)buffer[5];
-			bool isdir = false;
-			int access = 0100644;
-
-		if (os_madeby == 3) {	// good ole unix
-			access = (uchar)buffer[40] | (uchar)buffer[41] << 8;
-		}
-
-			QString entryName;
-
-			if ( name.endsWith( '/' ) ) // Entries with a trailing slash are directories
-			{
-				isdir = true;
-				name = name.left( name.length() - 1 );
-				if (os_madeby != 3) access = S_IFDIR | 0755;
-		else Q_ASSERT(access & S_IFDIR);
-			}
-
-			int pos = name.lastIndexOf( '/' );
-			if ( pos == -1 )
-				entryName = name;
-			else
-				entryName = name.mid( pos + 1 );
-			Q_ASSERT( !entryName.isEmpty() );
-
-			KArchiveEntry* entry;
-			if ( isdir )
-			{
-				QString path = QDir::cleanPath( name );
-				const KArchiveEntry* ent = rootDir()->entry( path );
-				if ( ent && ent->isDirectory() )
-				{
-					//qDebug() << "Directory already exists, NOT going to add it again";
-					entry = 0;
-				}
-				else
-				{
-					entry = new KArchiveDirectory( this, entryName, access, (int)pfi.mtime, rootDir()->user(), rootDir()->group(), QString() );
-					//qDebug() << "KArchiveDirectory created, entryName= " << entryName << ", name=" << name;
-				}
-		}
-			else
-			{
-			QString symlink;
-		if (S_ISLNK(access)) {
-			symlink = QFile::decodeName(pfi.guessed_symlink);
-		}
-				entry = new KZipFileEntry( this, entryName, access, pfi.mtime,
-					rootDir()->user(), rootDir()->group(),
-					symlink, name, dataoffset,
-					ucsize, cmethod, csize );
-				static_cast<KZipFileEntry *>(entry)->setHeaderStart( localheaderoffset );
-				static_cast<KZipFileEntry*>(entry)->setCRC32(crc32);
-				//qDebug() << "KZipFileEntry created, entryName= " << entryName << ", name=" << name;
-				d->m_fileList.append( static_cast<KZipFileEntry *>( entry ) );
-			}
-
-			if ( entry )
-			{
-				if ( pos == -1 )
-				{
-					rootDir()->addEntry(entry);
-				}
-				else
-				{
-					// In some tar files we can find dir/./file => call cleanPath
-					QString path = QDir::cleanPath( name.left( pos ) );
-					// Ensure container directory exists, create otherwise
-					KArchiveDirectory * tdir = findOrCreate( path );
-					tdir->addEntry(entry);
-				}
-			}
-
-			//calculate offset to next entry
-			offset += 46 + commlen + extralen + namelen;
-			bool b = dev->seek(offset);
-			Q_ASSERT( b );
-			if ( !b )
-			  return false;
-		}
-		else if ( startOfFile )
-		{
-			// The file does not start with any ZIP header (e.g. self-extractable ZIP files)
-			// Therefore we need to find the first PK\003\004 (local header)
-			qDebug() << "Try to skip start of file";
-			startOfFile = false;
-			bool foundSignature = false;
-
-			while (!foundSignature)
-			{
-				n = dev->read( buffer, 1 );
-				if (n < 1)
-				{
-					qWarning() << "Invalid ZIP file. Unexpected end of file. " ;
-					return false;
-				}
-
-				if ( buffer[0] != 'P' )
-					continue;
-
-				n = dev->read( buffer, 3 );
-				if (n < 3)
-				{
-					qWarning() << "Invalid ZIP file. Unexpected end of file. " ;
-					return false;
-				}
-
-				// We have to detect the magic token for a local header: PK\003\004
-				/*
-				 * Note: we do not need to check the other magics, if the ZIP file has no
-				 * local header, then it has not any files!
-				 */
-				if ( buffer[0] == 'K' && buffer[1] == 3 && buffer[2] == 4 )
-				{
-					foundSignature = true;
-					dev->seek( dev->pos() - 4 ); // go back 4 bytes, so that the magic bytes can be found...
-				}
-				else if ( buffer[0] == 'P' || buffer[1] == 'P' || buffer[2] == 'P' )
-				{
-						// We have another P character so we must go back a little to check if it is a magic
-					dev->seek( dev->pos() - 3 );
-				}
-			}
-		}
-		else
-		{
-			qWarning() << "Invalid ZIP file. Unrecognized header at offset " << offset;
-
-			return false;
-		}
-	}
-	//qDebug() << "*** done *** ";
-	return true;
-}
-
-bool KZip::closeArchive()
-{
-	if ( ! ( mode() & QIODevice::WriteOnly ) )
-	{
-		//qDebug() << "readonly";
-		return true;
-	}
-
-	//ReadWrite or WriteOnly
-	//write all central dir file entries
-
-	// to be written at the end of the file...
-	char buffer[ 22 ]; // first used for 12, then for 22 at the end
-	uLong crc = crc32(0L, Z_NULL, 0);
-
-	qint64 centraldiroffset = device()->pos();
-	//qDebug() << "closearchive: centraldiroffset: " << centraldiroffset;
-	qint64 atbackup = centraldiroffset;
-	QMutableListIterator<KZipFileEntry*> it( d->m_fileList );
-
-	while(it.hasNext())
-	{	//set crc and compressed size in each local file header
-		it.next();
-		if ( !device()->seek( it.value()->headerStart() + 14 ) )
-			return false;
-	//qDebug() << "closearchive setcrcandcsize: fileName:"
-	//    << it.current()->path()
-	//    << "encoding:" << it.current()->encoding();
-
-		uLong mycrc = it.value()->crc32();
-		buffer[0] = char(mycrc); // crc checksum, at headerStart+14
-		buffer[1] = char(mycrc >> 8);
-		buffer[2] = char(mycrc >> 16);
-		buffer[3] = char(mycrc >> 24);
-
-		int mysize1 = it.value()->compressedSize();
-		buffer[4] = char(mysize1); // compressed file size, at headerStart+18
-		buffer[5] = char(mysize1 >> 8);
-		buffer[6] = char(mysize1 >> 16);
-		buffer[7] = char(mysize1 >> 24);
-
-		int myusize = it.value()->size();
-		buffer[8] = char(myusize); // uncompressed file size, at headerStart+22
-		buffer[9] = char(myusize >> 8);
-		buffer[10] = char(myusize >> 16);
-		buffer[11] = char(myusize >> 24);
-
-		if ( device()->write( buffer, 12 ) != 12 )
-			return false;
-	}
-	device()->seek( atbackup );
-
-	it.toFront();
-	while (it.hasNext())
-	{
-	it.next();
-		//qDebug() << "fileName:" << it.current()->path()
-		//              << "encoding:" << it.current()->encoding();
-
-		QByteArray path = QFile::encodeName(it.value()->path());
-
-	const int extra_field_len = 9;
-		int bufferSize = extra_field_len + path.length() + 46;
-		char* buffer = new char[ bufferSize ];
-
-		memset(buffer, 0, 46); // zero is a nice default for most header fields
-
-		const char head[] =
-		{
-			'P', 'K', 1, 2, // central file header signature
-			0x14, 3,        // version made by (3 == UNIX)
-			0x14, 0         // version needed to extract
-		};
-
-	// I do not know why memcpy is not working here
-		//memcpy(buffer, head, sizeof(head));
-		memmove(buffer, head, sizeof(head));
-
-		buffer[ 10 ] = char(it.value()->encoding()); // compression method
-		buffer[ 11 ] = char(it.value()->encoding() >> 8);
-
-		transformToMsDos( it.value()->datetime(), &buffer[ 12 ] );
-
-		uLong mycrc = it.value()->crc32();
-		buffer[ 16 ] = char(mycrc); // crc checksum
-		buffer[ 17 ] = char(mycrc >> 8);
-		buffer[ 18 ] = char(mycrc >> 16);
-		buffer[ 19 ] = char(mycrc >> 24);
-
-		int mysize1 = it.value()->compressedSize();
-		buffer[ 20 ] = char(mysize1); // compressed file size
-		buffer[ 21 ] = char(mysize1 >> 8);
-		buffer[ 22 ] = char(mysize1 >> 16);
-		buffer[ 23 ] = char(mysize1 >> 24);
-
-		int mysize = it.value()->size();
-		buffer[ 24 ] = char(mysize); // uncompressed file size
-		buffer[ 25 ] = char(mysize >> 8);
-		buffer[ 26 ] = char(mysize >> 16);
-		buffer[ 27 ] = char(mysize >> 24);
-
-		buffer[ 28 ] = char(it.value()->path().length()); // fileName length
-		buffer[ 29 ] = char(it.value()->path().length() >> 8);
-
-	buffer[ 30 ] = char(extra_field_len);
-	buffer[ 31 ] = char(extra_field_len >> 8);
-
-	buffer[ 40 ] = char(it.value()->permissions());
-	buffer[ 41 ] = char(it.value()->permissions() >> 8);
-
-		int myhst = it.value()->headerStart();
-		buffer[ 42 ] = char(myhst); //relative offset of local header
-		buffer[ 43 ] = char(myhst >> 8);
-		buffer[ 44 ] = char(myhst >> 16);
-		buffer[ 45 ] = char(myhst >> 24);
-
-		// file name
-		strncpy( buffer + 46, path, path.length() );
-	//qDebug() << "closearchive length to write: " << bufferSize;
-
-	// extra field
-	char *extfield = buffer + 46 + path.length();
-	extfield[0] = 'U';
-	extfield[1] = 'T';
-	extfield[2] = 5;
-	extfield[3] = 0;
-	extfield[4] = 1 | 2 | 4;	// specify flags from local field
-					// (unless I misread the spec)
-	// provide only modification time
-	unsigned long time = (unsigned long)it.value()->date();
-	extfield[5] = char(time);
-	extfield[6] = char(time >> 8);
-	extfield[7] = char(time >> 16);
-	extfield[8] = char(time >> 24);
-
-		crc = crc32(crc, (Bytef *)buffer, bufferSize );
-		bool ok = ( device()->write( buffer, bufferSize ) == bufferSize );
-		delete[] buffer;
-		if ( !ok )
-			return false;
-	}
-	qint64 centraldirendoffset = device()->pos();
-	//qDebug() << "closearchive: centraldirendoffset: " << centraldirendoffset;
-	//qDebug() << "closearchive: device()->pos(): " << device()->pos();
-
-	//write end of central dir record.
-	buffer[ 0 ] = 'P'; //end of central dir signature
-	buffer[ 1 ] = 'K';
-	buffer[ 2 ] = 5;
-	buffer[ 3 ] = 6;
-
-	buffer[ 4 ] = 0; // number of this disk
-	buffer[ 5 ] = 0;
-
-	buffer[ 6 ] = 0; // number of disk with start of central dir
-	buffer[ 7 ] = 0;
-
-	int count = d->m_fileList.count();
-	//qDebug() << "number of files (count): " << count;
-
-
-	buffer[ 8 ] = char(count); // total number of entries in central dir of
-	buffer[ 9 ] = char(count >> 8); // this disk
-
-	buffer[ 10 ] = buffer[ 8 ]; // total number of entries in the central dir
-	buffer[ 11 ] = buffer[ 9 ];
-
-	int cdsize = centraldirendoffset - centraldiroffset;
-	buffer[ 12 ] = char(cdsize); // size of the central dir
-	buffer[ 13 ] = char(cdsize >> 8);
-	buffer[ 14 ] = char(cdsize >> 16);
-	buffer[ 15 ] = char(cdsize >> 24);
-
-	//qDebug() << "end : centraldiroffset: " << centraldiroffset;
-	//qDebug() << "end : centraldirsize: " << cdsize;
-
-	buffer[ 16 ] = char(centraldiroffset); // central dir offset
-	buffer[ 17 ] = char(centraldiroffset >> 8);
-	buffer[ 18 ] = char(centraldiroffset >> 16);
-	buffer[ 19 ] = char(centraldiroffset >> 24);
-
-	buffer[ 20 ] = 0; //zipfile comment length
-	buffer[ 21 ] = 0;
-
-	if ( device()->write( buffer, 22 ) != 22 )
-		return false;
-
-	return true;
-}
-
-bool KZip::doWriteDir( const QString&, const QString&, const QString&,
-					   mode_t, time_t, time_t, time_t ) {
-		return true;
-}
-
-bool KZip::doPrepareWriting(const QString &name, const QString &user,
-							   const QString &group, qint64 /*size*/, mode_t perm,
-							   time_t atime, time_t mtime, time_t ctime) {
-	//qDebug();
-	if ( !isOpen() )
-	{
-		qWarning( "KZip::writeFile: You must open the zip file before writing to it\n");
-		return false;
-	}
-
-	if ( ! ( mode() & QIODevice::WriteOnly ) ) // accept WriteOnly and ReadWrite
-	{
-		qWarning( "KZip::writeFile: You must open the zip file for writing\n");
-		return false;
-	}
-
-	Q_ASSERT( device() );
-
-	// set right offset in zip.
-	if ( !device()->seek( d->m_offset ) ) {
-		qWarning() << "doPrepareWriting: cannot seek in ZIP file. Disk full?";
-		return false;
-	}
-
-	// delete entries in the filelist with the same fileName as the one we want
-	// to save, so that we don't have duplicate file entries when viewing the zip
-	// with konqi...
-	// CAUTION: the old file itself is still in the zip and won't be removed !!!
-	QMutableListIterator<KZipFileEntry*> it( d->m_fileList );
-	//qDebug() << "fileName to write: " << name;
-	while(it.hasNext())
-	{
-		it.next();
-		//qDebug() << "prepfileName: " << it.current()->path();
-		if (name == it.value()->path() )
-		{
-			//qDebug() << "removing following entry: " << it.current()->path();
-		delete it.value();
-			it.remove();
-		}
-
-	}
-	// Find or create parent dir
-	KArchiveDirectory* parentDir = rootDir();
-	QString fileName( name );
-	int i = name.lastIndexOf( '/' );
-	if ( i != -1 )
-	{
-		QString dir = name.left( i );
-		fileName = name.mid( i + 1 );
-		//qDebug() << "ensuring" << dir << "exists. fileName=" << fileName;
-		parentDir = findOrCreate( dir );
-	}
-
-	// construct a KZipFileEntry and add it to list
-	KZipFileEntry * e = new KZipFileEntry( this, fileName, perm, mtime, user, group, QString(),
-										   name, device()->pos() + 30 + name.length(), // start
-										   0 /*size unknown yet*/, d->m_compression, 0 /*csize unknown yet*/ );
-	e->setHeaderStart( device()->pos() );
-	//qDebug() << "wrote file start: " << e->position() << " name: " << name;
-	parentDir->addEntry( e );
-
-	d->m_currentFile = e;
-	d->m_fileList.append( e );
-
-	int extra_field_len = 0;
-	if ( d->m_extraField == ModificationTime )
-		extra_field_len = 17;	// value also used in finishWriting()
-
-	// write out zip header
-	QByteArray encodedName = QFile::encodeName(name);
-	int bufferSize = extra_field_len + encodedName.length() + 30;
-	//qDebug() << "bufferSize=" << bufferSize;
-	char* buffer = new char[ bufferSize ];
-
-	buffer[ 0 ] = 'P'; //local file header signature
-	buffer[ 1 ] = 'K';
-	buffer[ 2 ] = 3;
-	buffer[ 3 ] = 4;
-
-	buffer[ 4 ] = 0x14; // version needed to extract
-	buffer[ 5 ] = 0;
-
-	buffer[ 6 ] = 0; // general purpose bit flag
-	buffer[ 7 ] = 0;
-
-	buffer[ 8 ] = char(e->encoding()); // compression method
-	buffer[ 9 ] = char(e->encoding() >> 8);
-
-	transformToMsDos( e->datetime(), &buffer[ 10 ] );
-
-	buffer[ 14 ] = 'C'; //dummy crc
-	buffer[ 15 ] = 'R';
-	buffer[ 16 ] = 'C';
-	buffer[ 17 ] = 'q';
-
-	buffer[ 18 ] = 'C'; //compressed file size
-	buffer[ 19 ] = 'S';
-	buffer[ 20 ] = 'I';
-	buffer[ 21 ] = 'Z';
-
-	buffer[ 22 ] = 'U'; //uncompressed file size
-	buffer[ 23 ] = 'S';
-	buffer[ 24 ] = 'I';
-	buffer[ 25 ] = 'Z';
-
-	buffer[ 26 ] = (uchar)(encodedName.length()); //fileName length
-	buffer[ 27 ] = (uchar)(encodedName.length() >> 8);
-
-	buffer[ 28 ] = (uchar)(extra_field_len); // extra field length
-	buffer[ 29 ] = (uchar)(extra_field_len >> 8);
-
-	// file name
-	strncpy( buffer + 30, encodedName, encodedName.length() );
-
-	// extra field
-	if ( d->m_extraField == ModificationTime )
-	{
-		char *extfield = buffer + 30 + encodedName.length();
-		// "Extended timestamp" header (0x5455)
-		extfield[0] = 'U';
-		extfield[1] = 'T';
-		extfield[2] = 13; // data size
-		extfield[3] = 0;
-		extfield[4] = 1 | 2 | 4;	// contains mtime, atime, ctime
-
-		extfield[5] = char(mtime);
-		extfield[6] = char(mtime >> 8);
-		extfield[7] = char(mtime >> 16);
-		extfield[8] = char(mtime >> 24);
-
-		extfield[9] = char(atime);
-		extfield[10] = char(atime >> 8);
-		extfield[11] = char(atime >> 16);
-		extfield[12] = char(atime >> 24);
-
-		extfield[13] = char(ctime);
-		extfield[14] = char(ctime >> 8);
-		extfield[15] = char(ctime >> 16);
-		extfield[16] = char(ctime >> 24);
-	}
-
-	// Write header
-	bool b = (device()->write( buffer, bufferSize ) == bufferSize );
-	d->m_crc = 0L;
-	delete[] buffer;
-
-	Q_ASSERT( b );
-	if (!b) {
-		return false;
-	}
-
-	// Prepare device for writing the data
-	// Either device() if no compression, or a KFilterDev to compress
-	if ( d->m_compression == 0 ) {
-		d->m_currentDev = device();
-		return true;
-	}
-
-	d->m_currentDev = KFilterDev::device( device(), "application/x-gzip", false );
-	Q_ASSERT( d->m_currentDev );
-	if ( !d->m_currentDev ) {
-		return false; // ouch
-	}
-	static_cast<KFilterDev *>(d->m_currentDev)->setSkipHeaders(); // Just zlib, not gzip
-
-	b = d->m_currentDev->open( QIODevice::WriteOnly );
-	Q_ASSERT( b );
-	return b;
-}
-
-bool KZip::doFinishWriting( qint64 size )
-{
-	if ( d->m_currentFile->encoding() == 8 ) {
-		// Finish
-		(void)d->m_currentDev->write( 0, 0 );
-		delete d->m_currentDev;
-	}
-	// If 0, d->m_currentDev was device() - don't delete ;)
-	d->m_currentDev = 0L;
-
-	Q_ASSERT( d->m_currentFile );
-	//qDebug() << "fileName: " << d->m_currentFile->path();
-	//qDebug() << "getpos (at): " << device()->pos();
-	d->m_currentFile->setSize(size);
-	int extra_field_len = 0;
-	if ( d->m_extraField == ModificationTime )
-		extra_field_len = 17;	// value also used in finishWriting()
-
-	int csize = device()->pos() -
-		d->m_currentFile->headerStart() - 30 -
-		d->m_currentFile->path().length() - extra_field_len;
-	d->m_currentFile->setCompressedSize(csize);
-	//qDebug() << "usize: " << d->m_currentFile->size();
-	//qDebug() << "csize: " << d->m_currentFile->compressedSize();
-	//qDebug() << "headerstart: " << d->m_currentFile->headerStart();
-
-	//qDebug() << "crc: " << d->m_crc;
-	d->m_currentFile->setCRC32( d->m_crc );
-
-	d->m_currentFile = 0L;
-
-	// update saved offset for appending new files
-	d->m_offset = device()->pos();
-	return true;
-}
-
-bool KZip::doWriteSymLink(const QString &name, const QString &target,
-						  const QString &user, const QString &group,
-						  mode_t perm, time_t atime, time_t mtime, time_t ctime) {
-  // reassure that symlink flag is set, otherwise strange things happen on
-  // extraction
-  perm |= S_IFLNK;
-  Compression c = compression();
-  setCompression(NoCompression);	// link targets are never compressed
-
-  if (!doPrepareWriting(name, user, group, 0, perm, atime, mtime, ctime)) {
-	qWarning() << "prepareWriting failed";
-	setCompression(c);
-	return false;
-  }
-
-  QByteArray symlink_target = QFile::encodeName(target);
-  if (!writeData(symlink_target, symlink_target.length())) {
-	qWarning() << "writeData failed";
-	setCompression(c);
-	return false;
-  }
-
-  if (!finishWriting(symlink_target.length())) {
-	qWarning() << "finishWriting failed";
-	setCompression(c);
-	return false;
-  }
-
-  setCompression(c);
-  return true;
-}
-
-void KZip::virtual_hook( int id, void* data )
-{
-	KArchive::virtual_hook( id, data );
-}
-
-bool KZip::writeData(const char * data, qint64 size)
-{
-	Q_ASSERT( d->m_currentFile );
-	Q_ASSERT( d->m_currentDev );
-	if (!d->m_currentFile || !d->m_currentDev) {
-		return false;
-	}
-
-	// crc to be calculated over uncompressed stuff...
-	// and they didn't mention it in their docs...
-	d->m_crc = crc32(d->m_crc, (const Bytef *) data , size);
-
-	qint64 written = d->m_currentDev->write( data, size );
-	//qDebug() << "wrote" << size << "bytes.";
-	return written == size;
-}
-
-void KZip::setCompression( Compression c )
-{
-	d->m_compression = ( c == NoCompression ) ? 0 : 8;
-}
-
-KZip::Compression KZip::compression() const
-{
-   return ( d->m_compression == 8 ) ? DeflateCompression : NoCompression;
-}
-
-void KZip::setExtraField( ExtraField ef )
-{
-	d->m_extraField = ef;
-}
-
-KZip::ExtraField KZip::extraField() const
-{
-	return d->m_extraField;
-}
-
-////////////////////////////////////////////////////////////////////////
-////////////////////// KZipFileEntry////////////////////////////////////
-////////////////////////////////////////////////////////////////////////
-class KZipFileEntry::KZipFileEntryPrivate
-{
-public:
-	KZipFileEntryPrivate()
-	: crc(0),
-	  compressedSize(0),
-	  headerStart(0),
-	  encoding(0)
-	{}
-	unsigned long crc;
-	qint64        compressedSize;
-	qint64        headerStart;
-	int           encoding;
-	QString       path;
-};
-
-KZipFileEntry::KZipFileEntry(KZip* zip, const QString& name, int access, int date,
-							 const QString& user, const QString& group, const QString& symlink,
-							 const QString& path, qint64 start, qint64 uncompressedSize,
-							 int encoding, qint64 compressedSize)
- : KArchiveFile(zip, name, access, date, user, group, symlink, start, uncompressedSize ),
-   d(new KZipFileEntryPrivate)
-{
-	d->path = path;
-	d->encoding = encoding;
-	d->compressedSize = compressedSize;
-}
-
-KZipFileEntry::~KZipFileEntry()
-{
-	delete d;
-}
-
-int KZipFileEntry::encoding() const
-{
-	return d->encoding;
-}
-
-qint64 KZipFileEntry::compressedSize() const
-{
-	return d->compressedSize;
-}
-
-void KZipFileEntry::setCompressedSize(qint64 compressedSize)
-{
-	d->compressedSize = compressedSize;
-}
-
-void KZipFileEntry::setHeaderStart(qint64 headerstart)
-{
-	d->headerStart = headerstart;
-}
-
-qint64 KZipFileEntry::headerStart() const
-{
-	return d->headerStart;
-}
-
-unsigned long KZipFileEntry::crc32() const
-{
-	return d->crc;
-}
-
-void KZipFileEntry::setCRC32(unsigned long crc32)
-{
-	d->crc=crc32;
-}
-
-const QString &KZipFileEntry::path() const
-{
-	return d->path;
-}
-
-QByteArray KZipFileEntry::data() const
-{
-	QIODevice* dev = createDevice();
-	QByteArray arr;
-	if ( dev ) {
-		arr = dev->readAll();
-		delete dev;
-	}
-	return arr;
-}
-
-QIODevice* KZipFileEntry::createDevice() const
-{
-	//qDebug() << "creating iodevice limited to pos=" << position() << ", csize=" << compressedSize();
-	// Limit the reading to the appropriate part of the underlying device (e.g. file)
-	KLimitedIODevice* limitedDev = new KLimitedIODevice( archive()->device(), position(), compressedSize() );
-	if ( encoding() == 0 || compressedSize() == 0 ) // no compression (or even no data)
-		return limitedDev;
-
-	if ( encoding() == 8 )
-	{
-		// On top of that, create a device that uncompresses the zlib data
-		QIODevice* filterDev = KFilterDev::device( limitedDev, "application/x-gzip" );
-		if ( !filterDev )
-			return 0L; // ouch
-		static_cast<KFilterDev *>(filterDev)->setSkipHeaders(); // Just zlib, not gzip
-		bool b = filterDev->open( QIODevice::ReadOnly );
-		static_cast<void>(b); // annoying unused variable warning
-		Q_ASSERT( b );
-		return filterDev;
-	}
-
-	qWarning() << "This zip file contains files compressed with method"
-			  << encoding() << ", this method is currently not supported by KZip,"
-			  << "please use a command-line tool to handle this file.";
-	return 0L;
-}

=== removed file 'src/core/external/kfilter/kzip.h'
--- src/core/external/kfilter/kzip.h	2010-04-15 12:28:34 +0000
+++ src/core/external/kfilter/kzip.h	1970-01-01 00:00:00 +0000
@@ -1,224 +0,0 @@
-/* This file is part of the KDE libraries
-   Copyright (C) 2002 Holger Schroeder <[e-mail]>
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License version 2 as published by the Free Software Foundation.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-