void
MakeGlyphDisplayList(FontInfoPtr font, int c)
{
PerCharInfoPtr glyph;
char *bitmapData;
int width, height, spanLength;
int x, y;
if (c < font->min_char || c > font->max_char)
return;
if (font->dlist_base == 0) {
font->dlist_base = glGenLists(font->max_char - font->min_char + 1);
if (font->dlist_base == 0)
XtAppError(app, "could not generate font display lists");
}
glyph = &font->glyph[c - font->min_char];
glNewList(c - font->min_char + font->dlist_base, GL_COMPILE);
bitmapData = glyph->bitmap;
if (bitmapData) {
int oldx = 0, oldy = 0;
glPushMatrix();
glTranslatef(-glyph->xoffset, -glyph->yoffset, 0);
width = glyph->width;
spanLength = (width + 7) / 8;
height = glyph->height;
for (x = 0; x < width; x++) {
for (y = 0; y < height; y++) {
if (bitmapData[y * spanLength + x / 8] & (1 << (x & 7))) {
int y1, count;
/*
* Fonts tend to have good vertical repetion. If we find that
* the vertically adjacent pixels in the glyph bitmap are also enabled,
* we can scale a single cube instead of drawing a cube per pixel.
*/
for (y1 = y + 1, count = 1; y < height; y1++, count++) {
if (!(bitmapData[y1 * spanLength + x / 8] & (1 << (x & 7))))
break;
}
glTranslatef(x - oldx, y - oldy, 0);
oldx = x;
oldy = y;
if (count > 1) {
glPushMatrix();
glScalef(1, count, 1);
glCallList(1);
glPopMatrix();
y += count - 1;
} else {
glCallList(1);
}
}
}
}
glPopMatrix();
}
glTranslatef(glyph->advance, 0, 0);
glEndList();
}
void
SFinitFont()
{
#if ENABLE_NLS
XFontSetExtents *fse = XExtentsOfFontSet(fontSet);
SFcharWidth = fse->max_logical_extent.width;
SFcharAscent = -fse->max_logical_extent.y;
SFcharHeight = fse->max_logical_extent.height;
#else
TextData *data;
data = XtNew(TextData);
XtGetApplicationResources(selFileForm, (XtPointer) data, textResources,
XtNumber(textResources), (Arg *) NULL, ZERO);
SFfont = XLoadQueryFont(SFdisplay, data->fontname);
if (!SFfont) {
SFfont = XLoadQueryFont(SFdisplay, SF_DEFAULT_FONT);
if (!SFfont) {
char sbuf[256];
(void) sprintf(sbuf, "XsraSelFile: can't get font %s",
SF_DEFAULT_FONT);
XtAppError(SFapp, sbuf);
}
}
SFcharWidth = (SFfont->max_bounds.width + SFfont->min_bounds.width) / 2;
SFcharAscent = SFfont->max_bounds.ascent;
SFcharHeight = SFcharAscent + SFfont->max_bounds.descent;
#endif
return;
}
void
SFinitFont()
{
TextData *data;
data = XtNew(TextData);
XtGetApplicationResources(selFileForm, (XtPointer) data, textResources,
XtNumber(textResources), (Arg *) NULL, ZERO);
SFfont = XLoadQueryFont(SFdisplay, data->fontname);
if (!SFfont) {
SFfont = XLoadQueryFont(SFdisplay, SF_DEFAULT_FONT);
if (!SFfont) {
char sbuf[256];
(void) sprintf(sbuf, "XsraSelFile: can't get font %s",
SF_DEFAULT_FONT);
XtAppError(SFapp, sbuf);
}
}
SFcharWidth = (SFfont->max_bounds.width + SFfont->min_bounds.width) / 2;
SFcharAscent = SFfont->max_bounds.ascent;
SFcharHeight = SFcharAscent + SFfont->max_bounds.descent;
return;
}
void
SoXtGLWidgetP::buildContext(void)
{
XVisualInfo * visual;
Display * display = SoXt::getDisplay();
XtVaGetValues(this->glxwidget, SoXtNvisualInfo, &visual, NULL);
int screen = DefaultScreen(display);
SoXtGLWidget * share = (SoXtGLWidget *)
SoAny::si()->getSharedGLContext((void *)display, (void *)screen);
//this->normalcontext =
// glXCreateContext(display, visual,
// share ? PRIVATE(share)->normalcontext : None,
// GL_TRUE);
if (!this->normalcontext) {
SoDebugError::postInfo("SoXtGLWidget::glInit",
"CreateContext() returned NULL");
XtAppError(SoXt::getAppContext(), "no context");
}
else {
SoAny::si()->registerGLContext((void *)PUBLIC(this), (void *)display, (void *)screen);
}
PUBLIC(this)->initGraphic();
}
static void
error(
Widget w,
char * string)
{
char buf[100];
sprintf(buf, "SoXtGLArea: %s\n", string);
XtAppError(XtWidgetToApplicationContext(w), buf);
} // error()
static void SFprepareToReturn (void) {
SFstatus = SEL_FILE_NULL;
XtRemoveGrab (selFile);
XtUnmapWidget (selFile);
XtRemoveTimeOut (SFdirModTimerId);
if (SFchdir (SFstartDir)) {
XtAppError (SFapp, "XsraSelFile: can't return to current directory");
}
}
static void error(Widget w,char* string) {
char buf[100];
#ifdef __GLX_MOTIF
sprintf(buf,"GLwMDrawingArea: %s\n",string);
#else
sprintf(buf,"GLwDrawingArea: %s\n",string);
#endif
XtAppError(XtWidgetToApplicationContext(w),buf);
}
GLuint
GetGlyphDisplayList(FontInfoPtr font, int c)
{
PerCharInfoPtr glyph;
if (c < font->min_char || c > font->max_char)
return 0;
if (font->dlist_base == 0)
XtAppError(app, "font not display listed");
return c - font->min_char + font->dlist_base;
}
static void Change_Font(Widget w, int n, char *s)
{
CtrlWidget cw = (CtrlWidget)w;
CtrlPart *c = & cw->ctrl;
Display *dpy = XtDisplay(w);
clabel_t *cl = c->clabel+n;
XftFont *font;
TF();
TRACE(2,"%s",s);
if( IsEmpty(s) ) s="Sans-12";
font = XftFontOpenName(dpy, DefaultScreen(dpy), s );
if(!font )
XtAppError(XtWidgetToApplicationContext(w), "CtrlWidget: unknown font" );
else {
if( cl->font ) XftFontClose( dpy, cl->font);
cl->font = font;
}
}
static void
CreateGC (Widget w)
{
ScrollbarWidget sbw = (ScrollbarWidget) w;
XGCValues gcValues;
XtGCMask mask;
unsigned int depth = 1;
if (sbw->scrollbar.thumb == XtUnspecifiedPixmap) {
sbw->scrollbar.thumb = XmuCreateStippledPixmap (XtScreen(w),
(Pixel) 1, (Pixel) 0, depth);
} else if (sbw->scrollbar.thumb != None) {
Window root;
int x, y;
unsigned int width, height, bw;
if (XGetGeometry (XtDisplay(w), sbw->scrollbar.thumb, &root, &x, &y,
&width, &height, &bw, &depth) == 0) {
XtAppError (XtWidgetToApplicationContext (w),
"Scrollbar Widget: Could not get geometry of thumb pixmap.");
}
}
gcValues.foreground = sbw->scrollbar.foreground;
gcValues.background = sbw->core.background_pixel;
mask = GCForeground | GCBackground;
if (sbw->scrollbar.thumb != None) {
if (depth == 1) {
gcValues.fill_style = FillOpaqueStippled;
gcValues.stipple = sbw->scrollbar.thumb;
mask |= GCFillStyle | GCStipple;
}
else {
gcValues.fill_style = FillTiled;
gcValues.tile = sbw->scrollbar.thumb;
mask |= GCFillStyle | GCTile;
}
}
/* the creation should be non-caching, because */
/* we now set and clear clip masks on the gc returned */
sbw->scrollbar.gc = XtGetGC (w, mask, &gcValues);
}
int
XsraSelFile (
Widget toplevel, char *prompt, char *ok, char *cancel, char *failed,
char *init_path, char *mode,
int (*show_entry) (char *, char **, struct stat *),
char *name_return, int name_size
) {
static int firstTime = 1;
Cardinal i;
Arg arglist[20];
XEvent event;
if (!prompt) {
prompt = "Pathname:";
}
if (!ok) {
ok = "OK";
}
if (!cancel) {
cancel = "Cancel";
}
if (firstTime) {
firstTime = 0;
SFdisplay = XtDisplay (toplevel);
SFcreateWidgets (toplevel, prompt, ok, cancel);
} else {
i = 0;
XtSetArg (arglist[i], XtNlabel, prompt); i++;
XtSetValues (selFilePrompt, arglist, i);
i = 0;
XtSetArg (arglist[i], XtNlabel, ok); i++;
XtSetValues (selFileOK, arglist, i);
i = 0;
XtSetArg (arglist[i], XtNlabel, cancel); i++;
XtSetValues (selFileCancel, arglist, i);
}
SFpositionWidget (selFile);
XtMapWidget (selFile);
if (!getcwd (SFstartDir, MAXPATHLEN)) {
XtAppError (SFapp, "XsraSelFile: can't get current directory");
}
strcat (SFstartDir, "/");
strcpy (SFcurrentDir, SFstartDir);
if (init_path) {
if (init_path[0] == '/') {
strcpy (SFcurrentPath, init_path);
if (strncmp (SFcurrentPath, SFstartDir, strlen (SFstartDir))) {
SFsetText (SFcurrentPath);
} else {
SFsetText (& (SFcurrentPath[strlen (SFstartDir)]));
}
} else {
strcat (strcpy (SFcurrentPath, SFstartDir), init_path);
SFsetText (& (SFcurrentPath[strlen (SFstartDir)]));
}
} else {
strcpy (SFcurrentPath, SFstartDir);
}
SFfunc = show_entry;
SFtextChanged ();
XtAddGrab (selFile, True, True);
SFdirModTimerId = XtAppAddTimeOut (
SFapp, (unsigned long) 1000, SFdirModTimer, (XtPointer) NULL
);
while (1) {
XtAppNextEvent (SFapp, &event);
XtDispatchEvent (&event);
switch (SFstatus) {
case SEL_FILE_TEXT:
SFstatus = SEL_FILE_NULL;
SFtextChanged ();
break;
case SEL_FILE_OK:
strncpy (name_return, SFtextBuffer, name_size);
SFprepareToReturn ();
if (SFworkProcAdded) {
XtRemoveWorkProc (SFworkProcId);
SFworkProcAdded = 0;
}
return 1;
case SEL_FILE_CANCEL:
SFprepareToReturn ();
return 0;
case SEL_FILE_NULL:
break;
}
}
return 0;
}
static void DoLayout(Widget w, Boolean doit)
{
ScrollBoxWidget sbw = (ScrollBoxWidget)w;
Widget wmain, vscroll, hscroll, child;
Dimension mw, mh; /* main window */
Dimension vh; /* vertical scrollbar length (height) */
Dimension hw; /* horizontal scrollbar length (width) */
Position vx;
Position hy;
Cardinal i;
if (sbw->composite.num_children != 3)
XtAppError(XtWidgetToApplicationContext(w),
"ScrollBox: must manage exactly three widgets.");
for (i = 0; i < sbw->composite.num_children; i++)
{
child = sbw->composite.children[i];
if (!XtIsManaged(child))
XtAppError(XtWidgetToApplicationContext(w),
"ScrollBox: all three widgets must be managed.");
}
/* Child one is the main window, two is the vertical scrollbar,
and three is the horizontal scrollbar. */
wmain = sbw->composite.children[0];
vscroll = sbw->composite.children[1];
hscroll = sbw->composite.children[2];
/* Size all three widgets so that space is fully utilized. */
mw = sbw->core.width - (2 * sbw->scrollBox.h_space) -
vscroll->core.width - (2 * vscroll->core.border_width) -
(2 * wmain->core.border_width);
mh = sbw->core.height - (2 * sbw->scrollBox.v_space) -
hscroll->core.height - (2 * hscroll->core.border_width) -
(2 * wmain->core.border_width);
/* Force the main window to be sized to the appropriate increment. */
mw = (mw / sbw->scrollBox.increment_width) *
sbw->scrollBox.increment_width;
mh = ((mh / sbw->scrollBox.increment_height) *
sbw->scrollBox.increment_height) +
sbw->scrollBox.increment_height;
vx = wmain->core.x + mw + sbw->scrollBox.h_space +
wmain->core.border_width + vscroll->core.border_width;
hy = wmain->core.y + mh + sbw->scrollBox.v_space +
wmain->core.border_width + hscroll->core.border_width;
vh = mh; /* scrollbars are always same length as main window */
hw = mw;
if (doit)
{
XtResizeWidget(wmain, mw, mh, 1);
XtResizeWidget(vscroll, vscroll->core.width, vh, 1);
XtMoveWidget(vscroll, vx, vscroll->core.y);
XtResizeWidget(hscroll, hw, hscroll->core.height, 1);
XtMoveWidget(hscroll, hscroll->core.x, hy);
}
}
Widget *XbrMenu(Widget parent, char *title, int menu_type,
XbrMenuData menu_data[], int n)
{
XtAppContext app_context = XtWidgetToApplicationContext(parent);
Widget *widgets;
Boolean radio_behaviour = False;
int i, extras;
Arg args[10];
Cardinal num;
XmString string;
char name[256];
/* Number of extra widgets to create - for a popup this is just the popup
menu but for pulldowns there is the menu and the cascade button.
*/
if(menu_type == XbrMENU_POPUP)
extras = 1;
else
extras = 2;
/* Allocate memory for widgets */
if((widgets = (Widget *) malloc(sizeof(Widget) * (n+extras))) == NULL) {
XtAppError(app_context, "Error - out of memory!\n");
return(NULL);
}
/* Create menu */
switch(menu_type) {
case XbrMENU_POPUP:
sprintf(name, "%sPopup", title);
widgets[MENU] = XmCreatePopupMenu(parent, name, NULL, 0);
break;
case XbrMENU_OPTION:
sprintf(name, "%sPane", title);
widgets[MENU] = XmCreatePulldownMenu(parent, name, NULL,0);
num = 0;
string = XmStringCreateLocalized(title);
XtSetArg(args[num], XmNsubMenuId, widgets[MENU]); num++;
XtSetArg(args[num], XmNlabelString, string); num++;
sprintf(name, "%sOption", title);
widgets[CASCADE] = XmCreateOptionMenu(parent, name, args, num);
XmStringFree(string);
XtManageChild(widgets[CASCADE]);
break;
case XbrMENU_PULLDOWN_RADIO:
radio_behaviour = True;
case XbrMENU_PULLDOWN:
sprintf(name, "%sPulldown", title);
widgets[MENU] = XmCreatePulldownMenu(parent, name, NULL,0);
XtVaSetValues(widgets[MENU], XmNradioBehavior, radio_behaviour,
NULL);
/* Create menu title */
sprintf(name, "%sCascade", title);
widgets[CASCADE] = XtVaCreateManagedWidget(name,
xmCascadeButtonWidgetClass, parent,
XmNsubMenuId, widgets[MENU],
XtVaTypedArg, XmNlabelString, XmRString,
title, sizeof(char *),
NULL);
break;
default:
XtAppError(app_context, "Unknown menu type!\n");
}
/* Add desired widgets */
for(i = 0; i < n; i++) {
sprintf(name, "%s%d", title, i);
switch(menu_data[i].type) {
/* Label widget - easy */
case XbrLABEL:
string = XmStringCreateLocalized(menu_data[i].label);
widgets[i+extras] = XtVaCreateManagedWidget(name,
xmLabelWidgetClass, widgets[MENU],
XmNlabelString, string,
NULL);
XmStringFree(string);
break;
/* Push button gadget - include activate callback & data */
case XbrPB:
string = XmStringCreateLocalized(menu_data[i].label);
widgets[i+extras] = XtVaCreateManagedWidget(name,
xmPushButtonWidgetClass, widgets[MENU],
XmNlabelString, string,
NULL);
XmStringFree(string);
if(menu_data[i].callback)
XtAddCallback(widgets[i+extras], XmNactivateCallback,
menu_data[i].callback, menu_data[i].data);
if(menu_data[i].set && menu_type == XbrMENU_OPTION)
XtVaSetValues(widgets[CASCADE], XmNmenuHistory,
widgets[i+extras], NULL);
break;
/* Toggle button - include value changed callback & data */
case XbrTOGGLE:
num = 0;
string = XmStringCreateLocalized(menu_data[i].label);
XtSetArg(args[num], XmNlabelString, string); num++;
XtSetArg(args[num], XmNindicatorType, XmONE_OF_MANY); num++;
if(menu_data[i].set != XbrNOSET) {
XtSetArg(args[num], XmNset, menu_data[i].set); num++;
}
widgets[i+extras] = XmCreateToggleButton(widgets[MENU], name,
args, num);
XtManageChild(widgets[i+extras]);
XmStringFree(string);
if(menu_data[i].callback)
XtAddCallback(widgets[i+extras], XmNvalueChangedCallback,
menu_data[i].callback, menu_data[i].data);
break;
/* Separator to make menu look pretty! */
case XbrSEPARATOR:
widgets[i+extras] = XtVaCreateManagedWidget(name,
xmSeparatorWidgetClass, widgets[MENU],
NULL);
break;
/* A sub menu */
case XbrSUBMENU:
widgets[i+extras] = (Widget)XbrMenu(widgets[MENU], menu_data[i].title, menu_data[i].stype,
menu_data[i].submenu, menu_data[i].n);
break;
default:
XtAppError(app_context, "Unknown menu item!\n");
break;
}
}
return(widgets);
}
void
main(int argc, char *argv[])
{
int i;
#ifdef IRIX_5_1_MOTIF_BUG_WORKAROUND
/*
* XXX Unfortunately a bug in the IRIX 5.1 Motif shared library
* causes a BadMatch X protocol error if the SGI look&feel
* is enabled for this program. If we detect we are on an
* IRIX 5.1 system, skip the first two fallback resources which
* specify using the SGI look&feel.
*/
struct utsname versionInfo;
if(uname(&versionInfo) >= 0) {
if(!strcmp(versionInfo.sysname, "IRIX") &&
!strncmp(versionInfo.release, "5.1", 3)) {
toplevel = XtAppInitialize(&app, "Textfun", NULL, 0, &argc, argv,
&fallbackResources[2], NULL, 0);
}
}
if(toplevel == NULL) {
toplevel = XtAppInitialize(&app, "Textfun", NULL, 0, &argc, argv,
fallbackResources, NULL, 0);
}
#else
toplevel = XtAppInitialize(&app, "Textfun", NULL, 0, &argc, argv,
fallbackResources, NULL, 0);
#endif
dpy = XtDisplay(toplevel);
/* find an OpenGL-capable RGB visual with depth buffer */
vi = glXChooseVisual(dpy, DefaultScreen(dpy), dblBuf);
if (vi == NULL) {
vi = glXChooseVisual(dpy, DefaultScreen(dpy), snglBuf);
if (vi == NULL)
XtAppError(app, "no RGB visual with depth buffer");
doubleBuffer = GL_FALSE;
}
for (i = 0; i < NUM_FONT_ENTRIES; i++) {
fontEntry[i].xfont = XLoadQueryFont(dpy, fontEntry[i].xlfd);
if (i == 0 && !fontEntry[i].xfont)
XtAppError(app, "could not get basic font");
}
fontEntry[0].fontinfo = SuckGlyphsFromServer(dpy, fontEntry[0].xfont->fid);
if (!fontEntry[0].fontinfo)
XtAppError(app, "could not get font glyphs");
/* create an OpenGL rendering context */
cx = glXCreateContext(dpy, vi, /* no display list sharing */ None,
/* favor direct */ GL_TRUE);
if (cx == NULL)
XtAppError(app, "could not create rendering context");
/* create an X colormap since probably not using default visual */
cmap = XCreateColormap(dpy, RootWindow(dpy, vi->screen),
vi->visual, AllocNone);
XtVaSetValues(toplevel, XtNvisual, vi->visual, XtNdepth, vi->depth,
XtNcolormap, cmap, NULL);
XtAddEventHandler(toplevel, StructureNotifyMask, False,
map_state_changed, NULL);
mainw = XmCreateMainWindow(toplevel, "mainw", NULL, 0);
XtManageChild(mainw);
/* create menu bar */
menubar = XmCreateMenuBar(mainw, "menubar", NULL, 0);
XtManageChild(menubar);
/* hack around Xt's ignorance of visuals */
XtSetArg(menuPaneArgs[0], XmNdepth, DefaultDepthOfScreen(XtScreen(mainw)));
XtSetArg(menuPaneArgs[1],
XmNcolormap, DefaultColormapOfScreen(XtScreen(mainw)));
/* create File pulldown menu: Quit */
menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 2);
btn = XmCreatePushButton(menupane, "Quit", NULL, 0);
XtAddCallback(btn, XmNactivateCallback, quit, NULL);
XtManageChild(btn);
XtSetArg(args[0], XmNsubMenuId, menupane);
cascade = XmCreateCascadeButton(menubar, "File", args, 1);
XtManageChild(cascade);
/* create Options pulldown menu: Motion, Dolly, Rotate, Wobble */
menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 2);
btn = XmCreateToggleButton(menupane, "Motion", NULL, 0);
XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc) toggle, NULL);
XtManageChild(btn);
btn = XmCreateToggleButton(menupane, "Dolly", NULL, 0);
XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc) dolly, NULL);
XtVaSetValues(btn, XmNset, True, NULL);
XtManageChild(btn);
btn = XmCreateToggleButton(menupane, "Rotate", NULL, 0);
XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc) rotate, NULL);
XtManageChild(btn);
btn = XmCreateToggleButton(menupane, "Wobble", NULL, 0);
XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc) wobble, NULL);
XtManageChild(btn);
XtSetArg(args[0], XmNsubMenuId, menupane);
cascade = XmCreateCascadeButton(menubar, "Options", args, 1);
XtManageChild(cascade);
XtSetArg(menuPaneArgs[2], XmNradioBehavior, True);
XtSetArg(menuPaneArgs[3], XmNradioAlwaysOne, True);
menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 4);
XtAddCallback(menupane, XmNentryCallback, (XtCallbackProc) fontSelect, NULL);
for (i = 0; i < NUM_FONT_ENTRIES; i++) {
btn = XmCreateToggleButton(menupane, fontEntry[i].name, NULL, 0);
XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc) neverCalled, &fontEntry[i]);
if (i == 0)
XtVaSetValues(btn, XmNset, True, NULL);
if (!fontEntry[i].xfont)
XtSetSensitive(btn, False);
XtManageChild(btn);
}
XtSetArg(args[0], XmNsubMenuId, menupane);
cascade = XmCreateCascadeButton(menubar, "Font", args, 1);
XtManageChild(cascade);
/* create framed drawing area for OpenGL rendering */
frame = XmCreateFrame(mainw, "frame", NULL, 0);
XtManageChild(frame);
glxarea = XtCreateManagedWidget("glxarea", xmDrawingAreaWidgetClass,
frame, NULL, 0);
XtAddCallback(glxarea, XmNexposeCallback, (XtCallbackProc) draw, NULL);
XtAddCallback(glxarea, XmNresizeCallback, resize, NULL);
XtAddCallback(glxarea, XmNinputCallback, input, NULL);
/* set up application's window layout */
XmMainWindowSetAreas(mainw, menubar, NULL, NULL, NULL, frame);
XtRealizeWidget(toplevel);
/*
* Once widget is realized (ie, associated with a created X window), we
* can bind the OpenGL rendering context to the window.
*/
glXMakeCurrent(dpy, XtWindow(glxarea), cx);
made_current = GL_TRUE;
/* setup OpenGL state */
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glClearDepth(1.0);
glMatrixMode(GL_PROJECTION);
glFrustum(-1.0, 1.0, -1.0, 1.0, 1.0, 80);
glMatrixMode(GL_MODELVIEW);
MakeCube();
if (argv[1] != NULL) {
numMessages = argc - 1;
messages = &argv[1];
} else {
numMessages = NUM_DEFAULT_MESSAGES;
messages = defaultMessage;
}
base = glGenLists(numMessages + 1);
SetupMessageDisplayList(&fontEntry[0], numMessages, messages);
tick();
/* start event processing */
XtAppMainLoop(app);
}
NAMESPACEHACK
#include <Xm/Xm.h>
#include <Xm/Form.h>
#include <Xm/Frame.h>
#ifdef HYPFREE
#include <GL/GLwMDrawA.h>
#else
#include <X11/GLw/GLwMDrawA.h>
#endif
#include "VkHypViewer.h"
#ifdef HYPVK
VkHypViewer::VkHypViewer(const char* name, Widget top, Widget parent,
XVisualInfo *vi) : VkComponent(name) {
#else
VkHypViewer::VkHypViewer(const char* name, Widget top, Widget parent,
XVisualInfo *vi) {
#endif
hv = NULL;
if (!vi) {
static int fallback[] = { GLX_RGBA, GLX_DOUBLEBUFFER, GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1,
GLX_DEPTH_SIZE, 1, None};
XVisualInfo *visinfo;
Display *d = XtDisplay(top);
if (!(visinfo = glXChooseVisual(d, DefaultScreen(d), fallback))) {
XtAppError(XtDisplayToApplicationContext(XtDisplay(top)),
"HypViewer: no suitable RGB visual");
return;
}
vi = visinfo;
}
Pixel bg = WhitePixelOfScreen(XtScreen(top));
int pfwidth = 0;
int pfheight = 0;
XtVaGetValues(top, /* get width, height of parent_form */
XmNwidth, &pfwidth,
XmNheight, &pfheight,
NULL);
glxarea = XtVaCreateManagedWidget("glxwidget",
glwMDrawingAreaWidgetClass, parent,
GLwNrgba, TRUE,
GLwNdoublebuffer, TRUE,
GLwNredSize, 1,
GLwNgreenSize, 1,
GLwNblueSize, 1,
GLwNdepthSize, 15,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNbackground, bg,
NULL);
par = parent;
#ifdef HYPVK
_baseWidget = glxarea;
installDestroyHandler();
#endif
// XtAddCallback(glxarea, GLwNginitCallback, initCallback, (XtPointer)this);
XtAddEventHandler(glxarea,
PointerMotionMask | ButtonPressMask | ButtonReleaseMask |
StructureNotifyMask | ExposureMask,
FALSE, eventHandlerCB, (XtPointer) this);
hv = new HypView(glxarea);
cx = NULL;
}
void
SoXtGLWidgetP::createVisual(void)
{
Display * const display = SoXt::getDisplay();
int trynum = 0;
const int ARRAYSIZE = 256;
int attrs[ARRAYSIZE];
int screen = DefaultScreen(display);
while (this->normalvisual == NULL && trynum < 8) {
int arraysize = this->buildGLAttrs(attrs, trynum);
assert(arraysize < ARRAYSIZE);
//this->normalvisual = glXChooseVisual(display, screen, attrs);
trynum++;
}
if (this->normalvisual == NULL) {
SoDebugError::post("SoXtGLWidget::buildWidget",
"could not get satisfactory visual for GLX");
XtAppError(SoXt::getAppContext(), "SoXtGLWidget::buildWidget()");
}
this->doublebuffer = ((trynum-1) & 0x02) ? FALSE : TRUE;
if ((this->normalvisual->c_class != TrueColor) &&
(this->normalvisual->c_class != PseudoColor)) {
SoDebugError::post("SoXtGLWidget::buildWidget",
"Visual hasn't the necessary color capabilities");
XtAppError(SoXt::getAppContext(), "SoXtGLWidget::buildWidget()");
}
#ifndef HAVE_LIBXMU
SoDebugError::post("SoXtGLWidget::buildWidget",
"SoXt does not support detecting best visual/colormap without the Xmu library (yet)");
exit(1);
#else // HAVE_LIBXMU
Colormap colors = (Colormap) NULL;
XStandardColormap * cmaps = NULL;
int nmaps = 0;
if (XmuLookupStandardColormap(display, this->normalvisual->screen, this->normalvisual->visualid,
this->normalvisual->depth, XA_RGB_DEFAULT_MAP, False, True) &&
XGetRGBColormaps(display,
RootWindow(display, this->normalvisual->screen), &cmaps, &nmaps,
XA_RGB_DEFAULT_MAP)) {
SbBool found = FALSE;
for (int i = 0; i < nmaps && ! found; i++) {
if (cmaps[i].visualid == this->normalvisual->visualid) {
#if SOXT_DEBUG && 0
SoDebugError::postInfo("SoXtGLWidget::buildWidget",
"got shared color map");
#endif // SOXT_DEBUG
colors = cmaps[i].colormap;
XFree(cmaps);
found = TRUE;
}
}
if (! found) {
colors = XCreateColormap(display,
RootWindow(display, this->normalvisual->screen),
this->normalvisual->visual, AllocNone);
}
}
else {
colors = XCreateColormap(display,
RootWindow(display, this->normalvisual->screen),
this->normalvisual->visual, AllocNone);
}
this->colormap = colors;
#endif // HAVE_LIBXMU
}
FILE *
Format(ManpageGlobals * man_globals, char * entry)
{
FILE * file = NULL;
#ifdef HAS_MKSTEMP
int fd;
#endif
Widget manpage = man_globals->manpagewidgets.manpage;
char cmdbuf[BUFSIZ], tmp[BUFSIZ], filename[BUFSIZ], error_buf[BUFSIZ];
char path[BUFSIZ], sect[BUFSIZ];
XEvent event;
Position x,y; /* location to pop up the
"would you like to save" widget. */
#ifndef HAS_MKSTEMP
if ( !UncompressUnformatted(man_globals, entry, filename) ) {
#else
if ( !UncompressUnformatted(man_globals, entry, filename, &file) ) {
#endif
/* We Really could not find it, this should never happen, yea right. */
snprintf(error_buf, sizeof(error_buf),
"Could not open manual page, %s", entry);
PopupWarning(man_globals, error_buf);
XtPopdown( XtParent(man_globals->standby) );
return(NULL);
}
#ifndef HAS_MKSTEMP
if ((file = fopen(filename, "r")) != NULL) {
#else
if (file != NULL) {
#endif
char line[BUFSIZ];
if (fgets(line, sizeof(line), file) != NULL) {
if (strncmp(line, ".so ", 4) == 0) {
line[strlen(line) - 1] = '\0';
fclose(file);
unlink(filename);
if (line[4] != '/') {
char *ptr = NULL;
strcpy(tmp, entry);
if ((ptr = rindex(tmp, '/')) != NULL) {
*ptr = '\0';
if ((ptr = rindex(tmp, '/')) != NULL)
ptr[1] = '\0';
}
}
else
*tmp = '\0';
snprintf(filename, sizeof(filename), "%s%s", tmp, line + 4);
return (Format(man_globals, filename));
}
}
fclose(file);
}
Popup(XtParent(man_globals->standby), XtGrabExclusive);
while ( !XCheckTypedWindowEvent(XtDisplay(man_globals->standby),
XtWindow(man_globals->standby),
Expose, &event) );
XtDispatchEvent( &event );
XFlush(XtDisplay(man_globals->standby));
strcpy(tmp,MANTEMP); /* Get a temp file. */
#ifndef HAS_MKSTEMP
(void) mktemp(tmp);
#else
fd = mkstemp(tmp);
file = fdopen(fd, "r");
#endif
strcpy(man_globals->tempfile, tmp);
ParseEntry(entry, path, sect, NULL);
#ifndef HANDLE_ROFFSEQ
#ifndef HAS_MKSTEMP
snprintf(cmdbuf, sizeof(cmdbuf), "cd %s ; %s %s %s > %s %s", path, TBL,
filename, FORMAT, man_globals->tempfile, "2> /dev/null");
#else
snprintf(cmdbuf, sizeof(cmdbuf), "cd %s ; %s %s %s >> %s %s", path, TBL,
filename, FORMAT, man_globals->tempfile, "2> /dev/null");
#endif
#else
/* Handle more flexible way of specifying the formatting pipeline */
if (! ConstructCommand(cmdbuf, path, filename, man_globals->tempfile)) {
sprintf(error_buf, "Constructed command was too long!");
PopupWarning(man_globals, error_buf);
file = NULL;
}
else
#endif /* HANDLE_ROFFSEQ */
if(system(cmdbuf) != 0) { /* execute search. */
snprintf(error_buf, sizeof(error_buf),
"Something went wrong trying to run the command: %s", cmdbuf);
PopupWarning(man_globals, error_buf);
file = NULL;
}
else {
#ifndef HAS_MKSTEMP
if ((file = fopen(man_globals->tempfile,"r")) == NULL) {
sprintf(error_buf, "Something went wrong in retrieving the %s",
"temp file, try cleaning up /tmp");
PopupWarning(man_globals, error_buf);
}
else {
#endif
XtPopdown( XtParent(man_globals->standby) );
if ( (man_globals->save == NULL) ||
(man_globals->manpagewidgets.manpage == NULL) )
unlink(man_globals->tempfile);
else {
char * ptr, catdir[BUFSIZ];
/*
* If the catdir is writeable then ask the user if he/she wants to
* write the man page to it.
*/
strcpy(catdir, man_globals->save_file);
if ( (ptr = rindex(catdir, '/')) != NULL) {
*ptr = '\0';
if ( access(catdir, W_OK) != 0 )
unlink(man_globals->tempfile);
else {
x = (Position) Width(man_globals->manpagewidgets.manpage)/2;
y = (Position) Height(man_globals->manpagewidgets.manpage)/2;
XtTranslateCoords(manpage, x, y, &x, &y);
PositionCenter( man_globals->save, (int) x, (int) y, 0, 0, 0, 0);
XtPopup( man_globals->save, XtGrabExclusive);
}
}
else
unlink(man_globals->tempfile);
}
#ifndef HAS_MKSTEMP
}
#endif
}
/*
* If the original was compressed or in another format, delete temporary file.
*/
if (man_globals->deletetempfile)
unlink(filename);
return(file);
}
#ifdef HANDLE_ROFFSEQ
/* Function Name: ConstructCommand
* Description: Constructs the pipeline of commands necessary to format
* a manual page.
* Arguments: cmdbuf - the buffer into which to write the command
* path - the directory in which the original man page resides
* filename - the (uncompressed) manpage source file
* tempfile - the name of a temporary file to direct the final
* output of the pipeline into
* Returns: TRUE if the command fit into the buffer, FALSE if it would
* be too long (more than BUFSIZ characters)
*/
static Boolean
ConstructCommand(cmdbuf, path, filename, tempfile)
char *cmdbuf, *path, *filename, *tempfile;
{
/* The original code did the following to produce a command line:
* sprintf(cmdbuf,"cd %s ; %s %s %s > %s %s", path, TBL,
* filename, FORMAT, man_globals->tempfile, "2> /dev/null");
* We are more flexible and follow more or less the algorithm used
* by the Linux man command:
* + Obtain a string of letters from the following sources in order
* of preference:
* + a command line option (not implemented in xman; it's probably not
* useful)
* + the first line of the manpage source, if it is of the form:
* '\" <string>
* + the MANROFFSEQ environment variable
* + a default string; this is "".
* + Interpret the string as a pipeline of filters:
* + e = eqn g = grap p = pic t = tbl v = vgrind r = refer
* + zsoelim is always run as the first preprocessor in any case.
*
* Strictly speaking we should save a catpage iff the string comes
* from the file or is the default.
*
* You'll notice that we format a man page into ASCII text output and then
* attempt to interpret things like L^HL as bold and so forth. This
* is so obviously the Wrong Thing it's untrue.
*/
char *c = cmdbuf; /* current posn in buffer */
int left = BUFSIZ; /* space left in buffer */
int used;
char *fmt;
FILE *file;
char fmtbuf[128];
int gotfmt = 0; /* set to 1 if we got a directive from source */
char *fname = NULL;
#ifdef __UNIXOS2__
int i;
#endif
fmt = NULL;
/* If you have a command line option that gives a setting for fmt,
set it here. */
if (!fmt) {
/* This is the tricky bit: extract a format string from the source file
* Annoyingly, filename might be relative or absolute. We cheat and
* use system to get the thing to a known absoute filename.
*/
if (filename[0] == '/') {
fname = filename;
} else {
fname = malloc(strlen(path) + 1 + strlen(filename) + 1);
if (!fname)
return FALSE;
sprintf(fname, "%s/%s", path, filename);
}
if ((file = fopen(fname, "r")) &&
(fgets(fmtbuf, sizeof(fmtbuf), file)) &&
(!memcmp(fmtbuf, "'\\\" ", 4))) {
/* that's squote-backslash-dquote-space */
int len;
fmt = fmtbuf + 3;
len = strlen(fmt);
if (len && (fmt[len-1] == '\n')) {
fmt[len-1] = 0;
gotfmt++;
}
}
if (fname && fname != filename)
free(fname);
if (!gotfmt) /* not there or some error */
{
fmt = getenv("MANROFFSEQ");
}
}
if (!fmt)
{
fmt = DEFAULT_MANROFFSEQ;
}
/* Start with the first fixed part of the command line */
#ifdef __UNIXOS2__
for (i = 0; i < strlen(path); i++) {
if (path[i] == '/')
path[i] = '\\';
}
used = snprintf(c, left, "cd %s & %s %s ", path, ZSOELIM, filename);
#else
used = snprintf(c, left, "cd %s; %s %s ", path, ZSOELIM, filename);
#endif
left -= used;
c += used;
if (left <= 1)
return (FALSE);
/* Now add preprocessors of the form '| processor' */
for ( ; *fmt; fmt++)
{
char *filter;
switch (*fmt)
{
case 'e':
filter = EQN;
break;
case 'g':
filter = GRAP;
break;
case 'p':
filter = PIC;
break;
case 't':
filter = TBL;
break;
case 'v':
filter = VGRIND;
break;
case 'r':
filter = REFER;
break;
default:
filter = NULL;
break;
}
if (filter)
{
used = snprintf(c, left, " | %s ", filter);
left -= used;
c += used;
if (left <= 1)
return (FALSE);
}
}
/* Now add the fixed trailing part 'formatprog > tempfile 2> /dev/null' */
#ifdef __UNIXOS2__
used = snprintf(c, left, " | %s > %s 2>NUL", FORMAT, tempfile);
#else
#ifndef HAS_MKSTEMP
used = snprintf(c, left, " | %s > %s 2>/dev/null", FORMAT, tempfile);
#else
used = snprintf(c, left, " | %s >> %s 2>/dev/null", FORMAT, tempfile);
#endif
#endif /* __UNIXOS2__ */
left -= used;
if (left <= 1)
return (FALSE);
return (TRUE);
}
#endif /* HANDLE_ROFFSEQ */
/* Function Name: UncompressUnformatted
* Description: Finds an uncompressed unformatted manual page.
* Arguments: man_globals - the psuedo global structure.
* entry - the manual page entry.
* RETURNED filename - location to put the name of the file.
* Returns: TRUE if the file was found.
*/
static Boolean
#ifndef HAS_MKSTEMP
UncompressUnformatted(ManpageGlobals * man_globals, char * entry,
char * filename)
#else
UncompressUnformatted(ManpageGlobals * man_globals, char * entry,
char * filename, FILE **file)
#endif
{
char path[BUFSIZ], page[BUFSIZ], section[BUFSIZ], input[BUFSIZ];
int len_cat = strlen(CAT), len_man = strlen(MAN);
#if defined(SMAN) && defined(SFORMAT)
int len_sman = strlen(SMAN);
#endif
ParseEntry(entry, path, section, page);
man_globals->bzip2 = FALSE;
man_globals->lzma = FALSE;
#if defined(__OpenBSD__) || defined(__NetBSD__)
/*
* look for uncompressed file in machine subdir first
*/
snprintf(filename, BUFSIZ, "%s/%s%s/%s/%s", path, MAN,
section + len_cat, MACHINE, page);
if ( access( filename, R_OK ) == 0 ) {
man_globals->compress = FALSE;
man_globals->gzip = FALSE;
man_globals->deletetempfile = FALSE;
snprintf(man_globals->save_file, sizeof(man_globals->save_file),
"%s/%s%s/%s/%s", path, CAT, section + len_cat, MACHINE, page);
return(TRUE);
}
/*
* Then for compressed files in an uncompressed directory.
*/
snprintf(input, sizeof(input), "%s.%s", filename, COMPRESSION_EXTENSION);
#ifndef HAS_MKSTEMP
if ( UncompressNamed(man_globals, input, filename) ) {
#else
if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
man_globals->compress = TRUE;
man_globals->deletetempfile = TRUE;
snprintf(man_globals->save_file, sizeof(man_globals->save_file),
"%s/%s%s/%s.%s", path, CAT, section + len_cat, page,
COMPRESSION_EXTENSION);
return(TRUE);
}
#ifdef GZIP_EXTENSION
else {
snprintf(input, sizeof(input), "%s.%s", filename, GZIP_EXTENSION);
#ifndef HAS_MKSTEMP
if ( UncompressNamed(man_globals, input, filename) ) {
#else
if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
man_globals->compress = TRUE;
man_globals->gzip = TRUE;
man_globals->deletetempfile = TRUE;
snprintf(man_globals->save_file, sizeof(man_globals->save_file),
"%s/%s%s/%s.%s", path, CAT, section + len_cat, page,
GZIP_EXTENSION);
return(TRUE);
}
}
#endif /* GZIP_EXTENSION */
#endif /* __OpenBSD__ || __NetBSD__ */
#ifdef BZIP2_EXTENSION
{
sprintf(input, "%s.%s", filename, BZIP2_EXTENSION);
#ifndef HAS_MKSTEMP
if ( UncompressNamed(man_globals, input, filename) ) {
#else
if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
man_globals->compress = TRUE;
man_globals->gzip = FALSE;
man_globals->bzip2 = TRUE;
sprintf(man_globals->save_file, "%s/%s%s/%s.%s", path,
CAT, section + len_cat, page, BZIP2_EXTENSION);
return(TRUE);
}
}
#endif /* BZIP2_EXTENSION */
#ifdef LZMA_EXTENSION
{
sprintf(input, "%s.%s", filename, LZMA_EXTENSION);
#ifndef HAS_MKSTEMP
if ( UncompressNamed(man_globals, input, filename) ) {
#else
if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
man_globals->compress = TRUE;
man_globals->gzip = FALSE;
man_globals->lzma = TRUE;
sprintf(man_globals->save_file, "%s/%s%s/%s.%s", path,
CAT, section + len_cat, page, LZMA_EXTENSION);
return(TRUE);
}
}
#endif /* LZMA_EXTENSION */
/*
* Look for uncompressed file first.
*/
snprintf(filename, BUFSIZ, "%s/%s%s/%s", path, MAN, section + len_man, page);
if ( access( filename, R_OK ) == 0 ) {
man_globals->compress = FALSE;
man_globals->gzip = FALSE;
man_globals->deletetempfile = FALSE;
snprintf(man_globals->save_file, sizeof(man_globals->save_file),
"%s/%s%s/%s", path, CAT, section + len_cat, page);
return(TRUE);
}
#if defined(SMAN) && defined(SFORMAT)
/*
* Look for uncompressed sgml file next.
*/
snprintf(input, BUFSIZ, "%s/%s%s/%s", path, SMAN, section + len_sman, page);
#ifndef HAS_MKSTEMP
if ( SgmlToRoffNamed(man_globals, input, filename) ) {
#else
if ( SgmlToRoffNamed(man_globals, input, filename, file) ) {
#endif
man_globals->compress = FALSE;
man_globals->gzip = FALSE;
man_globals->deletetempfile = TRUE;
snprintf(man_globals->save_file, sizeof(man_globals->save_file),
"%s/%s%s/%s", path, CAT, section + len_cat, page);
return(TRUE);
}
#endif
/*
* Then for compressed files in an uncompressed directory.
*/
snprintf(input, sizeof(input), "%s.%s", filename, COMPRESSION_EXTENSION);
#ifndef HAS_MKSTEMP
if ( UncompressNamed(man_globals, input, filename) ) {
#else
if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
man_globals->compress = TRUE;
man_globals->deletetempfile = TRUE;
snprintf(man_globals->save_file, sizeof(man_globals->save_file),
"%s/%s%s/%s.%s", path, CAT, section + len_cat, page,
COMPRESSION_EXTENSION);
return(TRUE);
}
#ifdef GZIP_EXTENSION
else {
snprintf(input, sizeof(input), "%s.%s", filename, GZIP_EXTENSION);
#ifndef HAS_MKSTEMP
if ( UncompressNamed(man_globals, input, filename) ) {
#else
if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
man_globals->compress = TRUE;
man_globals->gzip = TRUE;
man_globals->deletetempfile = TRUE;
snprintf(man_globals->save_file, sizeof(man_globals->save_file),
"%s/%s%s/%s.%s", path, CAT, section + len_cat, page,
GZIP_EXTENSION);
return(TRUE);
}
}
#endif
#ifdef BZIP2_EXTENSION
{
sprintf(input, "%s.%s", filename, BZIP2_EXTENSION);
#ifndef HAS_MKSTEMP
if ( UncompressNamed(man_globals, input, filename) ) {
#else
if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
man_globals->compress = TRUE;
man_globals->gzip = TRUE;
sprintf(man_globals->save_file, "%s/%s%s/%s.%s", path,
CAT, section + len_cat, page, BZIP2_EXTENSION);
return(TRUE);
}
}
#endif
#ifdef LZMA_EXTENSION
{
sprintf(input, "%s.%s", filename, LZMA_EXTENSION);
#ifndef HAS_MKSTEMP
if ( UncompressNamed(man_globals, input, filename) ) {
#else
if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
man_globals->compress = TRUE;
man_globals->lzma = TRUE;
sprintf(man_globals->save_file, "%s/%s%s/%s.%s", path,
CAT, section + len_cat, page, LZMA_EXTENSION);
return(TRUE);
}
}
#endif
/*
* And lastly files in a compressed directory.
*/
snprintf(input, sizeof(input), "%s/%s%s.%s/%s", path,
MAN, section + len_man, COMPRESSION_EXTENSION, page);
#ifndef HAS_MKSTEMP
if ( UncompressNamed(man_globals, input, filename) ) {
#else
if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
man_globals->compress = TRUE;
man_globals->deletetempfile = TRUE;
snprintf(man_globals->save_file, sizeof(man_globals->save_file),
"%s/%s%s.%s/%s", path, CAT, section + len_cat,
COMPRESSION_EXTENSION, page);
return(TRUE);
}
return(FALSE);
}
/* Function Name: AddCursor
* Description: This function adds the cursor to the window.
* Arguments: w - the widget to add the cursor to.
* cursor - the cursor to add to this widget.
* Returns: none
*/
void
AddCursor(Widget w, Cursor cursor)
{
XColor colors[2];
Arg args[10];
Cardinal num_args = 0;
Colormap c_map;
if (!XtIsRealized(w)) {
PopupWarning(NULL, "Widget is not realized, no cursor added.\n");
return;
}
XtSetArg( args[num_args], XtNcolormap, &c_map); num_args++;
XtGetValues( w, args, num_args);
colors[0].pixel = resources.cursors.fg_color;
colors[1].pixel = resources.cursors.bg_color;
XQueryColors (XtDisplay(w), c_map, colors, 2);
XRecolorCursor(XtDisplay(w), cursor, colors, colors+1);
XDefineCursor(XtDisplay(w),XtWindow(w),cursor);
}
/* Function Name: ChangeLabel
* Description: This function changes the label field of the
* given widget to the string in str.
* Arguments: w - the widget.
* str - the string to change the label to.
* Returns: none
*/
void
ChangeLabel(Widget w, char * str)
{
Arg arglist[3]; /* An argument list. */
if (w == NULL) return;
XtSetArg(arglist[0], XtNlabel, str);
/* shouldn't really have to do this. */
XtSetArg(arglist[1], XtNwidth, 0);
XtSetArg(arglist[2], XtNheight, 0);
XtSetValues(w, arglist, (Cardinal) 1);
}
/*
* In an ideal world this would be part of the XToolkit, and I would not
* have to do it, but such is life sometimes. Perhaps in X11R3.
*/
/* Function Name: PositionCenter
* Description: This function positions the given widgets center
* in the following location.
* Arguments: widget - the widget widget to postion
* x,y - The location for the center of the widget
* above - number of pixels above center to locate this widget
* left - number of pixels left of center to locate this widget
* h_space, v_space - how close to get to the edges of the
* parent window.
* Returns: none
* Note: This should only be used with a popup widget that has override
* redirect set.
*/
void
PositionCenter(Widget widget, int x, int y, int above, int left, int v_space, int h_space)
{
Arg wargs[2];
int x_temp,y_temp; /* location of the new window. */
int parent_height,parent_width; /* Height and width of the parent widget or
the root window if it has no parent. */
x_temp = x - left - Width(widget) / 2 + BorderWidth(widget);
y_temp = y - above - Height(widget) / 2 + BorderWidth(widget);
parent_height = HeightOfScreen(XtScreen(widget));
parent_width = WidthOfScreen(XtScreen(widget));
/*
* Check to make sure that all edges are within the viewable part of the
* root window, and if not then force them to be.
*/
if (x_temp < h_space)
x_temp = v_space;
if (y_temp < v_space)
(y_temp = 2);
if ( y_temp + Height(widget) + v_space > parent_height )
y_temp = parent_height - Height(widget) - v_space;
if ( x_temp + Width(widget) + h_space > parent_width )
x_temp = parent_width - Width(widget) - h_space;
XtSetArg(wargs[0], XtNx, x_temp);
XtSetArg(wargs[1], XtNy, y_temp);
XtSetValues(widget, wargs, 2);
}
/* Function Name: ParseEntry(entry, path, sect, page)
* Description: Parses the manual pages entry filenames.
* Arguments: str - the full path name.
* path - the path name. RETURNED
* sect - the section name. RETURNED
* page - the page name. RETURNED
* Returns: none.
*/
void
ParseEntry(char *entry, char *path, char *sect, char *page)
{
char *c, temp[BUFSIZ];
strcpy(temp, entry);
c = rindex(temp, '/');
if (c == NULL)
PrintError("index failure in ParseEntry.");
*c++ = '\0';
if (page != NULL)
strcpy(page, c);
c = rindex(temp, '/');
if (c == NULL)
PrintError("index failure in ParseEntry.");
*c++ = '\0';
#if defined(SFORMAT) && defined(SMAN)
/* sgmltoroff sometimes puts an extra ./ in the path to .so entries */
if (strcmp(c, ".") == 0) {
c = rindex(temp, '/');
if (c == NULL)
PrintError("index failure in ParseEntry.");
*c++ = '\0';
}
#endif
#if defined(__OpenBSD__) || defined(__NetBSD__)
/* Skip machine subdirectory if present */
if (strcmp(c, MACHINE) == 0) {
c = rindex(temp, '/');
if (c == NULL)
PrintError("index failure in ParseEntry.");
*c++ = '\0';
}
#endif
if (sect != NULL)
strcpy(sect, c);
if (path != NULL)
strcpy(path, temp);
}
/* Function Name: GetGlobals
* Description: Gets the psuedo globals associated with the
* manpage associated with this widget.
* Arguments: w - a widget in the manpage.
* Returns: the psuedo globals.
* Notes: initial_widget is a globals variable.
* manglobals_context is a global variable.
*/
ManpageGlobals *
GetGlobals(Widget w)
{
Widget temp;
caddr_t data;
while ( (temp = XtParent(w)) != initial_widget && (temp != NULL))
w = temp;
if (temp == NULL)
XtAppError(XtWidgetToApplicationContext(w),
"Xman: Could not locate widget in tree, exiting");
if (XFindContext(XtDisplay(w), XtWindow(w),
manglobals_context, &data) != XCSUCCESS)
XtAppError(XtWidgetToApplicationContext(w),
"Xman: Could not find global data, exiting");
return( (ManpageGlobals *) data);
}
/* Function Name: SaveGlobals
* Description: Saves the psuedo globals on the widget passed
* to this function, although GetGlobals assumes that
* the data is associated with the popup child of topBox.
* Arguments: w - the widget to associate the data with.
* globals - data to associate with this widget.
* Returns: none.
* Notes: WIDGET MUST BE REALIZED.
* manglobals_context is a global variable.
*/
void
SaveGlobals(Widget w, ManpageGlobals * globals)
{
if (XSaveContext(XtDisplay(w), XtWindow(w), manglobals_context,
(caddr_t) globals) != XCSUCCESS)
XtAppError(XtWidgetToApplicationContext(w),
"Xman: Could not save global data, are you out of memory?");
}
/* Function Name: RemoveGlobals
* Description: Removes the psuedo globals from the widget passed
* to this function.
* Arguments: w - the widget to remove the data from.
* Returns: none.
* Notes: WIDGET MUST BE REALIZED.
* manglobals_context is a global variable.
*/
void
RemoveGlobals(Widget w)
{
if (XDeleteContext(XtDisplay(w), XtWindow(w),
manglobals_context) != XCSUCCESS)
XtAppError(XtWidgetToApplicationContext(w),
"Xman: Could not remove global data?");
}
main(int argc, char *argv[])
{
toplevel = XtAppInitialize(&app, "Paperplane", NULL, 0, &argc, argv,
fallbackResources, NULL, 0);
dpy = XtDisplay(toplevel);
/* find an OpenGL-capable RGB visual with depth buffer */
vi = glXChooseVisual(dpy, DefaultScreen(dpy), dblBuf);
if (vi == NULL) {
vi = glXChooseVisual(dpy, DefaultScreen(dpy), snglBuf);
if (vi == NULL)
XtAppError(app, "no RGB visual with depth buffer");
doubleBuffer = GL_FALSE;
}
/* create an OpenGL rendering context */
cx = glXCreateContext(dpy, vi, /* no display list sharing */ None,
/* favor direct */ GL_TRUE);
if (cx == NULL)
XtAppError(app, "could not create rendering context");
/* create an X colormap since probably not using default visual */
#ifdef noGLwidget
cmap = XCreateColormap(dpy, RootWindow(dpy, vi->screen),
vi->visual, AllocNone);
/*
* Establish the visual, depth, and colormap of the toplevel
* widget _before_ the widget is realized.
*/
XtVaSetValues(toplevel, XtNvisual, vi->visual, XtNdepth, vi->depth,
XtNcolormap, cmap, NULL);
#endif
XtAddEventHandler(toplevel, StructureNotifyMask, False,
map_state_changed, NULL);
mainw = XmCreateMainWindow(toplevel, "mainw", NULL, 0);
XtManageChild(mainw);
/* create menu bar */
menubar = XmCreateMenuBar(mainw, "menubar", NULL, 0);
XtManageChild(menubar);
#ifdef noGLwidget
/* Hack around Xt's unfortunate default visual inheritance. */
XtSetArg(menuPaneArgs[0], XmNvisual, vi->visual);
menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 1);
#else
menupane = XmCreatePulldownMenu(menubar, "menupane", NULL, 0);
#endif
btn = XmCreatePushButton(menupane, "Quit", NULL, 0);
XtAddCallback(btn, XmNactivateCallback, quit, NULL);
XtManageChild(btn);
XtSetArg(args[0], XmNsubMenuId, menupane);
cascade = XmCreateCascadeButton(menubar, "File", args, 1);
XtManageChild(cascade);
#ifdef noGLwidget
menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 1);
#else
menupane = XmCreatePulldownMenu(menubar, "menupane", NULL, 0);
#endif
btn = XmCreateToggleButton(menupane, "Motion", NULL, 0);
XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc)toggle, NULL);
XtManageChild(btn);
btn = XmCreatePushButton(menupane, "Add plane", NULL, 0);
XtAddCallback(btn, XmNactivateCallback, (XtCallbackProc)add_plane, NULL);
XtManageChild(btn);
btn = XmCreatePushButton(menupane, "Remove plane", NULL, 0);
XtAddCallback(btn, XmNactivateCallback, (XtCallbackProc)remove_plane, NULL);
XtManageChild(btn);
XtSetArg(args[0], XmNsubMenuId, menupane);
cascade = XmCreateCascadeButton(menubar, "Planes", args, 1);
XtManageChild(cascade);
/* create framed drawing area for OpenGL rendering */
frame = XmCreateFrame(mainw, "frame", NULL, 0);
XtManageChild(frame);
#ifdef noGLwidget
glxarea = XtVaCreateManagedWidget("glxarea", xmDrawingAreaWidgetClass,
frame, NULL);
#else
#ifdef noMotifGLwidget
/* notice glwDrawingAreaWidgetClass lacks an 'M' */
glxarea = XtVaCreateManagedWidget("glxarea", glwDrawingAreaWidgetClass,
#else
glxarea = XtVaCreateManagedWidget("glxarea", glwMDrawingAreaWidgetClass,
#endif
frame, GLwNvisualInfo, vi, NULL);
#endif
XtAddCallback(glxarea, XmNexposeCallback, (XtCallbackProc)draw, NULL);
XtAddCallback(glxarea, XmNresizeCallback, resize, NULL);
XtAddCallback(glxarea, XmNinputCallback, input, NULL);
/* set up application's window layout */
XmMainWindowSetAreas(mainw, menubar, NULL, NULL, NULL, frame);
XtRealizeWidget(toplevel);
/*
* Once widget is realized (ie, associated with a created X window), we
* can bind the OpenGL rendering context to the window.
*/
glXMakeCurrent(dpy, XtWindow(glxarea), cx);
made_current = GL_TRUE;
/* setup OpenGL state */
glClearDepth(1.0);
glClearColor(0.0, 0.0, 0.0, 0.0);
glMatrixMode(GL_PROJECTION);
glFrustum(-1.0, 1.0, -1.0, 1.0, 1.0, 20);
glMatrixMode(GL_MODELVIEW);
/* add three initial random planes */
srandom(getpid());
add_plane(); add_plane(); add_plane(); add_plane(); add_plane();
/* start event processing */
toggle();
XtAppMainLoop(app);
}
