|
|
|
|
|
|
|
|
#include "misc.h"
|
|
|
#include "proc.h"
|
|
|
|
|
|
extern SearchBox *search_box;
|
|
|
extern bool flag_show_thread;
|
|
|
extern int flag_thread_ok;
|
|
|
extern bool flag_devel;
|
|
|
|
|
|
#include "../icon/x1.xpm"
|
|
|
#include "../icon/x2.xpm"
|
|
|
|
|
|
#include <stdio.h>
|
|
|
#include <time.h>
|
|
|
#include <errno.h>
|
|
|
|
|
|
// 300% faster than glibc (by fasthyun@magicn.com)
|
|
|
int x_atoi(const char *sstr)
|
|
|
{
|
|
|
const char *str = sstr;
|
|
|
int val = 0;
|
|
|
while (*str)
|
|
|
{
|
|
|
val *= 10;
|
|
|
val += *str - 48;
|
|
|
str++;
|
|
|
}
|
|
|
return val;
|
|
|
}
|
|
|
|
|
|
#include <QApplication>
|
|
|
QWidget *getQpsWidget()
|
|
|
{
|
|
|
QWidgetList list = QApplication::topLevelWidgets();
|
|
|
for (int i = 0; i < list.size(); ++i)
|
|
|
{
|
|
|
QWidget *w = list.at(i);
|
|
|
if (w->objectName() == "qps")
|
|
|
return w;
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
#include <stdarg.h>
|
|
|
#include <string.h>
|
|
|
/*
|
|
|
ver 0.2
|
|
|
A simplified vsscanf implementation from Internet
|
|
|
|
|
|
%S can read char_string_has_spaces.
|
|
|
ex. "(%S)" == (foo bar) or (foo bar )
|
|
|
|
|
|
|
|
|
%s %d %ld %u %x? %lu %*s %f
|
|
|
%S: (%S)
|
|
|
|
|
|
Only recognizes %s %f,%d, %u, %ld, %lu, %lg and whitespace. ...terminates
|
|
|
scanning.
|
|
|
space* same tab*
|
|
|
|
|
|
*/
|
|
|
|
|
|
// Description:
|
|
|
// mini_sscanf() == strstr() + sscanf() + %S
|
|
|
//
|
|
|
// there is test_sample_code in init_misc()
|
|
|
// fixed : invalid conversion from ‘const char*’ to ‘char*’
|
|
|
//
|
|
|
// TOO COMPLEX !!!!!! -> simple code
|
|
|
char *strchar(const char *s, int k);
|
|
|
int mini_sscanf(const char *s1, const char *fmt, ...)
|
|
|
{
|
|
|
|
|
|
va_list va;
|
|
|
va_start(va, fmt);
|
|
|
char *s = (char *)s1; // *** for gcc 4.4
|
|
|
char *p;
|
|
|
int k = 0; // count
|
|
|
while (*fmt and *s) // if (*fmt==0 or *s==0) break;
|
|
|
{
|
|
|
if (*fmt == '%')
|
|
|
{
|
|
|
int n;
|
|
|
if (fmt[1] == 'S')
|
|
|
{
|
|
|
// if(fmt[2]!=0)
|
|
|
p = strchr(s, fmt[2]); // get the token
|
|
|
int len = p - s;
|
|
|
p = va_arg(va, char *);
|
|
|
strncpy(p, s, len);
|
|
|
p[len] = 0;
|
|
|
s += len + 1;
|
|
|
fmt += 3;
|
|
|
k++;
|
|
|
}
|
|
|
else if (fmt[1] == 's') // extract string
|
|
|
{
|
|
|
// printf("%s : %%s =%s \n",__FUNCTION__,s);
|
|
|
k += sscanf(s, "%s%n", va_arg(va, char *), &n);
|
|
|
s += n;
|
|
|
fmt += 2;
|
|
|
}
|
|
|
else if (fmt[1] == '*' && fmt[2] == 's') // skip
|
|
|
{
|
|
|
p = strchr(s, ' '); // 0x20,0x00,0x0A, 123 435 54054
|
|
|
if (p == 0)
|
|
|
{
|
|
|
// printf("%s : %c [%s]
|
|
|
//\n",__FUNCTION__,fmt[1],s);
|
|
|
break;
|
|
|
}
|
|
|
s = p;
|
|
|
fmt += 3;
|
|
|
}
|
|
|
else if (fmt[1] == 'c')
|
|
|
{
|
|
|
p = va_arg(va, char *);
|
|
|
// printf("%s : %c [%c]
|
|
|
//\n",__FUNCTION__,fmt[1],*s);
|
|
|
*p = *s;
|
|
|
s++;
|
|
|
k++;
|
|
|
fmt += 2;
|
|
|
}
|
|
|
else if (fmt[1] == 'f')
|
|
|
{
|
|
|
k += sscanf(s, "%f%n", va_arg(va, float *), &n);
|
|
|
s += n;
|
|
|
fmt += 2;
|
|
|
}
|
|
|
else if (fmt[1] == 'd')
|
|
|
{
|
|
|
k += sscanf(s, "%d%n", va_arg(va, int *), &n);
|
|
|
s += n;
|
|
|
fmt += 2;
|
|
|
}
|
|
|
else if (fmt[1] == 'u')
|
|
|
{
|
|
|
k += sscanf(s, "%u%n", va_arg(va, int *), &n);
|
|
|
s += n;
|
|
|
fmt += 2;
|
|
|
}
|
|
|
else if (fmt[1] == 'l' && fmt[2] == 'd')
|
|
|
{
|
|
|
k += sscanf(s, "%ld%n", va_arg(va, long *), &n);
|
|
|
s += n;
|
|
|
fmt += 3;
|
|
|
}
|
|
|
else if (fmt[1] == 'l' && fmt[2] == 'u')
|
|
|
{
|
|
|
k += sscanf(s, "%lu%n", va_arg(va, long *), &n);
|
|
|
s += n;
|
|
|
fmt += 3;
|
|
|
}
|
|
|
else if (fmt[1] == 'l' && fmt[2] == 'g')
|
|
|
{
|
|
|
k += sscanf(s, "%lg%n", va_arg(va, double *), &n);
|
|
|
s += n;
|
|
|
fmt += 3;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
printf("%s: unsupported"
|
|
|
" format '%c'",
|
|
|
__FUNCTION__, fmt[1]);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (isspace(*fmt)) // isblank
|
|
|
{
|
|
|
while (isspace(*s))
|
|
|
s++;
|
|
|
fmt++;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
char sstr[32];
|
|
|
int n = strcspn(fmt, " %\n"); // find delimiters noSEGFAULT
|
|
|
strncpy(sstr, fmt, n);
|
|
|
sstr[n] = 0;
|
|
|
p = strstr(s, sstr);
|
|
|
if (p == 0)
|
|
|
{
|
|
|
if (0 and flag_devel)
|
|
|
printf("%s : can't found [%s] "
|
|
|
"in %s\n",
|
|
|
__FUNCTION__, sstr, s);
|
|
|
break;
|
|
|
}
|
|
|
s = p + n;
|
|
|
fmt += n;
|
|
|
// ddd at %s, at%s
|
|
|
// printf("opp_vsscanf: unexpected ""char in
|
|
|
// format '%s'",fmt);
|
|
|
// break;
|
|
|
// return k;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (*fmt == '\0' || *fmt == '#' or *s == 0)
|
|
|
break;
|
|
|
}
|
|
|
va_end(va);
|
|
|
return k;
|
|
|
}
|
|
|
|
|
|
#include <sys/stat.h>
|
|
|
#include <fcntl.h>
|
|
|
#include <sys/types.h>
|
|
|
#include <unistd.h>
|
|
|
|
|
|
// return /proc/* file size
|
|
|
int fsize(char *fname)
|
|
|
{
|
|
|
int size = 0;
|
|
|
if (0)
|
|
|
{
|
|
|
// !!! important !! not works with [/proc] , because [/proc/*]
|
|
|
// always zero
|
|
|
int fd = open(fname, O_RDONLY);
|
|
|
if (fd < 0)
|
|
|
return -1;
|
|
|
size = lseek(fd, 0, SEEK_END);
|
|
|
printf("size=%d\n", size);
|
|
|
close(fd);
|
|
|
return size;
|
|
|
}
|
|
|
|
|
|
int buf[1024];
|
|
|
int r;
|
|
|
int fd = open(fname, O_RDONLY);
|
|
|
if (fd < 0)
|
|
|
return -1;
|
|
|
do
|
|
|
{
|
|
|
r = read(fd, buf, 1024);
|
|
|
size += r;
|
|
|
// printf("r_size=%d\n",size);
|
|
|
} while (r);
|
|
|
// printf("size=%d\n",size);
|
|
|
close(fd);
|
|
|
return size;
|
|
|
}
|
|
|
|
|
|
// sleep for mili seconds
|
|
|
void msleep(long msec)
|
|
|
{
|
|
|
#ifdef LINUX
|
|
|
timespec req, remain;
|
|
|
timeval tv;
|
|
|
req.tv_sec = 0;
|
|
|
req.tv_nsec = msec * 1000000;
|
|
|
// int nanosleep(const struct timespec *req, struct timespec
|
|
|
// *remain)
|
|
|
/*while (nanosleep(&req, &req))
|
|
|
{
|
|
|
if (errno != EINTR)
|
|
|
break;
|
|
|
} */
|
|
|
|
|
|
tv.tv_sec = 0;
|
|
|
tv.tv_usec = msec * 1000;
|
|
|
select(0, NULL, NULL, NULL, &tv);
|
|
|
return;
|
|
|
#endif
|
|
|
}
|
|
|
|
|
|
void mem_string_k(int kbytes, char *buf)
|
|
|
{
|
|
|
if (kbytes >= 1024)
|
|
|
{
|
|
|
int mb = kbytes >> 10;
|
|
|
if (mb >= 1024 * 100)
|
|
|
sprintf(buf, "%uGB", mb >> 10);
|
|
|
else
|
|
|
sprintf(buf, "%uMB", mb);
|
|
|
}
|
|
|
else
|
|
|
sprintf(buf, "%uKB", kbytes);
|
|
|
}
|
|
|
void mem_string(int kbytes, char *buf)
|
|
|
{
|
|
|
if (kbytes >= 1024)
|
|
|
{
|
|
|
int meg = kbytes >> 10;
|
|
|
if (meg >= 1024 * 100)
|
|
|
sprintf(buf, "%uGb", meg >> 10);
|
|
|
else
|
|
|
sprintf(buf, "%uMb", meg);
|
|
|
}
|
|
|
else
|
|
|
sprintf(buf, "%uKb", kbytes);
|
|
|
}
|
|
|
|
|
|
// DEL
|
|
|
CheckMenu::CheckMenu(QWidget *parent) : QMenu(parent) {}
|
|
|
|
|
|
// ???
|
|
|
CrossBox::CrossBox(const char *text, QWidget *parent) : QCheckBox(text, parent)
|
|
|
{
|
|
|
}
|
|
|
|
|
|
void CrossBox::drawButton(QPainter *p)
|
|
|
{
|
|
|
///// QCheckBox::drawButton(p);
|
|
|
}
|
|
|
|
|
|
TBloon::TBloon(QWidget *parent) : QLabel(parent)
|
|
|
{
|
|
|
|
|
|
return;
|
|
|
paren = parent;
|
|
|
setStyleSheet("QLabel { "
|
|
|
//"border-width: 1px; border-style: solid; border-color:
|
|
|
// rgb(150,45,100); border-radius: 5px ;"
|
|
|
"border-width: 1px; border-style: solid; border-color: "
|
|
|
"rgb(150,180,180); border-radius: 5px ;"
|
|
|
"background-color : rgba(0,0,0,48%); padding: 3px; color: "
|
|
|
"rgb(255,120,60); }");
|
|
|
// COLOR orange FF5d00
|
|
|
|
|
|
setText(" This is unstable Alpha feature\n You maybe see a SEGFAULT...");
|
|
|
resize(sizeHint());
|
|
|
// parent->installEventFilter(this);
|
|
|
// parent->setMouseTracking(true);
|
|
|
hide();
|
|
|
|
|
|
// Construct a 1-second timeline with a frame range of 0 - 100
|
|
|
timeLine = new QTimeLine(100000, this);
|
|
|
timeLine->setFrameRange(0, 20000);
|
|
|
timeLine->setCurveShape(QTimeLine::EaseOutCurve);
|
|
|
// timeLine->set(0, 20000);
|
|
|
connect(timeLine, SIGNAL(frameChanged(int)), this, SLOT(update(int)));
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
void TBloon::start_ani()
|
|
|
{
|
|
|
|
|
|
} */
|
|
|
|
|
|
void TBloon::update(int val)
|
|
|
{
|
|
|
//`QPoint p=QCursor::pos();
|
|
|
// qDebug("pos %d %d", p.x(),p.y());
|
|
|
QPoint p2 = paren->mapFromGlobal(QCursor::pos());
|
|
|
|
|
|
// qDebug("wpos %d %d", p2.x(),p2.y());
|
|
|
int tx = p2.x();
|
|
|
int ty = p2.y();
|
|
|
int sx = pos().x();
|
|
|
int sy = pos().y();
|
|
|
float dx = tx - sx;
|
|
|
float dy = ty - sy;
|
|
|
dx = dx / 1.35;
|
|
|
dy = dy / 1.35;
|
|
|
move(tx + dx + 8, ty + dy + 14);
|
|
|
}
|
|
|
|
|
|
bool TBloon::eventFilter(QObject *obj, QEvent *event)
|
|
|
{
|
|
|
if (event->type() == QEvent::Enter)
|
|
|
{
|
|
|
QPoint p = paren->mapFromGlobal(QCursor::pos());
|
|
|
move(p);
|
|
|
// qDebug("Enter parent");
|
|
|
timeLine->start();
|
|
|
show();
|
|
|
return true;
|
|
|
}
|
|
|
else if (event->type() == QEvent::Leave)
|
|
|
{
|
|
|
// qDebug("Leave parent");
|
|
|
timeLine->stop();
|
|
|
hide();
|
|
|
return true;
|
|
|
}
|
|
|
else if (event->type() == QEvent::MouseMove)
|
|
|
{
|
|
|
QMouseEvent *me = static_cast<QMouseEvent *>(event);
|
|
|
// qDebug("Ate key press %d %d", me->x(),me->y());
|
|
|
// move(me->x()+5,me->y()+4);
|
|
|
return false;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
// standard event processing
|
|
|
return QObject::eventFilter(obj, event);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
void TBloon::paintEvent( QPaintEvent * event )
|
|
|
{
|
|
|
QLabel::paintEvent(event);
|
|
|
} */
|
|
|
|
|
|
TFrame::TFrame(QWidget *parent) : QLabel(parent)
|
|
|
// TFrame::TFrame(QWidget *parent):QFrame(parent)
|
|
|
{
|
|
|
text = "this is Tframe widget";
|
|
|
// setAutoFillBackground(false);
|
|
|
// setGeometry(50,50,100,100);
|
|
|
// setAttribute(Qt::WA_OpaquePaintEvent);
|
|
|
// setFrameShape(QFrame::StyledPanel);
|
|
|
// setFrameShadow(QFrame::Sunken);
|
|
|
// setSizePolicy(QSizePolicy::Preferred,QSizePolicy::Preferred);
|
|
|
// setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum);
|
|
|
// setSizePolicy(QSizePolicy::Maximum,QSizePolicy::Maximum);
|
|
|
// setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
|
|
|
|
|
|
//"border-width: 1px; border-style: solid; border-color:
|
|
|
// rgb(150,45,100);
|
|
|
// border-radius: 5px ;"
|
|
|
setStyleSheet("QLabel { "
|
|
|
"border-width: 1px; border-style: solid; border-color: "
|
|
|
"rgb(210,50,130); border-radius: 5px ;"
|
|
|
"background-color : rgba(0,0,0,69%); padding: 3px; color: "
|
|
|
"rgb(0,255,150); }");
|
|
|
// setStyleSheet( "QLabel { " "border-width: 1px; border-style:
|
|
|
// solid;
|
|
|
// border-radius: 5px ; padding: 3px; }");
|
|
|
hide();
|
|
|
|
|
|
timeLine = new QTimeLine(2000, this);
|
|
|
timeLine->setFrameRange(0, 100);
|
|
|
connect(timeLine, SIGNAL(frameChanged(int)), this, SLOT(setValue(int)));
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
void TFrame::showText(QPoint glob_pos,QString str)
|
|
|
{
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
void TFrame::move(int x,int y)
|
|
|
{
|
|
|
|
|
|
|
|
|
} */
|
|
|
|
|
|
// QToolTip::showText(e->globalPos(), s);
|
|
|
void TFrame::showText(QPoint glob_pos, QString str) {}
|
|
|
|
|
|
void TFrame::setText(QString str)
|
|
|
{
|
|
|
text = str;
|
|
|
|
|
|
QLabel::setText(str);
|
|
|
|
|
|
// resize(minimumSizeHint());
|
|
|
resize(sizeHint()); // **** before show !! *****
|
|
|
|
|
|
if (str.size() == 0)
|
|
|
{
|
|
|
hide();
|
|
|
return;
|
|
|
}
|
|
|
show();
|
|
|
}
|
|
|
|
|
|
// to avoid ~
|
|
|
void TFrame::draw(QPainter &p)
|
|
|
{
|
|
|
// if(!isVisible()) return;
|
|
|
return;
|
|
|
int h = fontMetrics().height() + 3;
|
|
|
int w = fontMetrics().width(text) + 9;
|
|
|
setFixedSize(w, h);
|
|
|
// QFont font("Adobe Helvetica"); // helvetica & No-Antialias
|
|
|
// font.setPixelSize(10);
|
|
|
// setFont(font);
|
|
|
// p.drawRoundRect(rect(),10,10);
|
|
|
// p.fillRect ( cr,QColor(0,0,0));
|
|
|
QColor bg = QColor(0, 0, 0, 120);
|
|
|
#if QT_VERSION < 0x040400
|
|
|
p.fillRect(rect(), QColor(0, 0, 0, 120));
|
|
|
#else
|
|
|
// p.fillRect(rect(),QColor(0,0,0,90));
|
|
|
|
|
|
// p.setPen(QColor(0,255,155)); // less visually obtrusive than
|
|
|
// black
|
|
|
// p.setBrush(QBrush(bg));
|
|
|
// p.drawRoundedRect(0,0,w,h, 4, 4);
|
|
|
p.fillRect(rect(), bg);
|
|
|
|
|
|
#endif
|
|
|
|
|
|
p.setPen(QColor(0, 255, 155)); // less visually obtrusive than black
|
|
|
p.drawText(0, 0, w, h, Qt::AlignVCenter | Qt::AlignHCenter, text);
|
|
|
}
|
|
|
|
|
|
void TFrame::setPos()
|
|
|
{
|
|
|
QWidget *parent = QWidget::parentWidget();
|
|
|
|
|
|
QPoint p = parent->mapFromGlobal(QCursor::pos());
|
|
|
|
|
|
setPos(p.x(), p.y());
|
|
|
}
|
|
|
|
|
|
void TFrame::setPos(int x, int y)
|
|
|
{
|
|
|
QWidget *parent = QWidget::parentWidget();
|
|
|
int pwidth = parent->width();
|
|
|
|
|
|
if (width() + x > pwidth)
|
|
|
{
|
|
|
x = pwidth - width();
|
|
|
}
|
|
|
move(x + 16, y + 4);
|
|
|
}
|
|
|
|
|
|
void TFrame::moveEvent(QMoveEvent *e)
|
|
|
{
|
|
|
// int x=e->pos().x();
|
|
|
// printf("pos (%d %d) \n",e->pos().x(),e->pos().y());
|
|
|
// event->oldPos();
|
|
|
}
|
|
|
|
|
|
void TFrame::setValue(int val)
|
|
|
{
|
|
|
opacity += ((float)val / 100);
|
|
|
update();
|
|
|
}
|
|
|
|
|
|
void TFrame::showEvent(QShowEvent *event)
|
|
|
{
|
|
|
opacity = 0.2;
|
|
|
// timeLine->start();
|
|
|
}
|
|
|
|
|
|
// Maybe SEGFAULT
|
|
|
void setPaletteBlend(QPalette &p)
|
|
|
{
|
|
|
for (int i = 0; i < (QPalette::NoRole); i++)
|
|
|
{
|
|
|
QColor c = p.color(QPalette::ColorRole(i));
|
|
|
c.alpha();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void TFrame::paintEvent(QPaintEvent *event)
|
|
|
{
|
|
|
QLabel::paintEvent(event);
|
|
|
return;
|
|
|
|
|
|
QCursor::pos();
|
|
|
// if(x()+width() > ) ;
|
|
|
QPalette np = palette();
|
|
|
setPaletteBlend(np);
|
|
|
|
|
|
QPainter p(this); // why?
|
|
|
|
|
|
// if(opacity>1) timeLine->stop(); //
|
|
|
// p.setOpacity(opacity);
|
|
|
// p.setOpacity(0.01);
|
|
|
// setWindowOpacity (0.1 );
|
|
|
// QFrame::paintEvent(event);
|
|
|
// p.scale(0.5,0.5);
|
|
|
|
|
|
// draw(p);
|
|
|
// p.setBackgroundMode (Qt::TransparentMode);
|
|
|
// p.setRenderHint(QPainter::Antialiasing);
|
|
|
// painter.translate(width() / 2, height() / 2);
|
|
|
}
|
|
|
|
|
|
UFrame::UFrame(QWidget *parent) : QFrame(parent)
|
|
|
// TFrame::TFrame(QWidget *parent):QFrame(parent)
|
|
|
{
|
|
|
// setAttribute(Qt::WA_OpaquePaintEvent);
|
|
|
// setFrameShape(QFrame::StyledPanel);
|
|
|
// setFrameShadow(QFrame::Sunken);
|
|
|
// setSizePolicy(QSizePolicy::Preferred,QSizePolicy::Preferred);
|
|
|
|
|
|
//"border-width: 1px; border-style: solid; border-color:
|
|
|
// rgb(150,45,100);
|
|
|
// border-radius: 5px ;"
|
|
|
|
|
|
// setStyleSheet( "QLabel { " "border-width: 1px; border-style:
|
|
|
// solid;
|
|
|
// border-color: rgb(210,50,130); border-radius: 5px ;"
|
|
|
// "background-color :
|
|
|
// rgba(0,0,0,70%); padding: 3px; color: rgb(0,255,150); }");
|
|
|
hide();
|
|
|
|
|
|
QVBoxLayout *vlayout = new QVBoxLayout;
|
|
|
QLabel *label = new QLabel("title");
|
|
|
vlayout->addWidget(label);
|
|
|
|
|
|
setLayout(vlayout);
|
|
|
QWidget *qps = getQpsWidget();
|
|
|
if (qps)
|
|
|
{
|
|
|
int w = qps->width();
|
|
|
int h = qps->height();
|
|
|
printf("qps w=%d h=%d\n", qps->width(), qps->height());
|
|
|
move(w / 2, h / 2);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
FaderWidget::FaderWidget(QWidget *parent) : QWidget(parent)
|
|
|
{
|
|
|
if (parent)
|
|
|
startBrush = parent->palette().window();
|
|
|
else
|
|
|
startBrush = Qt::white;
|
|
|
|
|
|
timeLine = new QTimeLine(333, this);
|
|
|
timeLine->setFrameRange(1000, 0);
|
|
|
connect(timeLine, SIGNAL(frameChanged(int)), this, SLOT(update()));
|
|
|
|
|
|
setAttribute(Qt::WA_DeleteOnClose);
|
|
|
resize(parent->size());
|
|
|
}
|
|
|
|
|
|
void FaderWidget::start()
|
|
|
{
|
|
|
timeLine->start();
|
|
|
show();
|
|
|
}
|
|
|
|
|
|
void FaderWidget::paintEvent(QPaintEvent * /* event */)
|
|
|
{
|
|
|
QPainter painter(this);
|
|
|
qreal frame = timeLine->currentFrame();
|
|
|
painter.setOpacity(frame / 1000.);
|
|
|
painter.fillRect(rect(), startBrush);
|
|
|
|
|
|
if (frame <= 0.)
|
|
|
close();
|
|
|
}
|
|
|
|
|
|
void UFrame::setTitle(QString str)
|
|
|
{
|
|
|
// QLabel::setText(str);
|
|
|
title = str;
|
|
|
}
|
|
|
|
|
|
void UFrame::paintEvent(QPaintEvent *event) {}
|
|
|
/*
|
|
|
//void SearchBox::event_cursor_moved(QMouseEvent *e)
|
|
|
{
|
|
|
move(e->x(),e->y());
|
|
|
//printf("xxxxxxxxxxxxxk\n");
|
|
|
}
|
|
|
|
|
|
*/
|
|
|
|
|
|
QPixmap *letters;
|
|
|
int pf_height = 9;
|
|
|
int pf_width = 6;
|
|
|
|
|
|
void init_xpm()
|
|
|
{
|
|
|
letters = new QPixmap(":/icon/letters.png");
|
|
|
pf_height = 9;
|
|
|
pf_width = 6;
|
|
|
}
|
|
|
|
|
|
#ifdef LINUX
|
|
|
#include <sys/prctl.h>
|
|
|
#include <QThread>
|
|
|
char strong_buff[128];
|
|
|
class MyThread : public QThread
|
|
|
{
|
|
|
public:
|
|
|
void run()
|
|
|
{
|
|
|
prctl(PR_SET_NAME, "thread_test123456789");
|
|
|
|
|
|
while (true)
|
|
|
{
|
|
|
int m = 0;
|
|
|
for (int i = 0; i < 20000; i++)
|
|
|
{
|
|
|
int p = rand() % 120;
|
|
|
strong_buff[p] = p;
|
|
|
}
|
|
|
msleep(40);
|
|
|
}
|
|
|
exec();
|
|
|
}
|
|
|
};
|
|
|
class MyThread2 : public QThread
|
|
|
{
|
|
|
public:
|
|
|
void run()
|
|
|
{
|
|
|
prctl(PR_SET_NAME, "thread_test987654321");
|
|
|
|
|
|
while (true)
|
|
|
{
|
|
|
int m = 0;
|
|
|
int i;
|
|
|
for (i = 0; i < 100000; i++)
|
|
|
{
|
|
|
int p = rand() % 120;
|
|
|
// strong_buff[p]=p;
|
|
|
m = i * p;
|
|
|
}
|
|
|
m += i;
|
|
|
msleep(60);
|
|
|
}
|
|
|
exec();
|
|
|
}
|
|
|
};
|
|
|
#endif
|
|
|
|
|
|
int pf_str_width(char *str)
|
|
|
{
|
|
|
int len;
|
|
|
len = strlen(str) * pf_width;
|
|
|
return len;
|
|
|
}
|
|
|
int pf_char_height() { return pf_height; }
|
|
|
|
|
|
int pf_write(QPainter *p, int x, int y, const char *str)
|
|
|
{
|
|
|
int i, len, n;
|
|
|
int ch;
|
|
|
int sx, sy;
|
|
|
int x0 = x;
|
|
|
len = strlen(str);
|
|
|
for (i = 0; i < len; i++)
|
|
|
{
|
|
|
ch = str[i];
|
|
|
|
|
|
if (ch == '\n')
|
|
|
{
|
|
|
// y+=pf_height;
|
|
|
continue;
|
|
|
}
|
|
|
// if(ch>96) ch-=(97-65);
|
|
|
n = ch - 32;
|
|
|
p->drawPixmap(x, y, *letters, n * pf_width, 0, pf_width + 1, pf_height);
|
|
|
x += pf_width;
|
|
|
}
|
|
|
return x - x0;
|
|
|
}
|
|
|
|
|
|
QPixmap *x1, *x2;
|
|
|
XButton::XButton(QWidget *parent) : QAbstractButton(parent)
|
|
|
{
|
|
|
setFocusPolicy(Qt::NoFocus);
|
|
|
x1 = new QPixmap((const char **)x1_xpm);
|
|
|
x2 = new QPixmap((const char **)x2_xpm);
|
|
|
int w = x1->width();
|
|
|
setGeometry(0, 0, w, w);
|
|
|
}
|
|
|
|
|
|
void XButton::resizeEvent(QResizeEvent *p)
|
|
|
{
|
|
|
int i, h;
|
|
|
i = height() % 2;
|
|
|
|
|
|
if (i != 0)
|
|
|
h = height() + 1;
|
|
|
else
|
|
|
h = height();
|
|
|
setFixedSize(h, h);
|
|
|
}
|
|
|
|
|
|
void XButton::paintEvent(QPaintEvent *event)
|
|
|
{
|
|
|
QPainter p(this);
|
|
|
int w, h, m;
|
|
|
|
|
|
if (isDown())
|
|
|
p.drawPixmap(0, 0, *x2);
|
|
|
else
|
|
|
p.drawPixmap(0, 0, *x1);
|
|
|
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
SearchBox::SearchBox(QWidget *parent) : QLineEdit(parent)
|
|
|
{
|
|
|
setToolTip("PID,COMMAND,USER...");
|
|
|
left_time = 0;
|
|
|
setMaximumWidth(300);
|
|
|
setMinimumWidth(20);
|
|
|
|
|
|
// setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Preferred);
|
|
|
// setContentsMargins(0,3,1,0);
|
|
|
// setLineWidth( 1 );
|
|
|
// setMargin(2);
|
|
|
|
|
|
/// xb=new XButton(this);
|
|
|
/// connect(xb, SIGNAL(clicked()), SLOT(event_xbutton_clicked()));
|
|
|
setFocus(Qt::ActiveWindowFocusReason); // good
|
|
|
}
|
|
|
|
|
|
void SearchBox::event_cursor_moved(QMouseEvent *e) { move(e->x(), e->y()); }
|
|
|
|
|
|
void SearchBox::resizeEvent(QResizeEvent *p)
|
|
|
{
|
|
|
int w, h, margin;
|
|
|
// setMinimumHeight(height()-4);
|
|
|
// setMaximumHeight(p->size().height()-1);
|
|
|
// setFixedHeight(p->size().height()-5);
|
|
|
// setMaximumHeight(height()-2);
|
|
|
w = width();
|
|
|
h = height();
|
|
|
/// margin=(h - xb->width())/2;
|
|
|
/// xb->move(w-h+margin-1,margin);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
void SearchBox::event_xbutton_clicked()
|
|
|
{
|
|
|
QKeyEvent ke(QEvent::KeyPress, Qt::Key_Escape, 0); // temp..
|
|
|
keyPressEvent(&ke);
|
|
|
}
|
|
|
|
|
|
// public
|
|
|
/*void SearchBox::keyPress( QKeyEvent * e )
|
|
|
{
|
|
|
|
|
|
} */
|
|
|
|
|
|
void SearchBox::timerEvent(QTimerEvent *e)
|
|
|
{
|
|
|
// qDebug( "timer event, id %d", e->timerId() );
|
|
|
}
|
|
|
|
|
|
LogBox::LogBox(QWidget *p) : QLabel(p)
|
|
|
{
|
|
|
text = new QTextEdit(p);
|
|
|
text->setFocusPolicy(Qt::NoFocus);
|
|
|
}
|
|
|
|
|
|
// Location: bottom
|
|
|
StatusBar::StatusBar(QWidget *parent) : QStatusBar(parent)
|
|
|
{
|
|
|
setSizeGripEnabled(true);
|
|
|
// QWidget *le = new QLabel(this);//QButton *button = new
|
|
|
// QButton(this);
|
|
|
// QLineEdit *le=new QLineEdit(this);
|
|
|
|
|
|
// showMessage ( const QString & message, int timeout = 0 )
|
|
|
// showMessage("aaaaaa");
|
|
|
label = new QLabel(this); // QButton *button = new QButton(this);
|
|
|
// label->setText ("") ;
|
|
|
label->setFrameShape(QFrame::NoFrame);
|
|
|
// label->setFrameShape (QFrame::StyledPanel);
|
|
|
// label->setFrameShape (QFrame::Panel);
|
|
|
// label->setFrameShape (QFrame::WinPanel);
|
|
|
// label->setFrameShadow(QFrame::Sunken);
|
|
|
// button2 = new QToolButton(this);//QButton *button = new
|
|
|
// QButton(this);
|
|
|
// button2->setTextLabel ("") ;
|
|
|
// button2->setUsesTextLabel ( true );
|
|
|
// button2->setAutoRaise(true);
|
|
|
// button3 = new QLabel(this);//QButton *button = new
|
|
|
// QButton(this);
|
|
|
// button3->setText ("") ;
|
|
|
// addPermanentWidget(label);
|
|
|
addWidget(label);
|
|
|
// addPermanentWidget(le,1);
|
|
|
}
|
|
|
|
|
|
void StatusBar::refresh() {}
|
|
|
|
|
|
extern int num_opened_files;
|
|
|
void StatusBar::update(int total_n)
|
|
|
{
|
|
|
QString str;
|
|
|
int x = 0;
|
|
|
label->setText("Process count: " + str.setNum(total_n));
|
|
|
// button2->setTextLabel ("Network Process(testing): "+
|
|
|
// str.setNum(Procinfo::num_network_process));
|
|
|
// button3->setText ("Opened files : "+
|
|
|
// str.setNum(num_opened_files));
|
|
|
}
|
|
|
|
|
|
#include <QHBoxLayout>
|
|
|
|
|
|
// Pstable or Procview
|
|
|
// Location :
|
|
|
QSpacerItem *stretch;
|
|
|
ControlBar::ControlBar(QWidget *parent) : QFrame(parent)
|
|
|
{
|
|
|
int h;
|
|
|
// setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Expanding);
|
|
|
setFrameStyle(QFrame::NoFrame);
|
|
|
// setFrameStyle(Panel | Raised);//bad
|
|
|
// setFrameStyle(Panel ); //bad
|
|
|
layout = new QHBoxLayout(this);
|
|
|
layout->addSpacing(4); // left gap
|
|
|
layout->setMargin(0);
|
|
|
|
|
|
// setStyleSheet(" QFrame,QCheckBox,QRadioButton { color: rgb(244, 244, 244);\
|
|
|
border-image: url(:/icon/vista.png); } ");
|
|
|
/* Frame { background-color: yellow }
|
|
|
* border: 2px solid #8f8f91;
|
|
|
min-width: 80px; */
|
|
|
/* image: url(:/icon/vista.png);*/
|
|
|
|
|
|
b_linear = new QRadioButton("Linear", this);
|
|
|
b_linear->setFocusPolicy(Qt::NoFocus);
|
|
|
|
|
|
b_tree = new QRadioButton("Tree", this);
|
|
|
b_tree->setFocusPolicy(Qt::NoFocus);
|
|
|
|
|
|
search_box = new SearchBox(this);
|
|
|
connect(b_linear, SIGNAL(clicked()), SLOT(linear_clicked()));
|
|
|
connect(b_tree, SIGNAL(clicked()), SLOT(tree_clicked()));
|
|
|
connect(search_box, SIGNAL(textChanged(const QString &)),
|
|
|
SLOT(event_search_box_changed()));
|
|
|
// search_box->setFocusPolicy(Qt::NoFocus);
|
|
|
// search_box->setFocus (Qt::ActiveWindowFocusReason);
|
|
|
// search_box->setFocusProxy ( parent );
|
|
|
|
|
|
if (flag_thread_ok)
|
|
|
{
|
|
|
check_thread = new QCheckBox("Thread", this);
|
|
|
check_thread->setFocusPolicy(Qt::NoFocus);
|
|
|
connect(check_thread, SIGNAL(clicked()), SLOT(show_thread_clicked()));
|
|
|
check_thread->setChecked(flag_show_thread);
|
|
|
}
|
|
|
|
|
|
view = new QComboBox(this);
|
|
|
view->insertItem(0, "All Processes", Procview::ALL);
|
|
|
view->insertItem(1, "Your Processes", Procview::OWNED);
|
|
|
view->insertItem(2, "Non-Root Processes", Procview::NROOT);
|
|
|
view->insertItem(3, "Running Processes", Procview::RUNNING);
|
|
|
connect(view, SIGNAL(activated(int)), SLOT(view_changed(int)));
|
|
|
view->setFocusPolicy(Qt::NoFocus);
|
|
|
// PAUSED view->insertItem("Hidden Processes", Procview::HIDDEN);
|
|
|
|
|
|
layout->addWidget(b_linear);
|
|
|
layout->addWidget(b_tree);
|
|
|
if (flag_thread_ok)
|
|
|
layout->addWidget(check_thread);
|
|
|
layout->addWidget(search_box);
|
|
|
layout->addWidget(view);
|
|
|
|
|
|
// stretch=new QSpacerItem(0,0,QSizePolicy::Expanding);
|
|
|
// layout->addItem(stretch);
|
|
|
layout->addStretch();
|
|
|
|
|
|
/*
|
|
|
QPushButton *mb=new QPushButton;
|
|
|
mb->setContentsMargins(0,0,0,0);
|
|
|
//mb->setDown(true);
|
|
|
mb->setCheckable(true);
|
|
|
mb->setText("pause");
|
|
|
mb->setFixedWidth(32);
|
|
|
mb->setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum);
|
|
|
layout->addWidget(mb);
|
|
|
*/
|
|
|
|
|
|
pauseButton = new QToolButton;
|
|
|
// QPushButton *pauseButton = new QPushButton;
|
|
|
pauseButton->setCheckable(true);
|
|
|
pauseButton->setIcon(QIcon(":/icon/pause.png"));
|
|
|
pauseButton->setIconSize(QSize(19, 19));
|
|
|
pauseButton->setToolTip(tr("Pause (Ctrl+Space)"));
|
|
|
pauseButton->setFocusPolicy(Qt::NoFocus);
|
|
|
// pauseButton->setFlat(true);
|
|
|
pauseButton->setAutoRaise(true);
|
|
|
connect(pauseButton, SIGNAL(clicked(bool)), SLOT(setPaused(bool)));
|
|
|
|
|
|
layout->addWidget(pauseButton);
|
|
|
|
|
|
setLayout(layout);
|
|
|
}
|
|
|
|
|
|
void PSTABLE_SETTREEMODE(bool mode);
|
|
|
void ControlBar::setMode(bool treemode) // just.. interface function
|
|
|
{
|
|
|
b_linear->setChecked(!treemode);
|
|
|
b_tree->setChecked(treemode);
|
|
|
|
|
|
PSTABLE_SETTREEMODE(treemode); // pstable->setTreeMode(treemode);
|
|
|
}
|
|
|
|
|
|
#include <QAction>
|
|
|
void ControlBar::view_changed(int idx)
|
|
|
{
|
|
|
QAction act(this);
|
|
|
act.setData(QVariant(idx));
|
|
|
emit viewChange(&act);
|
|
|
}
|
|
|
|
|
|
extern bool flag_refresh;
|
|
|
void ControlBar::setPaused(bool b)
|
|
|
{
|
|
|
flag_refresh = !b;
|
|
|
// if(!pauseButton->isDown()) pauseButton->setDown(true);
|
|
|
}
|
|
|
|
|
|
void ControlBar::linear_clicked()
|
|
|
{
|
|
|
setMode(false);
|
|
|
// emit modeChange(FALSE);
|
|
|
}
|
|
|
|
|
|
void ControlBar::tree_clicked()
|
|
|
{
|
|
|
setMode(true);
|
|
|
// emit modeChange(TRUE);
|
|
|
}
|
|
|
|
|
|
void ControlBar::show_thread_clicked()
|
|
|
{
|
|
|
flag_show_thread = check_thread->isChecked();
|
|
|
emit need_refresh();
|
|
|
}
|
|
|
|
|
|
void ControlBar::event_search_box_changed()
|
|
|
{
|
|
|
// printf("search_box changed!\n");
|
|
|
}
|
|
|
|
|
|
void ControlBar::event_command_pressed()
|
|
|
{
|
|
|
// printf("command!\n");
|
|
|
}
|
|
|
|
|
|
// not used
|
|
|
void ControlBar::update_bar() // trick for Command
|
|
|
{
|
|
|
}
|
|
|
|
|
|
// called after resize()
|
|
|
// simplified by fasthyun@magicn.com
|
|
|
|
|
|
extern bool flag_smallscreen;
|
|
|
|
|
|
void ControlBar::resizeEvent(QResizeEvent *e)
|
|
|
{
|
|
|
return;
|
|
|
// QLayoutItem *item=layout->takeAt (layout->count()-1);
|
|
|
// return;
|
|
|
if (flag_smallscreen)
|
|
|
{
|
|
|
search_box->hide();
|
|
|
pauseButton->hide();
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
search_box->show();
|
|
|
pauseButton->show();
|
|
|
}
|
|
|
|
|
|
// printf("size=%d\n",stretch->geometry().width());
|
|
|
// printf("hsize=%d\n",stretch->sizeHint().height());
|
|
|
// QSize s=e->size();
|
|
|
return;
|
|
|
/*
|
|
|
if(stretch->geometry().width()==0)
|
|
|
search_box->hide();
|
|
|
else
|
|
|
search_box->show();
|
|
|
*/
|
|
|
|
|
|
/* setMaximumHeight (b_tree->sizeHint().height()+2);
|
|
|
search_box->setMaximumHeight(height()-4);
|
|
|
//search_box->setMinimumHeight(height()-5);
|
|
|
|
|
|
for(i=0;i< commands.size();i++)
|
|
|
{
|
|
|
QToolButton *b;
|
|
|
b=commands[i]->toolbutton;
|
|
|
if(commands[i]->toolbar==true)
|
|
|
{
|
|
|
if (layout->findWidget(b)<0)
|
|
|
layout->addWidget(b);
|
|
|
b->show();
|
|
|
}
|
|
|
else
|
|
|
if(b!=NULL)
|
|
|
b->hide();
|
|
|
} */
|
|
|
}
|
|
|
|
|
|
void ServerAdaptor::accelerate() {}
|
|
|
|
|
|
//#include <QtDBus>
|
|
|
//#include <QDBusServer>
|
|
|
//#include <QtDBus/QDBusConnection>
|
|
|
#include <QDBusConnection>
|
|
|
// ServerAdaptor::ServerAdaptor(){ }
|
|
|
// ServerAdaptor::~ServerAdaptor(){}
|
|
|
|
|
|
#define SERVICE_NAME "com.trolltech.qps"
|
|
|
void dbus_register_server()
|
|
|
{
|
|
|
ServerAdaptor *sv = new ServerAdaptor();
|
|
|
QDBusConnection connection = QDBusConnection::sessionBus(); // user only??
|
|
|
// QDBusConnection connection = QDBusConnection::systemBus(); //user
|
|
|
// only??
|
|
|
connection.registerObject("/QPS_OBJ", sv);
|
|
|
connection.registerService(SERVICE_NAME); //
|
|
|
}
|
|
|
|
|
|
#include <QtDebug>
|
|
|
void qdbus_client()
|
|
|
{
|
|
|
// connection.connect ( SERVICE_NAME,"path", "interface","name",
|
|
|
// QObject *
|
|
|
// receiver, const char * slot );
|
|
|
|
|
|
// QDBusConnection conn =
|
|
|
// QDBusConnection::connectToBus(SERVICE_NAME,"hyun");
|
|
|
|
|
|
QDBusConnection conn = QDBusConnection::sessionBus(); // owner-user
|
|
|
// only, hang..
|
|
|
// blocked !!!
|
|
|
|
|
|
QDBusReply<QStringList> reply = conn.interface()->registeredServiceNames();
|
|
|
|
|
|
if (!reply.isValid())
|
|
|
{
|
|
|
qDebug() << "qdbus_client Error:" << reply.error().message();
|
|
|
// exit(1);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
foreach (QString name, reply.value())
|
|
|
{
|
|
|
qDebug() << name;
|
|
|
//printf("name %s, value %s \n",qPrintable(name),
|
|
|
} */
|
|
|
|
|
|
if (conn.interface()->isServiceRegistered(SERVICE_NAME))
|
|
|
{
|
|
|
printf("Qps: Already another QPS is running...\n");
|
|
|
exit(1);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void check_qps_running()
|
|
|
{
|
|
|
// QDBusServer *server=QDBusServer("xaddr"); //peer2peer mode
|
|
|
// service,path,interface,name
|
|
|
// connect(server, SIGNAL(clicked()), SLOT(event_xbutton_clicked()));
|
|
|
// SIGNAL(newConnection ( const QDBusConnection & connection ))
|
|
|
// QDBusConnection::connectToBus ("xaddr", "name" );
|
|
|
|
|
|
// glib_dbus_getlist();
|
|
|
// glib_dbus_server();
|
|
|
|
|
|
qdbus_client(); // hang... on root-user
|
|
|
// printf("D1-1-3\n");
|
|
|
dbus_register_server();
|
|
|
// printf("D1-1-6\n");
|
|
|
}
|
|
|
|
|
|
char *read_proc_file(const char *fname, int pid = -1, int tgid = -1); // Temp
|
|
|
void init_misc(QWidget *main)
|
|
|
{
|
|
|
|
|
|
init_xpm(); // xpm image file load
|
|
|
|
|
|
if (true) // TESTING
|
|
|
{
|
|
|
}
|
|
|
|
|
|
#ifdef LINUX
|
|
|
if (false or flag_devel) // thread's Name Change test
|
|
|
{
|
|
|
QThread *task = new MyThread();
|
|
|
task->start();
|
|
|
task = new MyThread2();
|
|
|
task->start();
|
|
|
}
|
|
|
#endif
|
|
|
|
|
|
if (false) // test mini_sscanf()
|
|
|
{
|
|
|
char *buf;
|
|
|
int val;
|
|
|
char sstr[32] = "pu%s";
|
|
|
char buffer[128];
|
|
|
|
|
|
if ((buf = read_proc_file("stat", 1)) == 0)
|
|
|
{
|
|
|
printf("cant open [%s]\n", "sss");
|
|
|
}
|
|
|
if (mini_sscanf(buf, sstr, &val) != 0)
|
|
|
printf("found [%s] val=%d \n", sstr, val);
|
|
|
if (mini_sscanf(buf, "(%s)", &buffer) != 0)
|
|
|
printf("found str=%s \n", buffer);
|
|
|
|
|
|
abort();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
QTabWidgetX::QTabWidgetX(QWidget *parent) {}
|
|
|
|
|
|
void QTabWidgetX::showTab(bool flag)
|
|
|
{
|
|
|
|
|
|
QTabBar *tb = tabBar();
|
|
|
// tb->setDrawBase(false); //??
|
|
|
|
|
|
if (flag)
|
|
|
tb->show();
|
|
|
else
|
|
|
tb->hide();
|
|
|
// if flag_useTabView == false
|
|
|
#if QT_VERSION > 0x040500
|
|
|
// setDocumentMode (true); // QT 4.5
|
|
|
#endif
|
|
|
}
|
