Bonjour,
Dans une fenetre de dialogue, j'insere un activeX (MicroSoft MapPoint Control 11.0) par la commande Insert ActiveX Control.
Lorsque je click OK, le controle est insére dans ma fenetre.
Lorsque je lance mon application, je ne voir pas le controle active X que je vien d'inserer.

Ai je oublier quelque chose ?

Merci pour la reponse

il faut ouvrir une carte

Merci,

En fait il faut installer completement l'activX de mappoint, c'est a dire dans le MFC class Wizzard, cree une donnee membre (une instance du control mapPoint).
A ce moment la, dans la methode OnInitDialog de ma boite de dialogue, je peux faire
_variant_t tVar;
short Var = 2;
tVar = Var;
m_MapPoint.NewMap(tVar);

bien sur il faut passe un _variant_t en arguement et la non plus c'est pas simple (ajout de #include "map.h" et #include "comutil.h" dans la cpp) et ajouter comme ressource COMSUPP.lib

Apres cela ca compile et ca fonctionne ... enfin presque.
Car la carte s'affiche bien dans ma fenetre de dialogue mais si je bouge la souris dessus, j'ai un debug assertion failed
dans le fichier occcont.cpp a la ligne 385
je sais pas trop se qui fait , regarde si le controle est active, le desactive ...

As tu une idée pour corriger se probleme ?
Merci

ouais j'ai déjà eu ce problème. pour y remédier :

dans la classe CMappointCtrl, tu rajoute la foction public (dans le.h):

inline COleControlSite* GetCtrlSite() {return m_pCtrlSite;}

lors de l'ouverture d'une carte :

SetCapture();
// ouverture nouvelle carte
VARIANT var;
var.vt = VT_INT;
var.intVal = 2; //geoMapEurope
CMap1 map = m_pMappointCtrl->NewMap(var);

// bidouille nécessaire pour éviter un plantage (problème d'activation du contrôle)
m_pCtrlCont->OnUIDeactivate(m_pMappointCtrl->GetCtrlSite());
m_pCtrlCont->OnUIActivate(NULL);
SetFocus();

ReleaseCapture();


normalement ça devrait aller (attention, le fichier MappointCtrl?h est regénéré à chaque fois que tu touche à projet->Insérer un contrôle activeX)

Merci pour la reponse
mais d'ou vient m_pCtrlCont (COleControlContainer je suppose)
pour le m_pCtrlCont->OnUIDeactivate(...... ?

Quel est l'include qu'il faut ?
Mais je ne trouve rien dans VC++

#include <../src/occimpl.h>

(necessite les sources MFC)

Super, ca fonctionne desormais correctement,
Merci beaucoup

J'ecris une appli qui lit un fichier texte contenant plusieurs centaines de villes et qui interroge MapPoint pour connaitre la distance entre chacune de ces villes.
En considerant que la distance de A à B et la même que celle de B à A, j'ai quand même n²/2 calcul de distance a faire.

Y a t il moyen de supprimer l'affichage des routes pendant le calcul des distances (ce qui devrait reduire le temps qui aest de 24 heures aujourd'hui pour 320 villes)

Merci,

Tu as quoi dans ton fichier pour les repérer ?
Si c'est les coordonnées géographiques, il vaut mieux calculer la distance toi-même.

sinon, je suppose que tu importe le fichier dans MapPoint.
importe tes villes sous forme de pushpin et réalise les calculs à partir des objets location.

void CDISComMapPointPjtDlg::OnButton1()
{
// TODO: Add your control notification handler code here

// Met a jour les variables des controles
UpdateData(TRUE);

int iArretApplication=0;

// Ouverture et lecture du fichier source
//---------------------------------------
ifstream fichierSource;
if (m_fichierSource != "")
{
fichierSource.open(m_fichierSource,ios::in);
}
else
{
MessageBox("Le nom du fichier source n'est pas valide");
return;
}

//int pos=1;

char buf[1000];
string sVilleComplete;
string sDepartement;

std::vector<string> Liste_Ville;
Liste_Ville.push_back("");

while (fichierSource.getline(buf,1000) && fichierSource.good() && !fichierSource.eof())
{
char *cbuf = strdup(buf);
string sbuf(buf);
int ibufLength = sbuf.length();

string sLegendeDepartement = "DEPARTEMENT: ";
int iLegendeDepartementLenght = sLegendeDepartement.length();
int iPosition=0;

// Decodage du nom du departement
if ((iPosition=sbuf.find(sLegendeDepartement)) >= 0)
{
sDepartement = sbuf.substr(iPosition+iLegendeDepartementLenght,ibufLength);
continue;
}

char *cNomVille = "";
char *cNomDepartement = "";
char *cNomRegion = "";
char *cNomPays = "";
char *cReste = "";

cNomVille = strtok(cbuf,"\t");
cNomDepartement = strtok(NULL,"\t");
cNomRegion = strtok(NULL,"\t");
cNomPays = strtok(NULL,"\t");
cReste = strtok(NULL,"\t");

sVilleComplete.append(cNomVille);
sVilleComplete.append(",");
sVilleComplete.append(cNomDepartement);
sVilleComplete.append(",");
sVilleComplete.append(cNomRegion);
sVilleComplete.append(",");
sVilleComplete.append(cNomPays);
sVilleComplete.append(";");

Liste_Ville.push_back(sVilleComplete);
sVilleComplete.erase();
}

fichierSource.close (); // fermeture du flot

// Creation du fichier liste de ville et correspondance des numeros
//-----------------------------------------------------------------
fstream fichierCorrespondances;
if (m_fichierCorrespondances == "")
{
CString fichier;
fichier+="Correspondances";
fichier+=sDepartement.c_str();

char fichierComplet[_MAX_PATH];
_makepath(fichierComplet, _cLecteur, _cRepertoire, fichier, ".txt" );

m_fichierCorrespondances = CString(fichierComplet);
}

if (m_fichierCorrespondances != "")
{
fichierCorrespondances.open(m_fichierCorrespondances,ios::out);
}
else
{
MessageBox("Le nom du fichier de corespondance n'est pas valide");
return;
}

// Ecriture dans le fichier
if (fichierCorrespondances.good())
{
for (int i=1; i<=Liste_Ville.size()-1; ++i)
{
fichierCorrespondances << i << " " << Liste_Ville[i].c_str() << endl; // ecrit "i nom de ville "
}
fichierCorrespondances.close ();
}

// Creation du fichier des chemins les plus courts en Km entre les villes
//-----------------------------------------------------------------------
_cMap.ZoomOut();

fstream fichierCheminsPlusCourts;
if (m_fichierCheminsPlusCourts == "")
{
CString fichier;
fichier+="CheminsPlusCourts";
fichier+=sDepartement.c_str();

char fichierComplet[_MAX_PATH];
_makepath(fichierComplet, _cLecteur, _cRepertoire, fichier, ".txt" );

m_fichierCheminsPlusCourts = CString(fichierComplet);
}
if (m_fichierCheminsPlusCourts != "")
{
fichierCheminsPlusCourts.open(m_fichierCheminsPlusCourts,ios::out);
}
else
{
MessageBox("Le nom du fichier des chemins les plus courts n'est pas valide");
return;
}

fichierCheminsPlusCourts << "NAME: " << sDepartement.c_str() << endl;
fichierCheminsPlusCourts << "TYPE: CVRP" << endl;
fichierCheminsPlusCourts << "COMMENT: " << "Chemins les plus courts" << endl;
fichierCheminsPlusCourts << "DIMENSION: " << Liste_Ville.size()-1 << endl;
fichierCheminsPlusCourts << "EDGE_WEIGHT_TYPE: EXPLICIT" << endl;
fichierCheminsPlusCourts << "EDGE_WEIGHT_FORMAT: FULL_MATRIX" << endl;
fichierCheminsPlusCourts << "EDGE_WEIGHT_SECTION" << endl;

// Creation du fichier des chemins les plus rapide en Km entre les villes
//-----------------------------------------------------------------------
fstream fichierCheminsPlusRapides;
if (m_fichierCheminsPlusRapides == "")
{
CString fichier;
fichier+="CheminsPlusRapides";
fichier+=sDepartement.c_str();

char fichierComplet[_MAX_PATH];
_makepath(fichierComplet, _cLecteur, _cRepertoire, fichier, ".txt" );

m_fichierCheminsPlusRapides = CString(fichierComplet);
}

if (m_fichierCheminsPlusRapides != "")
{
fichierCheminsPlusRapides.open(m_fichierCheminsPlusRapides,ios::out);
}
else
{
MessageBox("Le nom du fichier des chemins les plus rapides n'est pas valide");
return;
}

fichierCheminsPlusRapides << "NAME: " << sDepartement.c_str() << endl;
fichierCheminsPlusRapides << "TYPE: CVRP" << endl;
fichierCheminsPlusRapides << "COMMENT: " << "Chemins les plus rapides" << endl;
fichierCheminsPlusRapides << "DIMENSION: " << Liste_Ville.size()-1 << endl;
fichierCheminsPlusRapides << "EDGE_WEIGHT_TYPE: EXPLICIT" << endl;
fichierCheminsPlusRapides << "EDGE_WEIGHT_FORMAT: FULL_MATRIX" << endl;
fichierCheminsPlusRapides << "EDGE_WEIGHT_SECTION" << endl;

// Parcours toutes les villes de depart
//-----------------------------------------------------------------------
CRoute cRoute = _cMap.GetActiveRoute();
CWaypoints cWaypoints = cRoute.GetWaypoints();

for (int i=1; i<=Liste_Ville.size()-1; ++i)
{
m_villeDepart=Liste_Ville[i].c_str();
m_numVilleDepart = i;

// Extraction des info du depart
char* cTmp1 = strdup(Liste_Ville[i].c_str());
char* cVille1 = strtok(cTmp1,",");
char* cDepartement1 = strtok(NULL,",");
char* cRegion1 = strtok(NULL,",");
char* cPays1 = strtok(NULL,",");

for (int k=1; k<=i; ++k)
{
// Insertion des 0
fichierCheminsPlusCourts << " 0 ";
fichierCheminsPlusRapides << " 0 ";
}

for (int j=i+1; j<=Liste_Ville.size()-1; ++j)
{
m_villeArrivee=Liste_Ville[j].c_str();
m_numVilleArrivee=j;

// Extraction des info de l'arrivee
char* cTmp2 = strdup(Liste_Ville[j].c_str());
char* cVille2 = strtok(cTmp2,",");
char* cDepartement2 = strtok(NULL,",");
char* cRegion2 = strtok(NULL,",");
char* cPays2 = strtok(NULL,",");

// recherche de la ville 1
// -----------------------
// LPCTSTR ou Cstring
LPCTSTR Street1 = "";
LPCTSTR City1 = cVille1;
LPCTSTR OtherCity1 = "";
LPCTSTR Region1 = cDepartement1;
LPCTSTR ZipCode1 = "";
COleVariant Country1 = "84"; //France

cRoute.Clear();

CFindResults cResults1 = _cMap.FindAddressResults(Street1,
City1,
OtherCity1,
Region1,
ZipCode1,
Country1);

CWaypoint wStartPoint;
if (cResults1.GetCount() >= 1)
{
COleVariant numRes = "1";

LPCTSTR LocName = City1;
LPCTSTR S = "Start";
LPDISPATCH Res = cResults1.GetItem(&numRes);

wStartPoint = cWaypoints.Add(Res,LocName);
}
else
{
CString cMessage;
cMessage = City1 + CString(" introuvable");
MessageBox(cMessage);
}

// recherche de la ville 2
// -----------------------
// LPCTSTR ou Cstring
LPCTSTR Street2 = "";
LPCTSTR City2 = cVille2;
LPCTSTR OtherCity2 = "";
LPCTSTR Region2 = cDepartement2;
LPCTSTR ZipCode2 = "";
COleVariant Country2 = "84"; // France

CFindResults cResults2 = _cMap.FindAddressResults(Street2,
City2,
OtherCity2,
Region2,
ZipCode2,
Country2);

CWaypoint wStartPoint2;
if (cResults2.GetCount()>= 1)
{
COleVariant numRes2 = "1";
LPCTSTR LocName2 = City2;
LPCTSTR S2 = "Finish";

LPDISPATCH Res2 = cResults2.GetItem(&numRes2);

wStartPoint2 = cWaypoints.Add(Res2,LocName2);
}
else
{
CString cMessage;
cMessage = City2 + CString(" introuvable");
MessageBox(cMessage);
}

//----------------------------------------
//--- recherche de la route la plus rapide
//-----------------------------------------
wStartPoint.SetSegmentPreferences(2);
wStartPoint2.SetSegmentPreferences(2);
cWaypoints.Optimize();
cRoute.Calculate();
cWaypoints.Optimize();

//double dTime = cRoute.GetDrivingTime();
double distance = cRoute.GetDistance();

//----------------------------------------
//--- recherche de la route la plus courte
//-----------------------------------------
wStartPoint.SetSegmentPreferences(1);
wStartPoint2.SetSegmentPreferences(1);
cWaypoints.Optimize();
cRoute.Calculate();
cWaypoints.Optimize();

//double dTime2 = cRoute.GetDrivingTime();
double distance2 = cRoute.GetDistance();

//----------------------------------------
//--- mise à jour information interface et fichiers
//-----------------------------------------
m_cheminPlusRapide = distance;
m_cheminPlusCourt = distance2;

// Met a jour les variables des controles
UpdateData(FALSE);

fichierCheminsPlusRapides << distance << " ";
fichierCheminsPlusRapides.flush();

fichierCheminsPlusCourts << distance2 << " ";
fichierCheminsPlusCourts.flush();

// Stop de l'application en cas de click sur le bouton d'arret d'urgence
if (_bArretApplication)
{
fichierCheminsPlusRapides.close();
fichierCheminsPlusCourts.close();
break;
}


} // fin boucle en j

// Stop de l'application en cas de click sur le bouton d'arret d'urgence
if (_bArretApplication)
{
fichierCheminsPlusRapides.close();
fichierCheminsPlusCourts.close();
break;
}

fichierCheminsPlusRapides << endl;
fichierCheminsPlusCourts << endl;

} // fin boucle en i

fichierCheminsPlusRapides.close();
fichierCheminsPlusCourts.close();
}

Le bout de code ci-dessus s'arrete au bout d'un certain temps car il n'y a plus assez de memoire. Que puis je faire pour verifier les fuites de memoire dans VC++ ?

Y a t il quelque chose qui n'est aps fait correctement dans ce bout de code ?

Merci