//Get the current active TOC content type for the map view 
  var mapTOCContentType = MapView.Active.CurrentMapTOCContent;

//Get the current active TOC content type for the map view 
  var mapTOCContentType = (int)MapView.Active.CurrentMapTOCContent;
  //increment to the next tab whatever it is
  mapTOCContentType++;
  //Can we set this type on the TOC?
  if (MapView.Active.CanSetMapTOCContent((MapTOCContentType)mapTOCContentType))
    //Set it - must be on the UI! - No QueuedTask
    MapView.Active.SetMapTOCContentAsync((MapTOCContentType)mapTOCContentType);
  else
  {
    mapTOCContentType = (int)MapTOCContentType.DrawingOrder;
    //Set it - must be on the UI! - No QueuedTask
    MapView.Active.SetMapTOCContentAsync((MapTOCContentType)mapTOCContentType);
  }

string mapPaneCaption = "USNationalParks";
  IMapPane mapViewPane = FrameworkApplication.Panes.OfType<IMapPane>().FirstOrDefault((p) => p.Caption == mapPaneCaption);
  mapView = null;
  if (mapViewPane != null)
  {
    // activate the MapPane
    (mapViewPane as Pane).Activate();

    if (mapView != null)
    {
      // get the layers selected in the map's TOC
      var selectedLayers = mapView.GetSelectedLayers();
    }
  }

//Determine whether the viewing mode is SceneLocal or SceneGlobal
  var result = mapView.ViewingMode == MapViewingMode.SceneLocal ||
               mapView.ViewingMode == MapViewingMode.SceneGlobal;

  // Use the result variable as needed

//Check if the view can be set to SceneLocal and if it can set it.
  var result = mapView.CanSetViewingMode(MapViewingMode.SceneLocal);
  if (result)
    mapView.SetViewingModeAsync(MapViewingMode.SceneLocal);

//Set the view linking mode to Center and Scale.
  MapView.LinkMode = LinkMode.Center | LinkMode.Scale;

// Validate the current active view. Only a local scene can be exported.
  bool CanExportScene3DObjects = MapView.Active?.ViewingMode == MapViewingMode.SceneLocal;
  if (CanExportScene3DObjects)
  {
    // Create a scene content export format, export the scene context as a glTF file
    var exportFormat = new ExportSceneContentsFormat()
    {
      Extent = mapView.Extent, // sets Extent property
      FolderPath = @"C:\Temp", // sets FolderPath property
                               //sets FileName property.The export format is determined by the output file extension (e.g.,.stl, .gltf)
      FileName = "my-3d-objects.gltf",
      IsSingleFileOutput = true, // sets whether to export to one single file
      SaveTextures = true //sets whether to save textures
    };
    // Export the scene content as 3D objects
    mapView.ExportScene3DObjects(exportFormat);
  }

//Zoom to the selected layers in the TOC
  if (mapView.HasPreviousCamera())
    mapView.PreviousCameraAsync();

//Zoom to the selected layers in the TOC
  if (mapView.HasNextCamera())
    mapView.NextCameraAsync();

// Note: Needs QueuedTask to run
  {
    //Zoom to the map's full extent
    mapView.ZoomToFullExtent();
  }

//Zoom to the map's full extent
  mapView.ZoomToFullExtentAsync(TimeSpan.FromSeconds(2));

// Note: Needs QueuedTask to run
  {
    //Zoom in the map view by a fixed amount.
    mapView.ZoomInFixed();
  }

//Zoom in the map view by a fixed amount.
  mapView.ZoomInFixedAsync();

// Note: Needs QueuedTask to run
  {
    //Zoom out in the map view by a fixed amount.
    mapView.ZoomOutFixed();
  }

//Zoom in the map view by a fixed amount.
  mapView.ZoomOutFixedAsync();

envelope = EnvelopeBuilderEx.CreateEnvelope(xMin, yMin, xMax, yMax, spatialReference);

  //Zoom the view to a given extent.
  mapView.ZoomToAsync(envelope, TimeSpan.FromSeconds(2));

// Note: Needs QueuedTask to run
  {
    //Create a point
    var pt = MapPointBuilderEx.CreateMapPoint(x, y, spatialReference);
    //Buffer it - for purpose of zoom
    var poly = GeometryEngine.Instance.Buffer(pt, buffer_size);

    //do we need to project the buffer polygon?
    if (!MapView.Active.Map.SpatialReference.IsEqual(poly.SpatialReference))
    {
      //project the polygon
      poly = GeometryEngine.Instance.Project(poly, MapView.Active.Map.SpatialReference);
    }

    //Zoom - add in a delay for animation effect
    mapView.ZoomTo(poly, new TimeSpan(0, 0, 0, 3));
  }

// Note: Needs QueuedTask to run
  {
    //Zoom to the map's selected features.
    mapView.ZoomToSelected(TimeSpan.FromSeconds(3));
  }

//Zoom to the map's selected features.
  mapView.ZoomToSelectedAsync(TimeSpan.FromSeconds(2));

// Note: Needs QueuedTask to run
  {
    //Get the first bookmark with the given name.
    var bookmark = mapView.Map.GetBookmarks().FirstOrDefault(b => b.Name == bookmarkName);
    if (bookmark == null)
    {
      // Manage the error - bookmark not found
    }

    //Zoom the view to the bookmark.
    mapView.ZoomTo(bookmark);
  }

// Note: Needs QueuedTask to run
  //Get the first bookmark with the given name.
  var bookmark = mapView.Map.GetBookmarks().FirstOrDefault(b => b.Name == bookmarkName);
  if (bookmark == null)
  {
    // Manage the error - bookmark not found
  }

  //Zoom the view to the bookmark.
  mapView.ZoomToAsync(bookmark, TimeSpan.FromSeconds(2));

// Note: Needs QueuedTask to run
  {
    //Zoom to all visible layers in the map.
    var visibleLayers = mapView.Map.Layers.Where(l => l.IsVisible);
    mapView.ZoomTo(visibleLayers);
  }

//Zoom to the selected layers in the TOC
  var selectedLayers = mapView.GetSelectedLayers();
  mapView.ZoomToAsync(selectedLayers);

using var rowCursor = featureLayer.Search();
  var objectIds = new List<long>();
  while (rowCursor.MoveNext())
  {
    using var feature = rowCursor.Current as Feature;
    objectIds.Add(feature.GetObjectID());
  }
  if (objectIds.Count > 0)
  {
    MapView.Active.ZoomTo(featureLayer, objectIds, TimeSpan.FromSeconds(2));
  }

// Note: Needs QueuedTask to run
  {
    //Pan the view to a given extent.
    envelope = EnvelopeBuilderEx.CreateEnvelope(xMin, yMin, xMax, yMax, spatialReference);
    mapView.PanTo(envelope);
  }

//Create the envelope
  envelope = EnvelopeBuilderEx.CreateEnvelope(xMin, yMin, xMax, yMax, spatialReference);

  //Pan the view to a given extent.
  mapView.PanToAsync(envelope, TimeSpan.FromSeconds(2));

// Note: Needs QueuedTask to run
  {
    //Pan to the map's selected features.
    mapView.PanToSelected();
  }

//Pan to the map's selected features.
  mapView.PanToSelectedAsync(TimeSpan.FromSeconds(2));

//Note: Needs QueuedTask to run
  {
    //Get the first bookmark with the given name.
    var bookmark = mapView.Map.GetBookmarks().FirstOrDefault(b => b.Name == bookmarkName);
    if (bookmark == null)
    {
      // Manage the error - bookmark not found
    }

    //Pan the view to the bookmark.
    mapView.PanTo(bookmark);
  }

//Get the first bookmark with the given name.
  var bookmark = mapView.Map.GetBookmarks().FirstOrDefault(b => b.Name == bookmarkName);
  if (bookmark == null)
  {
    // Manage the error - bookmark not found
  }

  //Pan the view to the bookmark.
  mapView.PanToAsync(bookmark, TimeSpan.FromSeconds(2));

// Note: Needs QueuedTask to run
  {
    //Pan to all visible layers in the map.
    var visibleLayers = mapView.Map.Layers.Where(l => l.IsVisible);
    mapView.PanTo(visibleLayers);
  }

//Pan to the selected layers in the TOC
  var selectedLayers = mapView.GetSelectedLayers();
  mapView.PanToAsync(selectedLayers);

//Get the camera for the view, adjust the heading and zoom to the new camera position.
  camera = mapView.Camera;
  camera.Heading = heading;
  await mapView.ZoomToAsync(camera, TimeSpan.Zero);
  //Or synchronously
  mapView.ZoomTo(camera, TimeSpan.Zero);

//Note: Needs QueuedTask to run
  {
    //Expand the current extent by the given ratio.
    var extent = mapView.Extent;
    var newExtent = GeometryEngine.Instance.Expand(extent, dx, dy, true);
    mapView.ZoomTo(newExtent);
  }

//Return the name of the map currently displayed in the active map view.
  var result = mapView.Map.Name;
  // Use the result variable as needed

// Note: Needs QueuedTask to run
  {
    MapView.Active.Map?.SetSelection(null);
  }

//Selection tolerance for the map in pixels
  var selectionTolerance = SelectionEnvironment.SelectionTolerance;
  // Note: Needs QueuedTask to run
  {
    //Get the map center
    var mapExtent = MapView.Active.Map.GetDefaultExtent();
    var mapPoint = mapExtent.Center;
    //Map center as screen point
    var screenPoint = MapView.Active.MapToScreen(mapPoint);
    //Add selection tolerance pixels to get a "radius".
    var radiusScreenPoint = new System.Windows.Point(screenPoint.X + selectionTolerance, screenPoint.Y);
    var radiusMapPoint = MapView.Active.ScreenToMap(radiusScreenPoint);
    //Calculate the selection tolerance distance in map units.
    var searchRadius = GeometryEngine.Instance.Distance(mapPoint, radiusMapPoint);
  }

//Create a Progress Bar user control
  System.Windows.Controls.ProgressBar progressBarControl = new()
  {
    //Configure the progress bar
    Minimum = 0,
    Maximum = 100,
    IsIndeterminate = true,
    Width = 300,
    Value = 10,
    Height = 25,
    Visibility = System.Windows.Visibility.Visible
  };
  //Create a MapViewOverlayControl. 
  var mapViewOverlayControl = new MapViewOverlayControl(progressBarControl, true, true, true, OverlayControlRelativePosition.BottomCenter, .5, .8);
  //Add to the active map
  MapView.Active.AddOverlayControl(mapViewOverlayControl);
  // Note: Needs QueuedTask to run
  {
    //Wait 3 seconds to remove the progress bar from the map.
    Thread.Sleep(3000);
  }
  //Remove from active map
  MapView.Active.RemoveOverlayControl(mapViewOverlayControl);

//Zoom to the selected layers in the TOC
  var featureLayers = mapView.Map.Layers.OfType<FeatureLayer>();
  mapView.SelectLayers(featureLayers.ToList());

// Note: Needs QueuedTask to run
  {
    //Get the selected features from the map and filter out the standalone table selection.
    var selectedFeatures = mapView.Map.GetSelection();

    //Flash the collection of features.
    mapView.FlashFeature(selectedFeatures);
  }

if (layer == null)
  {
    // no layers in the map, leave
  }
  if (mapView == null)
  {
    // no active map view, leave
  }
  bool isLayerVisibleInView = layer.IsVisibleInView(mapView);
  if (isLayerVisibleInView)
  {
    //Do Something
  }

// select it in the TOC
  List<Layer> layersToSelect = [featureLayer];
  MapView.Active.SelectLayers(layersToSelect);

  // now execute the layer properties command
  var wrapper = FrameworkApplication.GetPlugInWrapper("esri_mapping_selectedLayerPropertiesButton");
  var command = wrapper as ICommand;
  if (command == null)
  {
    // the command is not found, leave
  }

  // execute the command
  if (command.CanExecute(null))
    command.Execute(null);

if (featureLayer != null)
  {
    // Note: Needs QueuedTask to run
    {
      featureLayer.ClearSelection();
    }
  }

mapMember = MapView.Active.Map.GetLayersAsFlattenedList().OfType<MapMember>().FirstOrDefault();
  //Gets or creates the CIMMapTableView for a MapMember.
  var mapTableView = FrameworkApplication.Panes.GetMapTableView(mapMember);
  //Configure the table view
  mapTableView.DisplaySubtypeDomainDescriptions = false;
  mapTableView.SelectionMode = false;
  mapTableView.ShowOnlyContingentValueFields = true;
  mapTableView.HighlightInvalidContingentValueFields = true;
  //Open the table pane using the configured tableView. If a table pane is already open it will be activated.
  //You must be on the UI thread to call this function.
  var tablePane = FrameworkApplication.Panes.OpenTablePane(mapTableView);

// change to "selected record" mode
  tableView.SetViewMode(TableViewMode.eSelectedRecords);

// change zoom level
  if (tableView.ZoomLevel > zoomLevel)
    tableView.SetZoomLevel(zoomLevel);
  else
    tableView.SetZoomLevel(zoomLevel * 2);

// set the value
  tableView.ShowFieldAlias = true;

  // OR toggle it
  if (tableView.CanToggleFieldAlias)
    tableView.ToggleFieldAlias();

// set the value
  tableView.ShowSubtypeDomainDescriptions = true;

  // OR toggle it
  if (tableView.CanToggleSubtypeDomainDescriptions)
    tableView.ToggleSubtypeDomainDescriptionsAsync();

// get the active row index
  int rowIndex = tableView.ActiveRowIndex;

// get the active row index
  int rowIndex = tableView.ActiveRowIndex;

  // move to a different row
  var newIndex = 10 + rowIndex;
  tableView.BringIntoView(newIndex);

// get the active objectID
  long? OID = tableView.ActiveObjectId;

// get the active row index
  int rowIndex = tableView.ActiveRowIndex;
  // increase
  int newIndex = rowIndex + 10;
  // get the objectID
  long newOID = tableView.GetObjectIdAsync(newIndex).Result;

  // get the rowIndex for a specific objectID
  //   2nd parameter indicates if the search only occurs for the pages loaded
  //   if pass false, then in the worst case, a full table scan will occur to 
  //    find the objectID.
  long OID = 100;
  var idx = tableView.GetRowIndexAsync(OID, true);

// Note: Needs QueuedTask to run
  {
    // get the set of selected objectIDs 
    var selOids = tableView.GetSelectedObjectIds();
    // get the set of selected row indexes
    var selRows = tableView.GetSelectedRowIndexes();
  }

// Note: Needs QueuedTask to run
  {
    // set of selected OIDS
    var newoids = new List<long>();
    newoids.AddRange([10, 15, 17]);
    tableView.Select(newoids, true);

    // add to set of selected row indexes
    var selRows = tableView.GetSelectedRowIndexes();
    var newRows = new List<long>(selRows);
    newRows.AddRange([21, 35]);
    tableView.Select(newRows, false);
  }

if (tableView.CanSelectAll)
    tableView.SelectAll();

// toggle the active rows selection
  if (tableView.CanToggleRowSelection)
    tableView.ToggleRowSelection();

  // switch the selection
  if (tableView.CanSwitchSelection)
    tableView.SwitchSelection();

  // clear the selection
  if (tableView.CanClearSelection)
    tableView.ClearSelection();

if (tableView.CanZoomToSelected)
    tableView.ZoomToSelected();

  if (tableView.CanPanToSelected)
    tableView.PanToSelected();

if (tableView.CanDeleteSelected)
    tableView.DeleteSelected();

// Note: Needs QueuedTask to run
  {
    IReadOnlyList<long> highlightedOIDs = null;
    if (tableView.CanGetHighlightedObjectIds)
      // get the set of selected objectIDs 
      highlightedOIDs = tableView.GetHighlightedObjectIds();
  }

// Note: Needs QueuedTask to run
  {
    // get list of current selected objectIDs
    IReadOnlyList<long> selectedObjectIds = tableView.GetSelectedObjectIds();
    List<long> idsToHighlight = [];

    // add the first two selected objectIds to highlight
    if (selectedObjectIds.Count >= 2)
    {
      idsToHighlight.Add(selectedObjectIds[0]);
      idsToHighlight.Add(selectedObjectIds[1]);
    }

    // highlight
    if (tableView.CanHighlight)
      tableView.Highlight(idsToHighlight, true);
  }

// toggle the active rows selection
  if (tableView.CanToggleRowHighlight)
    tableView.ToggleRowHighlight();

  // switch highlighted rows
  if (tableView.CanSwitchHighlight)
    tableView.SwitchHighlight();

  // clear the highlights
  if (tableView.CanClearHighlighted)
    tableView.ClearHighlighted();

if (tableView.CanZoomToHighlighted)
    tableView.ZoomToHighlighted();

  if (tableView.CanPanToHighlighted)
    tableView.PanToHighlighted();

if (tableView.CanDeleteHighlighted)
    tableView.DeleteHighlighted();

// field access
  var flds = tableView.GetFields();
  var fldIdx = tableView.GetFieldIndex("STATE_NAME");
  var fldDesc = tableView.GetField(fldIdx);

// get active field, active field name
  var activeFieldIdx = tableView.ActiveFieldIndex;
  var fldDesc = tableView.GetField(activeFieldIdx);
  var fldName = fldDesc.Name;

  // set active field by name
  tableView.SetActiveField("STATE_NAME");

  // or set active field by index
  tableView.SetActiveField(3);

// get selected fields
  var selectedfields = tableView.GetSelectedFields();

  // set selected fields
  tableView.SetSelectedFields(["CITY_FIPS", "STATE_FIPS"]);

if (tableView.CanResetFieldOrder)
  {
    tableView.ResetFieldOrder();

    List<string> fldOrder =
    [
      "STATE_NAME",
      "STATE_FIPS"
    ];
    tableView.SetFieldOrderAsync(fldOrder);
  }

// get list of hidden fields
  var hiddenFields = tableView.GetHiddenFields();

  // show all fields
  if (tableView.CanShowAllFields)
    tableView.ShowAllFields();

  // hide only "CITY_FIPS", "STATE_FIPS"
  if (tableView.CanShowAllFields)
  {
    // show all fields
    tableView.ShowAllFields();
    tableView.SetHiddenFields(["CITY_FIPS", "STATE_FIPS"]);
  }

  // add "STATE_NAME to set of hidden fields
  tableView.SetHiddenFields(["STATE_NAME"]);

  // hide selected fields
  if (tableView.CanHideSelectedFields)
    tableView.HideSelectedFields();

// get list of frozen fields
  var frozenfields = tableView.GetFrozenFields();

  // unfreeze all fields
  tableView.ClearAllFrozenFieldsAsync();

  // freeze a set of fields
  tableView.SetFrozenFieldsAsync(["CITY_FIPS", "STATE_FIPS"]);

// sort the active field descending
  if (tableView.CanSortDescending)
    tableView.SortDescending();

  // sort the active field ascending
  if (tableView.CanSortAscending)
    tableView.SortAscending();

  // perform a custom sort programmatically
  if (tableView.CanCustomSort)
  {
    // sort fields
    Dictionary<string, FieldSortInfo> dict = new()
    {
      { "STATE_NAME", FieldSortInfo.Asc },
      { "CITY_NAME", FieldSortInfo.Desc }
    };
    tableView.SortAsync(dict);
  }

  // perform a custom sort via the UI
  if (tableView.CanCustomSort)
    tableView.CustomSort();

// launch the find UI
  if (tableView.CanFind)
    tableView.Find();

  // or launch the find and replace UI
  if (tableView.CanFindAndReplace)
    tableView.FindAndReplace();

// launch the GoTo UI
  if (tableView.CanGoTo)
    tableView.GoTo();

// refresh
  if (tableView.CanRefresh)
    tableView.Refresh();

// find all the table panes (table panes hosting map data)
  var tablePanes = FrameworkApplication.Panes.OfType<ITablePane>();
  var tablePane = tablePanes.FirstOrDefault(p => p is ITablePaneEx { Caption: "oldCaption" });
  if (tablePane is ITablePaneEx tablePaneEx)
    tablePaneEx.Caption = "newCaption";

  // find all the external table panes (table panes hosting external data)
  var externalPanes = FrameworkApplication.Panes.OfType<IExternalTablePane>();
  var externalTablePane = externalPanes.FirstOrDefault(p => p.Caption == "oldCaption");
  if (externalTablePane != null)
    externalTablePane.Caption = "newCaption";

// find all the table panes (table panes hosting map data)
  var tablePanes = FrameworkApplication.Panes.OfType<ITablePane>();
  var tablePane = tablePanes.FirstOrDefault(p => p is ITablePaneEx { Caption: "caption" });
  if (tablePane is ITablePaneEx tablePaneEx)
    tableView = tablePaneEx.TableView;

  // if it's not found, maybe it's an external table pane
  if (tableView == null)
  {
    // find all the external table panes (table panes hosting external data)
    var externalPanes = FrameworkApplication.Panes.OfType<IExternalTablePane>();
    var externalTablePane = externalPanes.FirstOrDefault(p => p.Caption == "caption");
    if (externalTablePane != null)
      tableView = externalTablePane.TableView;
  }

// Note: Needs QueuedTask to run
  {
    //Get the layer to be masked
    var lineLyrToBeMasked = MapView.Active.Map.Layers.FirstOrDefault(lyr => lyr.Name == "TestLine") as FeatureLayer;
    //Get the layer's definition
    var lyrDefn = lineLyrToBeMasked.GetDefinition();
    //Create an array of Masking layers (polygon only)
    //Set the LayerMasks property of the Masked layer
    lyrDefn.LayerMasks = ["CIMPATH=map3/testpoly.xml"];
    //Re-set the Masked layer's definition
    lineLyrToBeMasked.SetDefinition(lyrDefn);
  }

// Note: Needs QueuedTask to run
  {
    //Adding a new bookmark using the active view.
    mapView.Map.AddBookmark(mapView, bookmarkName);
  }

// Note: Needs QueuedTask to run
  {
    //Set properties for Camera
    CIMViewCamera cimCamera = new()
    {
      X = camera.X,
      Y = camera.Y,
      Z = camera.Z,
      Scale = camera.Scale,
      Pitch = camera.Pitch,
      Heading = camera.Heading,
      Roll = camera.Roll
    };

    //Create new CIM bookmark and populate its properties
    var cimBookmark = new CIMBookmark() { Camera = cimCamera, Name = cameraName, ThumbnailImagePath = "" };

    //Add a new bookmark for the active map.
    mapView.Map.AddBookmark(cimBookmark);
  }

//Get the collection of bookmarks for the project.
  var result = Project.Current.GetBookmarks();
  // Use the bookmarks (if any)

// Note: Needs QueuedTask to run
  {
    //Return the collection of bookmarks for the map.
    var result = mapView.Map.GetBookmarks();
    // Use the bookmarks (if any)
  }

// Note: Needs QueuedTask to run
  {
    var map = mapView.Map;
    //Find the first bookmark with the name
    var bookmark = map.GetBookmarks().FirstOrDefault(b => b.Name == bookmarkName);
    if (bookmark == null)
    {
      //Bookmark not found
    }

    //Move the bookmark to the top of the list
    map.MoveBookmark(bookmark, 0);
  }

oldBookmark = mapView.Map.GetBookmarks().FirstOrDefault(b => b.Name == bookmarkName);
  oldBookmark.Rename(newBookmarkName);

// Note: Needs QueuedTask to run
  {
    //Find the first bookmark with the name
    var bookmark = mapView.Map.GetBookmarks().FirstOrDefault(b => b.Name == bookmarkName);
    if (bookmark == null)
    {
      //Bookmark not found
    }

    //Remove the bookmark
    mapView.Map.RemoveBookmark(bookmark);
  }

//Set the thumbnail to an image on disk, i.e. C:\Pictures\MyPicture.png.
  BitmapImage image = new(new Uri(imagePath, UriKind.RelativeOrAbsolute));
  oldBookmark.SetThumbnail(image);

// Note: Needs QueuedTask to run
  {
    //Update the bookmark using the active map view.
    oldBookmark.Update(mapView);
  }

// Note : Needs QueuedTask to run
  {
    //Get the bookmark's definition
    var bookmarkDef = oldBookmark.GetDefinition();

    //Modify the bookmark's location
    bookmarkDef.Location = envelope;

    //Clear the camera as it is no longer valid.
    bookmarkDef.Camera = null;

    //Set the bookmark definition
    oldBookmark.SetDefinition(bookmarkDef);
  }

//Step current map time forward by 1 month
  TimeDelta timeDelta = new(1, TimeUnit.Months);
  mapView.Time = mapView.Time.Offset(timeDelta);

MapView.Active.Time.Start = null;
  MapView.Active.Time.End = null;

var animation = mapView.Map.Animation;
  var duration = animation.Duration;
  if (duration == TimeSpan.Zero)
    return;

  var factor = length.TotalSeconds / duration.TotalSeconds;
  animation.ScaleDuration(factor);

var animation = mapView.Map.Animation;
  var duration = animation.Duration;
  if (duration == TimeSpan.Zero || duration <= afterTime)
  {
    // Nothing to scale, leave
  }

  var factor = length.TotalSeconds / (duration.TotalSeconds - afterTime.TotalSeconds);
  animation.ScaleDuration(afterTime, duration, factor);

var animation = mapView.Map.Animation;
  var cameraTrack = animation.Tracks.OfType<CameraTrack>().First(); //There will always be only 1 CameraTrack in the animation.
  var result = cameraTrack.Keyframes.OfType<CameraKeyframe>().ToList();
  //Use the camera keyframes (if any)

//Return the collection representing the camera for each frame in animation.
  // Note: Needs QueuedTask to run
  {
    var animation = mapView.Map.Animation;

    var cameras = new List<Camera>();
    //We will use ticks here rather than milliseconds to get the highest precision possible.
    var ticksPerFrame = Convert.ToInt64(animation.Duration.Ticks / (animation.NumberOfFrames - 1));
    for (int i = 0; i < animation.NumberOfFrames; i++)
    {
      var time = TimeSpan.FromTicks(i * ticksPerFrame);
      //Because of rounding for ticks the last calculated time may be greater than the duration.
      if (time > animation.Duration)
        time = animation.Duration;
      cameras.Add(mapView.Animation.GetCameraAtTime(time));
    }
    // Use cameras
  }

//Return the collection representing the map time for each frame in animation.
  // Note: Needs QueuedTask to run
  {
    var animation = mapView.Map.Animation;

    var timeRanges = new List<TimeRange>();
    //We will use ticks here rather than milliseconds to get the highest precision possible.
    var ticksPerFrame = Convert.ToInt64(animation.Duration.Ticks / (animation.NumberOfFrames - 1));
    for (int i = 0; i < animation.NumberOfFrames; i++)
    {
      var time = TimeSpan.FromTicks(i * ticksPerFrame);
      //Because of rounding for ticks the last calculated time may be greater than the duration.
      if (time > animation.Duration)
        time = animation.Duration;
      timeRanges.Add(mapView.Animation.GetCurrentTimeAtTime(time));
    }
    // Use timeRanges;
  }

//Return the collection representing the map time for each frame in animation.
  // Note: Needs QueuedTask to run
  {
    var animation = mapView.Map.Animation;

    var ranges = new List<ArcGIS.Desktop.Mapping.Range>();
    //We will use ticks here rather than milliseconds to get the highest precision possible.
    var ticksPerFrame = Convert.ToInt64(animation.Duration.Ticks / (animation.NumberOfFrames - 1));
    for (int i = 0; i < animation.NumberOfFrames; i++)
    {
      var time = TimeSpan.FromTicks(i * ticksPerFrame);
      //Because of rounding for ticks the last calculated time may be greeting than the duration.
      if (time > animation.Duration)
        time = animation.Duration;
      ranges.Add(mapView.Animation.GetCurrentRangeAtTime(time));
    }
    // Use ranges
  }

var animation = mapView.Map.Animation;
  var cameraTrack = animation.Tracks.OfType<CameraTrack>().First(); //There will always be only 1 CameraTrack in the animation.
  cameraTrack.CreateKeyframe(mapView.Camera, atTime, AnimationTransition.FixedArc);

var animation = mapView.Map.Animation;
  var timeTrack = animation.Tracks.OfType<TimeTrack>().First(); //There will always be only 1 TimeTrack in the animation.
  timeTrack.CreateKeyframe(mapView.Time, atTime, AnimationTransition.Linear);

var animation = mapView.Map.Animation;
  var rangeTrack = animation.Tracks.OfType<RangeTrack>().First(); //There will always be only 1 RangeTrack in the animation.
  rangeTrack.CreateKeyframe(range, atTime, AnimationTransition.Linear);

var animation = mapView.Map.Animation;
  var layerTrack = animation.Tracks.OfType<LayerTrack>().First(); //There will always be only 1 LayerTrack in the animation.
  layerTrack.CreateKeyframe(layer, atTime, true, transparency, AnimationTransition.Linear);

// get the current MapView and point
  var myextent = mapView.Extent;
  var point = myextent.Center;
  IDisposable _graphic = null;

  // add point graphic to the overlay at the center of the mapView
  // Note: Needs QueuedTask to run
  _graphic = mapView.AddOverlay(point,
      SymbolFactory.Instance.ConstructPointSymbol(
              ColorFactory.Instance.RedRGB, 30.0, SimpleMarkerStyle.Star).MakeSymbolReference());

  // update the overlay with new point graphic symbol
  MessageBox.Show("Now to update the overlay...");
  // Note: Needs QueuedTask to run
  {
    mapView.UpdateOverlay(_graphic, point, SymbolFactory.Instance.ConstructPointSymbol(
                                  ColorFactory.Instance.BlueRGB, 20.0, SimpleMarkerStyle.Circle).MakeSymbolReference());
  }

  // clear the overlay display by disposing of the graphic
  MessageBox.Show("Now to clear the overlay...");
  _graphic.Dispose();

// Use SourceURL for the URL to the image content. For
  // a local file, use a file path. For a web/internet file
  // location, use its URL
  //
  // Supported image types are:
  // png, jpg, tiff, bmp, gif, svg

  var pictureGraphic = new CIMPictureGraphic
  {
    SourceURL = @"C:\Images\MyImage.png",
    Shape = envelope
  };

  IDisposable _graphic = mapView.AddOverlay(pictureGraphic);
}
// cref: ArcGIS.Desktop.Mapping.MapTool.AddOverlayAsync(ArcGIS.Core.Geometry.Geometry, ArcGIS.Core.CIM.CIMSymbolReference, System.Double, System.Double)
// cref: ArcGIS.Desktop.Mapping.MappingExtensions.AddOverlay(ArcGIS.Desktop.Mapping.MapView, ArcGIS.Core.CIM.CIMGraphic, System.Double)

#region Add overlay graphic with text
{
  IDisposable _graphic = null;

  //define the text symbol
  var textSymbol = new CIMTextSymbol();
  //define the text graphic
  var textGraphic = new CIMTextGraphic();

  // Note: Needs QueuedTask to run
  {
    //Create a simple text symbol
    textSymbol = SymbolFactory.Instance.ConstructTextSymbol(ColorFactory.Instance.BlackRGB, 8.5, "Corbel", "Regular");
    //Sets the geometry of the text graphic
    textGraphic.Shape = geometry;
    //Sets the text string to use in the text graphic
    textGraphic.Text = "This is my line";
    //Sets symbol to use to draw the text graphic
    textGraphic.Symbol = textSymbol.MakeSymbolReference();
    //Draw the overlay text graphic
    _graphic = MapView.Active.AddOverlay(textGraphic);
  }

var options = ApplicationOptions.SelectionOptions;

  // Note: Needs QueuedTask to run
  {
    var defaultColor = options.DefaultSelectionColor;

    var color = options.SelectionColor as CIMRGBColor;
    options.SetSelectionColor(ColorFactory.Instance.CreateRGBColor(255, 0, 0));

    var defaultFill = options.DefaultSelectionFillColor;
    var fill = options.SelectionFillColor;
    var isHatched = options.IsSelectionFillHatched;
    options.SetSelectionFillColor(ColorFactory.Instance.CreateRGBColor(100, 100, 0));
    if (!isHatched)
      options.SetSelectionFillIsHatched(true);

    var showSelectionChip = options.ShowSelectionChip;
    options.SetShowSelectionChip(!showSelectionChip);

    var showSelectionGraphic = options.ShowSelectionGraphic;
    options.SetShowSelectionGraphic(!showSelectionGraphic);

    var saveSelection = options.SaveSelection;
    options.SetSaveSelection(!saveSelection);

    var defaultTol = options.DefaultSelectionTolerance;
    var tol = options.SelectionTolerance;
    options.SetSelectionTolerance(2 * defaultTol);

    // extension methods available 
    var selMethod = options.SelectionMethod;
    options.SetSelectionMethod(SelectionMethod.Contains);

    var combMethod = options.CombinationMethod;
    options.SetCombinationMethod(SelectionCombinationMethod.Add);

    // note that the following SelectionCombinationMethod is not supported
    //options.SetCombinationMethod(SelectionCombinationMethod.XOR);
  }

var options = ApplicationOptions.TableOptions;

  var hideAddNewRow = options.HideAddNewRow;
  options.HideAddNewRow = !hideAddNewRow;

  var overrides = options.HonorSelectionColorOverrides;
  options.HonorSelectionColorOverrides = !overrides;

  var activateMapView = options.ActivateMapViewAfterOperations;
  options.ActivateMapViewAfterOperations = !activateMapView;

  var defaultFontTName = options.DefaultFontName;
  var fontName = options.FontName;
  if (options.IsValidFontName("Arial"))
    options.FontName = "Arial";

  var defaultFontSize = options.DefaultFontSize;
  var fontSize = options.FontSize;
  if (options.IsValidFontSize(10))
    options.FontSize = 10;

  var heightType = options.ColumnHeaderHeightType;
  options.ColumnHeaderHeightType = TableRowHeightType.Double;

  var rowHeightType = options.RowHeightType;
  options.RowHeightType = TableRowHeightType.Single;

  var defaultColor = options.DefaultHighlightColor;
  var color = options.HighlightColor;
  // Note: Needs QueuedTask to run
  options.SetHighlightColor(ColorFactory.Instance.CreateRGBColor(0, 0, 255));

mapView.ShowPopup(mapMember, objectID);

//Create custom popup content
  List<PopupContent> popups =
      [
          new("<b>This text is bold.</b>", "Custom tooltip from HTML string"),
          new(new Uri("https://www.esri.com/"), "Custom tooltip from Uri")
      ];
  mapView.ShowCustomPopup(popups);

if (mapView == null) return;
  // Sample code: https://github.com/Esri/arcgis-pro-sdk-community-samples/blob/master/Map-Exploration/CustomIdentify/CustomIdentify.cs
  var topLeftCornerPoint = new System.Windows.Point(200, 200);
  var popupDef = new PopupDefinition()
  {
    Append = true,      // if true new record is appended to existing (if any)
    Dockable = true,    // if true popup is dockable - if false Append is not applicable
    Position = topLeftCornerPoint,  // Position of top left corner of the popup (in pixels)
    Size = new System.Windows.Size(200, 400)    // size of the popup (in pixels)
  };
  mapView.ShowPopup(mapMember, objectID, popupDef);

if (mapView == null) return;

  //Create custom popup content
  List<PopupContent> popups =
  [
      new("<b>This text is bold.</b>", "Custom tooltip from HTML string"),
          new(new Uri("https://www.esri.com/"), "Custom tooltip from Uri")
  ];
  // Sample code: https://github.com/Esri/arcgis-pro-sdk-community-samples/blob/master/Framework/DynamicMenu/DynamicFeatureSelectionMenu.cs
  var topLeftCornerPoint = new System.Windows.Point(200, 200);
  var popupDef = new PopupDefinition()
  {
    Append = true,      // if true new record is appended to existing (if any)
    Dockable = true,    // if true popup is dockable - if false Append is not applicable
    Position = topLeftCornerPoint,  // Position of top left corner of the popup (in pixels)
    Size = new System.Windows.Size(200, 400)    // size of the popup (in pixels)
  };
  mapView.ShowCustomPopup(popups, null, true, popupDef);

//Create custom popup content from existing map member and object id
  List<PopupContent> popups = [new PopupContent(mapMember, objectID)];

  //Create a new custom command to add to the popup window
  List<PopupCommand> commands =
  [
    new PopupCommand(
          p => MessageBox.Show(string.Format("Map Member: {0}, ID: {1}", p.MapMember, p.IDString)),
          p => { return p != null; },
          "My custom command",
          System.Windows.Application.Current.Resources["GenericCheckMark16"] as ImageSource),
      ];

  mapView.ShowCustomPopup(popups, commands, true);

public static void ShowDynamicPopup(MapMember mapMember, List<long> objectIDs)
{
  MapView mapView = MapView.Active;
  if (mapView == null) return;
  //Create popup whose content is created the first time the item is requested.
  var popups = new List<PopupContent>();
  foreach (var id in objectIDs)
  {
    popups.Add(new DynamicPopupContent(mapMember, id));
  }
  mapView.ShowCustomPopup(popups);
}
internal class DynamicPopupContent : PopupContent
{
  public DynamicPopupContent(MapMember mapMember, long objectID)
  {
    MapMember = mapMember;
    IDString = objectID.ToString();
    IsDynamicContent = true;
  }

  //Called when the pop-up is loaded in the window.
  protected override Task<string> OnCreateHtmlContent()
  {
    return QueuedTask.Run(() => string.Format("<b>Map Member: {0}, ID: {1}</b>", MapMember, IDString));
  }
}

internal class SketchTool_WithSymbol : MapTool
{
  public SketchTool_WithSymbol()
  {
    IsSketchTool = true;
    SketchOutputMode = SketchOutputMode.Map; //Changing the Sketch Symbol is only supported with map sketches.
    SketchType = SketchGeometryType.Rectangle;
  }

  protected override Task OnToolActivateAsync(bool hasMapViewChanged)
  {
    return QueuedTask.Run(() =>
    {
      //Set the Sketch Symbol if it hasn't already been set.
      if (SketchSymbol != null)
        return;
      var polygonSymbol = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.CreateRGBColor(24, 69, 59),
                          SimpleFillStyle.Solid,
                        SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.BlackRGB, 1.0, SimpleLineStyle.Dash));
      SketchSymbol = polygonSymbol.MakeSymbolReference();
    });
  }
}

internal class GetMapCoordinates : MapTool
{
  protected override void OnToolMouseDown(MapViewMouseButtonEventArgs e)
  {
    if (e.ChangedButton == System.Windows.Input.MouseButton.Left)
      e.Handled = true; //Handle the event args to get the call to the corresponding async method
  }

  protected override Task HandleMouseDownAsync(MapViewMouseButtonEventArgs e)
  {
    return QueuedTask.Run(() =>
    {
      //Convert the clicked point in client coordinates to the corresponding map coordinates.
      var mapPoint = MapView.Active.ClientToMap(e.ClientPoint);
      ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show(string.Format("X: {0} Y: {1} Z: {2}",
                  mapPoint.X, mapPoint.Y, mapPoint.Z), "Map Coordinates");
    });
  }
}

internal class CustomIdentify : MapTool
{
  public CustomIdentify()
  {
    IsSketchTool = true;
    SketchType = SketchGeometryType.Rectangle;

    //To perform a interactive selection or identify in 3D or 2D, sketch must be created in screen coordinates.
    SketchOutputMode = SketchOutputMode.Screen;
  }

  protected override Task<bool> OnSketchCompleteAsync(ArcGIS.Core.Geometry.Geometry geometry)
  {
    return QueuedTask.Run(() =>
    {
      var mapView = MapView.Active;
      if (mapView == null)
        return true;

      //Get all the features that intersect the sketch geometry and flash them in the view. 
      var results = mapView.GetFeatures(geometry);
      mapView.FlashFeature(results);

      var debug = System.String.Join("\n", results.ToDictionary()
                    .Select(kvp => System.String.Format("{0}: {1}", kvp.Key.Name, kvp.Value.Count())));
      System.Diagnostics.Debug.WriteLine(debug);
      return true;
    });
  }
}

internal class CustomMapTool : MapTool
{
  public CustomMapTool()
  {
    IsSketchTool = true;
    SketchType = SketchGeometryType.Rectangle;
    SketchOutputMode = SketchOutputMode.Map;
    //A custom cursor file as an embedded resource
    var cursorEmbeddedResource = new Cursor(new MemoryStream(Resource1.red_cursor));
    //A built in system cursor
    var systemCursor = System.Windows.Input.Cursors.ArrowCD;
    //Set the "CustomMapTool's" Cursor property to either one of the cursors defined above
    Cursor = cursorEmbeddedResource;
    //or
    Cursor = systemCursor;
  }
}

// Using the Visual Studio SDK templates, add a MapTool and an EmbeddableControl
// The EmbeddableControl is registered in the "esri_embeddableControls" category in the config.daml file
// 
//  <categories>
//    <updateCategory refID = "esri_embeddableControls" >
//      <insertComponent id="mapTool_EmbeddableControl" className="EmbeddableControl1ViewModel">
//        <content className = "EmbeddableControl1View" />
//      </insertComponent>
//    <updateCategory>
//  </categories>
internal class MapTool_WithControl : MapTool
{
  public MapTool_WithControl()
  {
    // substitute this string with the daml ID of the embeddable control you added
    ControlID = "mapTool_EmbeddableControl";
  }

  protected override void OnToolMouseDown(MapViewMouseButtonEventArgs e)
  {
    e.Handled = true;
  }

  protected override Task HandleMouseDownAsync(MapViewMouseButtonEventArgs e)
  {
    //Get the instance of the ViewModel
    var vm = EmbeddableControl;
    if (vm == null)
      return Task.FromResult(0);

    // cast vm to your viewModel in order to access your properties

    //Get the map coordinates from the click point and set the property on the ViewMode.
    return QueuedTask.Run(() =>
    {
      var mapPoint = MapView.Active.ClientToMap(e.ClientPoint);
      string clickText = string.Format("X: {0}, Y: {1}, Z: {2}", mapPoint.X, mapPoint.Y, mapPoint.Z);
    });
  }
}

// Using the Visual Studio SDK templates, add a MapTool and an EmbeddableControl
// The EmbeddableControl is registered in the "esri_embeddableControls" category in the config.daml file
// 
//  <categories>
//    <updateCategory refID = "esri_embeddableControls" >
//      <insertComponent id="mapTool_EmbeddableControl" className="EmbeddableControl1ViewModel">
//        <content className = "EmbeddableControl1View" />
//      </insertComponent>
//    <updateCategory>
//  </categories>

internal class MapTool_WithOverlayControl : MapTool
{
  public MapTool_WithOverlayControl()
  {
    // substitute this string with the daml ID of the embeddable control you added
    OverlayControlID = "mapTool_EmbeddableControl";
  }

  protected override void OnToolMouseDown(MapViewMouseButtonEventArgs e)
  {
    e.Handled = true;
  }

  protected override Task HandleMouseDownAsync(MapViewMouseButtonEventArgs e)
  {
    //Get the instance of the ViewModel
    var vm = OverlayEmbeddableControl;
    if (vm == null)
      return Task.FromResult(0);

    // cast vm to your viewModel in order to access your properties

    //Get the map coordinates from the click point and set the property on the ViewMode.
    return QueuedTask.Run(() =>
    {
      var mapPoint = MapView.Active.ClientToMap(e.ClientPoint);
      string clickText = string.Format("X: {0}, Y: {1}, Z: {2}", mapPoint.X, mapPoint.Y, mapPoint.Z);
    });
  }
}