850 lines
17 KiB
C
850 lines
17 KiB
C
/*
|
|
* head.c
|
|
*
|
|
* Copyright (C) 1993-1997, John D. Kilburg <john@cs.unlv.edu>
|
|
*
|
|
* The button table code written by Jim.Rees@umich.edu.
|
|
* The messed up parts were written by john.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
#include "port_before.h"
|
|
|
|
#include <stdio.h>
|
|
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#ifdef HAVE_STDLIB_H
|
|
#include <stdlib.h>
|
|
#endif
|
|
|
|
#include <X11/Intrinsic.h>
|
|
#include <X11/StringDefs.h>
|
|
#include <X11/Shell.h>
|
|
|
|
#include <X11/Xaw/Form.h>
|
|
#include <X11/Xaw/Paned.h>
|
|
#include <X11/Xaw/Box.h>
|
|
#include <X11/Xaw/Command.h>
|
|
#include <X11/Xaw/Toggle.h>
|
|
#include <X11/Xaw/Label.h>
|
|
|
|
#include "port_after.h"
|
|
|
|
#include "TextField.h"
|
|
|
|
#include "common.h"
|
|
|
|
#include "MyDialog.h"
|
|
|
|
#include "ChimeraP.h"
|
|
|
|
static void Quit _ArgProto((Widget, XtPointer, XtPointer));
|
|
static void Back _ArgProto((Widget, XtPointer, XtPointer));
|
|
static void Reload _ArgProto((Widget, XtPointer, XtPointer));
|
|
static void Cancel _ArgProto((Widget, XtPointer, XtPointer));
|
|
static void Home _ArgProto((Widget, XtPointer, XtPointer));
|
|
static void Dup _ArgProto((Widget, XtPointer, XtPointer));
|
|
static void Help _ArgProto((Widget, XtPointer, XtPointer));
|
|
static void AddMark _ArgProto((Widget, XtPointer, XtPointer));
|
|
static void ViewMark _ArgProto((Widget, XtPointer, XtPointer));
|
|
static void Bookmark _ArgProto((Widget, XtPointer, XtPointer));
|
|
static void Source _ArgProto((Widget, XtPointer, XtPointer));
|
|
static void Save _ArgProto((Widget, XtPointer, XtPointer));
|
|
|
|
static void OOpen _ArgProto((Widget, XtPointer, XtPointer));
|
|
static void DOpen _ArgProto((Widget, XtPointer, XtPointer));
|
|
static void Open _ArgProto((Widget, XtPointer, XtPointer));
|
|
|
|
static void OFind _ArgProto((Widget, XtPointer, XtPointer));
|
|
static void DFind _ArgProto((Widget, XtPointer, XtPointer));
|
|
static void Find _ArgProto((Widget, XtPointer, XtPointer));
|
|
|
|
static void CreateWidgets _ArgProto((ChimeraContext, char *));
|
|
|
|
static void AddButtons _ArgProto((ChimeraContext, Widget, char *));
|
|
|
|
static void InstallAccelerators _ArgProto((Widget));
|
|
|
|
static struct ButtonTable
|
|
{
|
|
char *name;
|
|
Boolean toggle;
|
|
Widget w;
|
|
void (*cb)();
|
|
char *accel;
|
|
} ButtonTable[] =
|
|
{
|
|
{ "quit", False, NULL, Quit, ":Meta<KeyUp>q"},
|
|
{ "open", False, NULL, Open, ":Meta<KeyUp>o" },
|
|
{ "home", False, NULL, Home, ":Meta<KeyUp>h" },
|
|
{ "back", False, NULL, Back, ":Meta<KeyUp>b" },
|
|
{ "reload", False, NULL, Reload, ":Meta<KeyUp>r" },
|
|
{ "cancel", False, NULL, Cancel, ":Meta<KeyUp>c"},
|
|
{ "dup", False, NULL, Dup, ":Meta<KeyUp>c" },
|
|
{ "help", False, NULL, Help, ":Meta<KeyUp>H" },
|
|
{ "addmark", False, NULL, AddMark, ":Meta<KeyUp>a" },
|
|
{ "viewmark", False, NULL, ViewMark, ":Meta<KeyUp>v" },
|
|
{ "bookmark", False, NULL, Bookmark, ":Meta<KeyUp>m" },
|
|
{ "find", False, NULL, Find, ":Meta<KeyUp>f" },
|
|
{ "source", True, NULL, Source, ":Meta<KeyUp>s" },
|
|
{ "save", False, NULL, Save, ":Meta<KeyUp>S" },
|
|
{ NULL, False, NULL, NULL, NULL},
|
|
};
|
|
|
|
static void
|
|
AddButtons(wc, box, list)
|
|
ChimeraContext wc;
|
|
Widget box;
|
|
char *list;
|
|
{
|
|
char name[256];
|
|
struct ButtonTable *btp;
|
|
char accel[256];
|
|
|
|
while (sscanf(list, " %[^,]", name) == 1)
|
|
{
|
|
/*
|
|
* Find the listed button and create its widget
|
|
*/
|
|
for (btp = &ButtonTable[0]; btp->name != NULL; btp++)
|
|
{
|
|
if (!strcasecmp(btp->name, name))
|
|
{
|
|
if (btp->toggle)
|
|
{
|
|
snprintf(accel, sizeof(accel) - 1,
|
|
"%s: toggle() notify()", btp->accel);
|
|
btp->w = XtVaCreateManagedWidget(btp->name,
|
|
toggleWidgetClass, box,
|
|
XtNaccelerators,
|
|
XtParseAcceleratorTable(accel),
|
|
NULL);
|
|
}
|
|
else
|
|
{
|
|
snprintf(accel, sizeof(accel) - 1,
|
|
"%s: set() notify() unset()", btp->accel);
|
|
btp->w = XtVaCreateManagedWidget(btp->name,
|
|
commandWidgetClass, box,
|
|
XtNaccelerators,
|
|
XtParseAcceleratorTable(accel),
|
|
NULL);
|
|
}
|
|
XtAddCallback(btp->w, XtNcallback, btp->cb, (XtPointer)wc);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!strcasecmp(name, "open")) wc->open = btp->w;
|
|
else if (!strcasecmp(name, "back")) wc->back = btp->w;
|
|
else if (!strcasecmp(name, "reload")) wc->reload = btp->w;
|
|
else if (!strcasecmp(name, "cancel")) wc->cancel = btp->w;
|
|
else if (!strcasecmp(name, "quit")) wc->quit = btp->w;
|
|
else if (!strcasecmp(name, "home")) wc->home = btp->w;
|
|
else if (!strcasecmp(name, "help")) wc->help = btp->w;
|
|
else if (!strcasecmp(name, "dup")) wc->dup = btp->w;
|
|
else if (!strcasecmp(name, "addmark")) wc->addmark = btp->w;
|
|
else if (!strcasecmp(name, "viewmark")) wc->viewmark = btp->w;
|
|
else if (!strcasecmp(name, "source")) wc->source = btp->w;
|
|
else if (!strcasecmp(name, "save")) wc->save = btp->w;
|
|
else if (!strcasecmp(name, "find")) wc->find = btp->w;
|
|
else if (!strcasecmp(name, "bookmark")) wc->bookmark = btp->w;
|
|
|
|
/*
|
|
* Skip to the next comma-delimited item in the list
|
|
*/
|
|
while (*list && *list != ',')
|
|
list++;
|
|
if (*list == ',')
|
|
list++;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* InstallAccelerators
|
|
*/
|
|
static void
|
|
InstallAccelerators(w)
|
|
Widget w;
|
|
{
|
|
struct ButtonTable *btp;
|
|
|
|
for (btp = &ButtonTable[0]; btp->name != NULL; btp++)
|
|
if(btp->w)
|
|
XtInstallAllAccelerators(w,btp->w);
|
|
}
|
|
|
|
#define BUTTON_LIST "quit, open, home, back, reload, source, save, bookmark, dup, find, cancel"
|
|
|
|
/*
|
|
* These are initialized in fallback.c
|
|
*/
|
|
#define offset(field) XtOffset(ChimeraContext, field)
|
|
static XtResource resource_list[] =
|
|
{
|
|
{ "button1Box", "BoxList", XtRString, sizeof(char *),
|
|
offset(button1Box), XtRString, BUTTON_LIST },
|
|
{ "button2Box", "BoxList", XtRString, sizeof(char *),
|
|
offset(button2Box), XtRString, NULL },
|
|
};
|
|
|
|
/*
|
|
* HeadCreate
|
|
*
|
|
* Setup chimera in a widget.
|
|
*/
|
|
static void
|
|
CreateWidgets(wc, name)
|
|
ChimeraContext wc;
|
|
char *name;
|
|
{
|
|
Widget paned, box, form;
|
|
Atom delete;
|
|
|
|
wc->toplevel = XtVaAppCreateShell(name, "Chimera2",
|
|
topLevelShellWidgetClass,
|
|
wc->cres->dpy,
|
|
NULL);
|
|
|
|
XtGetApplicationResources(wc->toplevel, wc,
|
|
resource_list, XtNumber(resource_list),
|
|
NULL, 0);
|
|
|
|
/*
|
|
* Main window pane
|
|
*/
|
|
paned = XtCreateManagedWidget("paned",
|
|
panedWidgetClass, wc->toplevel,
|
|
NULL, 0);
|
|
|
|
/*
|
|
* Button pane(s)
|
|
*/
|
|
if (wc->button1Box && *wc->button1Box)
|
|
{
|
|
box = XtCreateManagedWidget("box1", boxWidgetClass, paned, NULL, 0);
|
|
AddButtons(wc, box, wc->button1Box);
|
|
}
|
|
|
|
if (wc->button2Box && *wc->button2Box)
|
|
{
|
|
box = XtCreateManagedWidget("box2", boxWidgetClass, paned, NULL, 0);
|
|
AddButtons(wc, box, wc->button2Box);
|
|
}
|
|
|
|
/*
|
|
* URL pane
|
|
*/
|
|
form = XtVaCreateManagedWidget("urlform", formWidgetClass, paned, NULL);
|
|
XtVaCreateManagedWidget("urllabel", labelWidgetClass, form, NULL);
|
|
wc->url = XtVaCreateManagedWidget("url",
|
|
textfieldWidgetClass, form,
|
|
XtNstring, "",
|
|
NULL);
|
|
|
|
XtOverrideTranslations(wc->url,
|
|
XtParseTranslationTable
|
|
("<Key>Return: ReturnAction()"));
|
|
|
|
/*
|
|
* Message pane.
|
|
*/
|
|
box = XtCreateManagedWidget("box4", boxWidgetClass, paned, NULL, 0);
|
|
wc->message = XtVaCreateManagedWidget("message",
|
|
textfieldWidgetClass, box,
|
|
NULL);
|
|
|
|
/*
|
|
* WWW widget
|
|
*/
|
|
wc->tstack = StackCreateToplevel(wc, paned);
|
|
|
|
XtRealizeWidget(wc->toplevel);
|
|
|
|
delete = XInternAtom(XtDisplay(wc->toplevel), "WM_DELETE_WINDOW", False);
|
|
XSetWMProtocols (wc->cres->dpy, XtWindow(wc->toplevel), &delete, 1);
|
|
XtOverrideTranslations (wc->toplevel,
|
|
XtParseTranslationTable
|
|
("<Message>WM_PROTOCOLS: DeleteAction()"));
|
|
|
|
/*
|
|
* Accelerators
|
|
*/
|
|
InstallAccelerators(paned);
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* HeadDestroy
|
|
*/
|
|
void
|
|
HeadDestroy(wc)
|
|
ChimeraContext wc;
|
|
{
|
|
StackDestroy(wc->tstack);
|
|
GListRemoveItem(wc->cres->heads, wc);
|
|
XtDestroyWidget(wc->toplevel);
|
|
MPDestroy(wc->mp);
|
|
|
|
ChimeraRemoveReference(wc->cres);
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* ClearDialogValue
|
|
*/
|
|
static void
|
|
ClearDialogValue(w, cldata, cbdata)
|
|
Widget w;
|
|
XtPointer cldata, cbdata;
|
|
{
|
|
if ((w = XtParent(w)) != NULL) MyDialogSetValue(w, "");
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* CreateDialog
|
|
*/
|
|
Widget
|
|
CreateDialog(p, name, ofunc, dfunc, rfunc, closure)
|
|
Widget p;
|
|
char *name;
|
|
void (*ofunc)();
|
|
void (*dfunc)();
|
|
void (*rfunc)();
|
|
XtPointer closure;
|
|
{
|
|
Widget w, dw;
|
|
Window rw, cw;
|
|
int rx, ry, wx, wy;
|
|
unsigned int mask;
|
|
|
|
XQueryPointer(XtDisplay(p), DefaultRootWindow(XtDisplay(p)),
|
|
&rw, &cw,
|
|
&rx, &ry,
|
|
&wx, &wy,
|
|
&mask);
|
|
w = XtVaCreatePopupShell(name,
|
|
transientShellWidgetClass, p,
|
|
XtNx, rx - 2,
|
|
XtNy, ry - 2,
|
|
NULL);
|
|
dw = XtVaCreateManagedWidget("dialog",
|
|
mydialogWidgetClass, w,
|
|
XtNvalue, "",
|
|
NULL);
|
|
MyDialogAddButton(dw, "ok", ofunc, closure);
|
|
MyDialogAddButton(dw, "clear", ClearDialogValue, closure);
|
|
MyDialogAddButton(dw, "dismiss", dfunc, closure);
|
|
XtAddCallback(dw, XtNcallback, rfunc, closure);
|
|
|
|
XtRealizeWidget(w);
|
|
|
|
return(w);
|
|
}
|
|
|
|
/*
|
|
* GetDialogWidget
|
|
*/
|
|
Widget
|
|
GetDialogWidget(w)
|
|
Widget w;
|
|
{
|
|
return(XtNameToWidget(w, "dialog"));
|
|
}
|
|
|
|
/*
|
|
* OOpen
|
|
*/
|
|
static void
|
|
OOpen(w, cldata, cbdata)
|
|
Widget w;
|
|
XtPointer cldata, cbdata;
|
|
{
|
|
ChimeraContext wc = (ChimeraContext)cldata;
|
|
char *url;
|
|
|
|
if ((url = MyDialogGetValue(GetDialogWidget(wc->openpop))) == NULL) return;
|
|
|
|
StackOpen(wc->tstack, RequestCreate(wc->cres, url, NULL));
|
|
XtPopdown(wc->openpop);
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* DOpen
|
|
*/
|
|
static void
|
|
DOpen(w, cldata, cbdata)
|
|
Widget w;
|
|
XtPointer cldata, cbdata;
|
|
{
|
|
ChimeraContext wc = (ChimeraContext)cldata;
|
|
XtPopdown(wc->openpop);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Open
|
|
*/
|
|
static void
|
|
Open(w, cldata, cbdata)
|
|
Widget w;
|
|
XtPointer cldata, cbdata;
|
|
{
|
|
ChimeraContext wc = (ChimeraContext)cldata;
|
|
|
|
if (wc->openpop == NULL)
|
|
{
|
|
wc->openpop = CreateDialog(wc->toplevel, "openpop",
|
|
OOpen, DOpen, OOpen, (XtPointer)wc);
|
|
}
|
|
XtPopup(wc->openpop, XtGrabNone);
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Back
|
|
*/
|
|
static void
|
|
Back(w, cldata, cbdata)
|
|
Widget w;
|
|
XtPointer cldata, cbdata;
|
|
{
|
|
ChimeraContext wc = (ChimeraContext)cldata;
|
|
StackBack(wc->tstack);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Reload
|
|
*/
|
|
static void
|
|
Reload(w, cldata, cbdata)
|
|
Widget w;
|
|
XtPointer cldata, cbdata;
|
|
{
|
|
ChimeraContext wc = (ChimeraContext)cldata;
|
|
StackReload(wc->tstack);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Cancel
|
|
*/
|
|
static void
|
|
Cancel(w, cldata, cbdata)
|
|
Widget w;
|
|
XtPointer cldata, cbdata;
|
|
{
|
|
ChimeraContext wc = (ChimeraContext)cldata;
|
|
StackCancel(wc->tstack);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Quit
|
|
*/
|
|
static void
|
|
Quit(w, cldata, cbdata)
|
|
Widget w;
|
|
XtPointer cldata, cbdata;
|
|
{
|
|
HeadDestroy((ChimeraContext)cldata);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Source
|
|
*/
|
|
static void
|
|
Source(w, cldata, cbdata)
|
|
Widget w;
|
|
XtPointer cldata, cbdata;
|
|
{
|
|
ChimeraContext wc = (ChimeraContext)cldata;
|
|
|
|
if (wc->cres->plainhooks == NULL) XtVaSetValues(w, XtNstate, False, NULL);
|
|
else
|
|
{
|
|
if (cbdata) StackSetRender(wc->tstack, wc->cres->plainhooks);
|
|
else StackSetRender(wc->tstack, NULL);
|
|
StackRedraw(wc->tstack);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Save
|
|
*/
|
|
static void
|
|
Save(w, cldata, cbdata)
|
|
Widget w;
|
|
XtPointer cldata, cbdata;
|
|
{
|
|
ChimeraContext wc = (ChimeraContext)cldata;
|
|
char *url;
|
|
ChimeraRequest *wr;
|
|
|
|
if ((url = StackGetCurrentURL(wc->tstack)) == NULL) return;
|
|
|
|
if ((wr = RequestCreate(wc->cres, url, NULL)) == NULL)
|
|
{
|
|
TextFieldSetString(wc->message, "Invalid URL.");
|
|
return;
|
|
}
|
|
DownloadOpen(wc->cres, wr);
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Home
|
|
*/
|
|
static void
|
|
Home(w, cldata, cbdata)
|
|
Widget w;
|
|
XtPointer cldata, cbdata;
|
|
{
|
|
ChimeraContext wc = (ChimeraContext)cldata;
|
|
StackHome(wc->tstack);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Help
|
|
*/
|
|
static void
|
|
Help(w, cldata, cbdata)
|
|
Widget w;
|
|
XtPointer cldata, cbdata;
|
|
{
|
|
ChimeraContext wc = (ChimeraContext)cldata;
|
|
char *url;
|
|
|
|
if ((url = ResourceGetString(wc->cres, "chimera.helpURL")) != NULL)
|
|
{
|
|
StackOpen(wc->tstack, RequestCreate(wc->cres, url, NULL));
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Dup
|
|
*/
|
|
static void
|
|
Dup(w, cldata, cbdata)
|
|
Widget w;
|
|
XtPointer cldata, cbdata;
|
|
{
|
|
ChimeraContext wc = (ChimeraContext)cldata;
|
|
char *url;
|
|
ChimeraRequest *wr;
|
|
|
|
/* grab URL from to-be-cloned window */
|
|
if ((url = ResourceGetString(wc->cres, "chimera.cloneHome")) == NULL)
|
|
{
|
|
url = StackGetCurrentURL(wc->tstack);
|
|
}
|
|
|
|
if (url != NULL) wr = RequestCreate(wc->cres, url, NULL);
|
|
else wr = NULL;
|
|
|
|
HeadCreate(wc->cres, NULL, wr);
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* AddMark
|
|
*/
|
|
void
|
|
AddMark(w, cldata, cbdata)
|
|
Widget w;
|
|
XtPointer cldata, cbdata;
|
|
{
|
|
ChimeraContext wc = (ChimeraContext)cldata;
|
|
char *title;
|
|
char *url;
|
|
ChimeraRender wn;
|
|
|
|
if (wc->cres->bc == NULL) return;
|
|
|
|
wn = StackToRender(wc->tstack);
|
|
if ((url = RenderQuery(wn, "url")) == NULL) return;
|
|
if ((title = RenderQuery(wn, "title")) == NULL) title = url;
|
|
|
|
BookmarkAdd(wc->cres->bc, title, url);
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* ViewMark
|
|
*/
|
|
void
|
|
ViewMark(w, cldata, cbdata)
|
|
Widget w;
|
|
XtPointer cldata, cbdata;
|
|
{
|
|
ChimeraContext wc = (ChimeraContext)cldata;
|
|
MemPool mp;
|
|
char *filename;
|
|
char *url;
|
|
const char *fformat = "file:%s";
|
|
|
|
mp = MPCreate();
|
|
|
|
if ((filename = ResourceGetFilename(wc->cres,
|
|
mp, "bookmark.filename")) == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
url = (char *)MPGet(mp, strlen(fformat) + strlen(filename) + 1);
|
|
sprintf (url, fformat, filename);
|
|
StackOpen(wc->tstack, RequestCreate(wc->cres, url, NULL));
|
|
|
|
MPDestroy(mp);
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Bookmark
|
|
*/
|
|
static void
|
|
Bookmark(w, cldata, cbdata)
|
|
Widget w;
|
|
XtPointer cldata, cbdata;
|
|
{
|
|
ChimeraContext wc = (ChimeraContext)cldata;
|
|
|
|
wc->cres->bmcontext = wc;
|
|
if (wc->cres->bc != NULL) BookmarkShow(wc->cres->bc);
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* OFind
|
|
*/
|
|
static void
|
|
OFind(w, cldata, cbdata)
|
|
Widget w;
|
|
XtPointer cldata, cbdata;
|
|
{
|
|
ChimeraContext wc = (ChimeraContext)cldata;
|
|
char *str;
|
|
|
|
if ((str = MyDialogGetValue(GetDialogWidget(wc->findpop))) == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
RenderSearch(StackToRender(wc->tstack), str, 0);
|
|
|
|
XtPopdown(wc->findpop);
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* DFind
|
|
*/
|
|
static void
|
|
DFind(w, cldata, cbdata)
|
|
Widget w;
|
|
XtPointer cldata, cbdata;
|
|
{
|
|
ChimeraContext wc = (ChimeraContext)cldata;
|
|
XtPopdown(wc->findpop);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Find
|
|
*/
|
|
static void
|
|
Find(w, cldata, cbdata)
|
|
Widget w;
|
|
XtPointer cldata, cbdata;
|
|
{
|
|
ChimeraContext wc = (ChimeraContext)cldata;
|
|
|
|
if (wc->findpop == NULL)
|
|
{
|
|
wc->findpop = CreateDialog(wc->toplevel, "findpop",
|
|
OFind, DFind, OFind, (XtPointer)wc);
|
|
}
|
|
XtPopup(wc->findpop, XtGrabNone);
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* HeadCreate
|
|
*
|
|
* Frontend that sorts out which URL to use for a new head and then
|
|
* creates a new head.
|
|
*/
|
|
void
|
|
HeadCreate(cres, first, lastresort)
|
|
ChimeraResources cres;
|
|
ChimeraRequest *first;
|
|
ChimeraRequest *lastresort;
|
|
{
|
|
ChimeraContext wc;
|
|
char *buffer;
|
|
char *url;
|
|
int count;
|
|
MemPool mp;
|
|
ChimeraRequest *wr = NULL;
|
|
char base_url[255];
|
|
|
|
/*
|
|
* Default base URL; this allows filenames to be used on the
|
|
* command line
|
|
*/
|
|
strcpy( base_url, "file:" ) ;
|
|
getcwd( base_url + 5, sizeof(base_url) - 5 ) ;
|
|
strcat( base_url, "/" ) ;
|
|
|
|
ChimeraAddReference(cres);
|
|
|
|
mp = MPCreate();
|
|
wc = (ChimeraContext)MPCGet(mp, sizeof(struct ChimeraContextP));
|
|
wc->mp = mp;
|
|
wc->cres = cres;
|
|
|
|
GListAddHead(cres->heads, wc);
|
|
|
|
CreateWidgets(wc, "chimera");
|
|
|
|
/*
|
|
* If an override URL is supplied then try to use that.
|
|
*/
|
|
if (first != NULL) wr = first;
|
|
|
|
/*
|
|
* Look inside the cutbuffer for a valid URL.
|
|
*/
|
|
if (wr == NULL)
|
|
{
|
|
buffer = XFetchBytes(cres->dpy, &count);
|
|
if (count > 0)
|
|
{
|
|
mp = MPCreate();
|
|
url = (char *)MPCGet(mp, count + 1);
|
|
memcpy(url, buffer, count);
|
|
url[count] = '\0';
|
|
|
|
XFree(buffer);
|
|
|
|
if ((wr = RequestCreate(wc->cres, url, base_url)) != NULL)
|
|
{
|
|
XStoreBytes(cres->dpy, "", 0);
|
|
}
|
|
|
|
MPDestroy(mp);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Look for the caller-supplied last resort.
|
|
*/
|
|
if (wr == NULL && lastresort != NULL) wr = lastresort;
|
|
|
|
/*
|
|
* Check the standard environment variable.
|
|
*/
|
|
if (wr == NULL)
|
|
{
|
|
if ((url = getenv("WWW_HOME")) != NULL)
|
|
{
|
|
if ((wr = RequestCreate(wc->cres, url, base_url)) == NULL)
|
|
{
|
|
fprintf (stderr, "WWW_HOME (%s) is invalid.\n", url);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Check the chimera resource variable.
|
|
*/
|
|
if (wr == NULL)
|
|
{
|
|
if ((url = ResourceGetString(wc->cres, "chimera.homeURL")) != NULL)
|
|
{
|
|
if ((wr = RequestCreate(wc->cres, url, base_url)) == NULL)
|
|
{
|
|
fprintf (stderr, "chimera.homeURL (%s) is invalid.\n", url);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This better work...
|
|
*/
|
|
if (wr == NULL)
|
|
{
|
|
wr = RequestCreate(wc->cres, "file:/", NULL);
|
|
}
|
|
|
|
myassert(wr != NULL, "ERROR: No valud URLs found for new head.\n");
|
|
|
|
StackOpen(wc->tstack, wr);
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* HeadPrintMessage
|
|
*/
|
|
void
|
|
HeadPrintMessage(wc, message)
|
|
ChimeraContext wc;
|
|
char *message;
|
|
{
|
|
if (message == NULL) message = "";
|
|
TextFieldSetString(wc->message, message);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* HeadPrintURL
|
|
*/
|
|
void
|
|
HeadPrintURL(wc, url)
|
|
ChimeraContext wc;
|
|
char *url;
|
|
{
|
|
if (url == NULL) url = "";
|
|
TextFieldSetString(wc->url, url);
|
|
return;
|
|
}
|