bool set_resolution(CVideo& video , const unsigned width, const unsigned height) { SDL_Rect rect; SDL_GetClipRect(video.getSurface(), &rect); if(rect.w == width && rect.h == height) { return true; } const int flags = fullscreen() ? FULL_SCREEN : 0; int bpp = video.bppForMode(width, height, flags); if(bpp != 0) { video.setMode(width, height, bpp, flags); if(disp) { disp->redraw_everything(); } } else { // grzywacz: is this even true? gui2::show_transient_message(video,"",_("The video mode could not be changed. Your window manager must be set to 16 bits per pixel to run the game in windowed mode. Your display must support 1024x768x16 to run the game full screen.")); return false; } const std::string postfix = fullscreen() ? "resolution" : "windowsize"; preferences::set('x' + postfix, lexical_cast<std::string>(width)); preferences::set('y' + postfix, lexical_cast<std::string>(height)); return true; }
bool set_resolution(display& disp, const unsigned width, const unsigned height) { // - Ayin: disabled the following code. Why would one want to enforce that? // Some 16:9, or laptop screens, may have resolutions which do not // comply to this rule (see bug 10630). // I'm commenting this until it proves absolutely necessary. // // Make sure resolutions are always divisible by 4 //res.first &= ~3; //res.second &= ~3; SDL_Rect rect; SDL_GetClipRect(disp.video().getSurface(), &rect); if (rect.w == width && rect.h == height) { return true; } if (width < 480 || height < 320) { return false; } CVideo& video = disp.video(); const int flags = fullscreen() ? SDL_WINDOW_FULLSCREEN : 0; int bpp = video.modePossible(width, height, 32, flags); VALIDATE(bpp > 0, "bpp must be large than 0!"); video.setMode(width, height, bpp, flags); require_change_resolution = true; const std::string postfix = fullscreen() ? "resolution" : "windowsize"; preferences::set('x' + postfix, lexical_cast<std::string>(width)); preferences::set('y' + postfix, lexical_cast<std::string>(height)); return true; }
/*! Open an X11 window and create a cairo surface base on that window. If x and * y are set to 0 the function opens a full screen window and stores to window * dimensions to x and y. * @param x Pointer to width of window. * @param y Pointer to height of window. * @return Returns a pointer to a valid Xlib cairo surface. The function does * not return on error (exit(3)). */ cairo_surface_t* cairo_create_x11_surface(int *x, int *y) { Display *dsp; Drawable da; Screen *scr; int screen; cairo_surface_t *sfc; if ((dsp = XOpenDisplay(NULL)) == NULL) exit(1); screen = DefaultScreen(dsp); scr = DefaultScreenOfDisplay(dsp); if (!*x || !*y) { *x = WidthOfScreen(scr), *y = HeightOfScreen(scr); da = XCreateSimpleWindow(dsp, DefaultRootWindow(dsp), 0, 0, *x, *y, 0, 0, 0); fullscreen (dsp, da); } else da = XCreateSimpleWindow(dsp, DefaultRootWindow(dsp), 0, 0, *x, *y, 0, 0, 0); XSelectInput(dsp, da, ButtonPressMask | KeyPressMask); XMapWindow(dsp, da); sfc = cairo_xlib_surface_create(dsp, da, DefaultVisual(dsp, screen), *x, *y); cairo_xlib_surface_set_size(sfc, *x, *y); return sfc; }
char * message_client(Client *c, IxpMsg *m) { char *s; int i; s = getword(m); switch(getsym(s)) { case LKILL: kill_client(c); break; case LURGENT: i = gettoggle(m); if(i == -1) return Ebadusage; set_urgent(c, i, True); break; case LFULLSCREEN: i = gettoggle(m); if(i == -1) return Ebadusage; fullscreen(c, i); break; default: return Ebadcmd; } return nil; }
void Client::keyPressEvent(QKeyEvent *event) { if (event->key() == Qt::Key_Escape && this->isFullScreen()) { fullscreen(); } }
drawcmd () { int c; CURSOR cursor; if (H==LINES-7 && strlen (cur->shortcwd) + 3 + esclen (command) > 79) { fullscreen (); draw (); } for (c=H+5; c<LINES-1; ++c) { VMove (c, 0); VClearLine (); } VSetDim (); VMPutString (H+5, 0, cur->shortcwd); VSetBold (); VPutString (" > "); VSetNormal (); cursor = VGetCursor (); putescstr (command); if (c = command [cpos]) { VSetCursor (cursor); command [cpos] = 0; putescstr (command); command [cpos] = c; } }
/** * @brief キーボードイベント関数 */ void keyboard(unsigned char key, int x, int y) { switch (key) { case '\033': // ESC でも終了させる exit(0); break; case ' ': // スペースキーでフルスクリーンモードにする if (!Change) Change = true; else Change = false; fullscreen(); break; case 'r': // 方向転換 if (!moveChange) moveChange = true; else moveChange = false; break; } glutPostRedisplay(); // 再描画要求 }
SFAbstractApplicationUI::SFAbstractApplicationUI(bb::cascades::Application *app) : QObject(app) { //register meta types for SF classes and enums sfRegisterMetaTypes(); //Setup SFDC connection info SFAccountManager::setClientId(SFRemoteAccessConsumerKey); SFAccountManager::setRedirectUri(SFOAuthRedirectURI); //In addition, you can set up scope for your token like below. /* QList<QString> scopes; scopes.append("api"); SFAccountManager::setScopes(scopes); */ //setup API objects SFRestAPI::instance()->setApiVersion(SFDefaultRestApiVersion); //Expose API objects to QML QDeclarativeEngine *engine = QmlDocument::defaultDeclarativeEngine(); QDeclarativeContext *context = engine ? engine->rootContext() : NULL; if (context) { context->setContextProperty("SFAccountManager", SFAccountManager::instance()); context->setContextProperty("SFAuthenticationManager", SFAuthenticationManager::instance()); context->setContextProperty("SFRestAPI", SFRestAPI::instance()); } else { sfWarning() << "[SFAbstractApplicationUI] Failed to grab shared QML declarative engine. SF APIs may not be accessible in QML."; } //connect some slots connect(app, SIGNAL(aboutToQuit()), SFAuthenticationManager::instance(), SLOT(onAboutToQuit())); connect(app, SIGNAL(fullscreen()), SFAuthenticationManager::instance(), SLOT(onAppStart())); }
void key(unsigned char key , int x , int y) { if(key == ' '){//スペースキーでウインドウモードを切り替え if(Change == false){Change = true;} else{Change = false;} fullscreen(); } }
QVariant ApplicationManager::data(const QModelIndex& index, int role) const { if (index.row() < 0 || index.row() >= m_runningApplications.size()) return QVariant(); auto app = m_runningApplications.at(index.row()); switch(role) { case RoleAppId: return app->appId(); case RoleName: return app->name(); case RoleComment: return app->comment(); case RoleIcon: return app->icon(); case RoleStage: return app->stage(); case RoleState: return app->state(); case RoleFocused: return app->focused(); case RoleSession: return QVariant::fromValue(app->session()); case RoleFullscreen: return app->fullscreen(); default: return QVariant(); } }
void playerWindow::on_fullscreen_clicked ( void ) { // hide all useless stuff for fullscreen mode menubar->set_visible(!menubar->get_visible()); borderleft->set_visible(!borderleft->get_visible()); borderright->set_visible(!borderright->get_visible()); // show/hide window decoration set_decorated(!get_decorated()); // switch between the fullscreen and the unfullscreen button unfullscreenBtn->set_visible(!unfullscreenBtn->get_visible()); fullscreenBtn->set_visible(!fullscreenBtn->get_visible()); // switch between fullscreen and a decorated window (get_decorated()) ? unmaximize () : maximize (); (get_decorated()) ? unfullscreen() : fullscreen(); // set the fullscreen state isFullscreen = !isFullscreen; /* Call timeout function at a 3000ms interval to hide or show player controls when it is in fullscreen mode. When the window is no more in the fullscreen mode, timeout signals are disconnected motion detector */ if (isFullscreen) { // set the timer to call periodically the timeout function timeout_fullscreen = Glib::signal_timeout().connect ( sigc::mem_fun ( *this, &playerWindow::on_timeout_fullscreen ), 3000 ); // set a motion detector into the drawing area mouse_motion_signal_drawingArea = videoDrawingArea->signal_motion_notify_event().connect ( sigc::mem_fun ( *this, &playerWindow::on_mousemove ) ); /* set the focus into the drawing area. Without the focus, the motion detection doesn't occurs when a movie is playing*/ videoDrawingArea->set_can_focus ( !videoDrawingArea->get_can_focus() ); // next trigger to attempt to hide the mediaplayer controler nextmotiondetection = time(NULL)+3; } else { // disconnect signals timeout_fullscreen.disconnect() ; mouse_motion_signal_drawingArea.disconnect(); // remove the focus videoDrawingArea->set_can_focus(!videoDrawingArea->get_can_focus()); } }
void sdl_window_info::update_cursor_state() { #if (USE_XINPUT && USE_XINPUT_WII_LIGHTGUN_HACK) // Hack for wii-lightguns: // they stop working with a grabbed mouse; // even a ShowCursor(SDL_DISABLE) already does this. // To make the cursor disappear, we'll just set an empty cursor image. unsigned char data[]={0,0,0,0,0,0,0,0}; SDL_Cursor *c; c=SDL_CreateCursor(data, data, 8, 8, 0, 0); SDL_SetCursor(c); #else // do not do mouse capture if the debugger's enabled to avoid // the possibility of losing control if (!(machine().debug_flags & DEBUG_FLAG_OSD_ENABLED)) { bool should_hide_mouse = downcast<sdl_osd_interface&>(machine().osd()).should_hide_mouse(); if (!fullscreen() && !should_hide_mouse) { show_pointer(); release_pointer(); } else { hide_pointer(); capture_pointer(); } SDL_SetCursor(nullptr); // Force an update in case the underlying driver has changed visibility } #endif }
void MainWindow::on_view_fullscreen() { if(m_itemViewFullscreen->property_active()) { fullscreen(); } else { unfullscreen(); } }
bool detect_video_settings(CVideo& video, std::pair<int,int>& resolution, int& bpp, int& video_flags) { video_flags = fullscreen() ? SDL_WINDOW_FULLSCREEN: 0; resolution = preferences::resolution(); bpp = 32; return true; }
bool detect_video_settings(CVideo& video, std::pair<int,int>& resolution, int& bpp, int& video_flags) { video_flags = fullscreen() ? FULL_SCREEN : 0; resolution = preferences::resolution(); int DefaultBPP = 24; const SDL_VideoInfo* const video_info = SDL_GetVideoInfo(); if(video_info != NULL && video_info->vfmt != NULL) { DefaultBPP = video_info->vfmt->BitsPerPixel; } std::cerr << "Checking video mode: " << resolution.first << 'x' << resolution.second << 'x' << DefaultBPP << "...\n"; typedef std::pair<int, int> res_t; std::vector<res_t> res_list; if(fullscreen()){ res_list.push_back(res_t(2560, 1600)); res_list.push_back(res_t(1920, 1200)); res_list.push_back(res_t(1920, 1080)); res_list.push_back(res_t(1680, 1050)); res_list.push_back(res_t(1440, 900)); res_list.push_back(res_t(1360, 768)); } res_list.push_back(res_t(1024, 768)); bpp = video.modePossible(resolution.first, resolution.second, DefaultBPP, video_flags, true); BOOST_FOREACH(const res_t &res, res_list) { if (bpp != 0) break; std::cerr << "Video mode " << resolution.first << 'x' << resolution.second << 'x' << DefaultBPP << " is not supported; attempting " << res.first << 'x' << res.second << 'x' << DefaultBPP << "...\n"; resolution = res; bpp = video.modePossible(resolution.first, resolution.second, DefaultBPP, video_flags); } preferences::set_resolution(resolution); return bpp != 0; }
void ActionsManager::doAction( int id_action ) { switch( id_action ) { case PLAY_ACTION: play(); break; case STOP_ACTION: THEMIM->stop(); break; case OPEN_ACTION: THEDP->openDialog(); break; case PREVIOUS_ACTION: THEMIM->prev(); break; case NEXT_ACTION: THEMIM->next(); break; case SLOWER_ACTION: THEMIM->getIM()->slower(); break; case FASTER_ACTION: THEMIM->getIM()->faster(); break; case FULLSCREEN_ACTION: fullscreen(); break; case EXTENDED_ACTION: THEDP->extendedDialog(); break; case PLAYLIST_ACTION: playlist(); break; case SNAPSHOT_ACTION: snapshot(); break; case RECORD_ACTION: record(); break; case FRAME_ACTION: frame(); break; case ATOB_ACTION: THEMIM->getIM()->setAtoB(); break; case REVERSE_ACTION: THEMIM->getIM()->reverse(); break; case SKIP_BACK_ACTION: skipBackward(); break; case SKIP_FW_ACTION: skipForward(); break; case QUIT_ACTION: THEDP->quit(); break; case RANDOM_ACTION: THEMIM->toggleRandom(); break; case INFO_ACTION: THEDP->mediaInfoDialog(); break; case OPEN_SUB_ACTION: THEDP->loadSubtitlesFile(); break; case FULLWIDTH_ACTION: if( p_intf->p_sys->p_mi ) p_intf->p_sys->p_mi->getFullscreenControllerWidget()->toggleFullwidth(); break; default: msg_Warn( p_intf, "Action not supported: %i", id_action ); break; } }
TiAnalyticsObject::TiAnalyticsObject(NativeObjectFactory* objectFactory) : TiProxy("Analytics"), sequence_(1) { objectFactory_ = objectFactory; // if analytics is false just return bool analytics = defaultSettings.value("analytics").toBool(); if (analytics == true) { // get unique application id QString aguid = defaultSettings.value("aguid").toString(); aguid_ = aguid.toLocal8Bit(); // get unique mobile device id bb::device::HardwareInfo hdi; QString mid = hdi.pin(); mid_ = mid.toLocal8Bit(); // generate the session id QString sid = QUuid::createUuid().toString(); sid.replace("{", ""); sid.replace("}", ""); sid_ = sid.toLocal8Bit(); // get deploy type if development or production QString deployType = defaultSettings.value("deploytype").toString(); deployType_ = deployType.toLocal8Bit(); // application version QString appVersion = defaultSettings.value("version").toString(); appVersion_ = appVersion.toLocal8Bit(); QUrl analyticsSite("https://api.appcelerator.net/p/v3/mobile-track/" + aguid); request_.setUrl(analyticsSite); // Async callbacks to notify application of HTTP events eventHandler_ = new TiAnalyticsHandler(this); QObject::connect(&networkAccessManager_, SIGNAL(finished(QNetworkReply*)), eventHandler_, SLOT(finished(QNetworkReply*))); QObject::connect(&networkAccessManager_, SIGNAL(sslErrors(QNetworkReply*,QList<QSslError>)), eventHandler_, SLOT(errors(QNetworkReply*))); // Hook application life cycle events QObject::connect(bb::cascades::Application::instance(), SIGNAL(thumbnail()), eventHandler_, SLOT(thumbnail())); QObject::connect(bb::cascades::Application::instance(), SIGNAL(fullscreen()), eventHandler_, SLOT(fullscreen())); QObject::connect(bb::cascades::Application::instance(), SIGNAL(manualExit()), eventHandler_, SLOT(manualExit())); if (createAnalyticsDatabase()) { addAnalyticsEvent("ti.enroll"); } addAnalyticsEvent("ti.start"); sendPendingAnalyticsEvents(); // Set up timer and every 10 minutes send out analytics events if any are pending TiAnalyticsHandler* eventHandler = new TiAnalyticsHandler(this); timer_ = new QTimer(eventHandler); QObject::connect(timer_, SIGNAL(timeout()), eventHandler, SLOT(sendPendingRequests())); timer_->start(60000*10); }
void Window::vToggleFullscreen() { if (!m_bFullscreen) { fullscreen(); m_poMenuBar->hide(); } else { unfullscreen(); m_poMenuBar->show(); } }
void Environment::setFullscreen(bool enable) { if (fullscreen() == enable) return; if (enable) view()->showFullScreen(); else view()->show(); emit fullscreenChanged(); }
void mixer_window::toggle_fullscreen() { fullscreen_state_ = !fullscreen_state_; if(fullscreen_state_) { fullscreen(); } else { unfullscreen(); } }
void sdl_window_info::complete_destroy() { if (fullscreen() && video_config.switchres) { SDL_SetWindowFullscreen(platform_window<SDL_Window*>(), 0); // Try to set mode SDL_SetWindowDisplayMode(platform_window<SDL_Window*>(), &m_original_mode->mode); // Try to set mode SDL_SetWindowFullscreen(platform_window<SDL_Window*>(), SDL_WINDOW_FULLSCREEN); // Try to set mode } SDL_DestroyWindow(platform_window<SDL_Window*>()); // release all keys ... downcast<sdl_osd_interface &>(machine().osd()).release_keys(); }
void set_resolution(const std::pair<int,int>& resolution) { if(disp) { set_resolution(disp->video(), resolution.first, resolution.second); } else { /* This part is needed when wesnoth is started with the -r parameter. */ const std::string postfix = fullscreen() ? "resolution" : "windowsize"; preferences::set( 'x' + postfix, lexical_cast<std::string>(resolution.first)); preferences::set( 'y' + postfix, lexical_cast<std::string>(resolution.second)); } }
void sdl_window_info::toggle_full_screen() { // if we are in debug mode, never go full screen if (machine().debug_flags & DEBUG_FLAG_OSD_ENABLED) return; // If we are going fullscreen (leaving windowed) remember our windowed size if (!fullscreen()) { m_windowed_dim = get_size(); } // reset UI to main menu machine().ui().menu_reset(); // kill off the drawers renderer_reset(); bool is_osx = false; #ifdef SDLMAME_MACOSX // FIXME: This is weird behaviour and certainly a bug in SDL is_osx = true; #endif if (fullscreen() && (video_config.switchres || is_osx)) { SDL_SetWindowFullscreen(platform_window(), 0); // Try to set mode SDL_SetWindowDisplayMode(platform_window(), &m_original_mode->mode); // Try to set mode SDL_SetWindowFullscreen(platform_window(), SDL_WINDOW_FULLSCREEN); // Try to set mode } SDL_DestroyWindow(platform_window()); set_platform_window(nullptr); downcast<sdl_osd_interface &>(machine().osd()).release_keys(); set_renderer(osd_renderer::make_for_type(video_config.mode, shared_from_this())); // toggle the window mode set_fullscreen(!fullscreen()); complete_create(); }
std::pair<int,int> resolution() { const std::string postfix = fullscreen() ? "resolution" : "windowsize"; std::string x = prefs['x' + postfix], y = prefs['y' + postfix]; if (!x.empty() && !y.empty()) { return std::make_pair( std::max(atoi(x.c_str()), min_allowed_width()), std::max(atoi(y.c_str()), min_allowed_height())); } else { return std::pair<int,int>(1024,768); } }
void ActionsManager::doAction( int id_action ) { switch( id_action ) { case PLAY_ACTION: play(); break; case STOP_ACTION: THEMIM->stop(); break; case OPEN_ACTION: THEDP->openDialog(); break; case PREVIOUS_ACTION: THEMIM->prev(); break; case NEXT_ACTION: THEMIM->next(); break; case SLOWER_ACTION: THEMIM->getIM()->slower(); break; case FASTER_ACTION: THEMIM->getIM()->faster(); break; case FULLSCREEN_ACTION: fullscreen(); break; case EXTENDED_ACTION: THEDP->extendedDialog(); break; case PLAYLIST_ACTION: playlist(); break; case SNAPSHOT_ACTION: snapshot(); break; case RECORD_ACTION: record(); break; case FRAME_ACTION: frame(); break; case ATOB_ACTION: THEMIM->getIM()->setAtoB(); break; case REVERSE_ACTION: THEMIM->getIM()->reverse(); break; case SKIP_BACK_ACTION: skipBackward(); break; case SKIP_FW_ACTION: skipForward(); break; case QUIT_ACTION: THEDP->quit(); break; case RANDOM_ACTION: THEMIM->toggleRandom(); break; case INFO_ACTION: THEDP->mediaInfoDialog(); break; default: msg_Dbg( p_intf, "Action: %i", id_action ); break; } }
void Client::init(int w, IplImage *i, Cursor c) { image = i; curseur = new Cursor; *curseur = c; // Construction de l'interface ui->setupUi(this); // Classes utilisées camManager = new WebcamManager(); camWidget = new WidgetWebcam(); this->setWindowTitle("Tableau virtuel interactif"); // Demarrage de la webcam camManager->setWebcam(w); camManager->runWebcam(); // Connexion à la fonction d'exportation connect(ui->actionExporter, SIGNAL(triggered()), this, SLOT(exportDraw())); // Fonction pour vider la scène connect(ui->actionFlushScene, SIGNAL(triggered()), this, SLOT(flushScene())); // Connexion au plein écrans connect(ui->actionPleinEcran, SIGNAL(triggered()), this, SLOT(fullscreen())); // Connecion au changement de couleur connect(ui->actioncouleur, SIGNAL(triggered()), this, SLOT(changeColor())); // Création de la zone centrale scroll = new QScrollArea(); mainWidget = new QWidget(); layout = new QHBoxLayout(); mainWidget->setLayout(layout); // Ajout des widgets layout->addWidget(drawingBoard); layout->addWidget(camWidget); // Zone de défilement scroll->setWidget(mainWidget); this->setCentralWidget(scroll); // Démarrage du timer QTimer *timer = new QTimer(this); connect(timer, SIGNAL(timeout()), this, SLOT(tick())); timer->start(40); }
void KCommonDecoration::updateWindowShape() { // don't mask the widget... if (!decorationBehaviour(DB_WindowMask) ) return; int w = widget()->width(); int h = widget()->height(); bool tl=true,tr=true,bl=true,br=true; // is there a transparent rounded corner in top-left? etc QDesktopWidget *desktop=KApplication::desktop(); // no transparent rounded corners if this window corner lines up with a screen corner for(int screen=0; screen < desktop->numScreens(); ++screen) { QRect fullscreen(desktop->screenGeometry(screen)); QRect window = geometry(); if(window.topLeft() == fullscreen.topLeft() ) tl = false; if(window.topRight() == fullscreen.topRight() ) tr = false; if(window.bottomLeft() == fullscreen.bottomLeft() ) bl = false; if(window.bottomRight()== fullscreen.bottomRight() ) br = false; } QRegion mask(0, 0, w, h); // Remove top-left corner. if(tl) { mask -= cornerShape(WC_TopLeft); } // Remove top-right corner. if(tr) { mask -= cornerShape(WC_TopRight); } // Remove top-left corner. if(bl) { mask -= cornerShape(WC_BottomLeft); } // Remove top-right corner. if(br) { mask -= cornerShape(WC_BottomRight); } setMask( mask ); }
void ActionsManager::doAction( int id_action ) { switch( id_action ) { case PLAY_ACTION: play(); break; case STOP_ACTION: THEMIM->stop(); break; case OPEN_ACTION: THEDP->openDialog(); break; case PREVIOUS_ACTION: THEMIM->prev(); break; case NEXT_ACTION: THEMIM->next(); break; case SLOWER_ACTION: THEMIM->getIM()->slower(); break; case FASTER_ACTION: THEMIM->getIM()->faster(); break; case FULLSCREEN_ACTION: fullscreen(); break; case EXTENDED_ACTION: THEDP->extendedDialog(); break; case PLAYLIST_ACTION: playlist(); break; case SNAPSHOT_ACTION: snapshot(); break; case RECORD_ACTION: record(); break; case FRAME_ACTION: frame(); break; case ATOB_ACTION: THEMIM->getIM()->setAtoB(); break; case REVERSE_ACTION: THEMIM->getIM()->reverse(); break; case SKIP_BACK_ACTION: var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_JUMP_BACKWARD_SHORT ); break; case SKIP_FW_ACTION: var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_JUMP_FORWARD_SHORT ); break; case QUIT_ACTION: THEDP->quit(); break; default: msg_Dbg( p_intf, "Action: %i", id_action ); break; } }
QueryView::QueryView(Database *database, QString command) { this->database = database; //Identify this object with thisTableViewId for constructing database connection //specific to this object and this object alone. thisQueryViewId = queryViewObjectId++; //Thread busy indicator to avoid crashing of app when //QueryView receives a close signal before data retrieval. thread_busy = false; //Start the timer. t.start(); errors_model = new QStandardItemModel(0,1); query_model = new QueryModel; qview = new QTableView(this); qview->resizeColumnsToContents(); setCentralWidget(qview); statusBar()->showMessage(QApplication::translate("QueryView", "Fetching data...", 0, QApplication::UnicodeUTF8)); //qview->setModel(model); //setWindowTitle(name); qview->setStyleSheet("QTableView {font-weight: 400;}"); qview->setAlternatingRowColors(true); //setGeometry(100,100,640,480); //Create Ctrl+Shift+C key combo to copy selected table contents with headers. QShortcut *shortcut_ctrl_c = new QShortcut(QKeySequence::Copy, this); connect(shortcut_ctrl_c, SIGNAL(activated()), this, SLOT(copyc())); //Create Ctrl+Shift+C key combo to copy selected table contents with headers. QShortcut *shortcut_ctrl_shft_c = new QShortcut(QKeySequence("Ctrl+Shift+C"), this); connect(shortcut_ctrl_shft_c, SIGNAL(activated()), this, SLOT(copych())); //Create key-sequences for fullscreen and restore. shortcut_fullscreen = new QShortcut(QKeySequence(Qt::Key_F11), this); connect(shortcut_fullscreen, SIGNAL(activated()), this, SLOT(fullscreen())); shortcut_restore = new QShortcut(QKeySequence(Qt::Key_Escape), this); connect(shortcut_restore, SIGNAL(activated()), this, SLOT(restore())); //Tie thread finish to an update slot that refreshes meta-information. connect(this, SIGNAL(updRowCntSignal(QString)), this, SLOT(updRowCntSlot(QString))); //Tie a busy signal to a slot that changes the cursor to wait cursor. connect(this, SIGNAL(busySignal()), this, SLOT(busySlot())); QFuture<void> future = QtConcurrent::run(this, &QueryView::fetchData, command); }
std::pair<int,int> resolution() { const std::string postfix = fullscreen() ? "resolution" : "windowsize"; std::string x = prefs['x' + postfix], y = prefs['y' + postfix]; if (!x.empty() && !y.empty()) { std::pair<int,int> res(std::max(atoi(x.c_str()), min_allowed_width()), std::max(atoi(y.c_str()), min_allowed_height())); // Make sure resolutions are always divisible by 4 //res.first &= ~3; //res.second &= ~3; return res; } else { return std::pair<int,int>(1024,768); } }