void checkForExternalDrag (DragAndDropTarget::SourceDetails& details, const Point<int>& screenPos) { if (! hasCheckedForExternalDrag) { if (Desktop::getInstance().findComponentAt (screenPos) == nullptr) { hasCheckedForExternalDrag = true; StringArray files; bool canMoveFiles = false; if (owner.shouldDropFilesWhenDraggedExternally (details, files, canMoveFiles) && files.size() > 0) { WeakReference<Component> thisWeakRef (this); setVisible (false); isDoingExternalDrag = true; if (ModifierKeys::getCurrentModifiersRealtime().isAnyMouseButtonDown()) DragAndDropContainer::performExternalDragDropOfFiles (files, canMoveFiles); delete thisWeakRef.get(); return; } } } }
bool useTimeslice (const int elapsed) { if (auto* c = proxy != nullptr ? static_cast<Component*> (proxy) : static_cast<Component*> (component)) { msElapsed += elapsed; double newProgress = msElapsed / (double) msTotal; if (newProgress >= 0 && newProgress < 1.0) { const WeakReference<AnimationTask> weakRef (this); newProgress = timeToDistance (newProgress); const double delta = (newProgress - lastProgress) / (1.0 - lastProgress); jassert (newProgress >= lastProgress); lastProgress = newProgress; if (delta < 1.0) { bool stillBusy = false; if (isMoving) { left += (destination.getX() - left) * delta; top += (destination.getY() - top) * delta; right += (destination.getRight() - right) * delta; bottom += (destination.getBottom() - bottom) * delta; const Rectangle<int> newBounds (roundToInt (left), roundToInt (top), roundToInt (right - left), roundToInt (bottom - top)); if (newBounds != destination) { c->setBounds (newBounds); stillBusy = true; } } // Check whether the animation was cancelled/deleted during // a callback during the setBounds method if (weakRef.wasObjectDeleted()) return false; if (isChangingAlpha) { alpha += (destAlpha - alpha) * delta; c->setAlpha ((float) alpha); stillBusy = true; } if (stillBusy) return true; } } } moveToFinalDestination(); return false; }
int ModalComponentManager::runEventLoopForCurrentComponent() { // This can only be run from the message thread! jassert (MessageManager::getInstance()->isThisTheMessageThread()); Component* currentlyModal = getModalComponent (0); if (currentlyModal == nullptr) return 0; WeakReference<Component> prevFocused (Component::getCurrentlyFocusedComponent()); int returnValue = 0; bool finished = false; attachCallback (currentlyModal, new ReturnValueRetriever (returnValue, finished)); JUCE_TRY { while (! finished) { if (! MessageManager::getInstance()->runDispatchLoopUntil (20)) break; } } JUCE_CATCH_EXCEPTION if (prevFocused != nullptr) prevFocused->grabKeyboardFocus(); return returnValue; }
void moveToFinalDestination() { if (component != nullptr) { const WeakReference<AnimationTask> weakRef (this); component->setAlpha ((float) destAlpha); component->setBounds (destination); if (! weakRef.wasObjectDeleted()) if (proxy != nullptr) component->setVisible (destAlpha > 0); } }
ConvexHullShape& ConvexHullShape::getDefault() { static WeakReference<ConvexHullShape> defShape; if (defShape.expired()) { defShape = static_ref_cast<ConvexHullShape>(ResourceManager::getEmpty<ConvexHullShape>("jop_default_staticmeshshape").getReference()); defShape->m_shape = std::make_unique<btCapsuleShape>(0.5f, 2.f); defShape->setPersistence(0); } return *defShape; }
void DropShadower::updateShadows() { if (reentrant) return; const ScopedValueSetter<bool> setter (reentrant, true, false); if (owner == nullptr) { shadowWindows.clear(); return; } if (owner->isShowing() && owner->getWidth() > 0 && owner->getHeight() > 0 && (Desktop::canUseSemiTransparentWindows() || owner->getParentComponent() != nullptr)) { while (shadowWindows.size() < 4) shadowWindows.add (new ShadowWindow (owner, shadow)); const int shadowEdge = jmax (shadow.offset.x, shadow.offset.y) + shadow.radius; const int x = owner->getX(); const int y = owner->getY() - shadowEdge; const int w = owner->getWidth(); const int h = owner->getHeight() + shadowEdge + shadowEdge; for (int i = 4; --i >= 0;) { // there seem to be rare situations where the dropshadower may be deleted by // callbacks during this loop, so use a weak ref to watch out for this.. WeakReference<Component> sw (shadowWindows[i]); if (sw != nullptr) { sw->setAlwaysOnTop (owner->isAlwaysOnTop()); if (sw == nullptr) return; switch (i) { case 0: sw->setBounds (x - shadowEdge, y, shadowEdge, h); break; case 1: sw->setBounds (x + w, y, shadowEdge, h); break; case 2: sw->setBounds (x, y, w, shadowEdge); break; case 3: sw->setBounds (x, owner->getBottom(), w, shadowEdge); break; default: break; } if (sw == nullptr) return; sw->toBehind (i == 3 ? owner : shadowWindows.getUnchecked (i + 1)); } } } else { shadowWindows.clear(); } }
/** * Retrieve a requires file that might be loaded for this * instance. * * @param name The name used for the requires file. * * @return The loaded requires file, or OREF_NULL if this instance * has not used the file yet. */ PackageClass *InterpreterInstance::getRequiresFile(RexxActivity *activity, RexxString *name) { WeakReference *ref = (WeakReference *)requiresFiles->get(name); if (ref != OREF_NULL) { PackageClass *resolved = (PackageClass *)ref->get(); if (resolved != OREF_NULL) { // get the guard lock on this...this will ensure that // the initializer is run before we grab this from the cache GuardLock lock(activity, resolved, ThePackageClass); return resolved; } // this was garbage collected, remove it from the table requiresFiles->remove(name); } return OREF_NULL; }
static void testWeakRefs() { assertEquals( TestObject::count, 0 ); Reference<TestObject> ref( new TestObject() ); WeakReference<TestObject> wref = ref; assertEquals( TestObject::count, 1 ); assertTrue( ref ); assertTrue( wref ); assertTrue( wref.lock() ); ref = Reference<TestObject>(); assertEquals( TestObject::count, 0 ); assertFalse( ref ); assertFalse( wref ); assertFalse( wref.lock() ); }
DebugDraw() : m_buffer(VertexBuffer::Type::ArrayBuffer, Buffer::Usage::DynamicDraw) { if (shdr.expired()) { shdr = static_ref_cast<ShaderProgram>(ResourceManager::getEmpty<ShaderProgram>("jop_physics_debug_shader").getReference()); if (!shdr->isValid()) { Shader vertex(""); vertex.load(std::string(reinterpret_cast<const char*>(jopr::physicsDebugShaderVert), sizeof(jopr::physicsDebugShaderVert)), Shader::Type::Vertex, true); Shader frag(""); frag.load(std::string(reinterpret_cast<const char*>(jopr::physicsDebugShaderFrag), sizeof(jopr::physicsDebugShaderFrag)), Shader::Type::Fragment, true); JOP_ASSERT_EVAL(shdr->load("", vertex, frag), "Failed to compile physics debug shader!"); } } }
/** * Check for a package already in the requires cache. * * @param name The name of the target. * * @return The PackageClass instance, if any. */ RoutineClass *PackageManager::checkRequiresCache(RexxString *name, ProtectedObject &result) { // first check this using the specified name. Since we need to perform checks in the // macro space, it's possible this will be loaded under the simple name. We'll need to check // table again using the fully resolved name afterward. WeakReference *requiresRef = (WeakReference *)loadedRequires->get(name); if (requiresRef != OREF_NULL) { RoutineClass *resolved = (RoutineClass *)requiresRef->get(); if (resolved != OREF_NULL) { result = resolved; return resolved; } // this was garbage collected, remove it from the table loadedRequires->remove(name); } return OREF_NULL; }
bool MainWindowList::openFile (const File& file, bool openInBackground) { for (auto* w : windows) { if (w->getProject() != nullptr && w->getProject()->getFile() == file) { w->toFront (true); return true; } } if (file.hasFileExtension (Project::projectFileExtension)) { WeakReference<Component> previousFrontWindow (getFrontmostWindow()); auto* w = getOrCreateEmptyWindow(); bool ok = w->openFile (file); if (ok) { w->makeVisible(); avoidSuperimposedWindows (w); } else { closeWindow (w); } if (openInBackground && previousFrontWindow != nullptr) previousFrontWindow->toFront (true); return ok; } if (getFrontmostWindow()->tryToOpenPIP (file)) return true; if (! isPIPFile (file) && file.exists()) return getFrontmostWindow()->openFile (file); return false; }
static int dump_socket(int argc, char** argv) { if (argc < 2) { kprintf("usage: %s [address]\n", argv[0]); return 0; } net_socket_private* socket = (net_socket_private*)parse_expression(argv[1]); kprintf("SOCKET %p\n", socket); kprintf(" family.type.protocol: %d.%d.%d\n", socket->family, socket->type, socket->protocol); WeakReference<net_socket_private> parent = socket->parent; kprintf(" parent: %p (%p)\n", parent.Get(), socket->parent); kprintf(" first protocol: %p\n", socket->first_protocol); kprintf(" first module_info: %p\n", socket->first_info); kprintf(" options: %x\n", socket->options); kprintf(" linger: %d\n", socket->linger); kprintf(" bound to device: %d\n", socket->bound_to_device); kprintf(" owner: %ld\n", socket->owner); kprintf(" max backlog: %ld\n", socket->max_backlog); kprintf(" is connected: %d\n", socket->is_connected); kprintf(" child_count: %lu\n", socket->child_count); if (socket->child_count == 0) return 0; kprintf(" pending children:\n"); SocketList::Iterator iterator = socket->pending_children.GetIterator(); while (net_socket_private* child = iterator.Next()) { print_socket_line(child, " "); } kprintf(" connected children:\n"); iterator = socket->connected_children.GetIterator(); while (net_socket_private* child = iterator.Next()) { print_socket_line(child, " "); } return 0; }
/*! The socket has been connected. It will be moved to the connected queue of its parent socket. */ status_t socket_connected(net_socket* _socket) { net_socket_private* socket = (net_socket_private*)_socket; WeakReference<net_socket_private> parent = socket->parent; if (parent.Get() == NULL) return B_BAD_VALUE; MutexLocker _(parent->lock); parent->pending_children.Remove(socket); parent->connected_children.Add(socket); socket->is_connected = true; // notify parent if (parent->select_pool) notify_select_event_pool(parent->select_pool, B_SELECT_READ); return B_OK; }
/*! The socket has been aborted. Steals the parent's reference, and releases it. */ status_t socket_aborted(net_socket* _socket) { net_socket_private* socket = (net_socket_private*)_socket; WeakReference<net_socket_private> parent = socket->parent; if (parent.Get() == NULL) return B_BAD_VALUE; MutexLocker _(parent->lock); if (socket->is_connected) parent->connected_children.Remove(socket); else parent->pending_children.Remove(socket); parent->child_count--; socket->RemoveFromParent(); return B_OK; }
ChoicePropertyComponent::ChoicePropertyComponent (ValueWithDefault& valueToControl, const String& name) : PropertyComponent (name), choices ({ "Enabled", "Disabled" }) { valueWithDefault = &valueToControl; createComboBoxWithDefault (valueWithDefault->getDefault() ? "Enabled" : "Disabled"); comboBox.getSelectedIdAsValue().referTo (Value (new RemapperValueSourceWithDefault (valueWithDefault, { true, false }))); valueWithDefault->onDefaultChange = [this] { auto selectedId = comboBox.getSelectedId(); comboBox.clear(); createComboBoxWithDefault (valueWithDefault->getDefault() ? "Enabled" : "Disabled"); comboBox.setSelectedId (selectedId); }; }
ChoicePropertyComponent::ChoicePropertyComponent (ValueWithDefault& valueToControl, const String& name, const StringArray& choiceList, const Array<var>& correspondingValues) : ChoicePropertyComponent (name, choiceList, correspondingValues) { valueWithDefault = &valueToControl; createComboBoxWithDefault (choiceList [correspondingValues.indexOf (valueWithDefault->getDefault())]); comboBox.getSelectedIdAsValue().referTo (Value (new RemapperValueSourceWithDefault (valueWithDefault, correspondingValues))); valueWithDefault->onDefaultChange = [this, choiceList, correspondingValues] { auto selectedId = comboBox.getSelectedId(); comboBox.clear(); createComboBoxWithDefault (choiceList [correspondingValues.indexOf (valueWithDefault->getDefault())]); comboBox.setSelectedId (selectedId); }; }
void show() { LookAndFeel& lf = associatedComponent != nullptr ? associatedComponent->getLookAndFeel() : LookAndFeel::getDefaultLookAndFeel(); ScopedPointer <Component> alertBox (lf.createAlertWindow (title, message, button1, button2, button3, iconType, numButtons, associatedComponent)); jassert (alertBox != nullptr); // you have to return one of these! #if JUCE_MODAL_LOOPS_PERMITTED if (modal) { returnValue = alertBox->runModalLoop(); } else #endif { alertBox->enterModalState (true, callback, true); alertBox.release(); } }
void flushLines() { using namespace jop; if (m_lines.empty() && m_points.empty()) return; // Draw lines if (!m_lines.empty()) { m_buffer.setData(m_lines.data(), m_lines.size() * sizeof(LineVec::value_type)); shdr->setUniform("u_PVMatrix", m_proj->projectionMatrix * m_proj->viewMatrix); GlState::setVertexAttribute(true, Mesh::VertexIndex::Position); GlState::setVertexAttribute(true, Mesh::VertexIndex::Color); glCheck(glVertexAttribPointer(Mesh::VertexIndex::Position, 3, GL_FLOAT, GL_FALSE, sizeof(LineVec::value_type), reinterpret_cast<void*>(0))); glCheck(glVertexAttribPointer(Mesh::VertexIndex::Color, 3, GL_FLOAT, GL_FALSE, sizeof(LineVec::value_type), reinterpret_cast<void*>(sizeof(btVector3)))); glCheck(glDrawArrays(GL_LINES, 0, m_lines.size())); m_lines.clear(); } // Draw points if (!m_points.empty()) { #ifndef JOP_OPENGL_ES glCheck(glPointSize(3)); #endif m_buffer.setData(m_points.data(), m_points.size() * sizeof(LineVec::value_type)); glCheck(glDrawArrays(GL_POINTS, 0, m_points.size())); m_points.clear(); } }
void DropShadower::updateShadows() { if (reentrant || owner == nullptr) return; ComponentPeer* const peer = owner->getPeer(); const bool isOwnerVisible = owner->isVisible() && (peer == nullptr || ! peer->isMinimised()); const bool createShadowWindows = shadowWindows.size() == 0 && owner->getWidth() > 0 && owner->getHeight() > 0 && isOwnerVisible && (Desktop::canUseSemiTransparentWindows() || owner->getParentComponent() != nullptr); { const ScopedValueSetter<bool> setter (reentrant, true, false); const int shadowEdge = jmax (shadow.offset.x, shadow.offset.y) + shadow.radius; if (createShadowWindows) { const int shadowEdge2 = shadowEdge * 2; const int imageSize = shadowEdge * 5; // keep a cached version of the image to save doing the gaussian too often int64 hash = shadow.radius ^ 0x2342dfa7; hash = hash * 101 + shadow.offset.x; hash = hash * 101 + shadow.offset.y; hash = hash * 65537 + shadow.colour.getARGB(); Image bigIm (ImageCache::getFromHashCode (hash)); if (bigIm.isNull()) { bigIm = Image (Image::ARGB, imageSize, imageSize, true); Graphics g (bigIm); Path p; p.addRectangle ((float) (shadowEdge + shadow.offset.x), (float) (shadowEdge + shadow.offset.y), (float) (imageSize - shadowEdge2), (float) (imageSize - shadowEdge2)); shadow.drawForPath (g, p); ImageCache::addImageToCache (bigIm, hash); } jassert (imageSize == bigIm.getWidth() && imageSize == bigIm.getHeight()); setShadowImage (bigIm, 0, shadowEdge, shadowEdge2, 0, 0); setShadowImage (bigIm, 1, shadowEdge, shadowEdge2, 0, imageSize - shadowEdge2); setShadowImage (bigIm, 2, shadowEdge, shadowEdge, 0, shadowEdge2); setShadowImage (bigIm, 3, shadowEdge, shadowEdge2, imageSize - shadowEdge, 0); setShadowImage (bigIm, 4, shadowEdge, shadowEdge2, imageSize - shadowEdge, imageSize - shadowEdge2); setShadowImage (bigIm, 5, shadowEdge, shadowEdge, imageSize - shadowEdge, shadowEdge2); setShadowImage (bigIm, 6, shadowEdge, shadowEdge, shadowEdge, 0); setShadowImage (bigIm, 7, shadowEdge, shadowEdge, imageSize - shadowEdge2, 0); setShadowImage (bigIm, 8, shadowEdge, shadowEdge, shadowEdge2, 0); setShadowImage (bigIm, 9, shadowEdge, shadowEdge, shadowEdge, imageSize - shadowEdge); setShadowImage (bigIm, 10, shadowEdge, shadowEdge, imageSize - shadowEdge2, imageSize - shadowEdge); setShadowImage (bigIm, 11, shadowEdge, shadowEdge, shadowEdge2, imageSize - shadowEdge); for (int i = 0; i < 4; ++i) shadowWindows.add (new ShadowWindow (*owner, i, shadowImageSections)); } if (shadowWindows.size() >= 4) { const int x = owner->getX(); const int y = owner->getY() - shadowEdge; const int w = owner->getWidth(); const int h = owner->getHeight() + shadowEdge + shadowEdge; for (int i = shadowWindows.size(); --i >= 0;) { // there seem to be rare situations where the dropshadower may be deleted by // callbacks during this loop, so use a weak ref to watch out for this.. WeakReference<Component> sw (shadowWindows[i]); if (sw != nullptr) sw->setAlwaysOnTop (owner->isAlwaysOnTop()); if (sw != nullptr) sw->setVisible (isOwnerVisible); if (sw != nullptr) { switch (i) { case 0: sw->setBounds (x - shadowEdge, y, shadowEdge, h); break; case 1: sw->setBounds (x + w, y, shadowEdge, h); break; case 2: sw->setBounds (x, y, w, shadowEdge); break; case 3: sw->setBounds (x, owner->getBottom(), w, shadowEdge); break; default: break; } } if (sw == nullptr) return; } } } if (createShadowWindows) bringShadowWindowsToFront(); }
void updateLocation (const bool canDoExternalDrag, const Point<int>& screenPos) { // (note: use a local copy of this in case a callback runs a modal loop and deletes // this object before it returns) DragAndDropTarget::SourceDetails details (sourceDetails); Point<int> newPos (screenPos + imageOffset); if (getParentComponent() != nullptr) newPos = getParentComponent()->getLocalPoint (nullptr, newPos); //if (newX != getX() || newY != getY()) { setTopLeftPosition (newPos.getX(), newPos.getY()); Point<int> relPos; DragAndDropTarget* const newTarget = findTarget (screenPos, relPos); Component* newTargetComp = dynamic_cast <Component*> (newTarget); drawImage = (newTarget == nullptr) || newTarget->shouldDrawDragImageWhenOver(); if (newTargetComp != currentlyOverComp) { DragAndDropTarget* const lastTarget = getCurrentlyOver(); if (lastTarget != nullptr && details.sourceComponent != nullptr && lastTarget->isInterestedInDragSource (details)) lastTarget->itemDragExit (details); currentlyOverComp = newTargetComp; if (newTarget != nullptr) { details.localPosition = relPos; if (newTarget->isInterestedInDragSource (details)) newTarget->itemDragEnter (details); } } { DragAndDropTarget* const target = getCurrentlyOver(); if (target != nullptr) { details.localPosition = relPos; if (target->isInterestedInDragSource (details)) target->itemDragMove (details); } } if (getCurrentlyOver() == nullptr && canDoExternalDrag && ! hasCheckedForExternalDrag) { if (Desktop::getInstance().findComponentAt (screenPos) == nullptr) { hasCheckedForExternalDrag = true; StringArray files; bool canMoveFiles = false; if (owner->shouldDropFilesWhenDraggedExternally (details, files, canMoveFiles) && files.size() > 0) { WeakReference<Component> thisWeakRef (this); setVisible (false); if (ModifierKeys::getCurrentModifiersRealtime().isAnyMouseButtonDown()) DragAndDropContainer::performExternalDragDropOfFiles (files, canMoveFiles); delete thisWeakRef.get(); return; } } } } }
// LIVE -> DEINITING -> DEINITED -> FREED -> DEAD, with side table TEST(LongRefcountingTest, lifecycle_live_deiniting_deinited_freed_with_side_DeathTest) { ::testing::FLAGS_gtest_death_test_style = "threadsafe"; size_t deinited = 0; auto object = allocTestObject(&deinited, 1); object->CheckLifecycle = true; // Object is LIVE EXPECT_ALLOCATED(object); // RC tested elsewhere // URC load OK // URC increment OK // URC decrement OK swift_unownedCheck(object); swift_unownedRetain(object); swift_unownedCheck(object); swift_unownedRetain(object); swift_unownedCheck(object); swift_unownedRetain(object); swift_unownedCheck(object); swift_unownedRelease(object); swift_unownedCheck(object); // Remaining releases are performed during DEINITED. // WRC load can't happen // WRC increment adds side table // WRC decrement can't happen WeakReference w; swift_weakInit(&w, object); // Object is LIVE with side table void *side = w.getSideTable(); EXPECT_ALLOCATED(side); WeakReference w_deinit; swift_weakInit(&w_deinit, object); object->WeakRef = &w_deinit; // destroyed during deinit // RC increment ok // RC decrement ok swift_retain(object); swift_retain(object); swift_retain(object); swift_release(object); swift_release(object); swift_release(object); // URC load OK // URC increment OK // URC decrement OK swift_unownedCheck(object); swift_unownedRetain(object); swift_unownedCheck(object); swift_unownedRetain(object); swift_unownedCheck(object); swift_unownedRetain(object); swift_unownedCheck(object); swift_unownedRelease(object); swift_unownedCheck(object); swift_unownedRelease(object); swift_unownedCheck(object); swift_unownedRelease(object); swift_unownedCheck(object); // WRC load OK // WRC increment OK // WRC decrement OK WeakReference w2; swift_weakInit(&w2, object); HeapObject *weakValue = swift_weakLoadStrong(&w2); EXPECT_EQ(weakValue, object); swift_release(weakValue); weakValue = swift_weakLoadStrong(&w); EXPECT_EQ(weakValue, object); swift_release(weakValue); // RC == 1 // URC == 3 // WRC == 3 swift_release(object); // DEINITING is in here // Object is DEINITED // RC == 0 // URC == 2 // WRC == 3 EXPECT_EQ(1u, deinited); EXPECT_ALLOCATED(object); EXPECT_ALLOCATED(side); // RC can't happen // WRC load is nil // WRC increment can't happen // WRC decrement OK weakValue = swift_weakTakeStrong(&w2); EXPECT_EQ(0, weakValue); // URC load crashes // URC increment can't happen // URC decrement OK ASSERT_DEATH(swift_unownedCheck(object), "Attempted to read an unowned reference"); swift_unownedRelease(object); EXPECT_ALLOCATED(object); EXPECT_ALLOCATED(side); // RC == 0 // URC == 1 // WRC == 2 swift_unownedRelease(object); // Object is FREED // RC == 0 // URC == 0 // WRC == 1 EXPECT_EQ(1u, deinited); EXPECT_UNALLOCATED(object); EXPECT_ALLOCATED(side); // RC can't happen // URC can't happen // WRC load is nil // WRC increment can't happen // WRC decrement OK // RC == 0 // URC == 0 // WRC == 1 weakValue = swift_weakTakeStrong(&w); // Object is DEAD // RC == 0 // URC == 0 // WRC == 0 EXPECT_UNALLOCATED(side); EXPECT_EQ(0, weakValue); }
// LIVE -> DEINITING -> DEAD, with side table TEST(LongRefcountingTest, lifecycle_live_deiniting_with_side_DeathTest) { ::testing::FLAGS_gtest_death_test_style = "threadsafe"; size_t deinited = 0; auto object = allocTestObject(&deinited, 1); object->CheckLifecycle = true; // Object is LIVE EXPECT_ALLOCATED(object); // RC tested elsewhere // URC load OK // URC increment OK // URC decrement OK swift_unownedCheck(object); swift_unownedRetain(object); swift_unownedCheck(object); swift_unownedRetain(object); swift_unownedCheck(object); swift_unownedRetain(object); swift_unownedCheck(object); swift_unownedRelease(object); swift_unownedCheck(object); // Remaining releases are performed after the side table is allocated. // WRC load can't happen // WRC increment adds side table // WRC decrement can't happen WeakReference w; swift_weakInit(&w, object); // Object is LIVE with side table void *side = w.getSideTable(); EXPECT_ALLOCATED(side); WeakReference w_deinit; swift_weakInit(&w_deinit, object); object->WeakRef = &w_deinit; // destroyed during deinit // RC increment ok // RC decrement ok swift_retain(object); swift_retain(object); swift_retain(object); swift_release(object); swift_release(object); swift_release(object); // URC load OK // URC increment OK // URC decrement OK swift_unownedCheck(object); swift_unownedRetain(object); swift_unownedCheck(object); swift_unownedRetain(object); swift_unownedCheck(object); swift_unownedRetain(object); swift_unownedCheck(object); swift_unownedRelease(object); swift_unownedCheck(object); swift_unownedRelease(object); swift_unownedCheck(object); swift_unownedRelease(object); swift_unownedCheck(object); // ...and balancing from previously... swift_unownedRelease(object); swift_unownedCheck(object); swift_unownedRelease(object); swift_unownedCheck(object); // WRC load OK // WRC increment OK // WRC decrement OK WeakReference w2; swift_weakInit(&w2, object); HeapObject *weakValue = swift_weakTakeStrong(&w2); EXPECT_EQ(weakValue, object); swift_release(weakValue); weakValue = swift_weakTakeStrong(&w); EXPECT_EQ(weakValue, object); swift_release(weakValue); // RC == 1 // URC == 1 // WRC == 1 swift_release(object); // DEINITING is in here // Object is DEAD // RC == 0 // URC == 0 // WRC == 0 EXPECT_UNALLOCATED(side); EXPECT_UNALLOCATED(object); }
var Parameter::getValueFromScript(const juce::var::NativeFunctionArgs & a) { WeakReference<Parameter> c = getObjectFromJS<Parameter>(a); if (c == nullptr || c.wasObjectDeleted()) return var(); return c->getValue(); }
DragAndDropTarget* getCurrentlyOver() { return dynamic_cast <DragAndDropTarget*> (currentlyOverComp.get()); }
bool FileChooser::showDialog (const bool selectsDirectories, const bool selectsFiles, const bool isSave, const bool warnAboutOverwritingExistingFiles, const bool selectMultipleFiles, FilePreviewComponent* const previewComponent) { WeakReference<Component> previouslyFocused (Component::getCurrentlyFocusedComponent()); results.clear(); // the preview component needs to be the right size before you pass it in here.. jassert (previewComponent == nullptr || (previewComponent->getWidth() > 10 && previewComponent->getHeight() > 10)); #if JUCE_WINDOWS if (useNativeDialogBox && ! (selectsFiles && selectsDirectories)) #elif JUCE_MAC || JUCE_LINUX if (useNativeDialogBox && (previewComponent == nullptr)) #else if (false) #endif { showPlatformDialog (results, title, startingFile, filters, selectsDirectories, selectsFiles, isSave, warnAboutOverwritingExistingFiles, selectMultipleFiles, previewComponent); } else { WildcardFileFilter wildcard (selectsFiles ? filters : String::empty, selectsDirectories ? "*" : String::empty, String::empty); int flags = isSave ? FileBrowserComponent::saveMode : FileBrowserComponent::openMode; if (selectsFiles) flags |= FileBrowserComponent::canSelectFiles; if (selectsDirectories) { flags |= FileBrowserComponent::canSelectDirectories; if (! isSave) flags |= FileBrowserComponent::filenameBoxIsReadOnly; } if (selectMultipleFiles) flags |= FileBrowserComponent::canSelectMultipleItems; FileBrowserComponent browserComponent (flags, startingFile, &wildcard, previewComponent); FileChooserDialogBox box (title, String::empty, browserComponent, warnAboutOverwritingExistingFiles, browserComponent.findColour (AlertWindow::backgroundColourId)); if (box.show()) { for (int i = 0; i < browserComponent.getNumSelectedFiles(); ++i) results.add (browserComponent.getSelectedFile (i)); } } if (previouslyFocused != nullptr) previouslyFocused->grabKeyboardFocus(); return results.size() > 0; }
static void treeViewMenuItemChosen (int resultCode, WeakReference<JucerTreeViewBase> item) { if (item != nullptr) item->handlePopupMenuResult (resultCode); }
void DropShadower::updateShadows() { if (reentrant || owner == nullptr) return; ComponentPeer* const peer = owner->getPeer(); const bool isOwnerVisible = owner->isVisible() && (peer == nullptr || ! peer->isMinimised()); const bool createShadowWindows = shadowWindows.size() == 0 && owner->getWidth() > 0 && owner->getHeight() > 0 && isOwnerVisible && (Desktop::canUseSemiTransparentWindows() || owner->getParentComponent() != nullptr); { const ScopedValueSetter<bool> setter (reentrant, true, false); const int shadowEdge = jmax (xOffset, yOffset) + (int) blurRadius; if (createShadowWindows) { // keep a cached version of the image to save doing the gaussian too often String imageId; imageId << shadowEdge << ',' << xOffset << ',' << yOffset << ',' << alpha; const int hash = imageId.hashCode(); Image bigIm (ImageCache::getFromHashCode (hash)); if (bigIm.isNull()) { bigIm = Image (Image::ARGB, shadowEdge * 5, shadowEdge * 5, true, Image::NativeImage); Graphics bigG (bigIm); bigG.setColour (Colours::black.withAlpha (alpha)); bigG.fillRect (shadowEdge + xOffset, shadowEdge + yOffset, bigIm.getWidth() - (shadowEdge * 2), bigIm.getHeight() - (shadowEdge * 2)); ImageConvolutionKernel blurKernel (roundToInt (blurRadius * 2.0f)); blurKernel.createGaussianBlur (blurRadius); blurKernel.applyToImage (bigIm, bigIm, Rectangle<int> (xOffset, yOffset, bigIm.getWidth(), bigIm.getHeight())); ImageCache::addImageToCache (bigIm, hash); } const int iw = bigIm.getWidth(); const int ih = bigIm.getHeight(); const int shadowEdge2 = shadowEdge * 2; setShadowImage (bigIm, 0, shadowEdge, shadowEdge2, 0, 0); setShadowImage (bigIm, 1, shadowEdge, shadowEdge2, 0, ih - shadowEdge2); setShadowImage (bigIm, 2, shadowEdge, shadowEdge, 0, shadowEdge2); setShadowImage (bigIm, 3, shadowEdge, shadowEdge2, iw - shadowEdge, 0); setShadowImage (bigIm, 4, shadowEdge, shadowEdge2, iw - shadowEdge, ih - shadowEdge2); setShadowImage (bigIm, 5, shadowEdge, shadowEdge, iw - shadowEdge, shadowEdge2); setShadowImage (bigIm, 6, shadowEdge, shadowEdge, shadowEdge, 0); setShadowImage (bigIm, 7, shadowEdge, shadowEdge, iw - shadowEdge2, 0); setShadowImage (bigIm, 8, shadowEdge, shadowEdge, shadowEdge2, 0); setShadowImage (bigIm, 9, shadowEdge, shadowEdge, shadowEdge, ih - shadowEdge); setShadowImage (bigIm, 10, shadowEdge, shadowEdge, iw - shadowEdge2, ih - shadowEdge); setShadowImage (bigIm, 11, shadowEdge, shadowEdge, shadowEdge2, ih - shadowEdge); for (int i = 0; i < 4; ++i) shadowWindows.add (new ShadowWindow (*owner, i, shadowImageSections)); } if (shadowWindows.size() >= 4) { const int x = owner->getX(); const int y = owner->getY() - shadowEdge; const int w = owner->getWidth(); const int h = owner->getHeight() + shadowEdge + shadowEdge; for (int i = shadowWindows.size(); --i >= 0;) { // there seem to be rare situations where the dropshadower may be deleted by // callbacks during this loop, so use a weak ref to watch out for this.. WeakReference<Component> sw (shadowWindows[i]); if (sw != nullptr) sw->setAlwaysOnTop (owner->isAlwaysOnTop()); if (sw != nullptr) sw->setVisible (isOwnerVisible); if (sw != nullptr) { switch (i) { case 0: sw->setBounds (x - shadowEdge, y, shadowEdge, h); break; case 1: sw->setBounds (x + w, y, shadowEdge, h); break; case 2: sw->setBounds (x, y, w, shadowEdge); break; case 3: sw->setBounds (x, owner->getBottom(), w, shadowEdge); break; default: break; } } if (sw == nullptr) return; } } } if (createShadowWindows) bringShadowWindowsToFront(); }