Added libksquirrel for KDE3

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/libraries/libksquirrel@1095624 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 361 insertions, 0 deletions

diff --git a/kernel/kls_wmf/wmf2mem.cpp b/kernel/kls_wmf/wmf2mem.cpp
new file mode 100644
index 0000000..ed644e1
--- /dev/null
+++ b/kernel/kls_wmf/wmf2mem.cpp
@@ -0,0 +1,361 @@
+/* libwmf (convert/wmf2gd.c): library for wmf conversion
+   Copyright (C) 2000 - various; see CREDITS, ChangeLog, and sources
+
+   The libwmf Library 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.
+
+   The libwmf 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 the libwmf Library; see the file COPYING.  If not,
+   write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
+
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <cctype>
+#include <cmath>
+#include <stdio.h>
+#include <string.h>
+
+#include "ksquirrel-libs/fmt_types.h"
+#include "ksquirrel-libs/fmt_defs.h"
+
+#include <libwmf/fund.h>
+#include <libwmf/types.h>
+#include <libwmf/api.h>
+#include <libwmf/ipa.h>
+#include <libwmf/font.h>
+#include <libwmf/color.h>
+#include <libwmf/macro.h>
+
+#include <libwmf/gd.h>
+
+typedef struct
+{	int    argc;
+	char** argv;
+
+	char*  wmf_filename;
+	char*  gd_filename;
+
+	wmf_gd_t options;
+
+	unsigned int max_width;
+	unsigned int max_height;
+
+	unsigned long max_flags;
+
+} PlotData;
+
+#define WMF2GD_MAXPECT (1 << 0)
+#define WMF2GD_MAXSIZE (1 << 1)
+
+int  wmf2gd_draw (PlotData*, unsigned char **buf, int *w, int *h);
+
+void wmf2gd_init (PlotData*,int,char**);
+int  wmf2gd_args (PlotData*);
+int  wmf2gd_file (PlotData*, unsigned char **buf, int *w, int *h);
+
+int call(int argc,char** argv, unsigned char **buf, int *w, int *h);
+
+int  explicit_wmf_error(wmf_error_t);
+
+int wmf2gd_draw (PlotData* pdata, unsigned char **buf, int *www, int *hhh)
+{
+	int status = 0;
+
+	float wmf_width;
+	float wmf_height;
+
+	float ratio_wmf;
+	float ratio_bounds;
+
+	unsigned int disp_width  = 0;
+	unsigned int disp_height = 0;
+
+	unsigned long flags;
+	unsigned long max_flags;
+
+	wmf_error_t err;
+
+	wmf_gd_t* ddata = 0;
+
+	wmfAPI* API = 0;
+
+	wmfAPI_Options api_options;
+
+	flags = 0;
+
+	flags |= WMF_OPT_FUNCTION;
+	api_options.function = wmf_gd_function;
+
+	flags |= WMF_OPT_ARGS;
+	api_options.argc = pdata->argc;
+	api_options.argv = pdata->argv;
+#ifndef DEBUG
+	flags |= WMF_OPT_IGNORE_NONFATAL;
+#endif
+	err = wmf_api_create (&API,flags,&api_options);
+	status = explicit_wmf_error (err);
+
+	if (status)
+	{	if (API) wmf_api_destroy (API);
+		return (status);
+	}
+
+	ddata = WMF_GD_GetData (API);
+
+	err = wmf_file_open(API, pdata->wmf_filename);
+	status = explicit_wmf_error (err);
+
+	if (status)
+	{
+		wmf_api_destroy (API);
+		return (status);
+	}
+
+	err = wmf_scan (API, 0, &(pdata->options.bbox));
+	status = explicit_wmf_error (err);
+
+	if (status)
+	{	
+		wmf_api_destroy (API);
+		return (status);
+	}
+
+/* Okay, got this far, everything seems cool.
+ */
+	ddata->type = pdata->options.type;
+
+	ddata->flags |= WMF_GD_OUTPUT_MEMORY;
+	ddata->file = pdata->options.file;
+
+	ddata->bbox = pdata->options.bbox;
+
+	wmf_display_size (API, &disp_width, &disp_height, 72, 72);
+
+	wmf_width  = (float) disp_width;
+	wmf_height = (float) disp_height;
+
+	if ((wmf_width <= 0) || (wmf_height <= 0))
+	{
+		status = 1;
+		wmf_api_destroy (API);
+		return (status);
+	}
+
+	max_flags = pdata->max_flags;
+
+	if ((wmf_width  > (float) pdata->max_width ) || (wmf_height > (float) pdata->max_height))
+		if (max_flags == 0)
+		    max_flags = WMF2GD_MAXPECT;
+
+	if (max_flags == WMF2GD_MAXPECT) /* scale the image */
+	{	ratio_wmf = wmf_height / wmf_width;
+		ratio_bounds = (float) pdata->max_height / (float) pdata->max_width;
+
+		if (ratio_wmf > ratio_bounds)
+		{	ddata->height = pdata->max_height;
+			ddata->width  = (unsigned int) ((float) ddata->height / ratio_wmf);
+		}
+		else
+		{	ddata->width  = pdata->max_width;
+			ddata->height = (unsigned int) ((float) ddata->width  * ratio_wmf);
+		}
+	}
+	else if (max_flags == WMF2GD_MAXSIZE) /* bizarre option, really */
+	{	ddata->width  = pdata->max_width;
+		ddata->height = pdata->max_height;
+	}
+	else
+	{	ddata->width  = (unsigned int) ceil ((double) wmf_width );
+		ddata->height = (unsigned int) ceil ((double) wmf_height);
+	}
+
+	if (status == 0)
+	{
+		err = wmf_play(API, 0, &(pdata->options.bbox));
+		status = explicit_wmf_error (err);
+	}
+
+	wmf_api_destroy(API);
+
+	int *p = wmf_gd_image_pixels(ddata->gd_image);
+	unsigned int w, h;
+
+	unsigned int pixel;
+	unsigned char r, g, b, a;
+
+	*buf = new u8 [ddata->height * ddata->width * sizeof(RGBA)];
+
+	if(!*buf)
+	    return 1;
+	    
+	unsigned char *pss = *buf;
+
+        for (h = 0; h < ddata->height; h++)
+            for (w = 0; w < ddata->width; w++)
+            {
+                pixel = (unsigned int) (*p++);
+
+                b = (unsigned char) (pixel & 0xff);
+                pixel >>= 8;
+                g = (unsigned char) (pixel & 0xff);
+                pixel >>= 8;
+                r = (unsigned char) (pixel & 0xff);
+                pixel >>= 7;
+                a = (unsigned char) (pixel & 0xfe);
+                a ^= 0xff;
+
+                *pss++ = r;
+                *pss++ = g;
+                *pss++ = b;
+                *pss++ = a;
+            }
+
+	*www = ddata->width;
+	*hhh = ddata->height;
+
+	free(ddata->gd_image);
+	
+	if(ddata->memory)
+	    free(ddata->memory);
+
+	return status;
+}
+
+void wmf2gd_init(PlotData *pdata, int argc, char **argv)
+{
+	pdata->argc = argc;
+	pdata->argv = argv;
+
+	pdata->wmf_filename = 0;
+	pdata->gd_filename = 0;
+
+	pdata->options.type = wmf_gd_png;
+
+	pdata->options.file = 0;
+
+	pdata->options.width  = 0;
+	pdata->options.height = 0;
+
+	pdata->options.flags = 0;
+
+	pdata->max_width  = 768;
+	pdata->max_height = 512;
+
+	pdata->max_flags = 0;
+}
+
+int wmf2gd_args (PlotData* pdata)
+{
+	int status = 0;
+	int arg = 0;
+
+	int    argc = pdata->argc;
+	char** argv = pdata->argv;
+
+	while ((++arg) < argc)
+	{	
+		if (strcmp (argv[arg],"-o") == 0)
+		{	if ((++arg) < argc)
+			{	pdata->gd_filename = argv[arg];
+				continue;
+			}
+			fprintf (stderr,"usage: `wmf2gd -o <file.gd> <file.wmf>'.\n");
+			fprintf (stderr,"Try `%s --help' for more information.\n",argv[0]);
+			status = arg;
+			break;
+		}
+
+		if (argv[arg][0] != '-')
+		{	pdata->wmf_filename = argv[arg];
+			continue;
+		}
+
+		fprintf (stderr,"option `%s' not recognized.\n",argv[arg]);
+		fprintf (stderr,"Try `%s --help' for more information.\n",argv[0]);
+		status = arg;
+
+		break;
+	}
+
+	if (status == 0)
+	{	if(pdata->wmf_filename == 0)
+		{	
+			fprintf (stderr,"No input file specified!\n");
+			fprintf (stderr,"Try `%s --help' for more information.\n",argv[0]);
+			status = argc;
+		}
+	}
+
+	pdata->options.type = wmf_gd_image;
+
+	return (status);
+}
+
+int wmf2gd_file(PlotData* pdata, unsigned char **buf, int *w, int *h)
+{
+	int status = 0;
+
+	pdata->options.file = stdout;
+
+	status = wmf2gd_draw(pdata, buf, w, h);
+
+	if(pdata->options.file != stdout)
+	    fclose(pdata->options.file);
+
+	return status;
+}
+
+int call(int argc, char **argv, unsigned char **buf, int *w, int *h)
+{	
+	int status = 0;
+
+	PlotData PData;
+
+	wmf2gd_init(&PData, argc, argv);
+
+	status = wmf2gd_args(&PData);
+
+	if(status)
+	    return status;
+
+	status = wmf2gd_file(&PData, buf, w, h);
+
+	return status;
+}
+
+int explicit_wmf_error (wmf_error_t err)
+{
+    int status = 0;
+
+    switch (err)
+    {
+        case wmf_E_None:
+	    status = 0;
+	break;
+
+        case wmf_E_InsMem:
+        case wmf_E_BadFile:
+        case wmf_E_BadFormat:
+        case wmf_E_EOF:
+        case wmf_E_DeviceError:
+        case wmf_E_Glitch:
+        case wmf_E_Assert:
+	    status = 1;
+        break;
+
+	default:
+	    status = 1;
+    }
+
+    return status;
+}