Gui::~Gui()
{
config.removeListeners(mConfigListener);
delete2(mConfigListener);
if (mMouseCursors)
{
mMouseCursors->decRef();
mMouseCursors = nullptr;
}
if (windowContainer)
windowContainer->slowLogic();
delete getTop();
delete2(mGuiFont);
delete2(boldFont);
delete2(mHelpFont);
delete2(mSecureFont);
delete2(mInfoParticleFont);
delete2(mNpcFont);
delete2(guiInput);
delete2(theme);
if (Widget::widgetExists(mTop))
setTop(nullptr);
delete2(mFocusHandler);
}
Pointer &
Pointer::join(const Domain &value)
{
if (isTop())
return *this;
if (value.isBottom())
return *this;
if (value.isTop())
{
setTop();
return *this;
}
const Pointer &vv = llvm::cast<Pointer>(value);
CANAL_ASSERT_MSG(&vv.mType == &mType,
"Unexpected different types in a pointer merge ("
<< Canal::toString(vv.mType) << " != "
<< Canal::toString(mType) << ")");
PlaceTargetMap::const_iterator valueit = vv.mTargets.begin();
for (; valueit != vv.mTargets.end(); ++valueit)
{
PlaceTargetMap::iterator it = mTargets.find(valueit->first);
if (it == mTargets.end())
mTargets.insert(PlaceTargetMap::value_type(
valueit->first, new Target(*valueit->second)));
else
it->second->join(*valueit->second);
}
return *this;
}
void Rect::expand( const QPoint& point )
{
setLeft ( qMin(point.x(), left() ) );
setRight ( qMax(point.x(), right() ) );
setTop ( qMax(point.y(), top() ) );
setBottom( qMin(point.y(), bottom()) );
};
void SettingsPageComponent::resized() {
auto bounds = getLocalBounds();
int numRows = 4;
double rowProp = 0.6/numRows;
{
for (int i = 0, j = 0; i < numRows; ++i) {
if (i > 0) verticalLayout.setItemLayout(j++, 0, -1, -1);
verticalLayout.setItemLayout(j++, -rowProp, -rowProp, -rowProp);
}
Component *settingsItems[] = {
wifiCategoryItem, nullptr,
screenBrightnessSlider, nullptr,
volumeSlider, nullptr,
advanced
};
int numItems = sizeof(settingsItems) / sizeof(Component*);
auto b = bounds;
b.setLeft(60);
b.setTop(30);
b.setHeight(b.getHeight() - 30);
b.setWidth(b.getWidth() - 60);
verticalLayout.layOutComponents(settingsItems, numItems, b.getX(), b.getY(), b.getWidth(),
b.getHeight(), true, true);
}
mainPage->setBounds(bounds);
backButton->setBounds(bounds.getX(), bounds.getY(), 60, bounds.getHeight());
}
static RenderStyle createFullScreenStyle()
{
auto fullscreenStyle = RenderStyle::create();
// Create a stacking context:
fullscreenStyle.setZIndex(INT_MAX);
fullscreenStyle.setFontDescription({ });
fullscreenStyle.fontCascade().update(nullptr);
fullscreenStyle.setDisplay(FLEX);
fullscreenStyle.setJustifyContentPosition(ContentPositionCenter);
fullscreenStyle.setAlignItemsPosition(ItemPositionCenter);
fullscreenStyle.setFlexDirection(FlowColumn);
fullscreenStyle.setPosition(FixedPosition);
fullscreenStyle.setWidth(Length(100.0, Percent));
fullscreenStyle.setHeight(Length(100.0, Percent));
fullscreenStyle.setLeft(Length(0, WebCore::Fixed));
fullscreenStyle.setTop(Length(0, WebCore::Fixed));
fullscreenStyle.setBackgroundColor(Color::black);
return fullscreenStyle;
}
bool QDoubleValidator::qt_property( int id, int f, QVariant* v)
{
switch ( id - staticMetaObject()->propertyOffset() ) {
case 0: switch( f ) {
case 0: setBottom(v->asDouble()); break;
case 1: *v = QVariant( this->bottom() ); break;
case 3: case 4: case 5: break;
default: return FALSE;
} break;
case 1: switch( f ) {
case 0: setTop(v->asDouble()); break;
case 1: *v = QVariant( this->top() ); break;
case 3: case 4: case 5: break;
default: return FALSE;
} break;
case 2: switch( f ) {
case 0: setDecimals(v->asInt()); break;
case 1: *v = QVariant( this->decimals() ); break;
case 3: case 4: case 5: break;
default: return FALSE;
} break;
default:
return QValidator::qt_property( id, f, v );
}
return TRUE;
}
bool AnchorsBase::setAnchor(const Qt::AnchorPoint &p, QWidget *target, const Qt::AnchorPoint &point)
{
if (!target) {
return false;
}
AnchorsBase *base = AnchorsBasePrivate::getWidgetAnchorsBase(target);
if (!base) {
base = new AnchorsBase(target);
}
const AnchorInfo *info = base->d_func()->getInfoByPoint(point);
switch (p) {
case Qt::AnchorTop:
return setTop(info);
case Qt::AnchorBottom:
return setBottom(info);
case Qt::AnchorLeft:
return setLeft(info);
case Qt::AnchorRight:
return setRight(info);
case Qt::AnchorHorizontalCenter:
return setHorizontalCenter(info);
case Qt::AnchorVerticalCenter:
return setVerticalCenter(info);
default:
return false;
}
}
void GfxCropDialog::bindEvents()
{
// Left text box
text_left_->Bind(wxEVT_TEXT_ENTER, &GfxCropDialog::onTextEnter, this);
text_left_->Bind(wxEVT_KILL_FOCUS, [&](wxFocusEvent& e) {
setLeft();
e.Skip();
});
// Top text box
text_top_->Bind(wxEVT_TEXT_ENTER, &GfxCropDialog::onTextEnter, this);
text_top_->Bind(wxEVT_KILL_FOCUS, [&](wxFocusEvent& e) {
setTop();
e.Skip();
});
// Right text box
text_right_->Bind(wxEVT_TEXT_ENTER, &GfxCropDialog::onTextEnter, this);
text_right_->Bind(wxEVT_KILL_FOCUS, [&](wxFocusEvent& e) {
setRight();
e.Skip();
});
// Bottom text box
text_bottom_->Bind(wxEVT_TEXT_ENTER, &GfxCropDialog::onTextEnter, this);
text_bottom_->Bind(wxEVT_KILL_FOCUS, [&](wxFocusEvent& e) {
setBottom();
e.Skip();
});
// Absolute/Relative radio buttons
rb_absolute_->Bind(wxEVT_RADIOBUTTON, [&](wxCommandEvent&) { updateValues(); });
rb_relative_->Bind(wxEVT_RADIOBUTTON, [&](wxCommandEvent&) { updateValues(); });
}
PixelRegion PixelRegion::globalCut(Side side, int p) {
if (!lineIntersect(side, p)) {
return PixelRegion({ 0, 0 }, { 0, 0 });
}
PixelRegion cutOff(*this);
int cutSize = 0;
switch (side) {
case LEFT:
setLeft(p);
cutOff.setRight(p - cutSize);
break;
case TOP:
setTop(p);
cutOff.setBottom(p - cutSize);
break;
case RIGHT:
setRight(p);
cutOff.setLeft(p + cutSize);
break;
case BOTTOM:
setBottom(p);
cutOff.setTop(p + cutSize);
break;
}
return cutOff;
}
void GuiSetBorder::mousePressEvent(QMouseEvent * e)
{
if (e->y() > e->x()) {
if (e->y() < height() - e->x()) {
if (left_.enabled) {
setLeft(!left_.set);
// emit signal
leftSet(left_.set);
}
} else {
if (bottom_.enabled) {
setBottom(!bottom_.set);
// emit signal
bottomSet(bottom_.set);
}
}
} else {
if (e->y() < height() - e->x()) {
if (top_.enabled) {
setTop(!top_.set);
// emit signal
topSet(top_.set);
}
} else {
if (right_.enabled) {
setRight(!right_.set);
// emit signal
rightSet(right_.set);
}
}
}
update();
// emit signal
clicked();
}
void GuiSetBorder::setAll(bool border)
{
setLeft(border);
setRight(border);
setTop(border);
setBottom(border);
}
std::shared_ptr<Wt::WValidator> createBirthValidator() {
auto v = std::make_shared<Wt::WDateValidator>();
v->setBottom(Wt::WDate(1900, 1, 1));
v->setTop(Wt::WDate::currentDate());
v->setFormat("dd/MM/yyyy");
v->setMandatory(true);
return v;
}
void PixelRegion::setSide(Side side, int pos) {
switch (side) {
case LEFT: setLeft(pos); break;
case TOP: setTop(pos); break;
case RIGHT: setRight(pos); break;
case BOTTOM: setBottom(pos); break;
}
}
bool GFrame::onMouseMsg( MouseMsg const& msg )
{
BaseClass::onMouseMsg( msg );
static int x , y;
static bool needMove = false;
if ( msg.onLeftDown() )
{
setTop();
if ( msg.getPos().y > getWorldPos().y &&
msg.getPos().y < getWorldPos().y + TopSideHeight )
{
x = msg.x();
y = msg.y();
getManager()->captureMouse( this );
needMove = true;
}
}
else if ( msg.onRightDown() )
{
if ( msg.getPos().y > getWorldPos().y &&
msg.getPos().y < getWorldPos().y + TopSideHeight )
{
mbMiniSize = !mbMiniSize;
if ( mbMiniSize )
{
mPrevSize = getSize();
setSize( Vec2i( mPrevSize.x , TopSideHeight ) );
mClipEnable = true;
}
else
{
setSize( mPrevSize );
mClipEnable = false;
}
}
}
else if ( msg.onLeftUp() )
{
needMove = false;
getManager()->releaseMouse();
}
if ( needMove )
{
if ( msg.isLeftDown() && msg.isDraging() )
{
Vec2i pos = getPos() +Vec2i( msg.x() - x , msg.y() - y );
setPos( pos );
x = msg.x();
y = msg.y();
}
}
return false;
}
QRectF ScriptEditorItem::boundingRect() const
{
auto br = QGraphicsTextItem::boundingRect();
br.setBottom(br.bottom() + border);
br.setTop(br.top() - border);
br.setLeft(br.left() - border);
br.setRight(br.right() + border);
return br;
}
Gui::~Gui()
{
if (Widget::widgetExists(mTop))
{
setTop(NULL);
}
delete mFocusHandler;
}
void WDateEdit::render(WFlags<RenderFlag> flags)
{
if (flags & RenderFull) {
defineJavaScript();
setTop(validator()->top());
setBottom(validator()->bottom());
setFormat(validator()->format());
}
WLineEdit::render(flags);
}
// -----------------------------------------------------------------------------
// Called when enter is pressed in a text box
// -----------------------------------------------------------------------------
void GfxCropDialog::onTextEnter(wxCommandEvent& e)
{
if (e.GetEventObject() == text_left_)
setLeft();
else if (e.GetEventObject() == text_top_)
setTop();
else if (e.GetEventObject() == text_right_)
setRight();
else if (e.GetEventObject() == text_bottom_)
setBottom();
}
void WDateEdit::render(WFlags<RenderFlag> flags)
{
if (flags & RenderFull) {
defineJavaScript();
WDateValidator *dv = validator();
if (dv) {
setTop(dv->top());
setBottom(dv->bottom());
setFormat(dv->format());
}
}
WLineEdit::render(flags);
}
void WDatePicker::render(WFlags<RenderFlag> flags)
{
if (flags & RenderFull) {
WDateValidator *dv = dynamic_cast<WDateValidator *>(forEdit_->validator());
if (dv) {
setTop(dv->top());
setBottom(dv->bottom());
setFormat(dv->format());
}
}
WCompositeWidget::render(flags);
}
std::shared_ptr<CameraOrthographic> Scene::createOrthographicCamera(GameObject *cameraObject) {
if (!cameraObject ) {
cameraObject = createGameObject("OrthographicCamera");
}
auto cam = cameraObject->addComponent<CameraOrthographic>();
glm::ivec2 dim = Engine::context()->getContextSurfaceDim();
cam->setNear(-10);
cam->setFar(10);
cam->setLeft(-dim.x/2);
cam->setRight(dim.x/2);
cam->setBottom(-dim.y/2);
cam->setTop(dim.y/2);
cam->setClearColor(glm::vec4(0,0,0,1));
return cam;
}
/*!
* Defines an orthographic projection based on \a left, \a right, \a bottom, \a
* top, \a nearPlane, \a farPlane.
*/
void QCameraLens::setFrustumProjection(float left, float right,
float bottom, float top,
float nearPlane, float farPlane)
{
Q_D(QCameraLens);
bool block = blockNotifications(true);
setLeft(left);
setRight(right);
setBottom(bottom);
setTop(top);
setNearPlane(nearPlane);
setFarPlane(farPlane);
setProjectionType(FrustumProjection);
blockNotifications(block);
d->updateProjectionMatrix();
}
void initScreens() {
uint8_t i;
uint8_t j;
Row = 0;
for( i = 0 ; i < 8 ; i++) {
for ( j = 0 ; j < 8; j++) {
setPixel(screen1,i,j,0,0,0);
}
}
setTop(screen1,0,100,0);
setLeft(screen1,100,0,0);
setRight(screen1,0,0,100);
setBottom(screen1,100,100,0);
}
QRect VanishingScrollBar::scrollBarRect(double begin, double end, const QRect &rect, int margin, Qt::Orientation orientation)
{
auto validRect = QRect(rect.x() + margin, rect.y() + margin, rect.width() - 2 * margin, rect.height() - 2 * margin);
auto drawRect = validRect;
if (orientation == Qt::Horizontal)
{
drawRect.setLeft(validRect.left() + validRect.width() * begin);
drawRect.setWidth(validRect.width() * (end - begin));
}
else
{
drawRect.setTop(validRect.top() + validRect.height() * begin);
drawRect.setHeight(validRect.height() * (end - begin));
}
return drawRect;
}
Ref<BasicShape> BasicShapeInset::blend(const BasicShape& other, double progress) const
{
ASSERT(type() == other.type());
auto& otherInset = downcast<BasicShapeInset>(other);
auto result = BasicShapeInset::create();
result->setTop(m_top.blend(otherInset.top(), progress));
result->setRight(m_right.blend(otherInset.right(), progress));
result->setBottom(m_bottom.blend(otherInset.bottom(), progress));
result->setLeft(m_left.blend(otherInset.left(), progress));
result->setTopLeftRadius(m_topLeftRadius.blend(otherInset.topLeftRadius(), progress));
result->setTopRightRadius(m_topRightRadius.blend(otherInset.topRightRadius(), progress));
result->setBottomRightRadius(m_bottomRightRadius.blend(otherInset.bottomRightRadius(), progress));
result->setBottomLeftRadius(m_bottomLeftRadius.blend(otherInset.bottomLeftRadius(), progress));
return WTFMove(result);
}
Domain &
Domain::store(const Domain &value,
const std::vector<Domain*> &offsets,
bool overwrite)
{
CANAL_ASSERT(offsets.empty());
if (&getValueType() == &value.getValueType())
{
if (overwrite)
setBottom();
join(value);
}
else
setTop();
return *this;
}
int QDoubleValidator::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QValidator::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
#ifndef QT_NO_PROPERTIES
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< double*>(_v) = bottom(); break;
case 1: *reinterpret_cast< double*>(_v) = top(); break;
case 2: *reinterpret_cast< int*>(_v) = decimals(); break;
case 3: *reinterpret_cast< Notation*>(_v) = notation(); break;
}
_id -= 4;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: setBottom(*reinterpret_cast< double*>(_v)); break;
case 1: setTop(*reinterpret_cast< double*>(_v)); break;
case 2: setDecimals(*reinterpret_cast< int*>(_v)); break;
case 3: setNotation(*reinterpret_cast< Notation*>(_v)); break;
}
_id -= 4;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 4;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 4;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 4;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 4;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 4;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 4;
}
#endif // QT_NO_PROPERTIES
return _id;
}
void createVolume(float bot, float top, Volume& volume)
{
if (top < bot) // swap top and bottom if neccessary
{
float temp = bot;
bot = top;
top = temp;
}
if (top - bot < 1.0) // ensure minimum height of 1
{
double m = bot + (top - bot)/2.0; //FIXME: first bot realy exist?
top = m + 0.5;
bot = m - 0.5;
}
double mass = top - bot; // ensure initial density of 1
setBot (volume, bot);
setTop (volume, top);
setMass(volume, mass);
}
void
MM_TLHAllocationSupport::setupTLH(MM_EnvironmentBase *env, void *addrBase, void *addrTop, MM_MemorySubSpace *memorySubSpace, MM_MemoryPool *memoryPool)
{
MM_GCExtensionsBase *extensions = env->getExtensions();
if (extensions->doFrequentObjectAllocationSampling){
updateFrequentObjectsStats(env);
}
/* Set the new TLH values */
setBase(addrBase);
setAlloc(addrBase);
setTop(addrTop);
if (NULL != memorySubSpace) {
setObjectFlags(memorySubSpace->getObjectFlags());
}
setMemoryPool(memoryPool);
setMemorySubSpace(memorySubSpace);
#if defined(OMR_GC_TLH_PREFETCH_FTA)
*_pointerToTlhPrefetchFTA = 0;
#endif /* OMR_GC_TLH_PREFETCH_FTA */
}
int QLongLongValidator::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QValidator::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
#ifndef QT_NO_PROPERTIES
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< qlonglong*>(_v) = bottom(); break;
case 1: *reinterpret_cast< qlonglong*>(_v) = top(); break;
}
_id -= 2;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: setBottom(*reinterpret_cast< qlonglong*>(_v)); break;
case 1: setTop(*reinterpret_cast< qlonglong*>(_v)); break;
}
_id -= 2;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 2;
}
#endif // QT_NO_PROPERTIES
return _id;
}
