/*
** Map any control that should be visible according to the
** current scroll position. At the same time, if any controls that
** should not be visible are mapped, unmap them. After this routine
** finishes, all <INPUT> controls should be in their proper places
** regardless of where they might have been before.
**
** Return the number of controls that are currently visible.
*/
int HtmlMapControls(HtmlWidget *htmlPtr){
HtmlElement *p; /* For looping over all controls */
int x, y, w, h; /* Part of the virtual canvas that is visible */
int cnt = 0; /* Number of visible controls */
x = htmlPtr->xOffset;
y = htmlPtr->yOffset;
w = Tk_Width(htmlPtr->clipwin);
h = Tk_Height(htmlPtr->clipwin);
for(p=htmlPtr->firstInput; p; p=p->input.pNext){
if( p->input.tkwin==0 ) continue;
if( p->input.y < y+h
&& p->input.y + p->input.h > y
&& p->input.x < x+w
&& p->input.x + p->input.w > x
){
/* The control should be visible. Make is so if it isn't already */
Tk_MoveResizeWindow(p->input.tkwin,
p->input.x - x, p->input.y - y,
p->input.w, p->input.h);
if( !Tk_IsMapped(p->input.tkwin) ){
Tk_MapWindow(p->input.tkwin);
}
cnt++;
}else{
/* This control should not be visible. Unmap it. */
if( Tk_IsMapped(p->input.tkwin) ){
Tk_UnmapWindow(p->input.tkwin);
}
}
}
return cnt;
}
void trace_flash (DNATrace *t) {
int x0, i;
Display *d = t->display;
Window w = Tk_WindowId(t->tkwin);
Pixmap tmp;
if (!Tk_IsMapped(t->tkwin) || Tk_WindowId(t->tkwin) == 0)
return;
x0 = point_to_pixel(t, trace_get_pos(t, t->cursor_pos));
tmp = Tk_GetPixmap(d, w, 24, t->pos[TRACEP_T].h, Tk_Depth(t->tkwin));
XCopyArea(d, w, tmp, t->CursorGC,
x0-12, t->pos[TRACEP_T].y, 24, t->pos[TRACEP_T].h, 0, 0);
for (i=12; i > 0; i-=3) {
XCopyArea(d, tmp, w, t->CursorGC,
0, 0, 24, t->pos[TRACEP_T].h, x0-12, t->pos[TRACEP_T].y);
XFillRectangle(d, w,
t->CursorGC,
x0 - i, t->pos[TRACEP_T].y,
i, t->pos[TRACEP_T].h);
XSync(d, False);
myusleep(20000);
}
XCopyArea(d, tmp, w, t->CursorGC,
0, 0, 24, t->pos[TRACEP_T].h, x0-12, t->pos[TRACEP_T].y);
Tk_FreePixmap(d, tmp);
}
void
TkMacInvalClipRgns(
TkWindow *winPtr)
{
TkWindow *childPtr;
/*
* If already marked we can stop because all
* decendants will also already be marked.
*/
if (winPtr->privatePtr->flags & TK_CLIP_INVALID) {
return;
}
winPtr->privatePtr->flags |= TK_CLIP_INVALID;
/*
* Invalidate clip regions for all children &
* their decendants - unless the child is a toplevel.
*/
childPtr = winPtr->childList;
while (childPtr != NULL) {
if (!Tk_IsTopLevel(childPtr) && Tk_IsMapped(childPtr)) {
TkMacInvalClipRgns(childPtr);
}
childPtr = childPtr->nextPtr;
}
/*
* Also, if the window is a container, mark its embedded window
*/
if (Tk_IsContainer(winPtr)) {
childPtr = TkpGetOtherWindow(winPtr);
if (childPtr != NULL && Tk_IsMapped(childPtr)) {
TkMacInvalClipRgns(childPtr);
}
/*
* NOTE: Here we should handle out of process embedding.
*/
}
}
/* Draw the icon */
static void
DrawIcon (ClientData clientData)
{
TrayIcon *icon=clientData;
int x,y;
unsigned int w,h,b,d;
int widthImg, heightImg;
Window r;
char cmdBuffer[1024];
XSizeHints *hints = NULL;
long supplied = 0;
if( icon->win == NULL ) {
return;
}
XGetGeometry(display, Tk_WindowId(icon->win), &r, &x, &y, &w, &h, &b, &d);
XClearWindow(display, Tk_WindowId(icon->win));
/*
* Here we get the window hints because in some cases the XGetGeometry
* function returns the wrong width/height. We only check that
* min_width <= width <= max_width and min_height <= height <= max_height
*/
hints = XAllocSizeHints();
XGetWMNormalHints(display, Tk_WindowId(icon->win), hints, &supplied);
if( supplied & PMaxSize ) {
w = (hints->max_width < w) ? hints->max_width : w;
h = (hints->max_height < h) ? hints->max_height : h;
}
if( supplied & PMinSize ) {
w = (hints->min_width > w) ? hints->min_width : w;
h = (hints->min_height > h) ? hints->min_height : h;
}
if(hints) {
XFree(hints);
hints = NULL;
}
if (((icon->width != w) || (icon->height != h) || (icon->mustUpdate)) && (icon->cmdCallback[0] != '\0')) {
snprintf(cmdBuffer,sizeof(cmdBuffer),"%s %u %u",icon->cmdCallback,w,h);
Tcl_EvalEx(globalinterp,cmdBuffer,-1,TCL_EVAL_GLOBAL);
icon->mustUpdate = False;
icon->width = w;
icon->height = h;
}
Tk_SizeOfImage(icon->pixmap, &widthImg, &heightImg);
if (widthImg > w)
widthImg = w;
if (heightImg > h)
heightImg = h;
if( !Tk_IsMapped(icon->win) )
Tk_MapWindow(icon->win);
Tk_RedrawImage(icon->pixmap, 0, 0, widthImg, heightImg, Tk_WindowId(icon->win), (w-widthImg)/2 , (h-heightImg)/2 );
}
/*
** Unmap any input control that is currently mapped.
*/
void HtmlUnmapControls(HtmlWidget *htmlPtr){
HtmlElement *p;
for(p=htmlPtr->firstInput; p; p=p->input.pNext){
if( p->input.tkwin!=0 && Tk_IsMapped(p->input.tkwin) ){
Tk_UnmapWindow(p->input.tkwin);
}
}
}
/* ++ Ttk_PlaceSlave --
* Set the position and size of the specified slave window.
*
* NOTES:
* Contrary to documentation, Tk_MaintainGeometry doesn't always
* map the slave.
*/
void Ttk_PlaceSlave(
Ttk_Manager *mgr, int slaveIndex, int x, int y, int width, int height)
{
Ttk_Slave *slave = mgr->slaves[slaveIndex];
Tk_MaintainGeometry(slave->slaveWindow,mgr->masterWindow,x,y,width,height);
slave->flags |= SLAVE_MAPPED;
if (Tk_IsMapped(mgr->masterWindow)) {
Tk_MapWindow(slave->slaveWindow);
}
}
/* PaneRequest --
* Only update pane request size if slave is currently unmapped.
* Geometry requests from mapped slaves are not directly honored
* in order to avoid unexpected pane resizes (esp. while the
* user is dragging a sash [#1325286]).
*/
static int PaneRequest(void *managerData, int index, int width, int height)
{
Paned *pw = managerData;
Pane *pane = Ttk_SlaveData(pw->paned.mgr, index);
Tk_Window slaveWindow = Ttk_SlaveWindow(pw->paned.mgr, index);
int horizontal = pw->paned.orient == TTK_ORIENT_HORIZONTAL;
if (!Tk_IsMapped(slaveWindow)) {
pane->reqSize = horizontal ? width : height;
}
return 1;
}
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 PyObject *
tkwin_CopyArea(TkWinObject * self, PyObject * args)
{
PyObject *destobj, *gcobj;
Drawable dest;
GC gc;
int src_x, src_y, dest_x, dest_y;
unsigned int width, height;
if (!PyArg_ParseTuple(args, "OOiiiiii", &destobj, &gcobj, &src_x,
&src_y, &width, &height, &dest_x, &dest_y))
return NULL;
if (TkWin_Check(destobj))
{
if (Tk_IsMapped(self->tkwin))
dest = Tk_WindowId(((TkWinObject*) destobj)->tkwin);
else
{
Py_INCREF(Py_None);
return Py_None;
}
}
else if (PaxPixmap_Check(destobj))
{
dest = PaxPixmap_AsPixmap(destobj);
}
else
{
PyErr_SetString(PyExc_RuntimeError, "bad arguments");
return NULL;
}
if (gcobj == Py_None)
gc = DefaultGCOfScreen(Tk_Screen(self->tkwin));
else
{
gc = PaxGC_AsGC(gcobj);
if (PyErr_Occurred())
return NULL;
}
XCopyArea(Tk_Display(self->tkwin), Tk_WindowId(self->tkwin),
dest, gc, src_x, src_y, width, height, dest_x, dest_y);
Py_INCREF(Py_None);
return Py_None;
}
static void
GenerateConfigureNotify(
TkWindow *winPtr,
int includeWin)
{
TkWindow *childPtr;
for (childPtr = winPtr->childList; childPtr != NULL;
childPtr = childPtr->nextPtr) {
if (!Tk_IsMapped(childPtr) || Tk_IsTopLevel(childPtr)) {
continue;
}
GenerateConfigureNotify(childPtr, 1);
}
if (includeWin) {
TkDoConfigureNotify(winPtr);
}
}
static int
HoldBusy(
Tcl_HashTable *busyTablePtr,/* Busy hash table. */
Tcl_Interp *interp, /* Interpreter to report errors to. */
Tcl_Obj *const windowObj, /* Window name. */
int configObjc, /* Option pairs. */
Tcl_Obj *const configObjv[])
{
Tk_Window tkwin;
Tcl_HashEntry *hPtr;
Busy *busyPtr;
int isNew, result;
if (TkGetWindowFromObj(interp, Tk_MainWindow(interp), windowObj,
&tkwin) != TCL_OK) {
return TCL_ERROR;
}
hPtr = Tcl_CreateHashEntry(busyTablePtr, (char *) tkwin, &isNew);
if (isNew) {
busyPtr = CreateBusy(interp, tkwin);
if (busyPtr == NULL) {
return TCL_ERROR;
}
Tcl_SetHashValue(hPtr, busyPtr);
busyPtr->hashPtr = hPtr;
} else {
busyPtr = Tcl_GetHashValue(hPtr);
}
busyPtr->tablePtr = busyTablePtr;
result = ConfigureBusy(interp, busyPtr, configObjc, configObjv);
/*
* Don't map the busy window unless the reference window is also currently
* displayed.
*/
if (Tk_IsMapped(busyPtr->tkRef)) {
TkpShowBusyWindow(busyPtr);
} else {
TkpHideBusyWindow(busyPtr);
}
return result;
}
/*
*--------------------------------------------------------------
*
* ButtonContentDrawCB --
*
* This function draws the label and image for the button.
*
* Results:
* None.
*
* Side effects:
* The content of the button gets updated.
*
*--------------------------------------------------------------
*/
static void
ButtonContentDrawCB (
const HIRect * btnbounds,
ThemeButtonKind kind,
const HIThemeButtonDrawInfo *drawinfo,
MacButton *ptr,
SInt16 depth,
Boolean isColorDev)
{
TkButton *butPtr = (TkButton *)ptr;
Tk_Window tkwin = butPtr->tkwin;
if (tkwin == NULL || !Tk_IsMapped(tkwin)) {
return;
}
/*Overlay Tk elements over button native region: drawing elements within button boundaries/native region causes unpredictable metrics.*/
DrawButtonImageAndText( butPtr);
}
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;
}
}
}
static PyObject *
tkwin_ClearArea(TkWinObject *self, PyObject *args)
{
int x;
int y;
unsigned int width;
unsigned int height;
int exposures;
if (!PyArg_ParseTuple(args, "iiiii", &x, &y, &width, &height, &exposures))
return NULL;
if (Tk_IsMapped(self->tkwin))
XClearArea(Tk_Display(self->tkwin),Tk_WindowId(self->tkwin),
x, y, width, height, (Bool)exposures);
Py_INCREF(Py_None);
return Py_None;
}
static void
PaxWidgetDisplay(ClientData clientData)
{
PaxWidget *paxwidget = (PaxWidget *) clientData;
Tk_Window tkwin = paxwidget->tkwin;
PyObject * region;
paxwidget->update_pending = 0;
if (!Tk_IsMapped(tkwin))
return;
region = PaxRegion_FromRegion(paxwidget->exposed_region);
if (!region)
return;
paxwidget->exposed_region = XCreateRegion();
paxWidget_CallMethodArgs(paxwidget->obj, RedrawMethodIdx,
Py_BuildValue("(O)", region));
Py_DECREF(region);
}
void
TkpDisplayMenuButton(
ClientData clientData) /* Information about widget. */
{
MacMenuButton *mbPtr = (MacMenuButton *)clientData;
TkMenuButton *butPtr = (TkMenuButton *) clientData;
Tk_Window tkwin = butPtr->tkwin;
Pixmap pixmap;
DrawParams* dpPtr = &mbPtr->drawParams;
butPtr->flags &= ~REDRAW_PENDING;
if ((butPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) {
return;
}
pixmap = (Pixmap) Tk_WindowId(tkwin);
TkMacOSXComputeMenuButtonDrawParams(butPtr, dpPtr);
/*
* set up clipping region. Make sure the we are using the port
* for this button, or we will set the wrong window's clip.
*/
TkMacOSXSetUpClippingRgn(pixmap);
/* Draw the native portion of the buttons. */
TkMacOSXDrawMenuButton(mbPtr, dpPtr->gc, pixmap);
/* Draw highlight border, if needed. */
if (butPtr->highlightWidth < 3) {
if ((butPtr->flags & GOT_FOCUS)) {
Tk_Draw3DRectangle(tkwin, pixmap, butPtr->normalBorder, 0, 0,
Tk_Width(tkwin), Tk_Height(tkwin),
butPtr->highlightWidth, TK_RELIEF_SOLID);
}
}
}
static void
DisplaySimGraph(ClientData clientData)
{
SimGraph *graph = (SimGraph *) clientData;
Tk_Window tkwin = graph->tkwin;
Pixmap pm = None;
Drawable d;
graph->flags &= ~VIEW_REDRAW_PENDING;
//fprintf(stderr, "DisplaySimGraph token %d\n", graph->draw_graph_token);
assert(graph->draw_graph_token != 0);
if (graph->draw_graph_token != 0) {
// Tk_DeleteTimerHandler(graph->draw_graph_token);
graph->draw_graph_token = 0;
}
if (graph->visible && (tkwin != NULL) && Tk_IsMapped(tkwin)) {
DoUpdateGraph(graph);
}
}
/*
*--------------------------------------------------------------
*
* ButtonBackgroundDrawCB --
*
* This function draws the background that
* lies under checkboxes and radiobuttons.
*
* Results:
* None.
*
* Side effects:
* The background gets updated to the current color.
*
*--------------------------------------------------------------
*/
static void
ButtonBackgroundDrawCB (
const HIRect * btnbounds,
MacButton *ptr,
SInt16 depth,
Boolean isColorDev)
{
MacButton* mbPtr = (MacButton*)ptr;
TkButton* butPtr = (TkButton*)mbPtr;
Tk_Window tkwin = butPtr->tkwin;
Pixmap pixmap;
int usehlborder = 0;
if (tkwin == NULL || !Tk_IsMapped(tkwin)) {
return;
}
pixmap = (Pixmap)Tk_WindowId(tkwin);
if (butPtr->type != TYPE_LABEL) {
switch (mbPtr->btnkind) {
case kThemeSmallBevelButton:
case kThemeBevelButton:
case kThemeRoundedBevelButton:
case kThemePushButton:
usehlborder = 1;
break;
}
}
if (usehlborder) {
Tk_Fill3DRectangle(tkwin, pixmap, butPtr->highlightBorder, 0, 0,
Tk_Width(tkwin), Tk_Height(tkwin), 0, TK_RELIEF_FLAT);
} else {
Tk_Fill3DRectangle(tkwin, pixmap, butPtr->normalBorder, 0, 0,
Tk_Width(tkwin), Tk_Height(tkwin), 0, TK_RELIEF_FLAT);
}
}
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;
}
}
}
void
TkpDisplayMenuButton(
ClientData clientData) /* Information about widget. */
{
TkMenuButton *butPtr = (TkMenuButton *) clientData;
Tk_Window tkwin = butPtr->tkwin;
TkWindow * winPtr;
Pixmap pixmap;
MacMenuButton * mbPtr = (MacMenuButton *) butPtr;
GWorldPtr dstPort;
CGrafPtr saveWorld;
GDHandle saveDevice;
int hasImageOrBitmap = 0;
int width, height;
int err;
ControlButtonGraphicAlignment theAlignment;
Rect paneRect, cntrRect;
butPtr->flags &= ~REDRAW_PENDING;
if ((butPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) {
return;
}
pixmap = ( Pixmap )Tk_WindowId(tkwin);
GetGWorld(&saveWorld, &saveDevice);
dstPort = TkMacOSXGetDrawablePort(Tk_WindowId(tkwin));
SetGWorld(dstPort, NULL);
TkMacOSXSetUpClippingRgn(Tk_WindowId(tkwin));
winPtr=(TkWindow *)butPtr->tkwin;
paneRect.left=winPtr->privatePtr->xOff;
paneRect.top=winPtr->privatePtr->yOff;
paneRect.right=paneRect.left+Tk_Width(butPtr->tkwin)-1;
paneRect.bottom=paneRect.top+Tk_Height(butPtr->tkwin)-1;
cntrRect=paneRect;
cntrRect.left+=butPtr->inset;
cntrRect.top+=butPtr->inset;
cntrRect.right-=butPtr->inset;
cntrRect.bottom-=butPtr->inset;
if (mbPtr->userPane) {
MenuButtonControlParams params;
bzero(¶ms, sizeof(params));
ComputeMenuButtonControlParams(butPtr, ¶ms );
if (bcmp(¶ms,&mbPtr->params,sizeof(params))) {
if (mbPtr->userPane) {
DisposeControl(mbPtr->userPane);
mbPtr->userPane = NULL;
mbPtr->control = NULL;
}
}
}
if (!mbPtr->userPane) {
if (MenuButtonInitControl(mbPtr,&paneRect,&cntrRect ) ) {
fprintf(stderr,"Init Control failed\n" );
return;
}
}
SetControlBounds(mbPtr->userPane,&paneRect);
SetControlBounds(mbPtr->control,&cntrRect);
/*
* We need to cache the title and its style
*/
if (!(mbPtr->flags&2)) {
ControlTitleParams titleParams;
int titleChanged;
int styleChanged;
ComputeControlTitleParams(butPtr,&titleParams);
CompareControlTitleParams(&titleParams,&mbPtr->titleParams,
&titleChanged,&styleChanged);
if (titleChanged) {
CFStringRef cf;
cf = CFStringCreateWithCString(NULL,
titleParams.title, kCFStringEncodingUTF8);
if (hasImageOrBitmap) {
SetControlTitleWithCFString(mbPtr->control, cf);
} else {
SetMenuItemTextWithCFString(mbPtr->menuRef, 1, cf);
}
CFRelease(cf);
bcopy(titleParams.title,mbPtr->titleParams.title,titleParams.len+1);
mbPtr->titleParams.len = titleParams.len;
}
if ((titleChanged||styleChanged) && titleParams .len) {
if (hasImageOrBitmap) {
if ((err=SetControlFontStyle(mbPtr->control,&titleParams.style))!=noErr) {
fprintf(stderr,"SetControlFontStyle failed %d\n", err);
return;
}
}
bcopy(&titleParams.style,&mbPtr->titleParams.style,sizeof(titleParams.style));
}
}
if (butPtr->image != None) {
Tk_SizeOfImage(butPtr->image, &width, &height);
hasImageOrBitmap = 1;
} else if (butPtr->bitmap != None) {
Tk_SizeOfBitmap(butPtr->display, butPtr->bitmap, &width, &height);
hasImageOrBitmap = 1;
}
if (hasImageOrBitmap) {
mbPtr->picParams.srcRect.right = width;
mbPtr->picParams.srcRect.bottom = height;
/* Set the flag to circumvent clipping and bounds problems with OS 10.0.4 */
tkPictureIsOpen = 1;
if (!(mbPtr->bevelButtonContent.u.picture = OpenCPicture(&mbPtr->picParams)) ) {
fprintf(stderr,"OpenCPicture failed\n");
}
/*
* TO DO - There is one case where XCopyPlane calls CopyDeepMask,
* which does not get recorded in the picture. So the bitmap code
* will fail in that case.
*/
if (butPtr->image != NULL) {
Tk_RedrawImage(butPtr->image, 0, 0, width,
height, pixmap, 0, 0);
} else {
XCopyPlane(butPtr->display, butPtr->bitmap, pixmap, NULL, 0, 0,
(unsigned int) width, (unsigned int) height, 0, 0, 1);
}
ClosePicture();
tkPictureIsOpen = 0;
if ( (err=SetControlData(mbPtr->control, kControlButtonPart,
kControlBevelButtonContentTag,
sizeof(ControlButtonContentInfo),
(char *) &mbPtr->bevelButtonContent)) != noErr ) {
fprintf(stderr,"SetControlData BevelButtonContent failed, %d\n", err );
}
switch (butPtr->anchor) {
case TK_ANCHOR_N:
theAlignment = kControlBevelButtonAlignTop;
break;
case TK_ANCHOR_NE:
theAlignment = kControlBevelButtonAlignTopRight;
break;
case TK_ANCHOR_E:
theAlignment = kControlBevelButtonAlignRight;
break;
case TK_ANCHOR_SE:
theAlignment = kControlBevelButtonAlignBottomRight;
break;
case TK_ANCHOR_S:
theAlignment = kControlBevelButtonAlignBottom;
break;
case TK_ANCHOR_SW:
theAlignment = kControlBevelButtonAlignBottomLeft;
break;
case TK_ANCHOR_W:
theAlignment = kControlBevelButtonAlignLeft;
break;
case TK_ANCHOR_NW:
theAlignment = kControlBevelButtonAlignTopLeft;
break;
case TK_ANCHOR_CENTER:
theAlignment = kControlBevelButtonAlignCenter;
break;
}
if ((err=SetControlData(mbPtr->control, kControlButtonPart,
kControlBevelButtonGraphicAlignTag,
sizeof(ControlButtonGraphicAlignment),
(char *) &theAlignment)) != noErr ) {
fprintf(stderr,"SetControlData BevelButtonGraphicAlign failed, %d\n", err );
}
}
if (butPtr->flags & GOT_FOCUS) {
HiliteControl(mbPtr->control,kControlButtonPart);
} else {
HiliteControl(mbPtr->control,kControlNoPart);
}
UpdateControlColors(mbPtr);
if (mbPtr->flags&2) {
ShowControl(mbPtr->control);
ShowControl(mbPtr->userPane);
mbPtr->flags ^= 2;
} else {
Draw1Control(mbPtr->userPane);
SetControlVisibility(mbPtr->control, true, true);
}
if (hasImageOrBitmap) {
KillPicture(mbPtr->bevelButtonContent.u.picture);
}
SetGWorld(saveWorld, saveDevice);
}
void
TkpDisplayScrollbar(
ClientData clientData) /* Information about window. */
{
register TkScrollbar *scrollPtr = (TkScrollbar *) clientData;
register MacScrollbar *macScrollPtr = (MacScrollbar *) clientData;
register Tk_Window tkwin = scrollPtr->tkwin;
MacDrawable *macDraw;
CGrafPtr saveWorld;
GDHandle saveDevice;
GWorldPtr destPort;
WindowRef windowRef;
if ((scrollPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) {
goto done;
}
/*
* Draw the focus or any 3D relief we may have.
*/
if (scrollPtr->highlightWidth != 0) {
GC fgGC, bgGC;
bgGC = Tk_GCForColor(scrollPtr->highlightBgColorPtr,
Tk_WindowId(tkwin));
if (scrollPtr->flags & GOT_FOCUS) {
fgGC = Tk_GCForColor(scrollPtr->highlightColorPtr,
Tk_WindowId(tkwin));
TkpDrawHighlightBorder(tkwin, fgGC, bgGC, scrollPtr->highlightWidth,
Tk_WindowId(tkwin));
} else {
TkpDrawHighlightBorder(tkwin, bgGC, bgGC, scrollPtr->highlightWidth,
Tk_WindowId(tkwin));
}
}
Tk_Draw3DRectangle(tkwin, Tk_WindowId(tkwin), scrollPtr->bgBorder,
scrollPtr->highlightWidth, scrollPtr->highlightWidth,
Tk_Width(tkwin) - 2*scrollPtr->highlightWidth,
Tk_Height(tkwin) - 2*scrollPtr->highlightWidth,
scrollPtr->borderWidth, scrollPtr->relief);
/*
* Set up port for drawing Macintosh control.
*/
macDraw = (MacDrawable *) Tk_WindowId(tkwin);
destPort = TkMacGetDrawablePort(Tk_WindowId(tkwin));
GetGWorld(&saveWorld, &saveDevice);
SetGWorld(destPort, NULL);
TkMacSetUpClippingRgn(Tk_WindowId(tkwin));
if (macScrollPtr->sbHandle == NULL) {
Rect r;
WindowRef frontNonFloating;
r.left = r.top = 0;
r.right = r.bottom = 1;
macScrollPtr->sbHandle = NewControl((WindowRef) destPort, &r, "\p",
false, (short) 500, 0, 1000,
scrollBarProc, (SInt32) scrollPtr);
/*
* If we are foremost than make us active.
*/
if (TkMacHaveAppearance() >= 0x110) {
frontNonFloating = FrontNonFloatingWindow();
} else {
frontNonFloating = FrontWindow();
}
if ((WindowPtr) destPort == FrontWindow() || TkpIsWindowFloating((WindowPtr) destPort)) {
macScrollPtr->macFlags |= ACTIVE;
}
}
/*
* Update the control values before we draw.
*/
windowRef = (**macScrollPtr->sbHandle).contrlOwner;
UpdateControlValues(macScrollPtr);
if (macScrollPtr->macFlags & ACTIVE) {
Draw1Control(macScrollPtr->sbHandle);
if (macScrollPtr->macFlags & DRAW_GROW) {
DrawGrowIcon(windowRef);
}
} else {
(**macScrollPtr->sbHandle).contrlHilite = 255;
Draw1Control(macScrollPtr->sbHandle);
if (macScrollPtr->macFlags & DRAW_GROW) {
DrawGrowIcon(windowRef);
Tk_Fill3DRectangle(tkwin, Tk_WindowId(tkwin), scrollPtr->bgBorder,
Tk_Width(tkwin) - 13, Tk_Height(tkwin) - 13,
Tk_Width(tkwin), Tk_Height(tkwin),
0, TK_RELIEF_FLAT);
}
}
SetGWorld(saveWorld, saveDevice);
done:
scrollPtr->flags &= ~REDRAW_PENDING;
}
void
TkMacUpdateClipRgn(
TkWindow *winPtr)
{
RgnHandle rgn;
int x, y;
TkWindow *win2Ptr;
if (winPtr == NULL) {
return;
}
if (winPtr->privatePtr->flags & TK_CLIP_INVALID) {
rgn = winPtr->privatePtr->aboveClipRgn;
if (tmpRgn == NULL) {
tmpRgn = NewRgn();
}
/*
* Start with a region defined by the window bounds.
*/
x = winPtr->privatePtr->xOff;
y = winPtr->privatePtr->yOff;
SetRectRgn(rgn, (short) x, (short) y,
(short) (winPtr->changes.width + x),
(short) (winPtr->changes.height + y));
/*
* Clip away the area of any windows that may obscure this
* window.
* For a non-toplevel window, first, clip to the parents visable
* clip region.
* Second, clip away any siblings that are higher in the
* stacking order.
* For an embedded toplevel, just clip to the container's visible
* clip region. Remember, we only allow one contained window
* in a frame, and don't support any other widgets in the frame either.
* This is not currently enforced, however.
*/
if (!Tk_IsTopLevel(winPtr)) {
TkMacUpdateClipRgn(winPtr->parentPtr);
SectRgn(rgn,
winPtr->parentPtr->privatePtr->aboveClipRgn, rgn);
win2Ptr = winPtr->nextPtr;
while (win2Ptr != NULL) {
if (Tk_IsTopLevel(win2Ptr) || !Tk_IsMapped(win2Ptr)) {
win2Ptr = win2Ptr->nextPtr;
continue;
}
x = win2Ptr->privatePtr->xOff;
y = win2Ptr->privatePtr->yOff;
SetRectRgn(tmpRgn, (short) x, (short) y,
(short) (win2Ptr->changes.width + x),
(short) (win2Ptr->changes.height + y));
DiffRgn(rgn, tmpRgn, rgn);
win2Ptr = win2Ptr->nextPtr;
}
} else if (Tk_IsEmbedded(winPtr)) {
TkWindow *contWinPtr;
contWinPtr = TkpGetOtherWindow(winPtr);
if (contWinPtr != NULL) {
TkMacUpdateClipRgn(contWinPtr);
SectRgn(rgn,
contWinPtr->privatePtr->aboveClipRgn, rgn);
} else if (gMacEmbedHandler != NULL) {
gMacEmbedHandler->getClipProc((Tk_Window) winPtr, tmpRgn);
SectRgn(rgn, tmpRgn, rgn);
}
/*
* NOTE: Here we should handle out of process embedding.
*/
}
/*
* The final clip region is the aboveClip region (or visable
* region) minus all the children of this window.
* Alternatively, if the window is a container, we must also
* subtract the region of the embedded window.
*/
rgn = winPtr->privatePtr->clipRgn;
CopyRgn(winPtr->privatePtr->aboveClipRgn, rgn);
win2Ptr = winPtr->childList;
while (win2Ptr != NULL) {
if (Tk_IsTopLevel(win2Ptr) || !Tk_IsMapped(win2Ptr)) {
win2Ptr = win2Ptr->nextPtr;
continue;
}
x = win2Ptr->privatePtr->xOff;
y = win2Ptr->privatePtr->yOff;
SetRectRgn(tmpRgn, (short) x, (short) y,
(short) (win2Ptr->changes.width + x),
(short) (win2Ptr->changes.height + y));
DiffRgn(rgn, tmpRgn, rgn);
win2Ptr = win2Ptr->nextPtr;
}
if (Tk_IsContainer(winPtr)) {
win2Ptr = TkpGetOtherWindow(winPtr);
if (win2Ptr != NULL) {
if (Tk_IsMapped(win2Ptr)) {
x = win2Ptr->privatePtr->xOff;
y = win2Ptr->privatePtr->yOff;
SetRectRgn(tmpRgn, (short) x, (short) y,
(short) (win2Ptr->changes.width + x),
(short) (win2Ptr->changes.height + y));
DiffRgn(rgn, tmpRgn, rgn);
}
}
/*
* NOTE: Here we should handle out of process embedding.
*/
}
winPtr->privatePtr->flags &= ~TK_CLIP_INVALID;
}
}
static void
RecomputePlacement(
ClientData clientData) /* Pointer to Master record. */
{
register Master *masterPtr = clientData;
register Slave *slavePtr;
int x, y, width, height, tmp;
int masterWidth, masterHeight, masterX, masterY;
double x1, y1, x2, y2;
int abort; /* May get set to non-zero to abort this
* placement operation. */
masterPtr->flags &= ~PARENT_RECONFIG_PENDING;
/*
* Abort any nested call to RecomputePlacement for this window, since
* we'll do everything necessary here, and set up so this call can be
* aborted if necessary.
*/
if (masterPtr->abortPtr != NULL) {
*masterPtr->abortPtr = 1;
}
masterPtr->abortPtr = &abort;
abort = 0;
Tcl_Preserve(masterPtr);
/*
* Iterate over all the slaves for the master. Each slave's geometry can
* be computed independently of the other slaves. Changes to the window's
* structure could cause almost anything to happen, including deleting the
* parent or child. If this happens, we'll be told to abort.
*/
for (slavePtr = masterPtr->slavePtr; slavePtr != NULL && !abort;
slavePtr = slavePtr->nextPtr) {
/*
* Step 1: compute size and borderwidth of master, taking into account
* desired border mode.
*/
masterX = masterY = 0;
masterWidth = Tk_Width(masterPtr->tkwin);
masterHeight = Tk_Height(masterPtr->tkwin);
if (slavePtr->borderMode == BM_INSIDE) {
masterX = Tk_InternalBorderLeft(masterPtr->tkwin);
masterY = Tk_InternalBorderTop(masterPtr->tkwin);
masterWidth -= masterX + Tk_InternalBorderRight(masterPtr->tkwin);
masterHeight -= masterY +
Tk_InternalBorderBottom(masterPtr->tkwin);
} else if (slavePtr->borderMode == BM_OUTSIDE) {
masterX = masterY = -Tk_Changes(masterPtr->tkwin)->border_width;
masterWidth -= 2 * masterX;
masterHeight -= 2 * masterY;
}
/*
* Step 2: compute size of slave (outside dimensions including border)
* and location of anchor point within master.
*/
x1 = slavePtr->x + masterX + (slavePtr->relX*masterWidth);
x = (int) (x1 + ((x1 > 0) ? 0.5 : -0.5));
y1 = slavePtr->y + masterY + (slavePtr->relY*masterHeight);
y = (int) (y1 + ((y1 > 0) ? 0.5 : -0.5));
if (slavePtr->flags & (CHILD_WIDTH|CHILD_REL_WIDTH)) {
width = 0;
if (slavePtr->flags & CHILD_WIDTH) {
width += slavePtr->width;
}
if (slavePtr->flags & CHILD_REL_WIDTH) {
/*
* The code below is a bit tricky. In order to round correctly
* when both relX and relWidth are specified, compute the
* location of the right edge and round that, then compute
* width. If we compute the width and round it, rounding
* errors in relX and relWidth accumulate.
*/
x2 = x1 + (slavePtr->relWidth*masterWidth);
tmp = (int) (x2 + ((x2 > 0) ? 0.5 : -0.5));
width += tmp - x;
}
} else {
width = Tk_ReqWidth(slavePtr->tkwin)
+ 2*Tk_Changes(slavePtr->tkwin)->border_width;
}
if (slavePtr->flags & (CHILD_HEIGHT|CHILD_REL_HEIGHT)) {
height = 0;
if (slavePtr->flags & CHILD_HEIGHT) {
height += slavePtr->height;
}
if (slavePtr->flags & CHILD_REL_HEIGHT) {
/*
* See note above for rounding errors in width computation.
*/
y2 = y1 + (slavePtr->relHeight*masterHeight);
tmp = (int) (y2 + ((y2 > 0) ? 0.5 : -0.5));
height += tmp - y;
}
} else {
height = Tk_ReqHeight(slavePtr->tkwin)
+ 2*Tk_Changes(slavePtr->tkwin)->border_width;
}
/*
* Step 3: adjust the x and y positions so that the desired anchor
* point on the slave appears at that position. Also adjust for the
* border mode and master's border.
*/
switch (slavePtr->anchor) {
case TK_ANCHOR_N:
x -= width/2;
break;
case TK_ANCHOR_NE:
x -= width;
break;
case TK_ANCHOR_E:
x -= width;
y -= height/2;
break;
case TK_ANCHOR_SE:
x -= width;
y -= height;
break;
case TK_ANCHOR_S:
x -= width/2;
y -= height;
break;
case TK_ANCHOR_SW:
y -= height;
break;
case TK_ANCHOR_W:
y -= height/2;
break;
case TK_ANCHOR_NW:
break;
case TK_ANCHOR_CENTER:
x -= width/2;
y -= height/2;
break;
}
/*
* Step 4: adjust width and height again to reflect inside dimensions
* of window rather than outside. Also make sure that the width and
* height aren't zero.
*/
width -= 2*Tk_Changes(slavePtr->tkwin)->border_width;
height -= 2*Tk_Changes(slavePtr->tkwin)->border_width;
if (width <= 0) {
width = 1;
}
if (height <= 0) {
height = 1;
}
/*
* Step 5: reconfigure the window and map it if needed. If the slave
* is a child of the master, we do this ourselves. If the slave isn't
* a child of the master, let Tk_MaintainGeometry do the work (it will
* re-adjust things as relevant windows map, unmap, and move).
*/
if (masterPtr->tkwin == Tk_Parent(slavePtr->tkwin)) {
if ((x != Tk_X(slavePtr->tkwin))
|| (y != Tk_Y(slavePtr->tkwin))
|| (width != Tk_Width(slavePtr->tkwin))
|| (height != Tk_Height(slavePtr->tkwin))) {
Tk_MoveResizeWindow(slavePtr->tkwin, x, y, width, height);
}
if (abort) {
break;
}
/*
* Don't map the slave unless the master is mapped: the slave will
* get mapped later, when the master is mapped.
*/
if (Tk_IsMapped(masterPtr->tkwin)) {
Tk_MapWindow(slavePtr->tkwin);
}
} else {
if ((width <= 0) || (height <= 0)) {
Tk_UnmaintainGeometry(slavePtr->tkwin, masterPtr->tkwin);
Tk_UnmapWindow(slavePtr->tkwin);
} else {
Tk_MaintainGeometry(slavePtr->tkwin, masterPtr->tkwin,
x, y, width, height);
}
}
}
masterPtr->abortPtr = NULL;
Tcl_Release(masterPtr);
}
void
TkMacOSXUpdateClipRgn(
TkWindow *winPtr)
{
MacDrawable *macWin;
if (winPtr == NULL) {
return;
}
macWin = winPtr->privatePtr;
if (macWin && macWin->flags & TK_CLIP_INVALID) {
TkWindow *win2Ptr;
if (Tk_IsMapped(winPtr)) {
int rgnChanged = 0;
CGRect bounds;
HIMutableShapeRef rgn;
/*
* Start with a region defined by the window bounds.
*/
TkMacOSXWinCGBounds(winPtr, &bounds);
rgn = TkMacOSXHIShapeCreateMutableWithRect(&bounds);
/*
* Clip away the area of any windows that may obscure this window.
* For a non-toplevel window, first, clip to the parents visible
* clip region. Second, clip away any siblings that are higher in
* the stacking order. For an embedded toplevel, just clip to the
* container's visible clip region. Remember, we only allow one
* contained window in a frame, and don't support any other widgets
* in the frame either. This is not currently enforced, however.
*/
if (!Tk_IsTopLevel(winPtr)) {
TkMacOSXUpdateClipRgn(winPtr->parentPtr);
if (winPtr->parentPtr) {
ChkErr(HIShapeIntersect,
winPtr->parentPtr->privatePtr->aboveVisRgn,
rgn, rgn);
}
win2Ptr = winPtr;
while ((win2Ptr = win2Ptr->nextPtr)) {
if (Tk_IsTopLevel(win2Ptr) || !Tk_IsMapped(win2Ptr)) {
continue;
}
TkMacOSXWinCGBounds(win2Ptr, &bounds);
ChkErr(TkMacOSHIShapeDifferenceWithRect, rgn, &bounds);
}
} else if (Tk_IsEmbedded(winPtr)) {
win2Ptr = TkpGetOtherWindow(winPtr);
if (win2Ptr) {
TkMacOSXUpdateClipRgn(win2Ptr);
ChkErr(HIShapeIntersect,
win2Ptr->privatePtr->aboveVisRgn, rgn, rgn);
} else if (tkMacOSXEmbedHandler != NULL) {
HIShapeRef visRgn;
TkMacOSXCheckTmpQdRgnEmpty();
tkMacOSXEmbedHandler->getClipProc((Tk_Window) winPtr,
tkMacOSXtmpQdRgn);
visRgn = HIShapeCreateWithQDRgn(tkMacOSXtmpQdRgn);
SetEmptyRgn(tkMacOSXtmpQdRgn);
ChkErr(HIShapeIntersect, visRgn, rgn, rgn);
}
/*
* TODO: Here we should handle out of process embedding.
*/
} else if (winPtr->wmInfoPtr->attributes &
kWindowResizableAttribute) {
HIViewRef growBoxView;
OSErr err = HIViewFindByID(HIViewGetRoot(
TkMacOSXDrawableWindow(winPtr->window)),
kHIViewWindowGrowBoxID, &growBoxView);
if (err == noErr) {
ChkErr(HIViewGetFrame, growBoxView, &bounds);
bounds = CGRectOffset(bounds,
-winPtr->wmInfoPtr->xInParent,
-winPtr->wmInfoPtr->yInParent);
ChkErr(TkMacOSHIShapeDifferenceWithRect, rgn, &bounds);
}
}
macWin->aboveVisRgn = HIShapeCreateCopy(rgn);
/*
* The final clip region is the aboveVis region (or visible region)
* minus all the children of this window. If the window is a
* container, we must also subtract the region of the embedded
* window.
*/
win2Ptr = winPtr->childList;
while (win2Ptr) {
if (Tk_IsTopLevel(win2Ptr) || !Tk_IsMapped(win2Ptr)) {
win2Ptr = win2Ptr->nextPtr;
continue;
}
TkMacOSXWinCGBounds(win2Ptr, &bounds);
ChkErr(TkMacOSHIShapeDifferenceWithRect, rgn, &bounds);
rgnChanged = 1;
win2Ptr = win2Ptr->nextPtr;
}
if (Tk_IsContainer(winPtr)) {
win2Ptr = TkpGetOtherWindow(winPtr);
if (win2Ptr) {
if (Tk_IsMapped(win2Ptr)) {
TkMacOSXWinCGBounds(win2Ptr, &bounds);
ChkErr(TkMacOSHIShapeDifferenceWithRect, rgn, &bounds);
rgnChanged = 1;
}
}
/*
* TODO: Here we should handle out of process embedding.
*/
}
if (rgnChanged) {
HIShapeRef diffRgn = HIShapeCreateDifference(
macWin->aboveVisRgn, rgn);
if (!HIShapeIsEmpty(diffRgn)) {
macWin->visRgn = HIShapeCreateCopy(rgn);
}
CFRelease(diffRgn);
}
CFRelease(rgn);
} else {
/*
* An unmapped window has empty clip regions to prevent any
* (erroneous) drawing into it or its children from becoming
* visible. [Bug 940117]
*/
if (!Tk_IsTopLevel(winPtr)) {
TkMacOSXUpdateClipRgn(winPtr->parentPtr);
} else if (Tk_IsEmbedded(winPtr)) {
win2Ptr = TkpGetOtherWindow(winPtr);
if (win2Ptr) {
TkMacOSXUpdateClipRgn(win2Ptr);
}
}
macWin->aboveVisRgn = TkMacOSXHIShapeCreateEmpty();
}
if (!macWin->visRgn) {
macWin->visRgn = HIShapeCreateCopy(macWin->aboveVisRgn);
}
macWin->flags &= ~TK_CLIP_INVALID;
#ifdef TK_MAC_DEBUG_CLIP_REGIONS
TkMacOSXDebugFlashRegion((Drawable) macWin, macWin->visRgn);
#endif /* TK_MAC_DEBUG_CLIP_REGIONS */
}
}
void
TkpDisplayMenuButton(
ClientData clientData) /* Information about widget. */
{
TkMenuButton *mbPtr = (TkMenuButton *) clientData;
GC gc;
Tk_3DBorder border;
int x = 0; /* Initialization needed only to stop
* compiler warning. */
int y;
Tk_Window tkwin = mbPtr->tkwin;
int width, height;
MacMenuButton * macMBPtr = (MacMenuButton *) mbPtr;
GWorldPtr destPort;
CGrafPtr saveWorld;
GDHandle saveDevice;
MacDrawable *macDraw;
mbPtr->flags &= ~REDRAW_PENDING;
if ((mbPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) {
return;
}
GetGWorld(&saveWorld, &saveDevice);
destPort = TkMacGetDrawablePort(Tk_WindowId(tkwin));
SetGWorld(destPort, NULL);
macDraw = (MacDrawable *) Tk_WindowId(tkwin);
if ((mbPtr->state == tkDisabledUid) && (mbPtr->disabledFg != NULL)) {
gc = mbPtr->disabledGC;
} else if ((mbPtr->state == tkActiveUid) && !Tk_StrictMotif(mbPtr->tkwin)) {
gc = mbPtr->activeTextGC;
} else {
gc = mbPtr->normalTextGC;
}
border = mbPtr->normalBorder;
/*
* In order to avoid screen flashes, this procedure redraws
* the menu button in a pixmap, then copies the pixmap to the
* screen in a single operation. This means that there's no
* point in time where the on-sreen image has been cleared.
*/
Tk_Fill3DRectangle(tkwin, Tk_WindowId(tkwin), border, 0, 0,
Tk_Width(tkwin), Tk_Height(tkwin), 0, TK_RELIEF_FLAT);
/*
* Display image or bitmap or text for button.
*/
if (mbPtr->image != None) {
Tk_SizeOfImage(mbPtr->image, &width, &height);
imageOrBitmap:
TkComputeAnchor(mbPtr->anchor, tkwin, 0, 0,
width + mbPtr->indicatorWidth, height, &x, &y);
if (mbPtr->image != NULL) {
Tk_RedrawImage(mbPtr->image, 0, 0, width, height,
Tk_WindowId(tkwin), x, y);
} else {
XCopyPlane(mbPtr->display, mbPtr->bitmap, Tk_WindowId(tkwin),
gc, 0, 0, (unsigned) width, (unsigned) height, x, y, 1);
}
} else if (mbPtr->bitmap != None) {
Tk_SizeOfBitmap(mbPtr->display, mbPtr->bitmap, &width, &height);
goto imageOrBitmap;
} else {
TkComputeAnchor(mbPtr->anchor, tkwin, mbPtr->padX, mbPtr->padY,
mbPtr->textWidth + mbPtr->indicatorWidth, mbPtr->textHeight,
&x, &y);
Tk_DrawTextLayout(mbPtr->display, Tk_WindowId(tkwin), gc,
mbPtr->textLayout, x, y, 0, -1);
}
/*
* If the menu button is disabled with a stipple rather than a special
* foreground color, generate the stippled effect.
*/
if ((mbPtr->state == tkDisabledUid)
&& ((mbPtr->disabledFg == NULL) || (mbPtr->image != NULL))) {
XFillRectangle(mbPtr->display, Tk_WindowId(tkwin), mbPtr->disabledGC,
mbPtr->inset, mbPtr->inset,
(unsigned) (Tk_Width(tkwin) - 2*mbPtr->inset),
(unsigned) (Tk_Height(tkwin) - 2*mbPtr->inset));
}
/*
* Draw the cascade indicator for the menu button on the
* right side of the window, if desired.
*/
if (mbPtr->indicatorOn) {
int w, h, i;
Rect r;
r.left = macDraw->xOff + Tk_Width(tkwin) - mbPtr->inset
- mbPtr->indicatorWidth;
r.top = macDraw->yOff + Tk_Height(tkwin)/2
- mbPtr->indicatorHeight/2;
r.right = macDraw->xOff + Tk_Width(tkwin) - mbPtr->inset
- kTriangleMargin;
r.bottom = macDraw->yOff + Tk_Height(tkwin)/2
+ mbPtr->indicatorHeight/2;
h = mbPtr->indicatorHeight;
w = mbPtr->indicatorWidth - 1 - kTriangleMargin;
for (i = 0; i < h; i++) {
MoveTo(r.left + i, r.top + i);
LineTo(r.left + i + w, r.top + i);
w -= 2;
}
}
/*
* Draw the border and traversal highlight last. This way, if the
* menu button's contents overflow onto the border they'll be covered
* up by the border.
*/
TkMacSetUpClippingRgn(Tk_WindowId(tkwin));
if (mbPtr->borderWidth > 0) {
Rect r;
r.left = macDraw->xOff + mbPtr->highlightWidth + mbPtr->borderWidth;
r.top = macDraw->yOff + mbPtr->highlightWidth + mbPtr->borderWidth;
r.right = macDraw->xOff + Tk_Width(tkwin) - mbPtr->highlightWidth
- mbPtr->borderWidth;
r.bottom = macDraw->yOff + Tk_Height(tkwin) - mbPtr->highlightWidth
- mbPtr->borderWidth;
FrameRect(&r);
PenSize(mbPtr->borderWidth - 1, mbPtr->borderWidth - 1);
MoveTo(r.right, r.top + kShadowOffset);
LineTo(r.right, r.bottom);
LineTo(r.left + kShadowOffset, r.bottom);
}
if (mbPtr->state == tkDisabledUid) {
}
if (mbPtr->highlightWidth != 0) {
GC gc;
if (mbPtr->flags & GOT_FOCUS) {
gc = Tk_GCForColor(mbPtr->highlightColorPtr, Tk_WindowId(tkwin));
} else {
gc = Tk_GCForColor(mbPtr->highlightBgColorPtr, Tk_WindowId(tkwin));
}
Tk_DrawFocusHighlight(tkwin, gc, mbPtr->highlightWidth,
Tk_WindowId(tkwin));
}
SetGWorld(saveWorld, saveDevice);
}
void
TkpDisplayMenuButton(
ClientData clientData) /* Information about widget. */
{
register TkMenuButton *mbPtr = (TkMenuButton *) clientData;
GC gc;
Tk_3DBorder border;
Pixmap pixmap;
int x = 0; /* Initialization needed only to stop compiler
* warning. */
int y = 0;
register Tk_Window tkwin = mbPtr->tkwin;
int fullWidth, fullHeight;
int textXOffset, textYOffset;
int imageWidth, imageHeight;
int imageXOffset, imageYOffset;
int width = 0, height = 0;
/* Image information that will be used to
* restrict disabled pixmap as well */
int haveImage = 0, haveText = 0;
mbPtr->flags &= ~REDRAW_PENDING;
if ((mbPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) {
return;
}
if ((mbPtr->state == STATE_DISABLED) && (mbPtr->disabledFg != NULL)) {
gc = mbPtr->disabledGC;
border = mbPtr->normalBorder;
} else if ((mbPtr->state == STATE_ACTIVE)
&& !Tk_StrictMotif(mbPtr->tkwin)) {
gc = mbPtr->activeTextGC;
border = mbPtr->activeBorder;
} else {
gc = mbPtr->normalTextGC;
border = mbPtr->normalBorder;
}
if (mbPtr->image != None) {
Tk_SizeOfImage(mbPtr->image, &width, &height);
haveImage = 1;
} else if (mbPtr->bitmap != None) {
Tk_SizeOfBitmap(mbPtr->display, mbPtr->bitmap, &width, &height);
haveImage = 1;
}
imageWidth = width;
imageHeight = height;
haveText = (mbPtr->textWidth != 0 && mbPtr->textHeight != 0);
/*
* In order to avoid screen flashes, this function redraws the menu button
* in a pixmap, then copies the pixmap to the screen in a single
* operation. This means that there's no point in time where the on-sreen
* image has been cleared.
*/
pixmap = Tk_GetPixmap(mbPtr->display, Tk_WindowId(tkwin),
Tk_Width(tkwin), Tk_Height(tkwin), Tk_Depth(tkwin));
Tk_Fill3DRectangle(tkwin, pixmap, border, 0, 0, Tk_Width(tkwin),
Tk_Height(tkwin), 0, TK_RELIEF_FLAT);
imageXOffset = 0;
imageYOffset = 0;
textXOffset = 0;
textYOffset = 0;
fullWidth = 0;
fullHeight = 0;
if (mbPtr->compound != COMPOUND_NONE && haveImage && haveText) {
switch ((enum compound) mbPtr->compound) {
case COMPOUND_TOP:
case COMPOUND_BOTTOM:
/*
* Image is above or below text.
*/
if (mbPtr->compound == COMPOUND_TOP) {
textYOffset = height + mbPtr->padY;
} else {
imageYOffset = mbPtr->textHeight + mbPtr->padY;
}
fullHeight = height + mbPtr->textHeight + mbPtr->padY;
fullWidth = (width > mbPtr->textWidth ? width : mbPtr->textWidth);
textXOffset = (fullWidth - mbPtr->textWidth)/2;
imageXOffset = (fullWidth - width)/2;
break;
case COMPOUND_LEFT:
case COMPOUND_RIGHT:
/*
* Image is left or right of text.
*/
if (mbPtr->compound == COMPOUND_LEFT) {
textXOffset = width + mbPtr->padX;
} else {
imageXOffset = mbPtr->textWidth + mbPtr->padX;
}
fullWidth = mbPtr->textWidth + mbPtr->padX + width;
fullHeight = (height > mbPtr->textHeight ? height :
mbPtr->textHeight);
textYOffset = (fullHeight - mbPtr->textHeight)/2;
imageYOffset = (fullHeight - height)/2;
break;
case COMPOUND_CENTER:
/*
* Image and text are superimposed.
*/
fullWidth = (width > mbPtr->textWidth ? width : mbPtr->textWidth);
fullHeight = (height > mbPtr->textHeight ? height :
mbPtr->textHeight);
textXOffset = (fullWidth - mbPtr->textWidth)/2;
imageXOffset = (fullWidth - width)/2;
textYOffset = (fullHeight - mbPtr->textHeight)/2;
imageYOffset = (fullHeight - height)/2;
break;
case COMPOUND_NONE:
break;
}
TkComputeAnchor(mbPtr->anchor, tkwin, 0, 0,
mbPtr->indicatorWidth + fullWidth, fullHeight, &x, &y);
imageXOffset += x;
imageYOffset += y;
if (mbPtr->image != NULL) {
Tk_RedrawImage(mbPtr->image, 0, 0, width, height, pixmap,
imageXOffset, imageYOffset);
} else if (mbPtr->bitmap != None) {
XSetClipOrigin(mbPtr->display, gc, imageXOffset, imageYOffset);
XCopyPlane(mbPtr->display, mbPtr->bitmap, pixmap,
gc, 0, 0, (unsigned) width, (unsigned) height,
imageXOffset, imageYOffset, 1);
XSetClipOrigin(mbPtr->display, gc, 0, 0);
}
Tk_DrawTextLayout(mbPtr->display, pixmap, gc, mbPtr->textLayout,
x + textXOffset, y + textYOffset, 0, -1);
Tk_UnderlineTextLayout(mbPtr->display, pixmap, gc, mbPtr->textLayout,
x + textXOffset, y + textYOffset, mbPtr->underline);
} else if (haveImage) {
TkComputeAnchor(mbPtr->anchor, tkwin, 0, 0,
width + mbPtr->indicatorWidth, height, &x, &y);
imageXOffset += x;
imageYOffset += y;
if (mbPtr->image != NULL) {
Tk_RedrawImage(mbPtr->image, 0, 0, width, height, pixmap,
imageXOffset, imageYOffset);
} else if (mbPtr->bitmap != None) {
XSetClipOrigin(mbPtr->display, gc, x, y);
XCopyPlane(mbPtr->display, mbPtr->bitmap, pixmap,
gc, 0, 0, (unsigned) width, (unsigned) height,
x, y, 1);
XSetClipOrigin(mbPtr->display, gc, 0, 0);
}
} else {
TkComputeAnchor(mbPtr->anchor, tkwin, mbPtr->padX, mbPtr->padY,
mbPtr->textWidth + mbPtr->indicatorWidth,
mbPtr->textHeight, &x, &y);
Tk_DrawTextLayout(mbPtr->display, pixmap, gc, mbPtr->textLayout,
x + textXOffset, y + textYOffset, 0, -1);
Tk_UnderlineTextLayout(mbPtr->display, pixmap, gc,
mbPtr->textLayout, x + textXOffset, y + textYOffset,
mbPtr->underline);
}
/*
* If the menu button is disabled with a stipple rather than a special
* foreground color, generate the stippled effect.
*/
if ((mbPtr->state == STATE_DISABLED)
&& ((mbPtr->disabledFg == NULL) || (mbPtr->image != NULL))) {
/*
* Stipple the whole button if no disabledFg was specified, otherwise
* restrict stippling only to displayed image
*/
if (mbPtr->disabledFg == NULL) {
XFillRectangle(mbPtr->display, pixmap, mbPtr->stippleGC,
mbPtr->inset, mbPtr->inset,
(unsigned) (Tk_Width(tkwin) - 2*mbPtr->inset),
(unsigned) (Tk_Height(tkwin) - 2*mbPtr->inset));
} else {
XFillRectangle(mbPtr->display, pixmap, mbPtr->stippleGC,
imageXOffset, imageYOffset,
(unsigned) imageWidth, (unsigned) imageHeight);
}
}
/*
* Draw the cascade indicator for the menu button on the right side of the
* window, if desired.
*/
if (mbPtr->indicatorOn) {
int borderWidth;
borderWidth = (mbPtr->indicatorHeight+1)/3;
if (borderWidth < 1) {
borderWidth = 1;
}
/*y += mbPtr->textHeight / 2;*/
Tk_Fill3DRectangle(tkwin, pixmap, border,
Tk_Width(tkwin) - mbPtr->inset - mbPtr->indicatorWidth
+ mbPtr->indicatorHeight,
((int) (Tk_Height(tkwin) - mbPtr->indicatorHeight))/2,
mbPtr->indicatorWidth - 2*mbPtr->indicatorHeight,
mbPtr->indicatorHeight, borderWidth, TK_RELIEF_RAISED);
}
/*
* Draw the border and traversal highlight last. This way, if the menu
* button's contents overflow onto the border they'll be covered up by the
* border.
*/
if (mbPtr->relief != TK_RELIEF_FLAT) {
Tk_Draw3DRectangle(tkwin, pixmap, border,
mbPtr->highlightWidth, mbPtr->highlightWidth,
Tk_Width(tkwin) - 2*mbPtr->highlightWidth,
Tk_Height(tkwin) - 2*mbPtr->highlightWidth,
mbPtr->borderWidth, mbPtr->relief);
}
if (mbPtr->highlightWidth != 0) {
GC gc;
if (mbPtr->flags & GOT_FOCUS) {
gc = Tk_GCForColor(mbPtr->highlightColorPtr, pixmap);
} else {
gc = Tk_GCForColor(mbPtr->highlightBgColorPtr, pixmap);
}
Tk_DrawFocusHighlight(tkwin, gc, mbPtr->highlightWidth, pixmap);
}
/*
* Copy the information from the off-screen pixmap onto the screen, then
* delete the pixmap.
*/
XCopyArea(mbPtr->display, pixmap, Tk_WindowId(tkwin),
mbPtr->normalTextGC, 0, 0, (unsigned) Tk_Width(tkwin),
(unsigned) Tk_Height(tkwin), 0, 0);
Tk_FreePixmap(mbPtr->display, pixmap);
}
void
TkpDisplayScale(
ClientData clientData) /* Widget record for scale. */
{
TkScale *scalePtr = (TkScale *) clientData;
Tk_Window tkwin = scalePtr->tkwin;
Tcl_Interp *interp = scalePtr->interp;
Pixmap pixmap;
int result;
char string[PRINT_CHARS];
XRectangle drawnArea;
Tcl_DString buf;
scalePtr->flags &= ~REDRAW_PENDING;
if ((scalePtr->tkwin == NULL) || !Tk_IsMapped(scalePtr->tkwin)) {
goto done;
}
/*
* Invoke the scale's command if needed.
*/
Tcl_Preserve(scalePtr);
if ((scalePtr->flags & INVOKE_COMMAND) && (scalePtr->command != NULL)) {
Tcl_Preserve(interp);
sprintf(string, scalePtr->format, scalePtr->value);
Tcl_DStringInit(&buf);
Tcl_DStringAppend(&buf, scalePtr->command, -1);
Tcl_DStringAppend(&buf, " ", -1);
Tcl_DStringAppend(&buf, string, -1);
result = Tcl_EvalEx(interp, Tcl_DStringValue(&buf), -1, 0);
Tcl_DStringFree(&buf);
if (result != TCL_OK) {
Tcl_AddErrorInfo(interp, "\n (command executed by scale)");
Tcl_BackgroundException(interp, result);
}
Tcl_Release(interp);
}
scalePtr->flags &= ~INVOKE_COMMAND;
if (scalePtr->flags & SCALE_DELETED) {
Tcl_Release(scalePtr);
return;
}
Tcl_Release(scalePtr);
#ifndef TK_NO_DOUBLE_BUFFERING
/*
* In order to avoid screen flashes, this function redraws the scale in a
* pixmap, then copies the pixmap to the screen in a single operation.
* This means that there's no point in time where the on-sreen image has
* been cleared.
*/
pixmap = Tk_GetPixmap(scalePtr->display, Tk_WindowId(tkwin),
Tk_Width(tkwin), Tk_Height(tkwin), Tk_Depth(tkwin));
#else
pixmap = Tk_WindowId(tkwin);
#endif /* TK_NO_DOUBLE_BUFFERING */
drawnArea.x = 0;
drawnArea.y = 0;
drawnArea.width = Tk_Width(tkwin);
drawnArea.height = Tk_Height(tkwin);
/*
* Much of the redisplay is done totally differently for horizontal and
* vertical scales. Handle the part that's different.
*/
if (scalePtr->orient == ORIENT_VERTICAL) {
DisplayVerticalScale(scalePtr, pixmap, &drawnArea);
} else {
DisplayHorizontalScale(scalePtr, pixmap, &drawnArea);
}
/*
* Now handle the part of redisplay that is the same for horizontal and
* vertical scales: border and traversal highlight.
*/
if (scalePtr->flags & REDRAW_OTHER) {
if (scalePtr->relief != TK_RELIEF_FLAT) {
Tk_Draw3DRectangle(tkwin, pixmap, scalePtr->bgBorder,
scalePtr->highlightWidth, scalePtr->highlightWidth,
Tk_Width(tkwin) - 2*scalePtr->highlightWidth,
Tk_Height(tkwin) - 2*scalePtr->highlightWidth,
scalePtr->borderWidth, scalePtr->relief);
}
if (scalePtr->highlightWidth != 0) {
GC gc;
if (scalePtr->flags & GOT_FOCUS) {
gc = Tk_GCForColor(scalePtr->highlightColorPtr, pixmap);
} else {
gc = Tk_GCForColor(
Tk_3DBorderColor(scalePtr->highlightBorder), pixmap);
}
Tk_DrawFocusHighlight(tkwin, gc, scalePtr->highlightWidth, pixmap);
}
}
#ifndef TK_NO_DOUBLE_BUFFERING
/*
* Copy the information from the off-screen pixmap onto the screen, then
* delete the pixmap.
*/
XCopyArea(scalePtr->display, pixmap, Tk_WindowId(tkwin),
scalePtr->copyGC, drawnArea.x, drawnArea.y, drawnArea.width,
drawnArea.height, drawnArea.x, drawnArea.y);
Tk_FreePixmap(scalePtr->display, pixmap);
#endif /* TK_NO_DOUBLE_BUFFERING */
done:
scalePtr->flags &= ~REDRAW_ALL;
}
void
TkpDisplayButton(
ClientData clientData) /* Information about widget. */
{
register TkButton *butPtr = (TkButton *) clientData;
GC gc;
Tk_3DBorder border;
Pixmap pixmap;
int x = 0; /* Initialization only needed to stop compiler
* warning. */
int y, relief;
Tk_Window tkwin = butPtr->tkwin;
int width, height, fullWidth, fullHeight;
int textXOffset, textYOffset;
int haveImage = 0, haveText = 0;
int offset; /* 1 means this is a button widget, so we
* offset the text to make the button appear
* to move up and down as the relief
* changes. */
int imageWidth, imageHeight;
int imageXOffset = 0, imageYOffset = 0;
/* image information that will be used to
* restrict disabled pixmap as well */
butPtr->flags &= ~REDRAW_PENDING;
if ((butPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) {
return;
}
border = butPtr->normalBorder;
if ((butPtr->state == STATE_DISABLED) && (butPtr->disabledFg != NULL)) {
gc = butPtr->disabledGC;
} else if ((butPtr->state == STATE_ACTIVE)
&& !Tk_StrictMotif(butPtr->tkwin)) {
gc = butPtr->activeTextGC;
border = butPtr->activeBorder;
} else {
gc = butPtr->normalTextGC;
}
if ((butPtr->flags & SELECTED) && (butPtr->state != STATE_ACTIVE)
&& (butPtr->selectBorder != NULL) && !butPtr->indicatorOn) {
border = butPtr->selectBorder;
}
/*
* Override the relief specified for the button if this is a checkbutton
* or radiobutton and there's no indicator. The new relief is as follows:
* If the button is select --> "sunken"
* If relief==overrelief --> relief
* Otherwise --> overrelief
*
* The effect we are trying to achieve is as follows:
*
* value mouse-over? --> relief
* ------- ------------ --------
* off no flat
* off yes raised
* on no sunken
* on yes sunken
*
* This is accomplished by configuring the checkbutton or radiobutton like
* this:
*
* -indicatoron 0 -overrelief raised -offrelief flat
*
* Bindings (see library/button.tcl) will copy the -overrelief into
* -relief on mouseover. Hence, we can tell if we are in mouse-over by
* comparing relief against overRelief. This is an aweful kludge, but it
* gives use the desired behavior while keeping the code backwards
* compatible.
*/
relief = butPtr->relief;
if ((butPtr->type >= TYPE_CHECK_BUTTON) && !butPtr->indicatorOn) {
if (butPtr->flags & SELECTED) {
relief = TK_RELIEF_SUNKEN;
} else if (butPtr->overRelief != relief) {
relief = butPtr->offRelief;
}
}
offset = (butPtr->type == TYPE_BUTTON) && !Tk_StrictMotif(butPtr->tkwin);
/*
* In order to avoid screen flashes, this function redraws the button in a
* pixmap, then copies the pixmap to the screen in a single operation.
* This means that there's no point in time where the on-screen image has
* been cleared.
*/
pixmap = Tk_GetPixmap(butPtr->display, Tk_WindowId(tkwin),
Tk_Width(tkwin), Tk_Height(tkwin), Tk_Depth(tkwin));
Tk_Fill3DRectangle(tkwin, pixmap, border, 0, 0, Tk_Width(tkwin),
Tk_Height(tkwin), 0, TK_RELIEF_FLAT);
/*
* Display image or bitmap or text for button.
*/
if (butPtr->image != NULL) {
Tk_SizeOfImage(butPtr->image, &width, &height);
haveImage = 1;
} else if (butPtr->bitmap != None) {
Tk_SizeOfBitmap(butPtr->display, butPtr->bitmap, &width, &height);
haveImage = 1;
}
imageWidth = width;
imageHeight = height;
haveText = (butPtr->textWidth != 0 && butPtr->textHeight != 0);
if (butPtr->compound != COMPOUND_NONE && haveImage && haveText) {
textXOffset = 0;
textYOffset = 0;
fullWidth = 0;
fullHeight = 0;
switch ((enum compound) butPtr->compound) {
case COMPOUND_TOP:
case COMPOUND_BOTTOM:
/*
* Image is above or below text.
*/
if (butPtr->compound == COMPOUND_TOP) {
textYOffset = height + butPtr->padY;
} else {
imageYOffset = butPtr->textHeight + butPtr->padY;
}
fullHeight = height + butPtr->textHeight + butPtr->padY;
fullWidth = (width > butPtr->textWidth ? width :
butPtr->textWidth);
textXOffset = (fullWidth - butPtr->textWidth)/2;
imageXOffset = (fullWidth - width)/2;
break;
case COMPOUND_LEFT:
case COMPOUND_RIGHT:
/*
* Image is left or right of text.
*/
if (butPtr->compound == COMPOUND_LEFT) {
textXOffset = width + butPtr->padX;
} else {
imageXOffset = butPtr->textWidth + butPtr->padX;
}
fullWidth = butPtr->textWidth + butPtr->padX + width;
fullHeight = (height > butPtr->textHeight ? height :
butPtr->textHeight);
textYOffset = (fullHeight - butPtr->textHeight)/2;
imageYOffset = (fullHeight - height)/2;
break;
case COMPOUND_CENTER:
/*
* Image and text are superimposed.
*/
fullWidth = (width > butPtr->textWidth ? width :
butPtr->textWidth);
fullHeight = (height > butPtr->textHeight ? height :
butPtr->textHeight);
textXOffset = (fullWidth - butPtr->textWidth)/2;
imageXOffset = (fullWidth - width)/2;
textYOffset = (fullHeight - butPtr->textHeight)/2;
imageYOffset = (fullHeight - height)/2;
break;
case COMPOUND_NONE:
break;
}
TkComputeAnchor(butPtr->anchor, tkwin, butPtr->padX, butPtr->padY,
butPtr->indicatorSpace + fullWidth, fullHeight, &x, &y);
x += butPtr->indicatorSpace;
x += offset;
y += offset;
if (relief == TK_RELIEF_RAISED) {
x -= offset;
y -= offset;
} else if (relief == TK_RELIEF_SUNKEN) {
x += offset;
y += offset;
}
imageXOffset += x;
imageYOffset += y;
if (butPtr->image != NULL) {
/*
* Do boundary clipping, so that Tk_RedrawImage is passed valid
* coordinates. [Bug 979239]
*/
if (imageXOffset < 0) {
imageXOffset = 0;
}
if (imageYOffset < 0) {
imageYOffset = 0;
}
if (width > Tk_Width(tkwin)) {
width = Tk_Width(tkwin);
}
if (height > Tk_Height(tkwin)) {
height = Tk_Height(tkwin);
}
if ((width + imageXOffset) > Tk_Width(tkwin)) {
imageXOffset = Tk_Width(tkwin) - width;
}
if ((height + imageYOffset) > Tk_Height(tkwin)) {
imageYOffset = Tk_Height(tkwin) - height;
}
if ((butPtr->selectImage != NULL) && (butPtr->flags & SELECTED)) {
Tk_RedrawImage(butPtr->selectImage, 0, 0,
width, height, pixmap, imageXOffset, imageYOffset);
} else if ((butPtr->tristateImage != NULL) && (butPtr->flags & TRISTATED)) {
Tk_RedrawImage(butPtr->tristateImage, 0, 0,
width, height, pixmap, imageXOffset, imageYOffset);
} else {
Tk_RedrawImage(butPtr->image, 0, 0, width,
height, pixmap, imageXOffset, imageYOffset);
}
} else {
XSetClipOrigin(butPtr->display, gc, imageXOffset, imageYOffset);
XCopyPlane(butPtr->display, butPtr->bitmap, pixmap, gc,
0, 0, (unsigned int) width, (unsigned int) height,
imageXOffset, imageYOffset, 1);
XSetClipOrigin(butPtr->display, gc, 0, 0);
}
Tk_DrawTextLayout(butPtr->display, pixmap, gc,
butPtr->textLayout, x + textXOffset, y + textYOffset, 0, -1);
Tk_UnderlineTextLayout(butPtr->display, pixmap, gc,
butPtr->textLayout, x + textXOffset, y + textYOffset,
butPtr->underline);
y += fullHeight/2;
} else {
if (haveImage) {
TkComputeAnchor(butPtr->anchor, tkwin, 0, 0,
butPtr->indicatorSpace + width, height, &x, &y);
x += butPtr->indicatorSpace;
x += offset;
y += offset;
if (relief == TK_RELIEF_RAISED) {
x -= offset;
y -= offset;
} else if (relief == TK_RELIEF_SUNKEN) {
x += offset;
y += offset;
}
imageXOffset += x;
imageYOffset += y;
if (butPtr->image != NULL) {
/*
* Do boundary clipping, so that Tk_RedrawImage is passed
* valid coordinates. [Bug 979239]
*/
if (imageXOffset < 0) {
imageXOffset = 0;
}
if (imageYOffset < 0) {
imageYOffset = 0;
}
if (width > Tk_Width(tkwin)) {
width = Tk_Width(tkwin);
}
if (height > Tk_Height(tkwin)) {
height = Tk_Height(tkwin);
}
if ((width + imageXOffset) > Tk_Width(tkwin)) {
imageXOffset = Tk_Width(tkwin) - width;
}
if ((height + imageYOffset) > Tk_Height(tkwin)) {
imageYOffset = Tk_Height(tkwin) - height;
}
if ((butPtr->selectImage != NULL) &&
(butPtr->flags & SELECTED)) {
Tk_RedrawImage(butPtr->selectImage, 0, 0, width,
height, pixmap, imageXOffset, imageYOffset);
} else if ((butPtr->tristateImage != NULL) &&
(butPtr->flags & TRISTATED)) {
Tk_RedrawImage(butPtr->tristateImage, 0, 0, width,
height, pixmap, imageXOffset, imageYOffset);
} else {
Tk_RedrawImage(butPtr->image, 0, 0, width, height, pixmap,
imageXOffset, imageYOffset);
}
} else {
XSetClipOrigin(butPtr->display, gc, x, y);
XCopyPlane(butPtr->display, butPtr->bitmap, pixmap, gc, 0, 0,
(unsigned int) width, (unsigned int) height, x, y, 1);
XSetClipOrigin(butPtr->display, gc, 0, 0);
}
y += height/2;
} else {
TkComputeAnchor(butPtr->anchor, tkwin, butPtr->padX, butPtr->padY,
butPtr->indicatorSpace + butPtr->textWidth,
butPtr->textHeight, &x, &y);
x += butPtr->indicatorSpace;
x += offset;
y += offset;
if (relief == TK_RELIEF_RAISED) {
x -= offset;
y -= offset;
} else if (relief == TK_RELIEF_SUNKEN) {
x += offset;
y += offset;
}
Tk_DrawTextLayout(butPtr->display, pixmap, gc, butPtr->textLayout,
x, y, 0, -1);
Tk_UnderlineTextLayout(butPtr->display, pixmap, gc,
butPtr->textLayout, x, y, butPtr->underline);
y += butPtr->textHeight/2;
}
}
/*
* Draw the indicator for check buttons and radio buttons. At this point,
* x and y refer to the top-left corner of the text or image or bitmap.
*/
if ((butPtr->type == TYPE_CHECK_BUTTON) && butPtr->indicatorOn) {
if (butPtr->indicatorDiameter > 2*butPtr->borderWidth) {
TkBorder *selBorder = (TkBorder *) butPtr->selectBorder;
XColor *selColor = NULL;
if (selBorder != NULL) {
selColor = selBorder->bgColorPtr;
}
x -= butPtr->indicatorSpace/2;
y = Tk_Height(tkwin)/2;
TkpDrawCheckIndicator(tkwin, butPtr->display, pixmap, x, y,
border, butPtr->normalFg, selColor, butPtr->disabledFg,
((butPtr->flags & SELECTED) ? 1 :
(butPtr->flags & TRISTATED) ? 2 : 0),
(butPtr->state == STATE_DISABLED), CHECK_BUTTON);
}
} else if ((butPtr->type == TYPE_RADIO_BUTTON) && butPtr->indicatorOn) {
if (butPtr->indicatorDiameter > 2*butPtr->borderWidth) {
TkBorder *selBorder = (TkBorder *) butPtr->selectBorder;
XColor *selColor = NULL;
if (selBorder != NULL) {
selColor = selBorder->bgColorPtr;
}
x -= butPtr->indicatorSpace/2;
y = Tk_Height(tkwin)/2;
TkpDrawCheckIndicator(tkwin, butPtr->display, pixmap, x, y,
border, butPtr->normalFg, selColor, butPtr->disabledFg,
((butPtr->flags & SELECTED) ? 1 :
(butPtr->flags & TRISTATED) ? 2 : 0),
(butPtr->state == STATE_DISABLED), RADIO_BUTTON);
}
}
/*
* If the button is disabled with a stipple rather than a special
* foreground color, generate the stippled effect. If the widget is
* selected and we use a different background color when selected, must
* temporarily modify the GC so the stippling is the right color.
*/
if ((butPtr->state == STATE_DISABLED)
&& ((butPtr->disabledFg == NULL) || (butPtr->image != NULL))) {
if ((butPtr->flags & SELECTED) && !butPtr->indicatorOn
&& (butPtr->selectBorder != NULL)) {
XSetForeground(butPtr->display, butPtr->stippleGC,
Tk_3DBorderColor(butPtr->selectBorder)->pixel);
}
/*
* Stipple the whole button if no disabledFg was specified, otherwise
* restrict stippling only to displayed image
*/
if (butPtr->disabledFg == NULL) {
XFillRectangle(butPtr->display, pixmap, butPtr->stippleGC, 0, 0,
(unsigned) Tk_Width(tkwin), (unsigned) Tk_Height(tkwin));
} else {
XFillRectangle(butPtr->display, pixmap, butPtr->stippleGC,
imageXOffset, imageYOffset,
(unsigned) imageWidth, (unsigned) imageHeight);
}
if ((butPtr->flags & SELECTED) && !butPtr->indicatorOn
&& (butPtr->selectBorder != NULL)) {
XSetForeground(butPtr->display, butPtr->stippleGC,
Tk_3DBorderColor(butPtr->normalBorder)->pixel);
}
}
/*
* Draw the border and traversal highlight last. This way, if the button's
* contents overflow they'll be covered up by the border. This code is
* complicated by the possible combinations of focus highlight and default
* rings. We draw the focus and highlight rings using the highlight border
* and highlight foreground color.
*/
if (relief != TK_RELIEF_FLAT) {
int inset = butPtr->highlightWidth;
if (butPtr->defaultState == DEFAULT_ACTIVE) {
/*
* Draw the default ring with 2 pixels of space between the
* default ring and the button and the default ring and the focus
* ring. Note that we need to explicitly draw the space in the
* highlightBorder color to ensure that we overwrite any overflow
* text and/or a different button background color.
*/
Tk_Draw3DRectangle(tkwin, pixmap, butPtr->highlightBorder, inset,
inset, Tk_Width(tkwin) - 2*inset,
Tk_Height(tkwin) - 2*inset, 2, TK_RELIEF_FLAT);
inset += 2;
Tk_Draw3DRectangle(tkwin, pixmap, butPtr->highlightBorder, inset,
inset, Tk_Width(tkwin) - 2*inset,
Tk_Height(tkwin) - 2*inset, 1, TK_RELIEF_SUNKEN);
inset++;
Tk_Draw3DRectangle(tkwin, pixmap, butPtr->highlightBorder, inset,
inset, Tk_Width(tkwin) - 2*inset,
Tk_Height(tkwin) - 2*inset, 2, TK_RELIEF_FLAT);
inset += 2;
} else if (butPtr->defaultState == DEFAULT_NORMAL) {
/*
* Leave room for the default ring and write over any text or
* background color.
*/
Tk_Draw3DRectangle(tkwin, pixmap, butPtr->highlightBorder, 0,
0, Tk_Width(tkwin), Tk_Height(tkwin), 5, TK_RELIEF_FLAT);
inset += 5;
}
/*
* Draw the button border.
*/
Tk_Draw3DRectangle(tkwin, pixmap, border, inset, inset,
Tk_Width(tkwin) - 2*inset, Tk_Height(tkwin) - 2*inset,
butPtr->borderWidth, relief);
}
if (butPtr->highlightWidth > 0) {
GC gc;
if (butPtr->flags & GOT_FOCUS) {
gc = Tk_GCForColor(butPtr->highlightColorPtr, pixmap);
} else {
gc = Tk_GCForColor(Tk_3DBorderColor(butPtr->highlightBorder),
pixmap);
}
/*
* Make sure the focus ring shrink-wraps the actual button, not the
* padding space left for a default ring.
*/
if (butPtr->defaultState == DEFAULT_NORMAL) {
TkDrawInsetFocusHighlight(tkwin, gc, butPtr->highlightWidth,
pixmap, 5);
} else {
Tk_DrawFocusHighlight(tkwin, gc, butPtr->highlightWidth, pixmap);
}
}
/*
* Copy the information from the off-screen pixmap onto the screen, then
* delete the pixmap.
*/
XCopyArea(butPtr->display, pixmap, Tk_WindowId(tkwin),
butPtr->copyGC, 0, 0, (unsigned) Tk_Width(tkwin),
(unsigned) Tk_Height(tkwin), 0, 0);
Tk_FreePixmap(butPtr->display, pixmap);
}
void
TkpDisplayScale(
ClientData clientData) /* Widget record for scale. */
{
TkScale *scalePtr = (TkScale *) clientData;
Tk_Window tkwin = scalePtr->tkwin;
Tcl_Interp *interp = scalePtr->interp;
int result;
char string[TCL_DOUBLE_SPACE];
MacScale *macScalePtr = (MacScale *) clientData;
Rect r;
WindowRef windowRef;
CGrafPtr destPort, savePort;
Boolean portChanged;
MacDrawable *macDraw;
SInt32 initialValue, minValue, maxValue;
UInt16 numTicks;
#ifdef TK_MAC_DEBUG_SCALE
TkMacOSXDbgMsg("TkpDisplayScale");
#endif
scalePtr->flags &= ~REDRAW_PENDING;
if ((scalePtr->tkwin == NULL) || !Tk_IsMapped(scalePtr->tkwin)) {
goto done;
}
/*
* Invoke the scale's command if needed.
*/
Tcl_Preserve((ClientData) scalePtr);
if ((scalePtr->flags & INVOKE_COMMAND) && (scalePtr->command != NULL)) {
Tcl_Preserve((ClientData) interp);
sprintf(string, scalePtr->format, scalePtr->value);
result = Tcl_VarEval(interp, scalePtr->command, " ", string, NULL);
if (result != TCL_OK) {
Tcl_AddErrorInfo(interp, "\n (command executed by scale)");
Tcl_BackgroundError(interp);
}
Tcl_Release((ClientData) interp);
}
scalePtr->flags &= ~INVOKE_COMMAND;
if (scalePtr->flags & SCALE_DELETED) {
Tcl_Release((ClientData) scalePtr);
return;
}
Tcl_Release((ClientData) scalePtr);
/*
* Now handle the part of redisplay that is the same for
* horizontal and vertical scales: border and traversal
* highlight.
*/
if (scalePtr->highlightWidth != 0) {
GC gc = Tk_GCForColor(scalePtr->highlightColorPtr, Tk_WindowId(tkwin));
Tk_DrawFocusHighlight(tkwin, gc, scalePtr->highlightWidth,
Tk_WindowId(tkwin));
}
Tk_Draw3DRectangle(tkwin, Tk_WindowId(tkwin), scalePtr->bgBorder,
scalePtr->highlightWidth, scalePtr->highlightWidth,
Tk_Width(tkwin) - 2*scalePtr->highlightWidth,
Tk_Height(tkwin) - 2*scalePtr->highlightWidth,
scalePtr->borderWidth, scalePtr->relief);
/*
* Set up port for drawing Macintosh control.
*/
macDraw = (MacDrawable *) Tk_WindowId(tkwin);
destPort = TkMacOSXGetDrawablePort(Tk_WindowId(tkwin));
windowRef = TkMacOSXDrawableWindow(Tk_WindowId(tkwin));
portChanged = QDSwapPort(destPort, &savePort);
TkMacOSXSetUpClippingRgn(Tk_WindowId(tkwin));
/*
* Create Macintosh control.
*/
#define MAC_OSX_SCROLL_WIDTH 10
if (scalePtr->orient == ORIENT_HORIZONTAL) {
int offset = (Tk_Height(tkwin) - MAC_OSX_SCROLL_WIDTH)/2;
if (offset < 0) {
offset = 0;
}
r.left = macDraw->xOff + scalePtr->inset;
r.top = macDraw->yOff + offset;
r.right = macDraw->xOff+Tk_Width(tkwin) - scalePtr->inset;
r.bottom = macDraw->yOff + offset + MAC_OSX_SCROLL_WIDTH/2;
} else {
int offset = (Tk_Width(tkwin) - MAC_OSX_SCROLL_WIDTH)/2;
if (offset < 0) {
offset = 0;
}
r.left = macDraw->xOff + offset;
r.top = macDraw->yOff + scalePtr->inset;
r.right = macDraw->xOff + offset + MAC_OSX_SCROLL_WIDTH/2;
r.bottom = macDraw->yOff+Tk_Height(tkwin) - scalePtr->inset;
}
if (macScalePtr->scaleHandle == NULL) {
#ifdef TK_MAC_DEBUG_SCALE
TkMacOSXDbgMsg("Initialising scale");
#endif
initialValue = scalePtr->value;
if (scalePtr->orient == ORIENT_HORIZONTAL) {
minValue = scalePtr->fromValue;
maxValue = scalePtr->toValue;
} else {
minValue = scalePtr->fromValue;
maxValue = scalePtr->toValue;
}
if (scalePtr->tickInterval == 0) {
numTicks = 0;
} else {
numTicks = (maxValue - minValue)/scalePtr->tickInterval;
}
CreateSliderControl(windowRef, &r, initialValue, minValue, maxValue,
kControlSliderPointsDownOrRight, numTicks, 1, scaleActionProc,
&(macScalePtr->scaleHandle));
SetControlReference(macScalePtr->scaleHandle, (UInt32) scalePtr);
if (IsWindowActive(windowRef)) {
macScalePtr->flags |= ACTIVE;
}
} else {
SetControlBounds(macScalePtr->scaleHandle, &r);
SetControl32BitValue(macScalePtr->scaleHandle, scalePtr->value);
SetControl32BitMinimum(macScalePtr->scaleHandle, scalePtr->fromValue);
SetControl32BitMaximum(macScalePtr->scaleHandle, scalePtr->toValue);
}
/*
* Finally draw the control.
*/
SetControlVisibility(macScalePtr->scaleHandle,true,true);
HiliteControl(macScalePtr->scaleHandle,0);
Draw1Control(macScalePtr->scaleHandle);
if (portChanged) {
QDSwapPort(savePort, NULL);
}
done:
scalePtr->flags &= ~REDRAW_ALL;
}