Composant Delphi / Google Maps / OpenStreetMap / Leaflet  / Mappilary / Native Maps 100% Delphi 0% WebBrowser 0% Javascript

Composants

Vous êtes ici :TECNativeMap

La propriété TECNativeMap.Components permet d'ancrer des composants de type TControl de Delphi directement sur la carte.


TECMapComponents

function Add(const AName : string; const AComponent : TControl;const AAlign : TECComponentAlign):TECComponent;

Le nom doit être unique !

1
// add a checkbox at bottom left
map.components.Add('CheckBoxAlign',CheckBox2,ecLeftBottom);

Fig. 1 Add CheckBox

En pratique sous la VCL il vaut mieux utiliser un TPanel et y poser vos composants car ici le fond de la checkBox n'est pas modifié lorsque la carte bouge.

1

function Add(const AMargin : integer; const AAlign : TECComponentAlign):TECComponent;

Insere un espace de AMargin pixels

function IndexOf(const AName : string): integer;

procedure Remove(const AName : string);

procedure Remove(const AIndex : integer);

procedure Remove(const AComponent : TECComponent);

procedure Move(const CurIndex,NewIndex : integer);

Change l'ordre du composant dans sa liste, les composants sont alignés en suivant leur place dans la liste.

procedure Clear

function Count : integer;

property Component[index:integer] : TECComponent default;

Comme c'est la propriété par défaut vous pouvez simplement utiliser map.Components[index]

TECComponent

Encapsulage du TControl ancré sur la carte

procedure Remove
procedure Move(const NewIndex:integer)
property Name : string
property Component : TControl
property Align : TECComponentAlign
property Width : integer
property Height : integer
property Top : integer
property Left : integer

Top et Left ne sont utilisés que si l'alignement est ecNone

1
property Visible : boolean
property Opacity : single

Opacity varie de 0 à 1 (0.5 = 50%) et n'est disponible que sous Firemonkey

2

TECComponentAlign

Les composants peuvent être aligner sur les quatres bordures de la carte


ecTopRight , ecTopLeft empile les composants verticalement vers le haut à droite et à gauche

ecBottomRight, ecBottomLeft empilent les composants verticalement vers le bas à droite et à gauche

ecRightTop , ecLeftTop empilent les composants horizontalement vers le haut à droite et à gauche

ecRightBottom, ecLeftBottom empilent les composants horizontalement vers le bas à droite et à gauche

Création d'une barre de zoom

L'unité uecNativeMapControl déclare la classe TECCustomTool elle vous servira d'ancêtre pour vos composants

TECCustomTool

procedure Add(const Name : String; const AComponent : TControl; const AAlign : TECComponentAlign);

Ancrer le composant support sur la carte

property Align : TECComponentAlign

property Component : TECComponent

property Map : TNativeMapControl

property Layout : TECCustomToolLayout

Disposition verticale ou horizontale (ctlVertical, ctlHorizontal)

property Width : integer

property Height : integer

property Opacity : single

Opacité de 0 à 1 (uniquement pour Firemonkey)

property Visible: boolean

Composant ZoomBar

L'unité uecZoomBarComponent (FMX.uecZoomBarComponent) vous montre comment créé un composant composé de plusieurs controles Delphi, la démo BarZoom montre son utilisation

Fig. 2 Zoom Bar Component

unit uecZoomBarComponent;

interface
uses
Windows, messages,forms,sysutils,Classes, Graphics, Controls, StdCtrls, ExtCtrls,
uecNativeMapControl,uecMapUtil;

type

TZoomBarComponent = class(TECCustomTool)
private

tmZoom : TTimer;

FPanelBar : TPanel;
FNextZoom ,
FPrevZoom : Tbutton;

FButtonSize : integer;
FVerticalBar: boolean;

FInProgressiveZoom,
FProgressiveZoom : boolean;

procedure setProgressiveZoom(const value:boolean);

procedure setButtonSize(const value:integer);

procedure doNextZoom(Sender:TObject);
procedure doPrevZoom(Sender:TObject);

procedure doNextMouseDown(Sender: TObject; Button: TMouseButton;Shift: TShiftState; X, Y: integer);
procedure doNextMouseUp(Sender: TObject; Button: TMouseButton;Shift: TShiftState; X, Y: integer);

procedure tmZoomTimer(Sender: TObject);

procedure ChangeZoom;

protected
procedure setLayout(const value:TECCustomToolLayout); override;

public
constructor Create(Map : TNativeMapControl); override;
destructor Destroy; override;


property ButtonSize : integer read FButtonSize write setButtonSize;

property ProgressiveZoom : boolean read FProgressiveZoom write setProgressiveZoom;

end;

implementation

constructor TZoomBarComponent.Create(Map : TNativeMapControl);
begin

inherited;


// create zoom bar

// FPanelBar will be the support that determines the total occupancy of our component
// It will be connected to TECNativeMap

FPanelBar := TPanel.Create(nil);
FPanelBar.BevelOuter := bvNone;
FPanelBar.ParentBackground := false;
FPanelBar.Color := clBtnFace;
FPanelBar.showHint := true;


// place buttons on the panel

FNextZoom := TButton.Create(FPanelBar);
FNextZoom.Parent := FPanelBar;
FNextZoom.Caption:= '+';
FNextZoom.Hint := doubleToStrDigit(map.NumericalZoom,1);
FNextZoom.font.size := 11;
FNextZoom.onClick := doNextZoom;

FPrevZoom := TButton.Create(FPanelBar);
FPrevZoom.Parent := FPanelBar;
FPrevZoom.Caption:= '-';
FPrevZoom.Hint := doubleToStrDigit(map.NumericalZoom,1);
FPrevZoom.font.size := 11;
FPrevZoom.onClick:= doPrevZoom;


// Anchoring the panel on the map

add('ZoomBar',FPanelBar,ecTopRight);

ButtonSize := 32;

// A timer is used to manage the progressive zoom
// triggered when a zoom button is pressed.

tmZoom := TTimer.Create(nil);
tmZoom.Enabled := false;
tmZoom.Interval := 80;
tmZoom.OnTimer := tmZoomTimer;

ProgressiveZoom := true;

end;

procedure TZoomBarComponent.setProgressiveZoom(const value:boolean);
begin

FProgressiveZoom := value;

if value then
begin
FNextZoom.OnMouseDown := doNextMouseDown;
FNextZoom.OnMouseUp := doNextMouseUp;
FPrevZoom.OnMouseDown := doNextMouseDown;
FPrevZoom.OnMouseUp := doNextMouseUp;
end
else
begin
FNextZoom.OnMouseDown := nil;
FNextZoom.OnMouseUp := nil;
FPrevZoom.OnMouseDown := nil;
FPrevZoom.OnMouseUp := nil;
end;
end;

procedure TZoomBarComponent.setButtonSize(const value:integer);
begin
FButtonSize := value;

FNextZoom.width := FButtonSize;
FNextZoom.Height := FButtonSize;

FPrevZoom.width := FButtonSize;
FPrevZoom.Height := FButtonSize;

// recalculate button layout
Layout:=Layout;

end;

procedure TZoomBarComponent.setLayout(const value:TECCustomToolLayout);
begin
inherited;

FNextZoom.Top := 0;
FNextZoom.Left := 0;

if (Layout=ctlVertical) then
begin
Width := FButtonSize;
Height := 2*FButtonSize-1;
FPrevZoom.Top := FButtonSize-1;
FPrevZoom.Left := 0;
end
else
begin
Width := 2*FButtonSize-1;
Height:= FButtonSize;
FPrevZoom.Top := 0;
FPrevZoom.Left := FButtonSize-1;
end;

end;


procedure TZoomBarComponent.ChangeZoom;
begin
FNextZoom.Hint := doubleToStrDigit(map.NumericalZoom,1);
FPrevZoom.Hint := doubleToStrDigit(map.NumericalZoom,1);
end;


procedure TZoomBarComponent.doNextZoom(Sender:TObject);
begin
if not FInProgressiveZoom then
begin
Map.Zoom := Map.Zoom + 1;
ChangeZoom;
end;

FInProgressiveZoom := false;
end;

procedure TZoomBarComponent.doPrevZoom(Sender:TObject);
begin
if not FInProgressiveZoom then
begin
Map.Zoom := Map.Zoom - 1;
ChangeZoom;
end;

FInProgressiveZoom := false;
end;

// activate the timer when the button is pressed
// a progressive zoom will then be automatically performed
procedure TZoomBarComponent.doNextMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: integer);
begin
// save the button pressed to react on it.
tmZoom.Tag := integer(Sender);
tmZoom.Enabled := true;
end;
// cancel progressive zoom
procedure TZoomBarComponent.doNextMouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: integer);
begin
tmZoom.Enabled := false;
ChangeZoom;
end;
// Progressive zoom in or out
// Allows to go beyond the maximum zoom managed by the tile server
procedure TZoomBarComponent.tmZoomTimer(Sender: TObject);
begin
FInProgressiveZoom := true;

if (TButton(tmZoom.Tag) = FNextZoom) then
begin
map.ZoomScaleFactor := map.ZoomScaleFactor + 10
end
else
map.ZoomScaleFactor := map.ZoomScaleFactor - 10;

end;

Composant Légende

L'unité uecLegendPanel (FMX.uecLegendPanel) permet la gestion d'une légende pour votre carte.

Fig. 3 Demo Legend Component

TLegendComponent = class(TECCustomTool)
public
property Legend : TPanelLegend ;
end;

TPanelLegend

function Add(const ACaption:string;const AColor:TColor;const AStyle:TVisualStyle=vsFrame;const AObject:TObject=nil):TItemLegend;

function Add(const ACaption:string;const AGraphic:TGraphic;const AObject:TObject=nil):TItemLegend;


procedure Delete(index:integer);

property Count : integer

property Items[Index:integer] : TItemLegend

property VisualAlignment : TVisualAlignment
property VisualWidth : integer
property VisualWeight : integer
property ItemAlignment : TAlignment
property ItemHeight : integer
property ItemFontSize : integer
property TitleFontSize : integer
property FooterFontSize: integer
property FontName : string
property FontColor: TColor
property Title : string
property TitleAlignment : TAlignment
property Footer : string
property FooterAlignment : TAlignment
property OnItemClick : TNotifyEvent

TItemLegend

property ItemColor : TColor
property ItemBorderColor : TColor
property ItemCaption : String
property ItemGraphic : TGraphic
property ItemVisualStyle : TVisualStyle
property ItemVisualWidth : integer
property ItemVisualWeight: integer
property ItemVisualAlignment : TVisualAlignment
property ItemAlignment : TAlignment
property ItemFontSize : integer
property ItemFontName : string
property ItemFontColor : TColor
property ItemHeight: integer
property ItemObject : TObject

procedure TFormLegend.FormCreate(Sender: TObject);
begin
FLegendCp := TLegendComponent.Create(map);

FLegendCp.Legend.color := clWhite;
FLegendCp.Legend.Height:= 270;

// width of legend pictogram
FLegendCp.Legend.VisualWidth := 40;
// line thickness for styles <> vsFrame and vsFillRect
FLegendCp.Legend.VisualWeight := 3;

FLegendCp.Legend.add('Item 1',getRandomColor,vsFillRect);
FLegendCp.Legend.add('Item 2',getRandomColor,vsFrame);
FLegendCp.Legend.add('Item 3',getRandomColor,vsSolidLine);
FLegendCp.Legend.add('Item 4',getRandomColor,vsDashLine);
FLegendCp.Legend.add('Item 5',getRandomColor,vsDotLine);
FLegendCp.Legend.add('Item 6',getRandomColor,vsDashDotLine);

// add graphic
FLegendCp.Legend.add('Item 7',pins.picture.graphic);

FLegendCp.Legend.Title := 'Legend';
FLegendCp.Legend.Footer := 'Footer';

FLegendCp.Legend.OnItemClick := doOnItemLegendClick;

end;

procedure TFormLegend.FormDestroy(Sender: TObject);
begin
FLegendCp.Free;
end;

procedure TFormLegend.ckVisibleClick(Sender: TObject);
begin
FLegendCp.Visible := ckVisible.Checked;
end;

// event triggered by a click on an item
procedure TFormLegend.doOnItemLegendClick(sender : TObject);
begin
if Sender is TItemLegend then
begin
showMessage(TItemLegend(Sender).ItemCaption);
end;
end;

(*

ecTopRight , ecTopLeft stacks components vertically upwards to right and left
ecBottomRight, ecBottomLeft stack components vertically downwards on right and left
ecRightTop , ecLeftTop stack components horizontally upwards to right and left
ecRightBottom, ecLeftBottom stacks components horizontally downwards to right and left

*
)

procedure TFormLegend.RadioButton4Click(Sender: TObject);
begin
case TRadioButton(Sender).tag of
0 : FLegendCp.Align := ecTopRight;
1 : FLegendCp.Align := ecTopLeft;
2 : FLegendCp.Align := ecBottomRight;
3 : FLegendCp.Align := ecBottomLeft;
end;
end;

// item text alignment
procedure TFormLegend.RadioButton8Click(Sender: TObject);
begin
case TRadioButton(Sender).tag of
0 : FLegendCp.Legend.ItemAlignment := taLeftJustify;
1 : FLegendCp.Legend.ItemAlignment := taCenter;
2 : FLegendCp.Legend.ItemAlignment := taRightJustify;
end;
end;

// item visual alignment
procedure TFormLegend.RadioButton9Click(Sender: TObject);
begin
case TRadioButton(Sender).tag of
0 : FLegendCp.Legend.VisualAlignment := valLeft;
1 : FLegendCp.Legend.VisualAlignment := valRight;
end;
end;

Centrer un composant

Pour centrer un composant on va utilise un espacement calculé dynamiquement lors du changemet de taille de la carte

Fig. 4 Centrer la barre de zoom

interface

uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, uecNativeMapControl,uecLegendPanel,uecZoomBarComponent;

type
TForm21 = class(TForm)
map: TECNativeMap;
procedure FormCreate(Sender: TObject);
private
{ Déclarations privées }
FLegend : TLegendComponent;
FZoomBar: TZoomBarComponent;
FSpace : TECComponent;

procedure doMapResize(Sender : TObject);
public
{ Déclarations publiques }
end;

var
Form21: TForm21;

implementation

{$R *.dfm}

procedure TForm21.FormCreate(Sender: TObject);
begin
map.OnResize := doMapResize;

// align the components at the bottom of the map to the left

FLegend := TLegendComponent.Create(map);
FLegend.Legend.Add('Item 1',clRed);
FLegend.Legend.Add('Item 2',clYellow);
FLegend.Width := 80;
FLegend.Height:= 60;
FLegend.Align := ecLeftBottom;

// FSpace will act as a margin between the legend and the zoom bar.
FSpace := map.Components.Add(50,ecLeftBottom);

FZoomBar := TZoomBarComponent.Create(map);
FZoomBar.Layout := ctlHorizontal;
FZoomBar.Align := ecLeftBottom;

// calculate the gap between the two components
doMapResize(map);

end;

// Calculate spacing to center zoom bar
procedure TForm21.doMapResize(Sender : TObject);
begin
FSpace.width := (map.width div 2) - FLegend.width - (FZoomBar.width div 2);
end;

end.

Composant Mapillary

L'unité uecMapillaryComponent (FMX.uecMapillaryComponent) prend en charge l'affichage du layer Mapillary et offre un aperçu des images.

Fig. 5 Demo MapillaryComponent

procedure TMapillaryForm.FormCreate(Sender: TObject);
begin
// Pass the map that will display the Mapillary component
FMapillaryComponent := TMapillaryComponent.Create(map);
// color component
FMapillaryComponent.Color := clWhite;
// Triggered when a Mapillary image is displayed
FMapillaryComponent.OnImage := doOnImage;
// Triggered when component state, visibility, position, size change
FMapillaryComponent.OnChange:= doOnChange;

// FPosition will indicate the position of the displayed Mapillary image
FPosition := map.AddMarker(map.Latitude, map.Longitude);
FPosition.Visible := false;
FPosition.filename := GOOGLE_RED_DOT_ICON; // unit uecMapUtil also BLUE,YELLOW and GREEN
FPosition.YAnchor := 32;

// Enter your access key, see https://www.mapillary.com/developer
FMapillaryComponent.AccessToken := 'ENTER-YOUR-ACCESS-TOKEN';
FMapillaryComponent.visible := true;

end;



// Triggered when component state, visibility, position, size change
procedure TMapillaryForm.doOnChange(Sender:TObject);
begin

ckVisible.Checked := FMapillaryComponent.visible;
FPosition.Visible := FMapillaryComponent.visible;


with Memo1.Lines do
begin
BeginUpdate;
Clear;
add('Visible : '+BoolToStr(FMapillaryComponent.visible));
EndUpdate;
end

end;

// Triggered when a Mapillary image is displayed
procedure TMapillaryForm.doOnImage(Sender:TObject);
begin

if assigned(FMapillaryComponent.Image) then
begin
FPosition.SetPosition(FMapillaryComponent.Image.lat,FMapillaryComponent.Image.lng);
FPosition.setFocus;
with Memo1.Lines do
begin
BeginUpdate;
Clear;
add('Lat : '+doubleToStrDigit(FMapillaryComponent.Image.lat, 4));
add('Lng : '+doubleToStrDigit(FMapillaryComponent.Image.lng, 4));
add('Angle : '+inttostr(FMapillaryComponent.Image.Compass_angle)+ '°');
add('Time : '+DateTimeToStr(FMapillaryComponent.Image.Captured_at));
EndUpdate;
end;
end
else
Memo1.Lines.Clear;

end;

procedure TMapillaryForm.FormDestroy(Sender: TObject);
begin
FMapillaryComponent.Free;
end;

procedure TMapillaryForm.ckVisibleClick(Sender: TObject);
begin
FMapillaryComponent.Visible := ckVisible.Checked;
end;

procedure TMapillaryForm.RadioButton4Click(Sender: TObject);
begin
case TRadioButton(Sender).tag of
0 : FMapillaryComponent.Align := ecTopRight;
1 : FMapillaryComponent.Align := ecTopLeft;
2 : FMapillaryComponent.Align := ecBottomRight;
3 : FMapillaryComponent.Align := ecBottomLeft;
4 : FMapillaryComponent.Align := ecTopCenter;
5 : FMapillaryComponent.Align := ecBottomCenter;
6 : FMapillaryComponent.Align := ecLeftCenter;
7 : FMapillaryComponent.Align := ecRightCenter;
end;
end;

TMapillaryComponent

property AccessToken : string
Insérer ici votre clef d'accès obtenue sur www.mapillary.com/developer
property Bitmap : TBitmap
Bitmap contient l'image affichée par le composant.
La propriété est valide après l'événement OnImage
property BordeSize : integer
Taille de la bordure défaut 3
property CenterMapOnImage : boolean
Si True le centre de la carte est positionné sur l'image Mapillary (défaut true)
property ColorGlyph : TColor

Couleur des glyphes des boutons

Fig. 6 Match button color to image sequence color

// Triggered when a Mapillary image is displayed
procedure TMapillaryForm.doOnImage(Sender:TObject);
begin
if assigned(FMapillaryComponent.Image) then
begin
// Match button color to image sequence color
FMapillaryComponent.ColorGlyph := FMapillaryComponent.Sequence.Color;
...
end;
end;
property Image : TMapillaryImage
Accès au propriété de l'image (Lat, Lng, compass_angle, captured_at)
La propriété est valide après l'événement OnImage

Image = nil si aucune image n'est sélectionnée

2
property ImageIndex : integer
Position de l'image dans la séquence, vous pouvez changer d'image en modifiant la valeur
property Increment : integer;
Lorsque vous gardez le bouton Suivant ou Précédent enfoncé l'index de l'image est incrémenté ou décrementé de la valeur de Increment (défaut 10)

property CloseHint: string

property RunHint: string

property PauseHint: string

property FirstHint: string

property PrevHint: string

property NextHint: string

property LastHint: string

Accès à la propriété Hint des boutons

property CloseGlyph: string

property RunGlyph: string

property PauseGlyph: string

property FirstGlyph: string

property PrevGlyph: string

property NextGlyph: string

property LastGlyph: string

Accès permettant de modifier le SVG des glyphes (uniquement sous Firemonkey)
FMapillaryComponent.RunGlyph := 'M716.8 512l-384-256v512z';
property Sequence : TMapillarySequence
Contient la séquence Mapillary auquel l'image appartient
property MapillaryLayer : TECMapillaryLayer
Accès au layer Mapillary
property SequenceColorHeight : integer
Hauteur du liseret qui indique la couleur associée à la séquence contenant l'image (defaut 4)
property XYRadius : integer
Rayon de l'arrondi des coins de 0 à 10 (défaut 5)
property OnImage : TNotifyEvent
Événement déclenché après la sélection d'une image, déclenché aussi lors du passage à aucune image.
property OnChange : TNotifyEvent
Événement déclenché lors du changement d'état du composant (visible, position, taille)
property OnBeginRequest : TNotifyEvent
Déclenché juste avant une requête du layer Mapillary pour obtenir les images de la portion visible de la carte
property OnEndRequest : TNotifyEvent
Déclenché lorsque les données Mapillary de la zone sont disponible
Aller à la page
Réalisé avec la version gratuite pour les particuliers d'Help&Web