SystemWindow::SystemWindow() : QDialog(), ui(new Ui::SystemWindow){
ui->setupUi(this); //load the designer file
//Setup the window flags
this->setWindowFlags( Qt::Tool | Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint);
//Setup the icons based on the current theme
ui->tool_logout->setIcon( LXDG::findIcon("system-log-out","") );
ui->tool_restart->setIcon( LXDG::findIcon("system-reboot","") );
ui->tool_shutdown->setIcon( LXDG::findIcon("system-shutdown","") );
ui->push_cancel->setIcon( LXDG::findIcon("dialog-cancel","") );
ui->push_lock->setIcon( LXDG::findIcon("system-lock-screen","") );
//Connect the signals/slots
connect(ui->tool_logout, SIGNAL(clicked()), this, SLOT(sysLogout()) );
connect(ui->tool_restart, SIGNAL(clicked()), this, SLOT(sysRestart()) );
connect(ui->tool_shutdown, SIGNAL(clicked()), this, SLOT(sysShutdown()) );
connect(ui->push_cancel, SIGNAL(clicked()), this, SLOT(sysCancel()) );
connect(ui->push_lock, SIGNAL(clicked()), this, SLOT(sysLock()) );
//Disable the shutdown/restart buttons if necessary
if( !LOS::userHasShutdownAccess() ){
ui->tool_restart->setEnabled(false);
ui->tool_shutdown->setEnabled(false);
}
//Center this window on the screen
QDesktopWidget desktop;
this->move(desktop.screenGeometry().width()/2 - this->width()/2, desktop.screenGeometry().height()/2 - this->height()/2);
this->show();
}
void PCDMgui::fillScreens(){
//Set a background image on any other available screens
QDesktopWidget *DE = QApplication::desktop();
screens.clear();
//Generate the background style sheet
//QString tmpIcon = currentTheme->itemIcon("background");
//if( tmpIcon.isEmpty() || !QFile::exists(tmpIcon) ){ tmpIcon = ":/images/backgroundimage.jpg"; }
//QString bgstyle = "QWidget#BGSCREEN{border-image: url(BGIMAGE) stretch;}";
//bgstyle.replace("BGIMAGE", tmpIcon);
//this->setStyleSheet(bgstyle);
//Now apply the background to all the other screens
// - Keep track of the total width/height of all screens combined (need to set the QMainWindow to this size)
int wid, high;
wid = high = 0;
for(int i=0; i<DE->screenCount(); i++){
//if(i != DE->screenNumber(this)){
//Just show a generic QWidget with the proper background image on every screen
QWidget *screen = new QWidget(this->centralWidget());
screen->setObjectName("BGSCREEN");
QRect rec = DE->screenGeometry(i);
screen->setGeometry( rec );
if(rec.height() > high){ high = rec.height(); }
wid += rec.width();
//screen->setStyleSheet(bgstyle);
screen->show();
screens << screen;
/*}else{
//Now move the mouse cursor over this window (fix for multi-monitor setups)
QCursor::setPos( DE->screenGeometry(i).center() );
}*/
}
this->setGeometry(0,0,wid,high);
this->activateWindow();
QCursor::setPos( DE->screenGeometry(0).center() );
}
/*************ClientP: Delete Acc******************/
void MainWindow::on_btnDC_clicked()
{
QMessageBox message(QMessageBox::Warning,"Are you sure?","Once it did, it can not be undo!",QMessageBox::Yes|QMessageBox::No,NULL);
if (message.exec()==QMessageBox::Yes)
{
showme("yes!");
Msg msg=sendAndGet(userName_,userPassword_,"dc","","","","","","");
bool flag=msg.opResult;
if(!flag){
showme("Error in delete User");
}
ui->stackedWidget->setCurrentIndex(0);
ui->widgetWelcome->show();
ui->widgetLog->hide();
QDesktopWidget* desktopWidget = QApplication::desktop();
int winWidth=desktopWidget->screenGeometry().width();
int winHeight=desktopWidget->screenGeometry().height();
QRect winRect((winWidth-400)/2,(winHeight-300)/2,400,300);
this->setGeometry(winRect);
this->setFixedSize(400,300);
userName_="";
userPassword_="";
}
else
{
showme("no!");
}
}
void RegionGrab::init()
{
m_pixmap = m_grabber->grabFullScreen();
QDesktopWidget *desktop = QApplication::desktop();
QRect rect;
if (desktop->screenCount() > 1) {
for (int i = 0; i < desktop->screenCount(); ++i) {
if (rect.isNull())
rect = desktop->screenGeometry(i);
else
rect = rect.united(desktop->screenGeometry(i));
}
}
else
rect = QRect(QPoint(0, 0), m_pixmap.size());
resize(rect.size());
move(rect.topLeft());
setCursor(Qt::CrossCursor);
# ifdef Q_OS_MAC
showFullScreen();
# else
show();
# endif
raise();
activateWindow();
setFocus();
}
QPoint InviwoApplicationQt::movePointOntoDesktop(const QPoint& point, const QSize& size,
bool decorationOffset) {
QPoint pos(point);
if (movePointsOn_) {
QDesktopWidget* desktop = QApplication::desktop();
int primaryScreenIndex = desktop->primaryScreen();
QRect wholeScreen = desktop->screenGeometry(primaryScreenIndex);
for (int i = 0; i < desktop->screenCount(); i++) {
if (i != primaryScreenIndex) wholeScreen = wholeScreen.united(desktop->screenGeometry(i));
}
wholeScreen.setRect(wholeScreen.x() - 10, wholeScreen.y() - 10, wholeScreen.width() + 20,
wholeScreen.height() + 20);
QPoint bottomRight = QPoint(point.x() + size.width(), point.y() + size.height());
QPoint appPos = getMainWindow()->pos();
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
if (decorationOffset) {
QPoint offset = getWindowDecorationOffset();
pos -= offset;
}
#endif
if (!wholeScreen.contains(pos) || !wholeScreen.contains(bottomRight)) {
// If the widget is outside visible screen
pos = appPos;
pos += offsetWidget();
}
}
return pos;
}
void DianVoteControl::mouseMoveEvent(QMouseEvent *event)
{
QDesktopWidget* desktopWidget = QApplication::desktop();
//获取设备屏幕大小
int screenWidth = desktopWidget->screenGeometry().width();
int screenHeight = desktopWidget->screenGeometry().height();
if (event->buttons() & Qt::LeftButton) {
QPoint pos = event->globalPos() - dragPosition;
if((pos.x() <= DEFAULT_DOCK_SPACE))
{
pos.setX(0);
}
else if((pos.x() + this->width() + DEFAULT_DOCK_SPACE) \
>= screenWidth)
{
pos.setX(screenWidth - this->width() - 2);
}
if((pos.y() <= DEFAULT_DOCK_SPACE))
{
pos.setY(0);
}
else if((pos.y() + this->height() + DEFAULT_DOCK_SPACE) \
>= screenHeight)
{
pos.setY(screenHeight - this->height() - 2);
}
move(pos);
event->accept();
}
}
SpriteSceneConverter::SpriteSceneConverter(QWidget *parent)
: QWidget(parent)
{
ui.setupUi(this);
QDesktopWidget desktop;
int width = desktop.screenGeometry(0).width();
int height = desktop.screenGeometry(0).height();
QRect q = this->geometry();
this->setGeometry(width/2-q.width()/2,height/2-q.height()/2,q.width(),q.height());
mScene = new QGraphicsScene(this);
ui.elementoPreview->setScene(mScene);
mScene->addPixmap(mMap);
mModelo = new QStandardItemModel();
ui.elementosTabla->setModel(mModelo);
ui.elementosTabla->horizontalHeader()->setResizeMode(0, QHeaderView::ResizeToContents);
ui.elementosTabla->horizontalHeader()->setResizeMode(3, QHeaderView::ResizeToContents);
PointDelegate* pointDelegate = new PointDelegate();
TexturasDelegate* texturasDelegate = new TexturasDelegate();
ui.elementosTabla->setItemDelegateForColumn(1,pointDelegate);
ui.elementosTabla->setItemDelegateForColumn(2,pointDelegate);
ui.elementosTabla->setItemDelegateForColumn(3,texturasDelegate);
connect(
ui.elementosTabla->selectionModel(),
SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)),
SLOT(selectionChanged(const QItemSelection &, const QItemSelection &))
);
}
void scene::newGame() {
gfxitems.clear();
QDesktopWidget desktop;
game = new pong(desktop.screenGeometry().width()-30, desktop.screenGeometry().height()-40);
//game = new pong(desktop.width(), desktop.height());
std::ifstream level(gametype.toStdString().c_str());
qDebug()<<"reading file "<<gametype;
std::string type;
float x;
float speed_mult;
short pos;
float wrong_ai;
std::string bonus_name_string;
while (level.good()) {
level>>type;
if (type=="new:bar") {
level>>x;
level>>speed_mult;
level>>pos;
new bar(game,
x,
(game->getHeight()-settings->value("bar/height").toFloat())/2,
settings->value("bar/width").toFloat(),
settings->value("bar/height").toFloat(),
speed_mult,
element::directions(pos),
settings->value("bar/touch_dx_comeback").toFloat(),
settings->value("bar/touch_straight").toFloat());
} else if (type=="new:bar_ai") {
GrabResolutions MediaSourceDesktop::GetSupportedVideoGrabResolutions()
{
VideoFormatDescriptor tFormat;
mSupportedVideoFormats.clear();
tFormat.Name="CIF"; // 352 × 288
tFormat.ResX = 352;
tFormat.ResY = 288;
mSupportedVideoFormats.push_back(tFormat);
tFormat.Name="VGA"; // 640 * 480
tFormat.ResX = 640;
tFormat.ResY = 480;
mSupportedVideoFormats.push_back(tFormat);
tFormat.Name="DVD"; // 720 × 576
tFormat.ResX = 720;
tFormat.ResY = 576;
mSupportedVideoFormats.push_back(tFormat);
tFormat.Name="CIF9"; // 1056 × 864
tFormat.ResX = 1056;
tFormat.ResY = 864;
mSupportedVideoFormats.push_back(tFormat);
tFormat.Name="SXGA"; // 1280 × 1024
tFormat.ResX = 1280;
tFormat.ResY = 1024;
mSupportedVideoFormats.push_back(tFormat);
tFormat.Name="WXGA+"; // 1440 × 900
tFormat.ResX = 1440;
tFormat.ResY = 900;
mSupportedVideoFormats.push_back(tFormat);
tFormat.Name="SXGA+"; // 1440 × 1050
tFormat.ResX = 1440;
tFormat.ResY = 1050;
mSupportedVideoFormats.push_back(tFormat);
tFormat.Name="WUXGA"; // 1920 * 1200
tFormat.ResX = 1920;
tFormat.ResY = 1200;
mSupportedVideoFormats.push_back(tFormat);
QDesktopWidget *tDesktop = QApplication::desktop();
tFormat.Name="Desktop";
tFormat.ResX = tDesktop->screenGeometry(tDesktop->primaryScreen()).width();
tFormat.ResY = tDesktop->screenGeometry(tDesktop->primaryScreen()).height();
mSupportedVideoFormats.push_back(tFormat);
tFormat.Name="Segment";
tFormat.ResX = mSourceResX;
tFormat.ResY = mSourceResY;
mSupportedVideoFormats.push_back(tFormat);
return mSupportedVideoFormats;
}
int ConfigPanelWidget::getMaxLength()
{
QDesktopWidget* dw = QApplication::desktop();
if (mPosition == ILxQtPanel::PositionTop ||
mPosition == ILxQtPanel::PositionBottom)
return dw->screenGeometry(mScreenNum).width();
else
return dw->screenGeometry(mScreenNum).height();
}
RazorDeskManager::RazorDeskManager(const QString & configId, RazorSettings * config)
: DesktopPlugin(configId, config)
{
m_launchMode = DesktopPlugin::launchModeFromString(config->value("icon-launch-mode").toString());
config->beginGroup(configId);
bool makeIcons = config->value("icons", false).toBool();
//now we got the desktop we need to determine if the user wants a defined picture there
QString finalPixmap = config->value("wallpaper", "").toString();
config->endGroup();
if (finalPixmap.isEmpty() || !QFile::exists(finalPixmap))
{
//now we want to use the system default - we still need to find that one out though
finalPixmap = razorTheme.desktopBackground();
qDebug() << "trying to get system-defaults" << finalPixmap;
}
if (! finalPixmap.isEmpty())
{
qDebug() << "Creating wallpaper";
int width,height;
QDesktopWidget * dw = QApplication::desktop();
if (dw->screenCount() == 1)
{
width=dw->width();
height = dw->height();
}
else
{
width=dw->screenGeometry(-1).width();
height=dw->screenGeometry(-1).height();
}
QPixmap pixmap(finalPixmap);
pixmap = pixmap.scaled(width,height);
Pixmap p = pixmap.handle();
XGrabServer(QX11Info::display());
XChangeProperty(QX11Info::display(), QX11Info::appRootWindow(), XfitMan::atom("_XROOTPMAP_ID"), XA_PIXMAP, 32, PropModeReplace, (unsigned char *) &p, 1);
XChangeProperty(QX11Info::display(), QX11Info::appRootWindow(), XfitMan::atom("ESETROOT_PMAP_ID"), XA_PIXMAP, 32, PropModeReplace, (unsigned char *) &p, 1);
XSetCloseDownMode(QX11Info::display(), RetainPermanent);
XSetWindowBackgroundPixmap(QX11Info::display(), QX11Info::appRootWindow(), p);
XClearWindow(QX11Info::display(), QX11Info::appRootWindow());
XUngrabServer(QX11Info::display());
XFlush(QX11Info::display());
}
if (makeIcons)
{
deskicons = new RazorSettings("deskicons", this);
m_fsw = new QFileSystemWatcher(QStringList() << QDesktopServices::storageLocation(QDesktopServices::DesktopLocation), this);
connect(m_fsw, SIGNAL(directoryChanged(const QString&)), this, SLOT(updateIconList()));
updateIconList();
}
}
int main(int argc, char *argv[])
{
QApplication::setAttribute(Qt::AA_UseOpenGLES,true);
QApplication a(argc, argv);
// MODEL
SubteState * m_subte = new SubteState();
// CONTROLLER DISPATCHER
EventHandler *m_eventHandler = new EventHandler();
// VIEWS
BoardCenter * m_c = new BoardCenter(0);
BoardAtp *m_a = new BoardAtp(0);
BoardMac *m_m = new BoardMac(0,m_subte,m_eventHandler);
BoardBottom *m_b = new BoardBottom(0);
BoardHardware *m_h = new BoardHardware(0,m_subte,m_eventHandler);
QTabWidget *m_tabs = new QTabWidget(0);
m_tabs->addTab(m_h,QObject::tr("HARDWARE"));
m_tabs->addTab(m_b,QObject::tr("BOTTOM"));
m_tabs->setMinimumWidth(1024);
m_tabs->setMinimumHeight(768);
QDesktopWidget *desktop = a.desktop();
if(desktop->screenCount() == 4){
QRect s0 = desktop->screenGeometry(0);
QRect s1 = desktop->screenGeometry(1);
QRect s2 = desktop->screenGeometry(2);
QRect s3 = desktop->screenGeometry(3);
m_c->showFullScreen();
m_a->showFullScreen();
m_m->showFullScreen();
m_tabs->showFullScreen();
m_c->move(s0.topLeft());
m_a->move(s2.topLeft());
m_m->move(s3.topLeft());
m_tabs->move(s1.topLeft());
}else{
m_c->showNormal();
m_a->showNormal();
m_m->showNormal();
m_tabs->showNormal();
}
m_eventHandler->setModel(m_subte);
m_subte->setHandler(m_eventHandler);
m_eventHandler->initConnection(qApp->applicationDirPath());
QObject::connect(m_eventHandler,SIGNAL(closeApp()),qApp,SLOT(quit()));
return a.exec();
}
EXPORT QRect screenGeometry(unsigned nScreen)
{
QDesktopWidget *desktop = QApplication::desktop();
if(nScreen == ~0U) {
QRect rc;
for (int i = 0; i < desktop->numScreens(); i++){
rc |= desktop->screenGeometry(i);
}
return rc;
}
return desktop->screenGeometry(nScreen);
}
void TupCanvas::penDialog()
{
QDesktopWidget desktop;
TupPenDialog *dialog = new TupPenDialog(k->brushManager, this);
connect(dialog, SIGNAL(updatePen(int)), this, SLOT(updateThickness(int)));
QApplication::restoreOverrideCursor();
dialog->show();
dialog->move((int) (desktop.screenGeometry().width() - dialog->width())/2 ,
(int) (desktop.screenGeometry().height() - dialog->height())/2);
}
void TupCanvas::exposureDialog()
{
QDesktopWidget desktop;
TupExposureDialog *dialog = new TupExposureDialog(k->project, k->scene->currentSceneIndex(),
k->scene->currentLayerIndex(), k->scene->currentFrameIndex(), this);
// connect(dialog, SIGNAL(updatePen(int)), this, SLOT(updateThickness(int)));
QApplication::restoreOverrideCursor();
dialog->show();
dialog->move((int) (desktop.screenGeometry().width() - dialog->width())/2 ,
(int) (desktop.screenGeometry().height() - dialog->height())/2);
}
/*************ClientP: log out******************/
void MainWindow::on_btnLO_clicked()
{
ui->stackedWidget->setCurrentIndex(0);
ui->widgetWelcome->show();
ui->widgetLog->hide();
QDesktopWidget* desktopWidget = QApplication::desktop();
int winWidth=desktopWidget->screenGeometry().width();
int winHeight=desktopWidget->screenGeometry().height();
QRect winRect((winWidth-400)/2,(winHeight-300)/2,400,300);
this->setGeometry(winRect);
this->setFixedSize(400,300);
userName_="";
userPassword_="";
}
// Return geometry of user's screen selection
bool screenSelectDialog::getFullscreenGeometry( QWidget* target, QRect& geom )
{
// Determine number of screens
QDesktopWidget* desktop = QApplication::desktop();
int numScreens = desktop->screenCount();
// If more than one screen, ask the user where to go fullscreen
if( numScreens > 1 )
{
// construct the dialog
screenSelectDialog* screenSelect = new screenSelectDialog( numScreens, target );
// Get user's choice of screen
if( screenSelect->exec() == QDialog::Rejected )
{
return false;
}
// Determine the geometry of the user's choice
int screenId = screenSelect->getScreenNum();
switch( screenId )
{
case screenSelectDialog::PRIMARY_SCREEN:
geom = desktop->screenGeometry( desktop->primaryScreen() );
break;
case screenSelectDialog::THIS_SCREEN:
geom = desktop->screenGeometry( target );
break;
case screenSelectDialog::ALL_SCREENS:
geom = desktop->geometry();
break;
default:
geom = desktop->screenGeometry( screenId );
break;
}
}
// If only one screen, just get it's geometry
else
{
geom = desktop->screenGeometry( desktop->primaryScreen() );
}
// All done
return true;
}
void regionEditDialog::listReady(void)
{
disconnect(link, SIGNAL(success()), 0, 0);
regionSelector.clear();
regionSelector.addItem("");
regionSelector.addItems(link->getRegionList());
regionSelector.setCurrentIndex(0);
connect(®ionSelector, SIGNAL(currentIndexChanged(int)), this, SLOT(changeRegion(int)));
window->setEnabled(0);
show();
QDesktopWidget screen;
move((screen.screenGeometry().width() - size().width())/2, (screen.screenGeometry().height() - size().height())/2);
}
ObjKsTheme::ObjKsTheme( const QString& theme )
:mActiveTheme (theme), mThemeDir("/"), mThemeConfig (0L), mThemePrefix( "Themes/" ), d(0)
{
// Get Xinerama config.
KConfig *config = kapp->config();
config->setGroup( "Xinerama" );
QDesktopWidget *desktop = kapp->desktop();
mXineramaScreen = config->readNumEntry("KSplashScreen", desktop->primaryScreen());
// For Xinerama, let's put the mouse on the first head. Otherwise it could appear anywhere!
if (desktop->isVirtualDesktop() && mXineramaScreen != -2)
{
QRect rect = desktop->screenGeometry( mXineramaScreen );
if (!rect.contains(QCursor::pos()))
QCursor::setPos(rect.center());
}
// Does the active theme exist?
if( !loadThemeRc( mActiveTheme, false ) )
if( !loadLocalConfig( mActiveTheme, false ) )
if( !loadThemeRc( "Default", false ) )
loadLocalConfig( "Default", true ); //force: we need some defaults
loadCmdLineArgs(KCmdLineArgs::parsedArgs());
mThemePrefix += ( mActiveTheme + "/" );
}
void VisibleAreaMode::stop(int x, int y) {
toolbar_.appView().setMouseTracking(false);
move(x, y);
const int padding = 10;
QDesktopWidget *desktop = QApplication::desktop();
QRect geo = desktop->screenGeometry(desktop->screenNumber(QCursor::pos()));
// Width
int formX = area.x + area.width + 28;
int screenWidth = geo.width();
int formWidth = toolbar_.width();
if (formX + formWidth + padding > screenWidth) {
formX = screenWidth - formWidth - padding;
}
// Height
int formHeight = toolbar_.height();
int formY = area.y + area.height / 2 - formHeight / 2;
int screenHeight = geo.height();
if (formY < padding) {
formY = padding;
} else if (formY + formHeight + padding > screenHeight) {
formY = screenHeight - formHeight - padding;
}
toolbar_.setGeometry(formX, formY, formWidth, formHeight);
toolbar_.show();
}
void VisibleAreaMode::set(int x, int y, int width, int height) {
int sceneWidth = scene_.width(),
sceneHeight = scene_.height();
rectTop->setRect(0, 0, sceneWidth, y);
rectBottom->setRect(0, y + height, sceneWidth, sceneHeight - y - height);
rectLeft->setRect(0, y, x, height);
rectRight->setRect(x + width, y, sceneWidth - x - width, height);
QDesktopWidget *desktop = QApplication::desktop();
QRect geo = desktop->screenGeometry(desktop->screenNumber(QCursor::pos()));
int screenWidth = geo.width();
int screenHeight = geo.height();
// Horizontal and vertical lines
if (0 == width && 0 == height) {
lineTop->setLine(0, y, screenWidth, y);
lineLeft->setLine(x, 0, x, screenHeight);
return;
}
lineTop->setLine(0, y - 1, screenWidth, y - 1);
lineBottom->setLine(0, y + height + 1, screenWidth, y + height + 1);
lineLeft->setLine(x - 1, 0, x - 1, screenHeight);
lineRight->setLine(x + width + 1, 0, x + width + 1, sceneHeight);
}
void VSCMainWindows::EditVGroup(int nId)
{
VSCIPCGroupConf group;
VSCVGroupDataItem groupItem;
gFactory->GetVGroupById(groupItem, nId);
group.SetName(groupItem.Name);
group.show();
QDesktopWidget *desktop = QApplication::desktop();
QRect rect = desktop->screenGeometry(0);
group.setGeometry(rect.width()/2 -group.width()/2 ,
rect.height()/2 - group.height()/2,
group.width(), group.height());
group.exec();
VSCIPCGroupConfType type = group.GetType();
if (type == VSC_IPCGROUP_CONF_LAST
|| type == VSC_IPCGROUP_CONF_CANCEL)
{
return;
}
string strName = "Group";
group.GetName(strName);
strcpy(groupItem.Name, strName.c_str());
gFactory->AddVGroup(groupItem);
}
void tst_QDesktopWidget::screenNumberForQPoint()
{
// make sure QDesktopWidget::screenNumber(QPoint) returns the correct screen
QDesktopWidget *desktopWidget = QApplication::desktop();
QRect allScreens;
for (int i = 0; i < desktopWidget->numScreens(); ++i) {
QRect screenGeometry = desktopWidget->screenGeometry(i);
QCOMPARE(desktopWidget->screenNumber(screenGeometry.center()), i);
allScreens |= screenGeometry;
}
// make sure QDesktopWidget::screenNumber(QPoint) returns a valid screen for points that aren't on any screen
int screen;
screen = desktopWidget->screenNumber(allScreens.topLeft() - QPoint(1, 1));
#ifdef Q_WS_QWS
QEXPECT_FAIL("", "Task 151710", Abort);
#endif
QVERIFY(screen >= 0 && screen < desktopWidget->numScreens());
screen = desktopWidget->screenNumber(allScreens.topRight() + QPoint(1, 1));
QVERIFY(screen >= 0 && screen < desktopWidget->numScreens());
screen = desktopWidget->screenNumber(allScreens.bottomLeft() - QPoint(1, 1));
QVERIFY(screen >= 0 && screen < desktopWidget->numScreens());
screen = desktopWidget->screenNumber(allScreens.bottomRight() + QPoint(1, 1));
QVERIFY(screen >= 0 && screen < desktopWidget->numScreens());
}
int CaptureDialog::update_screen_combo(void)
{
//disable signals
screen_combo->blockSignals(true);
//save current value
int current = screen_combo->currentIndex();
//update combo
QStringList list;
screen_combo->clear();
QDesktopWidget * desktop = QApplication::desktop();
int screens = desktop->screenCount();
for (int i=0; i<screens; i++)
{
const QRect rect = desktop->screenGeometry(i);
list.append(QString("Screen %1 [%2x%3]").arg(i).arg(rect.width()).arg(rect.height()));
}
screen_combo->addItems(list);
//set current value
int saved_value = APP->config.value("capture/projector_screen", 1).toInt();
int default_screen = (saved_value<screen_combo->count() ? saved_value : 0);
screen_combo->setCurrentIndex((-1<current && current<screen_combo->count() ? current : default_screen));
//enable signals
screen_combo->blockSignals(false);
return screen_combo->count();
}
LapUSMouse::LapUSMouse(mtsIntuitiveDaVinci *daVinci ,QWidget* mainWidget) {
// this->parent = parent;
this->daVinci = daVinci;
this->mainWidget = mainWidget;
setAutoFillBackground(true);
setScaledContents(true);
resize(50,50);
setText("I am a mouse");
//setPixmap(Qt::red);
setWindowFlags(Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint);
setupDaVinci();
//update the first time
updateDaVinci();
QDesktopWidget *desk = QApplication::desktop();
if(desk)
screenSize = desk->screenGeometry(0);
std::cout<<"Screen size width "<<screenSize.width()<<std::endl;
std::cout<<"Screen size height "<<screenSize.height()<<std::endl;
// connect with the timer to update the mouse position every 50 milliseconds
connect( &timer, SIGNAL(timeout()), this, SLOT(updateMouse()) );
timer.start( 100 );
}
VideoOutWindow::VideoOutWindow() :
// DB settings
db_move(0, 0), db_scale_horiz(0.0f), db_scale_vert(0.0f),
db_pip_size(26),
db_scaling_allowed(true),
using_xinerama(false), screen_num(0), screen_geom(0, 0, 1024, 768),
// Manual Zoom
mz_scale_v(1.0f), mz_scale_h(1.0f), mz_move(0, 0),
// Physical dimensions
display_dim(400, 300), display_aspect(1.3333f),
// Video dimensions
video_dim(640, 480), video_disp_dim(640, 480),
video_dim_act(640, 480), video_aspect(1.3333f),
// Aspect override
overriden_video_aspect(1.3333f), aspectoverride(kAspect_Off),
// Adjust Fill
adjustfill(kAdjustFill_Off),
// Screen settings
video_rect(0, 0, 0, 0),
display_video_rect(0, 0, 0, 0),
display_visible_rect(0, 0, 0, 0),
tmp_display_visible_rect(0, 0, 0, 0),
// Various state variables
embedding(false), needrepaint(false),
allowpreviewepg(true), pip_state(kPIPOff)
{
db_pip_size = gCoreContext->GetNumSetting("PIPSize", 26);
db_move = QPoint(gCoreContext->GetNumSetting("xScanDisplacement", 0),
gCoreContext->GetNumSetting("yScanDisplacement", 0));
db_use_gui_size = gCoreContext->GetNumSetting("GuiSizeForTV", 0);
QDesktopWidget *desktop = NULL;
if (QApplication::type() == QApplication::GuiClient)
desktop = QApplication::desktop();
if (desktop)
{
screen_num = desktop->primaryScreen();
using_xinerama = (GetNumberXineramaScreens() > 1);
if (using_xinerama)
{
screen_num = gCoreContext->GetNumSetting("XineramaScreen", screen_num);
if (screen_num >= desktop->numScreens())
screen_num = 0;
}
screen_geom = desktop->geometry();
if (screen_num >= 0)
screen_geom = desktop->screenGeometry(screen_num);
}
}
bool Worker::setImage(QString &path)
{
QImage source(path), dest;
if (source.isNull())
return false;
QDesktopWidget *desktop = QApplication::desktop();
QRect geo = desktop->screenGeometry(desktop->primaryScreen());
int lw = geo.width();
int lh = geo.height();
float iw = source.width();
float ih = source.height();
if ((iw <= lw) && (ih <= lh))
dest = source;
else
if ((iw / lw) > (ih / lh))
dest = source.scaledToWidth(lw, Qt::SmoothTransformation);
else
dest = source.scaledToHeight(lh, Qt::SmoothTransformation);
setPixmap(QPixmap::fromImage(dest));
return true;
}
EXPORT QRect screenGeometry(unsigned nScreen)
{
#if QT_VERSION >= 300
QDesktopWidget *desktop = QApplication::desktop();
return desktop->screenGeometry(nScreen);
#else
#ifdef WIN32
HINSTANCE hLib = LoadLibraryA("user32.dll");
BOOL (WINAPI *_EnumDisplayMonitors)(HDC, LPCRECT, MONITORENUMPROC, LPARAM) = NULL;
(DWORD&)_EnumDisplayMonitors = (DWORD)GetProcAddress(hLib, "EnumDisplayMonitors");
if (_EnumDisplayMonitors == NULL){
FreeLibrary(hLib);
return QApplication::desktop()->rect();
}
vector<QRect> rc;
if (_EnumDisplayMonitors(NULL, NULL, enumScreens, (LPARAM)&rc) == 0){
FreeLibrary(hLib);
return QApplication::desktop()->rect();
}
return rc[nScreen];
#else
return QApplication::desktop()->rect();
#endif
#endif
}
void QtToaster::changeToasterPosition() {
QDesktopWidget * desktop = QApplication::desktop();
QPoint p = _toaster->pos();
//Toaster is showing slowly
if (_show) {
_toaster->move(p.x(), p.y() - 3);
QRect desktopGeometry = desktop->availableGeometry(desktop->primaryScreen());
if (p.y() < (desktopGeometry.bottom() - _toaster->size().height() - 5)) {
//Toaster should be hidden now
_show = false;
_timer->stop();
//Waits 5 seconds with the toaster on top
_timer->start(_timeOnTop);
}
}
//Toaster is hiding slowly
else {
_toaster->move(p.x(), p.y() + 3);
_toaster->repaint();
QRect screenGeometry = desktop->screenGeometry(desktop->primaryScreen());
_timer->stop();
_timer->start(TIME_TO_SHOW);
if (p.y() > (screenGeometry.bottom())) {
//Closes the toaster -> hide it completely
close();
}
}
}
EXPORT QRect screenGeometry()
{
#if QT_VERSION >= 300
QDesktopWidget *desktop = QApplication::desktop();
QRect rc;
for (int i = 0; i < desktop->numScreens(); i++){
rc |= desktop->screenGeometry(i);
}
return rc;
#else
#ifdef WIN32
HINSTANCE hLib = LoadLibraryA("user32.dll");
BOOL (WINAPI *_EnumDisplayMonitors)(HDC, LPCRECT, MONITORENUMPROC, LPARAM) = NULL;
(DWORD&)_EnumDisplayMonitors = (DWORD)GetProcAddress(hLib, "EnumDisplayMonitors");
if (_EnumDisplayMonitors == NULL){
FreeLibrary(hLib);
return QApplication::desktop()->rect();
}
vector<QRect> rc;
if (_EnumDisplayMonitors(NULL, NULL, enumScreens, (LPARAM)&rc) == 0){
FreeLibrary(hLib);
return QApplication::desktop()->rect();
}
QRect res;
for (vector<QRect>::iterator it = rc.begin(); it != rc.end(); ++it)
res |= (*it);
return res;
#else
return QApplication::desktop()->rect();
#endif
#endif
}
