Tk Source Code

#else
	canvasPtr->drawableXOrigin = canvasPtr->xOrigin;
	canvasPtr->drawableYOrigin = canvasPtr->yOrigin;
	pixmap = Tk_WindowId(tkwin);
	Tk_ClipDrawableToRect(Tk_Display(tkwin), pixmap,
		screenX1 - canvasPtr->xOrigin, screenY1 - canvasPtr->yOrigin,
		width, height);
	/*
	 * Call ItemDisplay for all window items.  This does not redraw the
	 * windows, but sets their position within the canvas, which ensures
	 * for macOS (the only platform which defines TK_NO_DOUBLE_BUFFERING)
	 * that the clipping region for the canvas gets updated before the
	 * background is painted by XFillRectangle.  Otherwise, when the
	 * background is filled the old locations of the window items will be
	 * clipped away, rather than the new locations, causing "ghost"
	 * windows to appear at the old locations.  Now that updateLayer is
	 * being used for macOS drawing it should be possible to stop
	 * maintaining clipping regions for all widgets.  When that happens
	 * this code can probably be removed.
	 */

	for (itemPtr = canvasPtr->firstItemPtr; itemPtr != NULL;
		itemPtr = itemPtr->nextPtr) {
	    if (AlwaysRedraw(itemPtr)) {
		ItemDisplay(canvasPtr, itemPtr, pixmap,
			    screenX1, screenY1, width, height);
	    }
	}

#endif /* TK_NO_DOUBLE_BUFFERING */

	/*
	 * Clear the area to be redrawn.
	 */

	XFillRectangle(Tk_Display(tkwin), pixmap, canvasPtr->pixmapGC,

 *	between them, that are on the same line and use the same font and font
 *	size. Allocate the chars of all these chunks, the so-called "stretch",
 *	in a DString in the first chunk, the so-called "base chunk". Use the
 *	base chunk string for measuring and drawing, so that these actions are
 *	always performed with maximum context.
 *
 *	This is necessary for text rendering engines that provide ligatures
 *	and sub-pixel layout, like ATSU on macOS. If we don't do this, the
 *	measuring will change all the time, leading to an ugly "tremble and
 *	shiver" effect. This is because of the continuous splitting and
 *	re-merging of chunks that goes on in a text widget, when the cursor or
 *	the selection move.
 *
 * Side effects:
 *

	 * Now scroll the lines. This may generate damage which we handle by
	 * calling TextInvalidateRegion to mark the display blocks as stale.
	 */

	damageRgn = TkCreateRegion();
	if (TkScrollWindow(textPtr->tkwin, dInfoPtr->scrollGC, MAX(0, dInfoPtr->x - extent1), oldY,
		dInfoPtr->maxX - dInfoPtr->x + extent1 + extent2, height, 0, y - oldY, damageRgn)) {
#ifndef MACOSX_TK
	    /* No point in doing this on macOS. The DLines get redrawn anyway.*/
	    TextInvalidateRegion(textPtr, damageRgn);
#endif
	}
	DEBUG(stats.numCopies += 1);
	TkDestroyRegion(damageRgn);
    }

    /*
     * Clear the REDRAW_PENDING flag here. This is actually pretty tricky. We want to

	    } else if (dInfoPtr->countWindows > 0 && dlPtr->chunkPtr) {
		/*
		 * On macOS we need to redisplay all embedded windows which
		 * were moved by the call to TkScrollWindows above.  This is
		 * not necessary on Unix or Windows because XScrollWindow will
		 * have included the bounding rectangles of all of these
		 * windows in the damage region.  The macosx implementation of
		 * TkScrollWindow is not able to do this because no
		 * information about embedded windows is avaliable to it. So
		 * it simply generates a damage region which is the scroll
		 * source rectangle minus the scroll destination rectangle.


		 * (On Unix this is handled by GraphicsExpose events generated
		 * by XCopyArea and on Windows by ScrollWindowEx.  On macOS


		 * the embedded windows are not managed by the window manager,

		 * so there is no analogous technique available.)
		 *
		 * On the other hand, this loop is already iterating through
		 * all embedded windows which could possibly have been moved
		 * by the scrolling.  So it is as efficient to redisplay them
		 * here as it would have been if they had been redisplayed by
		 * the call to TextInvalidateRegion above.
		 */
#else
	    } else if (dInfoPtr->countWindows > 0
		    && dlPtr->chunkPtr
		    && (dlPtr->y < 0 || dlPtr->y + dlPtr->height > dInfoPtr->maxY)) {

		/*
		 * On platforms other than the macOS:
		 *
		 * It's the first or last DLine which are also overlapping the
		 * top or bottom of the window, but we decided above it wasn't
		 * necessary to display them (we were able to update them by
		 * scrolling). This is fine, except that if the lines contain
		 * any embedded windows, we must still call the display proc
		 * on them because they might need to be unmapped or they

		    }
		    if (tkTextDebug) {
			char string[TK_POS_CHARS];

			TkrTextPrintIndex(textPtr, &dlPtr->index, string);
			LOG("tk_textEmbWinDisplay", string);
		    }
#ifdef MAC_OSX_TK
		    /* We need to redisplay the entire DLine so that the
		     * background of the line will not contain artifacts left
		     * by the scrolling.
		     */
		    
		    DisplayDLine(textPtr, dlPtr, NULL, pixmap);
#else		   
		    chunkPtr->layoutProcs->displayProc(textPtr, chunkPtr, x,
			    dlPtr->spaceAbove,
			    dlPtr->height - dlPtr->spaceAbove - dlPtr->spaceBelow,
			    dlPtr->baseline - dlPtr->spaceAbove, NULL,
			    (Drawable) None, dlPtr->y + dlPtr->spaceAbove);
#endif
		}
	    }
	}
#ifndef TK_NO_DOUBLE_BUFFERING
	Tk_FreePixmap(Tk_Display(textPtr->tkwin), pixmap);
#endif /* TK_NO_DOUBLE_BUFFERING */
    }

- (BOOL) wantsUpdateLayer
{
    return YES;
}
- (void) updateLayer {
    CGContextRef context = self.tkLayerBitmapContext;
    static bool initialized = NO;
    if (context && ![NSApp tkWillExit]) {
	/*
	 * Create a CGImage by copying (probably using copy-on-write) the
	 * bitmap data of the CGBitmapContext that we have been using for
	 * drawing.  Then render that CGImage into the CALayer of this view by
	 * assigning a reference to the CGImage to the contents property of the
	 * layer. This will cause all drawing done since the last call to this
	 * function to become visible.
	 */

	CGImageRef newImg = CGBitmapContextCreateImage(context);
	self.layer.contents = (__bridge id) newImg;
	CGImageRelease(newImg); // will quickly leak memory if this is missing

	/*
	 * Run any pending widget display procs as part of the update.
	 * Without this there are black flashes when a window opens.
	 */

	if (!initialized) {
	    while(Tcl_DoOneEvent(TCL_IDLE_EVENTS)){}
	    initialized = YES;
	}
    }
}

- (void) viewDidChangeBackingProperties
{

    /*

	Tk_MapWindow((Tk_Window)winPtr);
	[macWin deminiaturize:NSApp];
	[macWin orderFront:NSApp];
	TkMacOSXZoomToplevel(macWin, state == NormalState ? inZoomIn : inZoomOut);
    }

    /*
     * Make sure windows are updated after the state change too.  This is needed
     * in order for the event-9.11-20 tests to pass.
     */

    while (Tcl_DoOneEvent(TCL_IDLE_EVENTS)){}
setStateEnd:
    return 1;
}