blender-archive/source/blender/editors/curve/editfont.c

/**
 * $Id$
 *
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 *
 * Contributor(s): Blender Foundation
 *
 * ***** END GPL LICENSE BLOCK *****
 */

#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <wchar.h>

#ifndef WIN32 
#include <unistd.h>
#else
#include <io.h>
#endif

#include "MEM_guardedalloc.h"

#include "BLI_blenlib.h"
#include "BLI_arithb.h"

#include "DNA_curve_types.h"
#include "DNA_object_types.h"
#include "DNA_vfont_types.h"
#include "DNA_scene_types.h"
#include "DNA_text_types.h"
#include "DNA_view3d_types.h"
#include "DNA_userdef_types.h"

#include "BKE_context.h"
#include "BKE_curve.h"
#include "BKE_depsgraph.h"
#include "BKE_font.h"
#include "BKE_global.h"
#include "BKE_main.h"
#include "BKE_object.h"
#include "BKE_report.h"
#include "BKE_utildefines.h"

#include "RNA_access.h"
#include "RNA_define.h"

#include "WM_api.h"
#include "WM_types.h"

#include "ED_curve.h"
#include "ED_object.h"
#include "ED_screen.h"
#include "ED_util.h"

#include "curve_intern.h"

#define MAXTEXT	32766

/************************* utilities ******************************/

static char findaccent(char char1, unsigned int code)
{
	char new= 0;
	
	if(char1=='a') {
		if(code=='`') new= 224;
		else if(code==39) new= 225;
		else if(code=='^') new= 226;
		else if(code=='~') new= 227;
		else if(code=='"') new= 228;
		else if(code=='o') new= 229;
		else if(code=='e') new= 230;
		else if(code=='-') new= 170;
	}
	else if(char1=='c') {
		if(code==',') new= 231;
		if(code=='|') new= 162;
	}
	else if(char1=='e') {
		if(code=='`') new= 232;
		else if(code==39) new= 233;
		else if(code=='^') new= 234;
		else if(code=='"') new= 235;
	}
	else if(char1=='i') {
		if(code=='`') new= 236;
		else if(code==39) new= 237;
		else if(code=='^') new= 238;
		else if(code=='"') new= 239;
	}
	else if(char1=='n') {
		if(code=='~') new= 241;
	}
	else if(char1=='o') {
		if(code=='`') new= 242;
		else if(code==39) new= 243;
		else if(code=='^') new= 244;
		else if(code=='~') new= 245;
		else if(code=='"') new= 246;
		else if(code=='/') new= 248;
		else if(code=='-') new= 186;
		else if(code=='e') new= 143;
	}
	else if(char1=='s') {
		if(code=='s') new= 167;
	}
	else if(char1=='u') {
		if(code=='`') new= 249;
		else if(code==39) new= 250;
		else if(code=='^') new= 251;
		else if(code=='"') new= 252;
	}
	else if(char1=='y') {
		if(code==39) new= 253;
		else if(code=='"') new= 255;
	}
	else if(char1=='A') {
		if(code=='`') new= 192;
		else if(code==39) new= 193;
		else if(code=='^') new= 194;
		else if(code=='~') new= 195;
		else if(code=='"') new= 196;
		else if(code=='o') new= 197;
		else if(code=='e') new= 198;
	}
	else if(char1=='C') {
		if(code==',') new= 199;
	}
	else if(char1=='E') {
		if(code=='`') new= 200;
		else if(code==39) new= 201;
		else if(code=='^') new= 202;
		else if(code=='"') new= 203;
	}
	else if(char1=='I') {
		if(code=='`') new= 204;
		else if(code==39) new= 205;
		else if(code=='^') new= 206;
		else if(code=='"') new= 207;
	}
	else if(char1=='N') {
		if(code=='~') new= 209;
	}
	else if(char1=='O') {
		if(code=='`') new= 210;
		else if(code==39) new= 211;
		else if(code=='^') new= 212;
		else if(code=='~') new= 213;
		else if(code=='"') new= 214;
		else if(code=='/') new= 216;
		else if(code=='e') new= 141;
	}
	else if(char1=='U') {
		if(code=='`') new= 217;
		else if(code==39) new= 218;
		else if(code=='^') new= 219;
		else if(code=='"') new= 220;
	}
	else if(char1=='Y') {
		if(code==39) new= 221;
	}
	else if(char1=='1') {
		if(code=='4') new= 188;
		if(code=='2') new= 189;
	}
	else if(char1=='3') {
		if(code=='4') new= 190;
	}
	else if(char1==':') {
		if(code=='-') new= 247;
	}
	else if(char1=='-') {
		if(code==':') new= 247;
		if(code=='|') new= 135;
		if(code=='+') new= 177;
	}
	else if(char1=='|') {
		if(code=='-') new= 135;
		if(code=='=') new= 136;
	}
	else if(char1=='=') {
		if(code=='|') new= 136;
	}
	else if(char1=='+') {
		if(code=='-') new= 177;
	}
	
	if(new) return new;
	else return char1;
}


void update_string(Curve *cu)
{
	EditFont *ef= cu->editfont;
	int len;

	// Free the old curve string	
	MEM_freeN(cu->str);

	// Calculate the actual string length in UTF-8 variable characters
	len = wcsleninu8(ef->textbuf);

	// Alloc memory for UTF-8 variable char length string
	cu->str = MEM_callocN(len + sizeof(wchar_t), "str");

	// Copy the wchar to UTF-8
	wcs2utf8s(cu->str, ef->textbuf);
}

static int insert_into_textbuf(Object *obedit, unsigned long c)
{
	Curve *cu= obedit->data;
	
	if(cu->len<MAXTEXT-1) {
		EditFont *ef= cu->editfont;
		int x;

		for(x= cu->len; x>cu->pos; x--) ef->textbuf[x]= ef->textbuf[x-1];
		for(x= cu->len; x>cu->pos; x--) ef->textbufinfo[x]= ef->textbufinfo[x-1];		
		ef->textbuf[cu->pos]= c;
		ef->textbufinfo[cu->pos] = cu->curinfo;
		ef->textbufinfo[cu->pos].kern = 0;
		if(obedit->actcol>0)
			ef->textbufinfo[cu->pos].mat_nr = obedit->actcol;
		else
			ef->textbufinfo[cu->pos].mat_nr = 0;
					
		cu->pos++;
		cu->len++;
		ef->textbuf[cu->len]='\0';

		update_string(cu);

		return 1;
	}
	else
		return 0;
}

static void text_update_edited(bContext *C, Scene *scene, Object *obedit, int recalc, int mode)
{
	Curve *cu= obedit->data;
	EditFont *ef= cu->editfont;

	if(cu->pos)
		cu->curinfo = ef->textbufinfo[cu->pos-1];
	else
		cu->curinfo = ef->textbufinfo[0];
	
	if(obedit->totcol>0)
		obedit->actcol= ef->textbufinfo[cu->pos-1].mat_nr;

	update_string(cu);
	BKE_text_to_curve(scene, obedit, mode);

	if(recalc)
		DAG_object_flush_update(scene, obedit, OB_RECALC_DATA);
	WM_event_add_notifier(C, NC_OBJECT|ND_GEOM_DATA, obedit);
}

/********************** insert lorem operator *********************/

static int insert_lorem_exec(bContext *C, wmOperator *op)
{
	Scene *scene= CTX_data_scene(C);
	Object *obedit= CTX_data_edit_object(C);
	char *p, *p2;
	int i;
	static char *lastlorem;
	
	if(lastlorem)
		p= lastlorem;
	else
		p= ED_lorem;
	
	i= rand()/(RAND_MAX/6)+4;	
		
	for(p2=p; *p2 && i; p2++) {
		insert_into_textbuf(obedit, *p2);

		if(*p2=='.')
			i--;
	}

	lastlorem = p2+1;
	if(strlen(lastlorem)<5)
		lastlorem = ED_lorem;
	
	insert_into_textbuf(obedit, '\n');
	insert_into_textbuf(obedit, '\n');	

	DAG_object_flush_update(scene, obedit, OB_RECALC_DATA);
	WM_event_add_notifier(C, NC_OBJECT|ND_GEOM_DATA, obedit);

	return OPERATOR_FINISHED;
}

void FONT_OT_insert_lorem(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Insert Lorem";
	ot->idname= "FONT_OT_insert_lorem";
	
	/* api callbacks */
	ot->exec= insert_lorem_exec;
	ot->poll= ED_operator_editfont;
	
	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
}

/******************* paste file operator ********************/

/* note this handles both ascii and utf8 unicode, previously
 * there were 3 functions that did effectively the same thing. */

static int paste_file(bContext *C, ReportList *reports, char *filename)
{
	Scene *scene= CTX_data_scene(C);
	Object *obedit= CTX_data_edit_object(C);
	Curve *cu= obedit->data;
	EditFont *ef= cu->editfont;
	FILE *fp;
	int filelen;
	char *strp;

	fp= fopen(filename, "r");

	if(!fp) {
		if(reports)
			BKE_reportf(reports, RPT_ERROR, "Failed to open file %s.", filename);
		return OPERATOR_CANCELLED;
	}

	fseek(fp, 0L, SEEK_END);
	filelen = ftell(fp);
	fseek(fp, 0L, SEEK_SET);

	strp= MEM_callocN(filelen+4, "tempstr");

	// fread() instead of read(), because windows read() converts text
	// to DOS \r\n linebreaks, causing double linebreaks in the 3d text
	filelen = fread(strp, 1, filelen, fp);
	fclose(fp);
	strp[filelen]= 0;

	if(cu->len+filelen<MAXTEXT) {
		int tmplen;
		wchar_t *mem = MEM_callocN((sizeof(wchar_t)*filelen)+(4*sizeof(wchar_t)), "temporary");
		tmplen = utf8towchar(mem, strp);
		wcscat(ef->textbuf, mem);
		MEM_freeN(mem);
		cu->len += tmplen;
		cu->pos= cu->len;
	}
	MEM_freeN(strp);

	text_update_edited(C, scene, obedit, 1, 0);

	return OPERATOR_FINISHED;
}

static int paste_file_exec(bContext *C, wmOperator *op)
{
	char *filename;
	int retval;
	
	filename= RNA_string_get_alloc(op->ptr, "filename", NULL, 0);
	retval= paste_file(C, op->reports, filename);
	MEM_freeN(filename);

	return retval;
}

static int paste_file_invoke(bContext *C, wmOperator *op, wmEvent *event)
{
	if(RNA_property_is_set(op->ptr, "filename"))
		return paste_file_exec(C, op);

	WM_event_add_fileselect(C, op); 

	return OPERATOR_RUNNING_MODAL;
}

void FONT_OT_paste_file(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Paste File";
	ot->idname= "FONT_OT_paste_file";
	
	/* api callbacks */
	ot->exec= paste_file_exec;
	ot->invoke= paste_file_invoke;
	ot->poll= ED_operator_editfont;
	
	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;

	/* properties */
	RNA_def_string_file_path(ot->srna, "filename", "", 0, "Filename", "File path of text file to load.");
}

/******************* paste buffer operator ********************/

static int paste_buffer_exec(bContext *C, wmOperator *op)
{
	char *filename;

#ifdef WIN32
	filename= "C:\\windows\\temp\\cutbuf.txt";

//	The following is more likely to work on all Win32 installations.
//	suggested by Douglas Toltzman. Needs windows include files...
/*
	char tempFileName[MAX_PATH];
	DWORD pathlen;
	static const char cutbufname[]="cutbuf.txt";

	if((pathlen=GetTempPath(sizeof(tempFileName),tempFileName)) > 0 &&
		pathlen + sizeof(cutbufname) <= sizeof(tempFileName))
	{
		strcat(tempFileName,cutbufname);
		filename= tempFilename;
	}
*/
#else
	filename= "/tmp/.cutbuffer";
#endif

	return paste_file(C, NULL, filename);
}

void FONT_OT_paste_buffer(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Paste Buffer";
	ot->idname= "FONT_OT_paste_buffer";
	
	/* api callbacks */
	ot->exec= paste_buffer_exec;
	ot->poll= ED_operator_editfont;
	
	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
}

/******************* XXX text to object operator ********************/

static void txt_export_to_object(Scene *scene, Object *obedit, Text *text)
{
	ID *id;
	Curve *cu;
	struct TextLine *tmp;
	int nchars = 0;
//	char sdir[FILE_MAXDIR];
//	char sfile[FILE_MAXFILE];

	if(!text || !text->lines.first) return;

	id = (ID *)text;

	if(obedit && obedit->type==OB_FONT) return;
// XXX	check_editmode(OB_FONT);
	
	add_object(scene, OB_FONT);

	ED_object_base_init_from_view(NULL, BASACT); // XXX
	obedit= BASACT->object;
	where_is_object(scene, obedit);

	cu= obedit->data;

/*	
//		renames object, careful with long filenames.

	if(text->name) {
	//ID *find_id(char *type, char *name)	
		BLI_split_dirfile(text->name, sdir, sfile);
//		rename_id((ID *)obedit, sfile);
		rename_id((ID *)cu, sfile);
		id->us++;
	}
*/	
	cu->vfont= get_builtin_font();
	cu->vfont->id.us++;

	tmp= text->lines.first;
	while(cu->len<MAXTEXT && tmp) {
		nchars += strlen(tmp->line) + 1;
		tmp = tmp->next;
	}

	if(cu->str) MEM_freeN(cu->str);
	if(cu->strinfo) MEM_freeN(cu->strinfo);	

	cu->str= MEM_mallocN(nchars+4, "str");
	cu->strinfo= MEM_callocN((nchars+4)*sizeof(CharInfo), "strinfo");
	cu->totbox= cu->actbox= 1;
	cu->tb= MEM_callocN(MAXTEXTBOX*sizeof(TextBox), "textbox");
	cu->tb[0].w = cu->tb[0].h = 0.0;
	
	tmp= text->lines.first;
	strcpy(cu->str, tmp->line);
	cu->len= strlen(tmp->line);
	cu->pos= cu->len;

	tmp= tmp->next;

	while(cu->len<MAXTEXT && tmp) {
		strcat(cu->str, "\n");
		strcat(cu->str, tmp->line);
		cu->len+= strlen(tmp->line) + 1;
		cu->pos= cu->len;
		tmp= tmp->next;
	}

	make_editText(obedit);
	ED_object_exit_editmode(NULL, EM_FREEDATA|EM_WAITCURSOR); // XXX
}

static void txt_export_to_objects(Scene *scene, Object *obedit, Text *text)
{
	RegionView3D *rv3d= NULL; // XXX
	ID *id;
	Curve *cu;
	struct TextLine *curline;
	int nchars;
	int linenum = 0;
	float offset[3] = {0.0,0.0,0.0};

	if(!text || !text->lines.first) return;

	id = (ID *)text;

	if(obedit && obedit->type==OB_FONT) return;
// XXX	check_editmode(OB_FONT);

	curline = text->lines.first;
	while(curline){	
		/*skip lines with no text, but still make space for them*/
		if(curline->line[0] == '\0'){
			linenum++;
			curline = curline->next;
			continue;
		}
			
		nchars = 0;	
		add_object(scene, OB_FONT);
	
		ED_object_base_init_from_view(NULL, BASACT); // XXX
		obedit= BASACT->object;
		where_is_object(scene, obedit);	
		
		/* Do the translation */
		offset[0] = 0;
		offset[1] = -linenum;
		offset[2] = 0;
	
		Mat4Mul3Vecfl(rv3d->viewinv, offset);
		
		obedit->loc[0] += offset[0];
		obedit->loc[1] += offset[1];
		obedit->loc[2] += offset[2];
		/* End Translation */
					
		cu= obedit->data;
		
		cu->vfont= get_builtin_font();
		cu->vfont->id.us++;
	
		nchars = strlen(curline->line) + 1;
	
		if(cu->str) MEM_freeN(cu->str);
		if(cu->strinfo) MEM_freeN(cu->strinfo);		
	
		cu->str= MEM_mallocN(nchars+4, "str");
		cu->strinfo= MEM_callocN((nchars+4)*sizeof(CharInfo), "strinfo");
		cu->totbox= cu->actbox= 1;
		cu->tb= MEM_callocN(MAXTEXTBOX*sizeof(TextBox), "textbox");
		cu->tb[0].w = cu->tb[0].h = 0.0;
		
		strcpy(cu->str, curline->line);
		cu->len= strlen(curline->line);
		cu->pos= cu->len;

		make_editText(obedit);
		ED_object_exit_editmode(NULL, EM_FREEDATA|EM_WAITCURSOR); // XXX

		linenum++;
		curline = curline->next;
	}
}

static int text_to_object_exec(bContext *C, wmOperator *op)
{
	Scene *scene= CTX_data_scene(C);
	Object *obedit= CTX_data_edit_object(C);
	Text *text= NULL; /// XXX retrieve this ..

	if(RNA_boolean_get(op->ptr, "split_lines"))
		txt_export_to_objects(scene, obedit, text);
	else
		txt_export_to_object(scene, obedit, text);

	return OPERATOR_FINISHED;
}

void FONT_OT_text_to_object(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Text to Object";
	ot->idname= "FONT_OT_text_to_object";
	
	/* api callbacks */
	ot->exec= text_to_object_exec;
	ot->poll= ED_operator_editfont; // XXX not correct
	
	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;

	/* properties */
	RNA_def_boolean(ot->srna, "split_lines", 0, "Split Lines", "Create one object per line in the text.");
}

/********************** utilities ***************************/

static short next_word(Curve *cu)
{
	short s;
	for(s=cu->pos; (cu->str[s]) && (cu->str[s]!=' ') && (cu->str[s]!='\n') &&
	                (cu->str[s]!=1) && (cu->str[s]!='\r'); s++);
	if(cu->str[s]) return(s+1); else return(s);
}

static short prev_word(Curve *cu)
{
	short s;
	
	if(cu->pos==0) return(0);
	for(s=cu->pos-2; (cu->str[s]) && (cu->str[s]!=' ') && (cu->str[s]!='\n') &&
	                (cu->str[s]!=1) && (cu->str[s]!='\r'); s--);
	if(cu->str[s]) return(s+1); else return(s);
}

static int kill_selection(Object *obedit, int ins)	/* 1 == new character */
{
	Curve *cu= obedit->data;
	EditFont *ef= cu->editfont;
	int selend, selstart, direction;
	int offset = 0;
	int getfrom;

	direction = BKE_font_getselection(obedit, &selstart, &selend);
	if(direction) {
		int size;
		if(ins) offset = 1;
		if(cu->pos >= selstart) cu->pos = selstart+offset;
		if((direction == -1) && ins) {
			selstart++;
			selend++;
		}
		getfrom = selend+offset;
		if(ins==0) getfrom++;
		size = (cu->len * sizeof(wchar_t)) - (selstart * sizeof(wchar_t)) + (offset*sizeof(wchar_t));
		memmove(ef->textbuf+selstart, ef->textbuf+getfrom, size);
		memmove(ef->textbufinfo+selstart, ef->textbufinfo+getfrom, ((cu->len-selstart)+offset)*sizeof(CharInfo));
		cu->len -= (selend-selstart)+offset;
		cu->selstart = cu->selend = 0;
	}

	return(direction);
}

/******************* set style operator ********************/

static EnumPropertyItem style_items[]= {
	{CU_BOLD, "BOLD", "Bold", ""},
	{CU_ITALIC, "ITALIC", "Italic", ""},
	{CU_UNDERLINE, "UNDERLINE", "Underline", ""},
	{0, NULL, NULL, NULL}};

static int set_style(bContext *C, int style, int clear)
{
	Scene *scene= CTX_data_scene(C);
	Object *obedit= CTX_data_edit_object(C);
	Curve *cu= obedit->data;
	EditFont *ef= cu->editfont;
	int i, selstart, selend;

	if(!BKE_font_getselection(obedit, &selstart, &selend))
		return OPERATOR_CANCELLED;

	for(i=selstart; i<=selend; i++) {
		if(clear)
			ef->textbufinfo[i].flag &= ~style;
		else
			ef->textbufinfo[i].flag |= style;
	}

	DAG_object_flush_update(scene, obedit, OB_RECALC_DATA);
	WM_event_add_notifier(C, NC_OBJECT|ND_GEOM_DATA, obedit);

	return OPERATOR_FINISHED;
}

static int set_style_exec(bContext *C, wmOperator *op)
{
	int style, clear;

	style= RNA_enum_get(op->ptr, "style");
	clear= RNA_enum_get(op->ptr, "clear");

	return set_style(C, style, clear);
}

void FONT_OT_set_style(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Set Style";
	ot->idname= "FONT_OT_set_style";
	
	/* api callbacks */
	ot->exec= set_style_exec;
	ot->poll= ED_operator_editfont;
	
	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;

	/* properties */
	RNA_def_enum(ot->srna, "style", style_items, CU_BOLD, "Style", "Style to set selection to.");
	RNA_def_boolean(ot->srna, "clear", 0, "Clear", "Clear style rather than setting it.");
}

/******************* toggle style operator ********************/

static int toggle_style_exec(bContext *C, wmOperator *op)
{
	Object *obedit= CTX_data_edit_object(C);
	Curve *cu= obedit->data;
	int style, clear, selstart, selend;

	if(!BKE_font_getselection(obedit, &selstart, &selend))
		return OPERATOR_CANCELLED;
	
	style= RNA_enum_get(op->ptr, "style");

	cu->curinfo.flag ^= style;
	clear= (cu->curinfo.flag & style) == 0;

	return set_style(C, style, clear);
}

void FONT_OT_toggle_style(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Toggle Style";
	ot->idname= "FONT_OT_toggle_style";
	
	/* api callbacks */
	ot->exec= toggle_style_exec;
	ot->poll= ED_operator_editfont;
	
	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;

	/* properties */
	RNA_def_enum(ot->srna, "style", style_items, CU_BOLD, "Style", "Style to set selection to.");
}

/******************* set material operator ********************/

static int set_material_exec(bContext *C, wmOperator *op)
{
	Scene *scene= CTX_data_scene(C);
	Object *obedit= CTX_data_edit_object(C);
	Curve *cu= obedit->data;
	EditFont *ef= cu->editfont;
	int i, mat_nr, selstart, selend;

	if(!BKE_font_getselection(obedit, &selstart, &selend))
		return OPERATOR_CANCELLED;

	if(RNA_property_is_set(op->ptr, "index"))
		mat_nr= RNA_int_get(op->ptr, "index");
	else
		mat_nr= obedit->actcol;

	for(i=selstart; i<=selend; i++)
		ef->textbufinfo[i].mat_nr = mat_nr;

	DAG_object_flush_update(scene, obedit, OB_RECALC_DATA);
	WM_event_add_notifier(C, NC_OBJECT|ND_GEOM_DATA, obedit);

	return OPERATOR_FINISHED;
}

void FONT_OT_set_material(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Set Material";
	ot->idname= "FONT_OT_set_material";
	
	/* api callbacks */
	ot->exec= set_material_exec;
	ot->poll= ED_operator_editfont;
	
	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;

	/* properties */
	RNA_def_int(ot->srna, "index", 0, 0, INT_MAX, "Material Index", "Material slot index.", 0, INT_MAX);
}

/******************* copy text operator ********************/

static void copy_selection(Object *obedit)
{
	int selstart, selend;
	
	if(BKE_font_getselection(obedit, &selstart, &selend)) {
		Curve *cu= obedit->data;
		EditFont *ef= cu->editfont;
		
		memcpy(ef->copybuf, ef->textbuf+selstart, ((selend-selstart)+1)*sizeof(wchar_t));
		ef->copybuf[(selend-selstart)+1]=0;
		memcpy(ef->copybufinfo, ef->textbufinfo+selstart, ((selend-selstart)+1)*sizeof(CharInfo));	
	}
}

static int copy_text_exec(bContext *C, wmOperator *op)
{
	Object *obedit= CTX_data_edit_object(C);

	copy_selection(obedit);

	return OPERATOR_FINISHED;
}

void FONT_OT_copy_text(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Copy Text";
	ot->idname= "FONT_OT_copy_text";
	
	/* api callbacks */
	ot->exec= copy_text_exec;
	ot->poll= ED_operator_editfont;
}

/******************* cut text operator ********************/

static int cut_text_exec(bContext *C, wmOperator *op)
{
	Scene *scene= CTX_data_scene(C);
	Object *obedit= CTX_data_edit_object(C);
	int selstart, selend;

	if(!BKE_font_getselection(obedit, &selstart, &selend))
		return OPERATOR_CANCELLED;

	copy_selection(obedit);
	kill_selection(obedit, 0);

	text_update_edited(C, scene, obedit, 1, 0);

	return OPERATOR_FINISHED;
}

void FONT_OT_cut_text(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Cut Text";
	ot->idname= "FONT_OT_cut_text";
	
	/* api callbacks */
	ot->exec= cut_text_exec;
	ot->poll= ED_operator_editfont;

	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
}

/******************* paste text operator ********************/

static int paste_selection(Object *obedit, ReportList *reports)
{
	Curve *cu= obedit->data;
	EditFont *ef= cu->editfont;
	int len= wcslen(ef->copybuf);

	// Verify that the copy buffer => [copy buffer len] + cu->len < MAXTEXT
	if(cu->len + len <= MAXTEXT) {
		if(len) {	
			int size = (cu->len * sizeof(wchar_t)) - (cu->pos*sizeof(wchar_t)) + sizeof(wchar_t);
			memmove(ef->textbuf+cu->pos+len, ef->textbuf+cu->pos, size);
			memcpy(ef->textbuf+cu->pos, ef->copybuf, len * sizeof(wchar_t));
		
			memmove(ef->textbufinfo+cu->pos+len, ef->textbufinfo+cu->pos, (cu->len-cu->pos+1)*sizeof(CharInfo));
			memcpy(ef->textbufinfo+cu->pos, ef->copybufinfo, len*sizeof(CharInfo));	
		
			cu->len += len;
			cu->pos += len;

			return 1;
		}
	}
	else
		BKE_report(reports, RPT_WARNING, "Text too long.");
	
	return 0;
}

static int paste_text_exec(bContext *C, wmOperator *op)
{
	Scene *scene= CTX_data_scene(C);
	Object *obedit= CTX_data_edit_object(C);

	if(!paste_selection(obedit, op->reports))
		return OPERATOR_CANCELLED;

	text_update_edited(C, scene, obedit, 1, 0);

	return OPERATOR_FINISHED;
}

void FONT_OT_paste_text(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Paste Text";
	ot->idname= "FONT_OT_paste_text";
	
	/* api callbacks */
	ot->exec= paste_text_exec;
	ot->poll= ED_operator_editfont;

	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
}

/************************ move operator ************************/

static EnumPropertyItem move_type_items[]= {
	{LINE_BEGIN, "LINE_BEGIN", "Line Begin", ""},
	{LINE_END, "LINE_END", "Line End", ""},
	{PREV_CHAR, "PREVIOUS_CHARACTER", "Previous Character", ""},
	{NEXT_CHAR, "NEXT_CHARACTER", "Next Character", ""},
	{PREV_WORD, "PREVIOUS_WORD", "Previous Word", ""},
	{NEXT_WORD, "NEXT_WORD", "Next Word", ""},
	{PREV_LINE, "PREVIOUS_LINE", "Previous Line", ""},
	{NEXT_LINE, "NEXT_LINE", "Next Line", ""},
	{PREV_PAGE, "PREVIOUS_PAGE", "Previous Page", ""},
	{NEXT_PAGE, "NEXT_PAGE", "Next Page", ""},
	{0, NULL, NULL, NULL}};

static int move_cursor(bContext *C, int type, int select)
{
	Scene *scene= CTX_data_scene(C);
	Object *obedit= CTX_data_edit_object(C);
	Curve *cu= obedit->data;
	EditFont *ef= cu->editfont;
	int cursmove= 0;

	switch(type) {
		case LINE_BEGIN:
			if((select) && (cu->selstart==0)) cu->selstart = cu->selend = cu->pos+1;
			while(cu->pos>0) {
				if(ef->textbuf[cu->pos-1]=='\n') break;
				if(ef->textbufinfo[cu->pos-1].flag & CU_WRAP ) break;				
				cu->pos--;
			}		
			cursmove=FO_CURS;
			break;
			
		case LINE_END:
			if((select) && (cu->selstart==0)) cu->selstart = cu->selend = cu->pos+1;		
			while(cu->pos<cu->len) {
				if(ef->textbuf[cu->pos]==0) break;
				if(ef->textbuf[cu->pos]=='\n') break;
				if(ef->textbufinfo[cu->pos].flag & CU_WRAP ) break;
				cu->pos++;
			}
			cursmove=FO_CURS;
			break;

		case PREV_WORD:
			if((select) && (cu->selstart==0)) cu->selstart = cu->selend = cu->pos+1;
			cu->pos= prev_word(cu);
			cursmove= FO_CURS;
			break;

		case NEXT_WORD:
			if((select) && (cu->selstart==0)) cu->selstart = cu->selend = cu->pos+1;
			cu->pos= next_word(cu);
			cursmove= FO_CURS;				
			break;

		case PREV_CHAR:
			if((select) && (cu->selstart==0)) cu->selstart = cu->selend = cu->pos+1;
			cu->pos--;
			cursmove=FO_CURS;
			break;

		case NEXT_CHAR:	
			if((select) && (cu->selstart==0)) cu->selstart = cu->selend = cu->pos+1;
			cu->pos++;
			cursmove= FO_CURS;				

			break;

		case PREV_LINE:
			if((select) && (cu->selstart==0)) cu->selstart = cu->selend = cu->pos+1;
			cursmove=FO_CURSUP;
			break;
			
		case NEXT_LINE:
			if((select) && (cu->selstart==0)) cu->selstart = cu->selend = cu->pos+1;
			cursmove= FO_CURSDOWN;
			break;

		case PREV_PAGE:
			if((select) && (cu->selstart==0)) cu->selstart = cu->selend = cu->pos+1;
			cursmove=FO_PAGEUP;
			break;

		case NEXT_PAGE:
			if((select) && (cu->selstart==0)) cu->selstart = cu->selend = cu->pos+1;
			cursmove=FO_PAGEDOWN;
			break;
	}
		
	if(!cursmove)
		return OPERATOR_CANCELLED;

	if(select == 0) {
		if(cu->selstart) {
			cu->selstart = cu->selend = 0;
			update_string(cu);
			BKE_text_to_curve(scene, obedit, FO_SELCHANGE);
		}
	}

	if(cu->pos>cu->len) cu->pos= cu->len;
	else if(cu->pos>=MAXTEXT) cu->pos= MAXTEXT;
	else if(cu->pos<0) cu->pos= 0;

	text_update_edited(C, scene, obedit, select, cursmove);

	if(select)
		cu->selend = cu->pos;

	return OPERATOR_FINISHED;
}

static int move_exec(bContext *C, wmOperator *op)
{
	int type= RNA_enum_get(op->ptr, "type");

	return move_cursor(C, type, 0);
}

void FONT_OT_move(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Move Cursor";
	ot->idname= "FONT_OT_move";
	
	/* api callbacks */
	ot->exec= move_exec;
	ot->poll= ED_operator_editfont;

	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;

	/* properties */
	RNA_def_enum(ot->srna, "type", move_type_items, LINE_BEGIN, "Type", "Where to move cursor to.");
}

/******************* move select operator ********************/

static int move_select_exec(bContext *C, wmOperator *op)
{
	int type= RNA_enum_get(op->ptr, "type");

	return move_cursor(C, type, 1);
}

void FONT_OT_move_select(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Move Select";
	ot->idname= "FONT_OT_move_select";
	
	/* api callbacks */
	ot->exec= move_select_exec;
	ot->poll= ED_operator_editfont;

	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;

	/* properties */
	RNA_def_enum(ot->srna, "type", move_type_items, LINE_BEGIN, "Type", "Where to move cursor to, to make a selection.");
}

/************************* change spacing **********************/

static int change_spacing_exec(bContext *C, wmOperator *op)
{
	Scene *scene= CTX_data_scene(C);
	Object *obedit= CTX_data_edit_object(C);
	Curve *cu= obedit->data;
	EditFont *ef= cu->editfont;
	int kern, delta= RNA_int_get(op->ptr, "delta");

	kern = ef->textbufinfo[cu->pos-1].kern;
	kern += delta;
	CLAMP(kern, -20, 20);

	if(ef->textbufinfo[cu->pos-1].kern == kern)
		return OPERATOR_CANCELLED;

	ef->textbufinfo[cu->pos-1].kern = kern;

	text_update_edited(C, scene, obedit, 1, 0);

	return OPERATOR_FINISHED;
}

void FONT_OT_change_spacing(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Change Spacing";
	ot->idname= "FONT_OT_change_spacing";
	
	/* api callbacks */
	ot->exec= change_spacing_exec;
	ot->poll= ED_operator_editfont;

	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;

	/* properties */
	RNA_def_int(ot->srna, "delta", 1, -20, 20, "Delta", "Amount to decrease or increasing character spacing with.", -20, 20);
}

/************************* change character **********************/

static int change_character_exec(bContext *C, wmOperator *op)
{
	Scene *scene= CTX_data_scene(C);
	Object *obedit= CTX_data_edit_object(C);
	Curve *cu= obedit->data;
	EditFont *ef= cu->editfont;
	int character, delta= RNA_int_get(op->ptr, "delta");

	if(cu->pos <= 0)
		return OPERATOR_CANCELLED;

	character= ef->textbuf[cu->pos - 1];
	character += delta;
	CLAMP(character, 0, 255);

	if(character == ef->textbuf[cu->pos - 1])
		return OPERATOR_CANCELLED;

	ef->textbuf[cu->pos - 1]= character;

	text_update_edited(C, scene, obedit, 1, 0);

	return OPERATOR_FINISHED;
}

void FONT_OT_change_character(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Change Character";
	ot->idname= "FONT_OT_change_character";
	
	/* api callbacks */
	ot->exec= change_character_exec;
	ot->poll= ED_operator_editfont;

	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;

	/* properties */
	RNA_def_int(ot->srna, "delta", 1, -255, 255, "Delta", "Number to increase or decrease character code with.", -255, 255);
}

/******************* line break operator ********************/

static int line_break_exec(bContext *C, wmOperator *op)
{
	Scene *scene= CTX_data_scene(C);
	Object *obedit= CTX_data_edit_object(C);
	Curve *cu= obedit->data;
	EditFont *ef= cu->editfont;
	int ctrl= RNA_enum_get(op->ptr, "ctrl");

	if(ctrl) {
		insert_into_textbuf(obedit, 1);
		if(ef->textbuf[cu->pos]!='\n')
			insert_into_textbuf(obedit, '\n');
	}
	else
		insert_into_textbuf(obedit, '\n');

	cu->selstart = cu->selend = 0;

	text_update_edited(C, scene, obedit, 1, 0);

	return OPERATOR_FINISHED;
}

void FONT_OT_line_break(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Line Break";
	ot->idname= "FONT_OT_line_break";
	
	/* api callbacks */
	ot->exec= line_break_exec;
	ot->poll= ED_operator_editfont;

	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;

	/* properties */
	RNA_def_boolean(ot->srna, "ctrl", 0, "Ctrl", ""); // XXX what is this?
}

/******************* delete operator **********************/

static EnumPropertyItem delete_type_items[]= {
	{DEL_ALL, "ALL", "All", ""},
	{DEL_NEXT_CHAR, "NEXT_CHARACTER", "Next Character", ""},
	{DEL_PREV_CHAR, "PREVIOUS_CHARACTER", "Previous Character", ""},
	{DEL_SELECTION, "SELECTION", "Selection", ""},
	{DEL_NEXT_SEL, "NEXT_OR_SELECTION", "Next or Selection", ""},
	{DEL_PREV_SEL, "PREVIOUS_OR_SELECTION", "Previous or Selection", ""},
	{0, NULL, NULL, NULL}};

static int delete_exec(bContext *C, wmOperator *op)
{
	Scene *scene= CTX_data_scene(C);
	Object *obedit= CTX_data_edit_object(C);
	Curve *cu= obedit->data;
	EditFont *ef= cu->editfont;
	int x, selstart, selend, type= RNA_enum_get(op->ptr, "type");

	if(cu->len == 0)
		return OPERATOR_CANCELLED;

	if(BKE_font_getselection(obedit, &selstart, &selend)) {
		if(type == DEL_NEXT_SEL) type= DEL_SELECTION;
		else if(type == DEL_PREV_SEL) type= DEL_SELECTION;
	}
	else {
		if(type == DEL_NEXT_SEL) type= DEL_NEXT_CHAR;
		else if(type == DEL_PREV_SEL) type= DEL_PREV_CHAR;
	}

	switch(type) {
		case DEL_ALL:
			cu->len = cu->pos = 0;
			ef->textbuf[0]= 0;
			break;
		case DEL_SELECTION:
			if(!kill_selection(obedit, 0))
				return OPERATOR_CANCELLED;
			break;
		case DEL_PREV_CHAR:
			if(cu->pos<=0)
				return OPERATOR_CANCELLED;

			for(x=cu->pos;x<=cu->len;x++)
				ef->textbuf[x-1]= ef->textbuf[x];
			for(x=cu->pos;x<=cu->len;x++)
				ef->textbufinfo[x-1]= ef->textbufinfo[x];					

			cu->pos--;
			ef->textbuf[--cu->len]='\0';
			break;
		case DEL_NEXT_CHAR:
			if(cu->pos>=cu->len)
				return OPERATOR_CANCELLED;

			for(x=cu->pos;x<cu->len;x++)
				ef->textbuf[x]= ef->textbuf[x+1];
			for(x=cu->pos;x<cu->len;x++)
				ef->textbufinfo[x]= ef->textbufinfo[x+1];					

			ef->textbuf[--cu->len]='\0';
			break;
		default:
			return OPERATOR_CANCELLED;
	}

	text_update_edited(C, scene, obedit, 1, 0);

	return OPERATOR_FINISHED;
}

void FONT_OT_delete(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Delete";
	ot->idname= "FONT_OT_delete";
	
	/* api callbacks */
	ot->exec= delete_exec;
	ot->poll= ED_operator_editfont;

	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;

	/* properties */
	RNA_def_enum(ot->srna, "type", delete_type_items, DEL_ALL, "Type", "Which part of the text to delete.");
}

/*********************** insert text operator *************************/

static int insert_text_exec(bContext *C, wmOperator *op)
{
	Scene *scene= CTX_data_scene(C);
	Object *obedit= CTX_data_edit_object(C);
	char *inserted_utf8;
	wchar_t *inserted_text, first;
	int len;

	if(!RNA_property_is_set(op->ptr, "text"))
		return OPERATOR_CANCELLED;
	
	inserted_utf8= RNA_string_get_alloc(op->ptr, "text", NULL, 0);
	len= strlen(inserted_utf8);

	inserted_text= MEM_callocN(sizeof(wchar_t)*(len+1), "FONT_insert_text");
	utf8towchar(inserted_text, inserted_utf8);
	first= inserted_text[0];

	MEM_freeN(inserted_text);
	MEM_freeN(inserted_utf8);

	if(!first)
		return OPERATOR_CANCELLED;

	insert_into_textbuf(obedit, first);
	kill_selection(obedit, 1);
	text_update_edited(C, scene, obedit, 1, 0);

	return OPERATOR_FINISHED;
}

static int insert_text_invoke(bContext *C, wmOperator *op, wmEvent *evt)
{
	Scene *scene= CTX_data_scene(C);
	Object *obedit= CTX_data_edit_object(C);
	Curve *cu= obedit->data;
	EditFont *ef= cu->editfont;
	static int accentcode= 0;
	unsigned long ascii = evt->ascii;
	int alt= evt->alt, shift= evt->shift, ctrl= evt->ctrl;
	int event= evt->type, val= evt->val;
	wchar_t inserted_text[2]= {0};

	if(RNA_property_is_set(op->ptr, "text"))
		return insert_text_exec(C, op);
	
	/* tab should exit editmode, but we allow it to be typed using modifier keys */
	if(event==TABKEY) {
		if((alt||ctrl||shift) == 0)
			return OPERATOR_PASS_THROUGH;
		else
			ascii= 9;
	}
	else if(event==BACKSPACEKEY)
		ascii= 0;

	if(val && ascii) {
		/* handle case like TAB (== 9) */
		if((ascii > 31 && ascii < 254 && ascii != 127) || (ascii==13) || (ascii==10) || (ascii==8)) {
			if(accentcode) {
				if(cu->pos>0) {
					inserted_text[0]= findaccent(ef->textbuf[cu->pos-1], ascii);
					ef->textbuf[cu->pos-1]= inserted_text[0];
				}
				accentcode= 0;
			}
			else if(cu->len<MAXTEXT-1) {
				if(alt) {
					/* might become obsolete, apple has default values for this, other OS's too? */
					if(ascii=='t') ascii= 137;
					else if(ascii=='c') ascii= 169;
					else if(ascii=='f') ascii= 164;
					else if(ascii=='g') ascii= 176;
					else if(ascii=='l') ascii= 163;
					else if(ascii=='r') ascii= 174;
					else if(ascii=='s') ascii= 223;
					else if(ascii=='y') ascii= 165;
					else if(ascii=='.') ascii= 138;
					else if(ascii=='1') ascii= 185;
					else if(ascii=='2') ascii= 178;
					else if(ascii=='3') ascii= 179;
					else if(ascii=='%') ascii= 139;
					else if(ascii=='?') ascii= 191;
					else if(ascii=='!') ascii= 161;
					else if(ascii=='x') ascii= 215;
					else if(ascii=='>') ascii= 187;
					else if(ascii=='<') ascii= 171;
				}

				inserted_text[0]= ascii;
				insert_into_textbuf(obedit, ascii);
			}
			
			kill_selection(obedit, 1);
			text_update_edited(C, scene, obedit, 1, 0);
		}
		else {
			inserted_text[0]= ascii;
			insert_into_textbuf(obedit, ascii);
			text_update_edited(C, scene, obedit, 1, 0);
		}
	}
	else if(val && event == BACKSPACEKEY) {
		if(alt && cu->len!=0 && cu->pos>0)
			accentcode= 1;

		return OPERATOR_PASS_THROUGH;
	}
	else
		return OPERATOR_PASS_THROUGH;

	if(inserted_text[0]) {
		/* store as utf8 in RNA string */
		char inserted_utf8[8] = {0};

		wcs2utf8s(inserted_utf8, inserted_text);
		RNA_string_set(op->ptr, "text", inserted_utf8);
	}

	return OPERATOR_FINISHED;
}

void FONT_OT_insert_text(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Insert Text";
	ot->idname= "FONT_OT_insert_text";
	
	/* api callbacks */
	ot->exec= insert_text_exec;
	ot->invoke= insert_text_invoke;
	ot->poll= ED_operator_editfont;
	
	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;

	/* properties */
	RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");
}

/***************** editmode enter/exit ********************/

void make_editText(Object *obedit)
{
	Curve *cu= obedit->data;
	EditFont *ef= cu->editfont;
	
	if(ef==NULL) {
		ef= cu->editfont= MEM_callocN(sizeof(EditFont), "editfont");
	
		ef->textbuf= MEM_callocN((MAXTEXT+4)*sizeof(wchar_t), "texteditbuf");
		ef->textbufinfo= MEM_callocN((MAXTEXT+4)*sizeof(CharInfo), "texteditbufinfo");
		ef->copybuf= MEM_callocN((MAXTEXT+4)*sizeof(wchar_t), "texteditcopybuf");
		ef->copybufinfo= MEM_callocN((MAXTEXT+4)*sizeof(CharInfo), "texteditcopybufinfo");	
		ef->oldstr= MEM_callocN((MAXTEXT+4)*sizeof(wchar_t), "oldstrbuf");
		ef->oldstrinfo= MEM_callocN((MAXTEXT+4)*sizeof(wchar_t), "oldstrbuf");
	}
	
	// Convert the original text to wchar_t
	utf8towchar(ef->textbuf, cu->str);
	wcscpy(ef->oldstr, ef->textbuf);
		
	cu->len= wcslen(ef->textbuf);
	
	memcpy(ef->textbufinfo, cu->strinfo, (cu->len)*sizeof(CharInfo));
	memcpy(ef->oldstrinfo, cu->strinfo, (cu->len)*sizeof(CharInfo));

	if(cu->pos>cu->len) cu->pos= cu->len;

	if(cu->pos)
		cu->curinfo = ef->textbufinfo[cu->pos-1];
	else
		cu->curinfo = ef->textbufinfo[0];
	
	// Convert to UTF-8
	update_string(cu);
}

void load_editText(Object *obedit)
{
	Curve *cu= obedit->data;
	EditFont *ef= cu->editfont;
	
	MEM_freeN(ef->oldstr);
	ef->oldstr= NULL;
	MEM_freeN(ef->oldstrinfo);
	ef->oldstrinfo= NULL;
	
	update_string(cu);
	
	if(cu->strinfo)
		MEM_freeN(cu->strinfo);
	cu->strinfo= MEM_callocN((cu->len+4)*sizeof(CharInfo), "texteditinfo");
	memcpy(cu->strinfo, ef->textbufinfo, (cu->len)*sizeof(CharInfo));

	cu->len= strlen(cu->str);
	
	/* this memory system is weak... */
	
	if(cu->selboxes) {
		MEM_freeN(cu->selboxes);
		cu->selboxes= NULL;
	}
}

void free_editText(Object *obedit)
{
	BKE_free_editfont((Curve *)obedit->data);
}

/********************** set case operator *********************/

static EnumPropertyItem case_items[]= {
	{CASE_LOWER, "LOWER", "Lower", ""},
	{CASE_UPPER, "UPPER", "Upper", ""},
	{0, NULL, NULL, NULL}};

static int set_case(bContext *C, int ccase)
{
	Scene *scene= CTX_data_scene(C);
	Object *obedit= CTX_data_edit_object(C);
	Curve *cu= obedit->data;
	EditFont *ef= cu->editfont;
	wchar_t *str;
	int len;
	
	len= wcslen(ef->textbuf);
	str= ef->textbuf;
	while(len) {
		if(*str>='a' && *str<='z')
			*str-= 32;
		len--;
		str++;
	}
	
	if(ccase == CASE_LOWER) {
		len= wcslen(ef->textbuf);
		str= ef->textbuf;
		while(len) {
			if(*str>='A' && *str<='Z') {
				*str+= 32;
			}
			len--;
			str++;
		}
	}

	text_update_edited(C, scene, obedit, 1, 0);

	return OPERATOR_FINISHED;
}

static int set_case_exec(bContext *C, wmOperator *op)
{
	return set_case(C, RNA_enum_get(op->ptr, "case"));
}

void FONT_OT_set_case(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Set Case";
	ot->idname= "FONT_OT_set_case";
	
	/* api callbacks */
	ot->exec= set_case_exec;
	ot->poll= ED_operator_editfont;

	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;

	/* properties */
	RNA_def_enum(ot->srna, "case", case_items, CASE_LOWER, "Case", "Lower or upper case.");
}

/********************** toggle case operator *********************/

static int toggle_case_exec(bContext *C, wmOperator *op)
{
	Object *obedit= CTX_data_edit_object(C);
	Curve *cu= obedit->data;
	EditFont *ef= cu->editfont;
	wchar_t *str;
	int len, ccase= CASE_UPPER;
	
	len= wcslen(ef->textbuf);
	str= ef->textbuf;
	while(len) {
		if(*str>='a' && *str<='z') {
			ccase= CASE_LOWER;
			break;
		}

		len--;
		str++;
	}
	
	return set_case(C, ccase);
}

void FONT_OT_toggle_case(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Toggle Case";
	ot->idname= "FONT_OT_toggle_case";
	
	/* api callbacks */
	ot->exec= toggle_case_exec;
	ot->poll= ED_operator_editfont;

	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
}

/* **************** undo for font object ************** */

static void undoFont_to_editFont(void *strv, void *ecu)
{
	Curve *cu= (Curve *)ecu;
	EditFont *ef= cu->editfont;
	char *str= strv;

	cu->pos= *((short *)str);
	cu->len= *((short *)(str+2));

	memcpy(ef->textbuf, str+4, (cu->len+1)*sizeof(wchar_t));
	memcpy(ef->textbufinfo, str+4 + (cu->len+1)*sizeof(wchar_t), cu->len*sizeof(CharInfo));
	
	cu->selstart = cu->selend = 0;
	
	update_string(cu);
}

static void *editFont_to_undoFont(void *ecu)
{
	Curve *cu= (Curve *)ecu;
	EditFont *ef= cu->editfont;
	char *str;
	
	// The undo buffer includes [MAXTEXT+6]=actual string and [MAXTEXT+4]*sizeof(CharInfo)=charinfo
	str= MEM_callocN((MAXTEXT+6)*sizeof(wchar_t) + (MAXTEXT+4)*sizeof(CharInfo), "string undo");

	// Copy the string and string information
	memcpy(str+4, ef->textbuf, (cu->len+1)*sizeof(wchar_t));
	memcpy(str+4 + (cu->len+1)*sizeof(wchar_t), ef->textbufinfo, cu->len*sizeof(CharInfo));

	*((short *)str)= cu->pos;
	*((short *)(str+2))= cu->len;	
	
	return str;
}

static void free_undoFont(void *strv)
{
	MEM_freeN(strv);
}

static void *get_undoFont(bContext *C)
{
	Object *obedit= CTX_data_edit_object(C);
	if(obedit && obedit->type==OB_FONT) {
		return obedit->data;
	}
	return NULL;
}

/* and this is all the undo system needs to know */
void undo_push_font(bContext *C, char *name)
{
	undo_editmode_push(C, name, get_undoFont, free_undoFont, undoFont_to_editFont, editFont_to_undoFont, NULL);
}