Display

• Engine
• ArcGIS for Desktop Basic
• ArcGIS for Desktop Standard
• ArcGIS for Desktop Advanced
• Server

• Display
• Colors
• Color ramps
• Symbols
• Display feedbacks
• Rubber bands
• Trackers

• ScreenDisplay abstracts a normal application window and implements scrolling and backing store (multiple backing layers are possible).
• SimpleDisplay abstracts all other devices that can be rendered to using a Windows Device Context, such as printers, metafiles, bitmaps, and secondary windows.

• DisplayTransformation—This object defines how real-world coordinates are mapped to a output device. Three rectangles define the transformation. The Bounds specifies the full extent in real-world coordinates. The VisibleBounds specifies the visible extent. The DeviceFrame specifies where the VisibleBounds appears on the output device. Since the aspect ratio of the DeviceFrame may not always match the aspect ratio of the specified VisibleBounds, the transformation calculates the actual visible bounds that fits the DeviceFrame. This is called the FittedBounds and is in real-world coordinates. All coordinates can be rotated about the center of the visible bounds by setting the transformation's Rotation property.

Display caching

• Use the recording cache to redraw when the application is moved or exposed or when drawing editing rubberbanding. This is very efficient since only one BitBlt is needed.
• Select a new set of features and invalidate only the selection cache. Features draw from cache. Graphics and annotation draw from cache. Only the feature selection draws from scratch.
• Move a graphic element or annotation over features. Only invalidate the annotation cache. Features draw from cache and feature selection draws from cache. Only the annotation draws from scratch.
• Create a tracking layer. Always return true for its cached property. To show vehicle movement when new Global Positioning System (GPS) signals are received, move the markers in the layer and only invalidate the tracking layer. All other layers draw from cache. Only the vehicle layer draws from scratch. This makes it possible to animate a layer.
• Create a basemap by moving several layers into a group layer and setting the group layer's cached property to true. Now you can edit and interact with layers that draw on top of the basemap without having to redraw the basemap from scratch.
• The concept of a display filter allows raster operations to be performed on any kind of layer including feature layers that use custom symbols. It will be possible to create a slider dialog that attaches to a layer. It sets the layer's cached property to true and uses a transparency display filter to interactively control the layer's transparency using the slider. Other display filters can be created to implement clipping, contrast, brightness, and so on.

Recording cache

• Implement a single bitmap backing store by drawing a sequence. See the following code example:

IScreenDisplay screenDisplay;
MapControl mapControl;
boolean isCacheDirty = screenDisplay.isCacheDirty((short)
    esriScreenCache.esriScreenRecording);
if (isCacheDirty){
    screenDisplay.startRecording();
    screenDisplay.startDrawing(mapControl.getHWnd(), (short)
        esriScreenCache.esriNoScreenCache);
    drawContents();
    screenDisplay.finishDrawing();
    screenDisplay.stopRecording();
}

else{
    screenDisplay.drawCache(mapControl.getHWnd(), (short)
        esriScreenCache.esriScreenRecording, null, null);
}

Caveats

Caching layers

public void enableLayerCaches(MapBean map){
    try{
        for (int i = 0; i < map.getLayerCount(); i++)
            map.getLayer(i).setCached(true);
        //Pass the values as needed.   
        //Reactivate the display.
        map.getActiveView().deactivate();
        map.getActiveView().activate(map.getHWnd());
        map.getActiveView().refresh();
    }
    catch (Exception e){
        e.printStackTrace();
    }
}

Rotation

• Getting a rectangle from the transform—For example, if you want a rectangle representing the client area of the window; since the user is seeing rotated space on the display, it's not possible to represent the requested area as an envelope. The four corners of the rectangle have unique x,y values in map space. The internal representation of the Envelope coclass assumes shared x,y values for the sides. As a result, the envelope returned by DisplayTransformation.FittedBounds is not what you want because a rectangular polygon is needed to accurately represent the client area in unrotated map space. Currently there's a bug that causes FittedBounds to return the same envelope that is returned when there is no rotation. When this is fixed, it should return a slightly expanded envelope as you expected. Most clients avoid using an envelope when there is rotation and implement code to find the rectangular polygon that matches a rectangle on the user's display. See the following code example:

inline void ToUnrotatedMap(const RECT & r, IGeometry * pBounds,
    IDisplayTransformation * pTransform){
    WKSPoint mapPoints[5];
    POINT rectCorners[4] = {
        {
            r.left, r.bottom
        }
        , {
            r.left, r.top
        }
        , {
            r.right, r.top
        }
        , {
            r.right, r.bottom
        }
    };
    pTransform -  > TransformCoords(mapPoints, rectCorners, 4, esriTransformToMap |
        esriTransformPosition);
    // Build polygon from mapPoints.
    mapPoints[4] = mapPoints[0];
    IPointCollectionPtr(pBounds) -  > SetWKSPoints(5, mapPoints);
    ITopologicalOperator2Ptr(pBounds) -  > put_IsKnownSimple(VARIANT_TRUE);
}

IArea area = (IArea)rotatedExtent;
IPoint center = area.getCentroid();
ITransform2D transform = (ITransform2D)rotatedExtent;
transform.rotate(center, 45);
IEnvelope newExtent = rotatedExtent.getEnvelope();

Refreshing versus invalidation

• One stop invalidation—To allow views (Map and PageLayout) to completely manage display caching, all invalidation must go through the view. Calling IActiveView.Refresh always draws everything and is very inefficient. The PartialRefresh method should be used whenever possible. It lets you specify what part of the view to redraw and allows the view to work with display caches that allows drawing to be quick and efficient. See the following table:
  

screenDisplay.invalidate(null, false, esriScreenCache.esriNoScreenCache)

Display events

Drawing order

• Map (data view)—The following Map class drawing order table shows top to bottom order; each item is drawn above the items below it:
  

• PageLayout—The following PageLayout class drawing order table shows top to bottom order; each item is drawn above the items below it:
  

Drawing events

• afterDraw(display, esriViewBackground)
• afterDraw(display, esriViewGeography)
• afterDraw(display, esriViewGeoSelection)
• afterDraw(display, esriViewGraphics)
• afterDraw(display, esriViewGraphicSelection)
• afterDraw(display, esriViewForeground)
• afterItemDraw(display, idx, esriDPGeography)
• afterItemDraw(display, idx, esriDPAnnotation)
• afterItemDraw(display, idx, esriDPSelection)

• Create an object that connects to the active view (map). For example, Events.
• Pick the draw phase that you want to draw after. The phase you pick determines what gets drawn above and below.
• Draw in response to IActiveViewEvents.afterDraw();
  

Enabling item events with VerboseEvents

Events and display caching

• Create the cache in response to IDocumentEvents.activeViewChanged. Map creates its caches in response to activate and discards all caches in response to deactivate. The activeViewChanged event is fired after map creates its caches. If there's not enough memory, the map gets its caches, but the private cache will not. See the following code example:

Dim pActiveView As IActiveView IActiveView activeView = map.getActiveView(); 
    //Map is MapBean.
Dim pScreen As IScreenDisplay IScreenDisplay screenDisplay =
    activeView.getScreenDisplay();
short cacheID = screenDisplay.addCache();

if (phase != esriViewDrawPhase.esriViewXXX)
    return ;
if (display != null){
    //Draw directly to the output device.    
    drawMyStuff(display);
    return ;
}

//Draw to the screen using cache, if possible.   
int windowHDC = display.getWindowDC();
boolean isDirty = display.isCacheDirty(myCacheID);
if (isDirty){
    //Draw from scratch.    
    display.finishDrawing();
    display.startDrawing(myCacheID, isDirty);
    drawMyStuff(display); //Map.cacheDraw handles finish drawing.   
}

else{
    //Draw from cache.    
    display.drawCache(windowHDC, myCacheID, null, null);
}

Transparency

Display Transparency

TransparencyDisplayFilter filter = new TransparencyDisplayFilter();
filter.setTransparency((short)100);
display.startDrawing(hDC, cacheID);
display.setFilterByRef(filter);
drawToDisplay();
display.setFilterByRef(null);
display.finishDrawing();

Symbol transparency

• Divide the display surface into bands so the in-memory bitmaps required to create transparent colors do not consume too much memory.
• Create a BackingDisplay the size of one band. A BackingDisplay has an internal device independent bitmap that has the same color depth and resolution as the output device. Drawing is directed to the bitmap. When drawing is finished, the bitmap is copied to the actual output device (or file). The layers and symbols treat this BackingDisplay like any other display (no special coding is required).
• For each band, adjust the display's transform to reference the current band and draw the view. The renderers automatically clip to the band since the transform's visible bounds equals the band rectangle.

Rapid display

• How to store the live data
• How to rapidly draw it to the display

Design patterns

• Create a feature class and add and remove features as necessary. Use standard renderers or custom symbols to draw features. Draw above or below any other layers. Wrap with the feature layer that has its own display cache for best performance (set ILayer.IsCached to true).
• Create a custom layer. Use a proprietary database or a feature class to store features. Implement custom rendering in layers (use GDI+ directly). Draw above or below any other layers. Give a feature layer its own display cache for best performance.
• Create a graphics layer. Store data as graphic elements. Render using a standard or custom symbol. Draws above all other layers.
• Draw in response to IActiveViewEvents.afterDraw(esriViewForeground). Store data in a proprietary database. Draw directly using GDI or IDisplay. Draw on top of everything else. GPS extension uses this approach.

• Features in a geodatabase
• Elements in a graphics layer
• Proprietary data structure
  

Annimation support

• Text anti-aliasing is temporarily disabled. This prevents labels from having to be redrawn every time the animation layer is invalidated. Remember that anti-aliased text uses the background as part of its rendering; normally when anything below it changes, the text also needs to draw from scratch.
• Transparent layers above the animation layer are not automatically invalidated along with the animation layer. This speeds up the redraw with the following limitation:
• Features in the animation layer will not show through the transparent layer above it.
• All drawing is directed to the recording cache HDC rather than the window. This causes all drawing to happen behind the scenes. When drawing is complete, the window is updated once from the completed recording cache. The result is less flashing.
• To avoid excessive CPU consumption during rapid drawing, you can make a call to UpdateWindow between invalidating old location and invalidating new location.

Display design patterns

Application window

Initialization

Private m_pScreenDisplay As IScreenDisplay ScreenDisplay screenDisplay = new
    ScreenDisplay();
SimpleFillSymbol symbol = new SimpleFillSymbol();
Envelope env = new Envelope();
env.putCoords(0, 0, 50, 50);
screenDisplay.getDisplayTransformation().setBounds(env);
screenDisplay.getDisplayTransformation().setVisibleBounds(env);

Drawing

public Polygon getPolygon(){
    try{
        Polygon polygon = new Polygon();
        Point point = new Point();
        point.putCoords(20, 20);
        polygon.addPoint(point, null, null);
        point.putCoords(30, 20);
        polygon.addPoint(point, null, null);
        point.putCoords(30, 20);
        polygon.addPoint(point, null, null);
        point.putCoords(20, 30);
        polygon.addPoint(point, null, null);
        polygon.close();
        return polygon;
    }
    catch (Exception e){
        e.printStackTrace();
        return null;
    }
}


public void myDraw(IDisplay display, int hDC){
    try{
        SimpleFillSymbol symbol = new SimpleFillSymbol();
        IDraw draw = (IDraw)display;
        draw.startDrawing(hDC, (short)esriScreenCache.esriNoScreenCache);
        Polygon polygon = getPolygon();
        draw.setSymbol(symbol);
        draw.draw(polygon);
        draw.finishDrawing();
    }
    catch (Exception e){
        e.printStackTrace();
    }
}

public void picturePaint(){
    myDraw(screenDisplay, Picture1.gethDC());
}

Adding display caching

public void picturePaint(){
    try{
        if (screenDisplay.isCacheDirty((short)esriScreenCache.esriScreenRecording)){
            screenDisplay.startRecording();
            myDraw(screenDisplay, Picture1.gethDC());
            screenDisplay.stopRecording();
        }
        else{
            screenDisplay.drawCache(Picture1.gethDC(),
                esriScreenCache.esriScreenRecording, null, null);
        }
    }
    catch (Exception e){
        e.printStackTrace();
    }
}

screenDisplay.invalidate(null, true, (short)esriScreenCache.esriScreenRecording);

• Add a new cache using IScreenDisplay.addCache. Save the cache ID that is returned.
• To draw to your cache, specify the cache ID to startDrawing.
• To invalidate your cache, specify the cache ID to invalidate.
• To draw from your cache, specify the cache ID to drawCache.

• Add a member attribute to hold the new cache. See the following code example:

int cacheID;

cacheID = screenDisplay.addCache();

Pan, zoom, and rotate

public void actionPerformed(java.awt.event.ActionEvent e){
    IEnvelope env = screenDisplay.getDisplayTransformation().getVisibleBounds();
    env.expand(0.75, 0.75, true);
    screenDisplay.getDisplayTransformation().setVisibleBounds(env);
    screenDisplay.invalidate(null, true, esriScreenCache.esriAllScreenCaches);

}

Printing

Output to a metafile

Print to a frame

Filters

RGB color model

• If all RGB values are equal, the color is a gray tone.
• If all RGB values are 0, the color is black (an absence of light).
• If all RGB values are 255, the color is white.

CMYK color model

HSV color model

• If value equals 0, the color is black.
• If saturation equals 0, the color is a shade of gray.
• If value equals 255 and saturation equals 0, the color is white.

HLS color model

CIELAB color model

public int getRGB(int red, int blue, int green){
    int RGB = red + (100 * green) + (10000 * blue);

    return RGB;
}

public int convertCMYKToInt(long black, long yellow, long magenta, long cyan){
    int value = black + (100 * yellow) + (10000 * magenta) + (1000000 * cyan);
    return value;

}

• Accessing the individual colors in a ramp
• Using the ramp object directly as a property or in a method of another object.

RandomColorRamp colorRamp = new RandomColorRamp();
colorRamp.setSize(10);
boolean[] state = new boolean[1];
colorRamp.createRamp(state);
if (state[0]){
    for (int i = 0; i < colorRamp.getSize(); i++){
        //Access the color array and set the colors
        //for an array of synbols or map layers.
    }
}

AlgorithmicColorRamp algoRamp = new AlgorithmicColorRamp();
algoRamp.setFromColor(myFromColor);
algoRamp.setToColor(myToColor);
GradientFillSymbol symbol = new GradientFillSymbol();
symbol.setColorRamp(algoRamp);
symbol.setIntervalCount(5);

• Marker symbols
• Line symbols
• Fill symbols

• Call startDrawing on the display before using the Draw method, as this sets up the display's device context. Call finishDrawing on the display after you have finished.
• Call resetDC after you finish drawing with a symbol, which restores the device context to its original state.

screenDisplay.startDrawing(screenDisplay.getHDC(), (short)
    esriScreenCache.esriNoScreenCache);
symbol.setupDC(screenDisplay.getHDC(), screenDisplay.getDisplayTransformation());
symbol.draw(point);
symbol.resetDC();
screenDisplay.finishDrawing();

Symbol level drawing

Using symbol level drawing

• Turn on symbol level drawing for a layer using ISymbolLevels.useSymbolLevels, or for your entire map using IMap.setUseSymbolLevels.
• For each layer in your map that you want to use symbol levels, access the layer's renderer using IGeoFeatureLayer.getRenderer.
• Access your layer's symbols through the renderer.
• Using IMapLevel, set symbol levels on your layer's symbols. Symbols with MapLevel = 0 draw first, then symbols with MapLevel = 1, continuing until the highest MapLevel is reached. If two symbols have the same MapLevel, the features drawn with these symbols are drawn in the normal layer order. A MapLevel of –1 for a multilayer symbol (MultiLayerMarkerSymbol, MultiLayerLineSymbol, MultiLayerFillSymbol) indicates that each of the symbol's individual layers are drawn with their individual MapLevel.

Join and merge

//...
if (map.getLayer(0)instanceof IGeoFeatureLayer){
    IGeoFeatureLayer layer = (IGeoFeatureLayer)map.getLayer(0);
    ISymbolLevels levels = (ISymbolLevels)layer;
    levels.setUseSymbolLevels(true);
    if (renderer.getSymbol()instanceof IMultiLayerLineSymbol){
        IMultiLayerLineSymbol multi = (IMultiLayerLineSymbol)renderer.getSymbol();
        setMapLevel((IMapLevel)multi,  - 1);
        for (int i = 0; i < multi.getLayerCount(); i++)
            setMapLevel((IMapLevel)multi.getLayer(i), multi.getLayerCount() - (i + 1)
                );
    }
}

//...


public void setMapLevel(IMapLevel level, int i){
    if (level != null){
        try{
            level.setMapLevel(i);
        }
        catch (Exception e){
            e.printStackTrace();
        }
    }
}

Marker symbols

ArrowMarkerSymbol arrow = new ArrowMarkerSymbol();
arrow.setAngle(60);
arrow.setSize(50);
arrow.setXOffset(20);
arrow.setYOffset(30);
arrow.setColor(myColor)

Simple marker symbols
Arrow marker symbols
Character marker symbols
Picture marker symbols
Multilayer marker symbols

Line symbols

 

Fill symbols

Text symbols

StdFont font = new StdFont();
font.setName("ESRI Cartography");
font.setBold(true);

double[] x = {
    0
};
double[] y = {
    0
};
screenDisplay.startDrawing(0, (short)esriScreenCache.esriNoScreenCache);
textSymbol.getTextSize(display.getHDC(), display.getDisplayTransformation(), 
    "My Text", x, y);
screenDisplay.finishDrawing();

Chart symbols

BarChartSymbol symbol = new BarChartSymbol();
symbol.setMaxValue(10);

• Feedbacks that return a new geometry—The interfaces for these objects have a Stop method that returns the new geometry. These objects are NewEnvelopeFeedback, NewBezierCurveFeedback, NewDimensionFeedback, NewLineFeedback, NewPolygonFeedback, MoveEnvelopeFeedback, MoveLineFeedback, MovePointFeedback, MovePolygonFeedback, BezierMovePointFeedback, LineMovePointFeedback, PolygonMovePointFeedback, ReshapeFeedback, ResizeEnvelopeFeedback, and StretchLineFeedback.
• Feedbacks for display purposes only—The developer is required to calculate the new geometry, for example, use the start and end mouse locations and calculate the delta x and delta y shifts, then update or create the geometry. These feedback objects are MoveGeometryFeedback, MoveImageFeedback, NewMultiPointFeedback, and VertexFeedback.

public void refresh(int hDC){
    If(polygonFeedback != null)polyFeedback.refresh(hDC)
}

INewEnvelopeFeedback newEnvFeed;

NewEnvelopeFeedback newEnvFeed = new NewEnvelopeFeedback();
newEnvFeed.setDisplayByRef(screenDisplay);
newEnvFeed.setSymbolByRef(ineSym);
newEnvFeed.start(startPoint);

newEnvFeed.moveTo(movePoint);

env = newEnvFeed.stop();

• RubberCircle—ICircularArc
• RubberEnvelope—IEnvelope
• RubberLine—IPolyline
• RubberPoint—IPoint
• RubberPolygon—IPolygon
  RubberRectangularPolygon—IPolygon

public void onMouseDown(int button, int shift, int x, int y){
    super.onMouseDown(button, shift, x, y);
    try{
        IMap map = hookHelper.getFocusMap();
        //Create new RubberLine.   
        RubberLine rubberLine = new RubberLine();
        //Track a new polyline on current document's display using default symbol.   
        IGeometry geom = rubberLine.trackNew(hookHelper.getActiveView()
            .getScreenDisplay(), null);
    }
    catch (Exception e){
        e.printStackTrace();
    }
}

• Envelope tracker—Allows the user to move and resize the element. This functionality is implemented by the EnvelopeTracker object for all element types, including point, line, polygon, and group elements.
• Vertex edit tracker—Allows the user to move vertices of lines, polygons, curves, and curved text. This functionality is implemented by the LineTracker and PolygonTracker objects.
• Callout tracker—Allows the user to move a text callout. This functionality is implemented by the CalloutTracker objects.

public void ensureEnvelopeTracker(IActiveView activeView, IElement element){
    try{
        IScreenDisplay display = activeView.getScreenDisplay();
        if (element instanceof IElementEditVertices){
            IElementEditVertices editVertices = (IElementEditVertices)element;
            if (editVertices.isMovingVertices()){
                editVertices.setMovingVertices(false);
                activeView.partialRefresh(esriViewDrawPhase.esriViewGeography, null,
                    element.getSelectionTracker().getBounds(display));
            }
        }
    }
    catch (Exception e){
        e.printStackTrace();
    }
}

• The Esc key is pressed.
• The space bar is pressed (disable with CancelOnKeyPress property).
• The left mouse button is clicked (disable with CancelOnClick property).
• The right mouse button is clicked (disable with CancelOnClick property).
  

CancelTracker cancel = new CancelTracker();
activeView.output < OLE_handle > ,  < screen resolution > ,  < pixel bounds > ,  <
    visible bounds > , pCancel

public void testCancel(IEnumFeature enumFeats, CancelTracker cancel){
    try{
        IFeature feature = enumFeats.next();
        while (feature != null){
            if (feature instanceof INetworkFeature)
                ((INetworkFeature)feature).connect();
            if (!cancel.esri_continue()){
                JOptionPane.showConfirmDialog(null, "Process has been cancelled!");
            }
            feature = enumFeats.next();
        }
    }
    catch (Exception e){
        e.printStackTrace();
    }
}