QColor UBAbstractDrawRuler::middleFillColor() const { return scene()->isDarkBackground() ? sDarkBackgroundMiddleFillColor : sLightBackgroundMiddleFillColor; }
void StelMainView::resizeEvent(QResizeEvent* event) { scene()->setSceneRect(QRect(QPoint(0, 0), event->size())); rootItem->setGeometry(0,0,event->size().width(),event->size().height()); QGraphicsView::resizeEvent(event); }
void StelMainView::init(QSettings* conf) { gui = new StelGui(); #if STEL_USE_NEW_OPENGL_WIDGETS //glWidget->initializeGL(); // protected... //Q_ASSERT(glWidget->isValid()); #else Q_ASSERT(glWidget->isValid()); glWidget->makeCurrent(); #endif // Should be check of requirements disabled? if (conf->value("main/check_requirements", true).toBool()) { // Find out lots of debug info about supported version of OpenGL and vendor/renderer. processOpenGLdiagnosticsAndWarnings(conf, glWidget); } stelApp= new StelApp(); stelApp->setGui(gui); stelApp->init(conf); StelActionMgr *actionMgr = stelApp->getStelActionManager(); actionMgr->addAction("actionSave_Screenshot_Global", N_("Miscellaneous"), N_("Save screenshot"), this, "saveScreenShot()", "Ctrl+S"); actionMgr->addAction("actionSet_Full_Screen_Global", N_("Display Options"), N_("Full-screen mode"), this, "fullScreen", "F11"); StelPainter::initGLShaders(); skyItem = new StelSkyItem(); guiItem = new StelGuiItem(); QGraphicsAnchorLayout* l = new QGraphicsAnchorLayout(rootItem); l->setSpacing(0); l->setContentsMargins(0,0,0,0); l->addCornerAnchors(skyItem, Qt::TopLeftCorner, l, Qt::TopLeftCorner); l->addCornerAnchors(skyItem, Qt::BottomRightCorner, l, Qt::BottomRightCorner); l->addCornerAnchors(guiItem, Qt::BottomLeftCorner, l, Qt::BottomLeftCorner); l->addCornerAnchors(guiItem, Qt::TopRightCorner, l, Qt::TopRightCorner); rootItem->setLayout(l); scene()->addItem(rootItem); nightModeEffect = new NightModeGraphicsEffect(this); updateNightModeProperty(); rootItem->setGraphicsEffect(nightModeEffect); QSize size = glWidget->windowHandle()->screen()->size(); size = QSize(conf->value("video/screen_w", size.width()).toInt(), conf->value("video/screen_h", size.height()).toInt()); bool fullscreen = conf->value("video/fullscreen", true).toBool(); // Without this, the screen is not shown on a Mac + we should use resize() for correct work of fullscreen/windowed mode switch. --AW WTF??? resize(size); QDesktopWidget *desktop = QApplication::desktop(); int screen = conf->value("video/screen_number", 0).toInt(); if (screen < 0 || screen >= desktop->screenCount()) { qWarning() << "WARNING: screen" << screen << "not found"; screen = 0; } QRect screenGeom = desktop->screenGeometry(screen); if (fullscreen) { // The "+1" below is to work around Linux/Gnome problem with mouse focus. move(screenGeom.x()+1, screenGeom.y()+1); // The fullscreen window appears on screen where is the majority of // the normal window. Therefore we crop the normal window to the // screen area to ensure that the majority is not on another screen. setGeometry(geometry() & screenGeom); setFullScreen(true); } else { setFullScreen(false); int x = conf->value("video/screen_x", 0).toInt(); int y = conf->value("video/screen_y", 0).toInt(); move(x + screenGeom.x(), y + screenGeom.y()); } flagInvertScreenShotColors = conf->value("main/invert_screenshots_colors", false).toBool(); setFlagCursorTimeout(conf->value("gui/flag_mouse_cursor_timeout", false).toBool()); setCursorTimeout(conf->value("gui/mouse_cursor_timeout", 10.f).toFloat()); maxfps = conf->value("video/maximum_fps",10000.f).toFloat(); minfps = conf->value("video/minimum_fps",10000.f).toFloat(); flagMaxFpsUpdatePending = false; // XXX: This should be done in StelApp::init(), unfortunately for the moment we need init the gui before the // plugins, because the gui create the QActions needed by some plugins. StelApp::getInstance().initPlugIns(); // activate DE430/431 StelApp::getInstance().getCore()->initEphemeridesFunctions(); // The script manager can only be fully initialized after the plugins have loaded. StelApp::getInstance().initScriptMgr(); // Set the global stylesheet, this is only useful for the tooltips. StelGui* gui = dynamic_cast<StelGui*>(StelApp::getInstance().getGui()); if (gui!=NULL) setStyleSheet(gui->getStelStyle().qtStyleSheet); connect(&StelApp::getInstance(), SIGNAL(visionNightModeChanged(bool)), this, SLOT(updateNightModeProperty())); QThread::currentThread()->setPriority(QThread::HighestPriority); startMainLoop(); }
MapScene *MapView::mapScene() const { return qobject_cast<MapScene *>(scene()); }
void StelSkyItem::resizeEvent(QGraphicsSceneResizeEvent* event) { QGraphicsWidget::resizeEvent(event); StelApp::getInstance().glWindowHasBeenResized(scenePos().x(), scene()->sceneRect().height()-(scenePos().y()+geometry().height()), geometry().width(), geometry().height()); }
//! //! Changes the viewing transformation so that all items are visible at maximum //! zoom level. //! void GraphicsView::frameAll () { frame(scene()->itemsBoundingRect()); }
void ProfileGraphicsView::plot_cylinder_pressure(struct divecomputer *dc) { int i; int last = -1, last_index = -1; int lift_pen = FALSE; int first_plot = TRUE; int sac = 0; struct plot_data *last_entry = NULL; if (!get_cylinder_pressure_range(&gc)) return; QPointF from, to; for (i = 0; i < gc.pi.nr; i++) { int mbar; struct plot_data *entry = gc.pi.entry + i; mbar = GET_PRESSURE(entry); if (entry->cylinderindex != last_index) { lift_pen = TRUE; last_entry = NULL; } if (!mbar) { lift_pen = TRUE; continue; } if (!last_entry) { last = i; last_entry = entry; sac = get_local_sac(entry, gc.pi.entry + i + 1, dive); } else { int j; sac = 0; for (j = last; j < i; j++) sac += get_local_sac(gc.pi.entry + j, gc.pi.entry + j + 1, dive); sac /= (i - last); if (entry->sec - last_entry->sec >= SAC_WINDOW) { last++; last_entry = gc.pi.entry + last; } } QColor c = get_sac_color(sac, dive->sac); if (lift_pen) { if (!first_plot && entry->cylinderindex == last_index) { /* if we have a previous event from the same tank, * draw at least a short line */ int prev_pr; prev_pr = GET_PRESSURE(entry - 1); QGraphicsLineItem *item = new QGraphicsLineItem(SCALEGC((entry-1)->sec, prev_pr), SCALEGC(entry->sec, mbar)); QPen pen(defaultPen); pen.setColor(c); item->setPen(pen); scene()->addItem(item); } else { first_plot = FALSE; from = QPointF(SCALEGC(entry->sec, mbar)); } lift_pen = FALSE; } else { to = QPointF(SCALEGC(entry->sec, mbar)); QGraphicsLineItem *item = new QGraphicsLineItem(from.x(), from.y(), to.x(), to.y()); QPen pen(defaultPen); pen.setColor(c); item->setPen(pen); scene()->addItem(item); } from = QPointF(SCALEGC(entry->sec, mbar)); last_index = entry->cylinderindex; } }
// Animation loop void DisplayIntro::loop() { int no = mCards.size(); // Catch no card error if (no<1) return; // Retrieve theme data KConfigGroup cardconfig = thememanager()->config(QLatin1String( "card" )); double card_width = cardconfig.readEntry("width", 1.0); KConfigGroup config = thememanager()->config(id()); QPointF start_shift = config.readEntry("start-shift", QPointF(1.0,1.0)); QPointF start_pos = config.readEntry("start-pos", QPointF(1.0,1.0)); double time_clear_in = config.readEntry("time-clear-in", 1.0); double time_clear_out = config.readEntry("time-clear-out", 1.0); double aspectRatio = thememanager()->aspectRatio(); // Display the intro text delayed if (mAnimCnt == 2 && mState == Putting && !mTextShown) { mTextShown = true; QString s1 = i18nc("Title of the game - line 1", "Lieutenant Skat"); QString s2 = i18nc("Title of the game - line 2", "for"); QString s3 = i18nc("Title of the game - line 3", "K D E"); // Text sprite title foreground TextSprite* text1a = new TextSprite(s1, QLatin1String( "name-front" ), mTheme, scene()); mSprites.append(text1a); text1a->show(); // Text sprite title background TextSprite* text1b = new TextSprite(s1, QLatin1String( "name-back" ), mTheme, scene()); mSprites.append(text1b); text1b->show(); // Text sprite title foreground TextSprite* text2a = new TextSprite(s2, QLatin1String( "for-front" ), mTheme, scene()); mSprites.append(text2a); text2a->show(); // Text sprite title background TextSprite* text2b = new TextSprite(s2, QLatin1String( "for-back" ), mTheme, scene()); mSprites.append(text2b); text2b->show(); // Text sprite title foreground TextSprite* text3a = new TextSprite(s3, QLatin1String( "kde-front" ), mTheme, scene()); mSprites.append(text3a); text3a->show(); // Text sprite title background TextSprite* text3b = new TextSprite(s3, QLatin1String( "kde-back" ), mTheme, scene()); mSprites.append(text3b); text3b->show(); } // Display a card if (mAnimCnt < no && mState == Putting) { double factor = double(mAnimCnt)/double(no-1); double fsin = sin(factor*M_PI); CardSprite* sprite = mCards[mAnimCnt]; QPointF pos; if (mAnimCnt %2 == 0) { pos = QPointF(start_pos.x(), start_pos.y()); pos += QPointF(start_shift.x() * fsin, start_shift.y() * factor); } else { pos = QPointF(1.0-start_pos.x()-card_width, start_pos.y()); pos += QPointF(-start_shift.x() * fsin, start_shift.y() * factor); } sprite->setBackside(); sprite->setPosition(pos); sprite->setZValue(50+mAnimCnt); sprite->show(); mAnimCnt++; } // Change state to turning else if (mState == Putting) { mState = Turning; mAnimCnt = 0; } // Turn cards else if (mAnimCnt < no && mState == Turning) { CardSprite* sprite = mCards[mAnimCnt]; sprite->setTurning(true); mAnimCnt++; } // Change state to waiting else if (mState == Turning) { mState = Waiting; mAnimCnt = 0; } // Wait else if (mAnimCnt < WAIT_CNT && mState == Waiting) { mAnimCnt++; } // Change state to clearing the board else if (mState == Waiting) { mState = Clearing; mAnimCnt = 0; } // Clear the board, step 1 else if (mAnimCnt == 0 && mState == Clearing) { for (int i=0; i<no; i++) { CardSprite* sprite = mCards[i]; sprite->setMove(QPointF((1.0-card_width)/2.0, (1.0/aspectRatio-card_width)/2.0), time_clear_in); } mAnimCnt++; } // Clear the board, step 2 else if (mAnimCnt < 30 && mState == Clearing) { mAnimCnt++; } // Clear the board, step 3 and change state to waiting else if (mState == Clearing) { for (int i=0; i<no; i++) { double r = 1.0; double x = r*cos(double(i)/double(no-1)*M_PI*2.0) + 0.5; double y = r*sin(double(i)/double(no-1)*M_PI*2.0) + 0.5; CardSprite* sprite = mCards[i]; sprite->setMove(QPointF(x,y/aspectRatio), time_clear_out); } mState = Waiting2; mAnimCnt = 0; } // Wait else if (mAnimCnt < WAIT_CNT && mState == Waiting2) { mAnimCnt++; } // Restart cycle else if (mState == Waiting2) { for (int i=0; i<no; i++) { CardSprite* sprite = mCards[i]; sprite->stop(); } mState = Putting; mAnimCnt = 0; } }
void ribi::cmap::QtConceptMap::BuildQtConceptMap() { CleanMe(); assert(m_concept_map); assert(m_concept_map->IsValid()); assert(this->scene()); //This std::vector keeps the QtNodes in the same order as the nodes in the concept map //You cannot rely on Collect<QtConceptMapNodeConcept*>(scene), as this shuffles the order std::vector<QtNode*> qtnodes; assert(Collect<QtNode>(scene()).empty()); //Add the nodes to the scene, if there are any if (!m_concept_map->GetNodes().empty()) { //Add the main question as the first node const boost::shared_ptr<Node> node = m_concept_map->GetFocalNode(); QtNode * qtnode = nullptr; if (IsCenterNode(node)) { const boost::shared_ptr<CenterNode> centernode = boost::dynamic_pointer_cast<CenterNode>(node); qtnode = new QtCenterNode(centernode); } else { qtnode = new QtNode(node,this->GetDisplayStrategy(node->GetConcept())); } assert(qtnode); //Let the center node respond to mouse clicks qtnode->m_signal_request_scene_update.connect( boost::bind(&ribi::cmap::QtConceptMap::OnRequestSceneUpdate,this)); qtnode->m_signal_item_has_updated.connect( boost::bind(&ribi::cmap::QtConceptMap::OnItemRequestsUpdate,this,boost::lambda::_1)); //Add the center node to scene assert(!qtnode->scene()); this->scene()->addItem(qtnode); qtnodes.push_back(qtnode); assert(Collect<QtNode>(scene()).size() == 1); //Add the regular nodes to the scene const std::vector<boost::shared_ptr<ribi::cmap::Node> > nodes = m_concept_map->GetNodes(); const std::size_t n_nodes = nodes.size(); assert(n_nodes >= 1); for (std::size_t i=1; i!=n_nodes; ++i) //+1 to skip focal node { assert(Collect<QtNode>(scene()).size() == i && "Node not yet added to scene"); assert(i < nodes.size()); boost::shared_ptr<Node> node = nodes[i]; assert(node); assert( (IsCenterNode(node) || !IsCenterNode(node)) && "focal node != center node"); QtNode * const qtnode = AddNode(node); qtnodes.push_back(qtnode); assert(Collect<QtNode>(scene()).size() == i + 1 && "Node is added to scene"); } } #ifndef NDEBUG { //Check the number of const auto qtnodes = Collect<QtNode>(scene()); const auto n_qtnodes = qtnodes.size(); const auto nodes = m_concept_map->GetNodes(); const auto n_nodes = nodes.size(); assert(n_qtnodes == n_nodes && "There must as much nodes in the scene as there were in the concept map"); } #endif //Add the Concepts on the Edges { const std::vector<boost::shared_ptr<ribi::cmap::Edge> > edges = m_concept_map->GetEdges(); std::for_each(edges.begin(),edges.end(), [this,qtnodes](const boost::shared_ptr<Edge> edge) { assert(edge->GetFrom()); assert(edge->GetTo()); assert(edge->GetFrom() != edge->GetTo()); this->AddEdge(edge); } ); } #ifndef NDEBUG { //Check the number of edges const auto qtedges = Collect<QtEdge>(scene()); const auto n_qtedges = qtedges.size(); const auto edges = m_concept_map->GetEdges(); const auto n_edges = edges.size(); assert(n_qtedges == n_edges && "There must as much edges in the scene as there were in the concept map"); } #endif //Put the nodes around the focal question in an initial position if (MustReposition(AddConst(m_concept_map->GetNodes()))) { RepositionItems(); } #ifndef NDEBUG assert(m_concept_map->IsValid()); const auto nodes = m_concept_map->GetNodes(); const auto items = Collect<QtNode>(this->scene()); const std::size_t n_items = items.size(); const std::size_t n_nodes = nodes.size(); if (n_items != n_nodes) { TRACE(m_concept_map->GetNodes().size()); TRACE(n_items); TRACE(n_nodes); } assert(n_items == n_nodes && "GUI and non-GUI concept map must match"); TestMe(m_concept_map); #endif }
XYView* View::new_view(Coord x1, Coord y1, Coord x2, Coord y2) { Coord l,b,r,t; s2o().inverse_transform(x1,y1,l,b); s2o().inverse_transform(x2,y2,r,t); return new View( (x1+x2)/2, (y1+y2)/2, x2-x1, scene(), r-l, t-b); }
void Forest::drawSelf() { if( mPriority >= 99-quality() ) mModel->draw( scene()->eye()->viewMatrix(), mInstances ); }
XYView* XYView::new_view(Coord x1, Coord y1, Coord x2, Coord y2) { Coord l,b,r,t; s2o().inverse_transform(x1,y1,l,b); s2o().inverse_transform(x2,y2,r,t); return new XYView( x1, y1, x2-x1, y2-y1, scene(), r-l, t-b); }
XYView::~XYView() { // printf("~XYView\n"); scene()->remove_view(this); }
QColor UBAbstractDrawRuler::drawColor() const { return scene()->isDarkBackground() ? sDarkBackgroundDrawColor : sLightBackgroundDrawColor; }
int main (int argc, char *argv[]) { parseCommandLine (argc, argv); pcl::PointCloud<PointType>::Ptr model (new pcl::PointCloud<PointType> ()); pcl::PointCloud<PointType>::Ptr model_keypoints (new pcl::PointCloud<PointType> ()); pcl::PointCloud<PointType>::Ptr scene (new pcl::PointCloud<PointType> ()); pcl::PointCloud<PointType>::Ptr scene_keypoints (new pcl::PointCloud<PointType> ()); pcl::PointCloud<NormalType>::Ptr model_normals (new pcl::PointCloud<NormalType> ()); pcl::PointCloud<NormalType>::Ptr scene_normals (new pcl::PointCloud<NormalType> ()); pcl::PointCloud<DescriptorType>::Ptr model_descriptors (new pcl::PointCloud<DescriptorType> ()); pcl::PointCloud<DescriptorType>::Ptr scene_descriptors (new pcl::PointCloud<DescriptorType> ()); // // Load clouds // if (pcl::io::loadPCDFile (model_filename_, *model) < 0) { std::cout << "Error loading model cloud." << std::endl; showHelp (argv[0]); return (-1); } if (pcl::io::loadPCDFile (scene_filename_, *scene) < 0) { std::cout << "Error loading scene cloud." << std::endl; showHelp (argv[0]); return (-1); } // // Set up resolution invariance // if (use_cloud_resolution_) { float resolution = static_cast<float> (computeCloudResolution (model)); if (resolution != 0.0f) { model_ss_ *= resolution; scene_ss_ *= resolution; rf_rad_ *= resolution; descr_rad_ *= resolution; cg_size_ *= resolution; } std::cout << "Model resolution: " << resolution << std::endl; std::cout << "Model sampling size: " << model_ss_ << std::endl; std::cout << "Scene sampling size: " << scene_ss_ << std::endl; std::cout << "LRF support radius: " << rf_rad_ << std::endl; std::cout << "SHOT descriptor radius: " << descr_rad_ << std::endl; std::cout << "Clustering bin size: " << cg_size_ << std::endl << std::endl; } // // Compute Normals // pcl::NormalEstimationOMP<PointType, NormalType> norm_est; norm_est.setKSearch (10); norm_est.setInputCloud (model); norm_est.compute (*model_normals); norm_est.setInputCloud (scene); norm_est.compute (*scene_normals); // // Downsample Clouds to Extract keypoints // pcl::PointCloud<int> sampled_indices; pcl::UniformSampling<PointType> uniform_sampling; uniform_sampling.setInputCloud (model); uniform_sampling.setRadiusSearch (model_ss_); uniform_sampling.compute (sampled_indices); pcl::copyPointCloud (*model, sampled_indices.points, *model_keypoints); std::cout << "Model total points: " << model->size () << "; Selected Keypoints: " << model_keypoints->size () << std::endl; uniform_sampling.setInputCloud (scene); uniform_sampling.setRadiusSearch (scene_ss_); uniform_sampling.compute (sampled_indices); pcl::copyPointCloud (*scene, sampled_indices.points, *scene_keypoints); std::cout << "Scene total points: " << scene->size () << "; Selected Keypoints: " << scene_keypoints->size () << std::endl; // // Compute Descriptor for keypoints // pcl::SHOTEstimationOMP<PointType, NormalType, DescriptorType> descr_est; descr_est.setRadiusSearch (descr_rad_); descr_est.setInputCloud (model_keypoints); descr_est.setInputNormals (model_normals); descr_est.setSearchSurface (model); descr_est.compute (*model_descriptors); descr_est.setInputCloud (scene_keypoints); descr_est.setInputNormals (scene_normals); descr_est.setSearchSurface (scene); descr_est.compute (*scene_descriptors); // // Find Model-Scene Correspondences with KdTree // pcl::CorrespondencesPtr model_scene_corrs (new pcl::Correspondences ()); pcl::KdTreeFLANN<DescriptorType> match_search; match_search.setInputCloud (model_descriptors); // For each scene keypoint descriptor, find nearest neighbor into the model keypoints descriptor cloud and add it to the correspondences vector. for (size_t i = 0; i < scene_descriptors->size (); ++i) { std::vector<int> neigh_indices (1); std::vector<float> neigh_sqr_dists (1); if (!pcl_isfinite (scene_descriptors->at (i).descriptor[0])) //skipping NaNs { continue; } int found_neighs = match_search.nearestKSearch (scene_descriptors->at (i), 1, neigh_indices, neigh_sqr_dists); if(found_neighs == 1 && neigh_sqr_dists[0] < 0.25f) // add match only if the squared descriptor distance is less than 0.25 (SHOT descriptor distances are between 0 and 1 by design) { pcl::Correspondence corr (neigh_indices[0], static_cast<int> (i), neigh_sqr_dists[0]); model_scene_corrs->push_back (corr); } } std::cout << "Correspondences found: " << model_scene_corrs->size () << std::endl; // // Actual Clustering // std::vector<Eigen::Matrix4f, Eigen::aligned_allocator<Eigen::Matrix4f> > rototranslations; std::vector<pcl::Correspondences> clustered_corrs; // Using Hough3D if (use_hough_) { // // Compute (Keypoints) Reference Frames only for Hough // pcl::PointCloud<RFType>::Ptr model_rf (new pcl::PointCloud<RFType> ()); pcl::PointCloud<RFType>::Ptr scene_rf (new pcl::PointCloud<RFType> ()); pcl::BOARDLocalReferenceFrameEstimation<PointType, NormalType, RFType> rf_est; rf_est.setFindHoles (true); rf_est.setRadiusSearch (rf_rad_); rf_est.setInputCloud (model_keypoints); rf_est.setInputNormals (model_normals); rf_est.setSearchSurface (model); rf_est.compute (*model_rf); rf_est.setInputCloud (scene_keypoints); rf_est.setInputNormals (scene_normals); rf_est.setSearchSurface (scene); rf_est.compute (*scene_rf); // Clustering pcl::Hough3DGrouping<PointType, PointType, RFType, RFType> clusterer; clusterer.setHoughBinSize (cg_size_); clusterer.setHoughThreshold (cg_thresh_); clusterer.setUseInterpolation (true); clusterer.setUseDistanceWeight (false); clusterer.setInputCloud (model_keypoints); clusterer.setInputRf (model_rf); clusterer.setSceneCloud (scene_keypoints); clusterer.setSceneRf (scene_rf); clusterer.setModelSceneCorrespondences (model_scene_corrs); //clusterer.cluster (clustered_corrs); clusterer.recognize (rototranslations, clustered_corrs); } else // Using GeometricConsistency { pcl::GeometricConsistencyGrouping<PointType, PointType> gc_clusterer; gc_clusterer.setGCSize (cg_size_); gc_clusterer.setGCThreshold (cg_thresh_); gc_clusterer.setInputCloud (model_keypoints); gc_clusterer.setSceneCloud (scene_keypoints); gc_clusterer.setModelSceneCorrespondences (model_scene_corrs); //gc_clusterer.cluster (clustered_corrs); gc_clusterer.recognize (rototranslations, clustered_corrs); } // // Output results // std::cout << "Model instances found: " << rototranslations.size () << std::endl; for (size_t i = 0; i < rototranslations.size (); ++i) { std::cout << "\n Instance " << i + 1 << ":" << std::endl; std::cout << " Correspondences belonging to this instance: " << clustered_corrs[i].size () << std::endl; // Print the rotation matrix and translation vector Eigen::Matrix3f rotation = rototranslations[i].block<3,3>(0, 0); Eigen::Vector3f translation = rototranslations[i].block<3,1>(0, 3); printf ("\n"); printf (" | %6.3f %6.3f %6.3f | \n", rotation (0,0), rotation (0,1), rotation (0,2)); printf (" R = | %6.3f %6.3f %6.3f | \n", rotation (1,0), rotation (1,1), rotation (1,2)); printf (" | %6.3f %6.3f %6.3f | \n", rotation (2,0), rotation (2,1), rotation (2,2)); printf ("\n"); printf (" t = < %0.3f, %0.3f, %0.3f >\n", translation (0), translation (1), translation (2)); } // // Visualization // pcl::visualization::PCLVisualizer viewer ("Correspondence Grouping"); viewer.addPointCloud (scene, "scene_cloud"); pcl::PointCloud<PointType>::Ptr off_scene_model (new pcl::PointCloud<PointType> ()); pcl::PointCloud<PointType>::Ptr off_scene_model_keypoints (new pcl::PointCloud<PointType> ()); if (show_correspondences_ || show_keypoints_) { // We are translating the model so that it doesn't end in the middle of the scene representation pcl::transformPointCloud (*model, *off_scene_model, Eigen::Vector3f (-1,0,0), Eigen::Quaternionf (1, 0, 0, 0)); pcl::transformPointCloud (*model_keypoints, *off_scene_model_keypoints, Eigen::Vector3f (-1,0,0), Eigen::Quaternionf (1, 0, 0, 0)); pcl::visualization::PointCloudColorHandlerCustom<PointType> off_scene_model_color_handler (off_scene_model, 255, 255, 128); viewer.addPointCloud (off_scene_model, off_scene_model_color_handler, "off_scene_model"); } if (show_keypoints_) { pcl::visualization::PointCloudColorHandlerCustom<PointType> scene_keypoints_color_handler (scene_keypoints, 0, 0, 255); viewer.addPointCloud (scene_keypoints, scene_keypoints_color_handler, "scene_keypoints"); viewer.setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 5, "scene_keypoints"); pcl::visualization::PointCloudColorHandlerCustom<PointType> off_scene_model_keypoints_color_handler (off_scene_model_keypoints, 0, 0, 255); viewer.addPointCloud (off_scene_model_keypoints, off_scene_model_keypoints_color_handler, "off_scene_model_keypoints"); viewer.setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 5, "off_scene_model_keypoints"); } for (size_t i = 0; i < rototranslations.size (); ++i) { pcl::PointCloud<PointType>::Ptr rotated_model (new pcl::PointCloud<PointType> ()); pcl::transformPointCloud (*model, *rotated_model, rototranslations[i]); std::stringstream ss_cloud; ss_cloud << "instance" << i; pcl::visualization::PointCloudColorHandlerCustom<PointType> rotated_model_color_handler (rotated_model, 255, 0, 0); viewer.addPointCloud (rotated_model, rotated_model_color_handler, ss_cloud.str ()); if (show_correspondences_) { for (size_t j = 0; j < clustered_corrs[i].size (); ++j) { std::stringstream ss_line; ss_line << "correspondence_line" << i << "_" << j; PointType& model_point = off_scene_model_keypoints->at (clustered_corrs[i][j].index_query); PointType& scene_point = scene_keypoints->at (clustered_corrs[i][j].index_match); // We are drawing a line for each pair of clustered correspondences found between the model and the scene viewer.addLine<PointType, PointType> (model_point, scene_point, 0, 255, 0, ss_line.str ()); } } } while (!viewer.wasStopped ()) { viewer.spinOnce (); } return (0); }
void ribi::cmap::QtConceptMap::OnRequestSceneUpdate() { scene()->update(); }
GFXLib::GFXLib() : done(false) { initialize(); scene(); render(); }
void ribi::cmap::QtConceptMap::RepositionItems() { { //The ray of the upcoming circle of nodes, is the larger of //(1) half of the diagonal of the focal question (e.g. for short concepts) //(2) calculated from the circumference by adding the nodes' length const std::vector<QtNode *> qtnode_concepts_unsorted = Collect<QtNode>(scene()); if (qtnode_concepts_unsorted.empty()) return; const std::vector<QtNode *> qtnode_concepts = Sort(qtnode_concepts_unsorted); assert(!qtnode_concepts.empty()); assert(!qtnode_concepts.empty()); assert(qtnode_concepts[0]); const QtNode * const qtcenter_node = dynamic_cast<const QtNode *>(qtnode_concepts[0]); assert(qtcenter_node); assert(qtcenter_node->pos().x() > -0.5); assert(qtcenter_node->pos().x() < 0.5); assert(qtcenter_node->pos().y() > -0.5); assert(qtcenter_node->pos().y() < 0.5); const double r1 = 0.5 * ribi::cmap::GetDistance( qtcenter_node->boundingRect().width(), qtcenter_node->boundingRect().height()); const double r3 = 50.0; const double r = std::max(r1,r3); assert(r > 10.0); const int n_nodes = qtnode_concepts.size(); for (int i = 1; i!=n_nodes; ++i) //+1 to skip center node { //Added +0 (instead of -1) to n_nodes, to prevent, in a setup with two concepts and //one edge, the edge to overlap the central question const double pi = boost::math::constants::pi<double>(); const double angle = 2.0 * pi * boost::numeric_cast<double>(i) / boost::numeric_cast<double>(n_nodes - 1); const double x = std::cos(angle) * r; const double y = -std::sin(angle) * r; QtNode * const qtnode = qtnode_concepts[i]; qtnode->GetNode()->SetPos(x,y); //qtnode->setPos(x,y); #ifndef NDEBUG const double epsilon = 0.000001; #endif assert(std::abs(x - qtnode->pos().x()) < epsilon); assert(std::abs(x - qtnode->GetNode()->GetX()) < epsilon); assert(std::abs(x - qtnode->GetDisplayStrategy()->pos().x()) < epsilon); assert(std::abs(y - qtnode->pos().y()) < epsilon); assert(std::abs(y - qtnode->GetNode()->GetY()) < epsilon); assert(std::abs(y - qtnode->GetDisplayStrategy()->pos().y()) < epsilon); } } { //Put the edge concepts in the middle of the nodes const std::vector<QtEdge *> qtedge_concepts = Collect<QtEdge>(scene()); std::for_each(qtedge_concepts.begin(), qtedge_concepts.end(), [](QtEdge * const qtedge) { const QPointF p((qtedge->GetFrom()->pos() + qtedge->GetTo()->pos()) / 2.0); const double new_x = p.x(); const double new_y = p.y(); //qtedge->GetEdge()->SetX(new_x); //qtedge->GetEdge()->SetY(new_y); qtedge->GetEdge()->SetPos(new_x,new_y); #ifndef NDEBUG const double epsilon = 0.000001; #endif assert(std::abs(qtedge->pos().x() - qtedge->GetEdge()->GetX()) < epsilon); assert(std::abs(qtedge->pos().y() - qtedge->GetEdge()->GetY()) < epsilon); } ); } //Put the nodes around the focal question in their improved position //If there is no focal node, the non-focal nodes are put around an empty spot while (1) { bool done = true; const std::vector<QtNode *> qtnodes = Sort(Collect<QtNode>(scene())); assert(!qtnodes.empty()); assert(qtnodes[0]); //assert(IsCenterNode(qtnodes[0])); const std::vector<QtEdge* > qtedges = Collect<QtEdge>(scene()); //First node //const bool is_first_node_center_node { // boost::dynamic_pointer_cast<QtCenterNode>(qtnodes[0]) //}; const QtNode * const first_node { qtnodes[0] }; assert(first_node); std::vector<QtRoundedEditRectItem*> nodes_and_edges; std::copy(qtnodes.begin(),qtnodes.end(),std::back_inserter(nodes_and_edges)); std::copy(qtedges.begin(),qtedges.end(),std::back_inserter(nodes_and_edges)); //Move the nodes away from the center std::for_each( nodes_and_edges.begin() + 1, //+1 to skip the center node at [0] nodes_and_edges.end(), [first_node,&done](QtRoundedEditRectItem* const node_or_edge) { if (first_node->boundingRect().intersects( node_or_edge->boundingRect().translated(-node_or_edge->pos()))) { const double cur_x = node_or_edge->pos().x(); const double cur_y = node_or_edge->pos().y(); const double new_x = cur_x + (node_or_edge->pos().x() < first_node->pos().x() ? -1.0 : 1.0); const double new_y = cur_y + (node_or_edge->pos().y() < first_node->pos().y() ? -1.0 : 1.0); if (QtNode * const qtnode = dynamic_cast<QtNode *>(node_or_edge)) { qtnode->GetNode()->SetX(new_x); qtnode->GetNode()->SetY(new_y); } else { QtEdge * const qtedge = dynamic_cast<QtEdge *>(node_or_edge); assert(qtedge && "Every item is either a Qt node or Qt edge"); qtedge->GetEdge()->SetX(new_x); qtedge->GetEdge()->SetY(new_y); //node->setPos(QPointF(new_x,new_y)); } done = false; } } ); if (done) break; } }
void ProfileGraphicsView::plot(struct dive *d, bool forceRedraw) { struct divecomputer *dc; if (d) dc = select_dc(&d->dc); if (!forceRedraw && dive == d && (d && dc == diveDC)) return; clear(); dive = d; diveDC = d ? dc : NULL; if (!isVisible() || !dive) { return; } // best place to put the focus stealer code. setFocusProxy(mainWindow()->dive_list()); scene()->setSceneRect(0,0, viewport()->width()-50, viewport()->height()-50); toolTip = new ToolTipItem(); installEventFilter(toolTip); scene()->addItem(toolTip); // Fix this for printing / screen later. // plot_set_scale(scale_mode_t); if (!dc->samples) { dc = fake_dc(dc); } QString nick = get_dc_nickname(dc->model, dc->deviceid); if (nick.isEmpty()) nick = QString(dc->model); if (nick.isEmpty()) nick = tr("unknown divecomputer"); if ( tr("unknown divecomputer") == nick){ mode = PLAN; }else{ mode = DIVE; } /* * Set up limits that are independent of * the dive computer */ calculate_max_limits(dive, dc, &gc); QRectF profile_grid_area = scene()->sceneRect(); gc.maxx = (profile_grid_area.width() - 2 * profile_grid_area.x()); gc.maxy = (profile_grid_area.height() - 2 * profile_grid_area.y()); /* This is per-dive-computer */ gc.pi = *create_plot_info(dive, dc, &gc); /* Bounding box */ QPen pen = defaultPen; pen.setColor(profile_color[TIME_GRID].at(0)); QGraphicsRectItem *rect = new QGraphicsRectItem(profile_grid_area); rect->setPen(pen); scene()->addItem(rect); /* Depth profile */ plot_depth_profile(); plot_events(dc); /* Temperature profile */ plot_temperature_profile(); /* Cylinder pressure plot */ plot_cylinder_pressure(dc); /* Text on top of all graphs.. */ plot_temperature_text(); plot_depth_text(); plot_cylinder_pressure_text(); plot_deco_text(); /* Put the dive computer name in the lower left corner */ gc.leftx = 0; gc.rightx = 1.0; gc.topy = 0; gc.bottomy = 1.0; text_render_options_t computer = {DC_TEXT_SIZE, TIME_TEXT, LEFT, TOP}; diveComputer = plot_text(&computer, QPointF(gc.leftx, gc.bottomy), nick); // The Time ruler should be right after the DiveComputer: timeMarkers->setPos(0, diveComputer->y()); if (PP_GRAPHS_ENABLED) { plot_pp_gas_profile(); plot_pp_text(); } /* now shift the translation back by half the margin; * this way we can draw the vertical scales on both sides */ //cairo_translate(gc->cr, -drawing_area->x / 2.0, 0); //gc->maxx += drawing_area->x; //gc->leftx = -(drawing_area->x / drawing_area->width) / 2.0; //gc->rightx = 1.0 - gc->leftx; plot_depth_scale(); #if 0 if (gc->printer) { free(pi->entry); last_pi_entry = pi->entry = NULL; pi->nr = 0; } #endif QRectF r = scene()->itemsBoundingRect(); scene()->setSceneRect(r.x() - 15, r.y() -15, r.width() + 30, r.height() + 30); if (zoomLevel == 0) { fitInView(sceneRect()); } toolTip->readPos(); if(mode == PLAN){ timeEditor = new GraphicsTextEditor(); timeEditor->setPlainText( dive->duration.seconds ? QString::number(dive->duration.seconds/60) : tr("Set Duration: 10 minutes")); timeEditor->setPos(profile_grid_area.width() - timeEditor->boundingRect().width(), timeMarkers->y()); timeEditor->document(); connect(timeEditor, SIGNAL(editingFinished(QString)), this, SLOT(edit_dive_time(QString))); scene()->addItem(timeEditor); } }
YigNetworkChannelView::YigNetworkChannelView(QWidget *parent) : QGraphicsView(parent) { QGLFormat glFormat( QGL::SampleBuffers ); //glFormat.setSwapInterval( 1 ); // set VSync QGLWidget* viewportGL = new QGLWidget( glFormat ); setViewportUpdateMode( QGraphicsView::FullViewportUpdate ); setViewport(viewportGL); setRenderHints(QPainter::Antialiasing); setOptimizationFlag(QGraphicsView::DontAdjustForAntialiasing, true); YigGraphicsScene* yigScene = new YigGraphicsScene; yigScene->setSceneRect(0, 0, 1920, 1200); setScene(yigScene); scaleFactor = 1.0; selectionRect = new QGraphicsRectItem( QRect( 0, 0, 0, 0 ) ); selectionRect->setPen( QColor( 0, 0, 0, 200 ) ); selectionRect->setFlag(QGraphicsItem::ItemIgnoresTransformations); //selectionRect->setBrush( QColor( 69, 139, 19, 40 ) ); QColor rectColor = YigColorKit::accent; rectColor.setAlpha(130); selectionRect->setBrush(rectColor); selectionRect->setZValue( 10000 ); scene()->addItem( selectionRect ); selectionRect->hide(); //glWidget->startRendering(); mActiveBool = false; setActiveView(mActiveBool); currentCableBool = false; mouseDownBool = false; cableCounter = 0; srand((unsigned) time(0)); /* #ifdef __APPLE__ verticalScrollBar()->setStyle(new QMacStyle); horizontalScrollBar()->setStyle(new QMacStyle); #else verticalScrollBar()->setStyle(new QGtkStyle); horizontalScrollBar()->setStyle(new QGtkStyle); #endif */ QPalette scrollPalette = verticalScrollBar()->palette(); scrollPalette.setColor(QPalette::Button, YigColorKit::focus2); verticalScrollBar()->setPalette(scrollPalette); scrollPalette = horizontalScrollBar()->palette(); scrollPalette.setColor(QPalette::Button, YigColorKit::focus2); horizontalScrollBar()->setPalette(scrollPalette); setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn); setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn); /* QLinearGradient gradient(0, 0, 0, parent->geometry().height()); gradient.setColorAt(0, YigColorKit::background2); gradient.setColorAt(0.005, QColor(255, 255, 255)); gradient.setColorAt(1, QColor(190, 190, 190)); gradient.setInterpolationMode(QGradient::ColorInterpolation); QBrush backgroundBrush(gradient); backgroundBrush.setStyle(Qt::LinearGradientPattern);*/ //QBrush backgroundBrush(QPixmap(":/images/gui/YigAttractorBackground.png")); //scene()->setBackgroundBrush(YigColorKit::background); //backgroundPixmap = scene()->addPixmap(YigAttractor::renderAttractor(width(), height())); modCableParent = new QGraphicsLineItem(); modCableParent->setZValue(-20); modCableParent->setFlag(QGraphicsItem::ItemHasNoContents, true); //modCableParent->setVisible(false); scene()->addItem(modCableParent); audioCableParent = new QGraphicsLineItem(); audioCableParent->setZValue(-5); //audioCableParent->setVisible(false); audioCableParent->setFlag(QGraphicsItem::ItemHasNoContents, true); scene()->addItem(audioCableParent); /* QObject::connect(this, SIGNAL(synthForGLAdded(int,QPointF)), glWidget->getGLThread(), SLOT(addSynth(int,QPointF)), Qt::QueuedConnection); QObject::connect(this, SIGNAL(synthForGLRemoved(int)), glWidget->getGLThread(), SLOT(removeSynth(int)), Qt::QueuedConnection); QObject::connect(this, SIGNAL(synthForGLMoved(int,QPointF)), glWidget->getGLThread(), SLOT(setSynthPos(int,QPointF)), Qt::QueuedConnection); */ //glWidget.lower(); //setupViewport(&glWidget); //scene()->setBackgroundBrush(Qt::transparent); //setAttribute(Qt::WA_TranslucentBackground); //setWindowFlags(Qt::FramelessWindowHint | Qt::WindowSystemMenuHint); //QPalette p = viewport()->palette(); //p.setColor(QPalette::Base, Qt::transparent); //viewport()->setPalette(p); //viewport()->setAutoFillBackground(false); //parent->setAttribute(Qt::WA_TranslucentBackground); //parent->setAutoFillBackground(false); //setStyleSheet("background-color: transparent;"); //lower(); //glWidget.raise(); //glWidget.lower(); //glWidget.setStyleSheet("background-color: transparent;"); //glParent = new QWidget(parent); //glWidget.setParent(glParent); //glParent->lower(); //glWidget.show(); setActiveView(true); setMouseTracking(true); setFrameStyle(0); mouseCounter = 0; centerOn(0, 0); show(); }
void Line::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) { scene()->sendEvent(parentItem(), event); }
void EmulatedCardWindow::onUpdateFullWindow() { if (scene()) scene()->update(); }
void StelMainView::updateScene() { // For some reason the skyItem is not updated when the night mode shader is on. // To fix this we manually do it here. skyItem->update(); scene()->update(); }
void TextTool::mouseMoveEvent(const QList<QGraphicsItem*> & /*itemList*/, QGraphicsSceneMouseEvent *event) { event->setPos(textItem()->mapFromScene(event->scenePos())); event->setLastPos(textItem()->mapFromScene(event->lastScenePos())); scene()->sendEvent(textItem(), event); }
StelMainView::StelMainView(QWidget* parent) : QGraphicsView(parent), guiItem(NULL), gui(NULL), flagInvertScreenShotColors(false), flagOverwriteScreenshots(false), screenShotPrefix("stellarium-"), screenShotDir(""), cursorTimeout(-1.f), flagCursorTimeout(false), minFpsTimer(NULL), maxfps(10000.f) { StelApp::initStatic(); // Can't create 2 StelMainView instances Q_ASSERT(!singleton); singleton = this; setWindowIcon(QIcon(":/mainWindow/icon.bmp")); initTitleI18n(); setObjectName("Mainview"); // Allows for precise FPS control setViewportUpdateMode(QGraphicsView::NoViewportUpdate); setFrameShape(QFrame::NoFrame); setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); setFocusPolicy(Qt::StrongFocus); connect(this, SIGNAL(screenshotRequested()), this, SLOT(doScreenshot())); lastEventTimeSec = 0; #if STEL_USE_NEW_OPENGL_WIDGETS // Primary test for OpenGL existence if (QSurfaceFormat::defaultFormat().majorVersion() < 2) { qWarning() << "No OpenGL 2 support on this system. Aborting."; QMessageBox::critical(0, "Stellarium", q_("No OpenGL 2 found on this system. Please upgrade hardware or use MESA or an older version."), QMessageBox::Abort, QMessageBox::Abort); exit(0); } //QSurfaceFormat format(); //// TBD: What options shall be default? //QSurfaceFormat::setDefaultFormat(format); ////QOpenGLContext* context=new QOpenGLContext::create(); glWidget = new StelQOpenGLWidget(this); //glWidget->setFormat(format); #else // Primary test for OpenGL existence if (QGLFormat::openGLVersionFlags() < QGLFormat::OpenGL_Version_2_1) { qWarning() << "No OpenGL 2.1 support on this system. Aborting."; QMessageBox::critical(0, "Stellarium", q_("No OpenGL 2 found on this system. Please upgrade hardware or use MESA or an older version."), QMessageBox::Abort, QMessageBox::Abort); exit(1); } // Create an openGL viewport QGLFormat glFormat(QGL::StencilBuffer | QGL::DepthBuffer | QGL::DoubleBuffer); // Even if setting a version here, it is ignored in StelQGLWidget()! // TBD: Maybe this must make a differentiation between OpenGL and OpenGL ES! // glFormat.setVersion(2, 1); QGLContext* context=new QGLContext(glFormat); if (context->format() != glFormat) { qWarning() << "Cannot provide OpenGL context. Apparently insufficient OpenGL resources on this system."; QMessageBox::critical(0, "Stellarium", q_("Cannot acquire necessary OpenGL resources."), QMessageBox::Abort, QMessageBox::Abort); exit(1); } glWidget = new StelQGLWidget(context, this); // This does not return the version number set previously! // qDebug() << "glWidget.context.format.version, result:" << glWidget->context()->format().majorVersion() << "." << glWidget->context()->format().minorVersion(); #endif setViewport(glWidget); setScene(new QGraphicsScene(this)); scene()->setItemIndexMethod(QGraphicsScene::NoIndex); rootItem = new QGraphicsWidget(); rootItem->setFocusPolicy(Qt::NoFocus); // Workaround (see Bug #940638) Although we have already explicitly set // LC_NUMERIC to "C" in main.cpp there seems to be a bug in OpenGL where // it will silently reset LC_NUMERIC to the value of LC_ALL during OpenGL // initialization. This has been observed on Ubuntu 11.10 under certain // circumstances, so here we set it again just to be on the safe side. setlocale(LC_NUMERIC, "C"); // End workaround }
void ArrangeItem::mouseMoveEvent(QGraphicsSceneMouseEvent * event) { m_prevPos = pos(); m_prevRect = m_rect; qreal x = event->scenePos().x(); qreal y = event->scenePos().y(); QPointF position = pos(); qreal diffx = (x - position.x()) / 2.0; qreal diffy = (y - position.y()) / 2.0; qreal diffxw = (x - (position.x() + m_rect.width())); qreal diffyw = (y - (position.y() + m_rect.height())); prepareGeometryChange(); switch (m_mode) { case C_TL: setPos(position.x() + diffx, position.y() + diffy); m_rect.setHeight(m_rect.height() - diffy); m_rect.setWidth(m_rect.width() - diffx); break; case C_TR: setPos(position.x(), position.y() + diffy); m_rect.setHeight(m_rect.height() - diffy); m_rect.setWidth(m_rect.width() + diffxw/2.0); break; case C_BL: setPos(position.x() + diffxw/2.0, position.y()); m_rect.setHeight(m_rect.height() + diffyw/2.0); m_rect.setWidth(m_rect.width() - diffxw/2.0); break; case C_BR: m_rect.setHeight(m_rect.height() + diffyw/2.0); m_rect.setWidth(m_rect.width() + diffxw/2.0); break; case C_T: setPos(position.x(), position.y() + diffy); m_rect.setHeight(m_rect.height() - diffy); break; case C_B: m_rect.setHeight(m_rect.height() + diffyw); break; case C_L: setPos(position.x()+diffx, position.y()); m_rect.setWidth(m_rect.width() - diffx); break; case C_R: m_rect.setWidth(m_rect.width() + diffxw); break; case C_C: default: QGraphicsItem::mouseMoveEvent(event); } // scene boundaries QRectF sc(scene()->sceneRect()); QRectF it(sceneBoundingRect()); if (it.x() < sc.x() || it.y() < sc.y() || it.width()+it.x() > sc.width() || it.height()+it.y() > sc.height()) { setPos(m_prevPos); m_rect = m_prevRect; return; } // colliding plugins/items QList<QGraphicsItem*> colliding = collidingItems(); foreach (QGraphicsItem* i, colliding) { ArrangeItem * item = dynamic_cast<ArrangeItem*>(i); if (item && item->editable()) { setPos(m_prevPos); m_rect = m_prevRect; return; } }
void StelMainView::focusSky() { scene()->setActiveWindow(0); skyItem->setFocus(); }
void UBGraphicsRuler::EndLine() { // We never come to this place scene()->inputDeviceRelease(); }
void View::resizeEvent( QResizeEvent * event ) { if ( QGraphicsScene * scene_ = scene() ) scene_->setSceneRect( 0, 0, viewport()->width(), viewport()->height() ); QGraphicsView::resizeEvent(event); }
CrochetTab::CrochetTab(Scene::ChartStyle style, int defEditMode, QString defStitch, QColor defFgColor, QColor defBgColor, QWidget* parent) : QWidget(parent), ui(new Ui::OptionsBar), mChartStyle(style) { QVBoxLayout* l = new QVBoxLayout(this); QWidget* top = new QWidget(this); l->addWidget(top); QVBoxLayout* tl = new QVBoxLayout(top); top->setLayout(tl); top->setContentsMargins(0, 0, 0, 0); QPoint centerOn = QPoint(0,0); mView = new ChartView(top); mScene = new Scene(mView); mScene->setSceneRect(-2500,-2500, 5000,5000); centerOn = QPoint(0, 0); mTextView = new TextView(this, mScene); connect(mView, SIGNAL(scrollBarChanged(int,int)), mScene, SLOT(updateRubberBand(int,int))); connect(mScene, SIGNAL(stitchChanged(QString,QString)), SLOT(stitchChanged(QString,QString))); connect(mScene, SIGNAL(colorChanged(QString,QString)), SLOT(colorChanged(QString,QString))); connect(mScene, SIGNAL(rowEdited(bool)), SIGNAL(tabModified(bool))); connect(mScene, SIGNAL(guidelinesUpdated(Guidelines)), SIGNAL(guidelinesUpdated(Guidelines))); mView->setScene(mScene); QPoint pt = mView->mapFromScene(centerOn); mView->centerOn(pt.x(), pt.y()); mScene->setEditMode((Scene::EditMode)defEditMode); mScene->setEditStitch(defStitch); mScene->setEditFgColor(defFgColor); mScene->setEditBgColor(defBgColor); QWidget* w = new QWidget(top); ui->setupUi(w); tl->addWidget(mView); tl->addWidget(w); ui->horizontalLayout->setMargin(0); l->setMargin(0); tl->setMargin(0); w->setContentsMargins(0, 0, 0, 0); setContentsMargins(0, 0, 0, 0); mView->setMinimumSize(width(), height()*2/3); mView->setViewportUpdateMode(QGraphicsView::BoundingRectViewportUpdate); mRowEditDialog = new RowEditDialog(scene(), mTextView, this); ui->verticalLayout->insertWidget(0, mRowEditDialog); mRowEditDialog->hide(); connect(ui->copyInstructions, SIGNAL(clicked()), SLOT(copyInstructions())); connect(ui->zoom, SIGNAL(valueChanged(int)), SLOT(zoomChanged(int))); connect(mView, SIGNAL(zoomLevelChanged(int)), SLOT(updateZoomLevel(int))); }