int main(void)
{
auto renderWindow = CreateRenderWindow();
auto inputComponent = CreateInputHandler(renderWindow);
auto gameBoard = CreateGameBoard();
const auto numTiles = gameBoard->GetNumTiles();
auto renderComponent = CreateGameRenderer(*gameBoard, renderWindow);
auto boardController = std::make_unique<BoardController>(std::move(gameBoard));
auto playerController = CreatePlayerController(NUM_PLAYERS);
{
auto chooser = std::make_shared<TileChooser>(NUM_PLAYERS, 10, *renderComponent);
inputComponent->AddObserver(chooser);
chooser->ChooseTiles();
//chooser->AutoChooseTiles();
chooser->AssignTilesToPlayers(*playerController);
}
{
auto manager = std::make_shared<GameManager>(std::move(renderComponent), std::move(boardController), playerController);
inputComponent->AddObserver(manager);
playerController->ObserveTimers(manager);
manager->StartGame();
}
glfwDestroyWindow(renderWindow);
glfwTerminate();
}
CRTTransferSession::CRTTransferSession()
: RTJSBuffer()
, RTTransfer()
, m_transferSessId("")
{
AddObserver(this);
}
void iARenderer::setAreaPicker()
{
auto areaPicker = vtkSmartPointer<vtkAreaPicker>::New();
interactor->SetPicker(areaPicker);
auto style = vtkSmartPointer<MouseInteractorStyle>::New();
interactor->SetInteractorStyle(style);
auto keyPressCallback = vtkSmartPointer<vtkCallbackCommand>::New();
keyPressCallback->SetCallback(KeyPressCallbackFunction);
keyPressCallback->SetClientData(this);
interactor->AddObserver(vtkCommand::KeyReleaseEvent, keyPressCallback, 1.0);
auto pickCallback = vtkSmartPointer<vtkCallbackCommand>::New();
pickCallback->SetCallback(PickCallbackFunction);
pickCallback->SetClientData(this);
areaPicker->AddObserver(vtkCommand::EndPickEvent, pickCallback, 1.0);
finalSelection = vtkSmartPointer<vtkUnstructuredGrid>::New();
selectedMapper = vtkSmartPointer<vtkDataSetMapper>::New();
selectedMapper->SetScalarModeToUseCellData();
selectedMapper->SetInputData(finalSelection);
selectedActor = vtkSmartPointer<vtkActor>::New();
QColor c(255, 0, 0);
selectedActor->SetMapper(selectedMapper);
selectedActor->GetProperty()->SetColor(c.redF(), c.greenF(), c.blueF());
selectedActor->GetProperty()->SetRepresentationToWireframe();
selectedActor->GetProperty()->EdgeVisibilityOn();
selectedActor->GetProperty()->SetEdgeColor(c.redF(), c.greenF(), c.blueF());
selectedActor->GetProperty()->SetLineWidth(3);
}
CRTConnection::CRTConnection(void)
: m_pBuffer(NULL)
, m_nBufLen(0)
, m_nBufOffset(0)
{
m_nBufLen = kRequestBufferSizeInBytes;
m_pBuffer = new char[m_nBufLen];
AddObserver(this);
}
int main(){
auto p = new design::Observer();
auto pt = new design::Target();
pt->AddObserver(p);
pt->ChangeState();
delete p , pt;
return 1;
}
void
pcl::visualization::PCLVisualizerInteractorStyle::Initialize ()
{
modifier_ = pcl::visualization::INTERACTOR_KB_MOD_ALT;
// Set windows size (width, height) to unknown (-1)
win_height_ = win_width_ = -1;
win_pos_x_ = win_pos_y_ = 0;
max_win_height_ = max_win_width_ = -1;
// Grid is disabled by default
grid_enabled_ = false;
grid_actor_ = vtkSmartPointer<vtkLegendScaleActor>::New ();
// LUT is disabled by default
lut_enabled_ = false;
lut_actor_ = vtkSmartPointer<vtkScalarBarActor>::New ();
lut_actor_->SetTitle ("");
lut_actor_->SetOrientationToHorizontal ();
lut_actor_->SetPosition (0.05, 0.01);
lut_actor_->SetWidth (0.9);
lut_actor_->SetHeight (0.1);
lut_actor_->SetNumberOfLabels (lut_actor_->GetNumberOfLabels () * 2);
vtkSmartPointer<vtkTextProperty> prop = lut_actor_->GetLabelTextProperty ();
prop->SetFontSize (10);
lut_actor_->SetLabelTextProperty (prop);
lut_actor_->SetTitleTextProperty (prop);
// Create the image filter and PNG writer objects
wif_ = vtkSmartPointer<vtkWindowToImageFilter>::New ();
snapshot_writer_ = vtkSmartPointer<vtkPNGWriter>::New ();
snapshot_writer_->SetInputConnection (wif_->GetOutputPort ());
init_ = true;
stereo_anaglyph_mask_default_ = true;
// Start in orient mode
Superclass::CurrentMode = ORIENT_MODE;
// Add our own mouse callback before any user callback. Used for accurate point picking.
mouse_callback_ = vtkSmartPointer<pcl::visualization::PointPickingCallback>::New ();
AddObserver (vtkCommand::LeftButtonPressEvent, mouse_callback_);
AddObserver (vtkCommand::LeftButtonReleaseEvent, mouse_callback_);
}
NS_IMETHODIMP
nsHTTPIndex::AddObserver(nsIRDFObserver *aObserver)
{
nsresult rv = NS_ERROR_UNEXPECTED;
if (mInner)
{
rv = mInner->AddObserver(aObserver);
}
return(rv);
}
SupplyDropBehavior::SupplyDropBehavior( Actor* actor, World* world, Vector2& destination, SoundHandler* soundHandler )
: Behavior(actor, world), zSoundHandler(soundHandler)
{
AddObserver(this->zSoundHandler);
this->zMoving = true;
this->zSupplyCrateLanded= false;
if(!world->IsInside( destination) )
destination = this->zWorld->GetWorldCenter();
float yValue = world->CalcHeightAtWorldPos(destination);
this->zDestination = Vector3(destination.x, yValue, destination.y);
this->zVelocity = this->zDestination - this->zActor->GetPosition();
this->zVelocity.Normalize();
SupplyActor* sActor = dynamic_cast<SupplyActor*>(zActor);
if( sActor )
{
Vector3 pos = sActor->GetPosition();
//Check Heights
if( sActor->IsParachuteAttached() )
{
if( pos.y > MAX_AIRBORN_HEIGHT )
{
pos.y = MAX_AIRBORN_HEIGHT;
sActor->SetPosition(pos, false);
}
else if( pos.y < MAX_FALL_HEIGHT )
{
pos.y = MAX_FALL_HEIGHT;
sActor->SetPosition(pos);
}
}
else
{
if( pos.y > MAX_FALL_HEIGHT )
{
pos.y = MAX_FALL_HEIGHT;
sActor->SetPosition(pos, false);
}
else if( pos.y < 0 )
{
pos.y = MAX_FALL_HEIGHT;
sActor->SetPosition(pos);
}
}
}
}
DRTTransferSession::DRTTransferSession()
: RTJSBuffer()
, RTTransfer()
, m_lastUpdateTime(0)
, m_moduleId("")
, m_transferSessId("")
, m_addr("")
, m_port(0)
, m_connectingStatus(0)
{
AddObserver(this);
}
void
CDocument::AddWindow(
CDocWindow *window)
{
D_WINDOW(("CDocument::AddWindow(%s)\n", window->Name()));
CWriteLock lock(this);
AddObserver(window);
if (window->IsMasterWindow())
m_masterWindow = window;
else
m_windows.AddItem(window);
}
MRTTransferSession::MRTTransferSession(pms::ETransferModule module)
: RTTcp()
, RTJSBuffer()
, RTTransfer()
, m_lastUpdateTime(0)
, m_moduleId("")
, m_transferSessId("")
, m_module(module)
, m_addr("")
, m_port(0)
, m_connectingStatus(0)
{
AddObserver(this);
}
LRTGroupSession::LRTGroupSession()
: RTJSBuffer()
, LRTGrpConnTcp()
, m_lastUpdateTime(0)
, m_moduleId("")
, m_transferSessId("")
, m_addr("")
, m_port(0)
, m_connectingStatus(0)
, m_wNewMsgId(0)
{
AddObserver(this);
printf("LRTGroupSession was called\n");
}
void
WorkerThread::SetWorker(const WorkerThreadFriendKey& /* aKey */,
WorkerPrivate* aWorkerPrivate)
{
MOZ_ASSERT(PR_GetCurrentThread() == mThread);
if (aWorkerPrivate) {
{
MutexAutoLock lock(mLock);
MOZ_ASSERT(!mWorkerPrivate);
MOZ_ASSERT(mAcceptingNonWorkerRunnables);
mWorkerPrivate = aWorkerPrivate;
#ifdef DEBUG
mAcceptingNonWorkerRunnables = false;
#endif
}
mObserver = new Observer(aWorkerPrivate);
MOZ_ALWAYS_SUCCEEDS(AddObserver(mObserver));
} else {
MOZ_ALWAYS_SUCCEEDS(RemoveObserver(mObserver));
mObserver = nullptr;
{
MutexAutoLock lock(mLock);
MOZ_ASSERT(mWorkerPrivate);
MOZ_ASSERT(!mAcceptingNonWorkerRunnables);
MOZ_ASSERT(!mOtherThreadsDispatchingViaEventTarget,
"XPCOM Dispatch hapenning at the same time our thread is "
"being unset! This should not be possible!");
while (mOtherThreadsDispatchingViaEventTarget) {
mWorkerPrivateCondVar.Wait();
}
#ifdef DEBUG
mAcceptingNonWorkerRunnables = true;
#endif
mWorkerPrivate = nullptr;
}
}
}
void QmitkAbstractDataStorageModel::SetDataStorage(mitk::DataStorage* dataStorage)
{
if (m_DataStorage == dataStorage)
{
return;
}
if (!m_DataStorage.IsExpired())
{
auto dataStorage = m_DataStorage.Lock();
// remove Listener for the data storage itself
dataStorage->RemoveObserver(m_DataStorageDeletedTag);
// remove listener from old data storage
dataStorage->AddNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeAdded));
dataStorage->RemoveNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeRemoved));
dataStorage->ChangedNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeChanged));
}
m_DataStorage = dataStorage;
if (!m_DataStorage.IsExpired())
{
auto dataStorage = m_DataStorage.Lock();
// add Listener for the data storage itself
auto command = itk::SimpleMemberCommand<QmitkAbstractDataStorageModel>::New();
command->SetCallbackFunction(this, &QmitkAbstractDataStorageModel::SetDataStorageDeleted);
m_DataStorageDeletedTag = dataStorage->AddObserver(itk::DeleteEvent(), command);
// add listener for new data storage
dataStorage->AddNodeEvent.AddListener(
mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeAdded));
dataStorage->RemoveNodeEvent.AddListener(
mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeRemoved));
dataStorage->ChangedNodeEvent.AddListener(
mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeChanged));
}
// update model if the data storage has been changed
DataStorageChanged();
}
void TextField::OnFocusGain()
{
KeyboardCursor::GetInstance().SetHwndId(GetHwndId());
UIManager::GetInstance().DirtyRenderList(mHwndId);
auto mani = UIManager::GetInstance().GetTextManipulator();
mani->AddObserver(ITextManipulatorObserver::Default, std::dynamic_pointer_cast<ITextManipulatorObserver>(mSelfPtr.lock()));
mani->SetText(&mTextw);
auto propertyList = IsInPropertyList();
if (propertyList)
{
ListItem* listItem = (ListItem*)GetParent().get();
propertyList->SetFocusRow(listItem->GetRowIndex());
}
KeyboardCursor::GetInstance().SetScissorRegion(GetScissorRegion());
}
void QmitkAbstractNodeSelectionWidget::SetDataStorage(mitk::DataStorage* dataStorage)
{
if (m_DataStorage == dataStorage)
{
return;
}
if (!m_DataStorage.IsExpired())
{
auto oldStorage = m_DataStorage.Lock();
// remove Listener for the data storage itself
oldStorage->RemoveObserver(m_DataStorageDeletedTag);
// remove listener from old data storage
oldStorage->RemoveNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkAbstractNodeSelectionWidget, const mitk::DataNode*>(this, &QmitkAbstractNodeSelectionWidget::NodeRemovedFromStorage));
}
m_DataStorage = dataStorage;
if (!m_DataStorage.IsExpired())
{
auto newStorage = m_DataStorage.Lock();
// add Listener for the data storage itself
auto command = itk::SimpleMemberCommand<QmitkAbstractNodeSelectionWidget>::New();
command->SetCallbackFunction(this, &QmitkAbstractNodeSelectionWidget::SetDataStorageDeleted);
m_DataStorageDeletedTag = newStorage->AddObserver(itk::DeleteEvent(), command);
// add listener for new data storage
newStorage->RemoveNodeEvent.AddListener(
mitk::MessageDelegate1<QmitkAbstractNodeSelectionWidget, const mitk::DataNode*>(this, &QmitkAbstractNodeSelectionWidget::NodeRemovedFromStorage));
}
// update model if the data storage has been changed
m_DataStorage = dataStorage;
this->OnDataStorageChanged();
this->UpdateInfo();
};
zx_status_t Dispatcher::add_observer(StateObserver* observer) {
if (!is_waitable())
return ZX_ERR_NOT_SUPPORTED;
AddObserver(observer, nullptr);
return ZX_OK;
}
nsresult
AddObserver (const char *p1, C *p2, bool p3)
{
AddObserver (p1, p2, p3);
}
MultiplexingDataObserver :: MultiplexingDataObserver(IDataObserver* apObserver1, IDataObserver* apObserver2)
{
AddObserver(apObserver1);
AddObserver(apObserver2);
}
bool CDownloadQueue::SendNextUDPPacket()
{
if ( m_filelist.empty() || !theApp->serverconnect->IsUDPSocketAvailable() || !theApp->IsConnectedED2K()) {
return false;
}
// Start monitoring the server and the files list
if ( !m_queueServers.IsActive() ) {
AddObserver( &m_queueFiles );
theApp->serverlist->AddObserver( &m_queueServers );
}
bool packetSent = false;
while ( !packetSent ) {
// Get max files ids per packet for current server
int filesAllowed = GetMaxFilesPerUDPServerPacket();
if (filesAllowed < 1 || !m_udpserver || IsConnectedServer(m_udpserver)) {
// Select the next server to ask, must not be the connected server
do {
m_udpserver = m_queueServers.GetNext();
} while (IsConnectedServer(m_udpserver));
m_cRequestsSentToServer = 0;
filesAllowed = GetMaxFilesPerUDPServerPacket();
}
// Check if we have asked all servers, in which case we are done
if (m_udpserver == NULL) {
DoStopUDPRequests();
return false;
}
// Memoryfile containing the hash of every file to request
// 28bytes allocation because 16b + 4b + 8b is the worse case scenario.
CMemFile hashlist( 28 );
CPartFile* file = m_queueFiles.GetNext();
while ( file && filesAllowed ) {
uint8 status = file->GetStatus();
if ( ( status == PS_READY || status == PS_EMPTY ) && file->GetSourceCount() < thePrefs::GetMaxSourcePerFileUDP() ) {
if (file->IsLargeFile() && !m_udpserver->SupportsLargeFilesUDP()) {
AddDebugLogLineN(logDownloadQueue, wxT("UDP Request for sources on a large file ignored: server doesn't support it"));
} else {
++m_cRequestsSentToServer;
hashlist.WriteHash( file->GetFileHash() );
// See the notes on TCP packet
if ( m_udpserver->GetUDPFlags() & SRV_UDPFLG_EXT_GETSOURCES2 ) {
if (file->IsLargeFile()) {
wxASSERT(m_udpserver->SupportsLargeFilesUDP());
hashlist.WriteUInt32( 0 );
hashlist.WriteUInt64( file->GetFileSize() );
} else {
hashlist.WriteUInt32( file->GetFileSize() );
}
}
--filesAllowed;
}
}
// Avoid skipping a file if we can't send any more currently
if ( filesAllowed ) {
file = m_queueFiles.GetNext();
}
}
// See if we have anything to send
if ( hashlist.GetLength() ) {
packetSent = SendGlobGetSourcesUDPPacket(hashlist);
}
// Check if we've covered every file
if ( file == NULL ) {
// Reset the list of asked files so that the loop will start over
m_queueFiles.Reset();
// Unset the server so that the next server will be used
m_udpserver = NULL;
}
}
return true;
}
