/*
* Our class command procedure. This is different from usual class command
* procs as we actually use the SheetCmd() procedure and then carefully
* subvert their actions to our own uses.
*/
static int NamesCmd(ClientData clientData, Tcl_Interp *interp,
int argc, char **argv) {
Tk_Window tkwin;
edNames *en;
if (argc < 2) {
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " pathName ?options?\"", (char *)NULL);
return TCL_ERROR;
}
/*
* Allocate
*/
if (NULL == (en = (edNames *)xmalloc(sizeof(edNames)))) {
return TCL_ERROR;
}
/*
* Call common sheet initialisation code
*/
tkwin = SheetCmdCommon(interp, Tk_MainWindow(interp),
configSpecs, (tkSheet *)en,
argv[1], "EdNames");
if (NULL == tkwin) {
xfree(en);
return TCL_ERROR;
}
/*
* Initialised rest of edNames structure.
*/
en->xx = NULL;
en->xScrollCmd = NULL;
TKSHEET(en)->extensionData = (ClientData)en;
TKSHEET(en)->extension = EdNamesSheetExtension;
/*
* Register our instance of the widget class
*/
Tcl_CreateCommand(interp, Tk_PathName(tkwin),
NamesWidgetCmd, (ClientData)en,
(Tcl_CmdDeleteProc *)NULL);
/*
* And process our arguments - send them to Configure
*/
if (NamesConfigure(interp, en, argc-2, argv+2, 0) != TCL_OK) {
Tk_DestroyWindow(tkwin);
return TCL_ERROR;
}
Tcl_SetResult(interp, Tk_PathName(tkwin), TCL_VOLATILE);
return TCL_OK;
}
static void
imfsample_cmd_deleted_proc(ClientData cldata)
{
Imfsample *imfsample = (Imfsample *) cldata;
Tk_Window tkwin = imfsample->tkwin;
if (tkwin != NULL) {
imfsample->tkwin = NULL;
Tk_DestroyWindow(tkwin);
}
}
int
GraphViewCmd(CLIENT_ARGS)
{
SimGraph *graph;
Tk_Window tkwin = (Tk_Window) clientData;
if (argc < 2) {
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " pathName ?options?\"", (char *) NULL);
return TCL_ERROR;
}
tkwin = Tk_CreateWindowFromPath(interp, tkwin,
argv[1], (char *) NULL);
if (tkwin == NULL) {
return TCL_ERROR;
}
graph = (SimGraph *)ckalloc(sizeof (SimGraph));
graph->tkwin = tkwin;
graph->interp = interp;
graph->flags = 0;
Tk_SetClass(graph->tkwin, "GraphView");
Tk_CreateEventHandler(graph->tkwin,
VisibilityChangeMask |
ExposureMask |
StructureNotifyMask,
SimGraphEventProc, (ClientData) graph);
Tcl_CreateCommand(interp, Tk_PathName(graph->tkwin),
DoGraphCmd, (ClientData) graph, (void (*)()) NULL);
/*
Tk_MakeWindowExist(graph->tkwin);
*/
if (getenv("XSYNCHRONIZE") != NULL) {
XSynchronize(Tk_Display(tkwin), 1);
}
InitNewGraph(graph);
DoNewGraph(graph);
if (ConfigureSimGraph(interp, graph, argc-2, argv+2, 0) != TCL_OK) {
/* XXX: destroy graph */
Tk_DestroyWindow(graph->tkwin);
return TCL_ERROR;
}
interp->result = Tk_PathName(graph->tkwin);
return TCL_OK;
}
void
TkClipCleanup(
TkDisplay *dispPtr) /* Display associated with clipboard */
{
if (dispPtr->clipWindow != NULL) {
Tk_DeleteSelHandler(dispPtr->clipWindow, dispPtr->clipboardAtom,
dispPtr->applicationAtom);
Tk_DeleteSelHandler(dispPtr->clipWindow, dispPtr->clipboardAtom,
dispPtr->windowAtom);
Tk_DestroyWindow(dispPtr->clipWindow);
Tcl_Release((ClientData) dispPtr->clipWindow);
dispPtr->clipWindow = NULL;
}
}
void
TkWmProtocolEventProc(
TkWindow *winPtr, /* Window to which the event was sent. */
XEvent *eventPtr) /* X event. */
{
WmInfo *wmPtr;
ProtocolHandler *protPtr;
Tcl_Interp *interp;
Atom protocol;
int result;
wmPtr = winPtr->wmInfoPtr;
if (wmPtr == NULL) {
return;
}
protocol = (Atom) eventPtr->xclient.data.l[0];
for (protPtr = wmPtr->protPtr; protPtr != NULL;
protPtr = protPtr->nextPtr) {
if (protocol == protPtr->protocol) {
Tcl_Preserve(protPtr);
interp = protPtr->interp;
Tcl_Preserve(interp);
result = Tcl_EvalEx(interp, protPtr->command, -1, TCL_EVAL_GLOBAL);
if (result != TCL_OK) {
Tcl_AddErrorInfo(interp, "\n (command for \"");
Tcl_AddErrorInfo(interp,
Tk_GetAtomName((Tk_Window) winPtr, protocol));
Tcl_AddErrorInfo(interp, "\" window manager protocol)");
Tcl_BackgroundError(interp);
}
Tcl_Release(interp);
Tcl_Release(protPtr);
return;
}
}
/*
* No handler was present for this protocol. If this is a WM_DELETE_WINDOW
* message then just destroy the window.
*/
if (protocol == Tk_InternAtom((Tk_Window) winPtr, "WM_DELETE_WINDOW")) {
Tk_DestroyWindow((Tk_Window) winPtr);
}
}
static void
MenuButtonCmdDeletedProc(
ClientData clientData) /* Pointer to widget record for widget. */
{
TkMenuButton *mbPtr = clientData;
Tk_Window tkwin = mbPtr->tkwin;
/*
* This function could be invoked either because the window was destroyed
* and the command was then deleted (in which case tkwin is NULL) or
* because the command was deleted, and then this function destroys the
* widget.
*/
if (tkwin != NULL) {
Tk_DestroyWindow(tkwin);
}
}
/*
** Delete all input controls. This happens when the HTML widget
** is cleared.
**
** When the TCL "exit" command is invoked, the order of operations
** here is very touchy.
*/
void HtmlDeleteControls(HtmlWidget *htmlPtr){
HtmlElement *p; /* For looping over all controls */
Tcl_Interp *interp; /* The interpreter */
interp = htmlPtr->interp;
p = htmlPtr->firstInput;
htmlPtr->firstInput = 0;
htmlPtr->lastInput = 0;
htmlPtr->nInput = 0;
if( p==0 || htmlPtr->tkwin==0 ) return;
HtmlLock(htmlPtr);
for(; p; p=p->input.pNext){
if( p->input.pForm && p->input.pForm->form.id>0
&& htmlPtr->zFormCommand && htmlPtr->zFormCommand[0]
&& !Tcl_InterpDeleted(interp) && htmlPtr->clipwin ){
Tcl_DString cmd;
int result;
char zBuf[60];
Tcl_DStringInit(&cmd);
Tcl_DStringAppend(&cmd, htmlPtr->zFormCommand, -1);
sprintf(zBuf," %d flush", p->input.pForm->form.id);
Tcl_DStringAppend(&cmd, zBuf, -1);
result = Tcl_GlobalEval(htmlPtr->interp, Tcl_DStringValue(&cmd));
Tcl_DStringFree(&cmd);
if( !Tcl_InterpDeleted(interp) ){
if( result != TCL_OK ){
Tcl_AddErrorInfo(htmlPtr->interp,
"\n (-formcommand flush callback executed by html widget)");
Tcl_BackgroundError(htmlPtr->interp);
TestPoint(0);
}
Tcl_ResetResult(htmlPtr->interp);
}
p->input.pForm->form.id = 0;
}
if( p->input.tkwin ){
if( htmlPtr->clipwin!=0 ) Tk_DestroyWindow(p->input.tkwin);
p->input.tkwin = 0;
}
p->input.sized = 0;
}
HtmlUnlock(htmlPtr);
}
static void
ScaleCmdDeletedProc(
ClientData clientData) /* Pointer to widget record for widget. */
{
TkScale *scalePtr = clientData;
Tk_Window tkwin = scalePtr->tkwin;
/*
* This procedure could be invoked either because the window was destroyed
* and the command was then deleted (in which case tkwin is NULL) or
* because the command was deleted, and then this procedure destroys the
* widget.
*/
if (!(scalePtr->flags & SCALE_DELETED)) {
scalePtr->flags |= SCALE_DELETED;
Tk_DestroyWindow(tkwin);
}
}
/***************************************************************************
* test function
***************************************************************************/
int test() {
int code;
Tcl_Interp *interp;
interp = Tcl_CreateInterp();
Tk_Window tkwin;
tkwin=Tk_CreateMainWindow(interp,"unix:0.0","appName","className");
Tk_Window button;
button=Tk_CreateWindowFromPath(interp,tkwin,".appName","unix:0.0");
Tk_Window what;
what = Tk_NameToWindow(interp,".appName",tkwin);
what = Tk_NameToWindow(interp,".",tkwin);
Tk_MainLoop();
Tk_DestroyWindow(tkwin);
}
static void
DestroyBusy(
char *data) /* Busy window structure record */
{
register Busy *busyPtr = (Busy *) data;
if (busyPtr->hashPtr != NULL) {
Tcl_DeleteHashEntry(busyPtr->hashPtr);
}
Tk_DeleteEventHandler(busyPtr->tkRef, StructureNotifyMask,
RefWinEventProc, busyPtr);
if (busyPtr->tkBusy != NULL) {
Tk_FreeConfigOptions(data, busyPtr->optionTable, busyPtr->tkBusy);
Tk_DeleteEventHandler(busyPtr->tkBusy, StructureNotifyMask,
BusyEventProc, busyPtr);
Tk_ManageGeometry(busyPtr->tkBusy, NULL, busyPtr);
Tk_DestroyWindow(busyPtr->tkBusy);
}
ckfree(data);
}
void
TkTextWinFreeClient(
Tcl_HashEntry *hPtr, /* Hash entry corresponding to this client, or
* NULL */
TkTextEmbWindowClient *client)
/* Client data structure, with the 'tkwin'
* field to be cleaned up. */
{
if (hPtr != NULL) {
/*
* (It's possible for there to be no hash table entry for this window,
* if an error occurred while creating the window segment but before
* the window got added to the table)
*/
Tcl_DeleteHashEntry(hPtr);
}
/*
* Delete the event handler for the window before destroying the window,
* so that EmbWinStructureProc doesn't get called (we'll already do
* everything that it would have done, and it will just get confused).
*/
if (client->tkwin != NULL) {
Tk_DeleteEventHandler(client->tkwin, StructureNotifyMask,
EmbWinStructureProc, client);
Tk_DestroyWindow(client->tkwin);
}
Tcl_CancelIdleCall(EmbWinDelayedUnmap, client);
/*
* Free up this client.
*/
ckfree((char *) client);
}
static Busy *
CreateBusy(
Tcl_Interp *interp, /* Interpreter to report error to */
Tk_Window tkRef) /* Window hosting the busy window */
{
Busy *busyPtr;
int length, x, y;
const char *fmt;
char *name;
Tk_Window tkBusy, tkChild, tkParent;
Window parent;
Tk_FakeWin *winPtr;
busyPtr = (Busy *) ckalloc(sizeof(Busy));
x = y = 0;
length = strlen(Tk_Name(tkRef));
name = ckalloc(length + 6);
if (Tk_IsTopLevel(tkRef)) {
fmt = "_Busy"; /* Child */
tkParent = tkRef;
} else {
Tk_Window tkwin;
fmt = "%s_Busy"; /* Sibling */
tkParent = Tk_Parent(tkRef);
for (tkwin = tkRef; (tkwin != NULL) && !Tk_IsTopLevel(tkwin);
tkwin = Tk_Parent(tkwin)) {
if (tkwin == tkParent) {
break;
}
x += Tk_X(tkwin) + Tk_Changes(tkwin)->border_width;
y += Tk_Y(tkwin) + Tk_Changes(tkwin)->border_width;
}
}
for (tkChild = FirstChild(tkParent); tkChild != NULL;
tkChild = NextChild(tkChild)) {
Tk_MakeWindowExist(tkChild);
}
sprintf(name, fmt, Tk_Name(tkRef));
tkBusy = Tk_CreateWindow(interp, tkParent, name, NULL);
ckfree(name);
if (tkBusy == NULL) {
return NULL;
}
Tk_MakeWindowExist(tkRef);
busyPtr->display = Tk_Display(tkRef);
busyPtr->interp = interp;
busyPtr->tkRef = tkRef;
busyPtr->tkParent = tkParent;
busyPtr->tkBusy = tkBusy;
busyPtr->width = Tk_Width(tkRef);
busyPtr->height = Tk_Height(tkRef);
busyPtr->x = Tk_X(tkRef);
busyPtr->y = Tk_Y(tkRef);
busyPtr->cursor = None;
Tk_SetClass(tkBusy, "Busy");
busyPtr->optionTable = Tk_CreateOptionTable(interp, busyOptionSpecs);
if (Tk_InitOptions(interp, (char *) busyPtr, busyPtr->optionTable,
tkBusy) != TCL_OK) {
Tk_DestroyWindow(tkBusy);
return NULL;
}
SetWindowInstanceData(tkBusy, busyPtr);
winPtr = (Tk_FakeWin *) tkRef;
TkpCreateBusy(winPtr, tkRef, &parent, tkParent, busyPtr);
MakeTransparentWindowExist(tkBusy, parent);
Tk_MoveResizeWindow(tkBusy, x, y, busyPtr->width, busyPtr->height);
/*
* Only worry if the busy window is destroyed.
*/
Tk_CreateEventHandler(tkBusy, StructureNotifyMask, BusyEventProc,
busyPtr);
/*
* Indicate that the busy window's geometry is being managed. This will
* also notify us if the busy window is ever packed.
*/
Tk_ManageGeometry(tkBusy, &busyMgrInfo, busyPtr);
if (busyPtr->cursor != None) {
Tk_DefineCursor(tkBusy, busyPtr->cursor);
}
/*
* Track the reference window to see if it is resized or destroyed.
*/
Tk_CreateEventHandler(tkRef, StructureNotifyMask, RefWinEventProc,
busyPtr);
return busyPtr;
}
int
paxwidget_cmd(ClientData data, Tcl_Interp * interp, int argc, char** argv)
{
Tk_Window tkmain = (Tk_Window) data;
Tk_Window tkwin;
PaxWidget * paxwidget;
char * class_name = NULL;
int i;
if (argc < 2)
{
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " pathName ?options?\"", (char *) NULL);
return TCL_ERROR;
}
/* look for the -class option */
for (i = 2; i < argc; i += 2)
{
int length;
char c;
char * arg;
arg = argv[i];
length = strlen(arg);
if (length < 2)
continue;
c = arg[1];
if ((c == 'c') && (strncmp(arg, "-class", strlen(arg)) == 0)
&& (length >= 3))
{
if (i < argc - 1)
class_name = argv[i+1];
else
fprintf(stderr,
"No argument for -class option, using defaults");
}
}
tkwin = Tk_CreateWindowFromPath(interp, tkmain, argv[1], (char*)NULL);
if (tkwin == NULL)
{
return TCL_ERROR;
}
if (class_name)
Tk_SetClass(tkwin, class_name);
else
Tk_SetClass(tkwin, "PaxWidget");
paxwidget = (PaxWidget*) ckalloc(sizeof(PaxWidget));
if (!paxwidget)
return TCL_ERROR;
paxwidget->tkwin = tkwin;
paxwidget->display = Tk_Display(tkwin);
paxwidget->interp = interp;
paxwidget->widget_cmd = Tcl_CreateCommand(interp, Tk_PathName(tkwin),
paxwidget_widget_cmd,
(ClientData) paxwidget, NULL);
paxwidget->obj = NULL;
paxwidget->width = paxwidget->height = 0;
paxwidget->background = NULL;
paxwidget->background_inited = 0;
paxwidget->cursor = None;
paxwidget->class_name = NULL;
paxwidget->update_pending = 0;
paxwidget->exposed_region = XCreateRegion();
Tk_CreateEventHandler(paxwidget->tkwin, ExposureMask|StructureNotifyMask,
PaxWidgetEventProc, (ClientData) paxwidget);
if (PaxWidgetConfigure(interp, paxwidget, argc - 2, argv + 2, 0) != TCL_OK)
{
Tk_DestroyWindow(paxwidget->tkwin);
return TCL_ERROR;
}
Tcl_SetResult(interp, Tk_PathName(paxwidget->tkwin), TCL_VOLATILE);
return TCL_OK;
}
static void
ContainerEventProc(
ClientData clientData, /* Token for container window. */
XEvent *eventPtr) /* ResizeRequest event. */
{
TkWindow *winPtr = clientData;
Container *containerPtr;
Tk_ErrorHandler errHandler;
/*
* Ignore any X protocol errors that happen in this procedure (almost any
* operation could fail, for example, if the embedded application has
* deleted its window).
*/
errHandler = Tk_CreateErrorHandler(eventPtr->xfocus.display, -1,
-1, -1, NULL, NULL);
/*
* Find the Container structure associated with the parent window.
*/
for (containerPtr = firstContainerPtr;
containerPtr->parent != eventPtr->xmaprequest.parent;
containerPtr = containerPtr->nextPtr) {
if (containerPtr == NULL) {
Tcl_Panic("ContainerEventProc couldn't find Container record");
}
}
if (eventPtr->type == CreateNotify) {
/*
* A new child window has been created in the container. Record its id
* in the Container structure (if more than one child is created, just
* remember the last one and ignore the earlier ones).
*/
containerPtr->embedded = eventPtr->xcreatewindow.window;
} else if (eventPtr->type == ConfigureRequest) {
if ((eventPtr->xconfigurerequest.x != 0)
|| (eventPtr->xconfigurerequest.y != 0)) {
/*
* The embedded application is trying to move itself, which isn't
* legal. At this point, the window hasn't actually moved, but we
* need to send it a ConfigureNotify event to let it know that its
* request has been denied. If the embedded application was also
* trying to resize itself, a ConfigureNotify will be sent by the
* geometry management code below, so we don't need to do
* anything. Otherwise, generate a synthetic event.
*/
if ((eventPtr->xconfigurerequest.width == winPtr->changes.width)
&& (eventPtr->xconfigurerequest.height
== winPtr->changes.height)) {
EmbedSendConfigure(containerPtr);
}
}
EmbedGeometryRequest(containerPtr,
eventPtr->xconfigurerequest.width,
eventPtr->xconfigurerequest.height);
} else if (eventPtr->type == MapRequest) {
/*
* The embedded application's map request was ignored and simply
* passed on to us, so we have to map the window for it to appear on
* the screen.
*/
XMapWindow(eventPtr->xmaprequest.display,
eventPtr->xmaprequest.window);
} else if (eventPtr->type == DestroyNotify) {
/*
* The embedded application is gone. Destroy the container window.
*/
Tk_DestroyWindow((Tk_Window) winPtr);
}
Tk_DeleteErrorHandler(errHandler);
}
int
Tk_MenubuttonObjCmd(
ClientData clientData, /* NULL. */
Tcl_Interp *interp, /* Current interpreter. */
int objc, /* Number of arguments. */
Tcl_Obj *const objv[]) /* Argument objects. */
{
register TkMenuButton *mbPtr;
Tk_OptionTable optionTable;
Tk_Window tkwin;
if (objc < 2) {
Tcl_WrongNumArgs(interp, 1, objv, "pathName ?-option value ...?");
return TCL_ERROR;
}
/*
* Create the new window.
*/
tkwin = Tk_CreateWindowFromPath(interp, Tk_MainWindow(interp),
Tcl_GetString(objv[1]), NULL);
if (tkwin == NULL) {
return TCL_ERROR;
}
/*
* Create the option table for this widget class. If it has already been
* created, the cached pointer will be returned.
*/
optionTable = Tk_CreateOptionTable(interp, optionSpecs);
Tk_SetClass(tkwin, "Menubutton");
mbPtr = TkpCreateMenuButton(tkwin);
Tk_SetClassProcs(tkwin, &tkpMenubuttonClass, mbPtr);
/*
* Initialize the data structure for the button.
*/
mbPtr->tkwin = tkwin;
mbPtr->display = Tk_Display (tkwin);
mbPtr->interp = interp;
mbPtr->widgetCmd = Tcl_CreateObjCommand(interp,
Tk_PathName(mbPtr->tkwin), MenuButtonWidgetObjCmd, mbPtr,
MenuButtonCmdDeletedProc);
mbPtr->optionTable = optionTable;
mbPtr->menuName = NULL;
mbPtr->text = NULL;
mbPtr->underline = -1;
mbPtr->textVarName = NULL;
mbPtr->bitmap = None;
mbPtr->imageString = NULL;
mbPtr->image = NULL;
mbPtr->state = STATE_NORMAL;
mbPtr->normalBorder = NULL;
mbPtr->activeBorder = NULL;
mbPtr->borderWidth = 0;
mbPtr->relief = TK_RELIEF_FLAT;
mbPtr->highlightWidth = 0;
mbPtr->highlightBgColorPtr = NULL;
mbPtr->highlightColorPtr = NULL;
mbPtr->inset = 0;
mbPtr->tkfont = NULL;
mbPtr->normalFg = NULL;
mbPtr->activeFg = NULL;
mbPtr->disabledFg = NULL;
mbPtr->normalTextGC = None;
mbPtr->activeTextGC = None;
mbPtr->gray = None;
mbPtr->disabledGC = None;
mbPtr->stippleGC = None;
mbPtr->leftBearing = 0;
mbPtr->rightBearing = 0;
mbPtr->widthString = NULL;
mbPtr->heightString = NULL;
mbPtr->width = 0;
mbPtr->width = 0;
mbPtr->wrapLength = 0;
mbPtr->padX = 0;
mbPtr->padY = 0;
mbPtr->anchor = TK_ANCHOR_CENTER;
mbPtr->justify = TK_JUSTIFY_CENTER;
mbPtr->textLayout = NULL;
mbPtr->indicatorOn = 0;
mbPtr->indicatorWidth = 0;
mbPtr->indicatorHeight = 0;
mbPtr->direction = DIRECTION_FLUSH;
mbPtr->cursor = None;
mbPtr->takeFocus = NULL;
mbPtr->flags = 0;
Tk_CreateEventHandler(mbPtr->tkwin,
ExposureMask|StructureNotifyMask|FocusChangeMask,
MenuButtonEventProc, mbPtr);
if (Tk_InitOptions(interp, (char *) mbPtr, optionTable, tkwin) != TCL_OK) {
Tk_DestroyWindow(mbPtr->tkwin);
return TCL_ERROR;
}
if (ConfigureMenuButton(interp, mbPtr, objc-2, objv+2) != TCL_OK) {
Tk_DestroyWindow(mbPtr->tkwin);
return TCL_ERROR;
}
Tcl_SetObjResult(interp, TkNewWindowObj(mbPtr->tkwin));
return TCL_OK;
}
int
Tk_ScaleObjCmd(
ClientData clientData, /* NULL. */
Tcl_Interp *interp, /* Current interpreter. */
int objc, /* Number of arguments. */
Tcl_Obj *const objv[]) /* Argument values. */
{
register TkScale *scalePtr;
Tk_OptionTable optionTable;
Tk_Window tkwin;
if (objc < 2) {
Tcl_WrongNumArgs(interp, 1, objv, "pathName ?-option value ...?");
return TCL_ERROR;
}
tkwin = Tk_CreateWindowFromPath(interp, Tk_MainWindow(interp),
Tcl_GetString(objv[1]), NULL);
if (tkwin == NULL) {
return TCL_ERROR;
}
/*
* Create the option table for this widget class. If it has already been
* created, the cached pointer will be returned.
*/
optionTable = Tk_CreateOptionTable(interp, optionSpecs);
Tk_SetClass(tkwin, "Scale");
scalePtr = TkpCreateScale(tkwin);
/*
* Initialize fields that won't be initialized by ConfigureScale, or which
* ConfigureScale expects to have reasonable values (e.g. resource
* pointers).
*/
scalePtr->tkwin = tkwin;
scalePtr->display = Tk_Display(tkwin);
scalePtr->interp = interp;
scalePtr->widgetCmd = Tcl_CreateObjCommand(interp,
Tk_PathName(scalePtr->tkwin), ScaleWidgetObjCmd,
scalePtr, ScaleCmdDeletedProc);
scalePtr->optionTable = optionTable;
scalePtr->orient = ORIENT_VERTICAL;
scalePtr->width = 0;
scalePtr->length = 0;
scalePtr->value = 0.0;
scalePtr->varNamePtr = NULL;
scalePtr->fromValue = 0.0;
scalePtr->toValue = 0.0;
scalePtr->tickInterval = 0.0;
scalePtr->resolution = 1.0;
scalePtr->digits = 0;
scalePtr->bigIncrement = 0.0;
scalePtr->command = NULL;
scalePtr->repeatDelay = 0;
scalePtr->repeatInterval = 0;
scalePtr->label = NULL;
scalePtr->labelLength = 0;
scalePtr->state = STATE_NORMAL;
scalePtr->borderWidth = 0;
scalePtr->bgBorder = NULL;
scalePtr->activeBorder = NULL;
scalePtr->sliderRelief = TK_RELIEF_RAISED;
scalePtr->troughColorPtr = NULL;
scalePtr->troughGC = None;
scalePtr->copyGC = None;
scalePtr->tkfont = NULL;
scalePtr->textColorPtr = NULL;
scalePtr->textGC = None;
scalePtr->relief = TK_RELIEF_FLAT;
scalePtr->highlightWidth = 0;
scalePtr->highlightBorder = NULL;
scalePtr->highlightColorPtr = NULL;
scalePtr->inset = 0;
scalePtr->sliderLength = 0;
scalePtr->showValue = 0;
scalePtr->horizLabelY = 0;
scalePtr->horizValueY = 0;
scalePtr->horizTroughY = 0;
scalePtr->horizTickY = 0;
scalePtr->vertTickRightX = 0;
scalePtr->vertValueRightX = 0;
scalePtr->vertTroughX = 0;
scalePtr->vertLabelX = 0;
scalePtr->fontHeight = 0;
scalePtr->cursor = None;
scalePtr->takeFocusPtr = NULL;
scalePtr->flags = NEVER_SET;
Tk_SetClassProcs(scalePtr->tkwin, &scaleClass, scalePtr);
Tk_CreateEventHandler(scalePtr->tkwin,
ExposureMask|StructureNotifyMask|FocusChangeMask,
ScaleEventProc, scalePtr);
if ((Tk_InitOptions(interp, (char *) scalePtr, optionTable, tkwin)
!= TCL_OK) ||
(ConfigureScale(interp, scalePtr, objc - 2, objv + 2) != TCL_OK)) {
Tk_DestroyWindow(scalePtr->tkwin);
return TCL_ERROR;
}
Tcl_SetObjResult(interp, TkNewWindowObj(scalePtr->tkwin));
return TCL_OK;
}
int
imfsample_cmd(ClientData cldata, Tcl_Interp *interp, int argc, char *argv[])
{
Tk_Window mainw = (Tk_Window) cldata;
Imfsample *imfsample;
Tk_Window tkwin;
if (argc < 2) {
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " pathName ?options?\"", (char *) NULL);
return TCL_ERROR;
}
tkwin = Tk_CreateWindowFromPath(interp, mainw, argv[1], (char *) NULL);
if (tkwin == NULL)
return TCL_ERROR;
Tk_SetClass(tkwin, "Imfsample");
/* Allocate and initialize the widget record. */
imfsample = (Imfsample *) ckalloc(sizeof(Imfsample));
imfsample->tkwin = tkwin;
imfsample->display = Tk_Display(tkwin);
imfsample->interp = interp;
imfsample->widgetCmd =
Tcl_CreateCommand(interp,
Tk_PathName(imfsample->tkwin), imfsample_widget_cmd,
(ClientData) imfsample, imfsample_cmd_deleted_proc);
imfsample->border_width = 0;
imfsample->bg_border = NULL;
imfsample->fg_border = NULL;
imfsample->cu_border = NULL;
imfsample->relief = TK_RELIEF_FLAT;
imfsample->copygc = None;
imfsample->gc = None;
imfsample->double_buffer = 1;
imfsample->update_pending = 0;
imfsample->show_color = 1;
imfsample->show_names = 0;
imfsample->show_masks = 0;
imfsample->show_grid = 0;
imfsample->fill_color = NULL;
imfsample->with_terrain = -1;
imfsample->with_emblem = -1;
imfsample->main_imf_name = "";
imfsample->numimages = 0;
imfsample->imf_list =
(ImageFamily **) xmalloc(MAXIMAGEFAMILIES * sizeof(ImageFamily *));
imfsample->numvisrows = 0;
imfsample->firstvisrow = 0;
/* IMFApp-specific stuff. */
imfsample->imfapp = 0;
imfsample->selected = -1;
imfsample->previous = -1;
imfsample->oldfirst = 0;
imfsample->redraw = 0;
Tk_CreateEventHandler(imfsample->tkwin, ExposureMask|StructureNotifyMask,
imfsample_event_proc, (ClientData) imfsample);
if (imfsample_configure(interp, imfsample, argc-2, argv+2, 0) != TCL_OK) {
Tk_DestroyWindow(imfsample->tkwin);
return TCL_ERROR;
}
Tcl_SetResult(interp, Tk_PathName(imfsample->tkwin), TCL_VOLATILE);
return TCL_OK;
}
