Mercurial Mercurial > hedgewars / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
QTfrontend/ui/widget/mapContainer.cpp
changeset 7018 6a1f46c026bf
parent 7017 19a434fc91fc
child 7258 722e8a0d89dc
equal deleted inserted replaced
7017:19a434fc91fc 7018:6a1f46c026bf 
    75     chooseMap->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
 
    75     chooseMap->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
 
    76     m_mapModel = DataManager::instance().mapModel();
 
    76     m_mapModel = DataManager::instance().mapModel();
 
    77     chooseMap->setEditable(false);
 
    77     chooseMap->setEditable(false);
 
    78     chooseMap->setModel(m_mapModel);
 
    78     chooseMap->setModel(m_mapModel);
 
    79 
    79 
    80     // update model views after model changes (to e.g. re-adjust separators)
 
       
    81     connect(&DataManager::instance(), SIGNAL(updated()), this, SLOT(updateModelViews()));
 
       
    82 
       
    83     mapLayout->addWidget(chooseMap, 1, 1);
 
    80     mapLayout->addWidget(chooseMap, 1, 1);
 
    84 
    81 
    85     QLabel * lblMap = new QLabel(tr("Map"), mapWidget);
 
    82     QLabel * lblMap = new QLabel(tr("Map"), mapWidget);
 
    86     mapLayout->addWidget(lblMap, 1, 0);
 
    83     mapLayout->addWidget(lblMap, 1, 0);
 
    87 
    84 
   181     setRandomSeed();
 
   178     setRandomSeed();
 
   182     setRandomTheme();
 
   179     setRandomTheme();
 
   183 
   180 
   184     chooseMap->setCurrentIndex(0);
 
   181     chooseMap->setCurrentIndex(0);
 
   185     mapChanged(0);
 
   182     mapChanged(0);
 
   186     connect(chooseMap, SIGNAL(currentIndexChanged(int)), this, SLOT(mapChanged(int)));
 
   183     // use signal "activated" rather than currentIndexChanged
 
   187 
   184     // because index is somtimes changed a few times in a row programmatically
 
   188     updateModelViews();
 
   185     connect(chooseMap, SIGNAL(activated(int)), this, SLOT(mapChanged(int)));
 
       
   186 
       
   187     // update model views after model changes (to e.g. re-adjust separators)
 
       
   188     connect(&DataManager::instance(), SIGNAL(updated()), this, SLOT(updateModelViews()));
 
   189 }
 
   189 }
 
   190 
   190 
   191 void HWMapContainer::setImage(const QImage newImage)
 
   191 void HWMapContainer::setImage(const QImage newImage)
 
   192 {
 
   192 {
 
   193     QPixmap px(m_previewSize);
 
   193     QPixmap px(m_previewSize);
 
   211     hhLimit = newHHLimit;
 
   211     hhLimit = newHHLimit;
 
   212 }
 
   212 }
 
   213 
   213 
   214 void HWMapContainer::mapChanged(int index)
 
   214 void HWMapContainer::mapChanged(int index)
 
   215 {
 
   215 {
 
       
   216     if (chooseMap->currentIndex() != index)
 
       
   217         chooseMap->setCurrentIndex(index);
 
       
   218 
   216     if (index < 0)
 
   219     if (index < 0)
 
       
   220     {
 
       
   221         m_mapInfo.type = MapModel::Invalid;
 
       
   222         updatePreview();
 
   217         return;
 
   223         return;
 
       
   224     }
 
   218 
   225 
   219     Q_ASSERT(chooseMap->itemData(index, Qt::UserRole + 1).canConvert<MapModel::MapInfo>());
 
   226     Q_ASSERT(chooseMap->itemData(index, Qt::UserRole + 1).canConvert<MapModel::MapInfo>());
 
   220     m_mapInfo = chooseMap->itemData(index, Qt::UserRole + 1).value<MapModel::MapInfo>();
 
   227     m_mapInfo = chooseMap->itemData(index, Qt::UserRole + 1).value<MapModel::MapInfo>();
 
   221     m_curMap = chooseMap->currentText();
 
   228     m_curMap = m_mapInfo.name;
 
   222 
   229 
   223     switch(m_mapInfo.type)
 
   230     switch(m_mapInfo.type)
 
   224     {
 
   231     {
 
   225         case MapModel::GeneratedMap:
 
   232         case MapModel::GeneratedMap:
 
   226             mapgen = MAPGEN_REGULAR;
 
   233             mapgen = MAPGEN_REGULAR;
 
   227             updatePreview();
 
       
   228             gbThemes->show();
 
   234             gbThemes->show();
 
   229             lblFilter->show();
 
   235             lblFilter->show();
 
   230             cbTemplateFilter->show();
 
   236             cbTemplateFilter->show();
 
   231             maze_size_label->hide();
 
   237             maze_size_label->hide();
 
   232             cbMazeSize->hide();
 
   238             cbMazeSize->hide();
 
   233             break;
 
   239             break;
 
   234         case MapModel::GeneratedMaze:
 
   240         case MapModel::GeneratedMaze:
 
   235             mapgen = MAPGEN_MAZE;
 
   241             mapgen = MAPGEN_MAZE;
 
   236             updatePreview();
 
       
   237             gbThemes->show();
 
   242             gbThemes->show();
 
   238             lblFilter->hide();
 
   243             lblFilter->hide();
 
   239             cbTemplateFilter->hide();
 
   244             cbTemplateFilter->hide();
 
   240             maze_size_label->show();
 
   245             maze_size_label->show();
 
   241             cbMazeSize->show();
 
   246             cbMazeSize->show();
 
   242             break;
 
   247             break;
 
   243         case MapModel::HandDrawnMap:
 
   248         case MapModel::HandDrawnMap:
 
   244             mapgen = MAPGEN_DRAWN;
 
   249             mapgen = MAPGEN_DRAWN;
 
   245             updatePreview();
 
       
   246             gbThemes->show();
 
   250             gbThemes->show();
 
   247             lblFilter->hide();
 
   251             lblFilter->hide();
 
   248             cbTemplateFilter->hide();
 
   252             cbTemplateFilter->hide();
 
   249             maze_size_label->hide();
 
   253             maze_size_label->hide();
 
   250             cbMazeSize->hide();
 
   254             cbMazeSize->hide();
 
   251             break;
 
   255             break;
 
   252         default:
 
   256         default:
 
   253             mapgen = MAPGEN_MAP;
 
   257             mapgen = MAPGEN_MAP;
 
   254             updatePreview();
 
       
   255             gbThemes->hide();
 
   258             gbThemes->hide();
 
   256             lblFilter->hide();
 
   259             lblFilter->hide();
 
   257             cbTemplateFilter->hide();
 
   260             cbTemplateFilter->hide();
 
   258             maze_size_label->hide();
 
   261             maze_size_label->hide();
 
   259             cbMazeSize->hide();
 
   262             cbMazeSize->hide();
 
   264     if (m_mapInfo.theme.isEmpty())
 
   267     if (m_mapInfo.theme.isEmpty())
 
   265     {
 
   268     {
 
   266         m_theme = lvThemes->currentIndex().data().toString();
 
   269         m_theme = lvThemes->currentIndex().data().toString();
 
   267         emit themeChanged(m_theme);
 
   270         emit themeChanged(m_theme);
 
   268     }
 
   271     }
 
   269     emit mapChanged(m_mapInfo.name);
 
   272 
       
   273     updatePreview();
 
       
   274     emit mapChanged(m_curMap);
 
   270     emit mapgenChanged(mapgen);
 
   275     emit mapgenChanged(mapgen);
 
   271 }
 
   276 }
 
   272 
   277 
   273 // Should this add text to identify map size?
 
   278 // Should this add text to identify map size?
 
   274 void HWMapContainer::addInfoToPreview(QPixmap image)
 
   279 void HWMapContainer::addInfoToPreview(QPixmap image)
 
   291     imageButt->setIconSize(image.size());
 
   296     imageButt->setIconSize(image.size());
 
   292 }
 
   297 }
 
   293 
   298 
   294 void HWMapContainer::askForGeneratedPreview()
 
   299 void HWMapContainer::askForGeneratedPreview()
 
   295 {
 
   300 {
 
   296     if (pMap)
 
       
   297     {
 
       
   298         disconnect(pMap, 0, this, SLOT(setImage(const QImage)));
 
       
   299         disconnect(pMap, 0, this, SLOT(setHHLimit(int)));
 
       
   300         pMap = 0;
 
       
   301     }
 
       
   302 
       
   303     pMap = new HWMap();
 
   301     pMap = new HWMap();
 
   304     connect(pMap, SIGNAL(ImageReceived(const QImage)), this, SLOT(setImage(const QImage)));
 
   302     connect(pMap, SIGNAL(ImageReceived(const QImage)), this, SLOT(setImage(const QImage)));
 
   305     connect(pMap, SIGNAL(HHLimitReceived(int)), this, SLOT(setHHLimit(int)));
 
   303     connect(pMap, SIGNAL(HHLimitReceived(int)), this, SLOT(setHHLimit(int)));
 
   306     connect(pMap, SIGNAL(destroyed(QObject *)), this, SLOT(onPreviewMapDestroyed(QObject *)));
 
   304     connect(pMap, SIGNAL(destroyed(QObject *)), this, SLOT(onPreviewMapDestroyed(QObject *)));
 
   307     pMap->getImage(m_seed,
 
   305     pMap->getImage(m_seed,
 
   340 }
 
   338 }
 
   341 
   339 
   342 QString HWMapContainer::getCurrentMap() const
 
   340 QString HWMapContainer::getCurrentMap() const
 
   343 {
 
   341 {
 
   344     if(chooseMap->currentIndex() < MAPGEN_MAP) return QString();
 
   342     if(chooseMap->currentIndex() < MAPGEN_MAP) return QString();
 
   345     return(m_mapInfo.name);
 
   343     return(m_curMap);
 
   346 }
 
   344 }
 
   347 
   345 
   348 QString HWMapContainer::getCurrentTheme() const
 
   346 QString HWMapContainer::getCurrentTheme() const
 
   349 {
 
   347 {
 
   350     return(m_theme);
 
   348     return(m_theme);
 
   395         updatePreview();
 
   393         updatePreview();
 
   396 }
 
   394 }
 
   397 
   395 
   398 void HWMapContainer::intSetMap(const QString & map)
 
   396 void HWMapContainer::intSetMap(const QString & map)
 
   399 {
 
   397 {
 
       
   398     m_curMap = map;
 
       
   399 
   400     int id = m_mapModel->indexOf(map);
 
   400     int id = m_mapModel->indexOf(map);
 
   401 
   401 
   402     if (pMap)
 
   402     mapChanged(id);
 
   403     {
 
   403 }
 
   404         disconnect(pMap, 0, this, SLOT(setImage(const QImage)));
 
   404 
   405         disconnect(pMap, 0, this, SLOT(setHHLimit(int)));
 
   405 void HWMapContainer::setMap(const QString & map)
 
   406         pMap = 0;
 
   406 {
 
   407     }
 
   407     if ((m_mapInfo.type == MapModel::Invalid) || (map != m_mapInfo.name))
 
   408 
   408         intSetMap(map);
 
   409     chooseMap->setCurrentIndex(id);
 
       
   410 
       
   411     if(id < 0)
 
       
   412     {
 
       
   413         m_mapInfo.type = MapModel::Invalid;
 
       
   414         m_curMap = map;
 
       
   415     }
 
       
   416 }
 
       
   417 
       
   418 void HWMapContainer::setMap(const QString &map)
 
       
   419 {
 
       
   420     intSetMap(map);
 
       
   421     updatePreview();
 
       
   422 }
 
   409 }
 
   423 
   410 
   424 void HWMapContainer::setTheme(const QString & theme)
 
   411 void HWMapContainer::setTheme(const QString & theme)
 
   425 {
 
   412 {
 
   426     QModelIndexList mdl = m_themeModel->match(m_themeModel->index(0), Qt::DisplayRole, theme);
 
   413     QModelIndexList mdl = m_themeModel->match(m_themeModel->index(0), Qt::DisplayRole, theme);
 
   445             break;
 
   432             break;
 
   446         case MapModel::MissionMap:
 
   433         case MapModel::MissionMap:
 
   447         case MapModel::StaticMap:
 
   434         case MapModel::StaticMap:
 
   448             // get random map of same type
 
   435             // get random map of same type
 
   449             idx = m_mapModel->randomMap(m_mapInfo.type);
 
   436             idx = m_mapModel->randomMap(m_mapInfo.type);
 
   450             chooseMap->setCurrentIndex(idx);
 
   437             mapChanged(idx);
 
   451             break;
 
   438             break;
 
   452         case MapModel::Invalid:
 
   439         case MapModel::Invalid:
 
   453             chooseMap->setCurrentIndex(0);
 
   440             mapChanged(0);
 
   454     }
 
   441     }
 
   455 }
 
   442 }
 
   456 
   443 
   457 
   444 
   458 void HWMapContainer::setRandomSeed()
 
   445 void HWMapContainer::setRandomSeed()
 
   475 }
 
   462 }
 
   476 
   463 
   477 void HWMapContainer::setTemplateFilter(int filter)
 
   464 void HWMapContainer::setTemplateFilter(int filter)
 
   478 {
 
   465 {
 
   479     intSetTemplateFilter(filter);
 
   466     intSetTemplateFilter(filter);
 
   480     updatePreview();
 
   467     if (m_mapInfo.type == MapModel::GeneratedMap)
 
       
   468         updatePreview();
 
   481 }
 
   469 }
 
   482 
   470 
   483 MapGenerator HWMapContainer::get_mapgen(void) const
 
   471 MapGenerator HWMapContainer::get_mapgen(void) const
 
   484 {
 
   472 {
 
   485     return mapgen;
 
   473     return mapgen;
 
   497 }
 
   485 }
 
   498 
   486 
   499 void HWMapContainer::setMazeSize(int size)
 
   487 void HWMapContainer::setMazeSize(int size)
 
   500 {
 
   488 {
 
   501     intSetMazeSize(size);
 
   489     intSetMazeSize(size);
 
   502     updatePreview();
 
   490     if (m_mapInfo.type == MapModel::GeneratedMaze)
 
       
   491         updatePreview();
 
   503 }
 
   492 }
 
   504 
   493 
   505 void HWMapContainer::intSetMapgen(MapGenerator m)
 
   494 void HWMapContainer::intSetMapgen(MapGenerator m)
 
   506 {
 
   495 {
 
   507     mapgen = m;
 
   496     if (mapgen != m)
 
   508 
   497     {
 
       
   498         mapgen = m;
 
       
   499 
       
   500         switch (m)
 
       
   501         {
 
       
   502             case MAPGEN_REGULAR:
 
       
   503                 m_mapInfo.type = MapModel::GeneratedMap;
 
       
   504                 break;
 
       
   505             case MAPGEN_MAZE:
 
       
   506                 m_mapInfo.type = MapModel::GeneratedMaze;
 
       
   507                 break;
 
       
   508             case MAPGEN_DRAWN:
 
       
   509                 m_mapInfo.type = MapModel::HandDrawnMap;
 
       
   510                 break;
 
       
   511             case MAPGEN_MAP:
 
       
   512                 switch (m_mapInfo.type)
 
       
   513                 {
 
       
   514                     case MapModel::GeneratedMap:
 
       
   515                     case MapModel::GeneratedMaze:
 
       
   516                     case MapModel::HandDrawnMap:
 
       
   517                         m_mapInfo.type = MapModel::Invalid;
 
       
   518                     default:
 
       
   519                         break;
 
       
   520                 }
 
       
   521                 break;
 
       
   522         }
 
       
   523 
       
   524         if(m != MAPGEN_MAP)
 
       
   525             chooseMap->setCurrentIndex(m);
 
       
   526 
       
   527         emit mapgenChanged(m);
 
       
   528     }
 
       
   529 }
 
       
   530 
       
   531 void HWMapContainer::setMapgen(MapGenerator m)
 
       
   532 {
 
       
   533     intSetMapgen(m);
 
   509     if(m != MAPGEN_MAP)
 
   534     if(m != MAPGEN_MAP)
 
   510         chooseMap->setCurrentIndex(m);
 
   535         updatePreview();
 
   511 
       
   512     emit mapgenChanged(m);
 
       
   513 }
 
       
   514 
       
   515 void HWMapContainer::setMapgen(MapGenerator m)
 
       
   516 {
 
       
   517     intSetMapgen(m);
 
       
   518     updatePreview();
 
       
   519 }
 
   536 }
 
   520 
   537 
   521 void HWMapContainer::setDrawnMapData(const QByteArray & ar)
 
   538 void HWMapContainer::setDrawnMapData(const QByteArray & ar)
 
   522 {
 
   539 {
 
   523     drawMapScene.decode(ar);
 
   540     drawMapScene.decode(ar);
 
   560     updatePreview();
 
   577     updatePreview();
 
   561 }
 
   578 }
 
   562 
   579 
   563 void HWMapContainer::updatePreview()
 
   580 void HWMapContainer::updatePreview()
 
   564 {
 
   581 {
 
       
   582     if (pMap)
 
       
   583     {
 
       
   584         disconnect(pMap, 0, this, SLOT(setImage(const QImage)));
 
       
   585         disconnect(pMap, 0, this, SLOT(setHHLimit(int)));
 
       
   586         pMap = 0;
 
       
   587     }
 
       
   588 
   565     QPixmap failIcon;
 
   589     QPixmap failIcon;
 
   566 
   590 
   567     switch(m_mapInfo.type)
 
   591     switch(m_mapInfo.type)
 
   568     {
 
   592     {
 
   569         case MapModel::Invalid:
 
   593         case MapModel::Invalid:
 
   598     }
 
   622     }
 
   599 }
 
   623 }
 
   600 
   624 
   601 void HWMapContainer::setAllMapParameters(const QString &map, MapGenerator m, int mazesize, const QString &seed, int tmpl)
 
   625 void HWMapContainer::setAllMapParameters(const QString &map, MapGenerator m, int mazesize, const QString &seed, int tmpl)
 
   602 {
 
   626 {
 
   603     intSetMap(map);
 
       
   604     intSetMapgen(m);
 
   627     intSetMapgen(m);
 
   605     intSetMazeSize(mazesize);
 
   628     intSetMazeSize(mazesize);
 
   606     intSetSeed(seed);
 
   629     intSetSeed(seed);
 
   607     intSetTemplateFilter(tmpl);
 
   630     intSetTemplateFilter(tmpl);
 
   608 
   631     // this one last because it will refresh the preview
 
   609     updatePreview();
 
   632     intSetMap(map);
 
   610 }
 
   633 }
 
   611 
   634 
   612 
   635 
   613 void HWMapContainer::updateModelViews()
 
   636 void HWMapContainer::updateModelViews()
 
   614 {
 
   637 {
 
   622         else
 
   645         else
 
   623             setRandomTheme();
 
   646             setRandomTheme();
 
   624     }
 
   647     }
 
   625 
   648 
   626     // restore map selection
 
   649     // restore map selection
 
   627     if (!m_curMap.isEmpty())
 
   650     if ((!m_curMap.isEmpty()) && (chooseMap->currentIndex() < 0))
 
   628         setMap(m_curMap);
 
   651         intSetMap(m_curMap);
 
   629 
   652     else
 
       
   653         updatePreview();
 
   630 }
 
   654 }
 
   631 
   655 
   632 
   656 
   633 void HWMapContainer::onPreviewMapDestroyed(QObject * map)
 
   657 void HWMapContainer::onPreviewMapDestroyed(QObject * map)
 
   634 {
 
   658 {
hedgewars