QPtrVector<QStyleSheetItem> QTextParag::styleSheetItems() const
{
QPtrVector<QStyleSheetItem> vec;
vec.resize( styleSheetItemsVec.size() );
for ( int i = 0; i < (int)vec.size(); ++i )
vec.insert( i, styleSheetItemsVec[ i ] );
return vec;
}
bool QuickInterpreter::queryDispatchObjects( QObject *obj,
QPtrVector<QObject> &result )
{
Q_ASSERT( obj );
QMetaObject *meta = obj->metaObject();
result.resize( 1 );
result.insert( 0, obj );
while ( meta ) {
factory->constructInterface( meta->className(), (void*)obj, result );
meta = meta->superClass();
}
return TRUE;
}
static void writeLayers(QTextStream &ts, const RenderLayer* rootLayer, RenderLayer* l,
const QRect& paintDirtyRect, int indent)
{
// Calculate the clip rects we should use.
QRect layerBounds, damageRect, clipRectToApply;
l->calculateRects(rootLayer, paintDirtyRect, layerBounds, damageRect, clipRectToApply);
// Ensure our z-order lists are up-to-date.
l->updateZOrderLists();
bool shouldPaint = l->intersectsDamageRect(layerBounds, damageRect);
QPtrVector<RenderLayer>* negList = l->negZOrderList();
if (shouldPaint && negList && negList->count() > 0)
write(ts, *l, layerBounds, damageRect, clipRectToApply, -1, indent);
if (negList) {
for (unsigned i = 0; i != negList->count(); ++i)
writeLayers(ts, rootLayer, negList->at(i), paintDirtyRect, indent);
}
if (shouldPaint)
write(ts, *l, layerBounds, damageRect, clipRectToApply, negList && negList->count() > 0, indent);
QPtrVector<RenderLayer>* posList = l->posZOrderList();
if (posList) {
for (unsigned i = 0; i != posList->count(); ++i)
writeLayers(ts, rootLayer, posList->at(i), paintDirtyRect, indent);
}
}
bool QuickDispatchObjectFactory::constructInstance(const QString &className,
const QValueList<QVariant> &args,
QPtrVector<QObject> &result)
{
if (recurseBlock) {
qWarning("recursive construction of interfaces detected");
return FALSE;
}
recurseBlock = TRUE;
int oldIdx = result.size();
bool ret = createInstance(className, args, &result);
if (!ret) {
for (uint i = oldIdx; i < result.size(); ++i)
result.insert(i, 0);
}
recurseBlock = FALSE;
return ret;
}
int main(int argc, char *argv[])
{
KAboutData aboutData("kdesud", I18N_NOOP("KDE su daemon"),
Version, I18N_NOOP("Daemon used by kdesu"),
KAboutData::License_Artistic,
"Copyright (c) 1999,2000 Geert Jansen");
aboutData.addAuthor("Geert Jansen", I18N_NOOP("Author"),
"*****@*****.**", "http://www.stack.nl/~geertj/");
KCmdLineArgs::init(argc, argv, &aboutData);
KInstance instance(&aboutData);
// Set core dump size to 0
struct rlimit rlim;
rlim.rlim_cur = rlim.rlim_max = 0;
if (setrlimit(RLIMIT_CORE, &rlim) < 0)
{
kdError(1205) << "setrlimit(): " << ERR << "\n";
exit(1);
}
// Create the Unix socket.
int sockfd = create_socket();
if (sockfd < 0)
exit(1);
if (listen(sockfd, 1) < 0)
{
kdError(1205) << "listen(): " << ERR << "\n";
kdesud_cleanup();
exit(1);
}
int maxfd = sockfd;
// Ok, we're accepting connections. Fork to the background.
pid_t pid = fork();
if (pid == -1)
{
kdError(1205) << "fork():" << ERR << "\n";
kdesud_cleanup();
exit(1);
}
if (pid)
exit(0);
// Make sure we exit when the display gets closed.
int x11Fd = initXconnection();
maxfd = QMAX(maxfd, x11Fd);
repo = new Repository;
QPtrVector<ConnectionHandler> handler;
handler.setAutoDelete(true);
pipe(pipeOfDeath);
maxfd = QMAX(maxfd, pipeOfDeath[0]);
// Signal handlers
struct sigaction sa;
sa.sa_handler = signal_exit;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGHUP, &sa, 0L);
sigaction(SIGINT, &sa, 0L);
sigaction(SIGTERM, &sa, 0L);
sigaction(SIGQUIT, &sa, 0L);
sa.sa_handler = sigchld_handler;
sa.sa_flags = SA_NOCLDSTOP;
sigaction(SIGCHLD, &sa, 0L);
sa.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &sa, 0L);
// Main execution loop
ksocklen_t addrlen;
struct sockaddr_un clientname;
fd_set tmp_fds, active_fds;
FD_ZERO(&active_fds);
FD_SET(sockfd, &active_fds);
FD_SET(pipeOfDeath[0], &active_fds);
if (x11Fd != -1)
FD_SET(x11Fd, &active_fds);
while (1)
{
tmp_fds = active_fds;
if(x11Display)
XFlush(x11Display);
if (select(maxfd+1, &tmp_fds, 0L, 0L, 0L) < 0)
{
if (errno == EINTR) continue;
kdError(1205) << "select(): " << ERR << "\n";
exit(1);
}
repo->expire();
for (int i=0; i<=maxfd; i++)
{
if (!FD_ISSET(i, &tmp_fds))
continue;
if (i == pipeOfDeath[0])
{
char buf[101];
read(pipeOfDeath[0], buf, 100);
pid_t result;
do
{
int status;
result = waitpid((pid_t)-1, &status, WNOHANG);
if (result > 0)
{
for(int j=handler.size(); j--;)
{
if (handler[j] && (handler[j]->m_pid == result))
{
handler[j]->m_exitCode = WEXITSTATUS(status);
handler[j]->m_hasExitCode = true;
handler[j]->sendExitCode();
handler[j]->m_pid = 0;
break;
}
}
}
}
while(result > 0);
}
if (i == x11Fd)
{
// Discard X events
XEvent event_return;
if (x11Display)
while(XPending(x11Display))
XNextEvent(x11Display, &event_return);
continue;
}
if (i == sockfd)
{
// Accept new connection
int fd;
addrlen = 64;
fd = accept(sockfd, (struct sockaddr *) &clientname, &addrlen);
if (fd < 0)
{
kdError(1205) << "accept():" << ERR << "\n";
continue;
}
if (fd+1 > (int) handler.size())
handler.resize(fd+1);
handler.insert(fd, new ConnectionHandler(fd));
maxfd = QMAX(maxfd, fd);
FD_SET(fd, &active_fds);
continue;
}
// handle alreay established connection
if (handler[i] && handler[i]->handle() < 0)
{
handler.remove(i);
FD_CLR(i, &active_fds);
}
}
}
kdWarning(1205) << "???\n";
}