/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 *
 * The contents of this file are subject to the Netscape Public License
 * Version 1.0 (the "NPL"); you may not use this file except in
 * compliance with the NPL.  You may obtain a copy of the NPL at
 * http://www.mozilla.org/NPL/
 *
 * Software distributed under the NPL is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
 * for the specific language governing rights and limitations under the
 * NPL.
 *
 * The Initial Developer of this code under the NPL is Netscape
 * Communications Corporation.  Portions created by Netscape are
 * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
 * Reserved.
 */

/*
   editor.c --- XFE editor functions
   Created: Spencer Murray <spence@netscape.com>, 11-Jan-96.
 */


#include "mozilla.h"
#include "xfe.h"
#include "selection.h"

#include "net.h"

#ifdef EDITOR

#include <X11/keysym.h>   /* for editor key translation */
#include <Xm/CutPaste.h>   /* for editor key translation */


#include <Xfe/Xfe.h>		/* for xfe widgets and utilities */

#include <xpgetstr.h>     /* for XP_GetString() */
#include <edttypes.h>
#include <edt.h>
#include <layout.h>
#include <layers.h>
#include <secnav.h>
#include <prefapi.h>

#include "menu.h"
#include "fonts.h"
#include "felocale.h"
#include "intl_csi.h"

#endif  /* EDITOR */

#include "xeditor.h"

#ifdef EDITOR

#include "il_icons.h"           /* Image icon enumeration. */

#ifdef JAVA
#include "edtplug.h"
#endif

#define CB_STATIC static      /* let commands.c see it */

#define XFE_EDITOR_IM_SUPPORT 1

/*  Our event loop doesn't have workprocs, so we can't have two modal
 *  dialog conditions (one from frontend, one from backend)
#define EVENT_LOOP_HAS_WORKPROC
*/
extern int XFE_EDITOR_NEW_DOCNAME;
extern int XFE_WARNING_AUTO_SAVE_NEW_MSG;
extern int XFE_FILE_OPEN;
extern int XFE_EDITOR_ALERT_FRAME_DOCUMENT;
extern int XFE_EDITOR_ALERT_ABOUT_DOCUMENT;
extern int XFE_ALERT_SAVE_CHANGES;
extern int XFE_WARNING_SAVE_CHANGES;
extern int XFE_ERROR_GENERIC_ERROR_CODE;
extern int XFE_EDITOR_COPY_DOCUMENT_BUSY;
extern int XFE_EDITOR_COPY_SELECTION_EMPTY;
extern int XFE_EDITOR_COPY_SELECTION_CROSSES_TABLE_DATA_CELL;
extern int XFE_EDITOR_COPY_DOCUMENT_BUSY;
extern int XFE_COMMAND_EMPTY;
extern int XFE_EDITOR_HTML_EDITOR_COMMAND_EMPTY;
extern int XFE_EDITOR_IMAGE_EDITOR_COMMAND_EMPTY;
extern int XFE_ACTION_SYNTAX_ERROR;
extern int XFE_ACTION_WRONG_CONTEXT;
extern int XFE_EDITOR_WARNING_REMOVE_LINK;
extern int XFE_UNKNOWN;
extern int XFE_ERROR_COPYRIGHT_HINT;
extern int XFE_ERROR_SAVING_OPTIONS;
extern int XFE_ERROR_READ_ONLY;
extern int XFE_ERROR_BLOCKED;
extern int XFE_ERROR_BAD_URL;
extern int XFE_ERROR_FILE_OPEN;
extern int XFE_ERROR_FILE_WRITE;
extern int XFE_ERROR_CREATE_BAKNAME;
extern int XFE_ERROR_DELETE_BAKFILE;
extern int XFE_ERROR_WRITING_FILE;
extern int XFE_ERROR_SRC_NOT_FOUND;
extern int XFE_WARNING_SAVE_CONTINUE;
extern int XFE_EDITOR_DOCUMENT_TEMPLATE_EMPTY;
extern int XFE_EDITOR_BROWSE_LOCATION_EMPTY;
extern int XFE_UPLOADING_FILE;
extern int XFE_SAVING_FILE;
extern int XFE_LOADING_IMAGE_FILE;
extern int XFE_FILE_N_OF_N;
extern int XFE_PREPARE_UPLOAD;

extern void fe_MailComposeDocumentLoaded(MWContext*);
extern void fe_HackEditorNotifyToolbarUpdated(MWContext* context);

static void
fe_Bell(MWContext* context)
{
    XBell(XtDisplay(CONTEXT_WIDGET(context)), 0);
}

/*
 *    Utility stuff that should be somewhere else.
 */
static Widget
fe_CreateFormDialog(MWContext* context, char* name)
{
  Widget mainw = CONTEXT_WIDGET(context);
  Widget form;
  Arg    av[20];
  int    ac;
  Visual* v = 0;
  Colormap cmap = 0;
  Cardinal depth = 0;

  /*
   *    Inherit MainW attributes.
   */
  XtVaGetValues(mainw, XtNvisual, &v, XtNcolormap, &cmap,
		XtNdepth, &depth, 0);
  ac = 0;
  XtSetArg(av[ac], XmNvisual, v); ac++;
  XtSetArg(av[ac], XmNdepth, depth); ac++;
  XtSetArg(av[ac], XmNcolormap, cmap); ac++;
  XtSetArg(av[ac], XmNtransientFor, mainw); ac++;

  XtSetArg(av[ac], XmNallowShellResize, TRUE); ac++;
  XtSetArg(av[ac], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL); ac++;
  XtSetArg(av[ac], XmNautoUnmanage, False); ac++;

  form = XmCreateFormDialog(mainw, name, av, ac);

  return form;
}

static int fe_GetStandardPixmap_pixmapsInitialized;

static Pixmap
fe_GetStandardPixmap(MWContext* context, char type)
{
  Widget mainw = CONTEXT_WIDGET(context);
  Arg    av[20];
  int    ac;
  Cardinal depth;
  Screen* screen;
  Pixel   fg;
  Pixel   bg;
  char* name;
  Pixmap pixmap;

  switch (type) {
  case XmDIALOG_ERROR:       name = "xm_error";       break;
  case XmDIALOG_INFORMATION: name = "xm_information"; break;
  case XmDIALOG_QUESTION:    name = "xm_question";    break;
  case XmDIALOG_WARNING:     name = "xm_warning";     break;
  case XmDIALOG_WORKING:     name = "xm_working";     break;
  default:
    return XmUNSPECIFIED_PIXMAP;
  }

  /*
   *    This is so broken. Init MesageBox class, so the Motif
   *    standard icons get installed. YUCK..djw
   */
  if (!fe_GetStandardPixmap_pixmapsInitialized) {
    XtInitializeWidgetClass(xmMessageBoxWidgetClass);
    fe_GetStandardPixmap_pixmapsInitialized++;
  }

  /*
   *    Inherit MainW attributes.
   */
  ac = 0;
  XtSetArg(av[ac], XmNbackground, &bg); ac++;
  XtSetArg(av[ac], XmNforeground, &fg); ac++;
  XtSetArg(av[ac], XmNdepth, &depth); ac++;
  XtSetArg(av[ac], XmNscreen, &screen); ac++;
  XtGetValues(mainw, av, ac);

  pixmap = XmGetPixmapByDepth(screen, name, fg, bg, depth);
  if (pixmap == XmUNSPECIFIED_PIXMAP) {
    char default_name[256];

    strcpy(default_name, "default_");
    strcat(default_name, name);

    pixmap = XmGetPixmapByDepth(screen, default_name, fg, bg, depth);
  }

  return pixmap;
}

XtPointer
fe_GetUserData(Widget widget)
{
    void* rv;
    XtVaGetValues(widget, XmNuserData, &rv, 0);
    return rv;
}

static struct {
  unsigned type;
  char*    name;
} fe_CreateYesToAllDialog_button_data[] = {
  { XFE_DIALOG_YES_BUTTON,      "yes"      }, 
  { XFE_DAILOG_YESTOALL_BUTTON, "yesToAll" },
  { XFE_DIALOG_NO_BUTTON,       "no"       },
  { XFE_DIALOG_NOTOALL_BUTTON,  "noToAll"  },
  { XFE_DIALOG_CANCEL_BUTTON,   "cancel"   },
  { 0, NULL }
};



#define XFE_YESTOALL_YES_BUTTON      (fe_CreateYesToAllDialog_button_data[0].name)
#define XFE_YESTOALL_YESTOALL_BUTTON (fe_CreateYesToAllDialog_button_data[1].name)
#define XFE_YESTOALL_NO_BUTTON       (fe_CreateYesToAllDialog_button_data[2].name)
#define XFE_YESTOALL_NOTOALL_BUTTON  (fe_CreateYesToAllDialog_button_data[3].name)
#define XFE_YESTOALL_CANCEL_BUTTON   (fe_CreateYesToAllDialog_button_data[4].name)

typedef struct {
    Widget widget;
    char*  name;
} GetChildInfo;

static XtPointer
fe_YesToAllDialogGetChildMappee(Widget widget, XtPointer data)
{
    GetChildInfo* info = (GetChildInfo*)data;
    char*         name = XtName(widget);
    
    if (strcmp(info->name, name) == 0) {
	info->widget = widget;
	return (XtPointer)1; /* don't look any more */
    }
    return 0;
}

Widget
fe_YesToAllDialogGetChild(Widget parent, unsigned char type)
{
  char*        name;
  GetChildInfo info;

  switch (type) {
  case XFE_DIALOG_YES_BUTTON:
    name = XFE_YESTOALL_YES_BUTTON;
    break;
  case XFE_DAILOG_YESTOALL_BUTTON:
    name = XFE_YESTOALL_YESTOALL_BUTTON;
    break;
  case XFE_DIALOG_NO_BUTTON:
    name = XFE_YESTOALL_NO_BUTTON;
    break;
  case XFE_DIALOG_NOTOALL_BUTTON:
    name = XFE_YESTOALL_NOTOALL_BUTTON;
    break;
  case XFE_DIALOG_CANCEL_BUTTON:
    name = XFE_YESTOALL_CANCEL_BUTTON;
    break;
  default:
    return NULL; /* kill, kill, kill */
  }

  info.name = name;
  info.widget = NULL;
#ifdef OSF1
  fe_WidgetTreeWalk(parent, fe_YesToAllDialogGetChildMappee, (void *)&info);
#else
  fe_WidgetTreeWalk(parent, fe_YesToAllDialogGetChildMappee, &info);
#endif

  return info.widget;
}

static Widget
fe_CreateYesToAllDialog(MWContext* context, char* name, Arg* p_av, Cardinal p_ac)
{
  Arg      av[20];
  Cardinal ac;
  Widget   form;
  Widget   children[16];
  Cardinal nchildren = 0;
  Pixmap   pixmap;
  char* bname;
  Widget button;
  Widget icon;
  Widget text;
  Widget separator;
  Widget row;
  int i;
  XtCallbackRec* button_callback_rec = NULL;
  XmString msg_string = NULL;
  char namebuf[64];
  char pixmapType = XmDIALOG_WARNING;

  for (i = 0; i < p_ac; i++) {
      if (p_av[i].name == XmNarmCallback)
	  button_callback_rec = (XtCallbackRec*)p_av[i].value;
      else if (p_av[i].name == XmNmessageString)
	  msg_string = (XmString)p_av[i].value;
      else if (p_av[i].name == XmNdialogType)
	  pixmapType = (unsigned char)p_av[i].value;
  }

  form = fe_CreateFormDialog(context, name);

  strcpy(namebuf, name); strcat(namebuf, "Message");
  ac = 0;
  XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  XtSetArg(av[ac], XmNorientation, XmHORIZONTAL); ac++;
  XtSetArg(av[ac], XmNentryAlignment, XmALIGNMENT_CENTER); ac++;
  XtSetArg(av[ac], XmNisAligned, TRUE); ac++;
  XtSetArg(av[ac], XmNpacking, XmPACK_TIGHT); ac++;
  row = XmCreateRowColumn(form, namebuf, av, ac);

  nchildren = 0;

  /*
   *    Make pixmap label.
   */
  pixmap = fe_GetStandardPixmap(context, pixmapType);

  ac = 0;
  XtSetArg(av[ac], XmNlabelType, XmPIXMAP); ac++;
  XtSetArg(av[ac], XmNlabelPixmap, pixmap); ac++;
  icon = XmCreateLabelGadget(row, "icon", av, ac);
  children[nchildren++] = icon;

  /*
   *    Text.
   */
  ac = 0;
  if (msg_string)
    XtSetArg(av[ac], XmNlabelString, msg_string); ac++;
  XtSetArg(av[ac], XmNalignment, XmALIGNMENT_BEGINNING); ac++;
  XtSetArg(av[ac], XmNlabelType, XmSTRING); ac++;
  text = XmCreateLabelGadget(row, "text", av, ac);
  children[nchildren++] = text;

  XtManageChildren(children, nchildren); /* children of row */

  nchildren = 0;
  children[nchildren++] = row;

  /*
   *    Separator.
   */
  ac = 0;
  XtSetArg(av[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
  XtSetArg(av[ac], XmNtopWidget, row); ac++;
  XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  separator = XmCreateSeparatorGadget(form, "separator", av, ac);
  children[nchildren++] = separator;
 
  /*
   *    Yes, YesToAll, No, NoToAll, Cancel.
   */
  strcpy(namebuf, name); strcat(namebuf, "Buttons");
  ac = 0;
  XtSetArg(av[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
  XtSetArg(av[ac], XmNtopWidget, separator); ac++;
  XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  XtSetArg(av[ac], XmNorientation, XmHORIZONTAL); ac++;
  XtSetArg(av[ac], XmNentryAlignment, XmALIGNMENT_CENTER); ac++;
  XtSetArg(av[ac], XmNisAligned, TRUE); ac++;
  XtSetArg(av[ac], XmNpacking, XmPACK_COLUMN); ac++;
  row = XmCreateRowColumn(form, namebuf, av, ac);
  children[nchildren++] = row;

  XtManageChildren(children, nchildren);

  nchildren = 0; /* now do buttons */
  button = NULL;
  for (i = 0; (bname = fe_CreateYesToAllDialog_button_data[i].name); i++) {

    ac = 0;
    XtSetArg(av[ac], XmNalignment, XmALIGNMENT_CENTER); ac++;
    XtSetArg(av[ac], XmNlabelType, XmSTRING); ac++;
    button = XmCreatePushButtonGadget(row, bname, av, ac);

    if (button_callback_rec)
      XtAddCallback(
		    button,
		    XmNactivateCallback,
		    button_callback_rec->callback,
		    button_callback_rec->closure
		    );
    children[nchildren++] = button;
  }

  XtManageChildren(children, nchildren);

  return form;
}

Boolean
fe_EditorDocumentIsSaved(MWContext* context)
{
    History_entry* hist_ent;

	if (!context)
		return False;

	if (EDT_IS_NEW_DOCUMENT(context))
		return False;

    hist_ent = SHIST_GetCurrent(&context->hist);

    if (!hist_ent)
		return False;

	if (hist_ent->address != NULL && NET_IsLocalFileURL(hist_ent->address))
		return True;
	else
		return False;
}


Boolean fe_SaveAsDialog(MWContext* context, char* buf, int type);

static Boolean
fe_editor_report_file_error(MWContext*   context,
			    ED_FileError code,
			    char*        filename, 
			    Boolean      ask_question)
{
    int   id;
    char* msg;
    char  buf[MAXPATHLEN];

    switch (code) {
    case ED_ERROR_READ_ONLY: /* File is marked read-only */
	id = XFE_ERROR_READ_ONLY;
	break;
    case ED_ERROR_BLOCKED: /* Can't write at this time, edit buffer blocked */
	id = XFE_ERROR_BLOCKED;
	break;
    case ED_ERROR_BAD_URL: /* URL was not a "file:" type or no string */
	id = XFE_ERROR_BAD_URL;
	break;
    case ED_ERROR_FILE_OPEN:
	id = XFE_ERROR_FILE_OPEN;
	break;
    case ED_ERROR_FILE_WRITE:
	id = XFE_ERROR_FILE_WRITE;
	break;
    case ED_ERROR_CREATE_BAKNAME:
    case ED_ERROR_FILE_RENAME_TO_BAK:
	id = XFE_ERROR_CREATE_BAKNAME;
	break;
    case ED_ERROR_DELETE_BAKFILE:
	id = XFE_ERROR_DELETE_BAKFILE;
	break;
    case ED_ERROR_SRC_NOT_FOUND:
	id = XFE_ERROR_SRC_NOT_FOUND;
	break;
    default:
	id = XFE_ERROR_GENERIC_ERROR_CODE; /* generic "...code = (%d)" */
	break;
    }

    msg = XP_GetString(XFE_ERROR_WRITING_FILE);
    sprintf(buf, msg, filename);
    strcat(buf, "\n\n");

    msg = XP_GetString(id);
    sprintf(&buf[strlen(buf)], msg, code);

    if (ask_question) {
	strcat(buf, "\n\n");
	strcat(buf, XP_GetString(XFE_WARNING_SAVE_CONTINUE));
	return XFE_Confirm(context, buf);
    } else {
	FE_Alert(context, buf);
	return TRUE;
    }
}

static Boolean
fe_editor_save_common(MWContext* context, char* target_url)
{
    History_entry* hist_ent;
    ED_FileError   code;
    Boolean        images;
    Boolean        links;
    Boolean        save_as;

    /* url->address is used for filename */
    hist_ent = SHIST_GetCurrent(&context->hist);

    if (!hist_ent)
	return FALSE;

    /*
     *    Has the title changed since it was last saved?
     */
    if (hist_ent->title && strcmp(hist_ent->title, hist_ent->address) == 0) {
	/*
	 *    BE will set this to the new file, if we don't zap it,
	 *    BE will retain the old name - yuck!
	 */
	XP_FREE(hist_ent->title);
	hist_ent->title = NULL;
    }

    if (target_url) { /* save as */
	save_as = TRUE;
	/* fe_EditorPreferencesGetLinksAndImages(context, &links, &images); */
    } else { /* save me */ 
	target_url = hist_ent->address;
	save_as = FALSE;
	/* images = FALSE;
	links = FALSE; */
    }
    /* hardts, now always use prefs for links and images, Save and Save As 
     do the same thing for adjusting links and images */
    fe_EditorPreferencesGetLinksAndImages(context, &links, &images);

	/*
	 *    Do this before the save starts, as save very quickly gets
	 *    asynchronous.
	 */
    CONTEXT_DATA(context)->is_file_saving = True;

    /*
     *    EDT_SaveFile returns true if it completed immediately.
     *    savesas uses source and dest, save just uses 
     */
    code = EDT_SaveFile(context, hist_ent->address, target_url,
			save_as, images, links);

    /* here we spin and spin until all the savings of images
     * and stuff are done so that we get a "real" status back from
     * the backend.  This makes saving semi-synchronous, good for
     * status reporting
     */
	if (code == ED_ERROR_NONE) { /* we didn't error straight away */
		while(CONTEXT_DATA(context)->is_file_saving) {
			/* do nothing, we wait here */
			fe_EventLoop();
		}
	}

    code = CONTEXT_DATA(context)->file_save_status;
    if (code != ED_ERROR_NONE) {
	/*
	 *    I'm sure if it is bad if the title is NULL, but
	 *    just in case..
	 */
	if ((hist_ent = SHIST_GetCurrent(&context->hist)) != NULL
	    && 
	    hist_ent->title == NULL) {
	    hist_ent->title = XP_STRDUP(hist_ent->address);
	}
	fe_editor_report_file_error(context, code, target_url, FALSE);
	return FALSE;
    }

    return TRUE;
}

Boolean
fe_EditorSaveAs(MWContext* context) /* launches dialog */
{
    char filebuf[MAXPATHLEN];

    if (fe_SaveAsDialog(context, filebuf, fe_FILE_TYPE_HTML)) {
	
	char urlbuf[MAXPATHLEN];
	    
	PR_snprintf(urlbuf, sizeof(urlbuf), "file:%.900s", filebuf);

	return fe_editor_save_common(context, urlbuf);
    }

    return FALSE;
}

Boolean
fe_EditorSave(MWContext* context)
{
    /* 
     *    Always ask the user for the filename once.
     *
     *    if (EDT_IS_NEW_DOCUMENT(context))
     */
    if (!fe_EditorDocumentIsSaved(context)) {
		return fe_EditorSaveAs(context);
    }

    return fe_editor_save_common(context, NULL);
}

/*
 *    I18N input method support.
 */
#ifdef XFE_EDITOR_IM_SUPPORT
static void
fe_editor_im_deregister(Widget widget, XtPointer closure, XtPointer cb_data)
{
	if (!fe_globalData.editor_im_input_enabled)
		return;

    XmImUnregister(widget);
}

static void
fe_editor_im_get_coords(MWContext* context, XPoint* point)
{
    fe_EditorCaretData* data = &EDITOR_CONTEXT_DATA(context)->caret_data;
    
	if (!fe_globalData.editor_im_input_enabled)
		return;

    if (data->running == FALSE && data->showing == FALSE) {
		point->x = 0;
		point->y = 16;
    } else {
		point->x = data->x + data->width - CONTEXT_DATA(context)->document_x;
		point->y = data->y - 2 - CONTEXT_DATA(context)->document_y +
			data->height;
    }
#ifdef DEBUG_rhess2
	fprintf(stderr, "im_point::[ %d, %d ]\n", point->x, point->y);
#endif
}

static void
fe_editor_im_init(MWContext* context)
{
    Widget     widget = CONTEXT_DATA(context)->drawing_area;
    Arg        args[8];
    Cardinal   n;
    XmFontList font_list;
    Pixel      bg_pixel;
    Pixel      fg_pixel;
    /* Pixmap     bg_pixmap; */
    XPoint     xmim_point;
    /* int        xmim_height; */
    
	if (!fe_globalData.editor_im_input_enabled)
#ifdef DEBUG_rhess
		{
			fprintf(stderr, "fe_editor_im_init::[ PUNT ]\n");
		}
	else
		{
			fprintf(stderr, "fe_editor_im_init::[ ]\n");
		}
#else
		return;
#endif

    XtVaSetValues(CONTEXT_WIDGET(context), XmNallowShellResize, TRUE, NULL);

    XmImRegister(widget, 0);
    XtAddCallback(widget, XmNdestroyCallback, fe_editor_im_deregister, NULL);

    /*
     *    Should these change dynamically with point?
     */
#ifdef OSF1
    font_list = (void *)fe_GetFont(context, 3, LO_FONT_FIXED);
#else
    font_list = fe_GetFont(context, 3, LO_FONT_FIXED);
#endif
    bg_pixel = CONTEXT_DATA(context)->bg_pixel;
    fg_pixel = CONTEXT_DATA(context)->fg_pixel;
    /* bg_pixmap = CONTEXT_DATA(context)->backdrop_pixmap; */

    fe_editor_im_get_coords(context, &xmim_point);

    n = 0;
    XtSetArg(args[n], XmNfontList, font_list); n++;
    XtSetArg(args[n], XmNbackground, bg_pixel); n++;
    XtSetArg(args[n], XmNforeground, fg_pixel); n++;
    /* XtSetArg(args[n], XmNbackgroundPixmap, bg_pixmap); n++; */
    XtSetArg(args[n], XmNspotLocation, &xmim_point); n++;
    /* XtSetArg(args[n], XmNlineSpace, xmim_height); n++; */
    XmImSetValues(widget, args, n);
}

static void
fe_editor_im_set_coords(MWContext* context)
{
    Widget   widget = CONTEXT_DATA(context)->drawing_area;
    Arg      args[8];
    Cardinal n;
    XPoint   xmim_point;
    /* int      xmim_height; */

	if (!fe_globalData.editor_im_input_enabled)
		return;

    fe_editor_im_get_coords(context, &xmim_point);

    n = 0;
    XtSetArg(args[n], XmNspotLocation, &xmim_point); n++;
    /* XtSetArg(args[n], XmNlineSpace, xmim_height); n++; */
    XmImSetFocusValues(widget, args, n);
}

static void
fe_editor_im_focus_in(MWContext* context)
{
	if (!fe_globalData.editor_im_input_enabled)
		return;

    fe_editor_im_set_coords(context);

    XtSetKeyboardFocus(CONTEXT_WIDGET(context),
		       CONTEXT_DATA(context)->drawing_area);
}

static void
fe_editor_im_focus_out(MWContext* context)
{
    Widget widget = CONTEXT_DATA(context)->drawing_area;

	if (!fe_globalData.editor_im_input_enabled)
		return;

    XmImUnsetFocus(widget);
}
#endif /*XFE_EDITOR_IM_SUPPORT*/

static void fe_caret_pause(MWContext* context);
static void fe_caret_unpause(MWContext* context);

void
xfe2_EditorImSetCoords(MWContext* context)
{
	fe_editor_im_set_coords(context);
}

void
xfe2_EditorCaretShow(MWContext* context)
{
	fe_caret_unpause(context);
}

void
xfe2_EditorCaretHide(MWContext* context)
{
	fe_caret_pause(context);
}

void
xfe2_EditorWaitWhileContextBusy(MWContext* context)
{
	int  n = 0;

	while (XP_IsContextBusy(context)) {
		NET_ProcessNet(0, NET_EVERYTIME_TYPE);
#ifdef MOZ_MAIL_NEWS
		MSG_OnIdle();
#endif
#ifdef DEBUG_rhess
		fprintf(stderr, "tic::[ %d ]\n", n);
#endif
		n++;
	}
}

static void
fe_change_focus_eh(Widget w, XtPointer closure, XEvent* event, Boolean* cont)
{
    MWContext* context = (MWContext *)closure;

    *cont = TRUE;
    
    if (event->type == FocusIn) 
		{
			fe_caret_unpause(context);
#ifdef XFE_EDITOR_IM_SUPPORT
			fe_editor_im_focus_in(context);
#else
			XtSetKeyboardFocus(CONTEXT_WIDGET(context),
							   CONTEXT_DATA(context)->drawing_area);

#endif /*XFE_EDITOR_IM_SUPPORT*/
		} 
    else
		{
			fe_caret_pause(context);
#ifdef XFE_EDITOR_IM_SUPPORT
			fe_editor_im_focus_out(context);
#else
			XtSetKeyboardFocus(CONTEXT_WIDGET(context), NULL);
#endif /*XFE_EDITOR_IM_SUPPORT*/
      }
}

/*
 *    Menu stuff.
 */
typedef MWContext MWEditorContext; /* place holder */

/*
 *  NOTE: look in EditorFrame.cpp for new implementation...
 */

void
xfe2_EditorInit(MWContext* context)
{
	fe_EditorCaretData* data = &EDITOR_CONTEXT_DATA(context)->caret_data;
#if 0
	/*
	 *    Just cannot get this to do what it is supposed to.
	 */
	XtAddEventHandler(CONTEXT_WIDGET(context), PropertyChangeMask,
					  FALSE, (XtEventHandler)fe_property_notify_eh,
					  context);
#endif

	if (context->type == MWContextEditor) {
		/*
		 * NOTE:  the MWContextMessageComposition has it's own ev handler...
		 *
		 */
#ifdef DEBUG_rhess
		fprintf(stderr, "tag1::[ %p ]\n", CONTEXT_WIDGET(context));
#endif
		XtAddEventHandler(CONTEXT_WIDGET(context), FocusChangeMask,
						  FALSE, (XtEventHandler)fe_change_focus_eh,
						  context);
	}

	/*
	 *    Register with input server.
	 */
#ifdef XFE_EDITOR_IM_SUPPORT
	fe_editor_im_init(context);
#endif /*XFE_EDITOR_IM_SUPPORT*/

	/*
	 *  NOTE: initialize the caret data structure... [ may be overkill ]
	 */
	data->x = 0;
	data->y = 0;
	data->width = 0;
	data->height = 0;
	data->time = 0;
	data->timer_id = 0;
	data->showing = FALSE;
	data->running = FALSE;
	data->backing_store = 0;
}

char*
fe_EditorGetTemplateURL(MWContext* context)
{
    char* template_url = fe_EditorPreferencesGetTemplate(context);
 
    if (template_url == NULL || template_url[0] == '\0') {
		char* msg = XP_GetString(XFE_EDITOR_DOCUMENT_TEMPLATE_EMPTY);

		/* The new document template location is not set. */
      	if (XFE_Confirm(context, msg)) {
			fe_EditorPreferencesDialogDo(context,
									 XFE_EDITOR_DOCUMENT_PROPERTIES_GENERAL);
		}
		return NULL;
    }

	return template_url;
}

char*
fe_EditorGetWizardURL(MWContext* context)
{
	return XFE_WIZARD_TEMPLATE_URL;
}

void
fe_EditorDisplaySource(MWContext* context)
{
    EDT_DisplaySource(context);
}

void
fe_NukeCaret(MWContext * context)
{
	fe_EditorCaretData* data = &EDITOR_CONTEXT_DATA(context)->caret_data;

#if DEBUG_rhess2
	fprintf(stderr, "fe_NukeCaret::[ ]\n");
#endif

	data->x = 0;
	data->y = 0;
	data->width = 0;
	data->height = 0;
	data->time = 0;
	data->timer_id = 0;
	data->showing = False;
	data->running = False;
	data->backing_store = 0;
}

void
fe_EditorCleanup(MWContext* context)
{
    Boolean  as_enabled;
    unsigned as_time;

	/*
	 *    If they have autosave on, try to do a save. Don't do it
	 *    for a new doc, as that'll mean dialogs, and .....
	 */
	if (context->type != MWContextMessageComposition &&
            !EDT_IS_NEW_DOCUMENT(context) &&
		(!EDT_IsBlocked(context) && EDT_DirtyFlag(context))) {
		fe_EditorPreferencesGetAutoSave(context, &as_enabled, &as_time);
		if (as_enabled)
			fe_EditorSave(context);
	}

    fe_NukeCaret(context);
    EDT_DestroyEditBuffer(context);
}

char*
fe_EditorMakeName(MWContext* context, char* buf, unsigned maxsize)
{
    History_entry* entry;
    char*          local_name = NULL;

    if (!EDT_IS_NEW_DOCUMENT(context)
	&&
	(entry = SHIST_GetCurrent(&context->hist)) && (entry->address)) {

	local_name = NULL;
	if (XP_ConvertUrlToLocalFile(entry->address, &local_name)) {
	    FE_CondenseURL(buf, local_name, maxsize);
	    XP_FREE(local_name);
	} else {
	    FE_CondenseURL(buf, entry->address, maxsize);
	}
    } else {
	strcpy(buf, XP_GetString(XFE_EDITOR_NEW_DOCNAME));
    }
    return buf;
}

static Boolean
fe_named_question(MWContext* context, char* name, char* message)
{
    return (Boolean)((int)fe_dialog(CONTEXT_WIDGET (context),
				    name, message,
				    TRUE, 0, TRUE, FALSE, 0));
}

Boolean
fe_save_file_check(MWContext* context, Boolean file_must_exist, Boolean autoSaveNew)
{
    int rv;
    char filename[MAXPATHLEN];
    char buf[MAXPATHLEN];
    char dialogmessages[MAXPATHLEN+64];
    Boolean ok_cancel = (file_must_exist && EDT_IS_NEW_DOCUMENT(context));

    if (ok_cancel || EDT_DirtyFlag(context)) {
	fe_EditorMakeName(context, filename, sizeof(filename));
	
	if (ok_cancel) {
	    /* You must save <filename> as a local file */
	    sprintf(buf, XP_GetString(XFE_ALERT_SAVE_CHANGES), filename);
	    rv = (fe_named_question(context, "saveNewFile", buf))?
		XmDIALOG_OK_BUTTON: XmDIALOG_CANCEL_BUTTON;
	} else {
	    /* Save changes to <filename>? */
	    sprintf(buf, XP_GetString(XFE_WARNING_SAVE_CHANGES), filename);
	    if (autoSaveNew) {
            sprintf(dialogmessages,"%s\n\n%s", buf,
                    XP_GetString(XFE_WARNING_AUTO_SAVE_NEW_MSG));
			rv = fe_YesNoCancelDialog(context, "autoSaveNew", dialogmessages);
		} else
			rv = fe_YesNoCancelDialog(context, "saveFile", buf);
	}
	
	if (rv == XmDIALOG_OK_BUTTON)
	    return fe_EditorSave(context);
	else if (rv == XmDIALOG_CANCEL_BUTTON)
	    return FALSE;
    }
    return TRUE;
}

XP_Bool
FE_CheckAndSaveDocument(MWContext* context)
{
    return fe_save_file_check(context, TRUE, FALSE);
}

XP_Bool 
FE_CheckAndAutoSaveDocument(MWContext *context)
{
    return fe_save_file_check(context, FALSE, TRUE);
}

/*
 *    NOTE: this routine is currently commented out, always returns TRUE.
 *    Call this to check if we need to force saving file
 *    Conditions are New, unsaved document and when editing a remote file
 *    Returns TRUE for all cases except CANCEL by the user in any dialog
 */
XP_Bool
FE_SaveNonLocalDocument(MWContext* context, XP_Bool save_new_document) 
{
#if 0
    History_entry* hist_entry;
    int type;
    Boolean links;
    Boolean images;
    Boolean save;
    char filebuf[MAXPATHLEN];
    char urlbuf[MAXPATHLEN];
    ED_FileError file_error;

    if (context == NULL || !EDT_IS_EDITOR(context)) {
        return TRUE;
    }
    
    hist_entry = SHIST_GetCurrent(&(context->hist));
    if (!hist_entry || !hist_entry->address)
        return TRUE;
    
    /*
     */
    type = NET_URL_Type(hist_entry->address);

    if ((type >  0 && type != FILE_TYPE_URL && type != FILE_CACHE_TYPE_URL &&
         type != MAILBOX_TYPE_URL && type != VIEW_SOURCE_TYPE_URL)
	||
	(save_new_document && EDT_IS_NEW_DOCUMENT(context)))
    {
	fe_EditorPreferencesGetLinksAndImages(context, &links, &images);
	fe_DoSaveRemoteDialog(context, &save, &links, &images);

	if (!save)
	    return FALSE;

#if 0
	if (!EDT_IS_NEW_DOCUMENT(context))
	    fe_EditorCopyrightWarningDialogDo();
#endif
	
	if (!fe_SaveAsDialog(context, filebuf, fe_FILE_TYPE_HTML))
	    return FALSE;

	/*
	 *    Grab the filename while we have it to form file: path.
	 */
	PR_snprintf(urlbuf, sizeof(urlbuf), "file:%.900s", filebuf);

	/* the c++ comments are here deliberately so that later
	 * on if we use this code we won't forget to modify it */

	/* this here is all disabled, we don't use it anymore but if later
	 * on we need to use it again, we should probably make it synchronous
	 */

	file_error = EDT_SaveFile(context,
				  hist_entry->address,
				  urlbuf,
				  TRUE,
				  images,
				  links);
	
    	if (file_error != ED_ERROR_NONE) {
	    fe_editor_report_file_error(context, file_error, urlbuf,
					FALSE);
	    return FALSE;
	}
    }
#endif
    return TRUE;
}


CB_STATIC void
fe_editor_delete_cb(Widget widget, XtPointer closure, XtPointer call_data)
{
    MWContext *context = (MWContext *)closure;

    fe_UserActivity (context);

    if (fe_WindowCount == 1) {
	fe_QuitCallback(widget, closure, call_data);
    }  else {
	if (fe_save_file_check(context, FALSE, FALSE))
	    fe_EditorDelete(context);
    }
}

void fe_editor_delete_response(Widget widget, XtPointer closure, XtPointer call_data)
{
	fe_editor_delete_cb(widget, closure, call_data);
}


Boolean
fe_EditorCheckUnsaved(MWContext* context)
{
    struct fe_MWContext_cons* rest;

    for (rest = fe_all_MWContexts; rest; rest = rest->next) {
	MWContext* context = rest->context;
	if (context->type == MWContextEditor) {
	    if (!fe_save_file_check(context, FALSE, FALSE)) {
		return FALSE;
	    }
	}
    }
    return TRUE;
}

void
fe_EditorReload(MWContext* context, Boolean super_reload)
{
    if (EDT_IS_NEW_DOCUMENT(context))
		return; /* only from action */

    if (!FE_CheckAndSaveDocument(context))
		return;

#if 0 /* this does not exist! */
    EDT_Reload(context);
#else
    if (super_reload)
		fe_ReLayout (context, NET_SUPER_RELOAD);
    else
		fe_ReLayout (context, NET_NORMAL_RELOAD);
#endif
}

void
fe_EditorFind(MWContext* context)
{
    MWContext* top_context = XP_GetNonGridContext(context);
    
    if (!top_context)
	top_context = context;

    fe_UserActivity(top_context);

    fe_FindAndReplaceDialog(top_context, False);
}

Boolean
fe_EditorCanFindAgain(MWContext* context)
{
    fe_FindData* find_data = CONTEXT_DATA(context)->find_data;
    
    return ((find_data != NULL)
	    &&
	    (find_data->string != NULL)
	    &&
	    (find_data->string[0] != '\0'));
}

void
fe_EditorFindAgain(MWContext* context)
{
    MWContext*   top_context = XP_GetNonGridContext(context);
    fe_FindData* find_data;

    if (!top_context)
	top_context = context;

    fe_UserActivity(top_context);

    find_data = CONTEXT_DATA(top_context)->find_data;

  if (fe_EditorCanFindAgain(top_context))
      fe_FindAndReplaceDialog(top_context, TRUE);
  else
      fe_Bell(context);
}

Boolean
fe_EditorCanRemoveLinks(MWContext* context)
{
    ED_ElementType type = EDT_GetCurrentElementType(context);
    Boolean        sensitive = FALSE;

	if ((type == ED_ELEMENT_TEXT ||
		 type == ED_ELEMENT_SELECTION ||
		 type == ED_ELEMENT_IMAGE)
		&&
		EDT_CanSetHREF(context)) {
		sensitive = TRUE;
    }
	return sensitive;
}

void
fe_EditorInsertLinkDialogDo(MWContext* context)
{
#if 0
    if (EDT_IS_NEW_DOCUMENT(context)) {
		if (!FE_CheckAndSaveDocument(context))
			return;
    }
#endif

    fe_EditorPropertiesDialogDo(context, XFE_EDITOR_PROPERTIES_LINK_INSERT);
}

/* -------------------------------------------------------------- */

/*
 *    Size Group.
 */

void
fe_EditorFontSizeSet(MWContext* context, ED_FontSize edt_size)
{
    if (edt_size >= EDT_FONTSIZE_MIN && edt_size <= EDT_FONTSIZE_MAX) {
#if 1
	EDT_SetFontSize(context, edt_size);
#else
	/* this does not work */
	EDT_CharacterData* edt_cdata = EDT_GetCharacterData(context);
	edt_cdata->mask = TF_FONT_SIZE;
	edt_cdata->values = TF_FONT_SIZE;
	edt_cdata->iSize = edt_size;
	EDT_SetCharacterData(context, edt_cdata);
	EDT_FreeCharacterData(edt_cdata);
#endif
    } else {
	fe_Bell(context);
    }

    fe_EditorUpdateToolbar(context, TF_FONT_SIZE);
}

ED_FontSize
fe_EditorFontSizeGet(MWContext* context)
{
    EDT_CharacterData* edt_cdata = EDT_GetCharacterData(context);
    intn               edt_size;

	if (edt_cdata != NULL) {
		edt_size = edt_cdata->iSize;
		if (edt_size < EDT_FONTSIZE_MIN)
			edt_size = ED_FONTSIZE_ZERO;
		EDT_FreeCharacterData(edt_cdata);
	} else {
		edt_size = ED_FONTSIZE_DEFAULT;
	}

    return (ED_FontSize)edt_size;
}

Widget
fe_OptionMenuSetHistory(Widget menu, unsigned index)
{
    Arg        args[4];
    Cardinal   n;
    Widget     cascade;
    Widget     popup_menu;
    WidgetList children;
    Cardinal   nchildren;

    /*
     *   Update the label, and set the position of the popup.
     */
    cascade = XmOptionButtonGadget(menu);

    /*
     *    Get the popup menu from the cascade.
     */
    n = 0;
    XtSetArg(args[n], XmNsubMenuId, &popup_menu); n++;
    XtGetValues(cascade, args, n);

    /*
     *    Get the children of the popup.
     */
    n = 0;
    XtSetArg(args[n], XmNchildren, &children); n++;
    XtSetArg(args[n], XmNnumChildren, &nchildren); n++;
    XtGetValues(popup_menu, args, n);
    if (index < nchildren) {
	/*
	 *    Finally, set the Nth button as history.
	 */
	n = 0;
	XtSetArg(args[n], XmNmenuHistory, children[index]); n++;
	/* NOTE: set it on the top level menu (strange) */
	XtSetValues(menu, args, n);
	
	return children[index];
    }
    return NULL;
}

/* -------------------------------------------------------------- */
/*
 *    Text Attribute set.
 */
void
fe_EditorCharacterPropertiesSet(MWContext* context, ED_TextFormat values)
{
    EDT_CharacterData cdata;

    memset(&cdata, 0, sizeof(EDT_CharacterData));

    cdata.mask = TF_ALL_MASK;
    if (values == TF_NONE) {   /* pop everything */
	cdata.values = 0;
    } else if (values == (TF_SERVER|TF_SCRIPT)) {
	cdata.mask = TF_SERVER|TF_SCRIPT;
	cdata.values = 0;
    } else if (values == TF_SERVER || values == TF_SCRIPT) {
	cdata.mask = TF_SERVER|TF_SCRIPT;
	cdata.values = values;
    } else {
	values &= TF_ALL_MASK; /* don't let them shoot themselves */
	cdata.values = values;
    }

    EDT_SetCharacterData(context, &cdata);

    fe_EditorUpdateToolbar(context, values);
}

ED_TextFormat
fe_EditorCharacterPropertiesGet(MWContext* context)
{
    EDT_CharacterData* edt_cdata = EDT_GetCharacterData(context);
	ED_TextFormat      values;

	if (edt_cdata != NULL) {
		values = edt_cdata->values;
		EDT_FreeCharacterData(edt_cdata);
	} else {
		values = TF_NONE;
	}
    
    return values;
}

void
fe_EditorDoPoof(MWContext* context)
{
    Boolean            clear_link = TRUE;
    EDT_CharacterData* pData;
	
    if (EDT_SelectionContainsLink(context)) {
	/*Do you want to remove the link?*/
	if (!XFE_Confirm(context,
			 XP_GetString(XFE_EDITOR_WARNING_REMOVE_LINK)))
	    clear_link = FALSE;
    }

    if (clear_link) {
	EDT_FormatCharacter(context, TF_NONE);
    } else {
	pData = EDT_GetCharacterData(context);
        if (pData) {
            pData->mask = ~TF_HREF;
            pData->values = TF_NONE;
            EDT_SetCharacterData(context, pData);
            EDT_FreeCharacterData(pData);
        }
    }
    fe_EditorUpdateToolbar(context, 0);
}

/* -------------------------------------------------------------- */
/*
 *    Horizontal Rule.
 */
void
fe_EditorInsertHorizontalRule(MWContext* context)
{
    /*
     *    Hrule is so simple, just use default values
     *   instead of bringing up properties dialog
     */
    EDT_HorizRuleData *pData = EDT_NewHorizRuleData();
    if (pData) {
        EDT_InsertHorizRule(context, pData);
	EDT_FreeHorizRuleData(pData);
    }
}

void
fe_EditorIndent(MWContext* context, Boolean is_indent)
{
    if (is_indent)
		EDT_Outdent(context);
    else
		EDT_Indent(context);
}

/* -------------------------------------------------------------- */
/*
 *    Align Set.
 */
void
fe_EditorAlignSet(MWContext* pMWContext, ED_Alignment align)
{
    ED_ElementType type = EDT_GetCurrentElementType(pMWContext);

    switch ( type ){
        case ED_ELEMENT_HRULE:
        {
            EDT_HorizRuleData* pData = EDT_GetHorizRuleData(pMWContext);
            if ( pData ){
                pData->align = align;
                EDT_SetHorizRuleData(pMWContext, pData);
            }
            break;
        }
       default: /* For Images, Text, or selection, this will do all: */
            EDT_SetParagraphAlign( pMWContext, align );
            break;
    }

    fe_EditorUpdateToolbar(pMWContext, 0);
}

ED_Alignment
fe_EditorAlignGet(MWContext* pMWContext)
{
   ED_ElementType type = EDT_GetCurrentElementType(pMWContext);
   EDT_HorizRuleData h_data;

   if (type == ED_ELEMENT_HRULE) {
       fe_EditorHorizontalRulePropertiesGet(pMWContext, &h_data);
       return h_data.align;
   } else { /* For Images, Text, or selection, this will do all: */
       return EDT_GetParagraphAlign(pMWContext);
   }
}

/* -------------------------------------------------------------- */
/*
 *    List Set.
 */
void
fe_EditorToggleList(MWContext* context, intn tag_type)
{
    EDT_ToggleList(context, tag_type);

    fe_EditorUpdateToolbar(context, 0);
}

/* -------------------------------------------------------------- */
/*
 *    Paragraph Styles Set.
 */
TagType
fe_EditorParagraphPropertiesGet(MWContext* context)
{
    return EDT_GetParagraphFormatting(context);
}

void
fe_EditorParagraphPropertiesSet(MWContext* context, TagType type)
{
#if 1
    TagType paragraph_style = EDT_GetParagraphFormatting(context);

    if (type != paragraph_style) {
	EDT_MorphContainer(context, type);

	fe_EditorUpdateToolbar(context, 0);
    }
#else
    /*
     *    This seems like the correct code, as it would mean the toolbar
     *    menu and the properties dialog have the same effect when you set
     *    a list. But this would be different from the Windows version.
     *    Do above, the same as Windows.
     */
    if (type == P_LIST_ITEM) {
        EDT_ListData list_data;

        list_data.iTagType = P_UNUM_LIST;
        list_data.eType = ED_LIST_TYPE_DISC;
        list_data.bCompact = FALSE;

        fe_EditorParagraphPropertiesSetAll(context, type, &list_data,
					   ED_ALIGN_DEFAULT);
    } else {
        fe_EditorParagraphPropertiesSetAll(context, type, NULL,
					   ED_ALIGN_DEFAULT);
    }
#endif
}

void
fe_EditorObjectPropertiesDialogDo(MWContext* context)
{
    fe_EditorPropertiesDialogType type;
    ED_ElementType e_type = EDT_GetCurrentElementType(context);

	if (e_type == ED_ELEMENT_HRULE)
		type = XFE_EDITOR_PROPERTIES_HRULE;
	else if (e_type == ED_ELEMENT_IMAGE)
		type = XFE_EDITOR_PROPERTIES_IMAGE;
	else if (e_type == ED_ELEMENT_TARGET)
		type = XFE_EDITOR_PROPERTIES_TARGET;
	else if (e_type == ED_ELEMENT_UNKNOWN_TAG)
		type = XFE_EDITOR_PROPERTIES_HTML_TAG;
	else { /* character */
		if (EDT_GetHREF(context))
			type = XFE_EDITOR_PROPERTIES_LINK;
		else
			type = XFE_EDITOR_PROPERTIES_CHARACTER;
    }

    /*
     *    Validate that we can do this kind of dialog right now.
     */
    if (fe_EditorPropertiesDialogCanDo(context, type)) {
		fe_EditorPropertiesDialogDo(context, type);
    } else {
		fe_Bell(context);
    }
}

/*
 *    Caret handling stuff. The caret is just a timed draw onto the
 *    screen, it doesn't exist in the image.
 */
#define FE_CARET_DEFAULT_TIME 500
#define FE_CARET_FLAGS_BLANK  0x1
#define FE_CARET_FLAGS_DRAW   0x2
#define FE_CARET_FLAGS_XOR    0x4
#define FE_CARET_DEFAULT_WIDTH 5

static void
fe_caret_draw(MWContext *context)
{
    fe_EditorCaretData* data = &EDITOR_CONTEXT_DATA(context)->caret_data;
    Widget    drawing_area = CONTEXT_DATA(context)->drawing_area;
    Display*  dpy = XtDisplay(drawing_area);
    Window    win = XtWindow(drawing_area);
    GC        gc;
    XGCValues gcv;
    int       x = data->x;
    int       y = data->y;
    unsigned  width = data->width;
    unsigned  height = data->height;

#ifdef DEBUG_rhess2
	fprintf(stderr, "fe_caret_draw::[ ]\n");
#endif

    memset(&gcv, ~0, sizeof(gcv));
#if 0
    {
    LO_Color  text_color;
    LO_Color  bg_color;
    fe_EditorDocumentGetColors(context, NULL, &bg_color, &text_color,
			       NULL, NULL, NULL);
    gcv.foreground = fe_GetPixel(context,
				 text_color.red,
				 text_color.green,
				 text_color.blue);
    }
#else
    gcv.foreground = CONTEXT_DATA(context)->fg_pixel;
#endif
    gc = fe_GetGC(drawing_area, GCForeground, &gcv);

    x -= CONTEXT_DATA(context)->document_x;
    y -= CONTEXT_DATA(context)->document_y;

    if ((width & 0x1) != 1)
	width++;
	
    /*
     *    Hack, hack, hack. Do something pretty david!
     */
#if 1
    XDrawLine(dpy, win, gc, x, y, x + width - 1, y);
    XDrawLine(dpy, win, gc, x + (width/2), y, x + (width/2), y + height - 1);
    XDrawLine(dpy, win, gc, x, y + height - 1, x + width - 1, y + height - 1);
#else
    XDrawRectangle(dpy, win, gc, x, y, width-1, height-1);
#endif

	XFlush(dpy);
}


static void
fe_caret_undraw(MWContext *context)
{
    fe_EditorCaretData* data = &EDITOR_CONTEXT_DATA(context)->caret_data;
    Widget    drawing_area = CONTEXT_DATA (context)->drawing_area;
    Display*  dpy = XtDisplay(drawing_area);
#ifdef DONT_rhess
    Window    win = XtWindow(drawing_area);
    GC        gc;
    XGCValues gcv;
    Visual*   visual;
    int       visual_depth;
#endif
    int       x = data->x;
    int       y = data->y;
    unsigned  width = data->width;
    unsigned  height = data->height;

#ifdef DEBUG_rhess2
	fprintf(stderr, "fe_caret_undraw::[ ]\n");
#endif
	{
		int32 ex = x;
		int32 ey = y;
		int32 ew = width + 1;
		int32 eh = height + 1;

		if (width > 0  && height > 0) {
			/*
			 *  NOTE:  don't refresh if it's a 0 pixel box...
			 */
#ifdef DEBUG_rhess2
			fprintf(stderr, "fe_caret_undraw::[ %d, %d ][ %d, %d ]\n",
					ex, ey, ew, eh);
#endif
			fe_RefreshArea(context, ex, ey, ew, eh);

			XFlush(dpy);
		}
	}
#ifdef DONT_rhess
    {
        XExposeEvent event;

		/* generate an expose */
		event.type = Expose;
		event.serial = 0;
		event.send_event = True;
		event.display = XtDisplay(CONTEXT_DATA(context)->drawing_area);
		event.window = XtWindow(CONTEXT_DATA(context)->drawing_area);
		event.x = x - CONTEXT_DATA(context)->document_x;
		event.y = y - CONTEXT_DATA(context)->document_y;
		event.width = width + 1;
		event.height = height + 1;
		event.count = 0;
		XSendEvent(event.display, event.window, 
				   False, ExposureMask, (XEvent*)&event);
    }
	XFlush(dpy);
#endif
}

static void
fe_caret_update(MWContext* context, XtIntervalId *id)
{
    fe_EditorCaretData* data = &EDITOR_CONTEXT_DATA(context)->caret_data;

#ifdef DONT_rhess
    if (data->showing) {
		fe_caret_undraw(context);
		data->showing = FALSE;
    } else {
		fe_caret_draw(context);
		data->showing = TRUE;
    }

    if (data->running) {
        data->timer_id = XtAppAddTimeOut(fe_XtAppContext,
                                         data->time,
                                         (XtTimerCallbackProc)fe_caret_update,
                                         context);
    }
#else
    if (data->showing) {
		fe_caret_draw(context);
    } else {
		fe_caret_undraw(context);
    }

    data->timer_id = 0;
#endif
}

static void
fe_caret_cancel(MWContext* context)
{
    fe_EditorCaretData* data = &EDITOR_CONTEXT_DATA(context)->caret_data;
  
#ifdef DEBUG_rhess2
	fprintf(stderr, "fe_caret_cancel::[ ]\n");
#endif

#ifdef DONT_rhess
    if (data->running)
		XtRemoveTimeOut(data->timer_id);

    data->running = FALSE;

    if (data->showing)
		fe_caret_undraw(context);
    data->showing = FALSE;
    
    if (data->backing_store) {
		XFreePixmap(XtDisplay(CONTEXT_DATA(context)->drawing_area),
					data->backing_store);
		data->backing_store = 0;
    }
#else
	data->running = False;
	if (data->showing) {
		data->showing = False;
		fe_caret_update(context, NULL);
	}
#endif
}

static void
fe_caret_pause(MWContext* context)
{
    fe_EditorCaretData* data = &EDITOR_CONTEXT_DATA(context)->caret_data;

#ifdef DEBUG_rhess2
	fprintf(stderr, "fe_caret_pause::[ ]\n");
#endif

    if (!data->running) {
		/* already paused or never started */
        return;
	}
#ifdef DONT_rhess
	else {
		XtRemoveTimeOut(data->timer_id);
	}

    data->running = FALSE;

    if (data->showing == FALSE) /* always pause showing */
        fe_caret_update(context, NULL);
#else
	data->running = False;
#ifdef HOT_CARET_rhess
	if (!data->showing) {
		data->showing = True;
#else
	if (data->showing) {
		data->showing = False;
#endif
		fe_caret_update(context, NULL);
	}
#endif /* DONT_rhess */
}

static void
fe_caret_unpause(MWContext* context)
{
    fe_EditorCaretData* data = &EDITOR_CONTEXT_DATA(context)->caret_data;

#ifdef DEBUG_rhess2
	fprintf(stderr, "fe_caret_unpause::[ ]\n");
#endif

#ifdef DONT_rhess
    if (data->running == TRUE || data->showing == FALSE) /* not paused */
        return;

    data->showing = FALSE;
    data->running = TRUE;

    /*
     *    Draw and set timer
     */
    fe_caret_update(context, NULL);
#else
    if ( data->running || data->showing ) /* not paused */
        return;

	data->running = True;

	if (!data->showing) {
		data->showing = True;
		fe_caret_update(context, NULL);
	}
#endif
}

static void
fe_caret_begin(MWContext* context)
{
    fe_EditorCaretData* data = &EDITOR_CONTEXT_DATA(context)->caret_data;

#ifdef DEBUG_rhess2
	fprintf(stderr, "fe_caret_begin::[ ]\n");
#endif

#ifdef DONT_rhess
    data->showing = FALSE;
    data->time = FE_CARET_DEFAULT_TIME;
    data->running = TRUE;

    fe_caret_update(context, NULL);
#else
	data->time    = 0;
    data->running = True;
	if (!data->showing) {
		data->showing = True;
		fe_caret_update(context, NULL);
	}
#endif

#ifdef XFE_EDITOR_IM_SUPPORT
    fe_editor_im_set_coords(context);
#endif /* XFE_EDITOR_IM_SUPPORT */
}

void
fe_EditorRefreshArea(MWContext* context, int x, int y, unsigned w, unsigned h)
{
    fe_EditorCaretData* data = &EDITOR_CONTEXT_DATA(context)->caret_data;

    if (
#if 0
		/*
		 *    Don't use x, as LO_RefreshArea tends to redraw full width
		 *    anyway.
		 */
		((x < data->x && x + w >= data->x) ||
		 (x < data->x + data->width && x + w >= data->x + data->width))
		&&
#endif
		((y < data->y && y + h >= data->y) ||
		 (y < data->y + data->height && y + h >= data->y + data->height))) {

#ifdef DONT_rhess
        if (data->backing_store) {
            XFreePixmap(XtDisplay(CONTEXT_DATA(context)->drawing_area),
                        data->backing_store);
            data->backing_store = 0;
        }

        if (data->running) {
            XtRemoveTimeOut(data->timer_id);
            data->showing = TRUE; /* force restart of sequence next */
        }
        if (data->showing) {
            data->showing = FALSE;
            fe_caret_update(context, NULL);
        }
#else
        if (data->showing) {
            fe_caret_update(context, NULL);
        }
#endif
    }
}

static int fe_LastCoffeeScroll_X = 0;
static int fe_LastCoffeeScroll_Y = 0;

static void
fe_editor_keep_cursor_visible(MWContext* context)
{
    fe_EditorCaretData* c_data = &EDITOR_CONTEXT_DATA(context)->caret_data;
    int x = CONTEXT_DATA(context)->document_x;
    int y = CONTEXT_DATA(context)->document_y;
    unsigned win_height = CONTEXT_DATA(context)->scrolled_height;
    unsigned win_width = CONTEXT_DATA(context)->scrolled_width;
    Boolean  coffee_scroll = FALSE;
	int fudge = 20;
	int pad = 10;

#ifdef DEBUG_rhess2
	fprintf(stderr, "fe_editor_keep_cursor_visible::[ ]\n");
#endif

    if (c_data->y + c_data->height > y + win_height - fudge) {
		y = c_data->y + c_data->height - win_height + fudge; /* fudge */
		if (y + win_height > CONTEXT_DATA(context)->document_height)
			y = CONTEXT_DATA(context)->document_height - win_height;
		coffee_scroll = TRUE;
    } else if (c_data->y < y + pad) {
		y = c_data->y - pad;
		if (y < 0)
			y = 0;
		coffee_scroll = TRUE;
    }

	if (c_data->x + c_data->width > x + win_width - fudge) {
		x = c_data->x + c_data->width - win_width + fudge;
		if (x + win_width > CONTEXT_DATA(context)->document_width)
			x = CONTEXT_DATA(context)->document_width - win_width;
		coffee_scroll = TRUE;
    } else if (c_data->x < x + pad) {
		x = c_data->x - pad;
		if (x < 0)
			x = 0;
		coffee_scroll = TRUE;
    }

	if (x == fe_LastCoffeeScroll_X && y == fe_LastCoffeeScroll_Y) {
		coffee_scroll = False;
	}

    if (coffee_scroll) {
		if (c_data->showing)
			fe_caret_cancel(context);
#ifdef DEBUG_rhess2
		fprintf(stderr, "coffee_scroll::[ %d, %d ][ %d, %d ][ %d, %d ]\n", 
				x, y, c_data->x, c_data->y, 
				CONTEXT_DATA(context)->document_x,
				CONTEXT_DATA(context)->document_y );
#endif
        /*
		 *    Collect all pending exposures before we scroll.
		 */
		fe_SyncExposures(context);

		fe_ScrollTo(context, x, y);
    }

	fe_LastCoffeeScroll_X = x;
	fe_LastCoffeeScroll_Y = y;
}

static void
fe_editor_keep_pointer_visible_autoscroll(XtPointer, XtIntervalId*);

static void
fe_editor_keep_pointer_visible(MWContext* context, int p_x, int p_y)
{
    fe_ContextData* data = CONTEXT_DATA(context);
    fe_EditorAscrollData* ascroll_data
	= &EDITOR_CONTEXT_DATA(context)->ascroll_data;
    Boolean coffee_scroll = FALSE;
    int x = data->document_x;
    int y = data->document_y;
    int delta = 0;

#ifdef DEBUG_rhess2
	fprintf(stderr, "fe_editor_keep_pointer_visible::[ ]\n");
#endif

    if (ascroll_data->timer_id)
      XtRemoveTimeOut(ascroll_data->timer_id);

    ascroll_data->delta_x = 0;
    ascroll_data->delta_y = 0;

    if (p_y < data->document_y) {
	coffee_scroll = TRUE;
	y = p_y;
	delta = (data->document_y - p_y);
	ascroll_data->y = p_y;
	ascroll_data->delta_y = -delta;
    }

    if (p_y > data->document_y + data->scrolled_height) {
	coffee_scroll = TRUE;
	y = p_y - data->scrolled_height;
	delta = p_y - (data->document_y + data->scrolled_height);
	ascroll_data->y = p_y;
	ascroll_data->delta_y = delta;
    }

    if (coffee_scroll) {
        /*
		 *    Collect all pending exposures before we scroll.
		 */
		fe_SyncExposures(context);

		fe_ScrollTo(context, x, y);

		ascroll_data->timer_id = 
			XtAppAddTimeOut(fe_XtAppContext,
							(100),
							fe_editor_keep_pointer_visible_autoscroll,
							(XtPointer)context);
    }
}

static void
fe_editor_keep_pointer_visible_autoscroll(XtPointer closure, XtIntervalId* id)
{
    MWContext* context = (MWContext*)closure;
    fe_EditorAscrollData* ascroll_data;

#if DEBUG_rhess2
	fprintf (stderr,"fe_editor_keep_pointer_visible_autoscroll::[ ]\n");
#endif

    ascroll_data = &EDITOR_CONTEXT_DATA(context)->ascroll_data;
    ascroll_data->timer_id = 0; /* because we won't pop again */
  
    ascroll_data->x += ascroll_data->delta_x;
    ascroll_data->y += ascroll_data->delta_y;

    EDT_ExtendSelection(context, ascroll_data->x, ascroll_data->y);

    fe_editor_keep_pointer_visible(context, ascroll_data->x, ascroll_data->y);
}

static void
fe_caret_set(MWContext* context, int x, int y, unsigned w, unsigned h)
{
    fe_EditorCaretData* data = &EDITOR_CONTEXT_DATA(context)->caret_data;

#ifdef DEBUG_rhess2
	fprintf(stderr, "fe_caret_set::[ ]\n");
#endif

    if ( x != data->x || 
		 y != data->y || 
		 w != data->width || 
		 h != data->height )
		{
			if (data->showing)
				fe_caret_cancel(context);
		}

#ifdef DONT_rhess
    if (data->running)
	XtRemoveTimeOut(data->timer_id);
#endif

    data->x = x;
    data->y = y;
    data->width = w;
    data->height = h;

    fe_editor_keep_cursor_visible(context);
}

Boolean 
FE_GetCaretPosition(
		    MWContext *context,
		    LO_Position* where,
		    int32* caretX, int32* caretYLow, int32* caretYHigh
) {
  int32 xVal;
  int32 yVal;
  int32 yValHigh;

#if DEBUG_rhess2
  fprintf(real_stderr, "FE_GetCaretPosition::[ ]\n");
#endif

  if (!context || !where->element)
    return FALSE;
  
  xVal = where->element->lo_any.x + where->element->lo_any.x_offset;
  yVal = where->element->lo_any.y;
  yValHigh = yVal + where->element->lo_any.height;

  switch (where->element->type) {
  case LO_TEXT: {
    LO_TextStruct* text_data = & where->element->lo_text;
    LO_TextInfo    text_info;
    int            len_save = text_data->text_len;

    if (!text_data->text_attr)
      return FALSE;

    if (where->position <= text_data->text_len) {
      text_data->text_len = where->position;
    }
    XFE_GetTextInfo(context, text_data, &text_info);
    text_data->text_len = len_save;
    
    xVal += text_info.max_width - 1;
  } break;

  case LO_IMAGE: {
    LO_ImageStruct *pLoImage = & where->element->lo_image;
    if (where->position == 0) {
      xVal -= 1;
    } else {
      xVal += pLoImage->width + 2 * pLoImage->border_width;
    }
  } break;
    
  default: {
    LO_Any *any = &where->element->lo_any;
    if (where->position == 0) {
      xVal -= 1;
    } else {
      xVal += any->width;
    }
  }
  }

  *caretX = xVal;
  *caretYLow = yVal;
  *caretYHigh = yValHigh;

  return TRUE;
}

/*
 *    char_offset is in characters!!!
 */
PUBLIC void
FE_DisplayTextCaret(MWContext* context, int iLocation, LO_TextStruct* text,
		    int char_offset)
{
  int       x;
  int       y;
  unsigned  width;
  unsigned  height;
  LO_TextInfo text_info;
  int16     save_len;

#if DEBUG_rhess2
  fprintf (stderr,"FE_DisplayTextCaret::[ ]\n");
#endif

  /*
   *    Get info extent info about the first <char_offset> characters of
   *    text.
   */
  save_len = text->text_len;
  text->text_len = char_offset;
  XFE_GetTextInfo(context, text, &text_info);
  x = text->x + text->x_offset + text_info.max_width;
  y = text->y + text->y_offset;
  height =  text_info.ascent + text_info.descent;
  
  text->text_len = save_len;

  width = FE_CARET_DEFAULT_WIDTH;
  x -= (FE_CARET_DEFAULT_WIDTH/2) + 1; /* middle of char and back */

  fe_caret_set(context, x, y, width, height);
  fe_caret_begin(context);
}

void 
FE_DisplayImageCaret(
		     MWContext*             context, 
		     LO_ImageStruct*        image,
		     ED_CaretObjectPosition caretPos)
{
  int       x;
  int       y;
  unsigned  width;
  unsigned  height;
  
#if DEBUG_rhess2
  fprintf (stderr,"FE_DisplayImageCaret::[ ]\n");
#endif

  /*
   *    Get info extent info about the first <char_offset> characters of
   *    text.
   */
  x = image->x + image->x_offset;
  y = image->y + image->y_offset;
  width = FE_CARET_DEFAULT_WIDTH;
  height = image->height + (2 * image->border_width);

  if (caretPos == ED_CARET_BEFORE) {
    x -= 1;
  } else if (caretPos == ED_CARET_AFTER) {
    x += image->width + (2 * image->border_width);
  } else {
    width = image->width + (2 * image->border_width);
  }

  fe_caret_set(context, x, y, width, height);
  fe_caret_begin(context);
}

void FE_DisplayGenericCaret(MWContext * context, LO_Any * image,
                        ED_CaretObjectPosition caretPos )
{
  int       x;
  int       y;
  unsigned  width;
  unsigned  height;
  
#if DEBUG_rhess2
  fprintf (stderr,"FE_DisplayGenericCaret::[ ]\n");
#endif

  /*
   *    Get info extent info about the first <char_offset> characters of
   *    text.
   */
  x = image->x + image->x_offset;
  y = image->y + image->y_offset;
  width = FE_CARET_DEFAULT_WIDTH;
  height = image->line_height;

  if (caretPos == ED_CARET_BEFORE) {
    x -= 1;
  } else if (caretPos == ED_CARET_AFTER) {
    x += image->width;
  } else {
    width = image->width;
  }

  fe_caret_set(context, x, y, width, height);
  fe_caret_begin(context);
}

PUBLIC void
FE_DestroyCaret(MWContext * context)
{
	fe_EditorCaretData* data = &EDITOR_CONTEXT_DATA(context)->caret_data;

#if DEBUG_rhess2
	fprintf(stderr, "FE_DestroyCaret::[ ]\n");
#endif

	if (data->showing)
		fe_caret_cancel(context);

	data->time = 0;
	data->timer_id = 0;
	data->showing = False;
	data->running = False;
	data->backing_store = 0;
}

PUBLIC void
FE_ShowCaret(MWContext * context)
{
#if DEBUG_rhess2
	fprintf(stderr, "FE_ShowCaret::[ ]\n");
#endif
	fe_caret_begin(context);
}

/*
 *    Note all x, y co-ordinates are document relative.
 */
PUBLIC void 
FE_DocumentChanged(MWContext* context, int32 p_y, int32 p_height)
{
    int32  redraw_x = 0;
    int32  redraw_y;
    uint32 redraw_width = CONTEXT_DATA(context)->document_width;
    uint32 redraw_height;
    int32  win_y;
    uint32 win_height;
    int32  win_x;
    int32  margin_height;
    int32  margin_width;

    win_y = CONTEXT_DATA(context)->document_y;
    win_height = CONTEXT_DATA(context)->scrolled_height;

    win_x = CONTEXT_DATA(context)->document_x;

    /*
     *    Ok, it seems like layout doesn't take into account margins.
     *    If there was stuff in the margin before (because we *were*
     *    displaying something big, which was scrolled up), but now we
     *    are not, we must clear the margin. This code attempts
     *    to detect when we are close to the margin, and say, clear
     *    the whole thing. This seems kinda bogus, the back-end
     *    should know about margins (no?), but... djw
     */
    fe_GetMargin(context, &margin_width, &margin_height);
    
    if (p_y <= margin_height) {
        p_y = 0;
		if (p_height != -1)
			p_height += margin_height;
    }

    redraw_y = p_y;

    if (p_height < 0) {
		redraw_height = CONTEXT_DATA(context)->document_height;
		/* make sure full repaint goes to end of window at least. */
		if (win_height > redraw_height)
			redraw_height = win_height;
    } else {
		redraw_height = p_height;
    }

    /*
     *    Is doc change area above or below displayed region?
     */
    if (redraw_y > win_y + win_height || redraw_y + redraw_height < win_y)
		return; /* nothing to do */

    /*
     *    Clip redraw area.
     */
    if (redraw_y < win_y) {
		redraw_height -= (win_y - redraw_y);
		redraw_y = win_y;
    }

    if (redraw_y + redraw_height > win_y + win_height) {
		redraw_height = win_y + win_height - redraw_y;
    }

    /*FIXME*/
    /*
     *    Probably need to call CL_RefreshRegion()/Rect()
     */
#ifdef DONT_rhess
    fe_ClearArea(context, redraw_x - win_x, redraw_y - win_y,
				 redraw_width, redraw_height);
#endif
	fe_caret_cancel(context);

	{
		int32 ex = redraw_x;
		int32 ey = redraw_y;
		int32 ew = redraw_width;
		int32 eh = redraw_height;

#ifdef DEBUG_rhess2
		fprintf(stderr, "FE_DocumentChanged::[ %d, %d ][ %d, %d ]\n",
				ex, ey, ew, eh);
#endif
		fe_RefreshArea(context, ex, ey, ew, eh);
	}
#ifdef DONT_rhess
    {
        XExposeEvent event;

		/* generate an expose */
		event.type = Expose;
		event.serial = 0;
		event.send_event = True;
		event.display = XtDisplay(CONTEXT_DATA(context)->drawing_area);
		event.window = XtWindow(CONTEXT_DATA(context)->drawing_area);
		event.x = redraw_x - win_x;
		event.y = redraw_y - win_y;
		event.width = redraw_width;
		event.height = redraw_height;
		event.count = 0;
		XSendEvent(event.display, event.window, False, ExposureMask, (XEvent*)&event);
    }
#endif
}

void FE_GetDocAndWindowPosition(MWContext * context, int32 *pX, int32 *pY, 
    int32 *pWidth, int32 *pHeight )
{
  *pX = CONTEXT_DATA (context)->document_x;
  *pY = CONTEXT_DATA (context)->document_y;
  *pWidth = CONTEXT_DATA (context)->scrolled_width;
  *pHeight = CONTEXT_DATA (context)->scrolled_height;
}

void
FE_SetNewDocumentProperties(MWContext* context)
{

    LO_Color bg_color;
    LO_Color normal_color;
    LO_Color link_color;
    LO_Color active_color;
    LO_Color followed_color;
    char background_image[MAXPATHLEN];
    XP_Bool use_custom;
    Boolean keep_images;

    /*
     *    Set keep images state from prefs. 
     */
    fe_EditorPreferencesGetLinksAndImages(context, NULL, &keep_images);
    fe_EditorDocumentSetImagesWithDocument(context, keep_images);

    /*
     *    Get editor defaults.
     */
    use_custom = fe_EditorPreferencesGetColors(context,
											   background_image,
											   &bg_color,
											   &normal_color,
											   &link_color,
											   &active_color,
											   &followed_color);

    /*
     *    Apply.
     */
    if (use_custom) {
		fe_EditorDocumentSetColors(context,
								   background_image,
								   FALSE,
								   &bg_color,
								   &normal_color,
								   &link_color,
								   &active_color,
								   &followed_color);
    } else {
		fe_EditorDocumentSetColors(context,
								   background_image, /*independent of colors*/
								   FALSE,
								   NULL,
								   NULL,
								   NULL,
								   NULL,
								   NULL);
    }

    /*
     *    Now do other stuff.
     */
    /* Title */
    fe_EditorDocumentSetTitle(context, NULL); /* will show Untitled */

    /* Add fixed MetaData items for author, others?? */
    fe_EditorDocumentSetMetaData(context,
								 "Author",
								 fe_EditorPreferencesGetAuthor(context));
    fe_EditorDocumentSetMetaData(context,
								 "GENERATOR",
								 "Mozilla/X");
}

void
fe_EditorNotifyBackgroundChanged(MWContext* context)
{
#ifdef DONT_rhess
    fe_EditorCaretData* data = &EDITOR_CONTEXT_DATA(context)->caret_data;
    
    if (data->backing_store) {
		XFreePixmap(XtDisplay(CONTEXT_DATA(context)->drawing_area),
					data->backing_store);
		data->backing_store = 0;
    }
#endif
}

char* 
FE_URLToLocalName(char *name)
{
  char* qm;
  char* hm;
  char* begin;
  char* end;
  char* rv;
  char* nameSave;
  int   len;
  int   nameLen;

  /*
   *    Save a copy of the name as we might drop characters after '?' or '#'
   */

  nameLen = strlen(name);
  nameSave = XP_ALLOC(nameLen + 1);
  memcpy(nameSave, name, nameLen);
  nameSave[nameLen] = '\0';

  /*
   *    Drop everything after a '?' or '#' character.
   */
  qm = strchr(nameSave, '?');
  hm = strchr(nameSave, '#');

  if (qm && hm) {
    end = (qm > hm)? qm: hm;
  } else if (qm) {
    end = qm;
  } else if (hm) {
    end = hm;
  } else {
    end = nameSave + nameLen;
  }

  *end = '\0';

  /*
   *    Then get the basename of what's left.
   */
  if ((begin = strrchr(nameSave, '/')) != NULL && begin[1] != '\0') {
    begin++;
  } else {
    begin = nameSave;
  }
    
  len = end - begin;
  rv = malloc(len + 1);
  memcpy(rv, begin, len);
  rv[len] = '\0';

  XP_FREE(nameSave);
  return rv;
}

Boolean FE_EditorPrefConvertFileCaseOnWrite(void)
{
  fprintf (real_stderr,"FE_EditorPrefConvertFileCaseOnWrite\n");
  return TRUE;
}

void 
FE_FinishedSave(MWContext* context, int status,
		char *pDestURL, int iFileNumber)
{
}

#if 0
static void
fe_editor_copyright_hint_dialog(MWContext* context)
{
    if (!fe_globalPrefs.editor_copyright_hint)
	return;

    if (fe_HintDialog(context, XP_GetString(XFE_ERROR_COPYRIGHT_HINT))) {
	fe_globalPrefs.editor_copyright_hint = FALSE;
	
	/*
	 *    Save options.
	 */
	if (!XFE_SavePrefs((char *)fe_globalData.user_prefs_file,
			   &fe_globalPrefs)) {
	    fe_perror(context, XP_GetString(XFE_ERROR_SAVING_OPTIONS));
	}
    }
}
#endif

/*
 *    Crock timeout callback that is used by fe_EditorGetUrlExitRoutine() to
 *    kill a failed Frame (you opened a non-html doc say).
 */
static void
fe_editor_exit_timeout(XtPointer closure, XtIntervalId* id)
{
    MWContext *context = (MWContext *)closure;

	fe_EditorKill(context);
}

void
fe_EditorGetUrlExitRoutine(MWContext* context, URL_Struct* url, int status)
{
    if (status < 0) {
		/*
		 *    Make sure that it's not a publish. This code is only
		 *    meant for fe_GetURL() calls. Make sure the user gets to see
		 *    the error dialog, then request a delete on the editor.
		 */
		if (url != NULL && url->files_to_post == NULL) { /* not publish */

			/*
			 *    Wait for popup menus to go away.
			 */
			/* we need to check context->type because under certain cases we 
			 * reach this loop after the editor has been killed so context is
			 * garbage and if we don't check then ContextHasPopups fail
			 */
			while (context && context->type == MWContextEditor && 
				   fe_ContextHasPopups(context))
				fe_EventLoop();
	    
			/*
			 *    Then request a dissapearing act.
			 */
			XtAppAddTimeOut(fe_XtAppContext, 0, fe_editor_exit_timeout,
							(XtPointer)context);
		}
    }
}


/*
 * Editor calls us when we are finished loading
 * We force saving document if not editing local file
 */
void
FE_EditorDocumentLoaded(MWContext* context)
{
    History_entry* hist_ent;
    Bool           do_save_dialog;
    unsigned as_time;
    Boolean  as_enable;
    
    if (!context) {
		return;
    }
    
#ifdef DEBUG_rhess2
	fprintf(stderr, "editor::[ FE_EditorDocumentLoaded ]\n");
#endif

    /*
     *    Windows does a lot more gymnastics here to determine which
     *    docs should or should not be saved (especially new ones).
     *    Please look into this and match up.
     */
    /*FIXME*/
    do_save_dialog = FALSE;
    if ((hist_ent = SHIST_GetCurrent(&context->hist)) && hist_ent->address) {
		do_save_dialog = !NET_IsLocalFileURL(hist_ent->address);
    }
    
#if 0
	/*
	 *    Seems we don't do this anymore.
	 */
    if (!EDT_IS_NEW_DOCUMENT(context) && do_save_dialog) {
		
		/*
		 *    Tongue in cheek....
		 */
		fe_editor_copyright_hint_dialog(context);
    }
#endif
	
#ifdef MOZ_MAIL_NEWS
	if (context->type == MWContextMessageComposition) {
		fe_MailComposeDocumentLoaded(context);
	}
	else 
#endif
		xfe2_EditorInit(context);
	
    /*
     *    Set autosave period.
     */
    fe_EditorPreferencesGetAutoSave(context, &as_enable, &as_time);
    EDT_SetAutoSavePeriod(context, as_time);
	
    fe_HackEditorNotifyToolbarUpdated(context);
}

static char fe_SaveDialogSaveName[] = "saveMessageDialog";
static char fe_SaveDialogUploadName[] = "uploadMessageDialog";
static char fe_SaveDialogPrepareName[] = "prepareMessageDialog";
static char fe_SaveDialogImageLoadName[] = "imageLoadMessageDialog";

typedef enum fe_SaveDialogType
{
    XFE_SAVE_DIALOG_SAVE,
    XFE_SAVE_DIALOG_UPLOAD,
    XFE_SAVE_DIALOG_PREPARE,
    XFE_SAVE_DIALOG_IMAGELOAD
} fe_SaveDialogType;

typedef struct fe_SaveDialogInfo
{
    unsigned          nfiles;
    unsigned          current;
    fe_SaveDialogType type;
} fe_SaveDialogInfo;

static void
fe_save_dialog_info_init(Widget msg_box, fe_SaveDialogType type, unsigned n)
{
    fe_SaveDialogInfo* info = (fe_SaveDialogInfo*)XtNew(fe_SaveDialogInfo);
    
    if (info == NULL)
	return;

    info->nfiles = n;
    info->type = type;
    info->current = 0;

    XtVaSetValues(msg_box, XmNuserData, (XtPointer)info, 0);
}

#define XFE_SAVE_DIALOG_NEXT (-1)

static void
fe_save_dialog_info_set(Widget msg_box, char* filename, int index)
{
    XtPointer          user_data;
    fe_SaveDialogInfo* info;
    char               buf[MAXPATHLEN];
    int                id;
    char*              string;
    XmString           xm_string;

    XtVaGetValues(msg_box, XmNuserData, &user_data, 0);
    if (user_data != 0) {
	info = (fe_SaveDialogInfo*)user_data;

	if (index == XFE_SAVE_DIALOG_NEXT)
	    info->current++;
	else
	    info->current = index;

	if (info->current > info->nfiles)
	    info->nfiles = info->current;

	switch (info->type) {
	case XFE_SAVE_DIALOG_IMAGELOAD:
	    id = XFE_LOADING_IMAGE_FILE;
		break;
	case XFE_SAVE_DIALOG_UPLOAD:
	    id = XFE_UPLOADING_FILE;
		break;
	case XFE_SAVE_DIALOG_PREPARE:
	    id = XFE_PREPARE_UPLOAD;
		break;
	default:
	    id = XFE_SAVING_FILE;
		break;
	}

	string = XP_GetString(id);

	if (!filename)
	    filename = "";
	sprintf(buf, string, filename);
	
	if (info->nfiles > 1) {
	    strcat(buf, "\n");
	    string = XP_GetString(XFE_FILE_N_OF_N);
	    sprintf(&buf[strlen(buf)], string, info->current, info->nfiles);
	}
	
	xm_string = XmStringCreateLocalized(buf);
    } else {
	xm_string = XmStringCreateLocalized(filename);
    }
    XtVaSetValues(msg_box, XmNmessageString, xm_string, 0);
    XmStringFree(xm_string);
}

static fe_SaveDialogType
fe_SaveDialogGetType(Widget msg_box)
{
    char* name = XtName(msg_box);

    if (strcmp(name, fe_SaveDialogSaveName) == 0)
		return XFE_SAVE_DIALOG_SAVE;
    else if (strcmp(name, fe_SaveDialogUploadName) == 0)
		return XFE_SAVE_DIALOG_UPLOAD;
    else if (strcmp(name, fe_SaveDialogPrepareName) == 0)
		return XFE_SAVE_DIALOG_PREPARE;
    else
		return XFE_SAVE_DIALOG_IMAGELOAD;
}

static void
fe_save_dialog_cancel_cb(Widget msg_box, XtPointer closure, XtPointer cb_data)
{
    MWContext* context = (MWContext*)closure;

    if (fe_SaveDialogGetType(msg_box) == XFE_SAVE_DIALOG_SAVE) {
        EDT_SaveCancel(context);
    } else {
        NET_InterruptWindow(context);
    }
}

static void
fe_save_dialog_destroy_cb(Widget msg_box, XtPointer closure, XtPointer cb_data)
{
    MWContext* context = (MWContext*)closure;
    XtPointer  user_data;
    
    if (CONTEXT_DATA(context)->posted_msg_box == msg_box)
		CONTEXT_DATA(context)->posted_msg_box = NULL;

    XtVaGetValues(msg_box, XmNuserData, &user_data, 0);
    if (user_data != NULL)
		XtFree(user_data);
}

static Widget
fe_save_dialog_create(MWContext* context, char* name)
{
    Widget mainw = CONTEXT_WIDGET(context);
    Widget msg_box;
    Visual *v = 0;
    Colormap cmap = 0;
    Cardinal depth = 0;
    Arg args [20];
    Cardinal n;

    if (CONTEXT_DATA(context)->posted_msg_box != NULL)
	return CONTEXT_DATA(context)->posted_msg_box;

    XtVaGetValues(mainw, XtNvisual, &v, XtNcolormap, &cmap,
		  XtNdepth, &depth, 0);

    n = 0;
    XtSetArg(args[n], XmNvisual, v); n++;
    XtSetArg(args[n], XmNdepth, depth); n++;
    XtSetArg(args[n], XmNcolormap, cmap); n++;
    XtSetArg(args[n], XmNallowShellResize, TRUE); n++;
    XtSetArg(args[n], XmNtransientFor, mainw); n++;
    XtSetArg(args[n], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL); n++;
    XtSetArg(args[n], XmNdialogType, XmDIALOG_MESSAGE); n++;
    XtSetArg(args[n], XmNdeleteResponse, XmDO_NOTHING); n++;
    XtSetArg(args[n], XmNautoUnmanage, FALSE); n++;
    XtSetArg(args[n], XmNresizePolicy, XmRESIZE_GROW); n++;

    msg_box = XmCreateMessageDialog(mainw, name, args, n);

    fe_UnmanageChild_safe(XmMessageBoxGetChild(msg_box, XmDIALOG_OK_BUTTON));
    fe_UnmanageChild_safe(XmMessageBoxGetChild(msg_box, XmDIALOG_HELP_BUTTON));

    XtAddCallback(msg_box, XmNcancelCallback, fe_save_dialog_cancel_cb,
		  (XtPointer)context);
    XtAddCallback(msg_box, XmNdestroyCallback, fe_save_dialog_destroy_cb,
		  (XtPointer)context);

    CONTEXT_DATA(context)->posted_msg_box = msg_box;

    return msg_box;
}

static void
fe_destroy_parent_cb(Widget widget, XtPointer closure, XtPointer cbd)
{
	XtDestroyWidget(XtParent(widget));
}

static void 
fe_save_dialog_destroy(Widget msg_box)
{
	Widget   shell = XtParent(msg_box);
	Cardinal num_popups = XfeNumPopups(shell);
	Widget*  popups = XfePopupList(shell);

	/*
	 *    If we have a stacked popup on us, them wait for that
	 *    popup to destroy before we destroy ourselves. Do this by
	 *    setting a destroy callback on the popup that destroys
	 *    it's parent (us). Amongst other things we need to do this
	 *    because server side error messages get stacked on the save
	 *    progress dialog.
	 */
	if (num_popups > 0) { /* anyone who adds to me after this is a loser */
		XtAddCallback(popups[0], XmNdestroyCallback, fe_destroy_parent_cb, 0);
	} else {
		XtDestroyWidget(msg_box);
	}
}

/*
 *    Dialog to give feedback and allow canceling, overwrite protection
 *    when downloading remote files 
 *
 *    put up a save dialog that says "i'm saving foo right now", cancel?
 *    and return right away. 
 */
void 
FE_SaveDialogCreate(MWContext* context, int nfiles, ED_SaveDialogType saveType)
{
    Widget msg_box;
    char*  name;
    fe_SaveDialogType type;

    if (CONTEXT_DATA(context)->posted_msg_box != NULL)
		return;

	switch (saveType) {
	case ED_SAVE_DLG_PUBLISH:
		name = fe_SaveDialogUploadName;
		type = XFE_SAVE_DIALOG_UPLOAD;
		break;
	case ED_SAVE_DLG_PREPARE_PUBLISH:
		name = fe_SaveDialogPrepareName;
		type = XFE_SAVE_DIALOG_PREPARE;
		break;
	default:
		name = fe_SaveDialogSaveName;
		type = XFE_SAVE_DIALOG_SAVE;
		break;
	}

    msg_box = fe_save_dialog_create(context, name);

    fe_save_dialog_info_init(msg_box, type, nfiles);

    CONTEXT_DATA(context)->posted_msg_box = msg_box;

	/* this is here so that we know when the file saying is over */
    CONTEXT_DATA(context)->is_file_saving = True;

    /*
     *    Postpone until we have something to say..
    XtManageChild(msg_box);
     */
}

void 
FE_SaveDialogSetFilename(MWContext* context, char* filename) 
{
    Widget msg_box = CONTEXT_DATA(context)->posted_msg_box;
    
    if (!msg_box)
		return;
    
    fe_save_dialog_info_set(msg_box, filename, XFE_SAVE_DIALOG_NEXT);
    
    if (!XtIsManaged(msg_box))
		XtManageChild(msg_box);

	XfeUpdateDisplay(msg_box);
}

void 
FE_SaveDialogDestroy(MWContext* context, int status, char* file_url)
{
    Widget msg_box = CONTEXT_DATA(context)->posted_msg_box;
	fe_SaveDialogType type;
    
    if (msg_box == NULL)
		return;

	type = fe_SaveDialogGetType(msg_box);

    if (type == XFE_SAVE_DIALOG_SAVE) {
		CONTEXT_DATA(context)->save_file_url = file_url;
		CONTEXT_DATA(context)->file_save_status = status;
    }
    
    fe_save_dialog_destroy(msg_box);
    CONTEXT_DATA(context)->posted_msg_box = NULL;
	/* this is here so that we know when the file saying is over */
    CONTEXT_DATA(context)->is_file_saving = False;
}

void
FE_ImageLoadDialog(MWContext* context)
{
    Widget msg_box;

    if (CONTEXT_DATA(context)->posted_msg_box != NULL)
	return;

    msg_box = fe_save_dialog_create(context, fe_SaveDialogImageLoadName);

    fe_save_dialog_info_init(msg_box, XFE_SAVE_DIALOG_IMAGELOAD, 1);
    CONTEXT_DATA(context)->posted_msg_box = msg_box;

    fe_save_dialog_info_set(msg_box, "", 1);

    XtManageChild(msg_box);
}

void
FE_ImageLoadDialogDestroy(MWContext* context)
{
    Widget msg_box = CONTEXT_DATA(context)->posted_msg_box;

    if (msg_box == NULL)
	return;

    fe_save_dialog_destroy(msg_box);

    CONTEXT_DATA(context)->posted_msg_box = NULL;
}

typedef struct {
  Widget  form;
  Widget  widget;
  unsigned response;
  Boolean done;
} YesToAllInfo;

static void
fe_yes_to_all_cb(Widget widget, XtPointer closure, XtPointer call_data)
{
  YesToAllInfo* info = (YesToAllInfo*)closure;
  int i;
  char* name;
  char* widget_name = XtName(widget);

  for (i = 0; (name = fe_CreateYesToAllDialog_button_data[i].name); i++) {
    if (strcmp(name, widget_name) == 0) {
      info->response = fe_CreateYesToAllDialog_button_data[i].type;
      break;
    }
  }

  info->widget = widget;
  info->done = TRUE;

  XtUnmanageChild(info->form);
}

#if 0
static unsigned
fe_OverWriteFileQuestionDialog(MWContext* context, char* filename)
{
  char* msg;
  int   size;
  Bool  rv = FALSE;

  size = XP_STRLEN(filename) + 1 /* slash*/
       + XP_STRLEN(fe_globalData.overwrite_file_message) + 1; /*nul*/

  msg = (char *)XP_ALLOC(size);
  if (!msg)
    return False;

  PR_snprintf(msg, size, fe_globalData.overwrite_file_message, filename);

  if (FE_Confirm(context, msg))
    rv = TRUE;

  XP_FREE(msg);

  return rv;
}
#endif

static unsigned
fe_DoYesToAllDialog(MWContext* context, char* filename)
{
  YesToAllInfo info;
  Arg      av[20];
  Cardinal ac;
  XtCallbackRec cb_data;
  XmString msg_string;
  char* msg;
  int size;
  Widget form;
  Widget default_button;

  size = XP_STRLEN(filename) + 1 /* slash*/
       + XP_STRLEN(fe_globalData.overwrite_file_message) + 1; /*nul*/

  msg = (char *)XP_ALLOC(size);
  if (!msg)
    return XFE_DIALOG_CANCEL_BUTTON;

  PR_snprintf(msg, size, fe_globalData.overwrite_file_message, filename);
  msg_string = XmStringCreateLocalized(msg);
  XP_FREE(msg);

  cb_data.callback = fe_yes_to_all_cb;
#ifdef OSF1
  cb_data.closure = (void *)&info;
#else
  cb_data.closure = &info;
#endif

  ac = 0;
  XtSetArg(av[ac], XmNarmCallback, &cb_data); ac++;
  XtSetArg(av[ac], XmNmessageString, msg_string); ac++;
  form = fe_CreateYesToAllDialog(context, "confirmSaveFiles", av, ac);

  default_button = fe_YesToAllDialogGetChild(form, XFE_DAILOG_YESTOALL_BUTTON);
  ac = 0;
  XtSetArg(av[ac], XmNdefaultButton, default_button); ac++;
#if 0 /* why doesn't this work? */
  XtSetArg(av[ac], XmNinitialFocus, default_button); ac++;
#endif
  XtSetValues(form, av, ac);

  info.response = XFE_DIALOG_CANCEL_BUTTON;
  info.done = FALSE;
  info.widget = NULL;
  info.form = form;

  XmStringFree(msg_string);
    
  XtManageChild(form);

  fe_NukeBackingStore(form);
  while (!info.done)
    fe_EventLoop();

  XtDestroyWidget(form);

  return info.response;
}

ED_SaveOption
FE_SaveFileExistsDialog(MWContext* context, char* filename) 
{
  switch (fe_DoYesToAllDialog(context, filename)) {
  case XFE_DIALOG_YES_BUTTON:
    return ED_SAVE_OVERWRITE_THIS;
  case XFE_DAILOG_YESTOALL_BUTTON:
    return ED_SAVE_OVERWRITE_ALL;
  case XFE_DIALOG_NO_BUTTON:
    return ED_SAVE_DONT_OVERWRITE_THIS;
  case XFE_DIALOG_NOTOALL_BUTTON:
    return ED_SAVE_DONT_OVERWRITE_ALL;
  default:
    return ED_SAVE_CANCEL;
  }
}

Boolean
FE_SaveErrorContinueDialog(MWContext*   context,
			   char*        filename, 
			   ED_FileError error)
{
  if (error != ED_ERROR_NONE) {
      /* There was a an error while saving on:\n%s */
      /* The error code = (%d).*/
      return fe_editor_report_file_error(context, error, filename, TRUE);
  } else {
      return TRUE;
  }
}

Boolean XP_ConvertUrlToLocalFile (const char *url, char **localName)
{
  Boolean filefound = FALSE;
  char *path = NULL;
  char *file = NULL;
  XP_StatStruct statinfo;

  if (localName)
    {
      *localName = NULL;
    }

  /* Must have "file:" url type and at least 1 character after '//' */
  if (!url || !NET_IsLocalFileURL((char *) url))
    {
	return FALSE; 
    }

  /* Extract file path from url: e.g. "/cl/foo/file.html" */
  path = NET_ParseURL (url, GET_PATH_PART);
  if (!path || XP_STRLEN(path) < 1) {
    return FALSE;
  }

#if 0
  /* Get filename - skip over initial "/" */
  file = WH_FileName (path+1, xpURL);
  XP_FREE (path);
#endif
  file = XP_STRDUP(path);
 
  /* Test if file exists */
  if (XP_Stat (file, &statinfo, xpURL) >= 0 &&
      statinfo.st_mode & S_IFREG)
    {
      filefound = TRUE;
    }
 
  if (localName)
    {
      /* Pass string to caller; we didn't change it, so there's
         no need to strdup
         */
      *localName = file;
    }

  return filefound;
}

char *
XP_BackupFileName (const char *url)
{
  char *filename = NULL;
  char* path;

  /* Must have a "file:" url and at least 1 character after the "//" */
  if (!url || !NET_IsLocalFileURL((char *) url))
    {
      return FALSE;
    }

  /* Extract file path from url: e.g. "/cl/foo/file.html" */
  path = NET_ParseURL (url, GET_PATH_PART);
  if (!path || XP_STRLEN(path) < 1) {
    return FALSE;
  }

  filename = (char *) XP_ALLOC ((XP_STRLEN (path) + 5) * sizeof (char));
  if (!filename)
    {
      return NULL;
    }

  /* Get filename but ignore "file://" */
  {
      char* filename2 = WH_FileName (path, xpURL);
      if (!filename2) return NULL;
      XP_STRCPY (filename, filename2);
      XP_FREE(filename2);
  }

  /* Add extension to the filename */
  XP_STRCAT (filename, "~");
  return filename;
}

void
fe_EditorUpdateToolbar(MWEditorContext* context, ED_TextFormat unused_for_now)
{
}

Boolean
fe_EditorLineBreakCanInsert(MWContext* context)
{
   return (EDT_IsSelected(context) == FALSE);
}

/*
 *    type             description
 *    ED_BREAK_NORMAL  insert line break, ignore images.
 *    ED_BREAK_LEFT    Break so it passes the image on the left
 *    ED_BREAK_RIGHT   Break past the right image.
 *    ED_BREAK_BOTH    Break below image(s).
 */
void
fe_EditorLineBreak(MWContext* context, ED_BreakType type)
{
    if (!fe_EditorLineBreakCanInsert(context))
        return;
    EDT_InsertBreak(context, type);
    fe_EditorUpdateToolbar(context, 0);
}

void
fe_EditorNonBreakingSpace(MWContext* context)
{
    EDT_InsertNonbreakingSpace(context);
    fe_EditorUpdateToolbar(context, 0);
}

void
fe_EditorParagraphMarksSetState(MWContext* context, Boolean display)
{
    EDT_SetDisplayParagraphMarks(context, (Bool)display);
}

Boolean
fe_EditorParagraphMarksGetState(MWContext* context)
{
    return (Boolean)EDT_GetDisplayParagraphMarks(context);
}

char*
fe_EditorDefaultGetTemplate()
{
    return XFE_EDITOR_DEFAULT_DOCUMENT_TEMPLATE_URL;
}

void
fe_EditorDefaultGetColors(LO_Color*  bg_color,
			  LO_Color*  normal_color,
			  LO_Color*  link_color,
			  LO_Color*  active_color,
			  LO_Color*  followed_color)
{
    if (bg_color)
        *bg_color = lo_master_colors[LO_COLOR_BG];

    if (normal_color)
        *normal_color = lo_master_colors[LO_COLOR_FG];

    if (link_color)
        *link_color = lo_master_colors[LO_COLOR_LINK];

    if (active_color)
        *active_color = lo_master_colors[LO_COLOR_ALINK];

    if (followed_color)
        *followed_color = lo_master_colors[LO_COLOR_VLINK];
}

static char* fe_last_publish_location;
static char* fe_last_publish_username;
static char* fe_last_publish_password;

#define SAFE_STRDUP(x) ((x)? XP_STRDUP(x): NULL)

Boolean
fe_EditorDefaultGetLastPublishLocation(MWContext* context,
				       char** location,
				       char** username,
				       char** password)
{
    if (location)
        *location = SAFE_STRDUP(fe_last_publish_location);
    if (username)
        *username = SAFE_STRDUP(fe_last_publish_username);
    if (password)
        *password = SECNAV_UnMungeString(fe_last_publish_password);

    return fe_last_publish_password != NULL;
}

void
fe_EditorDefaultSetLastPublishLocation(MWContext* context,
				       char* location,
				       char* username,
				       char* password)
{
    /* NOTE: this function is not MT safe */
    if (fe_last_publish_location)
        XP_FREE(fe_last_publish_location);
    if (fe_last_publish_username)
        XP_FREE(fe_last_publish_username);
    if (fe_last_publish_password)
        XP_FREE(fe_last_publish_password);

    fe_last_publish_location = NULL;
    fe_last_publish_username = NULL;
    fe_last_publish_password = NULL;

    if (location) {
		char* full_location;
		int   rv;

        fe_last_publish_location = XP_STRDUP(location);

		if (username)
			fe_last_publish_username = XP_STRDUP(username);

		if (password)
			fe_last_publish_password = SECNAV_MungeString(password);

		full_location = NULL; /* having to do this is SO stupid */
		rv = NET_MakeUploadURL(&full_location, location, username, NULL);

		if (rv && full_location != NULL) {
			PREF_SetCharPref("editor.publish_last_loc", full_location);
			PREF_SetCharPref("editor.publish_last_pass",
							 fe_last_publish_password?
							 fe_last_publish_password: "");
		}
    }
}

void
fe_EditorPreferencesGetAutoSave(MWContext* context,
				Boolean*   enable,
				unsigned*  time)
{
    if (fe_globalPrefs.editor_autosave_period == 0) {
	*time = 0;
	*enable = FALSE;
    } else {
	*time = fe_globalPrefs.editor_autosave_period;
	*enable = TRUE;
    }
}

void
fe_EditorPreferencesSetAutoSave(MWContext* context,
				Boolean    enable,
				unsigned   time)
{
    struct fe_MWContext_cons *rest;

    if (enable) {
	fe_globalPrefs.editor_autosave_period = time;
    } else {
	fe_globalPrefs.editor_autosave_period = 0;
	time = 0;
    }

    /*
     *    Walk over the contexts, and tell the BE to reset the
     *    autosave.
     */
    for (rest = fe_all_MWContexts; rest; rest = rest->next) {
	if (rest->context->type == MWContextEditor) {
	    EDT_SetAutoSavePeriod(rest->context, time);
	}
    }
}

void
fe_EditorPreferencesGetLinksAndImages(MWContext* context,
				      Boolean*   links, 
				      Boolean*   images)
{
    if (links)
	*links = fe_globalPrefs.editor_maintain_links;
    if (images)
	*images = fe_globalPrefs.editor_keep_images;
}

void
fe_EditorPreferencesSetLinksAndImages(MWContext* context,
				      Boolean    links, 
				      Boolean    images)
{
    fe_globalPrefs.editor_maintain_links = links;
    fe_globalPrefs.editor_keep_images = images;
}

Boolean
fe_EditorPreferencesGetPublishLocation(MWContext* context,
				       char** location,
				       char** username,
				       char** password)
{
    if (location)
        *location = SAFE_STRDUP(fe_globalPrefs.editor_publish_location);
    if (username)
        *username = SAFE_STRDUP(fe_globalPrefs.editor_publish_username);
    if (password)
        *password =
	  SECNAV_UnMungeString(fe_globalPrefs.editor_publish_password);

    return (fe_globalPrefs.editor_publish_password != NULL);
}

void
fe_EditorPreferencesSetPublishLocation(MWContext* context,
				       char* location,
				       char* username,
				       char* password)
{
    if (fe_globalPrefs.editor_publish_location)
        XP_FREE(fe_globalPrefs.editor_publish_location);
    if (fe_globalPrefs.editor_publish_username)
        XP_FREE(fe_globalPrefs.editor_publish_username);
    if (fe_globalPrefs.editor_publish_password)
        XP_FREE(fe_globalPrefs.editor_publish_password);

    fe_globalPrefs.editor_publish_location = NULL;
    fe_globalPrefs.editor_publish_username = NULL;
    fe_globalPrefs.editor_publish_password = NULL;

    if (location) {
        fe_globalPrefs.editor_publish_location = XP_STRDUP(location);

	if (username)
	    fe_globalPrefs.editor_publish_username = XP_STRDUP(username);

	if (password)
	    fe_globalPrefs.editor_publish_password
	      = SECNAV_MungeString(password);
    }
    fe_globalPrefs.editor_save_publish_password = (password != NULL);
}

char*
fe_EditorPreferencesGetBrowseLocation(MWContext* context)
{
    return SAFE_STRDUP(fe_globalPrefs.editor_browse_location);
}

void
fe_EditorPreferencesSetBrowseLocation(MWContext* context, char* location)
{
    if (fe_globalPrefs.editor_browse_location)
        XP_FREE(fe_globalPrefs.editor_browse_location);
    fe_globalPrefs.editor_browse_location = NULL;

    if (location)
	fe_globalPrefs.editor_browse_location = XP_STRDUP(location);
}

char*
fe_EditorPreferencesGetAuthor(MWContext* context)
{
    if (fe_globalPrefs.editor_author_name)
	return fe_globalPrefs.editor_author_name;
    else
	return "";
}

void
fe_EditorPreferencesSetAuthor(MWContext* context, char* name)
{
    if (fe_globalPrefs.editor_author_name)
	XtFree(fe_globalPrefs.editor_author_name);
    fe_globalPrefs.editor_author_name = XtNewString(name);
}

char*
fe_EditorPreferencesGetTemplate(MWContext* context)
{
    if (fe_globalPrefs.editor_document_template)
	return fe_globalPrefs.editor_document_template;
    else
	return NULL;
}

void
fe_EditorPreferencesSetTemplate(MWContext* context, char* name)
{
    if (fe_globalPrefs.editor_document_template)
	XtFree(fe_globalPrefs.editor_document_template);
    fe_globalPrefs.editor_document_template = XtNewString(name);
}

void
fe_EditorPreferencesGetEditors(MWContext* context, char** html, char** image)
{
    if (html != NULL) {
	if (fe_globalPrefs.editor_html_editor)
	    *html = fe_globalPrefs.editor_html_editor;
	else
	    *html = NULL;
    }

    if (image != NULL) {
	if (fe_globalPrefs.editor_image_editor)
	    *image = fe_globalPrefs.editor_image_editor;
	else
	    *image = NULL;
    }
}

void
fe_EditorPreferencesSetEditors(MWContext* context, char* html, char* image)
{
    if (html != NULL) {
	if (fe_globalPrefs.editor_html_editor)
	    XtFree(fe_globalPrefs.editor_html_editor);
	fe_globalPrefs.editor_html_editor = XtNewString(html);
    }

    if (image != NULL) {
	if (fe_globalPrefs.editor_image_editor)
	    XtFree(fe_globalPrefs.editor_image_editor);
	fe_globalPrefs.editor_image_editor = XtNewString(image);
    }
}

Boolean
fe_EditorPreferencesGetColors(MWContext* context,
			      char*      background_image,
			      LO_Color*  bg_color,
			      LO_Color*  normal_color,
			      LO_Color*  link_color,
			      LO_Color*  active_color,
			      LO_Color*  followed_color)
{
    if (bg_color)
	*bg_color = fe_globalPrefs.editor_background_color;
    if (normal_color)
	*normal_color = fe_globalPrefs.editor_normal_color;
    if (link_color)
	*link_color = fe_globalPrefs.editor_link_color;
    if (active_color)
	*active_color = fe_globalPrefs.editor_active_color;
    if (followed_color)
	*followed_color = fe_globalPrefs.editor_followed_color;

    if (background_image) {
	if (fe_globalPrefs.editor_background_image)
	    strcpy(background_image,  fe_globalPrefs.editor_background_image);
	else
	    background_image[0] = '\0';
    }

    return fe_globalPrefs.editor_custom_colors;
}

void
fe_EditorPreferencesSetColors(MWContext* context,
							  char*      background_image,
							  LO_Color*  bg_color,
							  LO_Color*  normal_color,
							  LO_Color*  link_color,
							  LO_Color*  active_color,
							  LO_Color*  followed_color)
{
    XP_Bool set = FALSE;

    if (bg_color) {
		fe_globalPrefs.editor_background_color = *bg_color;
		set = TRUE;
    }
    if (normal_color) {
		fe_globalPrefs.editor_normal_color = *normal_color;
		set = TRUE;
    }
    if (link_color) {
		fe_globalPrefs.editor_link_color = *link_color;
		set = TRUE;
    }
    if (active_color) {
		fe_globalPrefs.editor_active_color = *active_color;
		set = TRUE;
    }
    if (followed_color) {
		fe_globalPrefs.editor_followed_color = *followed_color;
		set = TRUE;
    }

    fe_globalPrefs.editor_custom_colors = set;

    if (fe_globalPrefs.editor_background_image)
		XtFree(fe_globalPrefs.editor_background_image);
    if (background_image && background_image[0] != '\0')
		fe_globalPrefs.editor_background_image = XtNewString(background_image);
    else
		fe_globalPrefs.editor_background_image = NULL;
}

Boolean
fe_EditorDocumentGetImagesWithDocument(MWContext* context)
{
    Boolean keep;
    EDT_PageData* page_data = EDT_GetPageData(context);

    if (page_data == NULL) {
	fe_EditorPreferencesGetLinksAndImages(context, NULL, &keep);
    } else {
	keep = page_data->bKeepImagesWithDoc;
	EDT_FreePageData(page_data);
    }

    return keep;
}

void
fe_EditorDocumentSetImagesWithDocument(MWContext* context, Boolean keep)
{
    EDT_PageData* page_data = EDT_GetPageData(context);

    if (page_data != NULL) {
	page_data->bKeepImagesWithDoc = keep;
	EDT_SetPageData(context, page_data);
	EDT_FreePageData(page_data);
    }
}

char*
fe_EditorDocumentLocationGet(MWContext* context)
{
    History_entry* hist_ent;

    /* get the location */
    hist_ent = SHIST_GetCurrent(&context->hist);
    if (hist_ent)
	return hist_ent->address;
    else
	return NULL;
}

void
fe_EditorDocumentSetTitle(MWContext* context, char* name)
{
    EDT_PageData* page_data = EDT_GetPageData(context);

	if (!page_data)
		return;

	if (page_data->pTitle)
		XP_FREE(page_data->pTitle);

	if (name && name[0] != '\0')
		page_data->pTitle = XP_STRDUP(name);
	else
		page_data->pTitle = NULL;

	EDT_SetPageData(context, page_data);

	EDT_FreePageData(page_data);
}

char*
fe_EditorDocumentGetTitle(MWContext* context)
{
    EDT_PageData* page_data;
	char*         value = NULL;

    /* get the title */
    page_data = EDT_GetPageData(context);
	if (page_data != NULL) {
		if (page_data->pTitle != NULL && page_data->pTitle[0] != '\0')
			value = XP_STRDUP(page_data->pTitle);
	
		EDT_FreePageData(page_data);
	}

    return value;
}

#define BEGIN_DIRTY(xxx) XP_Bool dirty = FALSE

#define MARK_DIRTY(context)           \
if (!(dirty)) {                       \
	EDT_BeginBatchChanges((context)); \
	dirty = TRUE;                     \
}

#define END_DIRTY(context)            \
if ((dirty)) {                        \
	EDT_EndBatchChanges((context));   \
}

void
fe_EditorDocumentSetMetaData(MWContext* context, char* name, char* value)
{
    EDT_MetaData *pData = EDT_NewMetaData();

	BEGIN_DIRTY(context);

    if ( pData ) {

        pData->bHttpEquiv = FALSE;
        if ( name && XP_STRLEN(name) > 0 ) {

			MARK_DIRTY(context);

            pData->pName = XP_STRDUP(name);
            if ( value && XP_STRLEN(value) > 0 ) {
                pData->pContent = XP_STRDUP(value);
                EDT_SetMetaData(context, pData);
            } else {
                /* (Don't really need to do this) */
				pData->pContent = NULL; 
                /* Remove the item */
				EDT_DeleteMetaData(context, pData);
            }
		}

		EDT_FreeMetaData(pData);
    }

	END_DIRTY(context);
}

char*
fe_EditorDocumentGetMetaData(MWContext* context, char* name)
{
    EDT_MetaData* pData;
    int count;
    int i;

    /* lifted from winfe/edprops.cpp */
    count = EDT_MetaDataCount(context);
    for (i = 0; i < count; i++ ) {
        pData = EDT_GetMetaData(context, i);
		if (pData != NULL && !pData->bHttpEquiv) {
			if (XP_STRCASECMP(pData->pName, name) == 0) {
				return pData->pContent;
			}
	    }
    }
    return NULL;
}

static char* fe_editor_known_meta_data_names[] = {
    "Author",
    "Description",
#if 0 /* this one need to end up in user variables */
    "Generator",
#endif
    "Last-Modified",
    "Created",
    "Classification",
    "Keywords",
    NULL
};

static Boolean
fe_is_known_meta_data_name(char* name)
{
    unsigned i;

    for (i = 0; fe_editor_known_meta_data_names[i] != NULL; i++) {
	if (XP_STRCASECMP(fe_editor_known_meta_data_names[i], name) == 0)
	    return TRUE;
    }
    return FALSE;
}

fe_NameValueItem*
fe_EditorDocumentGetHttpEquivMetaDataList(MWContext* context)
{
    int count = EDT_MetaDataCount(context);
    int i;
    EDT_MetaData* pData;
    fe_NameValueItem* items;
    unsigned nitems = 0;

    items = (fe_NameValueItem*)XtMalloc(sizeof(fe_NameValueItem)*(count+1));

    for (i = 0; i < count; i++) {
		pData = EDT_GetMetaData(context, i);

		if (pData != NULL && pData->bHttpEquiv != 0) {
			items[nitems].name = XtNewString(pData->pName);
			items[nitems].value = XtNewString(pData->pContent);
			nitems++;
		}
    }
    items[nitems].name = NULL;
    items[nitems].value = NULL;

    items = (fe_NameValueItem*)XtRealloc((XtPointer)items,
					 sizeof(fe_NameValueItem)*(nitems+1));

    return items;
}

void
fe_EditorDocumentSetHttpEquivMetaDataList(MWContext* context,
					  fe_NameValueItem* list)
{
    fe_NameValueItem* old_list;
    int i;
    int j;
    EDT_MetaData *meta_data;
	BEGIN_DIRTY(context);

    old_list = fe_EditorDocumentGetHttpEquivMetaDataList(context);

    /* first delete items no longer in set */
    for (i = 0; old_list[i].name != NULL; i++) {

		for (j = 0; list[j].name != NULL; j++) {
			if (XP_STRCASECMP(old_list[i].name, list[j].name) == 0) /* match */
				break;
		}

		/* I'm sure all this thrashing of the heap can't be required ?? */
		if (list[j].name == NULL) { /* it's gone now */
			meta_data = EDT_NewMetaData();
			meta_data->pName = old_list[i].name;
			meta_data->pContent = NULL;
			MARK_DIRTY(context);
			EDT_DeleteMetaData(context, meta_data);
			EDT_FreeMetaData(meta_data);
		}
    }

    /* now set the ones that have changed */
    for (j = 0; list[j].name != NULL; j++) {
		meta_data = EDT_NewMetaData();
		meta_data->pName = list[j].name;
		meta_data->pContent = list[j].value;
		meta_data->bHttpEquiv = TRUE;
		MARK_DIRTY(context);
		EDT_SetMetaData(context, meta_data);
		EDT_FreeMetaData(meta_data);
    }

	END_DIRTY(context);
}

fe_NameValueItem*
fe_EditorDocumentGetAdvancedMetaDataList(MWContext* context)
{
    int count = EDT_MetaDataCount(context);
    int i;
    EDT_MetaData* pData;
    fe_NameValueItem* items;
    unsigned nitems = 0;

    items = (fe_NameValueItem*)XtMalloc(sizeof(fe_NameValueItem)*(count+1));

    for (i = 0; i < count; i++) {
		pData = EDT_GetMetaData(context, i);

		if (pData == NULL)
			continue;

		/* is it one of the ones handled in document general */
        if ((pData->bHttpEquiv) || fe_is_known_meta_data_name(pData->pName))
			continue;
	
		items[nitems].name = XtNewString(pData->pName);
		items[nitems].value = XtNewString(pData->pContent);
		nitems++;
    }
    items[nitems].name = NULL;
    items[nitems].value = NULL;

    items = (fe_NameValueItem*)XtRealloc((XtPointer)items,
					 sizeof(fe_NameValueItem)*(nitems+1));

    return items;
}

void
fe_EditorDocumentSetAdvancedMetaDataList(MWContext* context,
					 fe_NameValueItem* list)
{
    fe_NameValueItem* old_list;
    int i;
    int j;
    EDT_MetaData *meta_data;
	BEGIN_DIRTY(context);

    old_list = fe_EditorDocumentGetAdvancedMetaDataList(context);

    /* first delete items no longer in set */
    for (i = 0; old_list[i].name != NULL; i++) {

		for (j = 0; list[j].name != NULL; j++) {
			if (XP_STRCASECMP(old_list[i].name, list[j].name) == 0) /* match */
				break;
		}

		/* I'm sure all this thrashing of the heap can't be required ?? */
		if (list[j].name == NULL) { /* it's gone now */
			meta_data = EDT_NewMetaData();
			meta_data->pName = old_list[i].name;
			meta_data->pContent = NULL;
			MARK_DIRTY(context);
			EDT_DeleteMetaData(context, meta_data);
			EDT_FreeMetaData(meta_data);
		}
    }

    /* now set the ones that have changed */
    for (j = 0; list[j].name != NULL; j++) {
		meta_data = EDT_NewMetaData();
		meta_data->pName = list[j].name;
		meta_data->pContent = list[j].value;
		MARK_DIRTY(context);
		EDT_SetMetaData(context, meta_data);
		EDT_FreeMetaData(meta_data);
    }

	END_DIRTY(context);
}

Boolean
fe_EditorDocumentGetColors(MWContext* context,
						   char*      background_image,
						   Boolean*   leave_image,
						   LO_Color*  bg_color,
						   LO_Color*  normal_color,
						   LO_Color*  link_color,
						   LO_Color*  active_color,
						   LO_Color*  followed_color)
{
    EDT_PageData* page_data = EDT_GetPageData(context);
    Boolean set = FALSE;

    fe_EditorDefaultGetColors(bg_color,
							  normal_color,
							  link_color, 
							  active_color,
							  followed_color);

	if (!page_data)
		return FALSE;

    if (background_image != NULL) {
        if (page_data->pBackgroundImage != NULL) {
			XP_STRCPY(background_image, page_data->pBackgroundImage);
		} else {
			background_image[0] = '\0';
		}
    }

    if (bg_color) {
        if (page_data->pColorBackground) {
			*bg_color = *page_data->pColorBackground;
			set = TRUE;
		}
    }

    if (normal_color) {
        if (page_data->pColorText) {
			*normal_color = *page_data->pColorText;
			set = TRUE;
		}
    }

    if (link_color) {
        if (page_data->pColorLink) {
			*link_color = *page_data->pColorLink;
			set = TRUE;
		}
    }

    if (active_color) {
        if (page_data->pColorActiveLink) {
			*active_color = *page_data->pColorActiveLink;
			set = TRUE;
		}
    }

    if (followed_color) {
        if (page_data->pColorFollowedLink) {
			*followed_color = *page_data->pColorFollowedLink;
			set = TRUE;
		}
    }

	if (leave_image) {
		*leave_image = page_data->bBackgroundNoSave;
	}


    EDT_FreePageData(page_data);

    return set;
}

void
fe_EditorDocumentSetColors(MWContext* context,
						   char*      background_image,
						   Boolean    leave_image,
						   LO_Color*  bg_color,
						   LO_Color*  normal_color,
						   LO_Color*  link_color,
						   LO_Color*  active_color,
						   LO_Color*  followed_color)
{
    EDT_PageData  save_data;
    EDT_PageData* page_data;
    
    if (background_image != NULL && background_image[0] == '\0')
		background_image = NULL;
    
    page_data = EDT_GetPageData(context);

	if (!page_data)
		return;

    memcpy(&save_data, page_data, sizeof(EDT_PageData));
    
    page_data->pBackgroundImage = background_image;
    page_data->pColorBackground = bg_color;
    page_data->pColorText = normal_color;
    page_data->pColorLink = link_color;
    page_data->pColorActiveLink = active_color;
    page_data->pColorFollowedLink = followed_color;
    page_data->bBackgroundNoSave = leave_image;
    
    EDT_SetPageData(context, page_data);
    memcpy(page_data, &save_data, sizeof(EDT_PageData));
    EDT_FreePageData(page_data);
}

typedef struct fe_EditorCommandDescription {
    intn  id;
    char* name;
} fe_EditorCommandDescription;

/*
 *    Yuck lifted from editor.h
 */
#define kNullCommandID 0
#define kTypingCommandID 1
#define kAddTextCommandID 2
#define kDeleteTextCommandID 3
#define kCutCommandID 4
#define kPasteTextCommandID 5
#define kPasteHTMLCommandID 6
#define kPasteHREFCommandID 7
#define kChangeAttributesCommandID 8
#define kIndentCommandID 9
#define kParagraphAlignCommandID 10
#define kMorphContainerCommandID 11
#define kInsertHorizRuleCommandID 12
#define kSetHorizRuleDataCommandID 13
#define kInsertImageCommandID 14
#define kSetImageDataCommandID 15
#define kInsertBreakCommandID 16
#define kChangePageDataCommandID 17
#define kSetMetaDataCommandID 18
#define kDeleteMetaDataCommandID 19
#define kInsertTargetCommandID 20
#define kSetTargetDataCommandID 21
#define kInsertUnknownTagCommandID 22
#define kSetUnknownTagDataCommandID 23
#define kGroupOfChangesCommandID 24
#define kSetListDataCommandID 25

#define kInsertTableCommandID 26
#define kDeleteTableCommandID 27
#define kSetTableDataCommandID 28

#define kInsertTableCaptionCommandID 29
#define kSetTableCaptionDataCommandID 30
#define kDeleteTableCaptionCommandID 31

#define kInsertTableRowCommandID 32
#define kSetTableRowDataCommandID 33
#define kDeleteTableRowCommandID 34

#define kInsertTableColumnCommandID 35
#define kSetTableCellDataCommandID 36
#define kDeleteTableColumnCommandID 37

#define kInsertTableCellCommandID 38
#define kDeleteTableCellCommandID 39

static fe_EditorCommandDescription fe_editor_commands[] = {
    { kNullCommandID,             "Null"              },
    { kTypingCommandID,           "Typing"            },
    { kAddTextCommandID,          "AddText"           },
    { kDeleteTextCommandID,       "DeleteText"        },
    { kCutCommandID,              "Cut"               },
    { kPasteTextCommandID,        "PasteText"         },
    { kPasteHTMLCommandID,        "PasteHTML"         },
    { kPasteHREFCommandID,        "PasteHREF"         },
    { kChangeAttributesCommandID, "ChangeAttributes"  },
    { kIndentCommandID,           "Indent"            },
    { kParagraphAlignCommandID,   "ParagraphAlign"    },
    { kMorphContainerCommandID,   "MorphContainer"    },
    { kInsertHorizRuleCommandID,  "InsertHorizRule"   },
    { kSetHorizRuleDataCommandID, "SetHorizRuleData"  },
    { kInsertImageCommandID,      "InsertImage"       },
    { kSetImageDataCommandID,     "SetImageData"      },
    { kInsertBreakCommandID,      "InsertBreak"       },
    { kChangePageDataCommandID,   "ChangePageData"    },
    { kSetMetaDataCommandID,      "SetMetaData"       },
    { kDeleteMetaDataCommandID,   "DeleteMetaData"    },
    { kInsertTargetCommandID,     "InsertTarget"      },
    { kSetTargetDataCommandID,    "SetTargetData"     },
    { kInsertUnknownTagCommandID, "InsertUnknownTag"  },
    { kSetUnknownTagDataCommandID,"SetUnknownTagData" },
    { kGroupOfChangesCommandID,   "GroupOfChanges"    },
    { kSetListDataCommandID,      "SetListData"       },
    { kInsertTableCommandID,      "InsertTable"       },
    { kDeleteTableCommandID,      "DeleteTable"       },
    { kSetTableDataCommandID,     "SetTableData"      },
    { kInsertTableCaptionCommandID,  "InsertTableCaption"  },
    { kSetTableCaptionDataCommandID, "SetTableCaptionData" },
    { kDeleteTableCaptionCommandID,  "DeleteTableCaption"  },
    { kInsertTableRowCommandID,    "InsertTableRow"   },
    { kSetTableRowDataCommandID,   "SetTableRowData"  },
    { kDeleteTableRowCommandID,    "DeleteTableRow"   },
    { kInsertTableColumnCommandID, "InsertTableColumn" },
    { kSetTableCellDataCommandID,  "SetTableCellData"  },
    { kDeleteTableColumnCommandID, "DeleteTableColumn" },
    { kInsertTableCellCommandID,   "InsertTableCell"  },
    { kDeleteTableCellCommandID,   "DeleteTableCell"  },

    { -1, NULL }
};

static XmString
resource_motif_string(Widget widget, char* name)
{
  XmString result = XfeSubResourceGetXmStringValue(widget,
												   name,
												   "UndoItem",
												   XmNlabelString,
												   XmCXmString,
												   NULL);
  
  if (!result)
      result = XmStringCreateLocalized(name);

  return result;
}

static XmString string_cache;

static XmString
fe_editor_undo_get_label(MWContext* context, intn id, Boolean is_undo)
{
    char     buf[64];
    XmString string;
    char* name;
    int n;

    name = NULL;
    for (n = 0; fe_editor_commands[n].name != NULL; n++) {
	if (fe_editor_commands[n].id == id) {
	    name = fe_editor_commands[n].name;
	    break;
	}
    }

    /*
     *    For ids we don't know yet, just show "Undo" or "Redo"
     */
    if (!name)
	name = "";

    /*
     *    Look for it in the cache here!!!!
     */
    /*FIXME*/
    if (string_cache)
	XmStringFree(string_cache);

    if (is_undo)
	XP_STRCPY(buf, "undo");
    else
	XP_STRCPY(buf, "redo");
    XP_STRCAT(buf, name);

    /*
     *    Resource the string.
     */
    /*
     *    Why is it so hard to get a string! Like, what,
     *    I'd never want to do that.
     */
    string = resource_motif_string(CONTEXT_DATA(context)->menubar, buf);
    string_cache = string;

    return string;
}

Boolean
fe_EditorCanUndo(MWContext* context, XmString* label_return)
{
    intn command_id = EDT_GetUndoCommandID(context, 0);

    if (label_return) {
	*label_return = fe_editor_undo_get_label(context,
						 command_id,
						 True);
    }
    
    if (command_id != CEDITCOMMAND_ID_NULL)
	return True;
    else
	return FALSE;
}

Boolean
fe_EditorCanRedo(MWContext* context, XmString* label_return)
{
    intn command_id = EDT_GetRedoCommandID(context, 0);
    
    if (label_return) {
	*label_return = fe_editor_undo_get_label(context, 
						 command_id,
						 False);
    }
    
    if (command_id != CEDITCOMMAND_ID_NULL)
	return True;
    else
	return FALSE;
}

void
fe_EditorUndo(MWContext* context)
{
    if (EDT_GetUndoCommandID(context, 0) != CEDITCOMMAND_ID_NULL) {
	EDT_Undo(context);
	fe_EditorUpdateToolbar(context, 0);
    } else {
	fe_Bell(context);
    }
}

void
fe_EditorRedo(MWContext* context)
{
    if (EDT_GetRedoCommandID(context, 0) != CEDITCOMMAND_ID_NULL) {
	EDT_Redo(context);
	fe_EditorUpdateToolbar(context, 0);
    } else {
	fe_Bell(context);
    }
}

Boolean
fe_EditorCanCut(MWContext* context)
{
    return (EDT_COP_OK == EDT_CanCut(context, FALSE));
}

Boolean
fe_EditorCanCopy(MWContext* context)
{
    return (EDT_COP_OK == EDT_CanCopy(context, TRUE));
}

static char fe_editor_data_name[] = "NETSCAPE_HTML";
static char fe_editor_html_name[] = "HTML";
static char fe_editor_text_name[] = "STRING";
static char fe_editor_app_name[] = "MOZILLA";

static Atom XFE_TEXT_ATOM = 0;
static Atom XFE_HTML_ATOM = 0;
static Atom XFE_DATA_ATOM = 0;

#define XFE_CCP_TEXT (fe_editor_text_name)
#define XFE_CCP_HTML (fe_editor_html_name)
#define XFE_CCP_DATA (fe_editor_data_name)
#define XFE_CCP_NAME (fe_editor_app_name)

#if 0
/*
 *    Cannot get this to work.
 */
static void
fe_property_notify_eh(Widget w, XtPointer closure, XEvent *ev, Boolean *cont)
{
    MWContext* context = (MWContext *)closure;
    Display*   display = XtDisplay(CONTEXT_WIDGET(context));
    Atom       cb_atom = XmInternAtom(display, "CLIPBOARD", False);
    Atom       string_atom = XmInternAtom(display, XFE_CCP_TEXT, False);
    Atom       html_atom = XmInternAtom(display, XFE_CCP_HTML, False);
    Atom       data_atom = XmInternAtom(display, XFE_CCP_DATA, False);
    Atom       long_string_atom = XmInternAtom(display, "_MOTIF_CLIP_FORMAT_" "STRING", False);
    Atom       long_html_atom = XmInternAtom(display, "_MOTIF_CLIP_FORMAT_" "NETSCAPE_HTML", False);
    fe_EditorContextData* editor;

#if 0
    if (ev->xproperty.atom == XA_CUT_BUFFER0) {
	editor = EDITOR_CONTEXT_DATA(context);
	fe_editor_paste_update_cb(editor->toolbar_paste,
				  (XtPointer)context, NULL);
    }
#endif

#if 0
    if (ev->xproperty.atom ==  XmInternAtom (dpy, "CLIPBOARD", False)XA_CUT_BUFFER0)
#endif
}
#endif

Boolean
fe_EditorCanPasteData(MWContext* context, int32* r_length)
{
    Widget   mainw    = CONTEXT_WIDGET(context);
    Display* display  = XtDisplay(mainw);
    Window   window   = XtWindow(mainw);
    int      cb_result;
    unsigned long length;

	cb_result = XmClipboardInquireLength(display, window,
										 XFE_CCP_DATA, &length);

    if (cb_result ==  ClipboardSuccess && length > 0) {
		*r_length = length;
		return TRUE;
    } else {
		*r_length = 0;
		return FALSE;
    }
}

Boolean
fe_EditorCanPasteHtml(MWContext* context, int32* r_length)
{
    Widget   mainw    = CONTEXT_WIDGET(context);
    Display* display  = XtDisplay(mainw);
    Window   window   = XtWindow(mainw);
    int      cb_result;
    unsigned long length;

	cb_result = XmClipboardInquireLength(display, window,
										 XFE_CCP_HTML, &length);

    if (cb_result ==  ClipboardSuccess && length > 0) {
		*r_length = length;
		return TRUE;
    } else {
		*r_length = 0;
		return FALSE;
    }
}

Boolean
fe_EditorCanPasteText(MWContext* context, int32* r_length)
{
    Widget   mainw    = CONTEXT_WIDGET(context);
    Display* display  = XtDisplay(mainw);
    Window   window   = XtWindow(mainw);
    int      cb_result;
    unsigned long length;

	cb_result = XmClipboardInquireLength(display, window,
										 XFE_CCP_TEXT, &length);

    if (cb_result ==  ClipboardSuccess && length > 0) {
		*r_length = length;
		return TRUE;
    } else {
		*r_length = 0;
		return FALSE;
    }
}

Boolean
fe_EditorCanPasteLocal(MWContext* context, int32* r_length)
{
	*r_length = 0;
    return FALSE;
}

#ifdef OSF1
extern char *fe_GetInternalHtml();
extern char *fe_GetInternalText();
#endif

Boolean
fe_EditorCanPasteCache(MWContext* context, int32* r_length)
{
	unsigned long text_len = 0;
	unsigned long html_len = 0;
	unsigned long data_len = 0;
	XP_Bool  sel_p = False;

    /*
     *    We have an "new" unified internal clipboard....
     *    Check it.
     */
	sel_p = fe_InternalSelection(True, &text_len, &html_len, &data_len);

	if (sel_p) {
		if (data_len > 0) {
			*r_length = data_len;
			return TRUE;
		}
		else {
			if (html_len > 0) {
				*r_length = html_len;
				return TRUE;
			}
			else {
				if (text_len > 0) {
					*r_length = text_len;
					return TRUE;
				}
			}
		}
	}

	*r_length = 0;
    return FALSE;
}

Boolean
fe_EditorCanPaste(MWContext* context)
{
    int32 len;

    /*
     *    We have to check if we can do a local paste first,
     *    because we can hang the server if we try to re-own
     *    the selection. This is all very hokey. I need to
     *    talk to jamie.
     */
    if (
	fe_EditorCanPasteLocal(context, &len)
	||
	fe_EditorCanPasteCache(context, &len)
	||
	fe_EditorCanPasteData(context, &len)
	|| 
	fe_EditorCanPasteHtml(context, &len)
	|| 
	fe_EditorCanPasteText(context, &len))
    {
	return TRUE;
    } else {
	return FALSE;
    }
}

void
fe_EditorCopyToClipboard(MWContext* context, char* string, Time timestamp)
{
	fe_OwnEDTSelection (context, timestamp, True, string, NULL, NULL, 0);
}

static void
fe_editor_report_copy_error(MWContext* context, EDT_ClipboardResult code)
{
    char* msg;
    int id;

    switch (code) {
    case EDT_COP_DOCUMENT_BUSY: /* IDS_DOCUMENT_BUSY */
	id = XFE_EDITOR_COPY_DOCUMENT_BUSY;
	/* Cannot copy or cut at this time, try again later. */
	break;
    case EDT_COP_SELECTION_EMPTY: /* IDS_SELECTION_EMPTY */
	id = XFE_EDITOR_COPY_SELECTION_EMPTY;
	/* Nothing is selected. */
	break;
    case EDT_COP_SELECTION_CROSSES_TABLE_DATA_CELL:
	id = XFE_EDITOR_COPY_SELECTION_CROSSES_TABLE_DATA_CELL;
	/* The selection includes a table cell boundary. */
	/* Deleting and copying are not allowed.         */
	break;
    default:
	return;
    }

    msg = XP_GetString(id);
    FE_Alert(context, msg);
}

void
fe_EditorReportCopyError(MWContext* context, EDT_ClipboardResult code)
{
	fe_editor_report_copy_error(context, code);
} 

Boolean
fe_EditorOwnSelection(MWContext *context, Time time, 
					  Boolean clip_p, Boolean cut_p)
{
    char* text;
    int32 text_len;
    char* data;
    int32 data_len;
    EDT_ClipboardResult cut_result;

	if (cut_p && clip_p) {
		if (!fe_EditorCanCut(context)) {
#ifdef DEBUG_rhess
			fprintf(stderr, "fe_EditorOwnSelection::[ can't CUT ]\n");
#endif
			return False;
		}

		cut_result = EDT_CutSelection(context, 
									  &text, &text_len,
									  &data, &data_len);
	}
	else {
		if (!fe_EditorCanCopy(context)) {
#ifdef DEBUG_rhess
			fprintf(stderr, "fe_EditorOwnSelection::[ can't COPY ]\n");
#endif
			return False;
		}

		cut_result = EDT_CopySelection(context, 
									   &text, &text_len,
									   &data, &data_len);
	}

    if (cut_result != EDT_COP_OK) {
		fe_editor_report_copy_error(context, cut_result);
		return False;
    }

    if ((!text || text_len <= 0) && (!data || data_len <= 0))
		return False;
    
	fe_OwnEDTSelection (context, time, clip_p, text, NULL, data, data_len);

	return True;
}

void
fe_EditorDisownSelection(MWContext *context, Time time, Boolean clip_p)
{
	Widget mainw = CONTEXT_WIDGET(context);

	if (clip_p)
		{
			fe_DisownClipboard(mainw, time);
		}
	else
		{
			fe_DisownPrimarySelection(mainw, time);

#ifdef NOT_rhess
			if (!fe_ContextHasPopups(context))
				EDT_ClearSelection(context);
#endif
		}
}

Boolean
fe_EditorCut(MWContext* context, Time timestamp)
{
	Boolean own_p = False;

	own_p = fe_EditorOwnSelection(context, timestamp, True, True);

    fe_EditorUpdateToolbar(context, 0);

	return own_p;
}

Boolean
fe_EditorCopy(MWContext* context, Time timestamp)
{
	Boolean own_p = False;

	own_p = fe_EditorOwnSelection(context, timestamp, True, False);

    fe_EditorUpdateToolbar(context, 0);

	return own_p;
}

static char fe_editor_local_name[] = "LOCAL";

#define XFE_CCP_LOCAL (fe_editor_local_name)

typedef struct {
    MWContext* context;
    char*  text;
    char*  html;
    char*  data;
	unsigned long text_len;
	unsigned long html_len;
	unsigned long data_len;
	int    count;
	int    max_count;
} xfe_pdata;

static xfe_pdata*
fe_new_pdata(MWContext* context, int max_count)
{
	xfe_pdata* pData = (xfe_pdata*) XP_ALLOC(sizeof(xfe_pdata));

	pData->context = context;
	pData->text = NULL;
	pData->html = NULL;
	pData->data = NULL;
	pData->text_len = 0;
	pData->html_len = 0;
	pData->data_len = 0;
	pData->count = 0;
	pData->max_count = max_count;

	return( pData );
}

static void
fe_free_pdata(xfe_pdata* pData)
{
	if (pData->text) {
		XtFree(pData->text);
	}

	if (pData->html) {
		XtFree(pData->html);
	}

	if (pData->data) {
		XtFree(pData->data);
	}

	pData->context = NULL;
	pData->text = NULL;
	pData->html = NULL;
	pData->data = NULL;
	pData->text_len = 0;
	pData->html_len = 0;
	pData->data_len = 0;
	pData->count = 0;
	pData->max_count = 0;

	XP_FREE(pData);
}

static void
fe_primary_sel_cb(Widget widget, XtPointer cdata, Atom *sel, Atom *type, 
					   XtPointer value, unsigned long *len, int *format)
{
	xfe_pdata* pData = (xfe_pdata*) cdata;

	if (value) {
		char* clip = (char *) value;

		if (*type == XFE_DATA_ATOM) {
			/*
			 * WARNING... [ this is actually HTML data, not HTML text ]
			 */
#ifdef DEBUG_rhess
			fprintf(stderr, 
					"fe_primary_sel_cb::[ data ][ %d ]\n", *len);
#endif
			pData->count++;
			pData->data_len = *len;
			pData->data = clip;
		}
		else {
			if (*type == XFE_HTML_ATOM) {
				/*
				 * NOTE... [ this is HTML source text ]
				 */
#ifdef DEBUG_rhess
				fprintf(stderr, 
						"fe_primary_sel_cb::[ html ][ %d ]\n", *len);
#endif
				pData->count++;
				pData->html_len = *len;
				pData->html = clip;
			}
			else {
				if (*type == XFE_TEXT_ATOM) {
#ifdef DEBUG_rhess
					fprintf(stderr, 
							"fe_primary_sel_cb::[ text ][ %d ]\n", *len);
#endif
					pData->count++;
					pData->text_len = *len;
					pData->text = clip;
				}
				else {
#ifdef DEBUG_rhess
					fprintf(stderr, "WARNING... [ unknown type atom ]\n");
#endif
				}
			}
		}
	}
	else {
		pData->count++;

#ifdef DEBUG_rhess
		if (*type == XFE_DATA_ATOM) {
			fprintf(stderr, "fe_primary_sel_cb::[ NULL ] - DATA\n");
		}
		else {
			if (*type == XFE_HTML_ATOM) {
				fprintf(stderr, "fe_primary_sel_cb::[ NULL ] - HTML\n");
			}
			else {
				if (*type == XFE_TEXT_ATOM) {
					fprintf(stderr, "fe_primary_sel_cb::[ NULL ] - TEXT\n");
				}
				else {
					fprintf(stderr, "fe_primary_sel_cb::[ ERROR ]\n");
				}
			}
		}
#endif
	}

	if (pData->count == pData->max_count) {
		if (pData->data_len > 0) {
#ifdef DEBUG_rhess
			fprintf(stderr, 
					"fe_primary_sel_cb::[ PasteHTML ][ %d ]\n",
					pData->data_len);
#endif
			EDT_PasteHTML(pData->context, pData->data);
		}
		else {
			if (pData->html_len > 0) {
#ifdef DEBUG_rhess
				fprintf(stderr, 
						"fe_primary_sel_cb::[ PasteQuote ][ %d ]\n",
						pData->html_len);
#endif
				EDT_PasteQuoteBegin(pData->context, True);
				EDT_PasteQuote(pData->context, pData->html);
				EDT_PasteQuoteEnd(pData->context);
			}
			else {
				if (pData->text_len > 0) {
#ifdef DEBUG_rhess
					fprintf(stderr, 
							"fe_primary_sel_cb::[ PasteText ][ %d ]\n",
							pData->text_len);
#endif
					EDT_PasteText(pData->context, pData->text);
				}
#ifdef DEBUG_rhess
				else {
					fprintf(stderr, "fe_primary_sel_cb::[ EMPTY ]\n");
				}
#endif
			}
		}
		fe_free_pdata(pData);
	}
}

Boolean
fe_EditorPastePrimarySel(MWContext* context, Time timestamp)
{
    Widget         mainw = CONTEXT_WIDGET(context);
    Display*       dpy   = XtDisplay(mainw);
	char*          data  = NULL;
	unsigned long  len   = 0;
	unsigned long  text_len = 0;
	unsigned long  html_len = 0;
	unsigned long  data_len = 0;
	XP_Bool        sel_p = False;

	/*
	 *  NOTE:  this only works if we are talking to one server... [ oops ]
	 */
	if (XFE_TEXT_ATOM == 0)
		XFE_TEXT_ATOM = XmInternAtom(dpy, XFE_CCP_TEXT, False);

	if (XFE_HTML_ATOM == 0)
		XFE_HTML_ATOM = XmInternAtom(dpy, XFE_CCP_HTML, False);
	
	if (XFE_DATA_ATOM == 0)
		XFE_DATA_ATOM = XmInternAtom(dpy, XFE_CCP_DATA, False);
	
	/*
	 *  NOTE:  first, let's see if we have an internal selection...
	 *
	 */
	sel_p = fe_InternalSelection(False, &text_len, &html_len, &data_len);

	if (sel_p) {
		if (data_len > 0) {
			data = fe_GetPrimaryData(&len);

#ifdef DEBUG_rhess
			fprintf(stderr, "fe_EditorPastePrimarySel::[ DATA ]\n");
#endif
			EDT_PasteHTML(context, data);
		}
		else {
			if (html_len > 0) {
				data = fe_GetPrimaryHtml();
		
#ifdef DEBUG_rhess
				fprintf(stderr, "fe_EditorPastePrimarySel::[ HTML ]\n");
#endif
				EDT_PasteQuoteBegin( context, True);
				EDT_PasteQuote( context, data);
				EDT_PasteQuoteEnd( context );
			}
			else {
				if (text_len > 0) {
					data = fe_GetPrimaryText();
				
#ifdef DEBUG_rhess
					fprintf(stderr, "fe_EditorPastePrimarySel::[ TEXT ]\n");
#endif
					EDT_PasteText(context, data);
				}
			}
		}
	}
	else {
		xfe_pdata  *pData = fe_new_pdata(context, 3);
		Atom        atoms[3];
		XtPointer   tags[3];

		atoms[0] = XFE_TEXT_ATOM;
		atoms[1] = XFE_HTML_ATOM;
		atoms[2] = XFE_DATA_ATOM;

		tags[0] = (XtPointer) pData;
		tags[1] = (XtPointer) pData;
		tags[2] = (XtPointer) pData;
		
		XtGetSelectionValues(mainw, 
							 XA_PRIMARY, atoms, 3,
							 fe_primary_sel_cb, 
							 tags,
							 timestamp);
	}
	return False; /* keep compiler happy for now */
}

Boolean
fe_EditorPaste(MWContext* context, Time timestamp)
{
    int32   length;
	char*   tmp_data  = NULL;
    char*   clip_data = NULL;
    char*   clip_name = NULL; /* none */
    int     cb_result;
    Boolean rv = FALSE;
    Widget   mainw    = CONTEXT_WIDGET(context);
    Display* display  = XtDisplay(mainw);
    Window   window   = XtWindow(mainw);
	unsigned long len = 0;
	unsigned long text_len = 0;
	unsigned long html_len = 0;
	unsigned long data_len = 0;
	int      i;


	if (!clip_data) {
		XP_Bool sel_p = fe_InternalSelection(True, 
											 &text_len, &html_len, &data_len);

		if (sel_p) {
			if (data_len > 0) {
				tmp_data = fe_GetInternalData(&len);

				clip_data = XP_ALLOC(len+1);
				memcpy(clip_data, tmp_data, len);
				clip_name = XFE_CCP_DATA;
			}
			else {
				if (html_len > 0) {
					tmp_data = fe_GetInternalHtml();
				
					clip_data = XP_STRDUP(tmp_data);
					clip_name = XFE_CCP_HTML;
				}
				else {
					if (text_len > 0) {
						tmp_data = fe_GetInternalText();
				
						clip_data = XP_STRDUP(tmp_data);
						clip_name = XFE_CCP_TEXT;
					}
				}
			}
		}
	}

    if (!clip_data) { /* go look on real CLIPBOARD */

		i = 0;
		do {
			cb_result = XmClipboardLock(display, window);
#ifdef DEBUG_rhess
			fprintf(stderr, "lockEDT::[ %d ]\n", i);
#endif
			i++;
		} while (cb_result == ClipboardLocked);
		
		if (fe_EditorCanPasteHtml(context, &length)) {
			clip_data = XP_ALLOC(length+1);
			clip_name = XFE_CCP_HTML;
		} else if (fe_EditorCanPasteText(context, &length)) {
			clip_data = XP_ALLOC(length+1);
			clip_name = XFE_CCP_TEXT;
		}
		
		cb_result = XmClipboardUnlock(display, window, TRUE);
#ifdef DEBUG_rhess
		fprintf(stderr, "fe_EditorPaste::[ unlock ]\n");
#endif
		
		if (clip_data) {
			
#ifdef DEBUG_rhess
			fprintf(stderr, "fe_EditorPaste::[ retrieve ]\n");
#endif
			cb_result = xfe_clipboard_retrieve_work(mainw,
                                                                clip_name,
                                                                &clip_data,
                                                                &len,
                                                                timestamp);
#ifdef DEBUG_rhess
			fprintf(stderr, "fe_EditorPaste::[ gotcha ]\n");
#endif
			
			if (cb_result == ClipboardSuccess) {
				clip_data[len] = '\0';
			} else {
				XP_FREE(clip_data);
				clip_data = NULL;
				clip_name = NULL;
			}
		}
    } 

    if (clip_name == XFE_CCP_DATA) {
#ifdef DEBUG_rhess
		fprintf (stderr, "fe_EditorPaste::[ XFE_CCP_DATA ]\n");
#endif
		rv = (EDT_PasteHTML(context, clip_data) == EDT_COP_OK);
		XP_FREE(clip_data);
    } else if (clip_name == XFE_CCP_HTML) {
#ifdef DEBUG_rhess
		fprintf (stderr, "fe_EditorPaste::[ XFE_CCP_HTML ]\n");
#endif
		EDT_PasteQuoteBegin( context, True);
		EDT_PasteQuote( context, clip_data);
		EDT_PasteQuoteEnd( context );
		XP_FREE(clip_data);
	} else if (clip_name == XFE_CCP_TEXT) {
#ifdef DEBUG_rhess
		fprintf (stderr, "fe_EditorPaste::[ XFE_CCP_TEXT ]\n");
#endif
		rv = (EDT_PasteText(context, clip_data) == EDT_COP_OK);
		XP_FREE(clip_data);
    } else if (clip_name == XFE_CCP_LOCAL) {
#ifdef DEBUG_rhess
		fprintf (stderr, "fe_EditorPaste::[ XFE_CCP_LOCAL ]\n");
#endif
		rv = (EDT_PasteText(context, clip_data) == EDT_COP_OK);
    } else {
		fe_Bell(context);
    }

#ifdef DONT_rhess
    fe_EditorUpdateToolbar(context, 0);
#endif
    return rv;
}

void
fe_EditorSelectAll(MWContext* context)
{
	Display *dpy  = XtDisplay(CONTEXT_WIDGET(context));
	Time     time = XtLastTimestampProcessed(dpy);

    EDT_SelectAll(context);  

    fe_EditorOwnSelection (context, time, False, False);
    fe_EditorUpdateToolbar(context, 0);
}

void
fe_EditorDeleteItem(MWContext* context, Boolean previous)
{
    EDT_ClipboardResult result;

	if (previous)
		result = EDT_DeletePreviousChar(context);
	else
		result = EDT_DeleteChar(context);

    if (result != EDT_COP_OK)
		fe_editor_report_copy_error(context, result);

    fe_EditorUpdateToolbar(context, 0);
}

Boolean
fe_EditorHorizontalRulePropertiesCanDo(MWContext* context)
{
    ED_ElementType type = EDT_GetCurrentElementType(context);

    if  (type == ED_ELEMENT_HRULE)
	return TRUE;
    else
	return FALSE;
}

void
fe_EditorHorizontalRulePropertiesSet(MWContext* context, EDT_HorizRuleData* data)
{
    if (fe_EditorHorizontalRulePropertiesCanDo(context)) {
	EDT_SetHorizRuleData(context, data);
    } else {
	EDT_InsertHorizRule(context, data);
    }
}

void
fe_EditorHorizontalRulePropertiesGet(MWContext* context, EDT_HorizRuleData* data)
{
    EDT_HorizRuleData* foo;

    if (fe_EditorHorizontalRulePropertiesCanDo(context)
		&&
		(foo = EDT_GetHorizRuleData(context)) != NULL) {
		memcpy(data, foo, sizeof(EDT_HorizRuleData));
		EDT_FreeHorizRuleData(foo);
    } else {
		data->size = 2;
		data->iWidth = 100;
		data->bWidthPercent = TRUE;
		data->align = ED_ALIGN_CENTER;
		data->bNoShade = FALSE;
    }
}

void
fe_EditorRefresh(MWContext* context)
{
    EDT_RefreshLayout(context);    
}

void
fe_EditorHrefInsert(MWContext* context, char* p_text, char* p_url)
{
    char* text;
    char* url;
	EDT_ClipboardResult result;

    if (!EDT_CanSetHREF(context)) { /* should not exist already */

		if (p_url && p_url[0] != '\0')
			url = XP_STRDUP(p_url);
		else
			return; /* no url specified */

		if (p_text && p_text[0] != '\0')
			text = XP_STRDUP(p_text);
		else
			text = XP_STRDUP(p_url);

		result = EDT_PasteHREF(context, &url, &text, 1);
	
		if (result != EDT_COP_OK)
			fe_editor_report_copy_error(context, result);
    }
}

Boolean
fe_EditorGetHref(MWContext *context) {
    char*         p;

    p = (char *) LO_GetSelectionText(context);
    if (p == NULL) return False;
    else
	return NULL != EDT_GetHREF(context);
}


Boolean
fe_EditorHrefGet(MWContext* context, char** text, char** url)
{
    EDT_HREFData* href_data = EDT_GetHREFData(context);
    Bool          is_selected = EDT_IsSelected(context);
    char*         p;

    p = (char *) LO_GetSelectionText(context);

    if (is_selected && p != NULL) {
	*text = XtNewString(p);
	XP_FREE(p);
    } else if (p == NULL) {   /* this fixes #27762 */
	*text = NULL;
    } else if ((p = EDT_GetHREFText(context)) != NULL) { 
			/* charlie's new get the text of a link thing */
	*text = p;
    } else {
	*text = NULL;
    }
    
    if (href_data != NULL && (p = href_data->pURL) != NULL) {
	*url = XtNewString(p);
    } else {
	*url = NULL;
    }

    if (href_data != NULL)
	EDT_FreeHREFData(href_data);

    return EDT_CanSetHREF(context);
}

void
fe_EditorHrefSetUrl(MWContext* context, char* url)
{
    EDT_HREFData* href_data;

    if (EDT_CanSetHREF(context)) {

	href_data = EDT_GetHREFData(context);

	if (!href_data)
	    href_data = EDT_NewHREFData();

	if (href_data->pURL)
	    XP_FREE(href_data->pURL);
	
	if (url)
	    href_data->pURL = XP_STRDUP(url);
	else
	    href_data->pURL = NULL; /* clear the href */

	EDT_SetHREFData(context, href_data);

	EDT_FreeHREFData(href_data);
    }
}

void
fe_EditorHrefClearUrl(MWContext* context)
{
    fe_EditorHrefSetUrl(context, NULL);
}

void
fe_EditorRemoveLinks(MWContext* context)
{
    /*
     *    Remove a single link or all links within selected region.
     */
    if (EDT_CanSetHREF(context)) {
        EDT_SetHREF(context, NULL);
    }
}

static Time
fe_getTimeFromEvent(MWContext* context, XEvent* event)
{
  Time time;
  time = (event && (event->type == KeyPress ||
		    event->type == KeyRelease)
	       ? event->xkey.time :
	       event && (event->type == ButtonPress ||
			 event->type == ButtonRelease)
	       ? event->xbutton.time :
	       XtLastTimestampProcessed (XtDisplay(CONTEXT_WIDGET (context))));
  return time;
}

Boolean
fe_EditorPropertiesDialogCanDo(MWContext* context,
			       fe_EditorPropertiesDialogType d_type)
{
    ED_ElementType e_type;

    if (
	d_type == XFE_EDITOR_PROPERTIES_IMAGE_INSERT
	||
	d_type == XFE_EDITOR_PROPERTIES_LINK_INSERT
	||
	d_type == XFE_EDITOR_PROPERTIES_CHARACTER
	||
	d_type == XFE_EDITOR_PROPERTIES_PARAGRAPH
	||
	d_type == XFE_EDITOR_PROPERTIES_TABLE
	|| 
	d_type == XFE_EDITOR_PROPERTIES_DOCUMENT
    )
	return TRUE; /* always ok to do */

    e_type = EDT_GetCurrentElementType(context);

    if (d_type == XFE_EDITOR_PROPERTIES_IMAGE) {
	if (e_type == ED_ELEMENT_IMAGE)
	    return TRUE;
	else
	    return FALSE;

    } else if (d_type == XFE_EDITOR_PROPERTIES_HRULE) {
	if (e_type == ED_ELEMENT_HRULE)
	    return TRUE;
	else
	    return FALSE;

    } else if (d_type == XFE_EDITOR_PROPERTIES_HTML_TAG) {
	if (e_type == ED_ELEMENT_UNKNOWN_TAG)
	    return TRUE;
	else
	    return FALSE;

    } else if (d_type == XFE_EDITOR_PROPERTIES_TARGET) {
	if (e_type == ED_ELEMENT_TARGET)
	    return TRUE;
	else
	    return FALSE;

    } else if (d_type == XFE_EDITOR_PROPERTIES_LINK) {
	if (EDT_GetHREF(context))
	    return TRUE;
	else
	    return FALSE;
    } 
    return FALSE;
}

/*
 *    This stuff is so crazy.
 *
 */
void
fe_EditorParagraphPropertiesSetAll(MWContext*    context,
				   TagType       paragragh_type,
				   EDT_ListData* list_data,
				   ED_Alignment  align)
{
    TagType       old_paragraph_type = EDT_GetParagraphFormatting(context);
    EDT_ListData* old_list_data = EDT_GetListData(context);
    Boolean       do_set;

    EDT_BeginBatchChanges(context);

    /*
     *    Windows has this kludge, so...
     */
    if (align == ED_ALIGN_LEFT)
	align = ED_ALIGN_DEFAULT;

    EDT_SetParagraphAlign(context, align);

    /*
     *    If there was a list before, and now there is none,
     *    remove the list.
     */
    if (old_list_data && !list_data) {
	for ( ; old_list_data; old_list_data = EDT_GetListData(context)) {
	    EDT_FreeListData(old_list_data);
	    EDT_Outdent(context);
	}
	old_list_data = NULL;
    }
    
    /*
     *    If the style has changed.
     */
    if (paragragh_type != old_paragraph_type)
	EDT_MorphContainer(context, paragragh_type);

    /*
     *    If there was no list, and now there is..
     */
    if (!old_list_data && list_data) {
	EDT_Indent(context);
	old_list_data = EDT_GetListData(context);
    }

    /*
     *    The BE is losing. It cannot deal with lists in selections,
     *    it returns no list data. So, we protect oursleves and
     *    end up doing nothing, just like windows.
     */
    if (old_list_data != NULL) {

	do_set = TRUE;

	/*
	 *    If this is a block quote..
	 */
	if (list_data != NULL && list_data->iTagType == P_BLOCKQUOTE) {
	    old_list_data->iTagType = P_BLOCKQUOTE;
	    old_list_data->eType = ED_LIST_TYPE_DEFAULT;
	}

	/*
	 *    If it's a list.
	 */
	else if (list_data != NULL) {
	    old_list_data->iTagType = list_data->iTagType;
	    old_list_data->eType = ED_LIST_TYPE_DEFAULT;
#if 0
	    /*
	     *    We have no UI for this, but maybe it's in  the author's
	     *    HTML. Don't change it. Actually, I have no idea.
	     */
	    old_list_data->bCompact = FALSE;
#endif
	    switch (list_data->iTagType) {
	    case P_UNUM_LIST:
		if (list_data->eType == ED_LIST_TYPE_DISC   ||
		    list_data->eType == ED_LIST_TYPE_SQUARE	||
		    list_data->eType == ED_LIST_TYPE_CIRCLE)
		    old_list_data->eType = list_data->eType;
		break;
	    case P_NUM_LIST:
		if (list_data->eType == ED_LIST_TYPE_DIGIT       ||
		    list_data->eType == ED_LIST_TYPE_BIG_ROMAN   ||
		    list_data->eType == ED_LIST_TYPE_SMALL_ROMAN ||
		    list_data->eType == ED_LIST_TYPE_BIG_LETTERS ||
		    list_data->eType == ED_LIST_TYPE_SMALL_LETTERS)
		    old_list_data->eType = list_data->eType;
		if (list_data->iStart > 0)
		    old_list_data->iStart = list_data->iStart;
		else
		    old_list_data->iStart = 1;
		break;
	    case P_DIRECTORY:
	    case P_MENU:
	    case P_DESC_LIST:
		break;
	    default: /* garbage, don't set */
		do_set = FALSE;
		break;
	    }
	}

	if (do_set)
	    EDT_SetListData(context, old_list_data);
    }

    /*
     *    Else it's just an ordinary old jo.
     */
    /* nothing to do */
 
    if (old_list_data != NULL)
	EDT_FreeListData(old_list_data);

    EDT_EndBatchChanges(context);
    
    fe_EditorUpdateToolbar(context, 0);
}

Boolean
fe_EditorParagraphPropertiesGetAll(MWContext*    context,
				   TagType*      paragragh_type,
				   EDT_ListData* list_data,
				   ED_Alignment* align)
{
    TagType       old_paragraph_type = EDT_GetParagraphFormatting(context);
    EDT_ListData* old_list_data = EDT_GetListData(context);

    if (paragragh_type)
	*paragragh_type = old_paragraph_type;

    if (list_data && old_list_data)
	*list_data = *old_list_data;

    if (align)
	*align = EDT_GetParagraphAlign(context);

    if (old_list_data != NULL)
	EDT_FreeListData(old_list_data);

    return (old_list_data != NULL);
}

/*FIXME*/
/*
 *    I think the following routine could now be replaced
 *    by EDT_SetFontColor(context, &color);
 */
void
fe_EditorColorSet(MWContext* context, LO_Color* color)
{
    EDT_CharacterData cdata;

    memset(&cdata, 0, sizeof(EDT_CharacterData));

    cdata.mask = TF_FONT_COLOR;
    cdata.pColor = color;

    if (color)
	cdata.values = TF_FONT_COLOR;
    else
	cdata.values = 0;

    EDT_SetCharacterData(context, &cdata);
}

Boolean
fe_EditorColorGet(MWContext* context, LO_Color* color)
{
	EDT_CharacterData* cdata = EDT_GetCharacterData(context);
    Boolean   rv = FALSE;
	LO_Color* use_color = NULL;

    if (cdata != NULL && (cdata->values & TF_FONT_COLOR) != 0) { /* custom */
		rv = TRUE; /* custom */
		if ((cdata->mask & TF_FONT_COLOR) != 0 && cdata->pColor != NULL) {
			use_color = cdata->pColor; /* defined */
		}
	}

	if (use_color != NULL) {
		*color = *use_color;
    } else {
		fe_EditorDocumentGetColors(context,
								   NULL, /* bg image */
								   NULL, /* leave image */
								   NULL, /* bg color */
								   color,/* normal color */
								   NULL, /* link color */
								   NULL, /* active color */
								   NULL); /* followed color */
    }

	if (cdata != NULL)
		EDT_FreeCharacterData(cdata);

    return rv; /* custom */
}

extern int XFE_COULDNT_FORK;
extern int XFE_EXECVP_FAILED;

void
fe_ExecCommand(MWContext* context, char** argv)
{
    char buf[MAXPATHLEN];
    int forked;

    switch (forked = fork()) {
    case -1:
	fe_perror(context, XP_GetString(XFE_COULDNT_FORK));
	break;
    case 0: {
	Display *dpy = XtDisplay(CONTEXT_WIDGET(context));
	close(ConnectionNumber(dpy));

	execvp(argv[0], argv);

	PR_snprintf(buf, sizeof(buf), XP_GetString(XFE_EXECVP_FAILED),
			fe_progname, argv[0]);
	perror(buf);
	exit(3);	/* Note that this only exits a child fork.  */
	break;
    }
    default:
	/* block */
	break;
    }
}

static char**
fe_editor_parse_argv(char* string, char* filename)
{
    char     buf[MAXPATHLEN];
    unsigned size = 32;
    unsigned argc = 0;
    char**   argv = (char**)malloc(sizeof(char*) * size);
    char*    p;
    char*    q;
    char*    r;

    for (p = string; *p != '\0'; ) {

	q = buf;

	/* skip leading white */
	while (isspace(*p))
	    p++;

	while (!isspace(*p) && *p != '\0' && ((q - buf) < sizeof(buf))) {
	    if (*p == '%' && p[1] == 'f') {
		for (r = filename; *r != '\0'; ) {
		    *q++ = *r++;
		}
		p += 2;
	    } else {
		*q++ = *p++;
	    }
	}
	*q = '\0';

	if (q > buf)
	    argv[argc++] = strdup(buf);

	if (argc == size) {
	    size = argc + 32;
	    argv = (char**)realloc((void*)argv, sizeof(char*) * size);
	}
    }

    if (argc > 0) {
	argv[argc] = NULL;
	return argv;
    } else {
	free(argv);
	return NULL;
    }
}

void
fe_editor_free_argv(char** argv)
{
    unsigned i;
    for (i = 0; argv[i]; i++)
	free(argv[i]);
    free(argv);
}

void
fe_editor_exec_command(MWContext* context, char* command, char* filename)
{
    char** argv;

    if ((argv = fe_editor_parse_argv(command, filename)) != NULL) {

	fe_ExecCommand(context, argv);

	fe_editor_free_argv(argv);
    } else {
	/* Empty command specified! */
	FE_Alert(context, XP_GetString(XFE_COMMAND_EMPTY));
    }
}

void
fe_EditorEditSource(MWContext* context)
{
    char* html_editor;
    char* local_name;
    History_entry* hist_entry;

    if (!FE_CheckAndSaveDocument(context))
		return;
    fe_EditorPreferencesGetEditors(context, &html_editor, NULL);

    if (html_editor == NULL || XP_STRSTR(html_editor, "%f") == NULL) {
		/*
		 * "Please specify an editor in Editor Preferences.\n"
		 * "Specify the file argument with %f. Netscape will\n"
		 * "replace %f with the correct file name. Examples:\n"
		 * "             xterm -e vi %f\n"
		 * "             xgifedit %f\n"
		 */
		char* msg = XP_GetString(XFE_EDITOR_HTML_EDITOR_COMMAND_EMPTY);
	
      	if (XFE_Confirm(context, msg)) {
			fe_EditorShowNewPreferences(context); /* call C++ adaptor */
		}

		return;
    } 

    hist_entry = SHIST_GetCurrent(&context->hist);
    if (hist_entry && hist_entry->address) {
		if (XP_ConvertUrlToLocalFile(hist_entry->address, &local_name)) {
			fe_editor_exec_command(context, html_editor, local_name);
			XP_FREE(local_name);
		}
    }
}

void
fe_EditorEditImage(MWContext* context, char* file)
{
    char* image_editor;
    char* local_name = NULL;
    char* full_file;
    char* directory;
    char* p;
    History_entry* hist_entry;

    fe_EditorPreferencesGetEditors(context, NULL, &image_editor);

    if (image_editor == NULL || XP_STRSTR(image_editor, "%f") == NULL) {
		/*
		 * "Please specify an editor in Editor Preferences.\n"
		 * "Specify the file argument with %f. Netscape will\n"
		 * "replace %f with the correct file name. Examples:\n"
		 * "             xterm -e vi %f\n"
		 * "             xgifedit %f\n"
		 */
		char* msg = XP_GetString(XFE_EDITOR_IMAGE_EDITOR_COMMAND_EMPTY);

      	if (XFE_Confirm(context, msg)) {
			fe_EditorShowNewPreferences(context); /* call C++ adaptor */
		}

		return;
    }

    while (isspace(*file))
		file++;

    if (file[0] != '/') { /* not absolute */
		hist_entry = SHIST_GetCurrent(&context->hist);
		if (hist_entry && hist_entry->address) {
			if (XP_ConvertUrlToLocalFile(hist_entry->address, &local_name)) {
				p = strrchr(local_name, '/'); /* find last slash */
				if (p) {
					*p = '\0';
					directory = local_name;
				} else {
					directory = ".";
				}
				full_file = (char*)XtMalloc(strlen(directory) +
											strlen(file) + 2);
				sprintf(full_file, "%s/%s", directory, file);
				XP_FREE(local_name);

				fe_editor_exec_command(context, image_editor, full_file);
				XtFree(full_file);
			}
		}
    } else {
		fe_editor_exec_command(context, image_editor, file);
    }
}

#define COPY_SAVE_EXTRA(b, a) \
{ char* xx_extra = (b)->pExtra; *(b) = *(a); (b)->pExtra = xx_extra; }

#define COPY_SAVE_BGCOLOR(b, a) \
{ char* xx_bgcolor = (b)->pColorBackground; *(b) = *(a); (b)->pColorBackground = xx_bgcolor; }

static LO_Color*
fe_dup_lo_color(LO_Color* color)
{
    LO_Color* new_color;

    if (color != NULL && (new_color = (LO_Color*)XtNew(LO_Color)) != NULL) {
	*new_color = *color;
	return new_color;
    } else {
	return NULL;
    }
}

#define DUP_BGCOLOR(b, a) \
{ (b)->pColorBackground = fe_dup_lo_color((a)->pColorBackground); }

/*
 *    Table support.
 */
Boolean
fe_EditorTableCanInsert(MWContext* context)
{
    return !EDT_IsJavaScript(context);
}

void
fe_EditorTableInsert(MWContext* context, EDT_AllTableData* all_data)
{
    EDT_TableData* new_data = EDT_NewTableData();
    EDT_TableCaptionData* caption_data;
    
    if (all_data) {
		EDT_TableData* data = &all_data->td;
		COPY_SAVE_EXTRA(new_data, data);
		DUP_BGCOLOR(new_data, data);
    } else {
		new_data->iBorderWidth = 1;
		new_data->iRows = 2;
		new_data->iColumns = 2;
    }
    EDT_BeginBatchChanges(context);

    EDT_InsertTable(context, new_data);

    if (all_data != NULL && all_data->has_caption) {
		caption_data = EDT_NewTableCaptionData();
		caption_data->align = all_data->cd.align;
		EDT_InsertTableCaption(context, caption_data);
    }

    EDT_FreeTableData(new_data);

	EDT_EndBatchChanges(context);
}

Boolean
fe_EditorTableCanDelete(MWContext* context)
{
    return (EDT_IsInsertPointInTable(context) != 0);
}

void
fe_EditorTableDelete(MWContext* context)
{
    if (EDT_IsInsertPointInTable(context) != 0) {
	EDT_DeleteTable(context);
	fe_EditorUpdateToolbar(context, 0);
    }
}

Boolean
fe_EditorTableGetData(MWContext* context, EDT_AllTableData* all_data)
{
    Boolean in_table = FALSE;
    EDT_TableData* table_data = EDT_GetTableData(context);
    EDT_TableData* pt_data = &all_data->td;
    EDT_TableCaptionData* caption_data;

    if (table_data) {
		*pt_data = *table_data;
		if (table_data->pColorBackground != NULL) {
			static LO_Color color_buf;
			color_buf = *table_data->pColorBackground;
			pt_data->pColorBackground = &color_buf; /*caller cannot hang on*/
		}
	
		if (table_data->pBackgroundImage != NULL) {
			static char* bg_image;
			if (bg_image != NULL)
				XP_FREE(bg_image);
			bg_image = XP_STRDUP(table_data->pBackgroundImage);
			pt_data->pBackgroundImage = bg_image; /*caller cannot hang on*/
		}
	
		EDT_FreeTableData(table_data);
		in_table = TRUE;
    } else {
		return FALSE;
    }

    if (EDT_IsInsertPointInTableCaption(context)
		&&
		(caption_data = EDT_GetTableCaptionData(context)) != NULL) {
		
		all_data->has_caption = TRUE;
		all_data->cd.align = caption_data->align;
    } else {
		all_data->has_caption = FALSE;
		all_data->cd.align = ED_ALIGN_TOP;
    }
    return TRUE;
}

void
fe_EditorTableSetData(MWContext* context, EDT_AllTableData* all_data)
{
    Boolean has_caption;
    Boolean wants_caption;
    EDT_TableData* table_data = EDT_GetTableData(context);
    EDT_TableCaptionData* caption_data;

    if (table_data) {
		EDT_BeginBatchChanges(context);

		/* get the basic table data */
		COPY_SAVE_EXTRA(table_data, &all_data->td);
		DUP_BGCOLOR(table_data, &all_data->td);

		EDT_SetTableData(context, table_data);

		caption_data = NULL;
		has_caption = EDT_IsInsertPointInTableCaption(context);
		wants_caption = all_data->has_caption;

		if (has_caption == TRUE && wants_caption == FALSE) {
			EDT_DeleteTableCaption(context);
		} else if (has_caption == FALSE && wants_caption == TRUE) {
			caption_data = EDT_NewTableCaptionData();
			caption_data->align = all_data->cd.align;
			EDT_InsertTableCaption(context, caption_data);
		} else if (has_caption
				   &&
				   (caption_data = EDT_GetTableCaptionData(context)) != NULL) {
			if (caption_data->align != all_data->cd.align) {
				caption_data->align = all_data->cd.align;
				EDT_SetTableCaptionData(context, caption_data);
			}
		}

		EDT_BeginBatchChanges(context);

		if (caption_data)
			EDT_FreeTableCaptionData(caption_data);

		EDT_FreeTableData(table_data);
    }
}

Boolean
fe_EditorTableRowCanInsert(MWContext* context)
{
    return (EDT_IsInsertPointInTableRow(context) != 0);
}

void
fe_EditorTableRowInsert(MWContext* context, EDT_TableRowData* data)
{
    EDT_TableRowData* new_data;

    if (!fe_EditorTableRowCanInsert(context)) {
		fe_Bell(context);
		return;
    }

    new_data = EDT_GetTableRowData(context);

	if (!new_data)
		return;

    if (data) {
		new_data->align = data->align;
		new_data->valign = data->valign;
		DUP_BGCOLOR(new_data, data);
    } 
    EDT_InsertTableRows(context, new_data, TRUE, 1);
    EDT_FreeTableRowData(new_data);
    fe_EditorUpdateToolbar(context, 0);
}

Boolean
fe_EditorTableRowCanDelete(MWContext* context)
{
    return (EDT_IsInsertPointInTableRow(context) != 0);
}

void
fe_EditorTableRowDelete(MWContext* context)
{
    if (EDT_IsInsertPointInTable(context) != 0) {
	EDT_DeleteTableRows(context, 1);
	fe_EditorUpdateToolbar(context, 0);
    }
}

Boolean
fe_EditorTableRowGetData(MWContext* context, EDT_TableRowData* p_data)
{
    EDT_TableRowData* row_data = EDT_GetTableRowData(context);

    if (row_data) {
		*p_data = *row_data;
		if (row_data->pColorBackground != NULL) {
			static LO_Color color_buf;
			color_buf = *row_data->pColorBackground;
			p_data->pColorBackground = &color_buf; /*caller cannot hang on*/
		}
		EDT_FreeTableRowData(row_data);
		return TRUE;
    } else {
		return FALSE;
    }
}

void
fe_EditorTableRowSetData(MWContext* context, EDT_TableRowData* p_data)
{
    EDT_TableRowData* row_data = EDT_GetTableRowData(context);

    if (row_data) {
	COPY_SAVE_EXTRA(row_data, p_data);
	DUP_BGCOLOR(row_data, p_data);
	EDT_SetTableRowData(context, row_data);	
	EDT_FreeTableRowData(row_data);
	fe_EditorUpdateToolbar(context, 0);
    }
}

Boolean
fe_EditorTableCaptionCanInsert(MWContext* context)
{
    return (EDT_IsInsertPointInTable(context) != 0);
}

void
fe_EditorTableCaptionInsert(MWContext* context, EDT_TableCaptionData* data)
{
    EDT_TableCaptionData* new_data = EDT_NewTableCaptionData();
    EDT_InsertTableCaption(context, new_data);
    EDT_FreeTableCaptionData(new_data);
    fe_EditorUpdateToolbar(context, 0);
}

Boolean
fe_EditorTableCaptionCanDelete(MWContext* context)
{
    return (EDT_IsInsertPointInTableCaption(context) != 0);
}

void
fe_EditorTableCaptionDelete(MWContext* context)
{
    if (EDT_IsInsertPointInTableCaption(context) != 0) {
	EDT_DeleteTableCaption(context);
	fe_EditorUpdateToolbar(context, 0);
    }
}

Boolean
fe_EditorTableColumnCanInsert(MWContext* context)
{
    return (EDT_IsInsertPointInTableRow(context) != 0);
}

void
fe_EditorTableColumnInsert(MWContext* context, EDT_TableCellData* data)
{
    EDT_TableCellData* new_data = EDT_NewTableCellData();
    EDT_InsertTableColumns(context, new_data, TRUE, 1);
    EDT_FreeTableCellData(new_data);

    fe_EditorUpdateToolbar(context, 0);
}

Boolean
fe_EditorTableColumnCanDelete(MWContext* context)
{
    return (EDT_IsInsertPointInTableRow(context) != 0);
}

void
fe_EditorTableColumnDelete(MWContext* context)
{
    if (EDT_IsInsertPointInTableRow(context) != 0) {
	EDT_DeleteTableColumns(context, 1);
	fe_EditorUpdateToolbar(context, 0);
    }
}

Boolean
fe_EditorTableCellCanInsert(MWContext* context)
{
    return (EDT_IsInsertPointInTableRow(context) != 0);
}

void
fe_EditorTableCellInsert(MWContext* context, EDT_TableCellData* data)
{
    EDT_TableCellData* new_data = EDT_NewTableCellData();
    EDT_InsertTableCells(context, new_data, TRUE, 1);
    EDT_FreeTableCellData(new_data);

    fe_EditorUpdateToolbar(context, 0);
}

Boolean
fe_EditorTableCellCanDelete(MWContext* context)
{
    return (EDT_IsInsertPointInTableCell(context) != 0);
}

void
fe_EditorTableCellDelete(MWContext* context)
{
    if (EDT_IsInsertPointInTableRow(context) != 0) {
	EDT_DeleteTableCells(context, 1);
	fe_EditorUpdateToolbar(context, 0);
    }
}

Boolean
fe_EditorTableCellGetData(MWContext* context, EDT_TableCellData* p_data)
{
    EDT_TableCellData* cell_data = EDT_GetTableCellData(context);
    if (cell_data) {
	*p_data = *cell_data;
	if (cell_data->pColorBackground != NULL) {
	    static LO_Color color_buf;
	    color_buf = *cell_data->pColorBackground;
	    p_data->pColorBackground = &color_buf; /*caller cannot hang on*/
	}
	EDT_FreeTableCellData(cell_data);
	return TRUE;
    } else {
	return FALSE;
    }
}

void
fe_EditorTableCellSetData(MWContext* context, EDT_TableCellData* p_data)
{
    EDT_TableCellData* cell_data = EDT_GetTableCellData(context);
    if (cell_data) {
	COPY_SAVE_EXTRA(cell_data, p_data);
	DUP_BGCOLOR(cell_data, p_data);
	EDT_SetTableCellData(context, cell_data);
	EDT_FreeTableCellData(cell_data);
	fe_EditorUpdateToolbar(context, 0);
    }
}

void
fe_EditorPublish(MWContext* context)
{
    /* Get the destination and what files to include from the user:*/
    fe_EditorPublishDialogDo(context);
}

void
fe_EditorDisplayTablesSet(MWContext* context, Boolean display)
{
    EDT_SetDisplayTables(context, display == TRUE);
    fe_EditorUpdateToolbar(context, 0);
}

Boolean
fe_EditorDisplayTablesGet(MWContext* context)
{
    return (EDT_GetDisplayTables(context) == TRUE);
}

static char*
fe_action_name(char* buf,
	       XtActionsRec* action_list,
	       Cardinal      action_list_size,
	       XtActionProc  action_proc,
	       String *av, Cardinal *ac)
{
    int i;
    char* name = XP_GetString(XFE_UNKNOWN); /* "<unknown>" */

    if (action_list_size == 0)
	action_list_size = 100000; /* look for null termination */

    /*
     *    Look for action name in the action_list.
     */
    for (i = 0; i < action_list_size && action_list[i].string != NULL; i++) {
	if (action_list[i].proc == action_proc) {
	    name = action_list[i].string;
	    break;
	}
    }

    strcpy(buf, name);
    strcat(buf, "(");
    for (i = 0; i < *ac; i++) {
	if (i != 0)
	    strcat(buf, ",");
	strcat(buf, av[i]);
    }
    strcat(buf, ")");

    return buf;
}

void xfe_GetShiftAndCtrl(XEvent* event, Boolean* shiftP, Boolean* ctrlP)
{
    if (event->type == KeyPress || event->type == KeyRelease) {
        unsigned int mask = event->xkey.state;
        if (shiftP) *shiftP = ((mask & ShiftMask) != 0);
        if (ctrlP) *ctrlP = ((mask & ControlMask) != 0);
    }
    else if (event->type == ButtonPress || event->type == ButtonRelease) {
        unsigned int mask = event->xbutton.state;
        if (shiftP) *shiftP = ((mask & ShiftMask) != 0);
        if (ctrlP) *ctrlP = ((mask & ControlMask) != 0);
    }
}

/* TEMPORARY HACK ALERT!!!
 * The backend doesn't keep track of which cell in a table is selected
 * for purposes of transition from within-cell selection extend to
 * inter-cell selection, and relies on the front-end to handle that.
 * But that means that each editor instance needs to keep track of the
 * selected cell (if any), which means this code would have to live in
 * EditorView.cpp.  But that means a lot of code change which I won't
 * be able to check in for quite some time due to the stability freeze.
 * So as a TEMPORARY measure, they're implemented as statics and we
 * count on the unliklihood of selection-extending in multiple windows
 * at once.  (Safe for drag-select, unsafe for shift-ctrl-click.) Yuck.
 */
static LO_Element* edElement = 0;
static XP_Bool crossedCellBoundary = FALSE;
static m_resizingTable = FALSE;
static XP_Rect m_sizingRect;


/*
 * NOTE:  because of this routine and its explicit need to disown the
 *        primary selection, we can't select text in the editor and then
 *        middle mouse paste it into another location in the same window...
 *
 *        - any ideas on how we might get around this one?...
 */
/* fe_EditorGrabFocus is called on starting a selection,
 * and when extending a selection with control-left-click
 * (followed then by fe_EditorSelectionExtend).
 */
void
fe_EditorGrabFocus(MWContext* context, XEvent *event)
{
	Widget da = NULL;
	XEvent ev;
  unsigned long x, y;
  Time time;
    LO_Element*   leHit = 0;
    ED_HitType    iTableHit; 

#undef DEBUG_TABLE_SELECTION
#ifdef DEBUG_TABLE_SELECTION
    printf("fe_EditorGrabFocus\n");
#endif /* DEBUG_TABLE_SELECTION */

#ifdef DREDD_EDITOR
  fe_UserActivity(context); /* tell the app who has focus */
#else

	da = CONTEXT_DATA(context)->drawing_area;

    ev.type              = FocusIn;
    ev.xfocus.type       = FocusIn;
	ev.xfocus.send_event = False;
	ev.xfocus.display    = XtDisplay(da);
	ev.xfocus.window     = XtWindow(da);
	ev.xfocus.mode       = NotifyNormal;
    ev.xfocus.detail     = NotifyDetailNone;

	XtDispatchEvent(&ev);

	XSync(XtDisplay(da), False);

	/*
	XtSetKeyboardFocus(CONTEXT_WIDGET(context), da);
	*/
#endif

  /* don't do this -- Japanese input method requires focus
  fe_NeutralizeFocus(context);
  */

  time = fe_getTimeFromEvent(context, event); /* get the time */

  fe_EventLOCoords(context, event, &x, &y); /* get the doc co-ords */

  /* see if we're in a table first... */
  iTableHit = EDT_GetTableHitRegion(context, x, y, &leHit, False);
  if (iTableHit == ED_HIT_SIZE_TABLE_WIDTH
      || iTableHit == ED_HIT_SIZE_TABLE_HEIGHT
      || iTableHit == ED_HIT_SIZE_COL || iTableHit == ED_HIT_SIZE_ROW
      || iTableHit == ED_HIT_ADD_ROWS || iTableHit == ED_HIT_ADD_COLS)
  {
#ifdef DEBUG_TABLE_SELECTION
      printf("resizing\n");
#endif /* DEBUG_TABLE_SELECTION */
      if( EDT_StartSizing(context, leHit, x, y, FALSE, &m_sizingRect) )
      {
          m_resizingTable = TRUE;
          edElement = leHit;
      }
      return;
  }
  m_resizingTable = FALSE;

  /*    Do this first, so the EDT_ClearSelection() in the call doesn't
   *    blow away what EDT_StartSelection() does!
   */
  fe_EditorDisownSelection(context, time, False); /* give up selection */

  if ( iTableHit != ED_HIT_NONE )
  {
      Boolean shift, ctrl;
      xfe_GetShiftAndCtrl(event, &shift, &ctrl);
#ifdef DEBUG_TABLE_SELECTION
      printf("iTableHit: %d\n", iTableHit);
#endif /* DEBUG_TABLE_SELECTION */

      if (iTableHit == ED_HIT_SEL_CELL)
          edElement = leHit;
      EDT_SelectTableElement(context, x, y,
                             leHit, iTableHit,
                             ctrl,      /* bModifierKeyPressed */
                             FALSE);    /* bExtendSelection */
  }
  /* EDT_GetTableHitRegion returns ED_HIT_NONE inside a cell */
  else if (leHit && leHit->type == LO_CELL)
  {
      /* Two cases: we might be starting a new selection (click alone),
       * or we might be extending the selection with control-click.
       */
      Boolean shift, ctrl;
      xfe_GetShiftAndCtrl(event, &shift, &ctrl);
#ifdef DEBUG_TABLE_SELECTION
      printf("cell: edElement = 0x%x, shift = %d, ctrl = %d\n",
             edElement, shift, ctrl);
#endif /* DEBUG_TABLE_SELECTION */

      /* Reset crossedCellBoundary if we're in a different table
       * from the old edElement, or if there was no old edElement.
       */
      if (!ctrl || !edElement
          || (lo_GetParentTable(context, edElement)
              != lo_GetParentTable(context, leHit)))
      {
          edElement = leHit;
          crossedCellBoundary = FALSE;
      }
      else
      {
          /* Control-selection to add cell to existing selection:
           * select old cell as well as new one.
           */
#ifdef DEBUG_TABLE_SELECTION
          printf("control-selection.  edElement = 0x%x\n", edElement);
#endif /* DEBUG_TABLE_SELECTION */
          if (edElement)
              EDT_SelectTableElement(context, x, y,
                                     edElement, ED_HIT_SEL_CELL,
                                     ctrl,      /* bModifierKeyPressed */
                                     FALSE);    /* bExtendSelection */
          EDT_SelectTableElement(context, x, y,
                                 leHit, ED_HIT_SEL_CELL,
                                 ctrl,      /* bModifierKeyPressed */
                                 FALSE);    /* bExtendSelection */
          edElement = 0;
          crossedCellBoundary = TRUE;
          return;
      }
  }
  else
  {
      edElement = 0;
      crossedCellBoundary = FALSE;
  }

  EDT_StartSelection(context, x, y);
}

/* We never call fe_EditorSelectionBegin(), as far as I can tell. ...Akk */
void
fe_EditorSelectionBegin(MWContext* context, XEvent *event)
{
    unsigned long x, y;
    Time time;
    LO_Element*   leHit = 0;
    ED_HitType    iTableHit;

#ifdef DEBUG_TABLE_SELECTION
    printf("fe_EditorSelectionBegin\n");
#endif /* DEBUG_TABLE_SELECTION */

    edElement = 0;
    crossedCellBoundary = FALSE;

    /* don't do this -- Japanese input method requires focus
    fe_NeutralizeFocus (context);
     */

    if (CONTEXT_DATA(context)->editor.ascroll_data.timer_id) {
        XtRemoveTimeOut(CONTEXT_DATA(context)->editor.ascroll_data.timer_id);
        CONTEXT_DATA(context)->editor.ascroll_data.timer_id = 0;
    }

    if (CONTEXT_DATA(context)->clicking_blocked
        || CONTEXT_DATA (context)->synchronous_url_dialog)
    {
        fe_Bell(context);
        return;
    }

    time = fe_getTimeFromEvent(context, event); /* get the time */
  
    fe_EventLOCoords(context, event, &x, &y);

#ifdef DONT_rhess
    /* 
     *  WARNING... [ nuke the primary selection owner ]
     */
    {
        Display *dpy = XtDisplay(CONTEXT_WIDGET(context));
        Window  owner = XGetSelectionOwner(dpy, XA_PRIMARY);

        if (owner != None) {
            XSetSelectionOwner(dpy, XA_PRIMARY, None, time);
        }
    }
#endif

    /*
     *    Do this first, so the EDT_ClearSelection() in the call doesn't
     *    blow away what EDT_StartSelection() does!
     */
    fe_EditorDisownSelection(context, time, False);

    /* see if we're in a table first... */
    iTableHit = EDT_GetTableHitRegion(context, x, y, &leHit, False);
    if ( iTableHit != ED_HIT_NONE )
    {
        Boolean shift, ctrl;
        xfe_GetShiftAndCtrl(event, &shift, &ctrl);
        EDT_SelectTableElement(context, x, y,
                               leHit, iTableHit,
                               ctrl,    /* bModifierKeyPressed */
                               shift);  /*bExtendSelection*/
        edElement = leHit;
        return;
    }

    /* EDT_GetTableHitRegion returns ED_HIT_NONE in a cell */
    if (leHit && leHit->type == LO_CELL)
        edElement = leHit;

    /* need to implement disown */
    EDT_StartSelection(context, x, y);
}

/* This is called on dragging, and also on shift-click */
void
fe_EditorSelectionExtend(MWContext* context, XEvent *event)
{
    Time       time;
    unsigned long x;
    unsigned long y;
    LO_Element*   leHit = 0;
    ED_HitType    iTableHit; 

#ifdef DEBUG_TABLE_SELECTION
    printf("fe_EditorSelectionExtend\n");
#endif /* DEBUG_TABLE_SELECTION */

    time = fe_getTimeFromEvent(context, event); /* get the time */

    /* don't do this -- Japanese input method requires focus
     fe_NeutralizeFocus(context);
     */

    fe_EventLOCoords (context, event, &x, &y);

    if (CONTEXT_DATA(context)->editor.ascroll_data.timer_id) {
        XtRemoveTimeOut(CONTEXT_DATA(context)->editor.ascroll_data.timer_id);
        CONTEXT_DATA(context)->editor.ascroll_data.timer_id = 0;
    }

    fe_editor_keep_pointer_visible(context, x, y);

    if (m_resizingTable)
    {
        GC gc;
        XGCValues gcv;
        Drawable drawable = CONTEXT_DATA(context)->drawable->xdrawable;
#if FEEDBACK_WITH_TABLE_BORDER_COLOR
        /* colors come back as 0, 0, 0 and don't show up */
        LO_TableStruct* ts = &(edElement->lo_table);
        gcv.foreground = fe_GetPixel(context,
                                     ts->border_color.red,
                                     ts->border_color.green,
                                     ts->border_color.blue);
        printf("RGB = %d %d %d\n", ts->border_color.red,
               ts->border_color.green, ts->border_color.blue);
#else /* FEEDBACK_WITH_TABLE_BORDER_COLOR */
        gcv.foreground = fe_GetPixel(context, 0xff, 0xff, 0xff);
#endif /* FEEDBACK_WITH_TABLE_BORDER_COLOR */
        gcv.function = GXxor;
        gc = fe_GetGC(CONTEXT_WIDGET(context),
                      GCForeground|GCFunction, &gcv);
        XDrawRectangle(XtDisplay(CONTEXT_WIDGET(context)), drawable, gc,
                       m_sizingRect.left, m_sizingRect.top,
                       m_sizingRect.right - m_sizingRect.left,
                       m_sizingRect.bottom - m_sizingRect.top);
        if (EDT_GetSizingRect(context, x, y, FALSE, &m_sizingRect))
        {
            /* show feedback */
            XDrawRectangle(XtDisplay(CONTEXT_WIDGET(context)), drawable, gc,
                           m_sizingRect.left, m_sizingRect.top,
                           m_sizingRect.right - m_sizingRect.left,
                           m_sizingRect.bottom - m_sizingRect.top);
        }
        return;
    }

#ifdef DONT_rhess
    /* 
     *  WARNING... [ nuke the primary selection owner ]
     */
    {
        Display  *dpy = XtDisplay(CONTEXT_WIDGET(context));
        Window  owner = XGetSelectionOwner(dpy, XA_PRIMARY);

        if (owner != None) {
            XSetSelectionOwner(dpy, XA_PRIMARY, None, time);
        }
    }
#endif

    /* see if we're in a table first... */
    iTableHit = EDT_GetTableHitRegion(context, x, y, &leHit, False);

    if (leHit && leHit->type == LO_CELL)
    {
        if (edElement && leHit != edElement)
        {
            Boolean shift, ctrl;
            xfe_GetShiftAndCtrl(event, &shift, &ctrl);

            if (!crossedCellBoundary)
            {
                 fe_EditorDisownSelection(context, time, False);
                 EDT_SelectTableElement(context, x, y,
                                        edElement, ED_HIT_SEL_CELL,
                                        FALSE,      /* bModifierKeyPressed */
                                        FALSE);    /*bExtendSelection*/
                 crossedCellBoundary = TRUE;
            }

            EDT_SelectTableElement(context, x, y,
                                   leHit, ED_HIT_SEL_CELL,
                                   ctrl,      /* bModifierKeyPressed */
                                   TRUE);    /*bExtendSelection*/
        }
        else
        {
            /* edElement = leHit; */
            EDT_ExtendSelection(context, x, y);
        }
    }

    else
      /* need to implement own */
      EDT_ExtendSelection(context, x, y);

#ifdef DONT_rhess
    fe_EditorOwnSelection (context, time, False, False);
#endif

#if 0
    /* Making a selection turns off "Save Next" mode. */
    if (CONTEXT_DATA (context)->save_next_mode_p)
		{
			XBell (XtDisplay (widget), 0);
			CONTEXT_DATA (context)->save_next_mode_p = False;
			fe_SetCursor (context, False);
			XFE_Progress (context, fe_globalData.click_to_save_cancelled_message);
		}
#endif
}

void
fe_EditorSelectionEnd(MWContext *context, XEvent *event)
{
    Time time;
    unsigned long x;
    unsigned long y;
    LO_Element*   leHit = 0;
    ED_HitType    iTableHit; 

#ifdef DEBUG_TABLE_SELECTION
    printf("fe_EditorSelectionEnd\n");
#endif /* DEBUG_TABLE_SELECTION */

    fe_UserActivity(context);
    time = fe_getTimeFromEvent(context, event); /* get the time */

    fe_EventLOCoords (context, event, &x, &y);

    if (CONTEXT_DATA(context)->editor.ascroll_data.timer_id) {
		XtRemoveTimeOut(CONTEXT_DATA(context)->editor.ascroll_data.timer_id);
		CONTEXT_DATA(context)->editor.ascroll_data.timer_id = 0;
	}

    if (m_resizingTable)
    {
#ifdef DEBUG_TABLE_SELECTION
        printf("Ending table resize: [%d, %d, %d, %d]\n",
               m_sizingRect.left, m_sizingRect.right, m_sizingRect.top,
               m_sizingRect.bottom);
#endif /* DEBUG_TABLE_SELECTION */
        EDT_EndSizing(context);
        m_resizingTable = FALSE;
        return;
    }

    /* see if we're in a table first... */
    iTableHit = EDT_GetTableHitRegion( context, x, y, &leHit, FALSE );
    if ( iTableHit == ED_HIT_SEL_TABLE
        || iTableHit == ED_HIT_SEL_CELL
        || iTableHit == ED_HIT_SEL_ALL_CELLS
        || iTableHit == ED_HIT_SEL_COL
        || iTableHit == ED_HIT_SEL_ROW )
    {
        Boolean shift, ctrl;
        xfe_GetShiftAndCtrl(event, &shift, &ctrl);
        EDT_SelectTableElement(context, x, y,
                               leHit, iTableHit,
                               ctrl,    /* bModifierKeyPressed */
                               shift);  /*bExtendSelection*/
        /*return;*/
    }

    /* need to implement own */
    EDT_EndSelection(context, x, y);

    fe_EditorOwnSelection(context, time, False, False);
}

#define XFE_EDITOR_MAX_INSERT_SIZE 512

void
fe_EditorKeyInsert(MWContext* context, Widget widget, XEvent* event)
{
    char       buf[XFE_EDITOR_MAX_INSERT_SIZE + 1];
    KeySym     keysym;
    Status     status_return;
    int        len;
    EDT_ClipboardResult result = EDT_COP_OK;
	INTL_CharSetInfo c = LO_GetDocumentCharacterSetInfo(context);

    if (widget != CONTEXT_DATA(context)->drawing_area) {
#ifdef DEBUG
		(void) fprintf(real_stderr,
					   "fe_editor_key_input_action got wrong widget (%s)\n",
					   XtName(widget));
#endif /* DEBUG */
		XtSetKeyboardFocus(CONTEXT_WIDGET(context),
						   CONTEXT_DATA(context)->drawing_area);
		return;
    }
    len = XmImMbLookupString(widget,
							 (XKeyEvent *)event,
							 buf,
							 XFE_EDITOR_MAX_INSERT_SIZE, 
							 &keysym,
							 &status_return);
    
    if (status_return == XBufferOverflow || len > XFE_EDITOR_MAX_INSERT_SIZE)
        return;

    if (len > 0) {
		char *str;

		buf[len] = 0;
		str = (char *) fe_ConvertFromLocaleEncoding(INTL_GetCSIWinCSID(c),
													(unsigned char *) buf);
		if (str != buf) {
			len = strlen(str);
		}

		if (len == 1) {
			result = EDT_KeyDown(context, str[0], 0, 0);
		} else if (len > 1) {
			result = EDT_PasteText(context, str);
		}

		if (result != EDT_COP_OK) {
			fe_editor_report_copy_error(context, result);
		}

		if (str != buf && str != NULL) {
			XP_FREE(str);
		}
    }
}

void
fe_EditorTab(MWContext* context, Boolean forward, Boolean force)
{
	EDT_ClipboardResult result = EDT_TabKey(context, forward, force);
	
	if (result != EDT_COP_OK)
		fe_editor_report_copy_error(context, result);
}

/*
 *    Editor specific action handlers.
 */
static void
fe_ActionWrongContextAlert(MWContext*, XtActionProc, String*, Cardinal*);

#ifdef DEBUG
#define FE_ACTION_ALERT(c, p, a, n) fe_ActionWrongContextAlert((c),(p),(a),(n))
#else
#define FE_ACTION_ALERT(c, p, a, n)
#endif

#define FE_ACTION_VALIDATE(proc)                  \
if (!(context) || !EDT_IS_EDITOR(context)) {      \
    FE_ACTION_ALERT(context, (proc), av, ac);     \
    return;                                       \
}


#define FE_SYNTAX_ERROR(proc) fe_ActionSyntaxAlert(context, (proc), av, ac)

/*=========================== ACTIONS =================================*/
static void
fe_get_selected_text_rect(MWContext* context,
			  LO_TextStruct* text,
			  int32*         rect_x,
			  int32*         rect_y,
			  int32*         rect_width,
			  int32*         rect_height)
{
    PA_Block    text_save = text->text;
    int         len_save = text->text_len;
    LO_TextInfo info;
    
    text->text_len = text->sel_start;
    XFE_GetTextInfo(context, text, &info);

    *rect_x = text->x + text->x_offset + info.max_width;
    *rect_y = text->y + text->y_offset;

    text->text = (PA_Block)((char*)text->text + text->sel_start);
    text->text_len = text->sel_end - text->sel_start;
    
    XFE_GetTextInfo(context, text, &info);

    *rect_width = info.max_width;
    *rect_height = info.ascent + info.descent;

    text->text = text_save;
    text->text_len = len_save;
}

static Boolean
fe_editor_selection_contains_point(MWContext* context, int32 x, int32 y)
{
    int32 start_selection;
    int32 end_selection;
    LO_Element* start_element = NULL;
    LO_Element* end_element = NULL;
    LO_Element* lo_element;
    int32 rect_x;
    int32 rect_y;
    int32 rect_width;
    int32 rect_height;
    CL_Layer *layer;

    if (!EDT_IsSelected(context))
	return FALSE;

    LO_GetSelectionEndpoints(context,
			     &start_element,
			     &end_element,
			     &start_selection,
			     &end_selection,
                             &layer);

    if (start_element == NULL)
	return FALSE;

    for (lo_element = start_element;
	 lo_element != NULL;
	 lo_element = ((LO_Any *)lo_element)->next) {

	if (lo_element->type == LO_TEXT &&
	    (lo_element == start_element || lo_element == end_element)) {
	    LO_TextStruct* text = (LO_TextStruct*)lo_element;

	    if (text->text == NULL) {
		if (text->prev != NULL && text->prev->type == LO_TEXT) {
		    text = (LO_TextStruct*)text->prev;
		} else {
		    text = (LO_TextStruct*)text->next;
		}
	    }
	    
	    if (text->text == NULL)
		continue;
	    
	    fe_get_selected_text_rect(context, text,
				      &rect_x,
				      &rect_y,
				      &rect_width,
				      &rect_height);
	    
	} else if (lo_element->type == LO_LINEFEED) {
	    continue;
	    
	} else {
	    LO_Any* lo_any = (LO_Any*)lo_element;
	    rect_x = lo_any->x + lo_any->x_offset;
	    rect_y = lo_any->y + lo_any->y_offset;
	    rect_width = lo_any->width;
	    rect_height = lo_any->height;
	}
	
	if (x > rect_x && y > rect_y &&
	    x < (rect_x + rect_width) && y < (rect_y + rect_height))
	    return TRUE;

	if (lo_element == end_element)
	    break;
    }

    return FALSE;
}

Boolean
fe_EditorSelectionContainsPoint(MWContext* context, int32 x, int32 y)
{
	return fe_editor_selection_contains_point(context, x, y);
}

static char*
fe_lo_image_anchor(LO_ImageStruct* image,
		     long x, long y,
		     MWContext* context)
{
    if (image->is_icon &&
        image->icon_number == IL_IMAGE_DELAYED) { /* delayed image */ 
		long width, height;

		fe_IconSize(IL_IMAGE_DELAYED, &width, &height);

		if (image->alt &&
			image->alt_len &&
			(x > image->x + image->x_offset + 1 + 4 + width)) {
			if (image->anchor_href) {
				return (char *)image->anchor_href->anchor;
			}
		} /* else fall to end */
	} 

	/*
	 *    Internal editor image maybe?
	 */
	else if (image->is_icon &&
			 (image->icon_number == IL_EDIT_NAMED_ANCHOR ||
			  image->icon_number == IL_EDIT_FORM_ELEMENT ||
			  image->icon_number == IL_EDIT_UNSUPPORTED_TAG ||
			  image->icon_number == IL_EDIT_UNSUPPORTED_END_TAG)) {

		if (image->alt != NULL)
			return (char*)image->alt;
		else
			return "";
    }

    /*
     * This would be a client-side usemap image.
     */
    else if (image->image_attr->usemap_name != NULL) {
	
		LO_AnchorData *anchor_href;
		long ix = image->x + image->x_offset;
		long iy = image->y + image->y_offset;
		long mx = x - ix - image->border_width;
		long my = y - iy - image->border_width;
	
		anchor_href = LO_MapXYToAreaAnchor(context,
										   (LO_ImageStruct *)image,
										   mx, my);
		if (anchor_href) {
			return (char *)anchor_href->anchor;
		} /* else fall to end */
    } else { /* some old random image */
		if (image->anchor_href) {
			return (char *)image->anchor_href->anchor;
		}
    }

    return NULL;
}

static LO_Element*   fe_editor_motion_action_last_le;
static Boolean       fe_editor_motion_action_last_le_is_image;
static LO_Element*   fe_editor_motion_action_last_hit_le;
static ED_HitType    fe_editor_motion_action_last_hit_type;

static void
fe_editor_motion_action(Widget widget, XEvent *event,
			String *av, Cardinal *ac)
{
    MWContext*    context = fe_MotionWidgetToMWContext(widget);
    LO_Element*   le;
    LO_Element*   leHit;
    ED_HitType    iTableHit; 
    unsigned long x, y;
    Cursor        cursor = None;
    char*         progress_string = NULL;
    char buf[80];
    char num[32];

    FE_ACTION_VALIDATE(fe_editor_motion_action);

    fe_EventLOCoords(context, event, &x, &y); /* get the doc co-ords */

    /* NOTE:  let's see if we're in table stuff first... */
    iTableHit = EDT_GetTableHitRegion( context, 
                                       x, y, 
                                       &leHit,
                                       FALSE );
    if ( iTableHit ) { 
        if ((fe_editor_motion_action_last_hit_type == iTableHit) &&
            (fe_editor_motion_action_last_hit_le == leHit)) {
            return;  /* NOTE:  no change... */
        }

        fe_editor_motion_action_last_hit_le   = leHit;
        fe_editor_motion_action_last_hit_type = iTableHit;

        switch ( iTableHit ) { 
            case ED_HIT_SEL_TABLE:
#ifdef DEBUG_TABLE_SELECTION
#define DEBUG_motion
#endif
#ifdef DEBUG_motion
                fprintf(stderr, "ED_HIT_SEL_TABLE:\n");
#endif
                cursor = CONTEXT_DATA(context)->tab_sel_cursor;
                break; 

            case ED_HIT_SEL_ALL_CELLS: 
#ifdef DEBUG_motion
                fprintf(stderr, "ED_HIT_SEL_ALL_CELLS:\n");
#endif
                cursor = None;
                break; 

            case ED_HIT_SEL_COL:  
#ifdef DEBUG_motion
                fprintf(stderr, "ED_HIT_SEL_COL:\n");
#endif
                cursor = CONTEXT_DATA(context)->col_sel_cursor;
                break; 

            case ED_HIT_SEL_ROW:  
#ifdef DEBUG_motion
                fprintf(stderr, "ED_HIT_SEL_ROW:\n");
#endif
                cursor = CONTEXT_DATA(context)->row_sel_cursor;
                break; 

            case ED_HIT_SEL_CELL:  
#ifdef DEBUG_motion
                fprintf(stderr, "ED_HIT_SEL_CELL:\n");
#endif
                cursor = CONTEXT_DATA(context)->cel_sel_cursor;
                break; 

            case ED_HIT_DRAG_TABLE:  
#ifdef DEBUG_motion
                fprintf(stderr, "ED_HIT_DRAG_TABLE:\n");
#endif
                cursor = CONTEXT_DATA(context)->resize_tab_cursor;
                break; 

            case ED_HIT_SIZE_TABLE_WIDTH:
#ifdef DEBUG_motion
                fprintf(stderr, "ED_HIT_SIZE_TABLE_WIDTH:\n");
#endif
                cursor = CONTEXT_DATA(context)->resize_tab_cursor;
                break; 

            case ED_HIT_SIZE_TABLE_HEIGHT:
#ifdef DEBUG_motion
                fprintf(stderr, "ED_HIT_SIZE_TABLE_HEIGHT:\n");
#endif
                cursor = CONTEXT_DATA(context)->resize_tab_cursor;
                break; 

            case ED_HIT_SIZE_ROW:
#ifdef DEBUG_motion
                fprintf(stderr, "ED_HIT_SIZE_ROW:\n");
#endif
                cursor = CONTEXT_DATA(context)->resize_row_cursor;
                break; 

            case ED_HIT_SIZE_COL:
#ifdef DEBUG_motion
                fprintf(stderr, "ED_HIT_SIZE_COL:\n");
#endif
                cursor = CONTEXT_DATA(context)->resize_col_cursor;
                break;

            case ED_HIT_ADD_ROWS:  
#ifdef DEBUG_motion
                fprintf(stderr, "ED_HIT_ADD_ROWS:\n");
#endif
                cursor = CONTEXT_DATA(context)->add_row_cursor;
                break; 

            case ED_HIT_ADD_COLS:  
#ifdef DEBUG_motion
                fprintf(stderr, "ED_HIT_ADD_COLS:\n");
#endif
                cursor = CONTEXT_DATA(context)->add_col_cursor;
                break; 

            default:  
                /* NOTE:  we shouldn't ever get here... */
#ifdef DEBUG_motion
                fprintf(stderr, "fe_editor_motion_action default:  WARNING ***************\n");
#endif
                cursor = None;
        } 
    } 
    else {
        /* NOTE:  let's check for the other elements... */

        le = LO_XYToElement(context, (int32)x, (int32)y, NULL);

        if (le == fe_editor_motion_action_last_le &&
            !fe_editor_motion_action_last_le_is_image &&
            (fe_editor_motion_action_last_hit_type == 0)) {
            return; /* NOTE:  no change... */
        }

        fe_editor_motion_action_last_hit_le   = NULL;
        fe_editor_motion_action_last_hit_type = 0;

        fe_editor_motion_action_last_le_is_image = FALSE;
        fe_editor_motion_action_last_le = le;
    
        if (le != NULL) {
            /*  Are we over text? Special cursor */
            if (le->type == LO_TEXT) {
                cursor = CONTEXT_DATA(context)->editable_text_cursor;
                if (le->lo_text.anchor_href) { /* link */
                    progress_string = (char *)le->lo_text.anchor_href->anchor;
                }
                /*  Over image, special progress */
            } 
            else {
                if (le->type == LO_IMAGE) {
                    progress_string = fe_lo_image_anchor(&le->lo_image, 
                                                         /* link ? */
                                                         x, y,
                                                         context);
                    if (progress_string != NULL && progress_string[0] == '\0')
                        progress_string = NULL;
					
                    if (progress_string == NULL) {
						
                        if (le->lo_image.image_url) {
                            progress_string = (char*)le->lo_image.image_url;
                        } else if (le->lo_image.lowres_image_url) {
                            progress_string = (char*)le->lo_image.lowres_image_url;
                        }
					
                        if (progress_string != NULL) {
                            sprintf(num, ",%d,%d",
                                    x - le->lo_image.x, y - le->lo_image.y);
                            FE_CondenseURL(buf, progress_string,
                                           sizeof(buf) - 1 - strlen(num));
                            strcat(buf, num);
                            progress_string = buf;
                            fe_editor_motion_action_last_le_is_image = TRUE;
                        }
                    }
                }
            }
        }
    }

    if (CONTEXT_DATA(context)->clicking_blocked ||
		CONTEXT_DATA(context)->synchronous_url_dialog) {
		cursor = CONTEXT_DATA(context)->busy_cursor;
    }

    if (CONTEXT_DATA(context)->drawing_area) {
		XDefineCursor(XtDisplay(CONTEXT_DATA(context)->drawing_area),
					  XtWindow(CONTEXT_DATA(context)->drawing_area),
					  cursor);
    }

    if (progress_string == NULL)
		progress_string = "";

    if (CONTEXT_DATA(context)->active_url_count == 0) {
		/* If there are transfers in progress, don't document the URL under
		   the mouse, since that message would interfere with the transfer
		   messages.  Do change the cursor, however. */
		fe_MidTruncatedProgress(context, progress_string);
    }
}

#define EA_PREFIX "editor-"

static XtActionsRec fe_editor_actions [] =
{
	{ EA_PREFIX "motion", fe_editor_motion_action },
};

static void
fe_ActionWrongContextAlert(MWContext*    context,
			   XtActionProc  action_proc,
			   String* av, Cardinal* ac)
{
    char buf[1024];
    char name[1024];

    fe_action_name(name,
		   fe_editor_actions, countof(fe_editor_actions),
		   action_proc, av, ac);
    sprintf(buf, XP_GetString(XFE_ACTION_WRONG_CONTEXT), name);

    if (context)
	FE_Alert(context, buf);
    else
	fprintf(real_stderr, buf);
}

void
fe_EditorInitActions()
{
	XtAppAddActions(fe_XtAppContext,
					fe_editor_actions,
					countof(fe_editor_actions)
					);
}

static void
fe_EditURLCallback(const char* urlToOpen)
{
	/*
	 *    Try to get editor first.  XP_FindSomeContext() does not look for
	 *    editor context.
	 */
	MWContext *context = XP_FindContextOfType(NULL, MWContextEditor);
	if (!context) {
		context = XP_FindSomeContext();
	}

	/* This shouldn't happen. */
	if (!context) {
		XP_ASSERT(0);
		return;
	}

	/*
	 *   If urlToOpen is already being edited, this will just pop it to
	 *   front.
	 */
	fe_EditorEdit(context, NULL, NULL, (char*)urlToOpen);
}

void
fe_EditorStaticInit()
{
	EDTPLUG_RegisterEditURLCallback(&fe_EditURLCallback);
}

/*
 * Note: this routine is untested.  It's called for dragging columns,
 * not for highlighting selected columns.
 */
void
FE_DisplayAddRowOrColBorder(MWContext* context, XP_Rect *pRect,
                            XP_Bool bErase)
{
    XGCValues gcv;
    unsigned long gc_flags;
    GC gc;
    fe_Drawable *fe_drawable = CONTEXT_DATA(context)->drawable;

#ifdef DEBUG_akkana
    printf("FE_DisplayAddRowOrColBorder\n");
#endif /* DEBUG_akkana */

    if (bErase)
    {
        gc_flags = GCForeground /* | GCLineWidth */ | GCLineStyle;
        gcv.foreground = CONTEXT_DATA(context)->select_bg_pixel;
    }
    else
    {
        gc_flags = GCForeground /* | GCLineWidth */ | GCLineStyle;
        gcv.foreground = CONTEXT_DATA(context)->select_bg_pixel;
        gcv.line_style = LineOnOffDash;
    }
    /*gcv.line_width = iSelectionBorderThickness;*/
    gc = fe_GetGCfromDW(fe_display, fe_drawable->xdrawable,
                        gc_flags, &gcv, fe_drawable->clip_region);
    XDrawRectangle(fe_display,
                   XtWindow(CONTEXT_DATA(context)->drawing_area), gc,
                   pRect->left, pRect->top,
                   pRect->left - pRect->right, pRect->bottom - pRect->top);
}

void 
FE_DisplayEntireTableOrCell(MWContext* context, LO_Element* pLoElement)
{
    LO_TableStruct* table;

    if (pLoElement->lo_any.type == LO_TABLE)
    {
        XFE_DisplayTable(context, 0, &(pLoElement->lo_table));
    }
    else if (pLoElement->lo_any.type == LO_CELL)
    {
        XFE_DisplayCell(context, 0, &(pLoElement->lo_cell));
    }
    else        /* shouldn't happen */
    {
#ifdef DEBUG_akkana
        printf("FE_DisplayEntireTableOrCell() with type %d\n",
               pLoElement->lo_any.type);
#endif /* DEBUG_akkana */
        table = lo_GetParentTable(context, pLoElement);
        XFE_DisplayTable(context, 0, table);
    }
}


#endif /* EDITOR */
