GpsMarkerModule::GpsMarkerModule(Eegeo::Location::ILocationService& locationService,
Eegeo::Modules::Map::Layers::TerrainModelModule& terrainModelModule,
Eegeo::Modules::Map::MapModule& mapModule,
Eegeo::Modules::Core::RenderingModule& renderingModule,
Eegeo::Resources::Interiors::InteriorInteractionModel& interiorInteractionModel,
VisualMap::SdkModel::IVisualMapService& visualMapService,
const bool createBlueSphereViews,
ExampleAppMessaging::TMessageBus& messageBus)
: m_renderableFilters(renderingModule.GetRenderableFilters())
{
m_pModel = Eegeo_NEW(GpsMarkerModel)(locationService, interiorInteractionModel, mapModule.GetBlueSphereModule().GetBlueSphereModel());
m_pRingRenderableFactory = AccuracyRingRenderableFactory::Create(renderingModule);
m_pRingRenderable = m_pRingRenderableFactory->BuildRenderable();
m_pRingRenderable->SetColors(Eegeo::v4(18.0f/255.0f, 86.0f/255.0f, 172.0f/255.0f, 0.75f),
Eegeo::v4(18.0f/255.0f, 86.0f/255.0f, 172.0f/255.0f, 0.8f));
m_pRingView = Eegeo_NEW(AccuracyRingView)(*m_pRingRenderable);
m_renderableFilters.AddRenderableFilter(*m_pRingView);
m_pController = Eegeo_NEW(GpsMarkerController)(*m_pModel,
interiorInteractionModel,
locationService,
mapModule.GetEnvironmentFlatteningService(),
visualMapService,
mapModule.GetBlueSphereModule().GetBlueSphereView(),
mapModule.GetBlueSphereModule().GetBlueSphereAnchorView(),
createBlueSphereViews,
*m_pRingView,
messageBus);
}
void ModifiedRenderingExample::Start()
{
//MyPoolFilterCriteria implemented below... uses camera interest point as selection criteria
m_pCriteria = new ModifiedRenderingExample::MyPoolFilterCriteria(this);
//apply to filter, but lifetime responsibility is ours
m_buildingFilter.SetFilterCriteria(m_pCriteria);
//register for notifications when scene elements are added to or removed from the scene.
m_buildingRepository.AddObserver(*this);
//register as a renderable filter so that we can submit our new renderables for rendering.
m_renderableFilters.AddRenderableFilter(this);
// create alternative material to render with.
m_pAlternativeLighting = Eegeo_NEW(Eegeo::Lighting::GlobalLighting)();
m_pAlternativeShader = Eegeo::Rendering::Shaders::PackedDiffuseShader::Create(m_shaderIdGenerator.GetNextId());
m_pAlternativeMaterial = Eegeo_NEW(Eegeo::Rendering::Materials::PackedDiffuseMaterial)(
m_materialIdGenerator.GetNextId(),
"ExampleMaterial",
*m_pAlternativeShader,
*m_pAlternativeLighting,
m_placeHolderTexture.textureId,
Eegeo::Rendering::TextureMinify_NearestMipmap_Linear,
false,
false);
PopulateAlternativeRenderablesFromInitialSceneGraph();
}
WatermarkModule::WatermarkModule(Eegeo::Helpers::IIdentityProvider& identityProvider,
const std::string& appName,
const std::string& googleAnalyticsReferrerToken,
Eegeo::Resources::Interiors::InteriorSelectionModel& interiorSelectionModel,
Eegeo::Resources::Interiors::InteriorsModelRepository& interiorsModelRepository,
InteriorsExplorer::SdkModel::InteriorsExplorerModel& interiorsExplorerModel,
ExampleAppMessaging::TMessageBus& messageBus)
{
m_pViewModel = Eegeo_NEW(View::WatermarkViewModel)(identityProvider.GetNextIdentity(), false);
m_pWatermarkDataFactory = Eegeo_NEW(View::WatermarkDataFactory)(appName, googleAnalyticsReferrerToken);
m_pWatermarkDataRepository = Eegeo_NEW(View::WatermarkDataRepository)();
m_pWatermarkDataRepository->AddWatermarkData("eegeo", m_pWatermarkDataFactory->CreateDefaultEegeo());
m_pWatermarkModel = Eegeo_NEW(WatermarkModel)();
m_pWatermarkInteriorStateChangedObserver = Eegeo_NEW(WatermarkInteriorStateChangedObserver)(*m_pWatermarkModel,
interiorSelectionModel,
interiorsModelRepository,
interiorsExplorerModel,
messageBus);
AddThirdPartyWatermarkData();
}
WorldMenuController::WorldMenuController(IWorldMenuItemObservable& worldMenuItemObservable
, IWorldMenuItemViewFactory& viewFactory
, Eegeo::UI::IUIInteractionObservable& uiInteractionObservable
, Eegeo::UI::IUICameraProvider& uiCameraProvider
, Eegeo::UI::IUIQuadFactory& quadFactory
, Eegeo::UI::IUIRenderableFilter& uiRenderableFilter
, std::string texture
, int topSpriteID
, int numTilesAlong1Axes)
: m_worldMenuItemRepository(worldMenuItemObservable)
, m_viewFactory(viewFactory)
, m_uiInteractionObservable(uiInteractionObservable)
, m_uiCameraProvider(uiCameraProvider)
{
m_pWorldMenuUpView = Eegeo_NEW(WorldMenuUpView)(quadFactory, uiRenderableFilter, texture, topSpriteID, numTilesAlong1Axes);
m_menuItemsShouldRender = true;
m_isMenuShown = false;
m_worldMenuItemRepository.AddWorldMenuObserver(this);
Eegeo::v2 size(numTilesAlong1Axes,numTilesAlong1Axes);
Eegeo::v2 outMin;
Eegeo::v2 outMax;
Eegeo::UI::CalculateUV(size, 20, outMin, outMax);
Eegeo::v2 dimension = Eegeo::v2(50.f,50.f);
m_pSelectedArrow = Eegeo_NEW(Eegeo::UI::UISprite)(uiRenderableFilter,
quadFactory.CreateUIQuad(texture,
dimension,
outMin,
outMax,
Eegeo::Rendering::LayerIds::Values::AfterAll),
dimension);
m_pSelectedArrow->SetMaxAlpha(0.5f);
}
void PinsExample::CreateExamplePins()
{
// Get the repository of all currently active Pins.
Eegeo::Pins::PinRepository& pinRepository = m_pPinsModule->GetRepository();
// Create test pins and add them to the repository.
Eegeo::Pins::TPinId pin0Id = 0;
Eegeo::Space::LatLong pin0Location = Eegeo::Space::LatLong::FromDegrees(37.7858,-122.401);
int pin0Icon = 0;
Eegeo::Pins::Pin* pPin0 = Eegeo_NEW(Eegeo::Pins::Pin)(pin0Id, pin0Location, 0, pin0Icon, &m_pin0UserData);
pinRepository.AddPin(*pPin0);
// Save this pin so that we can add and remove it in AddRemovePin0()
m_pPin0 = pPin0;
Eegeo::Pins::TPinId pin1Id = 1;
Eegeo::Space::LatLong pin1Location = Eegeo::Space::LatLong::FromDegrees(37.78547,-122.40259);
int pin1Icon = 1;
Eegeo::Pins::Pin* pPin1 = Eegeo_NEW(Eegeo::Pins::Pin)(pin1Id, pin1Location, 0, pin1Icon, &m_pin1UserData);
pinRepository.AddPin(*pPin1);
Eegeo::Pins::TPinId pin2Id = 2;
Eegeo::Space::LatLong pin2Location = Eegeo::Space::LatLong::FromDegrees(37.78547,-122.402);
int pin2Icon = 2;
Eegeo::Pins::Pin* pPin2 = Eegeo_NEW(Eegeo::Pins::Pin)(pin2Id, pin2Location, 0, pin2Icon, &m_pin2UserData);
pinRepository.AddPin(*pPin2);
Eegeo::Pins::TPinId pin3Id = 3;
Eegeo::Space::LatLong pin3Location = Eegeo::Space::LatLong::FromDegrees(37.78547,-122.403);
int pin3Icon = 3;
Eegeo::Pins::Pin* pPin3 = Eegeo_NEW(Eegeo::Pins::Pin)(pin3Id, pin3Location, 30, pin3Icon, &m_pin3UserData);
pinRepository.AddPin(*pPin3);
}
AboutPageMenuModule::AboutPageMenuModule(Menu::View::IMenuViewModel& menuViewModel,
AboutPage::View::IAboutPageViewModel& aboutPageViewModel)
{
m_pAboutPageMenuModel = Eegeo_NEW(Menu::View::MenuModel)();
m_pAboutPageMenuOptionsModel = Eegeo_NEW(Menu::View::MenuOptionsModel)(*m_pAboutPageMenuModel);
m_pAboutPageMenuOptionsModel->AddItem("About", "About", "", "", Eegeo_NEW(View::AboutPageMenuOption)(menuViewModel, aboutPageViewModel));
}
void PinOverModelExample::Start()
{
pModel = Eegeo::Model::CreateFromPODFile("Test_ROBOT_ARM.pod", fileIO, renderContext.GetGLState(), &textureRequestor, "");
Eegeo_ASSERT(pModel->GetRootNode());
m_pMyModelRenderable = Eegeo_NEW (MyModelRenderable)(*pModel, renderContext, globalFogging, nullMat);
m_pMyRenderableFilter = Eegeo_NEW (MyRenderableFilter)(*m_pMyModelRenderable);
renderableFilters.AddRenderableFilter(m_pMyRenderableFilter);
}
void PinOverModelExample::Start()
{
m_pModel = Eegeo::Model::CreateFromPODFile("pin_over_model_example/Test_ROBOT_ARM.pod", m_fileIO, m_renderContext.GetGLState(), &m_textureRequestor, "pin_over_model_example/");
Eegeo_ASSERT(m_pModel->GetRootNode());
m_pMyModelRenderable = Eegeo_NEW (MyModelRenderable)(*m_pModel, m_renderContext, m_globalFogging, m_nullMat);
m_pMyRenderableFilter = Eegeo_NEW (MyRenderableFilter)(*m_pMyModelRenderable);
m_renderableFilters.AddRenderableFilter(m_pMyRenderableFilter);
}
ModalityModule::ModalityModule(ExampleAppMessaging::TMessageBus& messageBus,
const std::vector<OpenableControl::View::IOpenableControlViewModel*>& viewModels)
{
m_pModel = Eegeo_NEW(ModalityModel)();
m_pController = Eegeo_NEW(ModalityController)(*m_pModel,
viewModels);
m_pModalityObserver = Eegeo_NEW(ModalityObserver)(*m_pModel, messageBus);
}
DecartaSearchServiceModule::DecartaSearchServiceModule(Eegeo::Web::IWebLoadRequestFactory& webLoadRequestFactory,
Eegeo::Helpers::UrlHelpers::IUrlEncoder& urlEncoder)
{
m_pSearchResultParser = Eegeo_NEW(Decarta::DecartaSearchJsonParser);
m_pSearchService = Eegeo_NEW(Decarta::DecartaSearchService)(ExampleApp::DecartaApiKey,
*m_pSearchResultParser,
urlEncoder,
webLoadRequestFactory);
}
TwitterFeedService::TwitterFeedService(Eegeo::Web::IWebLoadRequestFactory& webLoadRequestFactory)
: m_accessToken("")
, m_webLoadRequestFactory(webLoadRequestFactory)
, m_pCurrentAuthRequest(NULL)
, m_pCurrentTimeLineRequest(NULL)
, m_pAuthCallback(Eegeo_NEW(Eegeo::Web::TWebLoadRequestCompletionCallback<TwitterFeedService>)(this, &TwitterFeedService::HandleAuthResponse))
, m_pTimeLineCallback(Eegeo_NEW(Eegeo::Web::TWebLoadRequestCompletionCallback<TwitterFeedService>)(this, &TwitterFeedService::HandleTimeLineResponse))
, m_currentServiceState(NOT_STARTED)
{
}
ModalBackgroundViewModule::ModalBackgroundViewModule(
AndroidNativeState& nativeState,
Modality::View::IModalityModel& modalityModel,
ExampleAppMessaging::TMessageBus& messageBus
)
{
ASSERT_UI_THREAD
m_pView = Eegeo_NEW(ModalBackgroundAggregateView)(nativeState, messageBus);
m_pController = Eegeo_NEW(Modality::View::ModalBackgroundController)(*m_pView, modalityModel);
}
CompassViewModule::CompassViewModule(
WindowsNativeState& nativeState,
ICompassViewModel& viewModel,
ExampleAppMessaging::TMessageBus& messageBus
)
{
m_pView = Eegeo_NEW(CompassView)(nativeState);
m_pController = Eegeo_NEW(CompassController)(
*m_pView,
viewModel,
messageBus);
}
GpsMarkerTutorialViewModule::GpsMarkerTutorialViewModule(WindowsNativeState& nativeState,
ExampleAppMessaging::TMessageBus& messageBus,
const GpsMarker::SdkModel::GpsMarkerModel& gpsMarkerModel,
Eegeo::Rendering::EnvironmentFlatteningService& environmentFlatteningService)
{
m_pView = Eegeo_NEW(GpsMarkerTutorialView)();
m_pController = Eegeo_NEW(GpsMarkerTutorialController)(*m_pView,
messageBus,
gpsMarkerModel,
environmentFlatteningService);
}
TagSearchViewModule* TagSearchViewModule::Create(
Menu::View::IMenuOptionsModel& menuOptionsModel,
Menu::View::IMenuViewModel& menuViewModel,
ExampleAppMessaging::TMessageBus& messageBus,
const Menu::View::IMenuReactionModel& menuReaction)
{
auto* pController = Eegeo_NEW(TagSearch::View::TagSearchSectionController)(
menuOptionsModel,
menuViewModel,
messageBus,
menuReaction);
return Eegeo_NEW(TagSearchViewModule)(pController);
}
InitialExperienceSearchResultAttractModeModule::InitialExperienceSearchResultAttractModeModule(PersistentSettings::IPersistentSettingsModel& persistentSettings,
Menu::View::IMenuViewModel& searchMenuViewModelControl,
SearchResultMenu::View::ISearchResultMenuViewModel& searchResultMenuViewModel,
ExampleAppMessaging::TMessageBus& messageBus)
: m_pInitialExperienceSearchResultAttractModeModel(NULL)
, m_pInitialExperienceSearchResultAttractModeViewController(NULL)
{
m_pInitialExperienceSearchResultAttractModeModel = Eegeo_NEW(SdkModel::InitialExperienceSearchResultAttractModeModel)(persistentSettings,
messageBus);
m_pInitialExperienceSearchResultAttractModeViewController = Eegeo_NEW(View::InitialExperienceSearchResultAttractModeViewController)(searchMenuViewModelControl,
searchResultMenuViewModel, messageBus);
}
PinsWithAttachedJavaUIExample::PinsWithAttachedJavaUIExample(
Eegeo::EegeoWorld& world,
AndroidNativeState& nativeState,
Eegeo::Rendering::RenderContext& renderContext,
Eegeo::Helpers::ITextureFileLoader& textureLoader,
Eegeo::Rendering::GlBufferPool& glBufferPool,
Eegeo::Rendering::Shaders::ShaderIdGenerator& shaderIdGenerator,
Eegeo::Rendering::Materials::MaterialIdGenerator& materialIdGenerator,
Eegeo::Rendering::VertexLayouts::VertexBindingPool& vertexBindingPool,
Eegeo::Rendering::VertexLayouts::VertexLayoutPool& vertexLayoutPool,
Eegeo::Rendering::RenderableFilters& renderableFilters,
const Eegeo::Camera::ICameraProvider& cameraProvider,
Eegeo::Resources::Terrain::Heights::TerrainHeightProvider& terrainHeightProvider,
Eegeo::Rendering::EnvironmentFlatteningService& environmentFlatteningService
)
: m_nativeState(nativeState)
, m_renderContext(renderContext)
, m_world(world)
, m_pinUserData("Pin User Data")
{
textureLoader.LoadTexture(m_pinIconsTexture, "PinIconTexturePage.png", true);
Eegeo_ASSERT(m_pinIconsTexture.textureId != 0);
int numberOfTilesAlongEachAxisOfTexturePage = 2;
m_pPinIconsTexturePageLayout = Eegeo_NEW(Eegeo::Rendering::RegularTexturePageLayout)(
numberOfTilesAlongEachAxisOfTexturePage);
// The following values specify the size and shape of the Pins within the 3D world.
int spriteWidthInMetres = 100;
int spriteHeightInMetres = 100;
m_pPinsModule = Eegeo_NEW(Eegeo::Pins::PinsModule)(
m_pinIconsTexture.textureId,
*m_pPinIconsTexturePageLayout,
glBufferPool,
shaderIdGenerator,
materialIdGenerator,
vertexBindingPool,
vertexLayoutPool,
renderableFilters,
cameraProvider,
terrainHeightProvider,
spriteWidthInMetres,
spriteHeightInMetres,
Eegeo::Rendering::LayerIds::PlaceNames,
environmentFlatteningService);
CreateExamplePins();
}
InteriorExplorerState::InteriorExplorerState(AppCamera::SdkModel::IAppCameraController& cameraController,
Eegeo::Resources::Interiors::InteriorSelectionModel& interiorSelectionModel,
Eegeo::Resources::Interiors::InteriorInteractionModel& interiorInteractionModel,
int interiorCameraHandle,
Tours::SdkModel::ITourService& tourService,
Eegeo::Streaming::CameraFrustumStreamingVolume& cameraFrustumStreamingVolume,
InteriorsExplorer::SdkModel::InteriorVisibilityUpdater& interiorVisibilityUpdater,
InteriorsExplorer::SdkModel::InteriorsExplorerModel& interiorsExplorerModel,
InteriorsExplorer::SdkModel::InteriorExplorerUserInteractionModel& interiorExplorerUserInteractionModel,
AppModes::SdkModel::IAppModeModel& appModeModel,
Eegeo::Camera::GlobeCamera::GpsGlobeCameraController& worldCameraController,
Eegeo::Resources::Interiors::InteriorsCameraController& interiorsCameraController,
Eegeo::UI::NativeUIFactories& nativeUIFactories,
MyPinCreation::SdkModel::IMyPinCreationModel& myPinCreationModel)
: m_tourService(tourService)
, m_tourStartedCallback(this, &InteriorExplorerState::OnTourStarted)
, m_interiorExplorerUserInteractionModel(interiorExplorerUserInteractionModel)
, m_appModeModel(appModeModel)
, m_worldCameraController(worldCameraController)
, m_interiorsCameraController(interiorsCameraController)
, m_nativeUIFactories(nativeUIFactories)
, m_failAlertHandler(this, &InteriorExplorerState::OnFailAlertBoxDismissed)
, m_myPinCreationModel(myPinCreationModel)
, m_lastEntryAttemptSuccessful(false)
{
m_subStates.push_back(Eegeo_NEW(InteriorsExplorer::SdkModel::States::InteriorExplorerSetupState)(*this,
cameraController,
interiorCameraHandle));
m_subStates.push_back(Eegeo_NEW(InteriorsExplorer::SdkModel::States::InteriorExplorerStreamState)(*this,
interiorInteractionModel,
cameraFrustumStreamingVolume,
interiorVisibilityUpdater));
m_subStates.push_back(Eegeo_NEW(InteriorsExplorer::SdkModel::States::InteriorExplorerViewingState)(*this,
interiorsExplorerModel,
interiorExplorerUserInteractionModel,
cameraFrustumStreamingVolume));
m_subStates.push_back(Eegeo_NEW(InteriorsExplorer::SdkModel::States::InteriorExplorerExitingState)(*this,
interiorSelectionModel,
cameraFrustumStreamingVolume,
interiorVisibilityUpdater,
interiorsExplorerModel
));
m_pSubStateMachine = Eegeo_NEW(Helpers::StateMachine)(m_subStates);
}
MyPinCreationDetailsViewModule::MyPinCreationDetailsViewModule(
WindowsNativeState& nativeState,
MyPinCreationDetails::View::IMyPinCreationDetailsViewModel& viewModel,
ExampleAppMessaging::TMessageBus& messageBus,
Metrics::IMetricsService& metricsService
)
{
m_pView = Eegeo_NEW(MyPinCreationDetailsView)(nativeState);
m_pController = Eegeo_NEW(MyPinCreationDetailsController)(*m_pView,
viewModel,
messageBus,
metricsService
);
}
MyPinCreationViewModule::MyPinCreationViewModule(
AndroidNativeState& nativeState,
IMyPinCreationInitiationViewModel& initiationViewModel,
IMyPinCreationConfirmationViewModel& confirmationViewModel,
MyPinCreationDetails::View::IMyPinCreationDetailsViewModel& detailsViewModel,
ExampleAppMessaging::TMessageBus& messageBus,
Metrics::IMetricsService& metricsService
)
{
m_pInitiationView = Eegeo_NEW(MyPinCreationInitiationView)(nativeState);
m_pInitiationController = Eegeo_NEW(MyPinCreationInitiationController)(initiationViewModel, *m_pInitiationView, confirmationViewModel, messageBus, metricsService);
m_pConfirmationView = Eegeo_NEW(MyPinCreationConfirmationView)(nativeState);
m_pConfirmationController = Eegeo_NEW(MyPinCreationConfirmationController)(confirmationViewModel, *m_pConfirmationView, detailsViewModel, messageBus, metricsService);
}
WorldPinItemModel* WorldPinsService::AddPin(IWorldPinSelectionHandler* pSelectionHandler,
IWorldPinVisibilityStateChangedHandler* pVisibilityStateChangedHandler,
const WorldPinFocusData& worldPinFocusData,
const Eegeo::Space::LatLong& location,
int iconIndex)
{
Eegeo::Pins::Pin* pPin = m_worldPinsFactory.CreatePin(location, iconIndex);
m_pinRepository.AddPin(*pPin);
Eegeo::Pins::TPinId pinId = pPin->GetId();
TPinToSelectionHandlerMapIt pinToSelectionHandlerMapIt = m_pinsToSelectionHandlers.find(pinId);
Eegeo_ASSERT(pinToSelectionHandlerMapIt == m_pinsToSelectionHandlers.end(), "Attempting to add same pin ID %d twice.\n", pinId);
m_pinsToSelectionHandlers[pinId] = pSelectionHandler;
TPinToVisiblityHandlerMapIt pinToVisiblityHandlerMapIt = m_pinsToVisbilityChangedHandlers.find(pinId);
Eegeo_ASSERT(pinToVisiblityHandlerMapIt == m_pinsToVisbilityChangedHandlers.end(), "Attempting to add same pin ID %d twice.\n", pinId);
m_pinsToVisbilityChangedHandlers[pinId] = pVisibilityStateChangedHandler;
WorldPinItemModel* model = Eegeo_NEW(WorldPinItemModel)(pinId,
pSelectionHandler,
pVisibilityStateChangedHandler,
worldPinFocusData);
m_worldPinsRepository.AddItem(model);
UpdatePinScale(*model, model->TransitionStateValue());
return model;
}
void SearchQueryPerformer::HandleSearchResultsResponseReceived(const SearchQuery& query,
const std::vector<SearchResultModel>& results)
{
// Ideally we should keep merge the new results into the old result set in a stable way, so that the
// result list doesn't jumble up when we move about and perform new searches.
std::map<SearchResultModel, size_t> currentRepoHash;
std::set<size_t> retainedResultIndices;
std::vector<SearchResultModel*> newResultTemporaryStorage;
const int topIndexBeforeAddingNewResult = static_cast<int>(m_searchResultsRepository.GetItemCount() - 1);
// First of all lets map the contents of the results repo so we can easily look results up later.
// Map the result to its index.
for(size_t i = 0; i < m_searchResultsRepository.GetItemCount(); ++ i)
{
SearchResultModel* pItem = m_searchResultsRepository.GetItemAtIndex(i);
currentRepoHash.insert(std::make_pair(*pItem, i));
}
// For the new results, check if we already have the result using the map. If so, we flag the results
// index as 'retained'. This will be used later when removing old results. If we have not seen the result
// before, add it to a new temporary vector.
for(std::vector<SearchResultModel>::const_iterator it = results.begin();
it != results.end();
++ it)
{
std::map<SearchResultModel, size_t>::iterator mapIt = currentRepoHash.find(*it);
if(mapIt == currentRepoHash.end())
{
SearchResultModel* pItem = Eegeo_NEW(SearchResultModel)(*it);
newResultTemporaryStorage.push_back(pItem);
}
else
{
retainedResultIndices.insert(mapIt->second);
}
}
// Walk backwards over the repository removing old results which are not retained, by inspection of
// the retained indices.
for(int i = topIndexBeforeAddingNewResult; i >= 0; --i)
{
if(retainedResultIndices.find(i) == retainedResultIndices.end())
{
SearchResultModel* pItem = m_searchResultsRepository.GetItemAtIndex(i);
m_searchResultsRepository.RemoveItem(pItem);
Eegeo_DELETE pItem;
}
}
// Add the new results on the end after removing the old results.
for(std::vector<SearchResultModel*>::const_iterator it = newResultTemporaryStorage.begin();
it != newResultTemporaryStorage.end();
++ it)
{
m_searchResultsRepository.AddItem(*it);
}
}
SearchResultPinBoundObject* SearchResultPinBoundObject::FromSerializedData(MyPinModel::TPinIdType pinId,
const std::string& pinMetadataJson,
const std::string& pinIconKey,
MyPinsFileIO& myPinsFileIO,
Search::SdkModel::MyPins::IMyPinsSearchResultRefreshService& myPinsSearchResultRefreshService,
ExampleAppMessaging::TMessageBus& messageBus,
ExampleAppMessaging::TSdkModelDomainEventBus& sdkModelDomainEventBus,
ExampleApp::MyPins::SdkModel::IMyPinsService& myPinsService)
{
Eegeo_ASSERT(!pinIconKey.empty());
Search::SdkModel::SearchResultModel searchResultModel;
if(!Search::SdkModel::TryDeserializeFromJson(pinMetadataJson, searchResultModel))
{
return NULL;
}
return Eegeo_NEW(SearchResultPinBoundObject)(pinId,
searchResultModel,
pinIconKey,
myPinsFileIO,
myPinsSearchResultRefreshService,
messageBus,
sdkModelDomainEventBus,
myPinsService);
}
void SearchResultSectionController::OnSearchQueryResponseReceivedMessage(const Search::SearchQueryResponseReceivedMessage& message)
{
for(int i = 0; i < m_lastAddedResults.size(); ++i)
{
const Search::SdkModel::SearchResultModel& model(m_lastAddedResults[i]);
m_menuOptions.RemoveItem(model.GetIdentifier());
}
m_lastAddedResults = message.GetResults();
// const std::vector<Search::SdkModel::SearchResultModel>& unorderedResults = message.GetResults();
OrderWrapper orderWrapper(m_order);
std::stable_sort(m_lastAddedResults.begin(), m_lastAddedResults.end(), orderWrapper);
for(int i = 0; i < m_lastAddedResults.size(); ++i)
{
const Search::SdkModel::SearchResultModel& model(m_lastAddedResults[i]);
m_menuOptions.AddItem(model.GetIdentifier(),
model.GetTitle(),
model.GetSubtitle(),
model.GetCategory(),
Eegeo_NEW(SearchResultItemModel)(model.GetTitle(),
model.GetLocation().ToECEF(),
model.IsInterior(),
model.GetBuildingId(),
model.GetFloor(),
m_searchMenuViewModel,
m_messageBus,
m_menuReaction));
}
}
void InitialExperienceModuleBase::InitialiseWithApplicationModels(WorldAreaLoader::SdkModel::IWorldAreaLoaderModel &worldAreaLoaderModel,
Menu::View::IMenuViewModel& searchMenuViewModelControl,
SearchResultMenu::View::ISearchResultMenuViewModel& searchResultMenuViewModel)
{
Eegeo_ASSERT(m_pInitialExperienceModel == NULL, "Cannot call InitialExperienceModule::InitialiseWithApplicationModels twice.\n");
std::vector<IInitialExperienceStep*> steps = CreateSteps(worldAreaLoaderModel,
searchMenuViewModelControl,
searchResultMenuViewModel);
const int lastCameraLockedStep = 1;
m_pInitialExperienceModel = Eegeo_NEW(InitialExperienceModel)(steps, lastCameraLockedStep);
m_pInitialExperienceController = Eegeo_NEW(InitialExperienceController)(*m_pInitialExperienceModel);
}
SearchResultMenuModule::SearchResultMenuModule(Search::SdkModel::ISearchResultRepository& searchResultRepository,
Search::SdkModel::ISearchQueryPerformer& searchQueryPerformer,
Eegeo::Helpers::IIdentityProvider& identityProvider,
CameraTransitions::SdkModel::ICameraTransitionController& cameraTransitionController,
Reaction::View::IReactionControllerModel& reactionControllerModel,
ExampleAppMessaging::TMessageBus& messageBus)
{
m_pModel = Eegeo_NEW(Menu::View::MenuModel)();
m_pMenuOptionsModel = Eegeo_NEW(Menu::View::MenuOptionsModel)(*m_pModel);
m_pViewModel = Eegeo_NEW(View::SearchResultMenuViewModel)(*m_pModel,
false,
identityProvider.GetNextIdentity(),
reactionControllerModel);
m_pMenuSection = Eegeo_NEW(Menu::View::MenuSectionViewModel)("Search", "search", *m_pModel, false);
m_pViewModel->AddSection(*m_pMenuSection);
m_pSearchResultRepositoryObserver = Eegeo_NEW(View::SearchResultRepositoryObserver)(
searchResultRepository,
messageBus
);
m_pSearchResultMenuItemSelectedMessageHandler = Eegeo_NEW(SearchResultMenuItemSelectedMessageHandler)(
cameraTransitionController,
messageBus
);
m_pSearchResultAddRemoveHandler = Eegeo_NEW(View::SearchResultAddRemoveHandler)(
*m_pMenuOptionsModel,
*m_pViewModel,
messageBus
);
m_pSearchResultMenuSearchQueryPerformedMessageHandler = Eegeo_NEW(View::SearchResultMenuSearchQueryPerformedMessageHandler)(
*m_pViewModel,
messageBus
);
m_pSearchResultMenuSearchQueryRemovedMessageHandler = Eegeo_NEW(View::SearchResultMenuSearchQueryRemovedMessageHandler)(
*m_pViewModel,
messageBus
);
m_pSearchResultViewClearedObserver = Eegeo_NEW(SearchResultViewClearedObserver)(searchQueryPerformer, messageBus);
}
void SecondaryMenuModule::AddMenuSection(const std::string& name,
Menu::View::IMenuModel& menuModel,
bool isExpandable)
{
Menu::View::MenuSectionViewModel* pMenuSection = Eegeo_NEW(Menu::View::MenuSectionViewModel)(name, "", menuModel, isExpandable);
m_pViewModel->AddSection(*pMenuSection);
m_sections.push_back(pMenuSection);
}
IGeoNamesSearchQuery* GeoNamesSearchQueryFactory::CreateGeoNamesSearchForQuery(const SdkModel::SearchQuery& query,
Eegeo::Helpers::ICallback0& completionCallback)
{
return Eegeo_NEW(GeoNamesSearchQuery)(m_webRequestFactory,
m_urlEncoder,
query,
completionCallback);
}
std::vector<IInitialExperienceStep*> AndroidInitialExperienceModule::CreateSteps(WorldAreaLoader::SdkModel::IWorldAreaLoaderModel& worldAreaLoaderModel)
{
std::vector<IInitialExperienceStep*> steps;
IInitialExperienceStep* pIntroStep = Eegeo_NEW(InitialExperienceIntroStep)(m_messageBus, GetPersistentSettings());
steps.push_back(pIntroStep);
IInitialExperienceStep* pWorldAreaLoaderStep = Eegeo_NEW(PreLoad::SdkModel::AndroidInitialExperiencePreLoadModel)(
m_nativeState,
worldAreaLoaderModel,
GetPersistentSettings()
);
steps.push_back(pWorldAreaLoaderStep);
return steps;
}
MyPinCreationDetailsViewModule::MyPinCreationDetailsViewModule(
AndroidNativeState& nativeState,
MyPinCreationDetails::View::IMyPinCreationDetailsViewModel& viewModel,
Eegeo::Web::IConnectivityService& connectivityService,
ExampleAppMessaging::TMessageBus& messageBus,
Metrics::IMetricsService& metricsService
)
{
m_pView = Eegeo_NEW(MyPinCreationDetailsView)(nativeState);
m_pController = Eegeo_NEW(MyPinCreationDetailsController)(*m_pView,
viewModel,
connectivityService,
messageBus,
metricsService
);
}
