|
|
/*ScianVisWindows.c
Visualization window stuff
Eric Pepke
April 6, 1990
*/
#include "Scian.h"
#include "ScianTypes.h"
#include "ScianArrays.h"
#include "ScianLists.h"
#include "ScianWindows.h"
#include "ScianTextBoxes.h"
#include "ScianTitleBoxes.h"
#include "ScianObjWindows.h"
#include "ScianIcons.h"
#include "ScianColors.h"
#include "ScianControls.h"
#include "ScianButtons.h"
#include "ScianSpaces.h"
#include "ScianLights.h"
#include "ScianSliders.h"
#include "ScianIDs.h"
#include "ScianVisWindows.h"
#include "ScianDatasets.h"
#include "ScianPictures.h"
#include "ScianDialogs.h"
#include "ScianEvents.h"
#include "ScianScripts.h"
#include "ScianErrors.h"
#include "ScianMethods.h"
#include "ScianStyle.h"
#include "ScianVisObjects.h"
#include "ScianDraw.h"
#include "ScianDrawings.h"
#include "ScianObjFunctions.h"
#include "ScianFilters.h"
#include "ScianPick.h"
#include "ScianSymbols.h"
#include "ScianTemplates.h"
#include "ScianTemplateHelper.h"
ObjPtr visWindowClass; /*Class for vis windows*/
ObjPtr spaceWindowClass; /*Class for space subwindows*/
ObjPtr visCorralClass; /*Class for corral of a vis window*/
Bool showControlPanels = true; /*True iff show control panels by default*/
ObjPtr visualizeAsList; /*List for Visualize As*/
static ObjPtr HideVisWindowPanel(window)
WinInfoPtr window;
/*Hides the panel of the controls on the vis window. Returns true iff it did*/
{
if (window)
{
ObjPtr panel, space, assocPanel;
WinInfoPtr subWindow;
int panelWidth;
int left, right, bottom, top;
int nl, nr, nb, nt;
SelWindow(window);
GetWindowBounds(&left, &right, &bottom, &top);
space = FindSpace(window);
if (!space)
{
return false;
}
panel = GetVar(space, OBJPANEL);
if (panel)
{
/*Get the panel's bounds*/
Get2DIntBounds(panel, &nl, &nr, &nb, &nt);
panelWidth = nr - nl;
/*Change panel to be off the screen*/
nl = right + 1;
nr = nl + panelWidth;
Set2DIntBounds(panel, nl, nr, nb, nt);
ImInvalid(panel);
}
panel = GetVar(space, TOOLPANEL);
if (panel)
{
/*Get the panel's bounds*/
Get2DIntBounds(panel, &nl, &nr, &nb, &nt);
panelWidth = nr - nl;
/*Change panel to be off the screen*/
nr = left - 1;
nl = nr - panelWidth;
Set2DIntBounds(panel, nl, nr, nb, nt);
ImInvalid(panel);
}
/*Change the window or space*/
Get2DIntBounds(space, &nl, &nr, &nb, &nt);
nr = right;
nl = left;
if ((subWindow = (WinInfoPtr) GetVar((ObjPtr) window, SPACEWINDOW)) &&
subWindow != window)
{
/*Change the window*/
int ox, oy;
SelWindow(window);
GetWindowOrigin(&ox, &oy);
SelWindow(subWindow);
SetWindowPosition(ox, ox + nr - nl, oy, oy + nt - nb);
}
else
{
/*Change the space*/
Set2DIntBounds(space, nl, nr, nb, nt);
ImInvalid(space);
/*And its panels*/
assocPanel = GetVar(space, FRONTPANEL);
if (assocPanel)
{
int ol, or, ob, ot;
Get2DIntBounds(assocPanel, &ol, &or, &ob, &ot);
ReshapeObject(assocPanel, ol, or, ob, ot, nl, nr, nb, nt);
ImInvalid(assocPanel);
}
assocPanel = GetVar(space, BACKPANEL);
if (assocPanel)
{
int ol, or, ob, ot;
Get2DIntBounds(assocPanel, &ol, &or, &ob, &ot);
ReshapeObject(assocPanel, ol, or, ob, ot, nl, nr, nb, nt);
ImInvalid(assocPanel);
}
}
SetVar((ObjPtr) window, PANELHIDDEN, ObjTrue);
DeleteMenus(window);
return ObjTrue;
}
else
{
return ObjFalse;
}
}
void DoHidePanel()
{
if (selWinInfo)
{
if (logging)
{
Log("hide panel\n");
}
DeferMessage((ObjPtr) selWinInfo, HIDEPANEL);
}
}
static ObjPtr ShowVisWindowPanel(window)
WinInfoPtr window;
/*Shows the panel of the controls on the vis window. Returns true iff it did*/
{
if (window)
{
ObjPtr panel, space, assocPanel;
WinInfoPtr subWindow;
int lPanelWidth, rPanelWidth;
int left, right, bottom, top;
int nl, nr, nb, nt;
SelWindow(window);
GetWindowBounds(&left, &right, &bottom, &top);
space = FindSpace(window);
if (!space)
{
return false;
}
panel = GetVar(space, OBJPANEL);
if (panel)
{
/*Get the panel's bounds*/
Get2DIntBounds(panel, &nl, &nr, &nb, &nt);
rPanelWidth = nr - nl;
/*Change panel to be on the screen*/
nr = right;
nl = right - rPanelWidth;
Set2DIntBounds(panel, nl, nr, nb, nt);
ImInvalid(panel);
}
panel = GetVar(space, TOOLPANEL);
if (panel)
{
/*Get the panel's bounds*/
Get2DIntBounds(panel, &nl, &nr, &nb, &nt);
lPanelWidth = nr - nl;
/*Change panel to be on the screen*/
nl = left;
nr = left + lPanelWidth;
Set2DIntBounds(panel, nl, nr, nb, nt);
ImInvalid(panel);
}
/*Change the window or space*/
Get2DIntBounds(space, &nl, &nr, &nb, &nt);
nr = right - rPanelWidth;
nl = left + lPanelWidth;
if ((subWindow = (WinInfoPtr) GetVar((ObjPtr) window, SPACEWINDOW)) &&
subWindow != window)
{
/*Change the window*/
int ox, oy;
SelWindow(window);
GetWindowOrigin(&ox, &oy);
SelWindow(subWindow);
SetWindowPosition(ox, ox + nr - nl, oy, oy + nt - nb);
}
else
{
/*Change the space*/
Set2DIntBounds(space, nl, nr, nb, nt);
ImInvalid(space);
/*And its panels*/
assocPanel = GetVar(space, FRONTPANEL);
if (assocPanel)
{
int ol, or, ob, ot;
Get2DIntBounds(assocPanel, &ol, &or, &ob, &ot);
ReshapeObject(assocPanel, ol, or, ob, ot, nl, nr, nb, nt);
ImInvalid(assocPanel);
}
assocPanel = GetVar(space, BACKPANEL);
if (assocPanel)
{
int ol, or, ob, ot;
Get2DIntBounds(assocPanel, &ol, &or, &ob, &ot);
ReshapeObject(assocPanel, ol, or, ob, ot, nl, nr, nb, nt);
ImInvalid(assocPanel);
}
}
SetVar((ObjPtr) window, PANELHIDDEN, ObjFalse);
DeleteMenus(window);
return ObjTrue;
}
else
{
return ObjFalse;
}
}
void DoShowPanel()
{
if (selWinInfo)
{
if (logging)
{
Log("show panel\n");
}
DeferMessage((ObjPtr) selWinInfo, SHOWPANEL);
}
}
int annotStagger = 0;
ObjPtr DeleteSpacePanelText(text)
ObjPtr text;
/*Delete text from a space panel*/
{
return ObjTrue;
}
void AddAnnotation(name, bounds)
char *name;
real bounds[4];
/*Adds annotation with name and bounds to current window*/
{
if (selWinInfo)
{
/*Search for a space*/
ObjPtr space, frontPanel;
space = FindSpace(selWinInfo);
if (space)
{
frontPanel = GetObjectVar("AddAnnotation", space, FRONTPANEL);
if (frontPanel)
{
/*There's a front panel. Stick an annotation there*/
ObjPtr annotation;
++nAnnot;
annotation = NewTextBox((int) bounds[0], (int) bounds[1], (int) bounds[2], (int) bounds[3],
/*WITH_BG + */EDITABLE + ADJUSTABLE, name, "");
SetMethod(annotation, CLONE, CloneAnnotation);
SetMethod(annotation, DUPLICATE, DuplicateDrawing);
PrefixList(GetVar(frontPanel, CONTENTS), annotation);
SetVar(annotation, PARENT, frontPanel);
SetTextColor(annotation, NewInt(UIWHITE));
ImInvalid(annotation);
SetTextFont(annotation, ANNOTFONT);
SetTextSize(annotation, ANNOTFONTSIZE);
SetVar(annotation, STICKINESS, NewInt(FLOATINGLEFT + FLOATINGRIGHT + FLOATINGTOP + FLOATINGBOTTOM));
SetMethod(annotation, DELETEICON, DeleteSpacePanelText);
SetMethod(annotation, DELETE, DeleteObject);
SetMethod(annotation, PUSHTOBOTTOM, PushDrawingToBottom);
SetMethod(annotation, BRINGTOTOP, BringDrawingToTop);
SetMethod(annotation, MOVETOBACKPANEL, MoveDrawingToBackPanel);
SetMethod(annotation, MOVETOFRONTPANEL, MoveDrawingToFrontPanel);
DeselectAll();
Select(annotation, true);
MakeMeCurrent(annotation);
if (logging)
{
/*Log the action.*/
char cmd[256];
char *d;
d = &(cmd[0]);
sprintf(cmd, "annotation ");
while (*d) ++d;
MakeObjectName(d, annotation);
while (*d) ++d;
sprintf(d, " [%g %g %g %g]\n",
bounds[0], bounds[1], bounds[2], bounds[3]);
Log(cmd);
}
}
}
}
}
void AddTimeReadout(name, bounds)
char *name;
real bounds[4];
/*Adds annotation with name and bounds to current window*/
{
if (selWinInfo)
{
/*Search for a space*/
ObjPtr space, frontPanel, list;
space = FindSpace(selWinInfo);
if (space)
{
frontPanel = GetObjectVar("AddTimeReadout", space, FRONTPANEL);
if (frontPanel)
{
/*There's a front panel. Stick a time readout there*/
ObjPtr timeReadout;
++nTimeReadout;
timeReadout = NewTimeReadout((int) bounds[0], (int) bounds[1], (int) bounds[2], (int) bounds[3],
name, space);
SetMethod(timeReadout, CLONE, CloneTimeReadout);
SetMethod(timeReadout, DUPLICATE, DuplicateDrawing);
PrefixList(GetVar(frontPanel, CONTENTS), timeReadout);
SetVar(timeReadout, PARENT, frontPanel);
SetTextColor(timeReadout, NewInt(UIWHITE));
ImInvalid(timeReadout);
SetTextFont(timeReadout, ANNOTFONT);
SetTextSize(timeReadout, ANNOTFONTSIZE);
SetVar(timeReadout, STICKINESS, NewInt(FLOATINGLEFT + FLOATINGRIGHT + FLOATINGTOP + FLOATINGBOTTOM));
SetMethod(timeReadout, DELETEICON, DeleteSpacePanelText);
SetMethod(timeReadout, DELETE, DeleteObject);
SetMethod(timeReadout, PUSHTOBOTTOM, PushDrawingToBottom);
SetMethod(timeReadout, BRINGTOTOP, BringDrawingToTop);
SetMethod(timeReadout, MOVETOBACKPANEL, MoveDrawingToBackPanel);
SetMethod(timeReadout, MOVETOFRONTPANEL, MoveDrawingToFrontPanel);
list = NewList();
PrefixList(list, NewSymbol(BOUNDS));
PrefixList(list, NewSymbol(TEXTFONT));
PrefixList(list, NewSymbol(TEXTSIZE));
PrefixList(list, NewSymbol(ALIGNMENT));
SetVar(timeReadout, SNAPVARS, list);
DeselectAll();
Select(timeReadout, true);
if (logging)
{
/*Log the action.*/
char cmd[256];
char *d;
d = &(cmd[0]);
sprintf(cmd, "timereadout ");
while (*d) ++d;
MakeObjectName(d, timeReadout);
while (*d) ++d;
sprintf(d, " [%g %g %g %g]\n",
bounds[0], bounds[1], bounds[2], bounds[3]);
Log(cmd);
}
}
}
}
}
void AddRectangle(name, bounds)
char *name;
real bounds[4];
/*Adds rectangle with name and bounds to current window*/
{
if (selWinInfo)
{
/*Search for a space*/
ObjPtr space, frontPanel;
space = FindSpace(selWinInfo);
if (space)
{
frontPanel = GetObjectVar("AddRectangle", space, FRONTPANEL);
if (frontPanel)
{
/*There's a front panel. Stick a rectangle there*/
ObjPtr rectangle;
++nRect;
rectangle = NewRectangle((int) bounds[0], (int) bounds[1], (int) bounds[2], (int) bounds[3],
name);
PrefixList(GetVar(frontPanel, CONTENTS), rectangle);
SetVar(rectangle, PARENT, frontPanel);
ImInvalid(rectangle);
DeselectAll();
Select(rectangle, true);
if (logging)
{
/*Log the action.*/
char cmd[256];
char *d;
d = &(cmd[0]);
sprintf(cmd, "rectangle ");
while (*d) ++d;
MakeObjectName(d, rectangle);
while (*d) ++d;
sprintf(d, " [%g %g %g %g]\n",
bounds[0], bounds[1], bounds[2], bounds[3]);
Log(cmd);
}
}
}
}
}
void AddLine(name, x1, y1, x2, y2)
char *name;
int x1, y1, x2, y2;
/*Adds line with name and endpoints (x1, y1)-(x2, y2) to current window*/
{
if (selWinInfo)
{
/*Search for a space*/
ObjPtr space, frontPanel;
space = FindSpace(selWinInfo);
if (space)
{
frontPanel = GetObjectVar("AddLine", space, FRONTPANEL);
if (frontPanel)
{
/*There's a front panel. Stick a line there*/
ObjPtr line;
++nLine;
line = NewLine(x1, y1, x2, y2, name);
PrefixList(GetVar(frontPanel, CONTENTS), line);
SetVar(line, PARENT, frontPanel);
ImInvalid(line);
DeselectAll();
Select(line, true);
if (logging)
{
/*Log the action.*/
char cmd[256];
char *d;
d = &(cmd[0]);
sprintf(cmd, "line ");
while (*d) ++d;
MakeObjectName(d, line);
while (*d) ++d;
sprintf(d, " %d %d %d %d\n",
x1, y1, x2, y2);
Log(cmd);
}
}
}
}
}
static void DoTogglePanel()
/*Toggles the panel of the controls on the top window.*/
{
if (selWinInfo)
{
if (GetPredicate((ObjPtr) selWinInfo, PANELHIDDEN))
{
DoShowPanel();
}
else
{
DoHidePanel();
}
}
}
void DoShowControls()
/*Shows the controls in the selected objects in the window*/
{
DoObjFunction(OF_SHOW_CONTROLS);
}
ObjPtr MakeLocalCopy(object)
ObjPtr object;
/*Makes a local copy of an object*/
{
object = ObjectWhichRepresents(selWinInfo, object);
if (object && IsIcon(object))
{
ObjPtr repObj, newObj;
FuncTyp method;
repObj = GetVar(object, REPOBJ);
if (repObj)
{
ObjPtr contentsList, corral = NULLOBJ;
contentsList = GetVar(object, PARENT);
if (contentsList || !IsList(contentsList))
{
contentsList = GetVar(contentsList, CONTENTS);
}
if (!contentsList || !IsList(contentsList))
{
ReportError("MakeLocalCopy","Internal error: cannot find contents list");
}
if (contentsList)
{
corral = contentsList;
while (corral && !IsCorral(corral))
{
corral = GetVar(corral, PARENT);
}
}
if (!corral)
{
ReportError("MakeLocalCopy", "Cannot find local corral");
}
method = GetMethodSurely("MakeLocalCopy", repObj, CLONE);
if (!method)
{
return ObjFalse;
}
method = GetMethod(object, DELETEICON);
if (method)
{
if (IsTrue((*method)(object)))
{
if (contentsList && IsList(contentsList))
{
ImInvalid(corral);
DeleteFromList(contentsList, object);
}
}
}
method = GetMethod(repObj, CLONE);
if (method)
{
ObjPtr name;
newObj = (*method)(repObj);
object = Clone(object);
SetVar(object, REPOBJ, newObj);
MakeVar(newObj, NAME);
name = GetVar(newObj, NAME);
SetVar(object, NAME, object);
SetVar(object, SELECTED, ObjFalse);
}
method = GetMethod(corral, DROPINCONTENTS);
if (method)
{
ObjPtr locArray;
int x, y;
real loc[2];
locArray = GetVar(object, ICONLOC);
if (locArray)
{
Array2CArray(loc, locArray);
x = loc[0];
y = loc[1];
}
else
{
x = y = 0;
}
(*method)(corral, object, x, y);
}
return ObjTrue;
}
}
return ObjFalse;
}
ObjPtr CloneObject(object)
ObjPtr object;
/*Clones an individual object*/
{
object = ObjectWhichRepresents(selWinInfo, object);
if (object && IsIcon(object))
{
ObjPtr repObj, newVis;
FuncTyp method;
repObj = GetVar(object, REPOBJ);
if (repObj && !GetPredicate(repObj, ONEONLY))
{
ObjPtr corral = NULLOBJ;
corral = GetVar(object, PARENT);
if (corral)
{
while (corral && !IsCorral(corral))
{
corral = GetVar(corral, PARENT);
}
}
if (!corral)
{
ReportError("CloneObject", "Cannot find local corral");
return ObjFalse;
}
method = GetMethodSurely("CloneObject", repObj, CLONE);
if (!method)
{
return ObjFalse;
}
newVis = (*method)(repObj);
SetVar(newVis, SELECTED, ObjFalse);
if (IsController(newVis))
{
AddControllerToSpace(newVis, FindSpace(selWinInfo), corral, NULLOBJ);
ImInvalid(newVis);
}
else
{
IdleAllWindows();
AddObjToSpace(newVis, FindSpace(selWinInfo), corral, NULLOBJ, NULLOBJ);
}
return ObjTrue;
}
}
return ObjFalse;
}
int vwSerialNumber = 0;
void NewSerializedVisWindow()
/*Creates a new, serialized visualization window*/
{
WinInfoPtr visWindow;
/*Create a vis window*/
sprintf(tempStr, "Visualization %d", ++vwSerialNumber);
visWindow = NewVisWindow(tempStr, WINDBUF + WINZBUF + WINRGB);
}
int vawSerialNumber;
void DoShowFrontPanelControls()
/*Shows the controls for the front panel in the selected vis window*/
{
ObjPtr space, panel;
if (!selWinInfo)
{
return;
}
space = FindSpace(selWinInfo);
if (!space)
{
return;
}
panel = GetVar(space, FRONTPANEL);
if (!panel)
{
return;
}
if (logging)
{
Log("show front panel controls\n");
InhibitLogging(true);
}
NewControlWindow(panel);
if (logging)
{
InhibitLogging(false);
}
}
void DoShowBackPanelControls()
/*Shows the controls for the back panel in the selected vis window*/
{
ObjPtr space, panel;
if (!selWinInfo)
{
return;
}
space = FindSpace(selWinInfo);
if (!space)
{
return;
}
panel = GetVar(space, BACKPANEL);
if (!panel)
{
return;
}
if (logging)
{
Log("show back panel controls\n");
InhibitLogging(true);
}
NewControlWindow(panel);
if (logging)
{
InhibitLogging(false);
}
}
void DoShowSpaceControls()
/*Shows the controls for the space in the selected vis window*/
{
ObjPtr space;
if (!selWinInfo)
{
return;
}
space = FindSpace(selWinInfo);
if (!space)
{
return;
}
if (logging)
{
Log("show space controls\n");
InhibitLogging(true);
}
NewControlWindow(space);
if (logging)
{
InhibitLogging(false);
}
}
#define MINANNOTSIZE 40
#define MINRECTSIZE 0
#define MINLINESIZE 0
static ObjPtr DeleteClockReadout(readout)
ObjPtr readout;
/*Deletes a clock readout from a space*/
{
return ObjTrue;
}
static ObjPtr MakeClockValue(clockDisplay)
ObjPtr clockDisplay;
/*Makes the VALUE of a clock display*/
{
ObjPtr space, timeObj, format;
real time;
char s[400];
space = GetObjectVar("MakeClockValue", clockDisplay, SPACE);
if (!space)
{
return ObjFalse;
}
MakeVar(space, TIME);
timeObj = GetVar(space, TIME);
if (!timeObj)
{
time = 0.0;
}
else
{
time = GetReal(timeObj);
}
format = GetVar(clockDisplay, FORMAT);
if (format)
{
PrintClock(s, GetString(format), time);
}
else
{
sprintf(s, "%#.2f", time);
}
SetVar(clockDisplay, VALUE, NewString(s));
return ObjTrue;
}
ObjPtr ChangeClockDisplayFormat(textBox)
ObjPtr textBox;
/*Changes a clock display's FORMAT according to textBox*/
{
ObjPtr repObj;
repObj = GetObjectVar("ChangeClockFormat", textBox, REPOBJ);
if (!repObj) return ObjFalse;
SetVar(repObj, FORMAT, GetValue(textBox));
ImInvalid(repObj);
return ObjTrue;
}
static ObjPtr ShowClockDisplayControls(display, windowName)
ObjPtr display;
char *windowName;
/*Makes a new control window to control a clock display*/
{
WinInfoPtr controlWindow;
ObjPtr var;
ObjPtr panel;
ObjPtr corral;
ObjPtr contents;
real rgb[3], hsv[3];
WinInfoPtr dialogExists;
Bool hasBackground;
dialogExists = DialogExists((WinInfoPtr) display, NewString("Controls"));
controlWindow = GetDialog((WinInfoPtr) display, NewString("Controls"), windowName,
CDWINWIDTH, CDWINHEIGHT, CDWINWIDTH,
CDWINHEIGHT, WINDBUF + WINFIXEDSIZE);
if (!dialogExists)
{
long info;
ObjPtr value;
ObjPtr format;
ObjPtr checkBox, icon, name, colorBar, titleBox, textBox, button;
ObjPtr colorWheel, slider, radioGroup;
int left, right, bottom, top;
SetVar((ObjPtr) controlWindow, REPOBJ, display);
/*Set help string*/
SetVar((ObjPtr) controlWindow, HELPSTRING, NewString("This window \
shows controls for a clock display. For information about any of the controls \
in the window, use Help In Context on the control.\n"));
/*Add in a panel*/
panel = NewPanel(greyPanelClass, 0, CDWINWIDTH, 0, CDWINHEIGHT);
if (!panel)
{
return NULLOBJ;
}
contents = GetVar((ObjPtr) controlWindow, CONTENTS);
PrefixList(contents, panel);
SetVar(panel, PARENT, (ObjPtr) controlWindow);
ContentsExpectWindowSize(controlWindow, CDWINWIDTH, CDWINHEIGHT);
contents = GetVar(panel, CONTENTS);
/*Add in the group of controls for text color*/
left = MINORBORDER;
top = CDWINHEIGHT - MINORBORDER;
right = left + 2 * MINORBORDER + 2 * MAJORBORDER + COLORWHEELWIDTH + SLIDERWIDTH;
titleBox = NewTitleBox(left, right,
top - TITLEBOXTOP - MINORBORDER - 2 * MINORBORDER - COLORWHEELWIDTH
- CHECKBOXHEIGHT - TEXTBOXHEIGHT - TEXTBOXSEP,
top, "Text");
SetVar(titleBox, PARENT, panel);
PrefixList(contents, titleBox);
left += MINORBORDER;
right -= MINORBORDER;
top -= TITLEBOXTOP + MINORBORDER;
/*Get the color for priming the controls*/
var = GetVar(display, COLOR);
if (IsArray(var) && RANK(var) == 1 && DIMS(var)[0] == 3)
{
Array2CArray(rgb, var);
}
else if (IsInt(var))
{
rgb[0] = uiColors[GetInt(var)][0] / 255.0;
rgb[1] = uiColors[GetInt(var)][1] / 255.0;
rgb[2] = uiColors[GetInt(var)][2] / 255.0;
}
else
{
ReportError("ShowClockDisplayControls", "Bad color");
rgb[0] = rgb[1] = rgb[2] = 1.0;
}
RGB2HSV(&(hsv[0]), &(hsv[1]), &(hsv[2]), (rgb[0]), (rgb[1]), (rgb[2]));
/*Make the color wheel*/
colorWheel = NewColorWheel(left, left + COLORWHEELWIDTH,
top - COLORWHEELWIDTH, top, "Text Color");
var = NewRealArray(1, 2L);
CArray2Array(var, hsv);
SetValue(colorWheel, var);
SetVar(colorWheel, PARENT, panel);
SetVar(colorWheel, REPOBJ, display);
PrefixList(contents, colorWheel);
SetMethod(colorWheel, CHANGEDVALUE, ChangeTextColorWheel);
SetVar(colorWheel, HELPSTRING, NewString("This color wheel controls the \
hue and saturation of the color used to draw the text in the clock display. \
The final color is a combination of this hue and saturation and the value, or brightness, \
given by the Value slider."));
/*Make the text box below*/
textBox = NewTextBox(left, left + COLORWHEELWIDTH,
top - COLORWHEELWIDTH - TEXTBOXSEP - TEXTBOXHEIGHT,
top - COLORWHEELWIDTH - TEXTBOXSEP,
PLAIN, "Text Color Label", "Color");
SetVar(textBox, PARENT, panel);
PrefixList(contents, textBox);
SetTextAlign(textBox, CENTERALIGN);
/*Make the brightness slider*/
slider = NewSlider(right - SLIDERWIDTH, right,
top - COLORWHEELWIDTH, top,
PLAIN, "Text Color Value");
SetVar(slider, PARENT, panel);
PrefixList(contents, slider);
SetSliderRange(slider, 1.0, 0.0, 0.0);
SetSliderValue(slider, hsv[2]);
SetVar(slider, REPOBJ, display);
SetMethod(slider, CHANGEDVALUE, ChangeTextColorSlider);
SetVar(slider, HELPSTRING, NewString("This slider controls the \
value, or brightness, of the color used to draw the text in the clock display. \
The final color is a combination of this value and the hue and saturation \
given by the Color color wheel."));
/*Make the text box below*/
textBox = NewTextBox(right - SLIDERWIDTH - MINORBORDER, right + MINORBORDER,
top - COLORWHEELWIDTH - TEXTBOXSEP - TEXTBOXHEIGHT,
top - COLORWHEELWIDTH - TEXTBOXSEP,
PLAIN, "Text Value Label", "Value");
SetVar(textBox, PARENT, panel);
PrefixList(contents, textBox);
SetTextAlign(textBox, CENTERALIGN);
/*Cross link the slider and color wheel*/
SetVar(colorWheel, SLIDER, slider);
SetVar(slider, COLORWHEEL, colorWheel);
left -= MINORBORDER;
right += MINORBORDER;
/*Make the background controls*/
top = CDWINHEIGHT - MINORBORDER;
right = CDWINWIDTH - MINORBORDER;
left = right - (2 * MINORBORDER + 2 * MAJORBORDER + COLORWHEELWIDTH + SLIDERWIDTH);
titleBox = NewTitleBox(left, right,
top - TITLEBOXTOP - MINORBORDER - 2 * MINORBORDER - COLORWHEELWIDTH
- CHECKBOXHEIGHT - TEXTBOXHEIGHT - TEXTBOXSEP,
top, "Background");
SetVar(titleBox, PARENT, panel);
PrefixList(contents, titleBox);
left += MINORBORDER;
right -= MINORBORDER;
top -= TITLEBOXTOP + MINORBORDER;
/*Get the color for priming the controls*/
var = GetVar(display, BACKGROUND);
if (var && IsArray(var) && RANK(var) == 1 && DIMS(var)[0] == 3)
{
Array2CArray(rgb, var);
hasBackground = true;
}
else if (var && IsInt(var))
{
rgb[0] = uiColors[GetInt(var)][0] / 255.0;
rgb[1] = uiColors[GetInt(var)][1] / 255.0;
rgb[2] = uiColors[GetInt(var)][2] / 255.0;
hasBackground = true;
}
else
{
rgb[0] = rgb[1] = rgb[2] = 0.5;
hasBackground = false;
}
RGB2HSV(&(hsv[0]), &(hsv[1]), &(hsv[2]), (rgb[0]), (rgb[1]), (rgb[2]));
/*Make the color wheel*/
colorWheel = NewColorWheel(left, left + COLORWHEELWIDTH,
top - COLORWHEELWIDTH, top, "Background Color");
var = NewRealArray(1, 2L);
CArray2Array(var, hsv);
SetValue(colorWheel, var);
SetVar(colorWheel, PARENT, panel);
SetVar(colorWheel, REPOBJ, display);
PrefixList(contents, colorWheel);
SetMethod(colorWheel, CHANGEDVALUE, ChangeBackgroundColorWheel);
SetVar(colorWheel, HELPSTRING, NewString("This color wheel controls the \
hue and saturation of the color used to draw the background of the clock display. \
The final color is a combination of this hue and saturation and the value, or brightness, \
given by the Value slider."));
/*Make the text box below*/
textBox = NewTextBox(left, left + COLORWHEELWIDTH,
top - COLORWHEELWIDTH - TEXTBOXSEP - TEXTBOXHEIGHT,
top - COLORWHEELWIDTH - TEXTBOXSEP,
PLAIN, "Background Color Label", "Color");
SetVar(textBox, PARENT, panel);
PrefixList(contents, textBox);
SetTextAlign(textBox, CENTERALIGN);
/*Make the brightness slider*/
slider = NewSlider(right - SLIDERWIDTH, right,
top - COLORWHEELWIDTH, top,
PLAIN, "Background Value");
SetVar(slider, PARENT, panel);
PrefixList(contents, slider);
SetSliderRange(slider, 1.0, 0.0, 0.0);
SetSliderValue(slider, hsv[2]);
SetVar(slider, REPOBJ, display);
SetMethod(slider, CHANGEDVALUE, ChangeBackgroundColorSlider);
SetVar(slider, HELPSTRING, NewString("This slider controls the \
value, or brightness, of the color used to draw the background of the clock display. \
The final color is a combination of this value and the hue and saturation \
given by the Color color wheel."));
/*Make the text box below*/
textBox = NewTextBox(right - SLIDERWIDTH - MINORBORDER, right + MINORBORDER,
top - COLORWHEELWIDTH - TEXTBOXSEP - TEXTBOXHEIGHT,
top - COLORWHEELWIDTH - TEXTBOXSEP,
PLAIN, "Background Value Label", "Value");
SetVar(textBox, PARENT, panel);
PrefixList(contents, textBox);
SetTextAlign(textBox, CENTERALIGN);
/*Cross link the slider and color wheel*/
SetVar(colorWheel, SLIDER, slider);
SetVar(slider, COLORWHEEL, colorWheel);
/*Make the check box*/
top -= COLORWHEELWIDTH + TEXTBOXSEP + TEXTBOXHEIGHT + MINORBORDER;
checkBox = NewCheckBox(left, right,
top - CHECKBOXHEIGHT, top,
"No background", hasBackground ? false : true);
SetVar(checkBox, PARENT, panel);
SetVar(checkBox, REPOBJ, display);
SetVar(checkBox, SLIDER, slider);
SetVar(checkBox, COLORWHEEL, colorWheel);
PrefixList(contents, checkBox);
SetMethod(checkBox, CHANGEDVALUE, ChangeNoBackground);
SetVar(checkBox, HELPSTRING, NewString("This checkbox controls whether \
a background is shown. If it is selected, no background is shown, and the \
objects behind can be seen."));
/*Link the checkbox to the slider and color wheel*/
SetVar(colorWheel, CHECKBOX, checkBox);
SetVar(slider, CHECKBOX, checkBox);
top -= CHECKBOXHEIGHT + MINORBORDER + MAJORBORDER;
left = MINORBORDER;
right = CDWINWIDTH - MINORBORDER;
/*Create the format text box*/
textBox = NewTextBox(left, left + CDFORMATLABELWIDTH,
top - EDITBOXHEIGHT + (EDITBOXHEIGHT - TEXTBOXHEIGHT) / 2,
top - (EDITBOXHEIGHT - TEXTBOXHEIGHT) / 2,
PLAIN, "Format:", "Format:");
PrefixList(contents, textBox);
SetVar(textBox, PARENT, panel);
/*Create the format editable text box*/
left = left + CDFORMATLABELWIDTH;
format = GetVar(display, FORMAT);
textBox = NewTextBox(left, right,
top - EDITBOXHEIGHT,
top,
EDITABLE + WITH_PIT + ONE_LINE, "Format",
format ? GetString(format) : "%#.2t");
PrefixList(contents, textBox);
SetVar(textBox, PARENT, panel);
SetVar(textBox, REPOBJ, display);
SetVar(textBox, HELPSTRING, NewString(
"This text box contains the format used to print the current time in \
the time readout. It works very much like printf with the special conversion \
characters listed below. Flags and field widths are exactly as in printf. \
All times are printed as real numbers, so you may need to limit the number \
of decimal places. \
There may be several conversions in one string, in which case, all will refer \
to the same time. Hours and minutes are derives from the internal time specified in seconds.\n\
\n\
%h\t\tPrint the number of hours, from 1 to 12.\n\
%H\t\tPrint the number of hours, from 0 to 23.\n\
%m\t\tPrint the number of minutes, from 0 to 59.\n\
%M\t\tPrint the total number of minutes.\n\
%s\t\tPrint the number of seconds from 0 to 59.\n\
%S\t\tPrint the time in seconds.\n\
%t\t\tPrint the time in timesteps. For this to work properly, \
each time step of data must have a time equal to the number of the time step.\n\
\n\
Examples for time = 43440 seconds:\n\
Format\t\t\t\tResult\t\tExplanation\n\
%.0t\t\t\t\t43440\t\tThe time is printed in seconds with no decimal places.\n\
%2.0h:%02.0m %a\t\t\t\t12:04 pm\t\tThe time is assumed to be 43440 seconds after \
midnight and is converted into 12-hour format.\n\
%.2M\t\t\t\t724.00\t\tThe time is printed in minutes with 2 decimal places."));
SetMethod(textBox, CHANGEDVALUE, ChangeClockDisplayFormat);
}
return (ObjPtr) controlWindow;
}
#ifdef PROTO
static ObjPtr NewTimeReadout(int left, int right, int bottom, int top, char *name, ObjPtr space)
#else
static ObjPtr NewTimeReadout(left, right, bottom, top, name, space)
int left, right, bottom, top;
char *name;
ObjPtr space;
#endif
{
ObjPtr clockThere;
clockThere = NewTextBox(left, right, bottom, top, ADJUSTABLE, name, "");
SetMethod(clockThere, DELETEICON, DeleteClockReadout);
DeclareDependency(clockThere, VALUE, FORMAT);
SetVar(clockThere, SPACE, space);
DeclareIndirectDependency(clockThere, VALUE, SPACE, TIME);
SetMethod(clockThere, NEWCTLWINDOW, ShowClockDisplayControls);
SetMethod(clockThere, VALUE, MakeClockValue);
SetVar(clockThere, FORMAT, NewString("%#.2t"));
SetVar(clockThere, HELPSTRING, NewString("This time readout displays the time \
given by the clock in this space. The display format is controlled by the Format \
text box in the readout's control panel.\n"));
return clockThere;
}
#ifdef INTERACTIVE
static ObjPtr PressSpacePanel(object, x, y, flags)
ObjPtr object;
int x, y;
long flags;
/*Does a press in a field beginning at x and y. Returns
true iff the press really was in the field.*/
{
int left, right, bottom, top;
FuncTyp pressContents; /*Routine to press the contents*/
Get2DIntBounds(object, &left, &right, &bottom, &top);
if (x >= left && x <= right && y >= bottom && y <= top)
{
/*Hey! It really was a click in the field*/
ObjPtr space;
int tool;
ObjPtr contents;
ObjPtr retVal = ObjFalse;
contents = GetVar(object, CONTENTS);
if (TOOL(flags) == T_HELP)
{
StartPanel(left, right, bottom, top);
retVal = PressObject(contents, x, y, flags);
StopPanel();
return retVal;
}
if (flags & F_OPTIONDOWN)
{
/*Ignore press if this is the front panel*/
if (GetPredicate(object, FRONTPANEL))
{
return ObjFalse;
}
}
if (TOOL(flags) == T_ROTATE) flags |= F_SHIFTDOWN;
SetScreenGrid(object);
/*See if it's a dragBuffer click*/
if (dragBuffer)
{
/*Yes it is. Move dragBuffer and exit*/
dropObject = dragBuffer;
dragBuffer = NULLOBJ;
return ObjTrue;
}
/*Setup the new viewport*/
StartPanel(left, right, bottom, top);
x -= left;
y -= bottom;
tool = ST_FINGER;
space = GetVar(object, SPACE);
if (space)
{
ObjPtr var;
var = GetVar(space, EDITTOOL);
if (var)
{
tool = GetInt(var);
}
}
if (TOOL(flags) == T_HELP)
{
tool = ST_FINGER;
}
switch (tool)
{
case ST_FINGER:
retVal = PressObject(contents, x, y, flags);
if (TOOL(flags) == T_HELP && !IsTrue(retVal))
{
ContextHelp(object);
StopPanel();
return ObjTrue;
}
else if (!IsTrue(retVal))
{
{
StopPanel();
if (!GetPredicate(object, FRONTPANEL))
{
ObjPtr space;
if (0 == (flags & F_SHIFTDOWN))
{
DeselectAll();
}
/*Return press to space*/
space = GetVar(object, SPACE);
if (TOOL(flags) == T_ROTATE)
{
RotateSpace(space, x + left, y + bottom, flags);
}
else
{
MoveSpace(space, x + left, y + bottom, flags);
}
return ObjTrue;
}
else
{
return ObjFalse;
}
}
}
retVal = ObjTrue;
break;
case ST_ANNOTATION:
case ST_RECTANGLE:
case ST_LINE:
case ST_TIME_READOUT:
{
char name[30];
int l, r, b, t;
int minSize;
ObjPtr boundsArray;
ObjPtr screenObject;
int startX, startY, newX, newY, endX, endY;
if (flags & F_SHIFTDOWN)
{
x = GRIDX(x);
y = GRIDY(y);
}
startX = x;
startY = y;
if (tool == ST_ANNOTATION || tool == ST_TIME_READOUT)
{
minSize = MINANNOTSIZE;
}
else if (tool == ST_RECTANGLE)
{
minSize = MINRECTSIZE;
}
else if (tool == ST_LINE)
{
minSize = MINLINESIZE;
}
l = startX - HANDLESIZE / 2;
r = startX + minSize + HANDLESIZE / 2;
b = startY - minSize - HANDLESIZE / 2;
t = startY + HANDLESIZE / 2;
if (tool == ST_ANNOTATION)
{
sprintf(name, "Annotation %d", nAnnot++);
screenObject = NewTextBox(l, r, b, t,
/*WITH_BG + */EDITABLE + ADJUSTABLE, name, "");
SetMethod(screenObject, CLONE, CloneAnnotation);
SetMethod(screenObject, DUPLICATE, DuplicateDrawing);
SetMethod(screenObject, PUSHTOBOTTOM, PushDrawingToBottom);
SetMethod(screenObject, BRINGTOTOP, BringDrawingToTop);
SetMethod(screenObject, MOVETOBACKPANEL, MoveDrawingToBackPanel);
SetMethod(screenObject, MOVETOFRONTPANEL, MoveDrawingToFrontPanel);
}
else if (tool == ST_TIME_READOUT)
{
sprintf(name, "Time Readout %d", nTimeReadout++);
screenObject = NewTimeReadout(l, r, b, t, name, space);
SetMethod(screenObject, CLONE, CloneTimeReadout);
SetMethod(screenObject, DUPLICATE, DuplicateDrawing);
SetMethod(screenObject, PUSHTOBOTTOM, PushDrawingToBottom);
SetMethod(screenObject, BRINGTOTOP, BringDrawingToTop);
SetMethod(screenObject, MOVETOBACKPANEL, MoveDrawingToBackPanel);
SetMethod(screenObject, MOVETOFRONTPANEL, MoveDrawingToFrontPanel);
}
else if (tool == ST_RECTANGLE)
{
sprintf(name, "Rectangle %d", nRect++);
screenObject = NewRectangle(l, r, b, t, name);
}
else if (tool == ST_LINE)
{
sprintf(name, "Line %d", nLine++);
screenObject = NewLine(startX, startY, startX, startY, name);
}
SetVar(screenObject, STICKINESS, NewInt(FLOATINGLEFT + FLOATINGRIGHT + FLOATINGTOP + FLOATINGBOTTOM));
PrefixList(contents, screenObject);
SetVar(screenObject, PARENT, object);
if (tool == ST_ANNOTATION)
{
SetTextColor(screenObject, NewInt(UIWHITE));
ImInvalid(screenObject);
SetTextFont(screenObject, ANNOTFONT);
SetTextSize(screenObject, ANNOTFONTSIZE);
SetMethod(screenObject, DELETEICON, DeleteSpacePanelText);
SetMethod(screenObject, DELETE, DeleteObject);
}
else if (tool == ST_TIME_READOUT)
{
SetTextColor(screenObject, NewInt(UIWHITE));
ImInvalid(screenObject);
SetTextFont(screenObject, ANNOTFONT);
SetTextSize(screenObject, ANNOTFONTSIZE);
SetMethod(screenObject, DELETEICON, DeleteClockReadout);
SetMethod(screenObject, DELETE, DeleteObject);
}
if (tool == ST_ANNOTATION || tool == ST_TIME_READOUT)
{
InhibitLogging(true);
Select(screenObject, true);
InhibitLogging(false);
}
/*Set up to draw in the overlay area*/
DrawSkeleton(true);
DrawMe(screenObject);
while (Mouse(&newX, &newY))
{
if (tool == ST_ANNOTATION ||
tool == ST_TIME_READOUT ||
tool == ST_RECTANGLE ||
tool == ST_LINE)
{
if (newX >= startX && newX - startX < minSize)
{
newX = startX + minSize;
}
else if (newX < startX && startX - newX < minSize)
{
newX = startX - minSize;
}
if (newY >= startY && newY - startY < minSize)
{
newY = startY + minSize;
}
else if (newY < startY && startY - newY < minSize)
{
newY = startY - minSize;
}
}
if (flags & F_SHIFTDOWN)
{
newX = GRIDX(newX);
newY = GRIDY(newY);
}
if (newX != x || newY != y)
{
x = newX;
y = newY;
Set2DIntBounds(screenObject,
MIN(startX, x) - HANDLESIZE / 2,
MAX(startX, x) + HANDLESIZE / 2,
MIN(startY, y) - HANDLESIZE / 2,
MAX(startY, y) + HANDLESIZE / 2);
if (tool == ST_LINE)
{
ObjPtr var;
real loc[2];
loc[0] = newX;
loc[1] = newY;
var = NewRealArray(1, 2L);
CArray2Array(var, loc);
SetVar(screenObject, ENDPOINT, var);
}
DrawMe(screenObject);
}
}
DrawSkeleton(false);
Get2DIntBounds(screenObject, &l, &r, &b, &t);
if (logging)
{
/*Log the action.*/
char cmd[256];
char *d, *s;
s = name;
d = &(cmd[0]);
if (tool == ST_ANNOTATION)
{
strcpy(cmd, "annotation ");
}
else if (tool == ST_RECTANGLE)
{
strcpy(cmd, "rectangle ");
}
else if (tool == ST_LINE)
{
strcpy(cmd, "line ");
}
else if (tool == ST_TIME_READOUT)
{
strcpy(cmd, "timereadout ");
}
while (*d) ++d;
MakeObjectName(d, screenObject);
while (*d) ++d;
if (tool == ST_LINE)
{
sprintf(d, " %d %d %d %d\n",
startX, startY, x, y);
}
else
{
sprintf(d, " [%d %d %d %d]\n",
l, r, b, t);
}
Log(cmd);
if (flags & F_OPTIONDOWN)
{
strcpy(d, "move ");
d = &(cmd[0]);
while (*d) ++d;
MakeObjectName(d, screenObject);
while (*d) ++d;
strcpy(d, " to back panel\n");
Log(cmd);
}
}
SetValue(GetVar(space, TOOLGROUP), NewInt(ST_FINGER));
if (!(flags & F_SHIFTDOWN))
{
DeselectAll();
IdleAllWindows();
}
Select(screenObject, true);
if (tool == ST_ANNOTATION)
{
MakeMeCurrent(screenObject);
}
}
retVal = ObjTrue;
break;
}
StopPanel();
return retVal;
}
else
{
return ObjFalse;
}
}
#endif
void SetupVisualizeAsList()
{
EmptyList(visualizeAsList);
}
void AddToVisualizeAsList(object)
ObjPtr object;
{
PostfixList(visualizeAsList, object);
}
void EmptyVisualizeAsList()
{
EmptyList(visualizeAsList);
}
ObjPtr ChangeCorralButton(object)
ObjPtr object;
/*Changedvalue for a corral button*/
{
ObjPtr corral, parent, value, curButton;
value = GetValue(object);
parent = GetObjectVar("ChangeCorralButton", object, PARENT);
if (!parent) return ObjFalse;
corral = GetObjectVar("ChangeCorralButton", object, CORRAL);
if (!corral) return ObjFalse;
curButton = GetVar(parent, BUTTON);
if (value && IsInt(value) && 0 == GetInt(value) && curButton != object)
{
SetVar(corral, CONTENTS, GetVar(object, PANELCONTENTS));
if (curButton)
{
SetVar(curButton, VALUE, NewInt(0));
}
SetVar(object, VALUE, NewInt(1));
SetVar(parent, BUTTON, object);
ImInvalid(corral);
return ObjTrue;
}
else
{
return ObjTrue;
}
}
void NewVisAsWindow()
/*Brings up a new, empty visAs window*/
{
WinInfoPtr newWindow;
ObjPtr objList, contents, fieldContents;
ObjPtr corral, panel, button, icon;
ObjPtr textBox;
ObjPtr controlField;
ThingListPtr runner;
int whichIcon;
int bw;
char *name;
ObjPtr var;
int x;
int l, r, b, t;
/*Create a vis as window*/
sprintf(tempStr, "Visualize As %d", ++vawSerialNumber);
newWindow = NewObjWindow(NULLOBJ, tempStr, WINDBUF,
VAWINWIDTH, VAWINHEIGHT, SCRWIDTH, SCRHEIGHT);
SetVar((ObjPtr) newWindow, HELPSTRING,
NewString("This window shows all the possible ways to visualize a \
group of datasets."));
ContentsExpectWindowSize(newWindow, VAWINWIDTH, VAWINHEIGHT);
/*Put in a panel*/
panel = NewPanel(greyPanelClass, 0, VAWINWIDTH, 0, VAWINHEIGHT);
SetVar(panel, STICKINESS, NewInt(STICKYLEFT + STICKYRIGHT +
STICKYBOTTOM + STICKYTOP));
contents = GetVar((ObjPtr) newWindow, CONTENTS);
PrefixList(contents, panel);
SetVar(panel, PARENT, (ObjPtr) newWindow);
/*Put in contents*/
contents = GetListVar("NewVisAsWindow", panel, CONTENTS);
if (!contents)
{
return;
}
/*Explanatory text at top*/
textBox = TemplateTextBox(VisAsTemplate, "Visualize As String", 0, "Visualize datasets as...");
PrefixList(contents, textBox);
SetVar((ObjPtr) newWindow, TITLETEXT, textBox);
SetVar(textBox, PARENT, panel);
/*Icon corral*/
corral = TemplateIconCorral(VisAsTemplate, "Visualizations Corral", NULLOBJ,
OBJECTSFROMTOP + BARRIGHT + BARBOTTOM);
SetVar(corral, STICKINESS, NewInt(STICKYLEFT + STICKYRIGHT +
STICKYBOTTOM + STICKYTOP));
SetVar((ObjPtr) newWindow, CORRAL, corral);
SetVar(corral, HELPSTRING,
NewString("This corral contains icons for all possible visualizations of a group of \
datasets. You can visualize or show info on the visualizations by selecting \
some of them and pressing the buttons at the bottom of the window. You can delete \
visualizations by selecting them and choosing Delete from the Object menu."));
PrefixList(contents, corral);
SetVar(corral, PARENT, panel);
SetVar((ObjPtr) newWindow, CORRAL, corral);
/*Control field*/
controlField = TemplateControlField(VisAsTemplate, "Visualization Type Field",
BARBOTTOM);
SetVar(controlField, STICKINESS, NewInt(STICKYLEFT + STICKYRIGHT + STICKYTOP));
SetVar(controlField, PARENT, panel);
PrefixList(contents, controlField);
SetVar((ObjPtr) newWindow, VISASFIELD, controlField);
/*Buttons in the control field*/
fieldContents = GetVar(controlField, CONTENTS);
runner = LISTOF(allVisObjClasses);
x = 0;
while (runner)
{
icon = GetVar(runner -> thing, DEFAULTICON);
var = GetIntVar("ShowVisControls", icon, WHICHICON);
if (var)
{
whichIcon = GetInt(var);
}
else
{
whichIcon = ICONQUESTION;
}
var = GetVar(runner -> thing, NAME);
if (var)
{
name = GetString(var);
}
else
{
name = "?";
}
/*Make a button*/
button = NewIconLabeledButton(x, x + VAWINICONBUTWIDTH, 0, CWINICONBUTHEIGHT,
whichIcon, UIYELLOW, name, BS_PITTED);
x += VAWINICONBUTWIDTH;
SetMethod(button, ICONEXTRADRAW, GetMethod(icon, ICONEXTRADRAW));
SetMethod(button, CHANGEDVALUE, ChangeCorralButton);
SetVar(button, CORRAL, corral);
PostfixList(fieldContents, button);
SetVar(button, PARENT, controlField);
runner = runner -> next;
}
RecalcScroll(controlField);
l = b = 0;
r = VAWINWIDTH;
t = VAWINHEIGHT;
l += MINORBORDER;
r -= MINORBORDER;
b += MINORBORDER;
t = b + BUTTONHEIGHT;
bw = (r - l - MINORBORDER) / 2;
/*Make a visualize button*/
button = NewFunctionButton(newWindow,
l, l + bw,
b, b + BUTTONHEIGHT, OF_VISUALIZE);
if (button)
{
SetVar(button, PARENT, panel);
SetVar(button, STICKINESS, NewInt(STICKYBOTTOM + STICKYLEFT + FLOATINGRIGHT));
PrefixList(contents, button);
}
/*Make a show info button*/
button = NewFunctionButton(newWindow,
r - bw,
r,
b, b + BUTTONHEIGHT, OF_SHOW_CONTROLS);
if (button)
{
SetVar(button, PARENT, panel);
SetVar(button, STICKINESS, NewInt(STICKYBOTTOM + FLOATINGLEFT + STICKYRIGHT));
PrefixList(contents, button);
}
/*Set up the list for modifications*/
SetupVisualizeAsList();
}
void ProcessVisAsList()
/*Processes the visualize as modification list*/
{
ObjPtr allFilters;
ThingListPtr visRunner, dataRunner, buttonRunner;
ObjPtr firstSuccessful;
ObjPtr contentsList, visList, var;
ObjPtr corral;
if (!selWinInfo)
{
return;
}
if (LISTOF(visualizeAsList))
{
/*There's at least one vis as*/
ObjPtr var, textBox;
if (LISTOF(visualizeAsList) -> next)
{
/*More than one, don't bother changing text */
}
else
{
var = GetVar(LISTOF(visualizeAsList) -> thing, NAME);
textBox = GetVar((ObjPtr) selWinInfo, TITLETEXT);
if (var && textBox)
{
sprintf(tempStr, "Visualize %s as...", GetString(var));
SetValue(textBox, NewString(tempStr));
}
}
}
/*Find all modifications for the list of filters*/
allFilters = AllEasyFilters(visualizeAsList);
corral = GetObjectVar("ProcessVisAsList", (ObjPtr) selWinInfo, CORRAL);
if (!corral) return;
var = GetObjectVar("ProcessVisAsList", (ObjPtr) selWinInfo, VISASFIELD);
if (!var) return;
var = GetListVar("ProcessVisAsList", var, CONTENTS);
if (!var) return;
buttonRunner = LISTOF(var);
/*Go through all the visualization objects*/
firstSuccessful = NULLOBJ;
visRunner = LISTOF(allVisObjClasses);
while (visRunner)
{
contentsList = NewList();
/*Do visualization just on normal data*/
dataRunner = LISTOF(visualizeAsList);
while (dataRunner)
{
visList = GetAllVis(dataRunner -> thing, false, visRunner -> thing);
if (visList)
{
ThingListPtr runner;
runner = LISTOF(visList);
while (runner)
{
ObjPtr vis, icon;
vis = runner -> thing;
if (vis)
{
SetVar(vis, TEMPLATEP, ObjTrue);
icon = NewVisIcon(vis);
if (icon)
{
ObjPtr format;
format = GetVar(icon, FORMAT);
if (format)
{
SetVar(icon, FORMAT, format);
}
SetVar(icon, CORRAL, corral);
SetVar(icon, ICONLOC, NULLOBJ);
PostfixList(contentsList, icon);
if (!firstSuccessful)
{
firstSuccessful = buttonRunner -> thing;
}
}
}
runner = runner -> next;
}
}
dataRunner = dataRunner -> next;
}
/*Do visualization on filtered data*/
if (allFilters)
{
dataRunner = LISTOF(allFilters);
while (dataRunner)
{
visList = GetAllVis(dataRunner -> thing, false, visRunner -> thing);
if (visList)
{
ThingListPtr runner;
runner = LISTOF(visList);
while (runner)
{
ObjPtr vis, icon;
vis = runner -> thing;
if (vis)
{
SetVar(vis, TEMPLATEP, ObjTrue);
icon = NewVisIcon(vis);
if (icon)
{
ObjPtr format;
format = GetVar(icon, FORMAT);
if (format)
{
SetVar(icon, FORMAT, format);
}
SetVar(icon, CORRAL, corral);
SetVar(icon, ICONLOC, NULLOBJ);
PostfixList(contentsList, icon);
if (!firstSuccessful)
{
firstSuccessful = buttonRunner -> thing;
}
}
}
runner = runner -> next;
}
}
dataRunner = dataRunner -> next;
}
}
SetVar(buttonRunner -> thing, PANELCONTENTS, contentsList);
buttonRunner = buttonRunner -> next;
visRunner = visRunner -> next;
}
if (firstSuccessful)
{
InhibitLogging(true);
SetValue(firstSuccessful, ObjTrue);
InhibitLogging(false);
}
EmptyVisualizeAsList();
}
void VisObjectsAs()
/*Opens a new VisObjectsAs window using default for all of the
selected objects.
*/
{
DoObjFunction(OF_VISUALIZE_AS);
}
static ObjPtr DropInVisCorral(corral, object, x, y)
ObjPtr corral, object;
int x, y;
/*Drops an icon in a vis corral*/
{
ObjPtr repObj;
repObj = GetVar(object, REPOBJ);
if (repObj)
{
real loc[2];
ObjPtr locArray;
loc[0] = x;
loc[1] = y;
locArray = NewRealArray(1, 2L);
CArray2Array(locArray, loc);
if (IsController(repObj))
{
AddControllerToSpace(repObj, FindSpace(selWinInfo), GetVar((ObjPtr) selWinInfo, CORRAL), locArray);
ImInvalid(repObj);
}
else
{
AddObjToSpace(repObj, FindSpace(selWinInfo), GetVar((ObjPtr) selWinInfo, CORRAL), locArray, NULLOBJ);
IdleAllWindows();
}
return ObjTrue;
}
else
{
return ObjFalse;
}
}
void ForAllVisWindows(routine)
void (*routine)();
/*Performs (*routine)(window) on all vis windows*/
{
WinInfoPtr curWindow;
curWindow = allWindows;
while (curWindow)
{
if (IsVisWindow((ObjPtr) curWindow))
{
(*routine)(curWindow);
}
curWindow = curWindow -> next;
}
}
void PushNonVisWindows()
/*Pushes all the non vis windows*/
{
#ifdef GRAPHICS
#ifdef WINDOWS4D
int maxDepth;
WinInfoPtr curWindow;
maxDepth = -1;
curWindow = allWindows;
while (curWindow)
{
if (IsVisWindow((ObjPtr) curWindow))
{
if ((curWindow) -> id)
{
maxDepth = MAX(maxDepth, windepth((curWindow) -> id));
}
}
curWindow = curWindow -> next;
}
curWindow = allWindows;
while (curWindow)
{
if (!IsVisWindow((ObjPtr) curWindow))
{
if ((curWindow) -> id && windepth((curWindow) -> id) < maxDepth)
{
SelWindow(curWindow);
--maxDepth;
winpush();
}
}
curWindow = curWindow -> next;
}
#endif
#endif
}
void Tile(width, height)
int width, height;
/*Tiles all the vis windows in the lower left corner as big as width, height*/
{
#ifdef GRAPHICS
#ifdef WINDOWS4D
int nWide, nHigh; /*# of windows wide and high*/
int i, j;
int nVisWindows;
WinInfoPtr curWindow;
long oldWindow;
if (logging)
{
char cmd[256];
sprintf(cmd, "tile %d %d\n", width, height);
Log(cmd);
}
/*Count the number of vis windows*/
nVisWindows = 0;
curWindow = allWindows;
while (curWindow)
{
if (IsVisWindow((ObjPtr) curWindow))
{
++nVisWindows;
}
curWindow = curWindow -> next;
}
if (!nVisWindows) return;
/*Estimate the number of windows high*/
nHigh = sqrt((double) nVisWindows) + 0.49;
nWide = nVisWindows / nHigh;
if (nWide * nHigh < nVisWindows) ++nHigh;
/*Go through and tile the windows*/
i = 0;
j = nHigh - 1;
curWindow = allWindows;
while (curWindow)
{
if (IsVisWindow((ObjPtr) curWindow))
{
long l, r, b, t;
if (i)
{
l = i * width / nWide + 1;
}
else
{
l = 0;
}
r = (i + 1) * width / nWide;
if (j)
{
b = j * height / nHigh + 1;
}
else
{
b = 0;
}
t = (j + 1) * height / nHigh;
if (++i >= nWide)
{
i = 0;
--j;
}
/*Move the window*/
SelWindow(curWindow);
SetWindowPosition(l, r, b, t);
}
curWindow = curWindow -> next;
}
#endif
#endif
}
void DoTileFullScreen()
/*Tiles all the visualization windows within the full screen*/
{
Tile(SCRWIDTH, SCRHEIGHT);
}
void DoTileVideoScreen()
/*Tiles all the visualization windows within the full screen*/
{
Tile(recScrWidth, recScrHeight);
}
static void RGBTask()
/*Task to change the current window to RGB*/
{
if (selWinInfo)
{
selWinInfo -> flags |= WINRGB;
SetMode(selWinInfo);
ImInvalid((ObjPtr) selWinInfo);
}
}
static void CMapTask()
/*Task to change the current window to CMap mode*/
{
if (selWinInfo)
{
selWinInfo -> flags &= ~WINRGB;
SetMode(selWinInfo);
ImInvalid((ObjPtr) selWinInfo);
}
}
static ObjPtr ChangeVisColorMode(radio)
ObjPtr radio;
/*Changes the color mode of the current visualization window according to
the value of radio*/
{
int rgbp;
ObjPtr repObj;
rgbp = GetInt(GetValue(radio));
repObj = GetWindowVar("ChangeVisColorMode", radio, REPOBJ);
if (!repObj)
{
return ObjFalse;
}
if (rgbp)
{
DeferMessage(repObj, SETTORGBMODE);
}
else
{
DeferMessage(repObj, SETTOCMAPMODE);
}
return ObjTrue;
}
ObjPtr ChangeShowGrid(checkBox)
ObjPtr checkBox;
/*Changes show grid according to a check box*/
{
ObjPtr repObj;
ObjPtr value;
real hsv[3], rgb[3];
repObj = GetObjectVar("ChangeShowGrid", checkBox, REPOBJ);
if (!repObj)
{
return ObjFalse;
}
value = GetValue(checkBox);
if (!value)
{
return ObjFalse;
}
SetVar(repObj, SHOWGRID, value);
ImInvalid(repObj);
return ObjTrue;
}
static ObjPtr ShowFrontSpacePanelControls(spacePanel, windowName)
ObjPtr spacePanel;
char *windowName;
/*Makes a new control window to control a space panel*/
{
WinInfoPtr controlWindow;
ObjPtr var;
ObjPtr panel;
ObjPtr corral;
ObjPtr contents;
real rgb[3], hsv[3];
WinInfoPtr dialogExists;
Bool hasBackground;
dialogExists = DialogExists((WinInfoPtr) spacePanel, NewString("Controls"));
controlWindow = GetDialog((WinInfoPtr) spacePanel, NewString("Controls"), windowName,
SPWINWIDTH, SPWINHEIGHT, SPWINWIDTH,
SPWINHEIGHT, WINDBUF + WINFIXEDSIZE);
if (!dialogExists)
{
long info;
ObjPtr value;
ObjPtr checkBox, icon, name, colorBar, titleBox, textBox, button;
ObjPtr colorWheel, slider, radioGroup;
int left, right, bottom, top;
SetVar((ObjPtr) controlWindow, REPOBJ, spacePanel);
/*Set help string*/
SetVar((ObjPtr) controlWindow, HELPSTRING, NewString("This window \
shows controls for a space panel. For information about any of the controls \
in the window, use Help In Context on the control.\n"));
/*Add in a panel*/
panel = NewPanel(greyPanelClass, 0, SPWINWIDTH, 0, SPWINHEIGHT);
if (!panel)
{
return ObjFalse;
}
contents = GetVar((ObjPtr) controlWindow, CONTENTS);
PrefixList(contents, panel);
SetVar(panel, PARENT, (ObjPtr) controlWindow);
ContentsExpectWindowSize(controlWindow, SPWINWIDTH, SPWINHEIGHT);
contents = GetVar(panel, CONTENTS);
/*Add in the group of controls for text color*/
left = MAJORBORDER;
top = SPWINHEIGHT - MAJORBORDER;
right = SPWINWIDTH - MAJORBORDER;
bottom = SPWINHEIGHT - (MAJORBORDER + (COLORWHEELWIDTH + TEXTBOXSEP + TEXTBOXHEIGHT + CHECKBOXHEIGHT + TITLEBOXTOP + 3 * MINORBORDER))
;
titleBox = NewTitleBox(left, right, bottom, top, "Background");
PrefixList(contents, titleBox);
SetVar(titleBox, PARENT, panel);
left += MINORBORDER;
right -= MINORBORDER;
top -= MINORBORDER + TITLEBOXTOP;
/*Get the color for priming the controls*/
var = GetVar(spacePanel, BACKGROUND);
if (var && IsRealArray(var) && RANK(var) == 1 && DIMS(var)[0] == 3)
{
Array2CArray(rgb, var);
hasBackground = true;
}
else if (var && IsInt(var))
{
rgb[0] = uiColors[GetInt(var)][0] / 255.0;
rgb[1] = uiColors[GetInt(var)][1] / 255.0;
rgb[2] = uiColors[GetInt(var)][2] / 255.0;
hasBackground = true;
}
else
{
rgb[0] = rgb[1] = rgb[2] = 0.0;
hasBackground = false;
}
RGB2HSV(&(hsv[0]), &(hsv[1]), &(hsv[2]), (rgb[0]), (rgb[1]), (rgb[2]));
/*Make the color wheel*/
colorWheel = NewColorWheel(left, left + COLORWHEELWIDTH,
top - COLORWHEELWIDTH, top, "Background Color");
var = NewRealArray(1, 2L);
CArray2Array(var, hsv);
InhibitLogging(true);
SetValue(colorWheel, var);
InhibitLogging(false);
SetVar(colorWheel, PARENT, panel);
SetVar(colorWheel, REPOBJ, spacePanel);
PrefixList(contents, colorWheel);
SetMethod(colorWheel, CHANGEDVALUE, ChangeBackgroundColorWheel);
SetVar(colorWheel, HELPSTRING, NewString("This color wheel controls the \
hue and saturation of the color used to draw the background of the space panel. \
The final color is a combination of this hue and saturation and the value, or brightness, \
given by the Value slider."));
/*Make the text box below*/
textBox = NewTextBox(left, left + COLORWHEELWIDTH,
top - COLORWHEELWIDTH - TEXTBOXSEP - TEXTBOXHEIGHT,
top - COLORWHEELWIDTH - TEXTBOXSEP,
PLAIN, "Background Color Label", "Color");
SetVar(textBox, PARENT, panel);
PrefixList(contents, textBox);
SetTextAlign(textBox, CENTERALIGN);
/*Make the brightness slider*/
slider = NewSlider(right - SLIDERWIDTH, right,
top - COLORWHEELWIDTH, top,
PLAIN, "Background Value");
SetVar(slider, PARENT, panel);
PrefixList(contents, slider);
SetSliderRange(slider, 1.0, 0.0, 0.0);
SetSliderValue(slider, hsv[2]);
SetVar(slider, REPOBJ, spacePanel);
SetMethod(slider, CHANGEDVALUE, ChangeBackgroundColorSlider);
SetVar(slider, HELPSTRING, NewString("This slider controls the \
value, or brightness, of the color used to draw the background of the space panel. \
The final color is a combination of this value and the hue and saturation \
given by the Color color wheel."));
/*Make the text box below*/
textBox = NewTextBox(right - SLIDERWIDTH - MINORBORDER, right + MINORBORDER,
top - COLORWHEELWIDTH - TEXTBOXSEP - TEXTBOXHEIGHT,
top - COLORWHEELWIDTH - TEXTBOXSEP,
PLAIN, "Text Value Label", "Value");
SetVar(textBox, PARENT, panel);
PrefixList(contents, textBox);
SetTextAlign(textBox, CENTERALIGN);
/*Cross link the slider and color wheel*/
SetVar(colorWheel, SLIDER, slider);
SetVar(slider, COLORWHEEL, colorWheel);
/*Make the check box*/
top -= COLORWHEELWIDTH + TEXTBOXSEP + TEXTBOXHEIGHT + MINORBORDER;
checkBox = NewCheckBox(left, right,
top - CHECKBOXHEIGHT, top,
"No background", hasBackground ? false : true);
SetVar(checkBox, PARENT, panel);
SetVar(checkBox, REPOBJ, spacePanel);
SetVar(checkBox, SLIDER, slider);
SetVar(checkBox, COLORWHEEL, colorWheel);
PrefixList(contents, checkBox);
SetMethod(checkBox, CHANGEDVALUE, ChangeNoBackground);
SetVar(checkBox, HELPSTRING, NewString("This checkbox controls whether \
a background is shown. If it is selected, no background is shown, and the \
objects behind can be seen."));
/*Link slider and color wheel to check box*/
SetVar(slider, CHECKBOX, checkBox);
SetVar(colorWheel, CHECKBOX, checkBox);
/*Make check box for show grid*/
left = MAJORBORDER;
top = MAJORBORDER + CHECKBOXHEIGHT;
right = SPWINWIDTH - MAJORBORDER;
bottom = MAJORBORDER;
checkBox = NewCheckBox(left, right, bottom, top, "Show grid",
GetPredicate(spacePanel, SHOWGRID));
PrefixList(contents, checkBox);
SetVar(checkBox, PARENT, panel);
SetVar(checkBox, REPOBJ, spacePanel);
SetMethod(checkBox, CHANGEDVALUE, ChangeShowGrid);
}
return (ObjPtr) controlWindow;
}
static ObjPtr ShowBackSpacePanelControls(spacePanel, windowName)
ObjPtr spacePanel;
char *windowName;
/*Makes a new control window to control a space panel*/
{
WinInfoPtr controlWindow;
ObjPtr var;
ObjPtr panel;
ObjPtr corral;
ObjPtr contents;
real rgb[3], hsv[3];
WinInfoPtr dialogExists;
Bool hasBackground;
dialogExists = DialogExists((WinInfoPtr) spacePanel, NewString("Controls"));
controlWindow = GetDialog((WinInfoPtr) spacePanel, NewString("Controls"), windowName,
SPWINWIDTH, SPWINHEIGHT, SPWINWIDTH,
SPWINHEIGHT, WINDBUF + WINFIXEDSIZE);
if (!dialogExists)
{
long info;
ObjPtr value;
ObjPtr checkBox, icon, name, colorBar, titleBox, textBox, button;
ObjPtr colorWheel, slider, radioGroup;
int left, right, bottom, top;
SetVar((ObjPtr) controlWindow, REPOBJ, spacePanel);
/*Set help string*/
SetVar((ObjPtr) controlWindow, HELPSTRING, NewString("This window \
shows controls for a space panel. For information about any of the controls \
in the window, use Help In Context on the control.\n"));
/*Add in a panel*/
panel = NewPanel(greyPanelClass, 0, SPWINWIDTH, 0, SPWINHEIGHT);
if (!panel)
{
return ObjFalse;
}
contents = GetVar((ObjPtr) controlWindow, CONTENTS);
PrefixList(contents, panel);
SetVar(panel, PARENT, (ObjPtr) controlWindow);
ContentsExpectWindowSize(controlWindow, SPWINWIDTH, SPWINHEIGHT);
contents = GetVar(panel, CONTENTS);
/*Add in the group of controls for text color*/
left = MAJORBORDER;
top = SPWINHEIGHT - MAJORBORDER;
right = SPWINWIDTH - MAJORBORDER;
bottom = SPWINHEIGHT - (MAJORBORDER + (COLORWHEELWIDTH +
TEXTBOXSEP + TEXTBOXHEIGHT + CHECKBOXHEIGHT + TITLEBOXTOP + 3 * MINORBORDER));
titleBox = NewTitleBox(left, right, bottom, top, "Background");
PrefixList(contents, titleBox);
SetVar(titleBox, PARENT, panel);
left += MINORBORDER;
right -= MINORBORDER;
top -= MINORBORDER + TITLEBOXTOP;
/*Get the color for priming the controls*/
var = GetVar(spacePanel, BACKGROUND);
if (var && IsRealArray(var) && RANK(var) == 1 && DIMS(var)[0] == 3)
{
Array2CArray(rgb, var);
hasBackground = true;
}
else if (var && IsInt(var))
{
rgb[0] = uiColors[GetInt(var)][0] / 255.0;
rgb[1] = uiColors[GetInt(var)][1] / 255.0;
rgb[2] = uiColors[GetInt(var)][2] / 255.0;
hasBackground = true;
}
else
{
rgb[0] = rgb[1] = rgb[2] = 0.0;
hasBackground = false;
}
RGB2HSV(&(hsv[0]), &(hsv[1]), &(hsv[2]), (rgb[0]), (rgb[1]), (rgb[2]));
/*Make the color wheel*/
colorWheel = NewColorWheel(left, left + COLORWHEELWIDTH,
top - COLORWHEELWIDTH, top, "Background Color");
var = NewRealArray(1, 2L);
CArray2Array(var, hsv);
InhibitLogging(true);
SetValue(colorWheel, var);
InhibitLogging(false);
SetVar(colorWheel, PARENT, panel);
SetVar(colorWheel, REPOBJ, spacePanel);
PrefixList(contents, colorWheel);
SetMethod(colorWheel, CHANGEDVALUE, ChangeBackgroundColorWheel);
SetVar(colorWheel, HELPSTRING, NewString("This color wheel controls the \
hue and saturation of the color used to draw the background of the space panel. \
The final color is a combination of this hue and saturation and the value, or brightness, \
given by the Value slider."));
/*Make the text box below*/
textBox = NewTextBox(left, left + COLORWHEELWIDTH,
top - COLORWHEELWIDTH - TEXTBOXSEP - TEXTBOXHEIGHT,
top - COLORWHEELWIDTH - TEXTBOXSEP,
PLAIN, "Background Color Label", "Color");
SetVar(textBox, PARENT, panel);
PrefixList(contents, textBox);
SetTextAlign(textBox, CENTERALIGN);
/*Make the brightness slider*/
slider = NewSlider(right - SLIDERWIDTH, right,
top - COLORWHEELWIDTH, top,
PLAIN, "Background Value");
SetVar(slider, PARENT, panel);
PrefixList(contents, slider);
SetSliderRange(slider, 1.0, 0.0, 0.0);
SetSliderValue(slider, hsv[2]);
SetVar(slider, REPOBJ, spacePanel);
SetMethod(slider, CHANGEDVALUE, ChangeBackgroundColorSlider);
SetVar(slider, HELPSTRING, NewString("This slider controls the \
value, or brightness, of the color used to draw the background of the space panel. \
The final color is a combination of this value and the hue and saturation \
given by the Color color wheel."));
/*Make the text box below*/
textBox = NewTextBox(right - SLIDERWIDTH - MINORBORDER, right + MINORBORDER,
top - COLORWHEELWIDTH - TEXTBOXSEP - TEXTBOXHEIGHT,
top - COLORWHEELWIDTH - TEXTBOXSEP,
PLAIN, "Text Value Label", "Value");
SetVar(textBox, PARENT, panel);
PrefixList(contents, textBox);
SetTextAlign(textBox, CENTERALIGN);
/*Cross link the slider and color wheel*/
SetVar(colorWheel, SLIDER, slider);
SetVar(slider, COLORWHEEL, colorWheel);
/*Make check box for show grid*/
left = MAJORBORDER;
top = MAJORBORDER + CHECKBOXHEIGHT;
right = SPWINWIDTH - MAJORBORDER;
bottom = MAJORBORDER;
checkBox = NewCheckBox(left, right, bottom, top, "Show grid",
GetPredicate(spacePanel, SHOWGRID));
PrefixList(contents, checkBox);
SetVar(checkBox, PARENT, panel);
SetVar(checkBox, REPOBJ, spacePanel);
SetMethod(checkBox, CHANGEDVALUE, ChangeShowGrid);
}
return (ObjPtr) controlWindow;
}
static ObjPtr ChangeSpaceTools(toolGroup)
ObjPtr toolGroup;
/*Changes a space's tools based on toolGroup*/
{
ObjPtr value;
int oldValue, newValue, index;
ObjPtr space;
ObjPtr contents;
ObjPtr var;
ThingListPtr runner;
space = GetObjectVar("ChangeSpaceTools", toolGroup, SPACE);
if (!space)
{
return ObjFalse;
}
value = GetVar(space, EDITTOOL);
if (value)
{
oldValue = GetInt(value);
}
else
{
oldValue = -1;
}
value = GetValue(toolGroup);
if (value)
{
index = GetInt(value);
}
else
{
index = 0;
}
newValue = ST_FINGER;
contents = GetListVar("ChangeSpaceTools", toolGroup, CONTENTS);
runner = LISTOF(contents);
while (runner)
{
if (!index)
{
/*Found it*/
var = GetVar(runner -> thing, EDITTOOL);
if (var)
{
newValue = GetInt(var);
}
break;
}
--index;
runner = runner -> next;
}
if (oldValue == newValue)
{
return ObjFalse;
}
if (oldValue == ST_FLYING)
{
/*Transition from flying*/
ObjPtr observer;
ObjPtr var;
real forward[3], up[3];
observer = GetVar(space, OBSERVER);
if (observer)
{
/*Incorporate changes*/
GetAdjustedVectors(forward, up, observer);
var = NewRealArray(1, 3L);
CArray2Array(var, forward);
SetVar(observer, FORWARDVECTOR, var);
var = NewRealArray(1, 3L);
CArray2Array(var, up);
SetVar(observer, UPVECTOR, var);
SetVar(observer, ROLL, NULLOBJ);
SetVar(observer, PITCH, NULLOBJ);
SetVar(observer, AIRSPEED, NULLOBJ);
LogObserver(observer);
}
}
if (newValue == ST_FLYING)
{
/*Transition from flying*/
ObjPtr observer;
ObjPtr var;
observer = GetVar(space, OBSERVER);
if (observer)
{
/*Incorporate changes*/
SetVar(observer, ROLL, NewReal(0.0));
SetVar(observer, PITCH, NewReal(0.0));
SetVar(observer, AIRSPEED, NewReal(4.0 * AIRSPEEDFACTOR));
LogObserver(observer);
}
}
SetVar(space, EDITTOOL, NewInt(newValue));
return ObjTrue;
}
ObjPtr ReshapeVisWindow(window, ol, or, ob, ot, nl, nr, nb, nt)
ObjPtr window;
int ol, or, ob, ot;
int nl, nr, nb, nt;
/*Reshapes vis window given that ol, or, ob, and ot was the old
viewport. Does not redraw anything.*/
{
ObjPtr contents;
/*DIKEO reshape the space window, if any*/
contents = GetVar(window, CONTENTS);
if (contents && IsList(contents))
{
ReshapeList(LISTOF(contents),
0, or - ol, 0, ot - ob,
0, nr - nl, 0, nt - nb);
}
return ObjTrue;
}
#ifdef CHANGECURSOR
static Bool metering;
static Bool pointCurrently;
static real meterX, meterY, meterZ;
static ObjPtr meterObject;
static ObjPtr IdleVisWindowCursor(visWindow, x, y)
ObjPtr visWindow;
int x, y;
/*Idles a vis window with a cursor inside*/
{
#ifdef GRAPHICS
ObjPtr space, var;
int left, right, bottom, top;
ObjPtr contents;
ThingListPtr runner;
FuncTyp method;
space = GetVar(visWindow, SPACE);
if (!space)
{
return ObjFalse;
}
var = GetVar(space, EDITTOOL);
if (!var)
{
return ObjFalse;
}
if (GetInt(var) == ST_FINGER)
{
FuncTyp method;
/*Have to go through the space to find where this is picked*/
Get2DIntBounds(space, &left, &right, &bottom, &top);
StartSpace(space, left, right, bottom, top, PICKSPACE, 0);
/*Pick the contents of the space*/
contents = GetVar(space, CONTENTS);
runner = LISTOF(contents);
while (runner)
{
if (IsObject(runner -> thing))
{
PickObject(runner -> thing, PR_CENTER);
method = GetMethod(runner -> thing, PICKPOINT);
if (method)
{
(*method)(runner -> thing);
}
}
runner = runner -> next;
}
StopSpace(PICKSPACE);
if (spacePickedObject && (bestPickVertex >= 0))
{
/*There is a vertex to highlight*/
method = GetMethod(spacePickedObject,
BEGINSTUFFING);
if (method)
{
(*method)(spacePickedObject);
method = GetMethod(spacePickedObject,
STUFFSELPOINT);
if (method)
{
real px, py, pz;
real xnew, ynew, znew, wnew;
Matrix projMatrix, viewMatrix, curMatrix;
(*method)(spacePickedObject,
bestPickVertex, &px, &py, &pz);
StartSpace(space, left, right, bottom, top, OVERDRAWSPACE, 0);
mmode(MPROJECTION);
getmatrix(projMatrix);
mmode(MVIEWING);
getmatrix(viewMatrix);
MULTMATRIX(viewMatrix, projMatrix, curMatrix);
StopSpace(OVERDRAWSPACE);
xnew = px * curMatrix[0][0] + py * curMatrix[1][0] +
pz * curMatrix[2][0] + curMatrix[3][0];
ynew = px * curMatrix[0][1] + py * curMatrix[1][1] +
pz * curMatrix[2][1] + curMatrix[3][1];
znew = px * curMatrix[0][2] + py * curMatrix[1][2] +
pz * curMatrix[2][2] + curMatrix[3][2];
wnew = px * curMatrix[0][3] + py * curMatrix[1][3] +
pz * curMatrix[2][3] + curMatrix[3][3];
xnew /= wnew;
ynew /= wnew;
znew /= wnew;
SetSubPort(left, right, bottom, top);
mmode(MPROJECTION);
ortho2(-1.0, 1.0, -1.0, 1.0);
mmode(MVIEWING);
loadmatrix(Identity);
OverDraw(true);
EraseAll();
SetUIColor(UIWHITE);
DrawSpaceLine(-1.0, ynew, 0.0, 1.0, ynew, 0.0);
DrawSpaceLine(xnew, -1.0, 0.0, xnew, 1.0, 0.0);
OverDraw(false);
RestoreSubPort();
}
}
}
else
{
SetSubPort(left, right, bottom, top);
OverDraw(true);
EraseAll();
OverDraw(false);
RestoreSubPort();
}
}
#endif
return ObjTrue;
}
static ObjPtr EnterVisWindow(visWindow)
ObjPtr visWindow;
/*Enters a vis window*/
{
metering = true;
pointCurrently = false;
}
static ObjPtr LeaveVisWindow(visWindow)
ObjPtr visWindow;
/*Leaves a vis window*/
{
if (metering && pointCurrently)
{
OverDraw(true);
EraseAll();
OverDraw(false);
}
metering = false;
}
#endif
WinInfoPtr NewVisWindow(title, flags)
char *title;
long flags;
/*Creates a new visualization window with title title and flags flags*/
{
WinInfoPtr visWindow;
WinInfoPtr spaceWindow;
ObjPtr space, panel, corral, contents, panelContents;
ObjPtr button, radioGroup;
int l, r, b, t;
ObjPtr lights;
ThingListPtr runner;
ObjPtr spaceContents;
visWindow = NewObjWindow(visWindowClass, title,
rgbGoodForUI ? flags : flags & ~WINRGB,
VWINWIDTH, VWINHEIGHT, SCRWIDTH, SCRHEIGHT);
#ifdef CHANGECURSOR
SetMethod((ObjPtr) visWindow, IDLECURSOR, IdleVisWindowCursor);
SetMethod((ObjPtr) visWindow, ENTERCURSOR, EnterVisWindow);
SetMethod((ObjPtr) visWindow, LEAVECURSOR, LeaveVisWindow);
#endif
SetMinSize(visWindow, 100, 100);
SetVar((ObjPtr) visWindow, HIDEPANEL, ObjTrue);
DefineMenuItem((ObjPtr) visWindow, WINDOWSMENU, "Show Front Panel Controls", DoShowFrontPanelControls);
DefineMenuItem((ObjPtr) visWindow, WINDOWSMENU, "Show Back Panel Controls", DoShowBackPanelControls);
DefineMenuItem((ObjPtr) visWindow, WINDOWSMENU, "Show Space Controls", DoShowSpaceControls);
DefineMenuItem((ObjPtr) visWindow, WINSIZEMENU, "Tile Full Screen", DoTileFullScreen);
DefineMenuItem((ObjPtr) visWindow, WINSIZEMENU, "Tile Video Screen", DoTileVideoScreen);
DefineMenuItem((ObjPtr) visWindow, WINSIZEMENU, "PHSCologram Screen", DoPhscoScreen);
DefineMenuItem((ObjPtr) visWindow, TEXTMENU, "", 0);
contents = GetVar((ObjPtr) visWindow, CONTENTS);
ContentsExpectWindowSize(visWindow, VWINWIDTH, VWINHEIGHT);
/*Create the space and its associated panels*/
l = VWINTOOLPWIDTH;
r = VWINWIDTH - VWINPANELWIDTH;
b = 0;
t = VWINHEIGHT;
if (rgbGoodForUI)
{
spaceWindow = visWindow;
}
else
{
char newName[300];
int x, y;
ObjPtr var;
real margins[4];
ObjPtr panelContents, textBox;
GetWindowOrigin(&x, &y);
spaceWindow = NewObjWindow(spaceWindowClass, title,
flags | WINFIXEDLOC | WINRGB | WINNOFRAME,
r - l, t - b, x + l, y);
SetVar((ObjPtr) visWindow, SPACEWINDOW, (ObjPtr) spaceWindow);
var = NewList();
PrefixList(var, (ObjPtr) spaceWindow);
SetVar((ObjPtr) visWindow, SUBWINDOWS, var);
SetVar((ObjPtr) spaceWindow, SUPERWINDOW, (ObjPtr) visWindow);
margins[0] = (real) (l);
margins[1] = (real) (VWINWIDTH - r);
margins[2] = 0.0;
margins[3] = 0.0;
var = NewRealArray(1, 4L);
CArray2Array(var, margins);
SetVar((ObjPtr) spaceWindow, SUBWINDOWMARGIN, var);
/*Make a dummy panel to put here*/
panel = NewPanel(greyPanelClass, l, r, b, t);
if (!panel)
{
return (WinInfoPtr) 0;
}
SetVar(panel, PARENT, (ObjPtr) visWindow);
PrefixList(contents, panel);
panelContents = GetVar(panel, CONTENTS);
r = r - l;
l = 0;
t = t - b;
b = 0;
/*And a warning text box*/
textBox = NewTextBox(MAJORBORDER, r - MAJORBORDER, MAJORBORDER,
t - MAJORBORDER, 0, "Yaha",
"In normal operation, you should never see this message. If you can read this, it means \
that something has gone wrong with the way SciAn is stacking its windows. This is most likely due \
to an X windows operation on the windows that SciAn cannot detect.\n\n\
You can probably fix the \
problem for the time being simply by clicking in the title bar of this window \
to pop it to the top.\n\n\
Please report this bug to scian-bugs@scri.fsu.edu.");
PrefixList(panelContents, textBox);
SetVar(textBox, PARENT, panel);
}
spaceContents = GetVar((ObjPtr) spaceWindow, CONTENTS);
/*Add in the panel behind the space*/
panel = NewPanel(spaceBackPanelClass, l, r, b, t);
if (!panel)
{
return (WinInfoPtr) 0;
}
SetVar(panel, NAME, ConcatStrings(NewString(title), NewString(" Back Panel")));
SetVar(panel, STICKINESS, NewInt(STICKYLEFT + STICKYRIGHT +
STICKYBOTTOM + STICKYTOP));
SetVar(panel, TYPESTRING, NewString("panel"));
SetVar(panel, HELPSTRING, NewString("This panel holds 2-dimensional objects \
and is always drawn behind the space."));
SetVar(panel, OWNERWINDOW, (ObjPtr) spaceWindow);
#ifdef INTERACTIVE
SetMethod(panel, PRESS, PressSpacePanel);
#endif
#ifndef BOCKA
PrefixList(spaceContents, panel);
#endif
/*Add in a space*/
space = NewSpace(l, r, b, t);
if (!space)
{
return (WinInfoPtr) 0;
}
SetVar(space, STICKINESS, NewInt(STICKYLEFT + STICKYRIGHT +
STICKYBOTTOM + STICKYTOP));
SetVar(space, NAME, ConcatStrings(NewString(title), NewString(" Space")));
SetVar(space, OWNERWINDOW, (ObjPtr) spaceWindow);
PrefixList(spaceContents, space);
SetVar(space, PARENT, (ObjPtr) spaceWindow);
/*Notify the space that the panel is behind the space*/
SetVar(panel, SPACE, space);
SetVar(space, BACKPANEL, panel);
SetVar(panel, PARENT, space);
SetMethod(panel, NEWCTLWINDOW, ShowBackSpacePanelControls);
SetMethod(panel, SHOWCONTROLS, NewControlWindow);
/*Add in the panel to cover the space*/
panel = NewPanel(spacePanelClass, l, r, b, t);
if (!panel)
{
return (WinInfoPtr) 0;
}
SetVar(panel, NAME, ConcatStrings(NewString(title), NewString(" Front Panel")));
SetVar(panel, STICKINESS, NewInt(STICKYLEFT + STICKYRIGHT +
STICKYBOTTOM + STICKYTOP));
SetVar(panel, TYPESTRING, NewString("panel"));
SetVar(panel, HELPSTRING, NewString("This panel holds 2-dimensional objects \
and is always drawn in front of the space."));
SetVar(panel, OWNERWINDOW, (ObjPtr) spaceWindow);
SetVar(panel, SPACE, space);
#ifdef INTERACTIVE
SetMethod(panel, PRESS, PressSpacePanel);
#endif
#ifndef BOCKA
PrefixList(spaceContents, panel);
#endif
SetVar(panel, PARENT, space);
/*Notify the space that the panel covers the space*/
SetVar(space, FRONTPANEL, panel);
SetVar(panel, FRONTPANEL, ObjTrue);
SetMethod(panel, NEWCTLWINDOW, ShowFrontSpacePanelControls);
SetMethod(panel, SHOWCONTROLS, NewControlWindow);
/*Give the space to (potentially) both the windows*/
SetVar((ObjPtr) visWindow, SPACE, space);
SetVar((ObjPtr) spaceWindow, SPACE, space);
/*Add in a tools panel*/
panel = NewPanel(greyPanelClass, 0, VWINTOOLPWIDTH, 0, VWINHEIGHT);
if (!panel)
{
return (WinInfoPtr) 0;
}
SetVar(panel, STICKINESS, NewInt(STICKYLEFT + STICKYBOTTOM + STICKYTOP));
#ifndef BOCKA
PrefixList(contents, panel);
#endif
SetVar(panel, PARENT, (ObjPtr) visWindow);
SetVar(space, TOOLPANEL, panel);
SetVar(panel, TYPESTRING, NewString("panel"));
SetVar(panel, HELPSTRING, NewString("You can show or hide this panel by choosing the Toggle Panel \
item from the Windows menu."));
panelContents = GetVar(panel, CONTENTS);
/*Put tools in the space tools group*/
radioGroup = NewRadioButtonGroup("Space Tools");
SetVar(space, TOOLGROUP, radioGroup);
SetVar(radioGroup, HELPSTRING,
NewString("This is a group of tools that allow you to modify the \
space using the mouse. To use one of these tools, click on the icon representing \
the tool before clicking in the space. To find out what each tool does, use \
help in context on each individual button."));
SetVar(radioGroup, PARENT, panel);
PrefixList(panelContents, radioGroup);
SetVar(radioGroup, HALTHELP, ObjTrue);
SetVar(radioGroup, STICKINESS, NewInt(STICKYLEFT + STICKYTOP));
/*First the 3-D tools on the left*/
l = VWTOOLBORDER;
t = VWINHEIGHT - VWTOOLBORDER;
/*Motion/rotation tool*/
button = NewIconButton(l, l + SMALLICONBUTTONSIZE,
t - SMALLICONBUTTONSIZE, t,
ICONMOVEROTATE, UIYELLOW, "Space Selection", BS_PLAIN);
SetVar(button, STICKINESS, NewInt(STICKYLEFT + STICKYTOP));
AddRadioButton(radioGroup, button);
SetVar(button, HELPSTRING, NewString("This button chooses the space and space panel selection tool.\n\
\n\
Click and drag within the space using the center mouse button to rotate \
the entire space around the focus point of the observer at the center of the \
space. The space can be rotated around any axis. Hold down the Shift key \
to constrain to rotation around a principal axis of the space. Double-click \
to snap the space to the nearest straight-on orientation. \
If Space Rotation Guides is turned on in the space control panel, you will see the \
virtual trackball as a wire frame sphere. If Rotation Inertia \
is turned on in the space control panel, the space will continue to rotate if you \
give it a spin and let go while moving the mouse.\n\
\n\
Click on an object within the space to select it. Drag after clicking to move \
the objects in the space. If you hold down the shift key while dragging, motion \
will be constrained to one principal axis of the space.\n\
\n\
Both rotation and motion will affect other spaces controlled by the same observer. This \
is because rotation and motion actually change the position of the observer \
within the space.\n\
\n\
Click on a 2-D object in the front or back panel, such as a text box or line, \
to select it. Once an object is selected, an outline with handles will appear \
around the object. You can click and drag the handled to move and resize the \
object. You can also edit text within text objects by clicking and dragging."));
SetVar(button, EDITTOOL, NewInt(ST_FINGER));
t = t - SMALLICONBUTTONSIZE - VWTOOLBORDER;
/*Flight tool*/
button = NewIconButton(l, l + SMALLICONBUTTONSIZE,
t - SMALLICONBUTTONSIZE, t,
ICONPLANE, UIYELLOW, "Flight Simulator", BS_PLAIN);
SetVar(button, STICKINESS, NewInt(STICKYLEFT + STICKYTOP));
AddRadioButton(radioGroup, button);
SetVar(button, HELPSTRING, NewString("This button chooses the space flight \
simulator. When this tool is chosen, you can fly through the space like an airplane \
using the mouse. This works best when the window is resized to fill the entire \
screen. It is also a good idea to give the observer a wide field of view from \
within the observer control panel.\n\
\n\
To start flying, click the left mouse button in the space. Pull the mouse back \
toward you to climb and push it forward to dive. Move the mouse to the left or right \
to turn. To accelerate, press the up arrow key repeatedly. To decelerate, press the \
down arrow key. When you are done flying, press the left mouse button once more \
in the space."));
SetVar(button, EDITTOOL, NewInt(ST_FLYING));
t = t - SMALLICONBUTTONSIZE - VWTOOLBORDER;
#if 0
/*3-D Finger Tool*/
button = NewIconButton(l, l + SMALLICONBUTTONSIZE,
t - SMALLICONBUTTONSIZE, t,
ICON3DFINGER, UIYELLOW, "Space Selection", BS_PLAIN);
SetVar(button, STICKINESS, NewInt(STICKYLEFT + STICKYTOP));
AddRadioButton(radioGroup, button);
SetVar(button, HELPSTRING, NewString("This button chooses the space \
selection tool. Use the left mouse button with this tool to select \
visualization objects within the space.\n"));
SetVar(button, EDITTOOL, NewInt(ST_3DFINGER));
t = t - SMALLICONBUTTONSIZE - VWTOOLBORDER;
#endif
#if 0
/*Meter tool*/
button = NewIconButton(l, l + SMALLICONBUTTONSIZE,
t - SMALLICONBUTTONSIZE, t,
ICONMETER, UIYELLOW, "Data Meter", BS_PLAIN);
SetVar(button, STICKINESS, NewInt(STICKYLEFT + STICKYTOP));
AddRadioButton(radioGroup, button);
SetVar(button, HELPSTRING, NewString("This button chooses the data meter \
tool, which is not implemented yet.\n"));
SetVar(button, EDITTOOL, NewInt(ST_METER));
t = t - SMALLICONBUTTONSIZE - VWTOOLBORDER;
#endif
#if 0
/*Now the 3-D tools on the right*/
l = 2 * VWTOOLBORDER + SMALLICONBUTTONSIZE;
t = VWINHEIGHT - VWTOOLBORDER;
/*2-D finger tool*/
button = NewIconButton(l, l + SMALLICONBUTTONSIZE,
t - SMALLICONBUTTONSIZE, t,
ICONFINGER, UIYELLOW, "Panel Selection", BS_PLAIN);
SetVar(button, STICKINESS, NewInt(STICKYLEFT + STICKYTOP));
AddRadioButton(radioGroup, button);
SetVar(button, HELPSTRING, NewString("This button chooses the space panel selection tool.\
Use this tool to select and move objects on the front or back panels of the space."));
SetVar(button, EDITTOOL, NewInt(ST_FINGER));
t = t - SMALLICONBUTTONSIZE - VWTOOLBORDER;
#endif
/*Annotation tool*/
button = NewIconButton(l, l + SMALLICONBUTTONSIZE,
t - SMALLICONBUTTONSIZE, t,
ICONANNOTATION, UIYELLOW, "Draw Annotation", BS_PLAIN);
SetVar(button, STICKINESS, NewInt(STICKYLEFT + STICKYTOP));
AddRadioButton(radioGroup, button);
SetVar(button, HELPSTRING, NewString("This button chooses the annotation drawing tool. \
Use this button to drag out annotation boxes on the panels of the space. \
Normally this tool draws on the front panel. Hold down the Alt or Ctrl key while drawing to draw \
on the back panel. When the box has been drawn, enter text by typing. The appearance of the boxes \
can be modified by selecting them and choosing Show Controls \
from the Objects menu."));
SetVar(button, EDITTOOL, NewInt(ST_ANNOTATION));
t = t - SMALLICONBUTTONSIZE - VWTOOLBORDER;
button = NewIconButton(l, l + SMALLICONBUTTONSIZE,
t - SMALLICONBUTTONSIZE, t,
ICONRECTANGLE, UIYELLOW, "Draw Rectangle", BS_PLAIN);
SetVar(button, STICKINESS, NewInt(STICKYLEFT + STICKYTOP));
AddRadioButton(radioGroup, button);
SetVar(button, HELPSTRING, NewString("This button chooses the rectangle drawing tool. \
Use this button to drag out rectangular boxes on the panels of the space. \
Normally this tool draws on the front panel. Hold down the Alt or Ctrl key while drawing to draw \
on the back panel. The appearance of the boxes can be modified by selecting them and choosing Show Controls \
from the Objects menu."));
SetVar(button, EDITTOOL, NewInt(ST_RECTANGLE));
t = t - SMALLICONBUTTONSIZE - VWTOOLBORDER;
button = NewIconButton(l, l + SMALLICONBUTTONSIZE,
t - SMALLICONBUTTONSIZE, t,
ICONLINE, UIYELLOW, "Draw Line", BS_PLAIN);
SetVar(button, STICKINESS, NewInt(STICKYLEFT + STICKYTOP));
AddRadioButton(radioGroup, button);
SetVar(button, HELPSTRING, NewString("This button chooses the line drawing tool. \
Use this button to drag out lines on the panels of the space. \
Normally this tool draws on the front panel. Hold down the Alt or Ctrl key while drawing to draw \
on the back panel. The appearance of the lines can be modified by selecting them and choosing Show Controls \
from the Objects menu. You can also add arrowheads from within this control panel."));
SetVar(button, EDITTOOL, NewInt(ST_LINE));
t = t - SMALLICONBUTTONSIZE - VWTOOLBORDER;
button = NewIconButton(l, l + SMALLICONBUTTONSIZE,
t - SMALLICONBUTTONSIZE, t,
ICONCLOCK, UIYELLOW, "Draw Time Readout", BS_PLAIN);
SetVar(button, STICKINESS, NewInt(STICKYLEFT + STICKYTOP));
AddRadioButton(radioGroup, button);
SetVar(button, HELPSTRING, NewString("This button chooses the time readout drawing tool. \
Use this button to drag out time readouts on the panels of the space. The time readout is \
a text box which always shows the current time in the space. To change the \
format in which the time is displayed, show the control panel by \
selecting the readout and choosing Show Controls from the Objects menu. \
Normally this tool draws on the front panel. Hold down the Alt or Ctrl key while drawing to draw \
on the back panel."));
SetVar(button, EDITTOOL, NewInt(ST_TIME_READOUT));
/*Give the radio group a default value*/
SetValue(radioGroup, NewInt(ST_FINGER));
SetVar(space, EDITTOOL, NewInt(ST_FINGER));
SetVar(radioGroup, SPACE, space);
SetMethod(radioGroup, CHANGEDVALUE, ChangeSpaceTools);
/*Add in an object control panel*/
panel = NewPanel(greyPanelClass, VWINWIDTH - VWINPANELWIDTH, VWINWIDTH,
0, VWINHEIGHT);
if (!panel)
{
return (WinInfoPtr) 0;
}
SetVar(panel, STICKINESS, NewInt(STICKYRIGHT + STICKYBOTTOM + STICKYTOP));
#ifndef BOCKA
PrefixList(contents, panel);
#endif
SetVar(panel, PARENT, (ObjPtr) visWindow);
SetVar(space, OBJPANEL, panel);
SetVar(panel, TYPESTRING, NewString("panel"));
SetVar(panel, HELPSTRING, NewString("You can show or hide this panel by choosing the Toggle Panel \
item from the Windows menu."));
contents = GetVar(panel, CONTENTS);
if (!contents)
{
return (WinInfoPtr) 0;
}
/*Add in an icon corral*/
corral = NewIconCorral(visCorralClass,
MINORBORDER, VWINPANELWIDTH - MINORBORDER,
MINORBORDER,
VWINHEIGHT - MINORBORDER,
BARRIGHT + BARBOTTOM);
if (!corral)
{
return (WinInfoPtr) 0;
}
SetVar((ObjPtr) visWindow, CORRAL, corral);
SetVar(corral, NAME, NewString("Space Contents"));
SetVar(corral, HELPSTRING,
NewString("This corral shows the objects and space controllers present \
in this visualization window. You can drag new datasets from the datasets window \
into this corral to visualize them along with the other objects. You can also \
drag in observer, renderer, clock, and lights icons. There can only be one \
observer, renderer, and clock in a space, so dragging in these will replace the \
existing controller.\n"));
SetVar(corral, STICKINESS, NewInt(STICKYLEFT + STICKYRIGHT +
STICKYBOTTOM + STICKYTOP));
PrefixList(contents, corral);
SetVar(corral, PARENT, panel);
/*Splice the space to the corral*/
SetVar(corral, SPACE, space);
SetVar(space, CORRAL, corral);
/*Add an observer*/
AddControllerToSpace(NewObserver(), space, corral, NULLOBJ);
/*Add a renderer*/
AddControllerToSpace(NewRenderer(), space, corral, NULLOBJ);
/*Add some lights*/
#ifdef GRAPHICS
if (hasRGB)
#endif
{
lights = NewLights();
runner = LISTOF(lights);
while (runner)
{
AddControllerToSpace(runner -> thing, space, corral, NULLOBJ);
runner = runner -> next;
}
}
/*Add a clock*/
AddControllerToSpace(NewClock(), space, corral, NULLOBJ);
return visWindow;
}
ObjPtr FindSpace(win)
WinInfoPtr win;
/*Finds the space in win*/
{
return GetVar((ObjPtr) win, SPACE);
}
ObjPtr FindObserver(win)
WinInfoPtr win;
/*Finds the observer in win*/
{
ObjPtr space, retVal;
retVal = GetVar((ObjPtr) win, REPOBJ);
if (retVal && (IsObserver(retVal)))
{
return retVal;
}
space = FindSpace(win);
if (space)
{
retVal = GetObjectVar("FindObserver", space, OBSERVER);
}
else
{
ReportError("FindObserver", "No space in window");
}
return retVal;
}
#ifdef PROTO
void RotateOrthoWindow(WinInfoPtr window, char axis, float amount)
#else
void RotateOrthoWindow(window, axis, amount)
WinInfoPtr window;
char axis;
float amount;
#endif
/*Rotates the observer in window about orthogonal axis axis by amount, and
stops continuous rotation.*/
{
ObjPtr observer;
real av[3];
observer = FindObserver(window);
if (!observer) return;
switch(axis)
{
case 'x':
case 'X':
av[0] = 1.0;
av[1] = 0.0;
av[2] = 0.0;
break;
case 'y':
case 'Y':
av[0] = 0.0;
av[1] = 1.0;
av[2] = 0.0;
break;
case 'z':
case 'Z':
av[0] = 0.0;
av[1] = 0.0;
av[2] = 1.0;
break;
default:
ReportError("RotateOrthoWindow", "Bad axis");
return;
}
RotateObserver(observer, av, -amount * M_PI / 180.0, false);
}
static ObjPtr ChangeWindowToRGB(window, button)
WinInfoPtr window;
int button;
/*If button is 1, changes the color mode of window to RGB*/
{
if (button == 1)
{
ObjPtr radio = NULLOBJ;
SelWindow(window);
if (selWinInfo)
{
radio = GetVar((ObjPtr) selWinInfo, CMODERADIO);
}
if (radio)
{
SetValue(radio, NewInt(1));
}
return ObjTrue;
}
else
{
return ObjFalse;
}
}
ObjPtr SetVisWindowRGB(window)
ObjPtr window;
/*Deferred message to choose whether to make window RGB or not*/
{
#ifdef GRAPHICS
char tempBuf[400];
WinInfoPtr errWindow;
WinInfoPtr spaceWindow;
/*See if the window is already RGB*/
spaceWindow = (WinInfoPtr) GetVar(window, SPACEWINDOW);
if (!spaceWindow)
{
spaceWindow = (WinInfoPtr) window;
}
if (spaceWindow -> flags & WINRGB)
{
return;
}
if (!hasRGB)
{
return;
}
sprintf(tempBuf, "You will see no effects from this action in window %s \
until you change it to full color mode. Would you like to change it now?",
((WinInfoPtr) window) -> winTitle);
errWindow = AlertUser(UICAUTIONALERT, (WinInfoPtr) window, tempBuf,
ChangeWindowToRGB, 2, "Cancel", "Change");
SetVar((ObjPtr) errWindow, HELPSTRING,
NewString("Visualization windows have two color modes: full color and color map. \
Full color specifies full 24-bit RGB color. Color map specifies mapped colors using a color \
table. Some features, such as lighting, only work on windows set to full color mode. \
If you click on the Change button, the affected window will automatically be set \
to this mode."));
#endif
}
void InitVisWindows()
/*Initializes the vis windows*/
{
visualizeAsList = NewList();
AddToReferenceList(visualizeAsList);
visWindowClass = NewObject(objWindowClass, 0);
AddToReferenceList(visWindowClass);
SetVar(visWindowClass, CLASSID, NewInt(CLASS_VISWINDOW));
SetVar(visWindowClass, HELPSTRING,
NewString("This is a visualizaton window. On the right is a panel which \
shows the visualization objects shown in the window, the controllers which \
affect the appearance of the object, and some buttons which affect the window \
as a whole or the selected icons. If this panel is not shown, it can be brought \
back with the Toggle Panel item in the Window menu. On the left is a \
3-dimensional space in which \
the visualization object are shown. There is one clear panel in front of the and \
one clear panel behind the space. These panels are used to hold 2-dimensional \
objects such as clock readouts and text boxes, which can be created and modified \
with items in the Text menu."));
#if 0
/*DIKEO I have decided to give up the RGB message*/
SetMethod(visWindowClass, SETRGBMESSAGE, SetVisWindowRGB);
#endif
SetMethod(visWindowClass, HIDEPANEL, HideVisWindowPanel);
SetMethod(visWindowClass, SHOWPANEL, ShowVisWindowPanel);
SetMethod(visWindowClass, RESHAPE, ReshapeVisWindow);
spaceWindowClass = NewObject(objWindowClass, 0);
AddToReferenceList(spaceWindowClass);
SetVar(spaceWindowClass, HELPSTRING,
NewString("This is a visualizaton window. On the right is a panel which \
shows the visualization objects shown in the window, the controllers which \
affect the appearance of the object, and some buttons which affect the window \
as a whole or the selected icons. If this panel is not shown, it can be brought \
back with the Toggle Panel item in the Window menu. On the left is a \
3-dimensional space in which \
the visualization object are shown. There is one clear panel in front of the and \
one clear panel behind the space. These panels are used to hold 2-dimensional \
objects such as clock readouts and text boxes, which can be created and modified \
with items in the Text menu."));
/*Class for the corral in a vis window*/
visCorralClass = NewObject(corralClass, 0);
AddToReferenceList(visCorralClass);
SetMethod(visCorralClass, DROPINCONTENTS, DropInVisCorral);
}
void KillVisWindows()
/*Kills the vis windows*/
{
DeleteThing(visCorralClass);
DeleteThing(spaceWindowClass);
DeleteThing(visWindowClass);
DeleteThing(visualizeAsList);
}
|
