static void
imfsample_event_proc(ClientData cldata, XEvent *eventPtr)
{
Imfsample *imfsample = (Imfsample *) cldata;
if (eventPtr->type == Expose) {
if (!imfsample->update_pending) {
Tcl_DoWhenIdle(imfsample_display, cldata);
imfsample->update_pending = 1;
}
} else if (eventPtr->type == ConfigureNotify) {
if (!imfsample->update_pending) {
Tcl_DoWhenIdle(imfsample_display, cldata);
imfsample->update_pending = 1;
}
} else if (eventPtr->type == DestroyNotify) {
if (imfsample->tkwin != NULL) {
imfsample->tkwin = NULL;
Tcl_DeleteCommand(imfsample->interp,
Tcl_GetCommandName(imfsample->interp,
imfsample->widgetCmd));
}
if (imfsample->update_pending) {
Tcl_CancelIdleCall(imfsample_display, cldata);
}
Tcl_EventuallyFree(cldata, imfsample_destroy);
}
}
/* Callback function when an event happens */
static void
IconEvent (ClientData clientData, register XEvent *eventPtr)
{
TrayIcon *icon = (TrayIcon *)clientData;
if ((eventPtr->type == Expose) && (eventPtr->xexpose.count == 0)) {
if (icon->win != NULL)
/*horrible hack to redraw the icon when dragging the dock aroun the panels*/
Tcl_DoWhenIdle (DrawIcon, icon);
goto redraw;
} else if (eventPtr->type == ConfigureNotify || eventPtr->type == ResizeRequest) {
icon->mustUpdate=True;
goto redraw;
} /*else if (eventPtr->type == EnterNotify) {
if (timer == NULL) {
timer = Tcl_CreateTimerHandler(500, show_tooltip, icon);
}
} else if (eventPtr->type == LeaveNotify) {
if (tooltip==1)
remove_tooltip();
if (timer != NULL) {
Tcl_DeleteTimerHandler(timer);
timer=NULL;
}
}*/
return;
redraw:
if ((icon->win != NULL)) {
Tcl_DoWhenIdle(DrawIcon, (ClientData) icon);
}
}
/* TtkScrolled --
* Update scroll info, schedule scrollbar update.
*/
void TtkScrolled(ScrollHandle h, int first, int last, int total)
{
Scrollable *s = h->scrollPtr;
/* Sanity-check inputs:
*/
if (total <= 0) {
first = 0;
last = 1;
total = 1;
}
if (last > total) {
first -= (last - total);
if (first < 0) first = 0;
last = total;
}
if (s->first != first || s->last != last || s->total != total
|| (h->flags & SCROLL_UPDATE_REQUIRED))
{
s->first = first;
s->last = last;
s->total = total;
if (!(h->flags & SCROLL_UPDATE_PENDING)) {
Tcl_DoWhenIdle(UpdateScrollbarBG, (ClientData)h);
h->flags |= SCROLL_UPDATE_PENDING;
}
}
}
/*
* ThemeChanged --
* Schedule a call to ThemeChanged if one is not already pending.
*/
static void ThemeChanged(StylePackageData *pkgPtr)
{
if (!pkgPtr->themeChangePending) {
Tcl_DoWhenIdle(ThemeChangedProc, pkgPtr);
pkgPtr->themeChangePending = 1;
}
}
static void
EmbWinUndisplayProc(
TkText *textPtr, /* Overall information about text widget. */
TkTextDispChunk *chunkPtr) /* Chunk that is about to be freed. */
{
TkTextSegment *ewPtr = chunkPtr->clientData;
TkTextEmbWindowClient *client = EmbWinGetClient(textPtr, ewPtr);
if (client == NULL) {
return;
}
client->chunkCount--;
if (client->chunkCount == 0) {
/*
* Don't unmap the window immediately, since there's a good chance
* that it will immediately be redisplayed, perhaps even in the same
* place. Instead, schedule the window to be unmapped later; the call
* to EmbWinDelayedUnmap will be cancelled in the likely event that
* the unmap becomes unnecessary.
*/
client->displayed = 0;
Tcl_DoWhenIdle(EmbWinDelayedUnmap, client);
}
}
/* ++ ScheduleUpdate --
* Schedule a call to recompute the size and/or layout,
* depending on flags.
*/
static void ScheduleUpdate(Ttk_Manager *mgr, unsigned flags)
{
if (!(mgr->flags & MGR_UPDATE_PENDING)) {
Tcl_DoWhenIdle(ManagerIdleProc, mgr);
mgr->flags |= MGR_UPDATE_PENDING;
}
mgr->flags |= flags;
}
void Signal_KillGraphicsProc(int i) {
signal(SIGUSR1,SIG_IGN);
#ifdef Tcl75_Tk41
Tcl_DoWhenIdle((Tcl_IdleProc*) C_KillGraphicsProc,(ClientData)NULL);
#endif
#ifdef Tcl74_Tk40
Tk_DoWhenIdle((Tk_IdleProc*) C_KillGraphicsProc,(ClientData)NULL);
#endif
}
int C_RunProc()
{
theRunFlag=TRUE;
#ifdef Tcl75_Tk41
Tcl_DoWhenIdle(DoMain,(ClientData)NULL);
#endif
#ifdef Tcl74_Tk40
Tk_DoWhenIdle(DoMain,(ClientData)NULL);
#endif
return TCL_OK;
}
int C_StepProc()
{
if(theRunFlag==TRUE) {
Tcl_Eval(interp,".lbframe.run invoke\n");
}
#ifdef Tcl75_Tk41
Tcl_DoWhenIdle(DoMain,(ClientData)NULL);
#endif
#ifdef Tcl74_Tk40
Tk_DoWhenIdle(DoMain,(ClientData)NULL);
#endif
return TCL_OK;
}
static void
ImageChangedProc (ClientData clientData,
int x,
int y,
int width,
int height,
int imageWidth,
int imageHeight)
{
TrayIcon *icon = (TrayIcon *)clientData;
icon->mustUpdate=True;
Tcl_DoWhenIdle(DrawIcon, clientData);
}
/*
*---------------------------------------------------------------------------
*
* imageChanged --
*
* Image-changed callback.
*
* Results:
* None.
*
* Side effects:
* None.
*
*---------------------------------------------------------------------------
*/
static void
imageChanged(
ClientData clientData,
int x,
int y,
int width,
int height,
int imgWidth,
int imgHeight
)
{
HtmlImage2 *pImage = (HtmlImage2 *)clientData;
if (pImage && !pImage->pUnscaled && !pImage->nIgnoreChange) {
HtmlImage2 *p;
HtmlTree *pTree = pImage->pImageServer->pTree;
assert(pImage->image);
for (p = pImage->pNext; p; p = p->pNext) {
p->isValid = 0;
assert(!p->pTileName);
}
freeTile(pImage);
pImage->eAlpha = ALPHA_CHANNEL_UNKNOWN;
/* Delete the pixmap/compressed-data representation */
if( pImage->pixmap ){
Tk_FreePixmap(Tk_Display(pTree->tkwin), pImage->pixmap);
pImage->pixmap = 0;
}
freeImageCompressed(pImage);
if (imgWidth!=pImage->width || imgHeight!=pImage->height) {
pImage->width = imgWidth;
pImage->height = imgHeight;
HtmlWalkTree(pTree, 0, imageChangedCb, (ClientData)pImage);
}
Tcl_DoWhenIdle(asyncPixmapify, (ClientData)pImage);
/* If the image contents have been modified but the size is
* constant, then just redraw the display. This is lazy. If
* there were an efficient way to determine the minimum region
* to draw, then stuff like animated gifs would be much more
* efficient.
*/
HtmlCallbackDamage(pTree, 0, 0, 1000000, 1000000);
}
}
void
TkEventuallyRedrawScale(
register TkScale *scalePtr, /* Information about widget. */
int what) /* What to redraw: REDRAW_SLIDER or
* REDRAW_ALL. */
{
if ((what == 0) || (scalePtr->tkwin == NULL)
|| !Tk_IsMapped(scalePtr->tkwin)) {
return;
}
if (!(scalePtr->flags & REDRAW_PENDING)) {
scalePtr->flags |= REDRAW_PENDING;
Tcl_DoWhenIdle(TkpDisplayScale, scalePtr);
}
scalePtr->flags |= what;
}
/* ARGSUSED */
static char *
MenuButtonTextVarProc(
ClientData clientData, /* Information about button. */
Tcl_Interp *interp, /* Interpreter containing variable. */
const char *name1, /* Name of variable. */
const char *name2, /* Second part of variable name. */
int flags) /* Information about what happened. */
{
register TkMenuButton *mbPtr = clientData;
const char *value;
unsigned len;
/*
* If the variable is unset, then immediately recreate it unless the whole
* interpreter is going away.
*/
if (flags & TCL_TRACE_UNSETS) {
if ((flags & TCL_TRACE_DESTROYED) && !(flags & TCL_INTERP_DESTROYED)) {
Tcl_SetVar(interp, mbPtr->textVarName, mbPtr->text,
TCL_GLOBAL_ONLY);
Tcl_TraceVar(interp, mbPtr->textVarName,
TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
MenuButtonTextVarProc, clientData);
}
return NULL;
}
value = Tcl_GetVar(interp, mbPtr->textVarName, TCL_GLOBAL_ONLY);
if (value == NULL) {
value = "";
}
if (mbPtr->text != NULL) {
ckfree(mbPtr->text);
}
len = 1 + (unsigned) strlen(value);
mbPtr->text = (char *) ckalloc(len);
memcpy(mbPtr->text, value, len);
TkpComputeMenuButtonGeometry(mbPtr);
if ((mbPtr->tkwin != NULL) && Tk_IsMapped(mbPtr->tkwin)
&& !(mbPtr->flags & REDRAW_PENDING)) {
Tcl_DoWhenIdle(TkpDisplayMenuButton, mbPtr);
mbPtr->flags |= REDRAW_PENDING;
}
return NULL;
}
static int
imfsample_configure(Tcl_Interp *interp, Imfsample *imfsample,
int argc, char **argv, int flags)
{
/* Interpret the configuration arguments according to the specs. */
if (Tk_ConfigureWidget(interp, imfsample->tkwin, config_specs,
argc, argv, (char *) imfsample, flags) != TCL_OK)
return TCL_ERROR;
/* Set the background for the window and create a graphics context
for use during redisplay. */
Tk_SetWindowBackground(imfsample->tkwin,
Tk_3DBorderColor(imfsample->fg_border)->pixel);
Tk_SetWindowBackground(imfsample->tkwin,
Tk_3DBorderColor(imfsample->bg_border)->pixel);
Tk_SetWindowBackground(imfsample->tkwin,
Tk_3DBorderColor(imfsample->cu_border)->pixel);
if ((imfsample->copygc == None) && 1/*imfsample->double_buffer*/) {
XGCValues gcValues;
gcValues.function = GXcopy;
gcValues.graphics_exposures = False;
imfsample->copygc = XCreateGC(imfsample->display,
DefaultRootWindow(imfsample->display),
GCFunction|GCGraphicsExposures,
&gcValues);
}
if (imfsample->gc == None) {
imfsample->gc = XCreateGC(imfsample->display,
DefaultRootWindow(imfsample->display),
None, NULL);
}
/* Register the desired geometry for the window, then arrange for
the window to be redisplayed. */
Tk_GeometryRequest(imfsample->tkwin, imfsample->width, imfsample->height);
Tk_SetInternalBorder(imfsample->tkwin, imfsample->border_width);
/* Make sure the resized widget is redrawn. */
imfsample->redraw = TRUE;
if (!imfsample->update_pending) {
Tcl_DoWhenIdle(imfsample_display, (ClientData) imfsample);
imfsample->update_pending = 1;
}
return TCL_OK;
}
static void
MenuButtonImageProc(
ClientData clientData, /* Pointer to widget record. */
int x, int y, /* Upper left pixel (within image) that must
* be redisplayed. */
int width, int height, /* Dimensions of area to redisplay (may be <=
* 0). */
int imgWidth, int imgHeight)/* New dimensions of image. */
{
register TkMenuButton *mbPtr = clientData;
if (mbPtr->tkwin != NULL) {
TkpComputeMenuButtonGeometry(mbPtr);
if (Tk_IsMapped(mbPtr->tkwin) && !(mbPtr->flags & REDRAW_PENDING)) {
Tcl_DoWhenIdle(TkpDisplayMenuButton, mbPtr);
mbPtr->flags |= REDRAW_PENDING;
}
}
}
int
Tclivy_Init(Tcl_Interp *interp)
{
Tcl_CreateCommand(interp, "Ivy::init", (Tcl_CmdProc*)IvyInitCmd, NULL, NULL);
Tcl_CreateCommand(interp, "Ivy::start", (Tcl_CmdProc*)IvyStartCmd, NULL, NULL);
Tcl_CreateCommand(interp, "Ivy::bind", (Tcl_CmdProc*)IvyBindCmd, NULL, NULL);
Tcl_CreateCommand(interp, "Ivy::unbind", (Tcl_CmdProc*)IvyUnbindCmd, NULL, NULL);
Tcl_CreateCommand(interp, "Ivy::send", (Tcl_CmdProc*)IvySendCmd, NULL, NULL);
Tcl_CreateCommand(interp, "Ivy::senddirect", (Tcl_CmdProc*)IvySendDirectCmd, NULL, NULL);
Tcl_CreateCommand(interp, "Ivy::binddirect", (Tcl_CmdProc*)IvyBindDirectCmd, NULL, NULL);
Tcl_CreateCommand(interp, "Ivy::applist", (Tcl_CmdProc*)IvyApplicationListCmd, NULL, NULL);
Tcl_CreateCommand(interp, "Ivy::apphost", (Tcl_CmdProc*)IvyApplicationHostCmd, NULL, NULL);
Tcl_CreateCommand(interp, "Ivy::appmsgs", (Tcl_CmdProc*)IvyApplicationMsgsCmd, NULL, NULL);
#ifndef TCL_CHANNEL_INTEGRATION
Tcl_DoWhenIdle(IvyIdleProc,0);
#endif
return TCL_OK;
}
/* ARGSUSED */
static void
PlaceRequestProc(
ClientData clientData, /* Pointer to our record for slave. */
Tk_Window tkwin) /* Window that changed its desired size. */
{
Slave *slavePtr = clientData;
Master *masterPtr;
if ((slavePtr->flags & (CHILD_WIDTH|CHILD_REL_WIDTH))
&& (slavePtr->flags & (CHILD_HEIGHT|CHILD_REL_HEIGHT))) {
return;
}
masterPtr = slavePtr->masterPtr;
if (masterPtr == NULL) {
return;
}
if (!(masterPtr->flags & PARENT_RECONFIG_PENDING)) {
masterPtr->flags |= PARENT_RECONFIG_PENDING;
Tcl_DoWhenIdle(RecomputePlacement, masterPtr);
}
}
static void
MenuButtonEventProc(
ClientData clientData, /* Information about window. */
XEvent *eventPtr) /* Information about event. */
{
TkMenuButton *mbPtr = clientData;
if ((eventPtr->type == Expose) && (eventPtr->xexpose.count == 0)) {
goto redraw;
} else if (eventPtr->type == ConfigureNotify) {
/*
* Must redraw after size changes, since layout could have changed and
* borders will need to be redrawn.
*/
goto redraw;
} else if (eventPtr->type == DestroyNotify) {
DestroyMenuButton((char *) mbPtr);
} else if (eventPtr->type == FocusIn) {
if (eventPtr->xfocus.detail != NotifyInferior) {
mbPtr->flags |= GOT_FOCUS;
if (mbPtr->highlightWidth > 0) {
goto redraw;
}
}
} else if (eventPtr->type == FocusOut) {
if (eventPtr->xfocus.detail != NotifyInferior) {
mbPtr->flags &= ~GOT_FOCUS;
if (mbPtr->highlightWidth > 0) {
goto redraw;
}
}
}
return;
redraw:
if ((mbPtr->tkwin != NULL) && !(mbPtr->flags & REDRAW_PENDING)) {
Tcl_DoWhenIdle(TkpDisplayMenuButton, mbPtr);
mbPtr->flags |= REDRAW_PENDING;
}
}
static void
ButtonEventProc(
ClientData clientData, /* Information about window. */
XEvent *eventPtr) /* Information about event. */
{
TkButton *buttonPtr = (TkButton *) clientData;
MacButton *mbPtr = (MacButton *) clientData;
if (eventPtr->type == ActivateNotify
|| eventPtr->type == DeactivateNotify) {
if ((buttonPtr->tkwin == NULL) || (!Tk_IsMapped(buttonPtr->tkwin))) {
return;
}
if (eventPtr->type == ActivateNotify) {
mbPtr->flags |= ACTIVE;
} else {
mbPtr->flags &= ~ACTIVE;
}
if ((buttonPtr->flags & REDRAW_PENDING) == 0) {
Tcl_DoWhenIdle(TkpDisplayButton, (ClientData) buttonPtr);
buttonPtr->flags |= REDRAW_PENDING;
}
}
}
static void
MasterStructureProc(
ClientData clientData, /* Pointer to Master structure for window
* referred to by eventPtr. */
XEvent *eventPtr) /* Describes what just happened. */
{
register Master *masterPtr = clientData;
register Slave *slavePtr, *nextPtr;
TkDisplay *dispPtr = ((TkWindow *) masterPtr->tkwin)->dispPtr;
switch (eventPtr->type) {
case ConfigureNotify:
if ((masterPtr->slavePtr != NULL)
&& !(masterPtr->flags & PARENT_RECONFIG_PENDING)) {
masterPtr->flags |= PARENT_RECONFIG_PENDING;
Tcl_DoWhenIdle(RecomputePlacement, masterPtr);
}
return;
case DestroyNotify:
for (slavePtr = masterPtr->slavePtr; slavePtr != NULL;
slavePtr = nextPtr) {
slavePtr->masterPtr = NULL;
nextPtr = slavePtr->nextPtr;
slavePtr->nextPtr = NULL;
}
Tcl_DeleteHashEntry(Tcl_FindHashEntry(&dispPtr->masterTable,
(char *) masterPtr->tkwin));
if (masterPtr->flags & PARENT_RECONFIG_PENDING) {
Tcl_CancelIdleCall(RecomputePlacement, masterPtr);
}
masterPtr->tkwin = NULL;
if (masterPtr->abortPtr != NULL) {
*masterPtr->abortPtr = 1;
}
Tcl_EventuallyFree(masterPtr, TCL_DYNAMIC);
return;
case MapNotify:
/*
* When a master gets mapped, must redo the geometry computation so
* that all of its slaves get remapped.
*/
if ((masterPtr->slavePtr != NULL)
&& !(masterPtr->flags & PARENT_RECONFIG_PENDING)) {
masterPtr->flags |= PARENT_RECONFIG_PENDING;
Tcl_DoWhenIdle(RecomputePlacement, masterPtr);
}
return;
case UnmapNotify:
/*
* Unmap all of the slaves when the master gets unmapped, so that they
* don't keep redisplaying themselves.
*/
for (slavePtr = masterPtr->slavePtr; slavePtr != NULL;
slavePtr = slavePtr->nextPtr) {
Tk_UnmapWindow(slavePtr->tkwin);
}
return;
}
}
int
TkpUseWindow(
Tcl_Interp *interp, /* If not NULL, used for error reporting if
* string is bogus. */
Tk_Window tkwin, /* Tk window that does not yet have an
* associated X window. */
CONST char *string) /* String identifying an X window to use for
* tkwin; must be an integer value. */
{
TkWindow *winPtr = (TkWindow *) tkwin;
int id;
HWND hwnd;
/*
ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
*/
/*
if (winPtr->window != None) {
Tcl_AppendResult(interp,
"can't modify container after widget is created", NULL);
return TCL_ERROR;
}
*/
if (strcmp(string, "") == 0) {
if (winPtr->flags & TK_EMBEDDED) {
Tk_DetachEmbeddedWindow(winPtr, TRUE);
}
return TCL_OK;
}
if (Tcl_GetInt(interp, string, &id) != TCL_OK) {
return TCL_ERROR;
}
hwnd = (HWND) id;
if ((HWND)winPtr->privatePtr == hwnd) {
return TCL_OK;
}
/*
* Check if the window is a valid handle. If it is invalid, return
* TCL_ERROR and potentially leave an error message in the interp's
* result.
*/
if (!IsWindow(hwnd)) {
if (interp != NULL) {
Tcl_AppendResult(interp, "window \"", string,
"\" doesn't exist", NULL);
}
return TCL_ERROR;
}
id = SendMessage(hwnd, TK_INFO, TK_CONTAINER_VERIFY, 0);
if (id == (long)hwnd) {
if (!SendMessage(hwnd, TK_INFO, TK_CONTAINER_ISAVAILABLE, 0)) {
Tcl_AppendResult(interp, "The container is already in use", NULL);
return TCL_ERROR;
}
} else if (id == -(long)hwnd) {
Tcl_AppendResult(interp, "the window to use is not a Tk container",
NULL);
return TCL_ERROR;
} else {
/*
* Proceed if the user decide to do so because it can be a legacy
* container application. However we may have to return a TCL_ERROR in
* order to avoid bug 1096074 in future.
*/
char msg[256];
sprintf(msg, "Unable to get information of window \"%.80s\". Attach to this\nwindow may have unpredictable results if it is not a valid container.\n\nPress Ok to proceed or Cancel to abort attaching.", string);
if (IDCANCEL == MessageBox(hwnd, msg, "Tk Warning",
MB_OKCANCEL | MB_ICONWARNING)) {
Tcl_SetResult(interp, "Operation has been canceled", TCL_STATIC);
return TCL_ERROR;
}
}
Tk_DetachEmbeddedWindow(winPtr, FALSE);
/*
* Store the parent window in the platform private data slot so
* TkWmMapWindow can use it when creating the wrapper window.
*/
winPtr->privatePtr = (struct TkWindowPrivate*) hwnd;
winPtr->flags |= TK_EMBEDDED;
winPtr->flags &= ~(TK_MAPPED);
/*
* Preserve the winPtr and create an idle handler to map the embedded
* window.
*/
Tcl_Preserve((ClientData) winPtr);
Tcl_DoWhenIdle((Tcl_IdleProc*) Tk_MapEmbeddedWindow, (ClientData) winPtr);
return TCL_OK;
}
void
TkMenuButtonWorldChanged(
ClientData instanceData) /* Information about widget. */
{
XGCValues gcValues;
GC gc;
unsigned long mask;
TkMenuButton *mbPtr = instanceData;
gcValues.font = Tk_FontId(mbPtr->tkfont);
gcValues.foreground = mbPtr->normalFg->pixel;
gcValues.background = Tk_3DBorderColor(mbPtr->normalBorder)->pixel;
/*
* Note: GraphicsExpose events are disabled in GC's because they're used
* to copy stuff from an off-screen pixmap onto the screen (we know that
* there's no problem with obscured areas).
*/
gcValues.graphics_exposures = False;
mask = GCForeground | GCBackground | GCFont | GCGraphicsExposures;
gc = Tk_GetGC(mbPtr->tkwin, mask, &gcValues);
if (mbPtr->normalTextGC != None) {
Tk_FreeGC(mbPtr->display, mbPtr->normalTextGC);
}
mbPtr->normalTextGC = gc;
gcValues.foreground = mbPtr->activeFg->pixel;
gcValues.background = Tk_3DBorderColor(mbPtr->activeBorder)->pixel;
mask = GCForeground | GCBackground | GCFont;
gc = Tk_GetGC(mbPtr->tkwin, mask, &gcValues);
if (mbPtr->activeTextGC != None) {
Tk_FreeGC(mbPtr->display, mbPtr->activeTextGC);
}
mbPtr->activeTextGC = gc;
gcValues.background = Tk_3DBorderColor(mbPtr->normalBorder)->pixel;
/*
* Create the GC that can be used for stippling
*/
if (mbPtr->stippleGC == None) {
gcValues.foreground = gcValues.background;
mask = GCForeground;
if (mbPtr->gray == None) {
mbPtr->gray = Tk_GetBitmap(NULL, mbPtr->tkwin, "gray50");
}
if (mbPtr->gray != None) {
gcValues.fill_style = FillStippled;
gcValues.stipple = mbPtr->gray;
mask |= GCFillStyle | GCStipple;
}
mbPtr->stippleGC = Tk_GetGC(mbPtr->tkwin, mask, &gcValues);
}
/*
* Allocate the disabled graphics context, for drawing text in its
* disabled state.
*/
mask = GCForeground | GCBackground | GCFont;
if (mbPtr->disabledFg != NULL) {
gcValues.foreground = mbPtr->disabledFg->pixel;
} else {
gcValues.foreground = gcValues.background;
}
gc = Tk_GetGC(mbPtr->tkwin, mask, &gcValues);
if (mbPtr->disabledGC != None) {
Tk_FreeGC(mbPtr->display, mbPtr->disabledGC);
}
mbPtr->disabledGC = gc;
TkpComputeMenuButtonGeometry(mbPtr);
/*
* Lastly, arrange for the button to be redisplayed.
*/
if (Tk_IsMapped(mbPtr->tkwin) && !(mbPtr->flags & REDRAW_PENDING)) {
Tcl_DoWhenIdle(TkpDisplayMenuButton, mbPtr);
mbPtr->flags |= REDRAW_PENDING;
}
}
/* On utilisa la procedure Idle et la boucle Standard Ivy */
void IvyIdleProc(ClientData clientData)
{
IvyIdle();
Tcl_DoWhenIdle(IvyIdleProc,0);
}
static int
ConfigureSlave(
Tcl_Interp *interp, /* Used for error reporting. */
Tk_Window tkwin, /* Token for the window to manipulate. */
Tk_OptionTable table, /* Token for option table. */
int objc, /* Number of config arguments. */
Tcl_Obj *const objv[]) /* Object values for arguments. */
{
register Master *masterPtr;
Tk_SavedOptions savedOptions;
int mask;
Slave *slavePtr;
Tk_Window masterWin = (Tk_Window) NULL;
if (Tk_TopWinHierarchy(tkwin)) {
Tcl_SetObjResult(interp, Tcl_ObjPrintf(
"can't use placer on top-level window \"%s\"; use "
"wm command instead", Tk_PathName(tkwin)));
Tcl_SetErrorCode(interp, "TK", "GEOMETRY", "TOPLEVEL", NULL);
return TCL_ERROR;
}
slavePtr = CreateSlave(tkwin, table);
if (Tk_SetOptions(interp, (char *) slavePtr, table, objc, objv,
slavePtr->tkwin, &savedOptions, &mask) != TCL_OK) {
goto error;
}
/*
* Set slave flags. First clear the field, then add bits as needed.
*/
slavePtr->flags = 0;
if (slavePtr->heightPtr) {
slavePtr->flags |= CHILD_HEIGHT;
}
if (slavePtr->relHeightPtr) {
slavePtr->flags |= CHILD_REL_HEIGHT;
}
if (slavePtr->relWidthPtr) {
slavePtr->flags |= CHILD_REL_WIDTH;
}
if (slavePtr->widthPtr) {
slavePtr->flags |= CHILD_WIDTH;
}
if (!(mask & IN_MASK) && (slavePtr->masterPtr != NULL)) {
/*
* If no -in option was passed and the slave is already placed then
* just recompute the placement.
*/
masterPtr = slavePtr->masterPtr;
goto scheduleLayout;
} else if (mask & IN_MASK) {
/* -in changed */
Tk_Window tkwin;
Tk_Window ancestor;
tkwin = slavePtr->inTkwin;
/*
* Make sure that the new master is either the logical parent of the
* slave or a descendant of that window, and that the master and slave
* aren't the same.
*/
for (ancestor = tkwin; ; ancestor = Tk_Parent(ancestor)) {
if (ancestor == Tk_Parent(slavePtr->tkwin)) {
break;
}
if (Tk_TopWinHierarchy(ancestor)) {
Tcl_SetObjResult(interp, Tcl_ObjPrintf(
"can't place %s relative to %s",
Tk_PathName(slavePtr->tkwin), Tk_PathName(tkwin)));
Tcl_SetErrorCode(interp, "TK", "GEOMETRY", "HIERARCHY", NULL);
goto error;
}
}
if (slavePtr->tkwin == tkwin) {
Tcl_SetObjResult(interp, Tcl_ObjPrintf(
"can't place %s relative to itself",
Tk_PathName(slavePtr->tkwin)));
Tcl_SetErrorCode(interp, "TK", "GEOMETRY", "LOOP", NULL);
goto error;
}
if ((slavePtr->masterPtr != NULL)
&& (slavePtr->masterPtr->tkwin == tkwin)) {
/*
* Re-using same old master. Nothing to do.
*/
masterPtr = slavePtr->masterPtr;
goto scheduleLayout;
}
if ((slavePtr->masterPtr != NULL) &&
(slavePtr->masterPtr->tkwin != Tk_Parent(slavePtr->tkwin))) {
Tk_UnmaintainGeometry(slavePtr->tkwin, slavePtr->masterPtr->tkwin);
}
UnlinkSlave(slavePtr);
masterWin = tkwin;
}
/*
* If there's no master specified for this slave, use its Tk_Parent.
*/
if (masterWin == NULL) {
masterWin = Tk_Parent(slavePtr->tkwin);
slavePtr->inTkwin = masterWin;
}
/*
* Manage the slave window in this master.
*/
masterPtr = CreateMaster(masterWin);
slavePtr->masterPtr = masterPtr;
slavePtr->nextPtr = masterPtr->slavePtr;
masterPtr->slavePtr = slavePtr;
Tk_ManageGeometry(slavePtr->tkwin, &placerType, slavePtr);
/*
* Arrange for the master to be re-arranged at the first idle moment.
*/
scheduleLayout:
Tk_FreeSavedOptions(&savedOptions);
if (!(masterPtr->flags & PARENT_RECONFIG_PENDING)) {
masterPtr->flags |= PARENT_RECONFIG_PENDING;
Tcl_DoWhenIdle(RecomputePlacement, masterPtr);
}
return TCL_OK;
/*
* Error while processing some option, cleanup and return.
*/
error:
Tk_RestoreSavedOptions(&savedOptions);
return TCL_ERROR;
}
/* ARGSUSED */
int
Tcl_AfterObjCmd(
ClientData clientData, /* Unused */
Tcl_Interp *interp, /* Current interpreter. */
int objc, /* Number of arguments. */
Tcl_Obj *const objv[]) /* Argument objects. */
{
Tcl_WideInt ms = 0; /* Number of milliseconds to wait */
Tcl_Time wakeup;
AfterInfo *afterPtr;
AfterAssocData *assocPtr;
int length;
int index;
static const char *const afterSubCmds[] = {
"cancel", "idle", "info", NULL
};
enum afterSubCmds {AFTER_CANCEL, AFTER_IDLE, AFTER_INFO};
ThreadSpecificData *tsdPtr = InitTimer();
if (objc < 2) {
Tcl_WrongNumArgs(interp, 1, objv, "option ?arg ...?");
return TCL_ERROR;
}
/*
* Create the "after" information associated for this interpreter, if it
* doesn't already exist.
*/
assocPtr = Tcl_GetAssocData(interp, "tclAfter", NULL);
if (assocPtr == NULL) {
assocPtr = ckalloc(sizeof(AfterAssocData));
assocPtr->interp = interp;
assocPtr->firstAfterPtr = NULL;
Tcl_SetAssocData(interp, "tclAfter", AfterCleanupProc, assocPtr);
}
/*
* First lets see if the command was passed a number as the first argument.
*/
if (objv[1]->typePtr == &tclIntType
#ifndef TCL_WIDE_INT_IS_LONG
|| objv[1]->typePtr == &tclWideIntType
#endif
|| objv[1]->typePtr == &tclBignumType
|| (Tcl_GetIndexFromObj(NULL, objv[1], afterSubCmds, "", 0,
&index) != TCL_OK)) {
index = -1;
if (Tcl_GetWideIntFromObj(NULL, objv[1], &ms) != TCL_OK) {
const char *arg = Tcl_GetString(objv[1]);
Tcl_SetObjResult(interp, Tcl_ObjPrintf(
"bad argument \"%s\": must be"
" cancel, idle, info, or an integer", arg));
Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "INDEX", "argument",
arg, NULL);
return TCL_ERROR;
}
}
/*
* At this point, either index = -1 and ms contains the number of ms
* to wait, or else index is the index of a subcommand.
*/
switch (index) {
case -1: {
if (ms < 0) {
ms = 0;
}
if (objc == 2) {
return AfterDelay(interp, ms);
}
afterPtr = ckalloc(sizeof(AfterInfo));
afterPtr->assocPtr = assocPtr;
if (objc == 3) {
afterPtr->commandPtr = objv[2];
} else {
afterPtr->commandPtr = Tcl_ConcatObj(objc-2, objv+2);
}
Tcl_IncrRefCount(afterPtr->commandPtr);
/*
* The variable below is used to generate unique identifiers for after
* commands. This id can wrap around, which can potentially cause
* problems. However, there are not likely to be problems in practice,
* because after commands can only be requested to about a month in
* the future, and wrap-around is unlikely to occur in less than about
* 1-10 years. Thus it's unlikely that any old ids will still be
* around when wrap-around occurs.
*/
afterPtr->id = tsdPtr->afterId;
tsdPtr->afterId += 1;
Tcl_GetTime(&wakeup);
wakeup.sec += (long)(ms / 1000);
wakeup.usec += ((long)(ms % 1000)) * 1000;
if (wakeup.usec > 1000000) {
wakeup.sec++;
wakeup.usec -= 1000000;
}
afterPtr->token = TclCreateAbsoluteTimerHandler(&wakeup,
AfterProc, afterPtr);
afterPtr->nextPtr = assocPtr->firstAfterPtr;
assocPtr->firstAfterPtr = afterPtr;
Tcl_SetObjResult(interp, Tcl_ObjPrintf("after#%d", afterPtr->id));
return TCL_OK;
}
case AFTER_CANCEL: {
Tcl_Obj *commandPtr;
const char *command, *tempCommand;
int tempLength;
if (objc < 3) {
Tcl_WrongNumArgs(interp, 2, objv, "id|command");
return TCL_ERROR;
}
if (objc == 3) {
commandPtr = objv[2];
} else {
commandPtr = Tcl_ConcatObj(objc-2, objv+2);;
}
command = TclGetStringFromObj(commandPtr, &length);
for (afterPtr = assocPtr->firstAfterPtr; afterPtr != NULL;
afterPtr = afterPtr->nextPtr) {
tempCommand = TclGetStringFromObj(afterPtr->commandPtr,
&tempLength);
if ((length == tempLength)
&& !memcmp(command, tempCommand, (unsigned) length)) {
break;
}
}
if (afterPtr == NULL) {
afterPtr = GetAfterEvent(assocPtr, commandPtr);
}
if (objc != 3) {
Tcl_DecrRefCount(commandPtr);
}
if (afterPtr != NULL) {
if (afterPtr->token != NULL) {
Tcl_DeleteTimerHandler(afterPtr->token);
} else {
Tcl_CancelIdleCall(AfterProc, afterPtr);
}
FreeAfterPtr(afterPtr);
}
break;
}
case AFTER_IDLE:
if (objc < 3) {
Tcl_WrongNumArgs(interp, 2, objv, "script ?script ...?");
return TCL_ERROR;
}
afterPtr = ckalloc(sizeof(AfterInfo));
afterPtr->assocPtr = assocPtr;
if (objc == 3) {
afterPtr->commandPtr = objv[2];
} else {
afterPtr->commandPtr = Tcl_ConcatObj(objc-2, objv+2);
}
Tcl_IncrRefCount(afterPtr->commandPtr);
afterPtr->id = tsdPtr->afterId;
tsdPtr->afterId += 1;
afterPtr->token = NULL;
afterPtr->nextPtr = assocPtr->firstAfterPtr;
assocPtr->firstAfterPtr = afterPtr;
Tcl_DoWhenIdle(AfterProc, afterPtr);
Tcl_SetObjResult(interp, Tcl_ObjPrintf("after#%d", afterPtr->id));
break;
case AFTER_INFO:
if (objc == 2) {
Tcl_Obj *resultObj = Tcl_NewObj();
for (afterPtr = assocPtr->firstAfterPtr; afterPtr != NULL;
afterPtr = afterPtr->nextPtr) {
if (assocPtr->interp == interp) {
Tcl_ListObjAppendElement(NULL, resultObj, Tcl_ObjPrintf(
"after#%d", afterPtr->id));
}
}
Tcl_SetObjResult(interp, resultObj);
return TCL_OK;
}
if (objc != 3) {
Tcl_WrongNumArgs(interp, 2, objv, "?id?");
return TCL_ERROR;
}
afterPtr = GetAfterEvent(assocPtr, objv[2]);
if (afterPtr == NULL) {
const char *eventStr = TclGetString(objv[2]);
Tcl_SetObjResult(interp, Tcl_ObjPrintf(
"event \"%s\" doesn't exist", eventStr));
Tcl_SetErrorCode(interp, "TCL","LOOKUP","EVENT", eventStr, NULL);
return TCL_ERROR;
} else {
Tcl_Obj *resultListPtr = Tcl_NewObj();
Tcl_ListObjAppendElement(interp, resultListPtr,
afterPtr->commandPtr);
Tcl_ListObjAppendElement(interp, resultListPtr, Tcl_NewStringObj(
(afterPtr->token == NULL) ? "idle" : "timer", -1));
Tcl_SetObjResult(interp, resultListPtr);
}
break;
default:
Tcl_Panic("Tcl_AfterObjCmd: bad subcommand index to afterSubCmds");
}
return TCL_OK;
}
static int
imfsample_widget_cmd(ClientData cldata, Tcl_Interp *interp, int argc, char **argv)
{
Imfsample *imfsample = (Imfsample *) cldata;
int result = TCL_OK;
size_t cmdlength;
char c;
int x, y, col, row, n;
char tclbuf[100];
int rslt;
if (argc < 2) {
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " option ?arg arg ...?\"", (char *) NULL);
return TCL_ERROR;
}
Tcl_Preserve((ClientData) imfsample);
c = argv[1][0];
cmdlength = strlen(argv[1]);
if ((c == 'c') && (strncmp(argv[1], "cget", cmdlength) == 0)
&& (cmdlength >= 2)) {
if (argc != 3) {
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " cget option\"",
(char *) NULL);
goto error;
}
result = Tk_ConfigureValue(interp, imfsample->tkwin, config_specs,
(char *) imfsample, argv[2], 0);
} else if ((c == 'c') && (strncmp(argv[1], "configure", cmdlength) == 0)
&& (cmdlength >= 2)) {
if (argc == 2) {
result = Tk_ConfigureInfo(interp, imfsample->tkwin, config_specs,
(char *) imfsample, (char *) NULL, 0);
} else if (argc == 3) {
result = Tk_ConfigureInfo(interp, imfsample->tkwin, config_specs,
(char *) imfsample, argv[2], 0);
} else {
result = imfsample_configure(interp, imfsample, argc-2, argv+2,
TK_CONFIG_ARGV_ONLY);
}
} else if ((c == 'c') && (strncmp(argv[1], "curselection", cmdlength) == 0)
&& (cmdlength >= 2)) {
sprintf(Tcl_GetStringResult(interp), "%d", imfsample->selected);
} else if ((c == 'a') && (strncmp(argv[1], "add", cmdlength) == 0)
&& (cmdlength >= 2)) {
if (strcmp(argv[2], "imf") == 0) {
imfsample_add_imf(imfsample, argv[3]);
} else if (strcmp(argv[2], "all") == 0) {
imfsample_add_imf(imfsample, "-all");
}
} else if ((c == 'e') && (strncmp(argv[1], "emblem", cmdlength) == 0)
&& (cmdlength >= 2)) {
n = strtol(argv[2], NULL, 10);
imfsample->with_emblem = n;
} else if ((c == 'r') && (strncmp(argv[1], "redraw", cmdlength) == 0)
&& (cmdlength >= 2)) {
imfsample->redraw = TRUE;
if (!imfsample->update_pending) {
Tcl_DoWhenIdle(imfsample_display, cldata);
imfsample->update_pending = 1;
}
} else if ((c == 'r') && (strncmp(argv[1], "replace", cmdlength) == 0)
&& (cmdlength >= 2)) {
if (strcmp(argv[2], "imf") == 0) {
imfsample_replace_imf(imfsample, argv[3]);
} else if (strcmp(argv[2], "emblem") == 0) {
imfsample_replace_emblem(imfsample, argv[3]);
}
} else if ((c == 'r') && (strncmp(argv[1], "remove", cmdlength) == 0)
&& (cmdlength >= 2)) {
if (strcmp(argv[2], "imf") == 0) {
imfsample_remove_imf(imfsample, argv[3]);
} else if (strcmp(argv[2], "emblem") == 0) {
imfsample->numimages = 1;
} else if (strcmp(argv[2], "all") == 0) {
imfsample_remove_imf(imfsample, "-all");
if (imfsample->imfapp) {
imfsample->selected = -1;
imfsample->previous = -1;
/* Turn off the scrollbar. */
sprintf(tclbuf, ".images.scroll set 0 1");
rslt = Tcl_Eval(interp, tclbuf);
if (rslt == TCL_ERROR) {
fprintf(stderr, "Error: %s\n", Tcl_GetStringResult(interp));
}
}
}
} else if ((c == 's') && (strncmp(argv[1], "select", cmdlength) == 0)
&& (cmdlength >= 2)) {
if (imfsample->numimages) {
x = strtol(argv[2], NULL, 10);
y = strtol(argv[3], NULL, 10);
col = x / imfsample->eltw;
row = y / imfsample->elth + imfsample->firstvisrow;
n = row * imfsample->cols + col;
if (n < 0
|| n >= imfsample->numimages
|| col >= imfsample->cols) {
n = -1;
}
/* This rather complicated scheme is to ensure that we can both select
images and then deselect them by clicking a second time on the image or
by clicking in an empty region. */
if (imfsample->selected != n) {
imfsample->previous = imfsample->selected;
imfsample->selected = n;
} else if (n == -1) {
imfsample->selected = -1;
} else {
imfsample->previous = n;
imfsample->selected = -1;
}
}
} else if ((c == 't') && (strncmp(argv[1], "terrain", cmdlength) == 0)
&& (cmdlength >= 2)) {
n = strtol(argv[2], NULL, 10);
imfsample->with_terrain = n;
} else if ((c == 'x') && (strncmp(argv[1], "xview", cmdlength) == 0)) {
} else if ((c == 'y') && (strncmp(argv[1], "yview", cmdlength) == 0)) {
int count, type, nrow = imfsample->firstvisrow;
double fraction, fraction2;
type = Tk_GetScrollInfo(interp, argc, argv, &fraction, &count);
switch (type) {
case TK_SCROLL_ERROR:
goto error;
case TK_SCROLL_MOVETO:
nrow = fraction * imfsample->rows;
break;
case TK_SCROLL_PAGES:
nrow += (count * imfsample->numvisrows * 4) / 5;
break;
case TK_SCROLL_UNITS:
nrow += count;
break;
}
/* Don't allow negative row numbers. */
imfsample->firstvisrow = max(0, nrow);
/* Compute the bounds of the visible window. */
fraction = (double) imfsample->firstvisrow / imfsample->rows;
fraction2 = (double) (imfsample->firstvisrow + imfsample->numvisrows) / imfsample->rows;
if (imfsample->imfapp) {
/* We must set the scrollbar explicitly since the imfsample widget
lacks a built-in yscrollcommand. */
sprintf(tclbuf, ".images.scroll set %f %f", fraction, fraction2);
rslt = Tcl_Eval(interp, tclbuf);
if (rslt == TCL_ERROR) {
fprintf(stderr, "Error: %s\n", Tcl_GetStringResult(interp));
}
}
} else {
Tcl_AppendResult(interp, "bad option \"", argv[1],
"\": must be cget, configure, position, replace, remove, select",
(char *) NULL);
goto error;
}
if (!imfsample->update_pending) {
Tcl_DoWhenIdle(imfsample_display, (ClientData) imfsample);
imfsample->update_pending = 1;
}
Tcl_Release((ClientData) imfsample);
return result;
error:
Tcl_Release((ClientData) imfsample);
return TCL_ERROR;
}
