mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-08 20:47:44 +00:00
627 lines
13 KiB
C++
627 lines
13 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* 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.
|
|
*/
|
|
/*
|
|
Command.cpp -- command goop
|
|
Created: Chris Toshok <toshok@netscape.com>, 21-Sep-96.
|
|
*/
|
|
|
|
|
|
#include "Command.h"
|
|
#include "Frame.h"
|
|
#include "View.h"
|
|
#include "ViewGlue.h"
|
|
#include "commands.h"
|
|
|
|
#include <xpgetstr.h> /* for XP_GetString() */
|
|
|
|
extern int XFE_ACTION_SYNTAX_ERROR;
|
|
|
|
const char * Command::commandArmedCallback = "Command::commandArmedCallback";
|
|
const char * Command::commandDispatchedCallback = "Command::commandDispatchedCallback";
|
|
const char * Command::commandDisarmedCallback = "Command::commandDisarmedCallback";
|
|
const char * Command::doCommandCallback = "Command::doCommandCallback";
|
|
|
|
XFE_CommandInfo::XFE_CommandInfo(XFE_CommandEventType t,
|
|
Widget w, XEvent* e,
|
|
String* p,
|
|
Cardinal n) {
|
|
type = t;
|
|
widget = w;
|
|
if (e != NULL ) {
|
|
event = e;
|
|
} else {
|
|
if (XtIsSubclass(widget, xmGadgetClass))
|
|
widget = XtParent(widget);
|
|
event_store.type = 0;
|
|
event_store.xany.serial = 0;
|
|
event_store.xany.send_event = False;
|
|
event_store.xany.display = XtDisplay(widget);
|
|
event_store.xany.window = XtWindow(widget);
|
|
event = &event_store;
|
|
}
|
|
params = p;
|
|
|
|
if (n == 0) {
|
|
for (; p != NULL && p[n] != NULL; n++)
|
|
;
|
|
}
|
|
|
|
nparams_store = n;
|
|
nparams = &nparams_store;
|
|
}
|
|
|
|
//
|
|
// These methods impliment simple defaults, so a subclass needs
|
|
// only impliment doCommand.
|
|
//
|
|
XFE_Command::XFE_Command(CommandType id)
|
|
{
|
|
m_id = id;
|
|
}
|
|
|
|
#if 0
|
|
// inlined.
|
|
CommandType
|
|
XFE_Command::getId()
|
|
{
|
|
return m_id;
|
|
}
|
|
#endif
|
|
|
|
char*
|
|
XFE_Command::getName()
|
|
{
|
|
return Command::getString(m_id);
|
|
}
|
|
|
|
XP_Bool
|
|
XFE_Command::isDynamic()
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
XP_Bool
|
|
XFE_Command::isSlow()
|
|
{
|
|
return TRUE; // of course
|
|
}
|
|
|
|
XP_Bool
|
|
XFE_Command::isEnabled(XFE_View*, XFE_CommandInfo*)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
XP_Bool
|
|
XFE_Command::isSelected(XFE_View*, XFE_CommandInfo*)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
XP_Bool
|
|
XFE_Command::isDeterminate(XFE_View*, XFE_CommandInfo*)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
XFE_CommandParameters*
|
|
XFE_Command::getParameters(XFE_View*)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
int
|
|
XFE_Command::getParameterIndex(XFE_View*)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
XFE_Command::setParameterIndex(XFE_View*, unsigned)
|
|
{
|
|
}
|
|
|
|
char*
|
|
XFE_Command::getLabel(XFE_View*, XFE_CommandInfo*)
|
|
{
|
|
return NULL; // we could probably impliment this.
|
|
}
|
|
|
|
char*
|
|
XFE_Command::getTipString(XFE_View*, XFE_CommandInfo*)
|
|
{
|
|
return NULL; // we could probably impliment this.
|
|
}
|
|
|
|
char*
|
|
XFE_Command::getDocString(XFE_View*, XFE_CommandInfo*)
|
|
{
|
|
return NULL; // we could probably impliment this.
|
|
}
|
|
|
|
XP_Bool
|
|
XFE_Command::isEnabled(XFE_Frame*, XFE_CommandInfo*)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
XP_Bool
|
|
XFE_Command::isSelected(XFE_Frame*, XFE_CommandInfo*)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
XP_Bool
|
|
XFE_Command::isDeterminate(XFE_Frame*, XFE_CommandInfo*)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
XFE_CommandParameters*
|
|
XFE_Command::getParameters(XFE_Frame*)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
int
|
|
XFE_Command::getParameterIndex(XFE_Frame*)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
XFE_Command::setParameterIndex(XFE_Frame*, unsigned)
|
|
{
|
|
}
|
|
|
|
char*
|
|
XFE_Command::getLabel(XFE_Frame*, XFE_CommandInfo*)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
char*
|
|
XFE_Command::getTipString(XFE_Frame*, XFE_CommandInfo*)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
char*
|
|
XFE_Command::getDocString(XFE_Frame*, XFE_CommandInfo*)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
CommandDoSyntaxErrorAlert(MWContext* context,
|
|
XFE_Command* command,
|
|
XFE_CommandInfo* info)
|
|
{
|
|
char buf[1024];
|
|
char buf2[1024];
|
|
|
|
XP_STRCPY(buf, command->getName());
|
|
XP_STRCAT(buf, "(");
|
|
if (info != NULL) {
|
|
for (unsigned n = 0; n < *info->nparams; n++) {
|
|
if (n != 0)
|
|
XP_STRCAT(buf, ",");
|
|
XP_STRCAT(buf, info->params[n]);
|
|
}
|
|
}
|
|
XP_STRCAT(buf, ")");
|
|
|
|
sprintf(buf2, XP_GetString(XFE_ACTION_SYNTAX_ERROR), buf);
|
|
|
|
FE_Alert(context, buf2);
|
|
}
|
|
|
|
static XFE_View*
|
|
frame_to_view(XFE_Command* command, XFE_Frame* frame, XFE_CommandInfo*)
|
|
{
|
|
XFE_View* view = frame->getView();
|
|
XFE_View* sub_view = view->getCommandView(command);
|
|
|
|
if (sub_view)
|
|
return sub_view;
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
XP_Bool
|
|
XFE_ViewCommand::isEnabled(XFE_Frame* frame, XFE_CommandInfo* info)
|
|
{
|
|
XFE_View* view = frame_to_view(this, frame, info);
|
|
|
|
return ((XFE_AbstractCommand*)this)->isEnabled(view, info);
|
|
}
|
|
|
|
XP_Bool
|
|
XFE_ViewCommand::isSelected(XFE_Frame* frame, XFE_CommandInfo* info)
|
|
{
|
|
XFE_View* view = frame_to_view(this, frame, info);
|
|
|
|
return ((XFE_AbstractCommand*)this)->isSelected(view, info);
|
|
}
|
|
|
|
XP_Bool
|
|
XFE_ViewCommand::isDeterminate(XFE_Frame* frame, XFE_CommandInfo* info)
|
|
{
|
|
XFE_View* view = frame_to_view(this, frame, info);
|
|
|
|
return ((XFE_AbstractCommand*)this)->isDeterminate(view, info);
|
|
}
|
|
|
|
XFE_CommandParameters*
|
|
XFE_ViewCommand::getParameters(XFE_Frame* frame)
|
|
{
|
|
XFE_View* view = frame_to_view(this, frame, NULL);
|
|
|
|
return ((XFE_AbstractCommand*)this)->getParameters(view);
|
|
}
|
|
|
|
void
|
|
XFE_ViewCommand::setParameterIndex(XFE_Frame* frame, unsigned index)
|
|
{
|
|
XFE_View* view = frame_to_view(this, frame, NULL);
|
|
|
|
((XFE_AbstractCommand*)this)->setParameterIndex(view, index);
|
|
}
|
|
|
|
int
|
|
XFE_ViewCommand::getParameterIndex(XFE_Frame* frame)
|
|
{
|
|
XFE_View* view = frame_to_view(this, frame, NULL);
|
|
|
|
return ((XFE_AbstractCommand*)this)->getParameterIndex(view);
|
|
}
|
|
|
|
char*
|
|
XFE_ViewCommand::getLabel(XFE_Frame* frame, XFE_CommandInfo* info)
|
|
{
|
|
XFE_View* view = frame_to_view(this, frame, info);
|
|
|
|
return ((XFE_AbstractCommand*)this)->getLabel(view, info);
|
|
}
|
|
|
|
char*
|
|
XFE_ViewCommand::getTipString(XFE_Frame* frame, XFE_CommandInfo* info)
|
|
{
|
|
XFE_View* view = frame_to_view(this, frame, info);
|
|
|
|
return ((XFE_AbstractCommand*)this)->getTipString(view, info);
|
|
}
|
|
|
|
char*
|
|
XFE_ViewCommand::getDocString(XFE_Frame* frame, XFE_CommandInfo* info)
|
|
{
|
|
XFE_View* view = frame_to_view(this, frame, info);
|
|
|
|
return ((XFE_AbstractCommand*)this)->getDocString(view, info);
|
|
}
|
|
|
|
void
|
|
XFE_ViewCommand::doCommand(XFE_Frame* frame, XFE_CommandInfo* info)
|
|
{
|
|
XFE_View* view = frame_to_view(this, frame, info);
|
|
|
|
((XFE_AbstractCommand*)this)->doCommand(view, info);
|
|
}
|
|
|
|
void
|
|
XFE_ViewCommand::doSyntaxErrorAlert(XFE_View* view, XFE_CommandInfo* info)
|
|
{
|
|
CommandDoSyntaxErrorAlert(view->getContext(), this, info);
|
|
}
|
|
|
|
XFE_Frame*
|
|
XFE_FrameCommand::getFrame(XFE_View* view)
|
|
{
|
|
return ViewGlue_getFrame(view->getContext());
|
|
}
|
|
|
|
XP_Bool
|
|
XFE_FrameCommand::isEnabled(XFE_View* view, XFE_CommandInfo* info)
|
|
{
|
|
return ((XFE_AbstractCommand*)this)->isEnabled(getFrame(view), info);
|
|
}
|
|
|
|
XP_Bool
|
|
XFE_FrameCommand::isSelected(XFE_View* view, XFE_CommandInfo* info)
|
|
{
|
|
return ((XFE_AbstractCommand*)this)->isSelected(getFrame(view), info);
|
|
}
|
|
|
|
XP_Bool
|
|
XFE_FrameCommand::isDeterminate(XFE_View* view, XFE_CommandInfo* info)
|
|
{
|
|
return ((XFE_AbstractCommand*)this)->isDeterminate(getFrame(view), info);
|
|
}
|
|
|
|
XFE_CommandParameters*
|
|
XFE_FrameCommand::getParameters(XFE_View* view)
|
|
{
|
|
return ((XFE_AbstractCommand*)this)->getParameters(getFrame(view));
|
|
}
|
|
|
|
int
|
|
XFE_FrameCommand::getParameterIndex(XFE_View* view)
|
|
{
|
|
return ((XFE_AbstractCommand*)this)->getParameterIndex(getFrame(view));
|
|
}
|
|
|
|
void
|
|
XFE_FrameCommand::setParameterIndex(XFE_View* view, unsigned index)
|
|
{
|
|
XFE_Frame* frame = getFrame(view);
|
|
((XFE_AbstractCommand*)this)->setParameterIndex(frame, index);
|
|
}
|
|
|
|
char*
|
|
XFE_FrameCommand::getLabel(XFE_View* view, XFE_CommandInfo* info)
|
|
{
|
|
return ((XFE_AbstractCommand*)this)->getLabel(getFrame(view), info);
|
|
}
|
|
|
|
char*
|
|
XFE_FrameCommand::getTipString(XFE_View* view, XFE_CommandInfo* info)
|
|
{
|
|
return ((XFE_AbstractCommand*)this)->getTipString(getFrame(view), info);
|
|
}
|
|
|
|
char*
|
|
XFE_FrameCommand::getDocString(XFE_View* view, XFE_CommandInfo* info)
|
|
{
|
|
return ((XFE_AbstractCommand*)this)->getDocString(getFrame(view), info);
|
|
}
|
|
|
|
void
|
|
XFE_FrameCommand::doCommand(XFE_View* view, XFE_CommandInfo* info)
|
|
{
|
|
((XFE_AbstractCommand*)this)->doCommand(getFrame(view), info);
|
|
}
|
|
|
|
void
|
|
XFE_FrameCommand::doSyntaxErrorAlert(XFE_Frame* frame, XFE_CommandInfo* info)
|
|
{
|
|
CommandDoSyntaxErrorAlert(frame->getContext(), this, info);
|
|
}
|
|
|
|
XFE_CommandList::XFE_CommandList(XFE_CommandList* list, XFE_Command* command)
|
|
{
|
|
m_next = list;
|
|
m_command = command;
|
|
}
|
|
|
|
XFE_CommandList*
|
|
registerCommand(XFE_CommandList*& list, XFE_Command* command)
|
|
{
|
|
return list = new XFE_CommandList(list, command);
|
|
}
|
|
|
|
XFE_Command*
|
|
findCommand(XFE_CommandList* list, CommandType id)
|
|
{
|
|
while (list != NULL) {
|
|
if (list->m_command != NULL && list->m_command->getId() == id) {
|
|
return list->m_command;
|
|
}
|
|
list = list->m_next;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
XFE_ObjectIsCommand::XFE_ObjectIsCommand() : XFE_ViewCommand(xfeCmdObjectIs)
|
|
{
|
|
};
|
|
|
|
void
|
|
XFE_ObjectIsCommand::doCommand(XFE_View* view, XFE_CommandInfo* info)
|
|
{
|
|
if (info == NULL)
|
|
return;
|
|
|
|
char* c_type = getObjectType(view);
|
|
char* s_type;
|
|
unsigned depth;
|
|
String* av = info->params;
|
|
Cardinal* ac = info->nparams;
|
|
unsigned n;
|
|
unsigned m;
|
|
|
|
for (n = 0; n + 1 < *ac; n++) {
|
|
|
|
s_type = av[n++];
|
|
|
|
if (XP_STRCMP(av[n], "{") == 0) {
|
|
n++;
|
|
} else {
|
|
// syntax error.
|
|
return;
|
|
}
|
|
|
|
for (depth = 1, m = n; av[m] != NULL && m < *ac; m++) {
|
|
if (XP_STRCMP(av[m], "{") == 0)
|
|
depth++;
|
|
else if (XP_STRCMP(av[m], "}") == 0)
|
|
depth--;
|
|
|
|
if (depth == 0)
|
|
break;
|
|
}
|
|
|
|
if (XP_STRCASECMP(c_type, s_type) == 0 && m > n && av[m] != NULL) {
|
|
XtCallActionProc(info->widget, "xfeDoCommand", info->event,
|
|
&av[n], m - n);
|
|
break; // done
|
|
}
|
|
|
|
n = m;
|
|
}
|
|
};
|
|
|
|
int
|
|
XFE_commandMatchParameters(XFE_CommandParameters* params, char* name)
|
|
{
|
|
int index;
|
|
|
|
if (params != NULL) {
|
|
for (index = 0; params[index].name != NULL; index++) {
|
|
if (XP_STRCMP(name, params[index].name) == 0)
|
|
return index;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
struct CommandList_t
|
|
{
|
|
char* name;
|
|
CommandList_t* next;
|
|
};
|
|
|
|
static CommandList_t* intern_list;
|
|
|
|
char *
|
|
Command::intern(char *foo)
|
|
{
|
|
int middle, first, last;
|
|
|
|
if (foo == NULL) return NULL;
|
|
|
|
/* do a binary search through the _XfeCommandIndices table, and return
|
|
the correct string */
|
|
|
|
first = 0;
|
|
last = _XfeNumCommands - 1;
|
|
|
|
while (first <= last)
|
|
{
|
|
int compare;
|
|
char *command;
|
|
|
|
middle = (first + last) / 2;
|
|
|
|
command = &_XfeCommands[_XfeCommandIndices[middle]];
|
|
|
|
compare = strcmp(foo, command);
|
|
|
|
if (compare == 0)
|
|
{
|
|
return command;
|
|
}
|
|
else if (compare < 0)
|
|
{
|
|
last = middle - 1;
|
|
}
|
|
else
|
|
{
|
|
first = middle + 1;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Didn't find it in static list, look in dynamic list
|
|
//
|
|
CommandList_t* bar;
|
|
for (bar = intern_list; bar != NULL; bar = bar->next) {
|
|
if (strcmp(foo, bar->name) == 0)
|
|
return bar->name;
|
|
}
|
|
|
|
// Didn't match, add a new dude..
|
|
bar = new CommandList_t;
|
|
bar->name = XP_STRDUP(foo);
|
|
bar->next = intern_list;
|
|
intern_list = bar;
|
|
|
|
return bar->name;
|
|
}
|
|
|
|
struct cmd_mapping {
|
|
char *old_remote_cmd;
|
|
char *xfe_do_cmd;
|
|
};
|
|
|
|
static struct cmd_mapping mapping[] = {
|
|
/* bringing up new pages. */
|
|
{ "new", xfeCmdOpenBrowser },
|
|
{ "openFile", xfeCmdOpenPageChooseFile },
|
|
{ "saveAs", xfeCmdSaveAs },
|
|
#ifdef MOZ_MAIL_NEW
|
|
{ "mailNew", xfeCmdNewMessage },
|
|
#endif
|
|
{ "docInfo", xfeCmdViewPageInfo },
|
|
{ "print", xfeCmdPrint },
|
|
{ "delete", xfeCmdClose },
|
|
{ "quit", xfeCmdExit },
|
|
|
|
/* edit menu functions. */
|
|
{ "find", xfeCmdFindInObject },
|
|
{ "findAgain", xfeCmdFindAgain },
|
|
|
|
/* view menu functions. */
|
|
{ "reload", xfeCmdReload },
|
|
{ "loadImages", xfeCmdShowImage },
|
|
{ "source", xfeCmdViewPageSource },
|
|
|
|
/* go menu functions. */
|
|
{ "back", xfeCmdBack },
|
|
{ "forward", xfeCmdForward },
|
|
{ "home", xfeCmdHome },
|
|
{ "abort", xfeCmdStopLoading },
|
|
{ "viewHistory", xfeCmdOpenHistory },
|
|
|
|
{ "viewBookmark", xfeCmdOpenBookmarks },
|
|
{ "preferences", xfeCmdEditPreferences },
|
|
|
|
#ifdef MOZ_MAIL_NEWS
|
|
{ "openInbox", xfeCmdOpenInbox },
|
|
{ "inbox", xfeCmdOpenInbox },
|
|
{ "openAddrBook", xfeCmdOpenAddressBook },
|
|
{ "addrbk", xfeCmdOpenAddressBook },
|
|
{ "openNews", xfeCmdOpenNewsgroups },
|
|
{ "news", xfeCmdOpenNewsgroups },
|
|
#endif
|
|
#ifdef EDITOR
|
|
{ "editor", xfeCmdOpenEditor },
|
|
{ "openEditor", xfeCmdOpenEditor },
|
|
{ "edit", xfeCmdNewBlank },
|
|
{ "editURL", xfeCmdNewBlank },
|
|
#endif
|
|
#ifdef MOZ_MAIL_NEWS
|
|
{ "openConference", xfeCmdOpenConference }
|
|
#endif
|
|
|
|
};
|
|
static int num_old_cmds = sizeof(mapping) / sizeof(mapping[0]);
|
|
|
|
char *
|
|
Command::convertOldRemote(char *foo)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < num_old_cmds; i ++)
|
|
{
|
|
if (!XP_STRCASECMP(foo, mapping[i].old_remote_cmd))
|
|
return mapping[i].xfe_do_cmd;
|
|
}
|
|
|
|
return Command::intern(foo);
|
|
}
|