The main view of FUIMapFloorplanViewController.

@MainActor
open class FUIMapFloorplanContentView : FUIBaseDrawingView, FUIMapFloorplanComponent

A generic map floorplan view controller that supports creating new geometry, editing geometry and save geometry. In general, you do not subclass this class directly. Use FUIMKMapFloorplanViewController(MapKit).

Views Available in FUIMapFloorplanViewController:

• detailPanel: Displays a resizing panel that holds the search controller, content controller, and edit controller. The panel resizes based on the presented controller preferredContentSize.

• toolbar: A view that contains toolbar buttons for easy access to common map functionalities. Default toolbar buttons are provided.

• legend: A view that shows mapAnnotations and their title.

• settingsController: A controller presented as a formSheet over the map allowing for customization of the map.

• createGeometryResultsController: A controller presented when a geometry is saved. Allows for additional configuration before committing the geometry.

Variables Available in FUIMapFloorplanViewController:

• isEditable: A Bool that prepares the floorplan for editing.

• createGeometryItems: An array that displays work orders to create in editing mode. The contents are displayed in a table and on cell selection displays the editing panel.

• isCreatePointEnabled: A Bool that enables editing of point geometries.

• isCreatePolylineEnabled: A Bool that enables editing of polyline geometries.

• isCreatePolygonEnabled: A Bool that enables editing of polygon geometries.

Usage

override func viewDidLoad() {
    detailPanel.search.tableView.dataSource = dataSource
    detailPanel.content.tableView.dataSource = dataSource
    legend.items = items
    settingsController = controller
    createGeometryResultsController = controller
}

Editing Interaction:

The floorplan supports editing to allow users to add geometries (points, polylines, and polygons) by drawing directly on the map.

A floorplan subclass can become editable by setting isEditable. The view controller will transition to an editing state by setting all other annotations to disabled, showing editing toolbar buttons, and presenting the editing panel. The + right bar button presents a popover allowing the user to select a geometry.

Once the panel is presented, a user can toggle between geometry types (points, polylines, and polygons) to edit. The user can draw directly on the map by tapping on screen. The editing tool bar buttons show how the user can interact with the map. When the add Button is selected, the user can tap to add points. When the delete button is selected, a user can tap a point to delete. Actions can be undone and redone with the undo and redo buttons. Lastly the branch button can extend a polyline or polygon. To edit existing points the user can use the long press gesture to drag points to new locations.

Alternatively, A user can edit existing points using the panel. The user can input directly an address and a list of suggestions will be presented. Tapping on a suggestion will add the point to the map. To delete, tap the red circle to show the red delete button. Tap delete to remove the point. Reordering points is done by dragging cells among each other.

To save, tap the save button. This will launch the developer’s createGeometryResultsController where the user can make additional changes to the work order. Tapping the save right bar button dismisses the controller and exits the editing state. It is up to the developer to update his/her model with the saved geometry.

See more

@MainActor
open class FUIMapFloorplanViewController<InnerView, EditingGeometryWrapper, EditingTypes> : FUIBaseDrawingViewController<InnerView>, FUIMapFloorplanComponent where InnerView : FUIMapFloorplanContentView, EditingGeometryWrapper : FUIManageRepresentation, EditingTypes : FUIGeometryTypeWrapper

A subclass of MKMapView is designed to be used with MapKit framework. You can use FUIMKMapView to display map information and to manipulate the map contents from your application. The FUIMKMapView class supports the ability to cache common map interface objects: annotations and overlays. Native MKMapView API methods are also available for developer use. It also adds the selection and deselection handlers for overlays.

Usage

When configuring your map interface with FUIMKMapView, all the added annotation and overlay objects and their corresponding display objects will be cached internally. Add annotation objects to the map view

func addAnnotation(_ annotation: MKAnnotation, toLayer layer: FUIGeometryLayer) {}
func addAnnotation(_ annotation: MKAnnotation, geometryLayer layer: FUIGeometryLayer) {}
func addAnnotations(_ annotations: [MKAnnotation], geometryLayer layer: FUIGeometryLayer) {}

Add overlay objects to the map view

func addOverlays(_ overlays: [MKOverlay], level: MKOverlayLevel, geometryLayer layer: FUIGeometryLayer) {}
func addOverlays(_ overlays: [MKOverlay], geometryLayer layer: FUIGeometryLayer) {}

Respond to select/deselect overlay action

func selectOverlay(_ overlay: MKOverlay, animated: Bool) {}
func deselectOverlay(_ overlay: MKOverlay, animated: Bool) {}

Theming

See more

@MainActor
open class FUIMKMapView : MKMapView

The main view of FUIMKMapFloorplanViewController

See more

@MainActor
open class FUIMKMapFloorplanContentView : FUIMapFloorplanContentView

A subclass of FUIMapFloorplanViewController designed to be used with MapKit framework. You can use it to display business objects(points, polylines, polygons) on the map view and view details by selecting a business object. It also supports clustering of point geometries.

Usage

The map view consists of mutiple FUIGeometryLayers. By assigning geometries onto different layers, you can show/hide all geometries on a specified layer using setLayerHidden(_:hidden:) api.

1. Implement FUIMKMapViewDataSource methods.

In the floorplan controller viewDidLoad() set the datasource.

self.dataSource = dataSource

func numberOfLayers(in mapView: MKMapView) -> Int { return 1 }

func mapView(_ mapView: MKMapView, layerAtIndex index: Int) -> FUIGeometryLayer { return FUIGeometryLayer("Functional Location") }

func mapView(_ mapView: MKMapView, geometriesForLayer layer: FUIGeometryLayer) -> [MKAnnotation] { return polylines }

You can also add annotations/overlays to a specified layer using FUIMKMapView’s addAnnotation(_:geometryLayer:) and addOverlays(_:geometryLayer:) APIs. Make sure you update you data model accordingly.

Please Note: If you use MapKit’s native APIs to add annotations/overlays, the FUIMKMapViewDelegate object is not able to manage these objects.

1. Implement MKMapViewDelegate methods as needed.

Developer can supply custom annotation views. FUIMarkerAnnotationView is provided by the floorplan.

mapView.delegate = delegate

open func mapView(_ mapView: MKMapView, viewFor annotation: MKAnnotation) -> MKAnnotationView? {
    guard let pointAnnotation = annotation as? MKPointAnnotation else { return nil }
    guard let view = FUIMarkerAnnotationView(annotation: pointAnnotation, reuseIdentifier: "cell") else { return nil }
    view.glyphImage = FUIIconLibrary.map.marker.venue.withRenderingMode(.alwaysTemplate)
    view.priorityIcon =  FUIIconLibrary.map.marker.veryHighPriority
}

1. FUIMKMapViewDelegate provides more functionalities that you can make your app more powerful.

In the floorplan controller viewDidLoad() set the delegate.

self.delegate = delegate

Determine how annotation view/overlay renderer should appear. You can customize the view/render provided with fiori default styles.

func mapView(_ mapView: MKMapView, willRender overlay: MKOverlayRenderer, for geometryIndex: Int, in layer: FUIGeometryLayer, in state: FUIMapFloorplan.State) {
    guard let polylineRenderer = overlayRenderer as? MKPolylineRenderer else { return }
    polylineRenderer.strokeColor = UIColor.blue
    polylineRenderer.setNeedsDisplay()
}

Respond to select/deselect action

func mapView(_ mapView: MKMapView, didSelect annotation: MKAnnotation, for geometryIndex: Int, in layer: FUIGeometryLayer) {}

func mapView(_ mapView: MKMapView, didSelect clusterAnnotation: MKClusterAnnotation, for geometryIndexesInLayers: [FUIGeometryLayer: [Int]]) {}

func mapView(_ mapView: MKMapView, didSelect overlay: MKOverlay, for geometryIndex: Int, in layer: FUIGeometryLayer) {}

func mapView(_ mapView: MKMapView, didSelect overlayRenderer: MKOverlayRenderer) {}

func mapView(_ mapView: MKMapView, didDeselect annotation: MKAnnotation, for geometryIndex: Int, in layer: FUIGeometryLayer) {}

func mapView(_ mapView: MKMapView, didDeselect clusterAnnotation: MKClusterAnnotation, for geometryIndexesInLayers: [FUIGeometryLayer: [Int]]) {}

func mapView(_ mapView: MKMapView, didDeselect overlay: MKOverlay, for geometryIndex: Int, in layer: FUIGeometryLayer) {}

func mapView(_ mapView: MKMapView, didDeselect overlayRenderer: MKOverlayRenderer) {}

Theming

See more

@MainActor
open class FUIMKMapFloorplanViewController : FUIMapFloorplanViewController<FUIMKMapFloorplanContentView, MKEditingGeometryWrapper, MKEditingTypes>, EditingGeometryProducing

A View that wraps the FUIMapToolbarButton in a vertical stack.

• The FUIMapToolbar holds a maximum of 6 FUIMapToolbarButton.
• Default variants of FUIMapToolbarButton exist within the SDK. See, FUIMapToolbarSettingsButton, FUIMapToolbarUserLocationButton, FUIMapToolbarZoomExtentButton, or FUIMapToolbarLegendButton
• The FUIMapToolbar can be presented in either a dark or light variant.
• The FUIMapToolbar will be pinned to the given MKMapView in the top right corner

Usage

var toolbar = FUIMapToolbar(mapView: mapView)
toolbar.backgroundColorScheme = .dark // defaults to `.light`
let locationButton = FUIMapToolbarUserLocationButton(mapView: self.mapView)
let zoomExtentsButton = FUIMapToolbarZoomExtentButton(mapView: self.mapView)
toolbar.items = [locationButton, zoomExtentsButton]

See more

@MainActor
open class FUIMapToolbar : FUIDrawingView

FUIMapToolbarButton inherits from the FUIButton class and appears within the FUIMapToolbar.

• Height and width are both set to 44
• Images should be set to 28 by 28 icons. Icons will be centered within the button.
• didSelectHandler can be set to add custom functionality on tap

Usage:

let toolbar = FUIMapToolbar(mapView: self.mapView)
let settingsButton = FUIMapToolbarButton()
settingsButton.isPersistentSelection = true
settingsButton.setImage(FUIIconLibrary.system.information.withRenderingMode(.alwaysTemplate), for: .normal)
settingsButton.didSelectHandler = { [weak self] button in
   DispatchQueue.main.async {
       let settings = DevMapSettingsViewController()
       settings.dismissButton = button

       let navController = UINavigationController(rootViewController: settings)
       if !(UIDevice.current.userInterfaceIdiom == .phone) {
           settings.modalPresentationStyle = .formSheet
           navController.modalPresentationStyle = .formSheet
           self.present(navController, animated: true, completion: nil)
       } else {
           navController.modalPresentationStyle = .overFullScreen
           let dismissClosure: (() -> Void)? = { [weak self] in
               self.dismiss(animated: true, completion: nil)
           }
           settings.dismissClosure = dismissClosure
           self.present(navController, animated: true, completion: nil)
       }
   }
}
toolbar.items = [settingsButton]

Notes

• Subclass the FUIMapToolbarButton for custom variants

See more

@MainActor
open class FUIMapToolbarButton : FUIButton

A UIViewController containing a tableView of FUIMapLegendItems. This controller is intended to be presented within a UIPopoverPresentationController. It calculates its preferred content size based on the tableView’s content height and tableView’s content width between a maximum and minimum value.

Available in FUIMapLegend:

• items: an array of FUIMapLegendItem that will be displayed in the tableView.

See more

@MainActor
open class FUIResizablePopoverContainer : UIViewController

FUIMapLegend extends UIViewController to show the Map Legend.

FUIMapLegend is presented in a UIPopoverView on iPad and presented in a UIPresentationController on iPhone

Available in FUIMapLegend:

• headerTextView: a TextView intended to display a footnote text.
• passThroughViews: an array of UIView that a user can interact with while popover is visible

Example Initialization and Configuration:

In view controller’s viewDidLoad method:

let toolbar = FUIMapToolbar(mapView: mapView)
let legend = FUIMapLegend()
legend.toolbarButton = FUIMapToolbarLegendButton()
legend.headerTextView.text = "MapView Example Legend"
legend.passThroughViews = [toolbar, mapView]

var venueItem = FUIMapLegendItem(title: "Self Service")
venueItem.backgroundColor = UIColor.preferredFioriColor(forStyle: .map1)
let venueImage = FUIAttributedImage(image: FUIIconLibrary.map.marker.venue.withRenderingMode(.alwaysTemplate))
venueImage.tintColor = .white
venueItem.icon = FUIMapLegendIcon(glyphImage: venueImage)

var valetItem = FUIMapLegendItem(title: "Valet")
valetItem.backgroundColor = UIColor.preferredFioriColor(forStyle: .map2)
let valetImage =  FUIAttributedImage(image: FUIIconLibrary.map.marker.walk.withRenderingMode(.alwaysTemplate))
valetImage.tintColor = .white
valetItem.icon = FUIMapLegendIcon(glyphImage: valetImage)
valetItem.line = FUIMapLegendLine(dashPattern: [10,8], dashPhase: 3.0)

let highActivityRegion = FUIMapLegendFillItem()
highActivityRegion.fillColor = UIColor.preferredFioriColor(forStyle: .map3)
highActivityRegion.borderColor = UIColor.preferredFioriColor(forStyle: .map3)
var highActivityRegionItem = FUIMapLegendItem(title: "High Activity Region")
highActivityRegionItem.fillItem = highActivityRegion

var highTrafficPathItem = FUIMapLegendItem(title: "High Traffic Path")
highTrafficPathItem.backgroundColor = UIColor.preferredFioriColor(forStyle: .map4)
highTrafficPathItem.line = FUIMapLegendLine(dashPattern: [2,2], dashPhase: 0.0)

legend.items = [highActivityRegionItem, valetItem, venueItem, highTrafficPathItem]

let legendHandler: ((FUIButton) -> Void)? = { [weak self] button in
    DispatchQueue.main.async {

        var dismissLegendAndRestoreCachedController = { [unowned self, unowned button] in
           self.dismiss(animated: true, completion: {
           button.isSelected = false
           })
        }

        let presentNewLegendPhone = {
           self.present(legend, animated: true, completion: nil)
        }

        let presentNewLegendPad = {
           legend.setupPopoverAttributes(popOver: legend.popoverPresentationController!, sender: button)
           if self.presentedViewController == nil {
               self.present(legend, animated: false, completion: nil)
           }
        }

        guard button.isSelected else {
           dismissLegendAndRestoreCachedController()
           return
        }

        let presentNewClosure = UIDevice.current.userInterfaceIdiom == .phone ? presentNewLegendPhone : presentNewLegendPad

        guard let presentedController = UIDevice.current.userInterfaceIdiom == .phone ? self.presentedViewController : self.popoverPresentationController?.presentedViewController else {
           presentNewClosure()
           return
        }

        if presentedController == legend {
           dismissLegendAndRestoreCachedController()
        } else {
           self.dismiss(animated: true, completion: {
               presentNewClosure()
           })
        }
    }
}
legend.toolbarButton?.didSelectHandler = legendHandler
let locationButton = FUIMapToolbarUserLocationButton(mapView: self.mapView)
toolbar.items = [legend.toolbarButton!, locationButton]

theming

fdlFUIMapLegendContainer_headerTextView {
font-color: @primary3;
font-name: semiboldSystem;
font-style: footnote;
}

notes

See more

@MainActor
open class FUIMapLegend : FUIResizablePopoverContainer

extension FUIMapLegend: UIViewControllerTransitioningDelegate

extension FUIMapLegend: UITableViewDelegate

extension FUIMapLegend: UITableViewDataSource

FUIMapLegendItem is a struct to represent an entry in the Map Legend. A FUIMapLegendItem can be one of 4 types:

1. icon: An item with a circular icon
2. iconLine: An item with a circular icon and line
3. line: An item with a line
4. fill: An item with a filled polygon

Available:

• title: a String that describes the FUIMapLegendItem

• type: a FUIMapLegendItemType designated for the item.

• backgroundColor: a UIColor displayed as a backgroundColor for the item

• tintColor: a UIColor displayed as a tintColor for the item

• icon: a FUIMapLegendIcon for the designated item.

• line: a FUIMapLegendLine for the designated item.

• fillItem: a FUIMapLegendFillItem for the designated item.

Example Initialization and Configuration:

// Type: .icon
var venueItem = FUIMapLegendItem(title: "Self Service")
venueItem.backgroundColor = UIColor.preferredFioriColor(forStyle: .map1)
let venueImage = FUIAttributedImage(image: FUIIconLibrary.map.marker.venue.withRenderingMode(.alwaysTemplate))
venueImage.tintColor = .white
venueItem.icon = FUIMapLegendIcon(glyphImage: venueImage)

var valetItem = FUIMapLegendItem(title: "Valet")
valetItem.backgroundColor = UIColor.preferredFioriColor(forStyle: .map2)
let valetImage =  FUIAttributedImage(image: FUIIconLibrary.map.marker.walk.withRenderingMode(.alwaysTemplate))
valetImage.tintColor = .white
valetItem.icon = FUIMapLegendIcon(glyphImage: valetImage)
valetItem.line = FUIMapLegendLine(dashPattern: [10,8], dashPhase: 3.0)

let highActivityRegion = FUIMapLegendFillItem()
highActivityRegion.fillColor = UIColor.preferredFioriColor(forStyle: .map3)
highActivityRegion.borderColor = UIColor.preferredFioriColor(forStyle: .map3)
var highActivityRegionItem = FUIMapLegendItem(title: "High Activity Region")
highActivityRegionItem.fillItem = highActivityRegion

var highTrafficPathItem = FUIMapLegendItem(title: "High Traffic Path")
highTrafficPathItem.backgroundColor = UIColor.preferredFioriColor(forStyle: .map4)
highTrafficPathItem.line = FUIMapLegendLine(dashPattern: [2,2], dashPhase: 0.0)

legend.items = [highActivityRegionItem, valetItem, venueItem, highTrafficPathItem]

See more

public struct FUIMapLegendItem

FUIMapLegendIcon is a struct to represent an entry in the Map Legend that displays an item with a circular icon.

Example Initialization and Configuration:

var venueItem = FUIMapLegendItem(title: "Self Service")
venueItem.backgroundColor = UIColor.preferredFioriColor(forStyle: .map1)
let venueImage = FUIAttributedImage(image: FUIIconLibrary.map.marker.venue.withRenderingMode(.alwaysTemplate))
venueImage.tintColor = .white
venueItem.icon = FUIMapLegendIcon(glyphImage: venueImage)

var valetItem = FUIMapLegendItem(title: "Valet")
valetItem.backgroundColor = UIColor.preferredFioriColor(forStyle: .map2)
let valetImage =  FUIAttributedImage(image: FUIIconLibrary.map.marker.walk.withRenderingMode(.alwaysTemplate))
valetImage.tintColor = .white
valetItem.icon = FUIMapLegendIcon(glyphImage: valetImage)
valetItem.line = FUIMapLegendLine(dashPattern: [10,8], dashPhase: 3.0)

legend.items = [venueItem, valetItem]

See more

public struct FUIMapLegendIcon

FUIMapLegendFillItem is a UIView that presents a square view with a fill color and border color.

Available in FUIMapLegendFillItem:

• fillColor: a UIColor that is the fill color of the square view

• borderColor: a UIColor that is the border color of the square view

Example Initialization and Configuration:

let highActivityRegion = FUIMapLegendFillItem()
highActivityRegion.fillColor = UIColor.preferredFioriColor(forStyle: .map3)
highActivityRegion.borderColor = UIColor.preferredFioriColor(forStyle: .map3)
var highActivityRegionItem = FUIMapLegendItem(title: "High Activity Region")
highActivityRegionItem.fillItem = highActivityRegion

legend.items = [highActivityRegionItem]

See more

@MainActor
public class FUIMapLegendFillItem : UIView

FUIMapLegendLine is a struct to represent the line in the Map Legend. The color of the line is determined by the backgroundColor set by the item.

Available in FUIMapLegendLine:

• dashPattern: an array of NSNumber objects specifying the lenghts of line segments

• dashPhase: a CGFloat describing how far into the dash pattern the line starts

Example Initialization and Configuration:

var valetItem = FUIMapLegendItem(title: "Valet")
valetItem.backgroundColor = UIColor.preferredFioriColor(forStyle: .map2)
let valetImage =  FUIAttributedImage(image: FUIIconLibrary.map.marker.walk.withRenderingMode(.alwaysTemplate))
valetImage.tintColor = .white
valetItem.icon = FUIMapLegendIcon(glyphImage: valetImage)
valetItem.line = FUIMapLegendLine(dashPattern: [10,8], dashPhase: 3.0)

var highTrafficPathItem = FUIMapLegendItem(title: "High Traffic Path")
highTrafficPathItem.backgroundColor = UIColor.preferredFioriColor(forStyle: .map4)
highTrafficPathItem.line = FUIMapLegendLine(dashPattern: [2,2], dashPhase: 0.0)

legend.items = [valetItem, highTrafficPathItem]

See more

public struct FUIMapLegendLine

A View Controller component within the FUIMapDetailPanel as the content. This controller shows additional details of a business object. It is up to the developer to set the tableView dataSource and delegate. Typically not used directly by developer.

Available:

• headlineText: A String used as the header text inside the panel. The headline text can wrap up to two lines and truncates at the tail.
• subheadlineText: A String used as the subheadline text inside the panel. The subheadline text gradually disappears while the tableView scrolls.
• didSelectTitleHandler: An optional handler that can be set by the developer that is executed when the headlineText is tapped. If the didSelectTitleHandler is not nil, the headlineText text color is changed to show that it is tappable.

Usage:

let content: FUIMapDetailPanelContentViewController = FUIMapDetailPanelContentViewController()
content.headlineText = "Headline Text"
content.subheadlineText = "Subheadline Text"
content.didSelectTitleHandler = {
   print("didSelectTitleHandler called!")
}
content.tableView.delegate = delegate
content.tableView.dataSource = dataSource
content.tableView.register(FUIMapDetailBaseObjectTableViewCell.self, forCellReuseIdentifier: FUIMapDetailBaseObjectTableViewCell.reuseIdentifier)
content.tableView.estimatedRowHeight = 100
content.tableView.rowHeight  = UITableView.automaticDimension

See more

@MainActor
final public class FUIMapDetailPanelContentViewController : FUIMapDetailPanelViewController

A View Controller component used in the FUIMapDetailPanel. It is up to the developer to set the tableView dataSource and delegate. Typically not used directly by developer.

Usage:

let vc = FUIMapDetailPanelViewController()
vc.tableView.delegate = delegate
vc.tableView.dataSource = dataSource

See more

@MainActor
public class FUIMapDetailPanelViewController : UIViewController, FUIMapDetailPanelProtocol

Searchbar component of FUIMapDetailPanelSearchResultsViewController. It is up to the developer to set the search delegate.

Usage

let searchBar: FUIMapDetailPanelSearchBar = FUIMapDetailPanelSearchBar()
searchBar.delegate = delegate

See more

@MainActor
public class FUIMapDetailPanelSearchBar : FUISearchBar

A View Controller component within the FUIMapDetailPanel as the searchResults. This controller shows a tableView with search results using a given searchBar. It is up to the developer to set the searchBar delegate, tableView datasource, and tableView delegate. Typically not used directly by developer.

Available:

• tableView: A UITableView that displays search results. Developer must set the tableView datasource and delegate.
• searchBar: A FUIMapDetailPanelSearchBar that should filter data. Developer must set the searchBar delegate.
• preferredContentSize: A CGSize that determines the size of the UIViewController. This variable drives the resizing capabilities of the view and must set correctly and properly updated.
• isApplyingBlurBackground: A Bool that determines if the tableView will use its blurredBackground. Setting it to false will set the tableView to the UITableView default values. isApplyingBlurBackground default value is true.
• searchBar: A FUIMapDetailPanelSearchBar used to filter data.

Usage:

let search = FUIMapDetailPanelSearchResultsViewController()
search.isApplyingBlurBackground = true
search.tableView.dataSource = tableViewDataSource
search.tableView.delegate = tableViewDelegate
search.tableView.register(FUIMapDetailTagObjectTableViewCell.self, forCellReuseIdentifier: FUIMapDetailTagObjectTableViewCell.reuseIdentifier)
search.searchBar.delegate = searchBarDelegate

See more

@MainActor
public class FUIMapDetailPanelSearchResultsViewController : FUIMapDetailPanelViewController

A View Component that wraps the FUIMapDetailPanelSearchResultsViewController as the searchResultsController and the FUIMapDetailPanelContentViewController as the content. Switching between the two view controllers should be driven by the pushChildViewController and popChildViewController methods in the developer’s mapView(_:didSelect:) and mapView(_:didDeselect:) methods.

## iPhone The searchResults and content will be presented on cards that can be swipe and panned to a bottom, middle, or top position.

## iPad The view is placed in the top left corner of the iPad and will dynamically resize based on the preferredContentSize. The view is pinned to the given pinMapView and will resize accordingly. The fitToContent method must be called when reloading the table view.

## Available:

• passThroughViews: A [UIView] that contains the views that are interactable when the map legend is presented on iPad. This prevents the popover from being dismissed while interacting with views in this list (ex. a MKMapView).
• isApplyingBlurBackground: A Bool that determines if the child views will have a blurred background.
• isSearchEnabled: A Boolean value to instantiate search.
• searchResults: A FUIMapDetailPanelSearchResultsViewController used for the search function. Manipulate its tableView to show search results. The developer must set the datasource and delegate methods.
• content: A FUIMapDetailPanelContentViewController used for showing the details. The developer must set the datasource and delegate methods.

## Usage

 container = FUIMapDetailPanel(parentViewController: self, mapView: mapView)
 favoritesData = Array(sampleData[3..<sampleData.count])

 container.isSearchEnabled = true
 container.isApplyingBlurBackground = true
 container.search.tableView.dataSource = searchResultsDataSource
 container.search.tableView.delegate = searchResultsDelegate
 container.search.tableView.register(FUIObjectTableViewCell.self, forCellReuseIdentifier: FUIObjectTableViewCell.reuseIdentifier)
 container.search.searchBar.delegate = searchResultsDelegate

 container.content.headlineText = "VA Palo Alto Health Care Sys wraps to two lines..."
 container.content.didSelectTitleHandler = {
    print("Developer Select Handler Called!")
 }
 container.content.subheadlineText = "Medical Center"
 container.content.tableView.dataSource = contentDataSource
 container.content.tableView.delegate = contentDelegate
 container.content.tableView.register(FUIObjectTableViewCell.self, forCellReuseIdentifier: FUIObjectTableViewCell.reuseIdentifier)
 container.content.tableView.estimatedRowHeight = 100
 container.content.tableView.rowHeight = UITableView.automaticDimension

Manage presenting the controller on iPhone in viewDidAppear(_:).

 DispatchQueue.main.async {
    self.container!.presentContainer()
 }

Manage dismissing the controller on iPhone in viewWillDisappear(_:)

 self.presentedViewController?.dismiss(animated: false, completion: nil)

Present the detailPanel by managing selecting and deselecting map annotations in mapView(_:didSelect:) and mapView(_:didDeselect:)

 open func mapView(_ mapView: MKMapView, didSelect view: MKAnnotationView) {

     let selectedAnnotation = view.annotation

     if selectedAnnotation is MKUserLocation {
        return
     }

    self.devUpdateDetailVC(annotation: selectedAnnotation!)

     DispatchQueue.main.async {
         container.pushChildViewController()
     }


     for annotation in mapView.annotations {
        if let annotation = annotation as? MKAnnotation, !annotation.isEqual(selectedAnnotation) {
            self.container.content.tableView.dataSource = newDataSource
            self.container.fitToContent()
            DispatchQueue.main.async {
                self.container.pushChildViewController()
            }
            return
        }
    }
 }

 open func mapView(_ mapView: MKMapView, didDeselect view: MKAnnotationView) {

     let selectedAnnotation = view.annotation

     if selectedAnnotation is MKUserLocation {
        return
     }

     DispatchQueue.main.async {

         if self.mapView.selectedAnnotations.isEmpty {
            self.container.popChildViewController()
         } else {
            self.container.content.tableView.dataSource = newDataSource
            self.container.fitToContent()
            self.container.content.tableView.reloadData()
         }
     }
 }

See more

@MainActor
open class FUIMapDetailPanel : UIView

A FUIMapDetailTagObjectTableViewCell that inherits from FUIMapDetailBaseObjectTableViewCell and FUITags. Add tags to the tableViewCell in the upper left corner above the subheadline text.

Available:

• tags: An array of String that will be wrapped in a bordered cell. These tags will go in the upper left corner of the cell.

Initialization and Configuration

In the viewDidLoad

tableView.register(FUIMapDetailTagObjectTableViewCell.self, forCellReuseIdentifier: FUIMapDetailTagObjectTableViewCell.reuseIdentifier)

In the tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath)

let cell = tableView.dequeueReusableCell(withIdentifier: FUIMapDetailTagObjectTableViewCell.reuseIdentifier, for: indexPath) as! FUIMapDetailTagObjectTableViewCell
cell.headlineText = "VA Palo Alto Health Care Sys wraps to two lines..."
cell.headlineLabel.numberOfLines = 1
cell.footnoteText = "Medical Center"
cell.statusLabel.font = UIFont.preferredFioriFont(forTextStyle: .headline)

See more

@MainActor
open class FUIMapDetailTagObjectTableViewCell : FUIBaseDrawingTableViewCell<FUIMapDetailTagObjectView>

Status view component of FUIMapDetailStatusTableViewCell

Typically not used directly by developer.

A view with left aligned text and an optional image. Images are left aligned and placed to the left of the text. Images are expected to be 16px by 16px.

Usage

let statusView = FUIMapDetailStatusView()
statusView.statusImage = FUIIconLibrary.indicator.veryHighPriority
statusView.status.text = "High"

Theming

nuiClass:

fdlFUIMapDetailStatusView {}

Supported TEXT class paths:

fdlFUIMapDetailStatusView_status {}

Supported TEXT properties:

font-color: Color;
font-style: UIFontTextStyle;

Supported IMAGE class paths:

fdlFUIMapDetailStatusView_statusImage {}

Supported IMAGE properties:

tint-color: Color;

See more

@MainActor
open class FUIMapDetailStatusView : FUIDrawingView, FUIStatusImageComponent

An object that manages editing data in the detailPanel. The developer specifies the items a user can create and which geometries he/she can use. A controller is presented when saving a geometry to add additional changes to the work order. When the geometry is saved, it is up to the developer to update their model with editing geometry.

Variables Available in FUIEditingPanel:

• createGeometryItems: An array of FUIMapLegendItem that displays the types of work orders that can be created. The items are presented in a table and when selected presents the editing panel. The panel takes the title of the item and sets it as the headline. The icon and title text has a white background and a tint color of UIColor.preferredFioriColor(forStyle: .tintColorDark)

• basemapTypes: An array of MKMapType a user can pick from during editing. MapType is returned to the original state after editing is completed. By default, the user can pick from .standard, .hybrid, .mutedStandard, and .satellite.

• isCreatePointEnabled: A Bool that enables the creation of a point geometry. By default, point geometry creation is enabled. Select the point symbol on the segmented control within the editing panel to begin editing.

• isCreatePolylineEnabled: A Bool that enables the creation of a polyline geometry. By default, polyline geometry creation is enabled. Select the polyline symbol on the segmented control within the editing panel to begin editing.

• isCreatePolygonEnabled: A Bool that enables the creation of a polygon geometry. By default, polygon geometry creation is enabled. Select the polygon symbol on the segmented control within the editing panel to begin editing.

• createGeometryResultsController: A view controller that is presented when an editing geometry is saved. Used to make additional changes to the work order before a save is committed. The controller is presented modally over the map. The saved geometry is handled by the developer in the didSaveGeometry method where the map model should be updated.

• willShowCreateGeometryResultsController: A closure that provides custom behaviors before showing createGeometryResultsController. This closure will only be called if createGeometryResultsController is displayed in .push mode. It is up to the developer to implement this closure and define custom actions before entering the editing results screen.

• didDismissGeometryResultsController: A closure that provides custom behaviors before dismissing createGeometryResultsController. This closure will only be called if createGeometryResultsController is displayed in .push mode. It is up to the developer to implement this closure and define custom actions before dismissing the editing results screen.

• didCommitGeometryResults: A closure that provides the committed saved geometry. It is up to the developer to implement this closure and update his/her own model with the saved geometry.

See more

open class FUIEditingPanel<GeometryType> where GeometryType : FUIGeometry

A protocol extending MKAnnotation for storing index and state info that will be used by FUIMapFloorplanViewController. The properties of this protocol are managed by FUIMapFloorplanViewController. Developer is not supposed to set these properties.

See more

public protocol FUIAnnotation : MKAnnotation

The FUIMapMarkerAnnotationView inherits from the MKMarkerAnnotationView and is presented as an annotation on the MKMapView. It is used to distinguish between location types and set a select priority to individual markers.

Note

We disabled setter of zPosition in order to prevent it from being modified when setting displayPriority. Set stickyZPosition instead.

## Available:

• priorityIcon: a 17x17 icon image in the upper right corner of the marker. This can appear in both the selected and unselected state.

## Example Initialization and Configuration

 @available(iOS 11.0, *)
 class MyMarker: FUIMarkerAnnotationView {
     override var annotation: MKAnnotation? {
         willSet {
             markerTintColor = UIColor.preferredFioriColor(forStyle: .map1)
             glyphImage = FUIIconLibrary.map.marker.venue.withRenderingMode(.alwaysTemplate)
             displayPriority = .defaultLow
             priorityIcon =  FUIIconLibrary.map.marker.veryHighPriority
         }
     }
 }

Register within the viewDidLoad()

 if #available(iOS 11.0, *) {
    mapView.register(MyMarker.self, forAnnotationViewWithReuseIdentifier: MKMapViewDefaultAnnotationViewReuseIdentifier)
 } else {
    // Fallback on earlier versions
 }
 let point1 = MKPointAnnotation()
 point1.coordinate = CLLocationCoordinate2D(latitude: 37.3318, longitude: -122.0312)
 let point2 = MKPointAnnotation()
 point2.coordinate = CLLocationCoordinate2D(latitude: 37.3988313, longitude: -122.1487375)
 let annotations = [point1 as MKAnnotation, point2 as MKAnnotation]
 mapView.addAnnotations(annotations)

Set the annotation view in the mapView(_:viewFor:) method.

var view: MKAnnotationView!
if let pointAnnotation = annotation as? MKPointAnnotation {
    if #available(iOS 11.0, *) {
        view = FUIMarkerAnnotationView(annotation: pointAnnotation, reuseIdentifier: "cell")
        let annotationImage = FUIIconLibrary.map.marker.venue
        (view as! FUIMarkerAnnotationView).glyphImage = annotationImage.withRenderingMode(.alwaysTemplate)
        (view as! FUIMarkerAnnotationView).priorityIcon =  FUIIconLibrary.map.marker.veryHighPriority
    } else {
        // Fallback on earlier versions
        view = MKPinAnnotationView(annotation: pointAnnotation, reuseIdentifier: "cell")
    }
}
return view

## Note:

• Set the glyphImage to a 20x20 icon.

See more

@available(iOS 11.0, *)
@MainActor
open class FUIMarkerAnnotationView : MKMarkerAnnotationView

The FUIProfileMarkerAnnotationView inherits from the MKMarkerAnnotationView and is presented as an annotation on the MKMapView. It is used to distinguish between static points on a map and person location. The annotation can either display a profilePicture or a set of initials to represent the person being annotated.

Example Initialization and Configuration

@available(iOS 11.0, *)
class MyProfileMarker: FUIProfileMarkerAnnotationView {
   override var annotation: MKAnnotation? {
       willSet {
           markerTintColor = UIColor.preferredFioriColor(forStyle: .map1)
           glyphImage = FUIIconLibrary.map.marker.venue.withRenderingMode(.alwaysTemplate)
       }
   }
}

Register within the viewDidLoad()

if #available(iOS 11.0, *) {
   mapView.register(MyProfileMarker.self, forAnnotationViewWithReuseIdentifier: MKMapViewDefaultAnnotationViewReuseIdentifier)
} else {
   // Fallback on earlier versions
}
let point1 = MKPointAnnotation()
point1.coordinate = CLLocationCoordinate2D(latitude: 37.3318, longitude: -122.0312)
let point2 = MKPointAnnotation()
point2.coordinate = CLLocationCoordinate2D(latitude: 37.3988313, longitude: -122.1487375)
let annotations = [point1 as MKAnnotation, point2 as MKAnnotation]
mapView.addAnnotations(annotations)
mapView.showAnnotations(annotations, animated: true)

Set the annotation view in the mapView(_:viewFor:) method.

var view: MKAnnotationView!
if let pointAnnotation = annotation as? MKPointAnnotation {
   if #available(iOS 11.0, *) {
       if pointAnnotation.coordinate.latitude == 37.3318 {
           view = FUIProfileMarkerAnnotationView(annotation: pointAnnotation, reuseIdentifier: "cell")
           (view as! FUIProfileMarkerAnnotationView).glyphText =  "ME"
           return view
       } else {
           view = FUIProfileMarkerAnnotationView(annotation: pointAnnotation, reuseIdentifier: "cell")
           (view as! FUIProfileMarkerAnnotationView).glyphImage = #imageLiteral(resourceName: "ProfilePic").withRenderingMode(.alwaysOriginal)
           (view as! FUIProfileMarkerAnnotationView).selectedGlyphImage = #imageLiteral(resourceName: "ProfilePic").withRenderingMode(.alwaysOriginal)
           return view
       }
   } else {
       // Fallback on earlier versions
       return nil
   }
}
return view

Note:

• Set the profileImage to a 24x24 icon.

See more

@available(iOS 11.0, *)
@MainActor
open class FUIProfileMarkerAnnotationView : MKMarkerAnnotationView

The FUICircleAnnotationView inherits from the MKAnnotationView and is presented as a circle annotation on the MKMapView. It is used to display annotation objects which have similar display effect as MKCircle object.

Note

We disabled setter of zPosition to prevent it from being modified when setting displayPriority. Set stickyZPosition instead.

Example

1. Add annotation objects to map let point1 = MKPointAnnotation() point1.coordinate = CLLocationCoordinate2D(latitude: 37.3318, longitude: -122.0312) let point2 = MKPointAnnotation() point2.coordinate = CLLocationCoordinate2D(latitude: 37.3988313, longitude: -122.1487375) let annotations = [point1 as MKAnnotation, point2 as MKAnnotation] mapView.addAnnotations(annotations)
2. Set the circle annotation view in the mapView(_:viewFor:) method.

let reuseIdentifier = "DefaultCircleAnnotationView"
let view = mapView.dequeueReusableAnnotationView(withIdentifier: reuseIdentifier) as? FUICircleAnnotationView
?? FUICircleAnnotationView(annotation: editAnnotation, reuseIdentifier: reuseIdentifier, clusteringIdentifier: nil)
view.outerColor = UIColor.preferredFioriColor(forStyle: .primary1)
view.outerWidth = 2.0
view.innerColor = UIColor.preferredFioriColor(forStyle: .tintColorTapState)
view.circleRadius = 6.0
return view

See more

@MainActor
open class FUICircleAnnotationView : MKAnnotationView

A protocol extending FUIAnnotation and MKOverlay for storing extra info that will be used by FUIMapFloorplanViewController. The properties of this protocol are managed by FUIMapFloorplanViewController. Developer is not supposed to set these properties.

See more

public protocol FUIOverlay : MKOverlay, FUIAnnotation

Geometry protocol for FUIMapView.

public protocol FUIGeometry : Hashable

A protocol adopted by an object that plays as the data model of FUIMKMapFloorplanViewController.

See more

public protocol FUIMKMapViewDataSource : AnyObject

A protocol adopted by an object which plays as the delegate of FUIMKMapFloorplanViewController.

See more

public protocol FUIMKMapViewDelegate : AnyObject

Component protocol for Map Floorplan properties

See more

public protocol FUIMapFloorplanComponent

Component protocol for FUIMapView.

public protocol FUIMapView

Map point geometry protocol conforms to FUIGeometry.

public protocol FUIPoint : FUIGeometry

Map polygon geometry protocol conforms to FUIGeometry.

public protocol FUIPolygon : FUIGeometry

Map polyline geometry protocol conforms to FUIGeometry.

public protocol FUIPolyline : FUIGeometry

Geometry layer object adds Hashable functionality and other properties.

See more

public struct FUIGeometryLayer : Hashable

Generic map Floorplan class for both MapKit and EsriMap.

See more

public struct FUIMapFloorplan