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();
}
