QLayout::~QLayout()
{
//note that this function may be called during the QObject destructor,
//when the parent no longer is a QWidget.
if ( isTopLevel() && parent() && parent()->isWidgetType() &&
((QWidget*)parent())->layout() == this )
setWidgetLayout( (QWidget*)parent(), 0 );
}
void AddNewTorrentDialog::showEvent(QShowEvent *event)
{
QDialog::showEvent(event);
if (!isTopLevel()) return;
activateWindow();
raise();
}
void gMainWindow::setSticky(bool vl)
{
sticky=vl;
if (!isTopLevel()) return;
if (vl) gtk_window_stick(GTK_WINDOW(border));
else gtk_window_unstick(GTK_WINDOW(border));
}
void gMainWindow::setMinimized(bool vl)
{
if (!isTopLevel()) return;
_minimized = vl;
if (vl) gtk_window_iconify(GTK_WINDOW(border));
else gtk_window_deiconify(GTK_WINDOW(border));
}
double gMainWindow::opacity()
{
if (isTopLevel())
#if GTK_CHECK_VERSION(3, 8, 0)
return gtk_widget_get_opacity(border);
#else
return gtk_window_get_opacity(GTK_WINDOW(border));
#endif
else
return 1.0;
// check my hierarchy for dirty allocated regions
bool QWidget::isAllocatedRegionDirty() const
{
if ( isTopLevel() )
return FALSE;
if ( alloc_region_dirty )
return TRUE;
return parentWidget()->isAllocatedRegionDirty();
}
QRegion QWidget::allocatedRegion() const
{
if (isVisible()) {
if ( isTopLevel() ) {
return alloc_region;
} else {
if ( isAllocatedRegionDirty() ) {
const QObjectList *c;
QRegion r( req_region );
r &= parentWidget()->allocatedRegion();
parentWidget()->updateOverlappingChildren();
if ( parentWidget()->overlapping_children ) {
c = parentWidget()->children();
if ( c ) {
QObjectListIt it(*c);
QObject* ch;
bool clip=FALSE;
while ((ch=it.current())) {
++it;
if ( ch->isWidgetType() ) {
QWidget *w = (QWidget*)ch;
if ( w == this )
clip=TRUE;
else if ( clip && !w->isTopLevel() && w->isVisible() ) {
if ( w->geometry().intersects( geometry() ) )
r -= w->req_region;
}
}
}
}
}
// if I'm dirty, so are my chlidren.
c = children();
if ( c ) {
QObjectListIt it(*c);
QObject* ch;
while ((ch=it.current())) {
++it;
if ( ch->isWidgetType() && !((QWidget*)ch)->isTopLevel() ) {
((QWidget *)ch)->alloc_region_dirty = TRUE;
}
}
}
alloc_region = r;
alloc_region_dirty = FALSE;
paintable_region_dirty = TRUE;
}
return alloc_region;
}
} else {
return QRegion();
}
}
void gMainWindow::showPopup(int x, int y)
{
gMainWindow *save;
bool has_border;
int oldx, oldy;
//int type;
if (!isTopLevel()) return;
if (isModal()) return;
//gtk_widget_unrealize(border);
//((GtkWindow *)border)->type = GTK_WINDOW_POPUP;
//gtk_widget_realize(border);
oldx = left();
oldy = top();
has_border = gtk_window_get_decorated(GTK_WINDOW(border));
//type = getType();
//setType(_NET_WM_WINDOW_TYPE_COMBO);
gtk_window_set_decorated(GTK_WINDOW(border), false);
//gtk_window_set_type_hint(GTK_WINDOW(border), GDK_WINDOW_TYPE_HINT_POPUP_MENU);
move(x, y);
gtk_window_resize(GTK_WINDOW(border), bufW, bufH);
//reparent(NULL, x, y, GTK_WINDOW_POPUP);
_popup = true;
save = _current;
_current = this;
gApplication::enterPopup(this);
_current = save;
_popup = false;
if (!persistent)
{
destroyNow();
}
else
{
hide();
//gdk_window_set_override_redirect(gtk_widget_get_window(GTK_WINDOW(border)), false);
gtk_window_set_decorated(GTK_WINDOW(border), has_border);
//setType(type);
//gtk_window_set_type_hint(GTK_WINDOW(border), type);
move(oldx, oldy);
}
}
void Widget::addEventCallback(Event::Type type, EventCallback *func) {
Widget::EventListener *&listener = eventListeners[type];
if (listener == NULL) {
if (!isTopLevel())
parent->trackEventType(type);
listener = new Widget::EventListener();
}
listener->push_back(func);
}
void gMainWindow::setBorder(bool b)
{
if (!isTopLevel())
return;
gtk_window_set_decorated(GTK_WINDOW(border), b);
/*#ifdef GDK_WINDOWING_X11
XSetWindowAttributes attr;
attr.override_redirect = !b;
XChangeWindowAttributes(GDK_WINDOW_XDISPLAY(border->window), GDK_WINDOW_XID(border->window), CWOverrideRedirect, &attr);
#endif*/
}
void Scope::assign(std::string id, LSRValue val,void *classDefs) {
if (st.contains(id)) {
if(val.isClass()) {
(*ptrScope)->setPtr(id,val.getObjectPointer());
}
st.set(id,val);
} else if (!isTopLevel()) {
parent->assign(id,val,classDefs);
} else {
std::cout << "UndefinedIDError: ID " << id << " has not been declared in this scope." << std::endl;
}
}
void QWidget::lower()
{
QWidget *p = parentWidget();
if ( p && p->childObjects && p->childObjects->findRef(this) >= 0 )
p->childObjects->insert( 0, p->childObjects->take() );
if ( isTopLevel() )
qwsDisplay()->setAltitude( winId(), -1 );
else if ( p ) {
p->setChildrenAllocatedDirty( geometry() );
paint_children( p,geometry(),TRUE );
}
}
void gMainWindow::setMaximized(bool vl)
{
if (!isTopLevel())
return;
_maximized = vl;
if (vl)
gtk_window_maximize(GTK_WINDOW(border));
else
gtk_window_unmaximize(GTK_WINDOW(border));
}
void QWidget::setMask( const QRegion& region )
{
createExtra();
if ( region == extra->mask )
return;
alloc_region_dirty = TRUE;
extra->mask = region;
if ( isTopLevel() ) {
if ( !region.isNull() ) {
req_region = extra->mask;
req_region.translate(crect.x(),crect.y()); //###expensive?
req_region &= crect; //??? this is optional
} else
req_region = QRegion(crect);
req_region = qt_screen->mapToDevice( req_region, QSize(qt_screen->width(), qt_screen->height()) );
}
if ( isVisible() ) {
if ( isTopLevel() ) {
QRegion rgn( req_region );
#ifndef QT_NO_QWS_MANAGER
if ( extra && extra->topextra && extra->topextra->qwsManager ) {
QRegion wmr = extra->topextra->qwsManager->region();
wmr = qt_screen->mapToDevice( wmr, QSize(qt_screen->width(), qt_screen->height()) );
rgn += wmr;
}
#endif
qwsDisplay()->requestRegion(winId(), rgn);
} else {
updateRequestedRegion( mapToGlobal(QPoint(0,0)) );
parentWidget()->paintable_region_dirty = TRUE;
parentWidget()->repaint(geometry());
paint_children( parentWidget(),geometry(),TRUE );
}
}
}
std::shared_ptr<BuildItem>
Item::transform( TransformSet &xform ) const
{
std::shared_ptr<BuildItem> ret = xform.getTransform( this );
if ( ret )
return ret;
DEBUG( "transform Item " << getName() );
ret = std::make_shared<BuildItem>( getName(), getDir() );
ret->setDefaultTarget( isDefaultTarget() );
ret->setUseName( isUseNameAsInput() );
ret->setTopLevel( isTopLevel(), myPseudoName );
VariableSet buildvars;
extractVariables( buildvars );
ret->setVariables( std::move( buildvars ) );
if ( myForceToolAll == "<pseudo>" )
{
ret->addExternalOutput( getName() );
ret->setOutputDir( getDir()->reroot( xform.getArtifactDir() ) );
}
else
{
std::shared_ptr<Tool> t = getTool( xform );
if ( t )
{
DEBUG( getName() << " transformed by tool '" << t->getTag() << "' (" << t->getName() << ")" );
if ( t->getGeneratedExecutable() )
{
std::shared_ptr<BuildItem> x = t->getGeneratedExecutable()->transform( xform );
ret->addDependency( DependencyType::IMPLICIT, x );
}
ret->setTool( t );
ret->setOutputDir( getDir()->reroot( xform.getArtifactDir() ) );
std::string overOpt;
for ( auto &i: t->allOptions() )
{
if ( hasToolOverride( i.first, overOpt ) )
ret->setVariable( t->getOptionVariable( i.first ),
t->getOptionValue( i.first, overOpt ) );
}
}
else
WARNING( "No tools found for " << getName() );
}
xform.recordTransform( this, ret );
return ret;
}
void QWidget::raise()
{
QWidget *p = parentWidget();
if ( p && p->childObjects && p->childObjects->findRef(this) >= 0 )
p->childObjects->append( p->childObjects->take() );
if ( isTopLevel() ) {
#ifdef QT_NO_WINDOWGROUPHINT
if ( !testWFlags( WStyle_Tool ) )
setActiveWindow();
qwsDisplay()->setAltitude( winId(), 0 );
#else
QWidget* act=0;
if ( !testWFlags( WStyle_Tool ) )
act=this;
qwsDisplay()->setAltitude( winId(), 0 );
if ( childObjects ) {
QObjectListIt it(*childObjects);
QObject* o;
QWidgetList toraise;
QWidget* w;
while ((o=it.current())) {
if ( o->isWidgetType() ) {
w = (QWidget*)o;
if ( w->isTopLevel() )
toraise.append(w);
}
++it;
}
QWidgetListIt wit(toraise);
while ((w=wit.current())) {
if ( w->isVisible() ) {
bool wastool = w->testWFlags( WStyle_Tool );
w->setWFlags( WStyle_Tool ); // avoid setActiveWindow flicker
w->raise();
if ( !wastool ) {
w->clearWFlags( WStyle_Tool );
act = w;
}
}
++wit;
}
}
if ( act )
act->setActiveWindow();
#endif // QT_NO_WINDOWGROUPHINT
} else if ( p ) {
p->setChildrenAllocatedDirty( geometry(), this );
paint_heirarchy( this, TRUE );
}
}
void gMainWindow::center()
{
GdkRectangle rect;
int x, y;
if (!isTopLevel()) return;
gDesktop::availableGeometry(screen(), &rect);
x = rect.x + (rect.width - width()) / 2;
y = rect.y + (rect.height - height()) / 2;
move(x, y);
}
LSRValue Scope::resolve(std::string id) {
if (st.contains(id)) {
LSRValue v = st.get(id);
if (v.isClass()) {
v.objPtr = (*ptrScope)->resolve(id);
}
return v;
} else if (!isTopLevel()) {
return parent->resolve(id);
} else {
std::cout << "UndefinedIDError: ID " << id << " has not been declared in this scope." << std::endl;
return LSRValue(0);
}
}
void gMainWindow::setResizable(bool b)
{
if (!isTopLevel())
return;
if (b == isResizable())
return;
gtk_window_set_resizable(GTK_WINDOW(border), b);
if (b)
gtk_widget_set_size_request(border, 1, 1);
else
gtk_widget_set_size_request(border, bufW, bufH);
}
void QWidget::stackUnder( QWidget* w)
{
QWidget *p = parentWidget();
if ( !p || !w || isTopLevel() || p != w->parentWidget() )
return;
int loc = p->childObjects->findRef(w);
if ( loc >= 0 && p->childObjects && p->childObjects->findRef(this) >= 0 )
p->childObjects->insert( loc, p->childObjects->take() );
if ( p ) {
// #### excessive repaints
p->setChildrenAllocatedDirty();
paint_children( p,geometry(),TRUE );
paint_children( p,w->geometry(),TRUE );
}
}
void gMainWindow::setFullscreen(bool vl)
{
if (!isTopLevel())
return;
_fullscreen = vl;
if (vl)
{
gtk_window_fullscreen(GTK_WINDOW(border));
if (isVisible())
gtk_window_present(GTK_WINDOW(border));
}
else
gtk_window_unfullscreen(GTK_WINDOW(border));
}
QVariant FilePlacesItem::data(int role) const
{
if (isTopLevel()) {
switch (role) {
case Qt::DecorationRole:
return m_icon;
case Qt::DisplayRole:
return m_text;
default:
return QVariant();
}
}
if (isDevice())
return deviceData(role);
return bookmarkData(role);
}
//
// Find loop invariant instructions in a given block.
// We can do this block by block because we are traversing the dominator
// tree in pre-order, which accumulating invariants in our set.
//
void LicmPass::inspectBlock(const Loop* loop, BasicBlock* block,
Invariants& invariants) {
// No need to iterate over subloops because they will already have their
// instructions hoisted. Skip if we are in the subloop.
bool top_level = isTopLevel(loop, block);
if (!top_level) {
return;
}
// Iterate through all the intructions.
for (BasicBlock::iterator J = block->begin(), JE = block->end();
J != JE; ++J) {
Instruction& instr = *J;
bool invariant = isInvariant(loop, invariants, &instr);
if (invariant) {
invariants.insert(&instr);
}
}
}
void Component::setSize( Dimension size )
{
mSize = size;
if ( isLightWeight() == FALSE &&
getLayoutingPhase() == Component::PHASE_1 )
{
// only in PHASE_1 sizes are actually set for heavy-weight components
if ( isTopLevel() )
// HACK::...
getPeer()->SetClientSize( size.width + NON_CLIENT_WIDTH,
size.height + NON_CLIENT_HEIGHT );
else
getPeer()->SetSize( size.width, size.height );
}
}
void QWidget::destroy( bool destroyWindow, bool destroySubWindows )
{
deactivateWidgetCleanup();
if ( testWState(WState_Created) ) {
clearWState( WState_Created );
if ( children() ) {
QObjectListIt it(*children());
register QObject *obj;
while ( (obj=it.current()) ) { // destroy all widget children
++it;
if ( obj->isWidgetType() )
((QWidget*)obj)->destroy(destroySubWindows,
destroySubWindows);
}
}
releaseMouse();
if ( qt_pressGrab == this )
qt_pressGrab = 0;
#ifndef QT_NO_QWS_MANAGER
if (QWSManager::grabbedMouse() == this) {
if ( extra && extra->topextra && extra->topextra->qwsManager ) {
extra->topextra->qwsManager->releaseGrab();
}
}
#endif
if ( keyboardGrb == this )
releaseKeyboard();
if ( testWFlags(WShowModal) ) // just be sure we leave modal
qt_leave_modal( this );
else if ( testWFlags(WType_Popup) )
qApp->closePopup( this );
if ( testWFlags(WType_Desktop) ) {
} else {
if ( parentWidget() && parentWidget()->testWState(WState_Created) ) {
hideWindow();
}
if ( destroyWindow && isTopLevel() )
qwsDisplay()->destroyRegion( winId() );
}
setWinId( 0 );
}
}
void MntConfigWidget::loadSettings( void )
{
TDEConfig &config = *kapp->config();
if( mInitializing == false && GUI )
{
config.setGroup("MntConfig");
if( isTopLevel() )
{
int w = config.readNumEntry("Width",this->width() );
int h = config.readNumEntry("Height",this->height() );
resize(w,h);
}
TQListViewItem *item = mList->selectedItem();
if( item != 0 )
{
clicked( item );
}
}
}
LSRValue Scope::resolveMembers(void * ma, void * ct) {
LSRMemberAccess * access = (LSRMemberAccess*) ma;
if (st.contains(access->getParent())) {
LSRValue val = resolve(access->getParent());
if (!val.isClass()) {
std::cout <<"Trying to member access variable: " << access->getParent() << " that is of type " << val.getType() << std::endl;
return LSRValue (0);
} else {
LSRClassTable * classTable = (LSRClassTable*) ct;
std::string className = val.getType();
std::string curType = classTable->getType(className,access->getChild());
long unsigned int offSet = classTable->getOffset(className,access->getChild());
ggc_size_t * curPointer = (ggc_size_t*) (*ptrScope)->resolve(access->getParent());
curPointer = curPointer + offSet;
accessList *iter = access->list;
while(iter) {
curPointer = (ggc_size_t *)(*curPointer);
offSet = classTable->getOffset(curType,iter->id);
if (offSet) {
curPointer = curPointer + offSet;
curType = classTable->getType(curType, iter->id);
}
iter = iter->next;
}
if (!curType.compare("int")) {
LSRValue retVal = LSRValue((*curPointer));
return LSRValue((*curPointer));
} else {
LSRValue v = getInitializedVal(curType);
v.objPtr = (void *) (*curPointer);
return v;
}
//TODO: stuff other than ints
}
} else if (!isTopLevel()) {
return parent->resolveMembers(ma,ct);
} else {
std::cout << "UndefinedIDError: ID " << access->getParent() << " has not been declared in this scope." << std::endl;
return LSRValue(0);
}
}
void gMainWindow::setUtility(bool v)
{
bool remap = false;
if (!isTopLevel())
return;
// TODO: works only if the window is not mapped!
_utility = v;
if (gtk_widget_get_mapped(border))
{
remap = true;
gtk_widget_unmap(border);
}
gtk_window_set_type_hint(GTK_WINDOW(border), v ? GDK_WINDOW_TYPE_HINT_UTILITY : GDK_WINDOW_TYPE_HINT_NORMAL);
if (remap)
gtk_widget_map(border);
}
void gMainWindow::setStacking(int vl)
{
stack=vl;
if (!isTopLevel()) return;
switch (vl)
{
case 0:
gtk_window_set_keep_below(GTK_WINDOW(border),FALSE);
gtk_window_set_keep_above(GTK_WINDOW(border),FALSE);
break;
case 1:
gtk_window_set_keep_below(GTK_WINDOW(border),FALSE);
gtk_window_set_keep_above(GTK_WINDOW(border),TRUE);
break;
case 2:
gtk_window_set_keep_above(GTK_WINDOW(border),FALSE);
gtk_window_set_keep_below(GTK_WINDOW(border),TRUE);
break;
}
}
KNewIcon::KNewIcon(QWidget *parent) : KWizard( parent, 0, true)
{
debug("KNewIcon - constructor");
if(isTopLevel())
debug("isTopLevel");
else
debug("not TopLevel");
//hide();
connect(this, SIGNAL(selected(int)), SLOT(checkPage(int)));
openstyle = -1;
setOkButton();
getNextButton()->setEnabled(false);
getOkButton()->setEnabled(false);
setCancelButton();
setEnableArrowButtons(true);
select = new NewSelect(this);
connect(select, SIGNAL(iconopenstyle(int)), SLOT(iconOpenStyle(int)));
//scratch = new NewFromScratch(this);
scratch = new KResize(this, 0, false, QSize(32, 32));
connect(scratch, SIGNAL(validsize(bool)), SLOT(checkPage(bool)));
scratch->hide();
templ = new NewFromTemplate(this);
templ->hide();
p1 = new KWizardPage;
p1->title = i18n("Select icontype");
p1->w = select;
p1->enabled = true;
addPage(p1);
p2 = new KWizardPage;
p2->title = i18n("Create from scratch");
p2->w = scratch;
p2->enabled = true;
addPage(p2);
setCaption(i18n("Create new icon"));
resize(400, 250);
}
