コード例 #1
0
ファイル: Tiled2DGraphics.cpp プロジェクト: cefix/addons
void Tiled2DGraphics::updateLevels()
{
	if (_levels.size() == 0)
		return;
	
	Level* new_level = NULL;
	Levels::iterator i = _levels.lower_bound(_currentZoomLevel);
	if (i != _levels.begin())
		--i;
	Levels::iterator next_i = i;
	if (next_i != _levels.end()) {
		next_i++;
		if (next_i == _levels.end())
			--next_i;
	}
	
	float lower_d = (_currentZoomLevel - i->first);
	float upper_d = (i->first - _currentZoomLevel);
	new_level =  (lower_d < upper_d) ? i->second : next_i->second;
	    
    if(_currentVisibleLevel != new_level) 
    {
        for(Level::TilesList::iterator i = _visibleTiles.begin(); i != _visibleTiles.end(); ++i) {
            _tilesToHide.push_back(*i);
        }
        _visibleTiles.clear();
        hideOrphanedTiles();
    }
    
    // std::cout << new_level << " lower: " << lower_d << " upper: " << upper_d << std::endl;
    
	for(Levels::iterator itr = _levels.begin(); itr != _levels.end(); ++itr) {
        // std::cout << itr->second->getLevelId() << ": " << ((itr->second == new_level) * 0xFFFF) << std::endl;
		itr->second->setNodeMask( (itr->second == new_level) * 0xFFFF);
	}
    

    
	_currentVisibleLevel = new_level;
    
    if (_tilesComputed)
        updateVisibility();
}
コード例 #2
0
ファイル: WaveEditorWidget.cpp プロジェクト: ellis/gcead
void WaveEditorWidget::updateFromInfo()
{
	if (m_vwi != NULL)
	{
		m_lblName->setText(m_vwi->wave()->sName);
		m_lblSens->setText(tr("%0 mV").arg(m_vwi->voltsPerDivision()));
		m_lblShift->setText(tr("%0 s").arg(m_vwi->shift() / EAD_SAMPLES_PER_SECOND));
		m_chkVisible->setChecked(m_vwi->isVisible());
	}
	else
	{
		m_lblName->setText("");
		m_lblSens->setText(tr("-"));
		m_lblShift->setText(tr("-"));
		m_chkVisible->setChecked(false);
	}

	updateVisibility();
}
コード例 #3
0
ファイル: level.cpp プロジェクト: Nekoninja/keeperrl
void Level::replaceSquare(Vec2 pos, PSquare square) {
  if (contains(tickingSquares, getSquare(pos)))
    removeElement(tickingSquares, getSquare(pos));
  Creature* c = squares[pos]->getCreature();
  for (Item* it : squares[pos]->getItems())
    square->dropItem(squares[pos]->removeItem(it));
  squares[pos]->onConstructNewSquare(square.get());
  addLightSource(pos, squares[pos]->getLightEmission(), -1);
  square->setCovered(squares[pos]->isCovered());
  square->addLight(squares[pos]->getTotalLight());
  square->setBackground(squares[pos].get());
  squares[pos] = std::move(square);
  squares[pos]->setPosition(pos);
  squares[pos]->setLevel(this);
  if (c) {
    squares[pos]->putCreatureSilently(c);
  }
  addLightSource(pos, squares[pos]->getLightEmission(), 1);
  updateVisibility(pos);
}
コード例 #4
0
void TargetSetupPage::setupWidgets()
{
    // Known profiles:
    QList<Kit *> kitList;
    if (m_requiredMatcher.isValid())
        kitList = KitManager::matchingKits(m_requiredMatcher);
    else
        kitList = KitManager::kits();


    foreach (Kit *k, kitList)
        addWidget(k);

    // Setup import widget:
    Utils::FileName path = Utils::FileName::fromString(m_projectPath);
    path = path.parentDir(); // base dir
    path = path.parentDir(); // parent dir
    m_importWidget->setCurrentDirectory(path);

    updateVisibility();
}
コード例 #5
0
void CrumbleBar::pushFile(const QString &fileName)
{
    if (m_isInternalCalled == false) {
        crumblePath()->clear();
    } else {
        CrumbleBarInfo lastElementCrumbleBarInfo = crumblePath()->dataForLastIndex().value<CrumbleBarInfo>();

        if (!lastElementCrumbleBarInfo.displayName.isEmpty()
                && lastElementCrumbleBarInfo.fileName == fileName)
            crumblePath()->popElement();
    }

    CrumbleBarInfo crumbleBarInfo;
    crumbleBarInfo.fileName = fileName;

    crumblePath()->pushElement(fileName.split("/").last(), QVariant::fromValue(crumbleBarInfo));

    m_isInternalCalled = false;

    updateVisibility();
}
コード例 #6
0
ファイル: ksaneoptbutton.cpp プロジェクト: KDE/libksane
void KSaneOptButton::createWidget(QWidget *parent)
{
    if (m_widget) {
        return;
    }

    readOption();

    if (!m_optDesc) {
        qDebug() << "This is a bug";
        m_widget = new KSaneOptionWidget(parent, QStringLiteral(""));
        return;
    }

    m_widget = m_button = new KSaneButton(parent, i18n(m_optDesc->title));
    m_widget->setToolTip(i18n(m_optDesc->desc));
    connect(m_button, &KSaneButton::clicked, this, &KSaneOptButton::buttonClicked);

    updateVisibility();
    readValue();
}
コード例 #7
0
SpellCheckerWidget::SpellCheckerWidget(QWidget *parent)
  : QWidget(parent)
{
  m_label = new QLabel(this);
  m_active = new QCheckBox(this);
  m_active->setChecked(ChatCore::settings()->value(LS("SpellChecker/Active")).toBool());

  m_advanced = new QCheckBox(this);
  m_advanced->setChecked(ChatCore::settings()->value(LS("SpellChecker/Advanced")).toBool());

  m_list = new QListWidget(this);
  m_list->setFrameShape(QFrame::NoFrame);
  m_list->setAlternatingRowColors(true);
  m_list->setSpacing(1);
  m_list->setDragDropMode(QAbstractItemView::InternalMove);
  m_list->installEventFilter(this);

  QGridLayout *listLay = new QGridLayout();
  listLay->addWidget(m_list);
  listLay->setContentsMargins(16, 0, 0, 0);

  QVBoxLayout *layout = new QVBoxLayout();
  layout->addWidget(m_active);
  layout->addWidget(m_advanced);
  layout->addLayout(listLay);
  layout->setContentsMargins(10, 0, 3, 0);

  QVBoxLayout *mainLay = new QVBoxLayout(this);
  mainLay->addWidget(m_label);
  mainLay->addLayout(layout);
  mainLay->setContentsMargins(0, 12, 0, 0);

  build();
  updateVisibility();
  retranslateUi();

  connect(m_active, SIGNAL(clicked(bool)),SLOT(activeClicked(bool)));
  connect(m_advanced, SIGNAL(clicked(bool)),SLOT(advancedClicked(bool)));
  connect(m_list, SIGNAL(itemChanged(QListWidgetItem*)),SLOT(reloadDictionaries()));
}
コード例 #8
0
ファイル: dockapplet.cpp プロジェクト: ViktorNova/qtpanel
void Client::windowPropertyChanged(unsigned long atom)
{
	if(atom == X11Support::atom("_NET_WM_WINDOW_TYPE") || atom == X11Support::atom("_NET_WM_STATE"))
	{
		updateVisibility();
	}

	if(atom == X11Support::atom("_NET_WM_VISIBLE_NAME") || atom == X11Support::atom("_NET_WM_NAME") || atom == X11Support::atom("WM_NAME"))
	{
		updateName();
	}

	if(atom == X11Support::atom("_NET_WM_ICON"))
	{
		updateIcon();
	}

	if(atom == X11Support::atom("WM_HINTS"))
	{
		updateUrgency();
	}
}
コード例 #9
0
QgsHtmlAnnotationItem::QgsHtmlAnnotationItem( QgsMapCanvas* canvas, QgsVectorLayer* vlayer, bool hasFeature, int feature )
    : QgsAnnotationItem( canvas )
    , mWidgetContainer( 0 )
    , mWebView( 0 )
    , mVectorLayer( vlayer )
    , mHasAssociatedFeature( hasFeature )
    , mFeatureId( feature )
{
  mWebView = new QgsWebView();
  mWebView->page()->setNetworkAccessManager( QgsNetworkAccessManager::instance() );

  mWidgetContainer = new QGraphicsProxyWidget( this );
  mWidgetContainer->setWidget( mWebView );

  QObject::connect( mWebView->page()->mainFrame(), SIGNAL( javaScriptWindowObjectCleared() ), this, SLOT( javascript() ) );

  if ( mVectorLayer && mMapCanvas )
  {
    QObject::connect( mVectorLayer, SIGNAL( layerModified() ), this, SLOT( setFeatureForMapPosition() ) );
    QObject::connect( mMapCanvas, SIGNAL( renderComplete( QPainter* ) ), this, SLOT( setFeatureForMapPosition() ) );
    QObject::connect( mMapCanvas, SIGNAL( layersChanged() ), this, SLOT( updateVisibility() ) );
  }
コード例 #10
0
ファイル: editable_label.cpp プロジェクト: bdajeje/QTNotes
void EditableLabel::showLabel()
{
  m_label_shown = true;
  updateVisibility();
}
コード例 #11
0
CovarianceProperty::CovarianceProperty( const QString& name,
                            bool default_value,
                            const QString& description,
                            Property* parent,
                            const char *changed_slot,
                            QObject* receiver )
  // NOTE: changed_slot and receiver aren't passed to BoolProperty here, but initialized at the end of this constructor
  : BoolProperty( name, default_value, description, parent )
{

  position_property_ = new BoolProperty( "Position", true,
                                       "Whether or not to show the position part of covariances",
                                       this, SLOT( updateVisibility() ));
  position_property_->setDisableChildrenIfFalse( true );

  position_color_property_ = new ColorProperty( "Color", QColor( 204, 51, 204 ),
                                             "Color to draw the position covariance ellipse.",
                                             position_property_, SLOT( updateColorAndAlphaAndScaleAndOffset() ), this );

  position_alpha_property_ = new FloatProperty( "Alpha", 0.3f,
                                             "0 is fully transparent, 1.0 is fully opaque.",
                                             position_property_, SLOT( updateColorAndAlphaAndScaleAndOffset() ), this );
  position_alpha_property_->setMin( 0 );
  position_alpha_property_->setMax( 1 );

  position_scale_property_ = new FloatProperty( "Scale", 1.0f,
                                             "Scale factor to be applied to covariance ellipse. Corresponds to the number of standard deviations to display",
                                             position_property_, SLOT( updateColorAndAlphaAndScaleAndOffset() ), this );
  position_scale_property_->setMin( 0 );

  orientation_property_ = new BoolProperty( "Orientation", true,
                                          "Whether or not to show the orientation part of covariances",
                                          this, SLOT( updateVisibility() ));
  orientation_property_->setDisableChildrenIfFalse( true );

  orientation_frame_property_ = new EnumProperty( "Frame", "Local", "The frame used to display the orientation covariance.",
                                      orientation_property_, SLOT( updateOrientationFrame() ), this );
  orientation_frame_property_->addOption( "Local", Local );
  orientation_frame_property_->addOption( "Fixed", Fixed );

  orientation_colorstyle_property_ = new EnumProperty( "Color Style", "Unique", "Style to color the orientation covariance: XYZ with same unique color or following RGB order",
                                      orientation_property_, SLOT( updateColorStyleChoice() ), this );
  orientation_colorstyle_property_->addOption( "Unique", Unique );
  orientation_colorstyle_property_->addOption( "RGB", RGB );

  orientation_color_property_ = new ColorProperty( "Color", QColor( 255, 255, 127 ),
                                             "Color to draw the covariance ellipse.",
                                             orientation_property_, SLOT( updateColorAndAlphaAndScaleAndOffset() ), this );

  orientation_alpha_property_ = new FloatProperty( "Alpha", 0.5f,
                                             "0 is fully transparent, 1.0 is fully opaque.",
                                             orientation_property_, SLOT( updateColorAndAlphaAndScaleAndOffset() ), this );
  orientation_alpha_property_->setMin( 0 );
  orientation_alpha_property_->setMax( 1 );

  orientation_offset_property_ = new FloatProperty( "Offset", 1.0f,
                                             "For 3D poses is the distance where to position the ellipses representing orientation covariance. For 2D poses is the height of the triangle representing the variance on yaw",
                                             orientation_property_, SLOT( updateColorAndAlphaAndScaleAndOffset() ), this );
  orientation_offset_property_->setMin( 0 );

  orientation_scale_property_ = new FloatProperty( "Scale", 1.0f,
                                             "Scale factor to be applied to orientation covariance shapes. Corresponds to the number of standard deviations to display",
                                             orientation_property_, SLOT( updateColorAndAlphaAndScaleAndOffset() ), this );
  orientation_scale_property_->setMin( 0 );

  connect(this, SIGNAL( changed() ), this, SLOT( updateVisibility() ));

  // Connect changed() signal here instead of doing it through the initialization of BoolProperty().
  // We do this here to make changed_slot be called _after_ updateVisibility()
  if(changed_slot && (parent || receiver))
  {
    if(receiver)
      connect(this, SIGNAL( changed() ), receiver, changed_slot);
    else
      connect(this, SIGNAL( changed() ), parent, changed_slot);
  }

  setDisableChildrenIfFalse( true );
}
コード例 #12
0
ファイル: lod_node.cpp プロジェクト: Benau/stk-code
void LODNode::OnRegisterSceneNode()
{
    bool shown = false;
    updateVisibility(&shown);

    const u32 now = irr_driver->getDevice()->getTimer()->getTime();

    // support an optional, mostly hard-coded fade-in/out effect for objects with a single level
    if (m_nodes.size() == 1 && (m_nodes[0]->getType() == scene::ESNT_MESH ||
                                m_nodes[0]->getType() == scene::ESNT_ANIMATED_MESH) &&
        now > m_last_tick)
    {
        if (m_previous_visibility == WAS_HIDDEN && shown)
        {
            scene::IMesh* mesh;

            if (m_nodes[0]->getType() == scene::ESNT_MESH)
            {
                scene::IMeshSceneNode* node = (scene::IMeshSceneNode*)(m_nodes[0]);
                mesh = node->getMesh();
            }
            else
            {
                assert(m_nodes[0]->getType() == scene::ESNT_ANIMATED_MESH);
                scene::IAnimatedMeshSceneNode* node =
                    (scene::IAnimatedMeshSceneNode*)(m_nodes[0]);
                assert(node != NULL);
                mesh = node->getMesh();
            }

            for (unsigned int n=0; n<mesh->getMeshBufferCount(); n++)
            {
                scene::IMeshBuffer* mb = mesh->getMeshBuffer(n);
                video::ITexture* t = mb->getMaterial().getTexture(0);
                if (t == NULL) continue;

                Material* m = material_manager->getMaterialFor(t, mb);
                if (m != NULL)
                {
                    m->onMadeVisible(mb);
                }
            }
        }
        else if (m_previous_visibility == WAS_SHOWN && !shown)
        {
            scene::IMesh* mesh;

            if (m_nodes[0]->getType() == scene::ESNT_MESH)
            {
                scene::IMeshSceneNode* node = (scene::IMeshSceneNode*)(m_nodes[0]);
                mesh = node->getMesh();
            }
            else
            {
                assert(m_nodes[0]->getType() == scene::ESNT_ANIMATED_MESH);
                scene::IAnimatedMeshSceneNode* node =
                    (scene::IAnimatedMeshSceneNode*)(m_nodes[0]);
                assert(node != NULL);
                mesh = node->getMesh();
            }

            for (unsigned int n=0; n<mesh->getMeshBufferCount(); n++)
            {
                scene::IMeshBuffer* mb = mesh->getMeshBuffer(n);
                video::ITexture* t = mb->getMaterial().getTexture(0);
                if (t == NULL) continue;
                Material* m = material_manager->getMaterialFor(t, mb);
                if (m != NULL)
                {
                    m->onHidden(mb);
                }
            }
        }
        else if (m_previous_visibility == FIRST_PASS && !shown)
        {
            scene::IMesh* mesh;

            if (m_nodes[0]->getType() == scene::ESNT_MESH)
            {
                scene::IMeshSceneNode* node = (scene::IMeshSceneNode*)(m_nodes[0]);
                mesh = node->getMesh();
            }
            else
            {
                assert(m_nodes[0]->getType() == scene::ESNT_ANIMATED_MESH);
                scene::IAnimatedMeshSceneNode* node =
                (scene::IAnimatedMeshSceneNode*)(m_nodes[0]);
                assert(node != NULL);
                mesh = node->getMesh();
            }

            for (unsigned int n=0; n<mesh->getMeshBufferCount(); n++)
            {
                scene::IMeshBuffer* mb = mesh->getMeshBuffer(n);
                video::ITexture* t = mb->getMaterial().getTexture(0);
                if(!t) continue;
                Material* m = material_manager->getMaterialFor(t, mb);
                if (m != NULL)
                {
                    m->isInitiallyHidden(mb);
                }
            }
        }
    }

    m_previous_visibility = (shown ? WAS_SHOWN : WAS_HIDDEN);
    m_last_tick = now;
    if (!CVS->isGLSL())
    {
        for (core::list<ISceneNode*>::Iterator it = Children.begin();
            it != Children.end(); it++)
        {
            (*it)->updateAbsolutePosition();
        }
    }

    scene::ISceneNode::OnRegisterSceneNode();
}
コード例 #13
0
	View::View(game::TileMap &tile_map, game::EntityMap &entity_map, const int2 &view_size)
		:m_tile_map(tile_map), m_entity_map(entity_map), m_occluder_config(tile_map.occluderMap()), m_height(1), m_cell_size(1),
		m_is_visible(false), m_view_size(view_size), m_view_pos(-200, 300) {
		updateVisibility();
	}
コード例 #14
0
ファイル: gfx_light.cpp プロジェクト: grit-engine/grit-engine
void GfxLight::setDiffuseColour (const Vector3 &v)
{
    if (dead) THROW_DEAD(className);
    diffuse = v;
    updateVisibility();
}
コード例 #15
0
ファイル: gfx_light.cpp プロジェクト: grit-engine/grit-engine
void GfxLight::setEnabled (bool v)
{
    if (dead) THROW_DEAD(className);
    enabled = v;
    updateVisibility();
}
コード例 #16
0
ファイル: tabview.cpp プロジェクト: serghei/kde-kdesdk
TabView::TabView(TraceItemView* parentView,
                 QWidget* parent, const char* name)
  : QWidget(parent, name), TraceItemView(parentView)
{
    setFocusPolicy(QWidget::StrongFocus);

  _isCollapsed = true;

  QVBoxLayout* vbox = new QVBoxLayout( this, 6, 6);

  _nameLabel = new KSqueezedTextLabel( this, "nameLabel" );
  _nameLabel->setText(i18n("(No profile data file loaded)"));
  vbox->addWidget( _nameLabel );

  _mainSplitter   = new QSplitter(Qt::Horizontal, this);
  _leftSplitter   = new Splitter(Qt::Vertical, _mainSplitter, "Left");
  vbox->addWidget( _mainSplitter );

  _rightTW = new TabWidget(this, _mainSplitter, "Right");
  connect(_rightTW, SIGNAL(currentChanged(QWidget*)),
          this, SLOT(tabChanged(QWidget*)));
  connect(_rightTW, SIGNAL(visibleRectChanged(TabWidget*)),
          this, SLOT(visibleRectChangedSlot(TabWidget*)));

  _topTW = new TabWidget(this, _leftSplitter, "Top");
  connect(_topTW, SIGNAL(currentChanged(QWidget*)),
          this, SLOT(tabChanged(QWidget*)));
  connect(_topTW, SIGNAL(visibleRectChanged(TabWidget*)),
          this, SLOT(visibleRectChangedSlot(TabWidget*)));

  _bottomSplitter = new Splitter(Qt::Horizontal,
                                  _leftSplitter, "Bottom");

  _leftTW = new TabWidget(this, _bottomSplitter, "Left");
  _leftTW->setTabPosition(QTabWidget::Bottom);
  connect(_leftTW, SIGNAL(currentChanged(QWidget*)),
          this, SLOT(tabChanged(QWidget*)));
  connect(_leftTW, SIGNAL(visibleRectChanged(TabWidget*)),
          this, SLOT(visibleRectChangedSlot(TabWidget*)));

  _bottomTW = new TabWidget(this, _bottomSplitter, "Bottom");
  _bottomTW->setTabPosition(QTabWidget::Bottom);
  connect(_bottomTW, SIGNAL(currentChanged(QWidget*)),
          this, SLOT(tabChanged(QWidget*)));
  connect(_bottomTW, SIGNAL(visibleRectChanged(TabWidget*)),
          this, SLOT(visibleRectChangedSlot(TabWidget*)));


  // default positions...

  addTop( addTab( i18n("Types"),
		  new CostTypeView(this, _topTW,
				   "CostTypeView")));
  addTop( addTab( i18n("Callers"),
		  new CallView(true, this, _topTW,
			       "CallerView")));
  addTop( addTab( i18n("All Callers"),
		  new CoverageView(true, this, _topTW,
				   "AllCallerView")));
  addTop( addTab( i18n("Caller Map"),
		  new CallMapView(true, this, _bottomTW,
				  "CallerMapView")));
  addTop( addTab( i18n("Source"),
		  new SourceView(this, _topTW,
				 "SourceView")));

  addBottom( addTab( i18n("Parts"),
		     new PartView(this, _bottomTW,
				  "PartView")));
  addBottom( addTab( i18n("Call Graph"),
		     new CallGraphView(this, _bottomTW,
				       "CallGraphView")));
  addBottom( addTab( i18n("Callees"),
		     new CallView(false, this, _bottomTW,
				  "CalleeView")));
  addBottom( addTab( i18n("All Callees"),
		     new CoverageView(false, this, _bottomTW,
				      "AllCalleeView")));

  addBottom( addTab( i18n("Callee Map"),
		     new CallMapView(false, this, _topTW,
				     "CalleeMapView")));
  addBottom( addTab( i18n("Assembler"),
		     new InstrView(this, _bottomTW,
				   "InstrView")));

  // after all child widgets are created...
  _lastFocus = 0;
  _active = false;
  installFocusFilters();

  updateVisibility();

  QWhatsThis::add( this, whatsThis() );
}
コード例 #17
0
ファイル: tabbar.cpp プロジェクト: agnelterry/arora
void TabBar::setShowTabBarWhenOneTab(bool enabled)
{
    m_showTabBarWhenOneTab = enabled;
    updateVisibility();
}
コード例 #18
0
ファイル: guipanel.cpp プロジェクト: cfcohen/openbrf
GuiPanel::GuiPanel(QWidget *parent, IniData &id) :
    QWidget(parent),
    inidata(id),
    ui(new Ui::GuiPanel)
{
  reference = NULL;
  curMaterialFocus = DIFFUSEA;

  //mapMT = mm;
  _selectedIndex = -1;

  ui->setupUi(this);

//  ui->attributeData->tabBar()->setContentsMargins(-4,0,-4,0);
  QTabWidget *tw = ui->attributeData;
  int mar = 0;
  tw->setStyleSheet(QString("QTabBar::tab { width: %1px;padding-top: 1px; padding-bottom: 1px;margin-right: %2px;margin-left: %2px;} ")
                    .arg((tw->size().width()+(2*mar*tw->count())-1)/tw->count()).arg(-mar)
                    );

  ui->wiBodyAxisA->setVisible(false);
  ui->wiBodyAxisB->setVisible(false);
  ui->wiBodyRadius->setVisible(false);
  ui->wiBodyNFaces->setVisible(false);
  ui->wiBodyNVerts->setVisible(false);
  ui->wiBodySigns->setVisible(false);
  ui->wiBodyFlags->setVisible(false);

  ui->bodyData->setVisible(false);
  ui->meshData->setVisible(false);
  ui->textureData->setVisible(false);
  ui->animationData->setVisible(false);
  ui->materialData->setVisible(false);
  ui->skeletonData->setVisible(false);
  ui->shaderData->setVisible(false);
  ui->hitboxEdit->setVisible(false);

  ui->viewRuler->setVisible(false);
  ui->viewFloatingProbe->setVisible(false);
  ui->generalView->setVisible(false);
  ui->vertexData->setVisible(false);


  ui->lvTextAcc->setModel( new TextureAccessModel(this) );
  ui->lvBodyPart->setModel( new BodyPartModel(this) );
  ui->lvBones->setModel( new BodyPartModel(this) );


  //ui->frameNumber->setBackgroundRole(QPalette::Foreground);
  //ui->frameNumberAni->setBackgroundRole(QPalette::Foreground);

  alignY(ui->textureData  ,ui->meshData);
  alignY(ui->materialData  ,ui->meshData);
  alignY(ui->animationData,ui->meshData);
  alignY(ui->skeletonData,ui->meshData);
  alignY(ui->shaderData,  ui->meshData);
  alignY(ui->bodyData,  ui->meshData);

  alignYAfter(ui->hitboxEdit, ui->skeletonData);
  alignY(ui->vertexData,  ui->meshData);
  //alignYAfter(ui->vertexData , ui->meshData );

  QString flagMask(">Hhhhhhhh");
  ui->boxFlags->setInputMask(flagMask);
  ui->boxTextureFlags->setInputMask(flagMask);
  ui->leMatFlags->setInputMask(flagMask);
  ui->leShaderFlags->setInputMask(flagMask);
  ui->leShaderTaFlags->setInputMask(flagMask);
  ui->leBodyFlags->setInputMask(flagMask);
  ui->leShaderRequires->setInputMask(flagMask);

  skel = NULL;

  //ui->leMatR->setInputMask("0.0000");
  //ui->leMatG->setInputMask("0.0000");
  //ui->leMatB->setInputMask("0.0000");
  //ui->leMatCoeff->setInputMask("0000");
  //ui->timeOfFrame->setInputMask("0000");

  textureAccessDup = new QAction("Duplicate",this);
  textureAccessDel = new QAction("Remove",this);
  textureAccessAdd = new QAction("Add",this);

  bodyPartDup = new QAction("Duplicate",this);
  bodyPartDel = new QAction("Remove",this);
  bodyPartAdd = new QAction("Add",this);

  connect(ui->cbSkin, SIGNAL(currentIndexChanged(QString)), this, SLOT(updateVisibility()));
  connect(ui->cbRefani, SIGNAL(currentIndexChanged(QString)), this, SLOT(updateVisibility()));
  connect(ui->cbRuler, SIGNAL(stateChanged(int)), this, SLOT(updateVisibility()));
  connect(ui->cbRefani, SIGNAL(currentIndexChanged(QString)), this, SLOT(updateRefAnimation()));

  connect(ui->rulerSlid, SIGNAL(sliderMoved (int)), this, SLOT(setRulerLenght(int)));
  connect(ui->rulerSpin, SIGNAL(valueChanged(int)), this, SLOT(setRulerLenght(int)));

  connect(ui->lvTextAcc->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
          this, SLOT(updateShaderTextaccData()));
  connect(ui->lvBodyPart->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
          this, SLOT(updateBodyPartData()));
  connect(ui->lvBones->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
          this, SLOT(updateSelectedBone()));


  // skeleton direct editing
  connect(ui->editHbRange, SIGNAL(actionTriggered(int)),this,SLOT(onEditHitbox(int)));
  connect(ui->editHbLenTop, SIGNAL(actionTriggered(int)),this,SLOT(onEditHitbox(int)));
  connect(ui->editHbLenBot, SIGNAL(actionTriggered(int)),this,SLOT(onEditHitbox(int)));
  connect(ui->editHbPosX, SIGNAL(actionTriggered(int)),this,SLOT(onEditHitbox(int)));
  connect(ui->editHbPosY, SIGNAL(actionTriggered(int)),this,SLOT(onEditHitbox(int)));
  connect(ui->editHbPosZ, SIGNAL(actionTriggered(int)),this,SLOT(onEditHitbox(int)));
  connect(ui->editHbRotAlpha, SIGNAL(actionTriggered(int)),this,SLOT(onEditHitbox(int)));
  connect(ui->editHbRotBeta, SIGNAL(actionTriggered(int)),this,SLOT(onEditHitbox(int)));

  QString st = tr(" (keep [shift] pressed to nudge)");
  ui->editHbRange->setStatusTip(ui->editHbRange->statusTip()+st);
  ui->editHbLenTop->setStatusTip(ui->editHbLenTop->statusTip()+st);
  ui->editHbLenBot->setStatusTip(ui->editHbLenBot->statusTip()+st);
  ui->editHbPosX->setStatusTip(ui->editHbPosX->statusTip()+st);
  ui->editHbPosY->setStatusTip(ui->editHbPosY->statusTip()+st);
  ui->editHbPosZ->setStatusTip(ui->editHbPosZ->statusTip()+st);
  ui->editHbRotAlpha->setStatusTip(ui->editHbRotAlpha->statusTip()+st);
  ui->editHbRotBeta->setStatusTip(ui->editHbRotBeta->statusTip()+st);

  connect(ui->editHbActive, SIGNAL(stateChanged(int)),this,SLOT(setHbEditVisible(int)));

  connect(ui->floatingProbeX,SIGNAL(valueChanged(double)),this,SLOT(onEditFloatingProbePos()));
  connect(ui->floatingProbeY,SIGNAL(valueChanged(double)),this,SLOT(onEditFloatingProbePos()));
  connect(ui->floatingProbeZ,SIGNAL(valueChanged(double)),this,SLOT(onEditFloatingProbePos()));

  // add a shortcut to hide/show skin
  quickToggleHideSkinAct = new QAction(this);
  quickToggleHideSkinAct->setShortcut(QKeySequence("space"));
  //quickToggleHideSkinAct->setShortcutContext(Qt::ApplicationShortcut);
  connect(quickToggleHideSkinAct, SIGNAL(triggered()),this,SLOT(quickToggleHideSkin()));
  ui->cbSkin->addAction(quickToggleHideSkinAct);

  connect(ui->cbFloatingProbe,SIGNAL(toggled(bool)),parent,SLOT(activateFloatingProbe(bool)));
  connect(ui->cbRuler,SIGNAL(toggled(bool)),parent,SLOT(activateRuler(bool)));

}
コード例 #19
0
ファイル: guipanel.cpp プロジェクト: cfcohen/openbrf
void GuiPanel::setSelection(const QModelIndexList &newsel, int k){
  int sel=-1;
  int nsel = (int)newsel.size();
  if (newsel.size()!=0) sel = newsel[0].row();

  //bool vertexani=false;
  //bool skinned=false;
  //bool vertexcolor=false;
  /*bool manyMaterials=false;
  int flags=-1;
  char materialSt[255]="";
  bool differentAni = false;

  int nv=0, nf=0, nfr=0, np=0;
  int last = -1;

  for (QModelIndexList::ConstIterator i=newsel.constBegin(); i!=newsel.constEnd(); i++){
    sel = i->row();
    if (k==MESH && sel<(int)data->mesh.size() ) {
      BrfMesh *m = &(data->mesh[sel]);
      skinned |= m->IsSkinned();
      vertexani |= m->frame.size()>1;
      vertexcolor |= m->hasVertexColor;
      np += m->frame[0].pos.size();
      nv += m->vert.size();
      int k = m->frame.size();
      if (nfr>k || !nfr) nfr=k;

      if (!differentAni) {

        if (last!=-1) {
          if (data->mesh[sel].frame.size()!=data->mesh[last].frame.size()) differentAni=true;
          else for (unsigned int fi=0; fi < data->mesh[sel].frame.size(); fi++)
            if (data->mesh[sel].frame[fi].time!=data->mesh[last].frame[fi].time) differentAni=true;
        } else {
          for (unsigned int fi=0; fi < data->mesh[sel].frame.size(); fi++)
            _frameTime[fi]=data->mesh[sel].frame[fi].time;
        }
        last = sel;
      }

      nf += m->face.size();
      if (!materialSt[0]) sprintf(materialSt,"%s",m->material);
      else if (strcmp(materialSt,m->material)) {
        sprintf(materialSt,"%s","<various>");
        manyMaterials=true;
      }
      if (flags==-1) flags=m->flags; else {
        if (flags!=(int)m->flags) flags=-2;
      }
    }


  }
  if (k==-1) k=NONE;

  BrfMesh *m = NULL;
  BrfTexture *tex = NULL;
  BrfAnimation *ani = NULL;
*/
_selectedIndex = sel;
//_nsel =
switch (TokenEnum(k)){
  case MATERIAL:{
    myClear(ui->leMatBump);
    myClear(ui->leMatDifA);
    myClear(ui->leMatDifB);
    myClear(ui->leMatEnv);
    myClear(ui->leMatShader);
    myClear(ui->leMatSpec);

    myClear(ui->leMatFlags);
    //myClear(ui->leMatRendOrd);
    myClear(ui->leMatCoeff);
    myClear(ui->leMatR);
    myClear(ui->leMatG);
    myClear(ui->leMatB);

    for (QModelIndexList::ConstIterator i=newsel.constBegin(); i!=newsel.constEnd(); i++){
      int sel = i->row();
      if (sel<0 || sel>=(int)data->material.size())  break;
      BrfMaterial &m(data->material[sel]);

      mySetText(ui->leMatBump,  m.bump );
      mySetText(ui->leMatDifA,  m.diffuseA );
      mySetText(ui->leMatDifB,  m.diffuseB );
      mySetText(ui->leMatEnv,   m.enviro);
      mySetText(ui->leMatShader,m.shader );
      mySetText(ui->leMatSpec,  m.spec );

      mySetText(ui->leMatFlags, StringH(m.flags) );
      //mySetText(ui->leMatRendOrd, m.RenderOrder() );
      mySetText(ui->leMatCoeff, StringF(m.specular,3) );
      mySetText(ui->leMatR, StringF( m.r ,3));
      mySetText(ui->leMatG, StringF( m.g ,3));
      mySetText(ui->leMatB, StringF( m.b ,3));
    }
    break;
    }

  case MESH: {
    myClear(ui->boxFlags);
    myClear(ui->boxMaterial);
    myClear(ui->boxTexture);
    myClear(ui->boxNVerts);
    myClear(ui->boxNFaces);
    myClear(ui->boxNPos);
    myClear(ui->boxNVerts);
    myClear(ui->boxNFrames);
    ui->meshDataAni->setVisible(false);
    ui->rbRiggingcolor->setEnabled(false);
    ui->rbVertexcolor->setEnabled(false);
    ui->viewRefAni->setVisible( false );

    int hasAni=-1,hasCol=-1,hasTan=-1,hasRig=-1;
    bool hasBump=false, hasSpec=false, hasTran = false;

    for (QModelIndexList::ConstIterator i=newsel.constBegin(); i!=newsel.constEnd(); i++){
      int sel = i->row();
      if (sel<0 || sel>=(int)data->mesh.size()) continue;
      BrfMesh *m=&(data->mesh[sel]);

      mySetText(ui->boxFlags, StringH(m->flags & ~(3<<16) ));
      mySetText( ui->boxMaterial ,  m->material );

      mySetValueAdd( ui->boxNVerts , (int)m->vert.size());
      mySetValueAdd( ui->boxNFaces , (int)m->face.size());
      mySetValueAdd( ui->boxNPos   , (int)m->frame[0].pos.size());
      mySetValueMax( ui->boxNFrames, (int)m->frame.size());

      mySetCompositeVal(hasAni, m->HasVertexAni());
      mySetCompositeVal(hasCol, m->hasVertexColor);
      mySetCompositeVal(hasTan, m->StoresTangentField());
      mySetCompositeVal(hasRig, m->IsSkinned());

      bool ta,tb,tc;
      QString s = inidata.mat2tex(m->material,&ta,&tb,&tc);
      if (s.isEmpty()) s = tr("<not found>");
      hasBump |= ta;
      hasSpec |= tb;
      hasTran |= tc;

      mySetText( ui->boxTexture, s );

      for (unsigned int fi=0; fi < m->frame.size(); fi++)
         frameTime[fi]=m->frame[fi].time;
    }

    if (hasRig>0)  {
      ui->rbRiggingcolor->setEnabled( true );
      ui->viewRefAni->setVisible( true );
    }
    if (hasCol>0) ui->rbVertexcolor->setEnabled(true);
    if (hasAni>0) ui->meshDataAni->setVisible(true);
    ui->cbMeshHasAni->setCheckState(myCheckState(hasAni));
    ui->cbMeshHasCol->setCheckState(myCheckState(hasCol));
    ui->cbMeshHasTan->setCheckState(myCheckState(hasTan));
    ui->cbMeshHasRig->setCheckState(myCheckState(hasRig));

    ui->cbTransp->setEnabled( hasTran );
    ui->cbNormalmap->setEnabled( hasBump );
    ui->cbSpecularmap->setEnabled( hasSpec );


    ui->timeOfFrame->setEnabled( newsel.size()==1 );

    int nfr = (int)ui->boxNFrames->value();
    if (nfr>0)
    ui->frameNumber->setMaximum(nfr -1 );
    ui->frameNumber->setMinimum( 0 );
    ui->frameNumber->setWrapping(true);

    break;
    }

  case TEXTURE:
    myClear(ui->boxTextureFlags);

    for (QModelIndexList::ConstIterator i=newsel.constBegin(); i!=newsel.constEnd(); i++){
      int j=i->row();
      if (j>=0 && j<(int)data->texture.size())
        mySetText(ui->boxTextureFlags,StringH(data->texture[j].flags));
      int nf = data->texture[j].NFrames();
      if (nf==0)
        ui->labNFrames->setHidden(true);
      else {
        ui->labNFrames->setHidden(false);
        ui->labNFrames->setText(QString("x %1").arg(nf));
      }

    }
    break;
  case SKELETON: {
    {
        int hasHb=-1;
        myClear(ui->boxSkelNBones);
        for (QModelIndexList::ConstIterator i=newsel.constBegin(); i!=newsel.constEnd(); i++){
          int sel = i->row();
          if (sel<0 || sel>=(int)data->skeleton.size()) continue;
          BrfSkeleton *s=&(data->skeleton[sel]);
          int bi=-1;
          if (hitBoxes) bi = hitBoxes->Find(s->name,BODY);
          mySetCompositeVal(hasHb,bi>=0);
          mySetValue(ui->boxSkelNBones,(int)s->bone.size());
        }
        ui->cbSkelHasHitbox->setCheckState(myCheckState(hasHb));

    }

    ui->cbTransp->setEnabled( true );
    ui->cbNormalmap->setEnabled( true );
    ui->cbSpecularmap->setEnabled( true );

    BodyPartModel* bmp = ((BodyPartModel*)(ui->lvBones->model()));
    if (sel>=0 && nsel==1 && sel<(int)data->skeleton.size()) {
      BrfSkeleton &s(data->skeleton[sel]);
      bmp->setSkel(s);      
    } else  bmp->clear();

    emit selectedSubPiece(-1); // unselect all
    ui->lvBones->selectionModel()->clearSelection();
    ui->hitboxEdit->setVisible(false); // until a piece is not selected

    break; }
  case ANIMATION:
    {

    myClear(ui->boxAniNBones);
    myClear(ui->boxAniNFrames);
    myClear(ui->boxAniMinFrame);
    myClear(ui->boxAniMaxFrame);

    for (QModelIndexList::ConstIterator i=newsel.constBegin(); i!=newsel.constEnd(); i++){
      int sel = i->row();
      if (sel<0 || sel>=(int)data->animation.size()) continue;
      BrfAnimation *a=&(data->animation[sel]);

      mySetValue(ui->boxAniNBones,a->nbones);
      mySetValue(ui->boxAniNFrames,a->frame.size());
      mySetValue(ui->boxAniMinFrame,a->FirstIndex());
      mySetValue(ui->boxAniMaxFrame,a->LastIndex() );
    }


    BrfAnimation *ani =NULL;
    if (sel>=0 && nsel==1 && sel<(int)data->animation.size()) ani=&(data->animation[sel]);
    if (ani) {
      for (unsigned int fi=0; fi < ani->frame.size(); fi++)
       frameTime[fi]=ani->frame[fi].index;
      ui->frameNumberAni->setMaximum(ani->frame.size());
      ui->frameNumberAni->setMinimum(1);
      updateFrameNumber( ui->frameNumberAni->value() );
    }

    ui->cbTransp->setEnabled( true );
    ui->cbNormalmap->setEnabled( true );
    ui->cbSpecularmap->setEnabled( true );

    ui->rbRiggingcolor->setEnabled( true ); // quick: use "true": just let user edit them
    ui->rbVertexcolor->setEnabled( true );
    ui->viewRefSkel->setVisible( true );
    if (ani) setAnimation(ani);
    }
    break;
  case SHADER:
      {
      if (!newsel.size()) break;
      int sel = newsel[0].row();
      if (sel<0 || sel>=(int)data->shader.size())  break;
      BrfShader &s(data->shader[sel]);
      ui->leShaderTechnique->setText( s.technique );
      ui->leShaderFallback->setText( s.fallback );
      ui->leShaderFlags->setText( StringH(s.flags) );
      ui->leShaderRequires->setText( StringH(s.requires) );
      updateShaderTextaccSize();
      }
      break;
    case BODY:

      bool collisionBodyHasMesh;
      if (nsel==1) {
          char* bodyname = data->body[sel].name;
          int si = data->Find(bodyname,SKELETON);

          collisionBodyHasSkel= (si>=0);
          if (si>=0) skel = &(data->skeleton[si]); else skel = NULL;
          collisionBodyHasMesh = false;
          for (int i=0; i<(int)data->mesh.size(); i++) {
              if (data->mesh[i].IsNamedAsBody(bodyname)) collisionBodyHasMesh = true;
          }
      } else {
          collisionBodyHasMesh = true;
          collisionBodyHasSkel = false;
      }
      ui->cbComparisonMesh->setEnabled( collisionBodyHasMesh || collisionBodyHasSkel );
      updateBodyPartData();
      break;
    default:

      break;
  }

  ui->animationData->setVisible(k == ANIMATION);
  ui->textureData->setVisible(k == TEXTURE);
  ui->meshData->setVisible(k == MESH);
  ui->materialData->setVisible( k==MATERIAL );
  ui->skeletonData->setVisible( k==SKELETON );
  ui->shaderData->setVisible( k==SHADER );
  ui->bodyData->setVisible( k==BODY );
  ui->generalView->setVisible( k!=SHADER && k!=NONE );

  QRect rect = ui->generalView->geometry();
  if (k==MATERIAL)
    rect.setTop( ui->materialData->geometry().bottom() + 40 );
  else
    rect.setTop( ui->meshData->geometry().bottom() + 40 );
  ui->generalView->setGeometry(rect);

  displaying=k;
  updateVisibility();
  updateFrameNumber( ui->frameNumber->value() );

}
コード例 #20
0
ファイル: testApp.cpp プロジェクト: fridgehead/ArCraft
//--------------------------------------------------------------
void testApp::setup(){
	ofDisableArbTex();
	ofSetTextureWrap();
	//configure FBO
	initFrameBuffer();
	
	//camera config
#ifdef KINECT
	
	context.setupUsingXMLFile();
	image.setup(&context);
	depth.setup(&context);
	xn::DepthGenerator& depthGen = depth.getXnDepthGenerator();
	xn::ImageGenerator& imageGen = image.getXnImageGenerator();
	
	
	XnStatus ret = xnSetViewPoint(depthGen, imageGen);
	cout << "Using kinect" << endl;

#else
	//ofSetLogLevel(OF_LOG_VERBOSE);
	//grabber.listDevices();
	//grabber.setDeviceID(7);
	if(grabber.initGrabber(640, 480)){
		
	
		cout << "Using grabber" << endl;
		
	} else {
		cout << "MASSIVE FAIL" <<endl;
		
	}
	
#endif
	
	
	convert.allocate(640, 480);				//conversion of camera image to grayscale
	gray.allocate(640, 480);				//grayscale tracking image
	kinectImage.allocate(640, 480);			//image from kinect
	kinectDepthImage.allocate(640, 480);	//Depth image from kinect
	finalMaskImage.allocate(640, 480);;		//final composition mask
	sceneDepthImage.allocate(640, 480);;	//scenes depthmap image
	finalImage.allocate(640, 480);
	sceneImage.allocate(640,480);
	
	pixelBuf = new unsigned char[640*480];			//temp buffer for kinect depth strea
	colorPixelBuf = new unsigned char[640*480*3];	//temp buffer for kinect image
	sceneDepthBuf = new unsigned short[640 * 480];	//depth buffer from our rendered scene
	kinectDepthBuf = new unsigned short[640 * 480];	//camera image buffer
	finalBuf = new unsigned char[640 * 480];		//final mask buffer
	finalImageBuf = new unsigned char[640 * 480 * 3];	//final Image buffer
	sceneBuffer = new unsigned char[640 * 480 * 3];		//copy of the scene in the FBO	
	
	bDraw = false;
	
	//tracker = new ARToolKitPlus::TrackerSingleMarkerImpl<6,6,6, 1, 8>(width,height);
	tracker = new ARToolKitPlus::TrackerMultiMarkerImpl<6,6,6, 1, 64>(width,height);
	
	tracker->setPixelFormat(ARToolKitPlus::PIXEL_FORMAT_LUM);	
	//markerboard_480-499.cfg
    if( !tracker->init( (const char *)ofToDataPath("bluedot.cfg").c_str(), (const char *)ofToDataPath("conf.cfg").c_str(), 1.0f, 1000.0f) )            // load std. ARToolKit camera file
	{
		printf("ERROR: init() failed\n");
		delete tracker;
		return;
	}
	// the marker in the BCH test image has a thin border...
    tracker->setBorderWidth(0.125f);	
    // set a threshold. alternatively we could also activate automatic thresholding
    //tracker->setThreshold(150);	
	tracker->activateAutoThreshold(true);
    // let's use lookup-table undistortion for high-speed
    // note: LUT only works with images up to 1024x1024
    tracker->setUndistortionMode(ARToolKitPlus::UNDIST_LUT);
	
    // RPP is more robust than ARToolKit's standard pose estimator
    tracker->setPoseEstimator(ARToolKitPlus::POSE_ESTIMATOR_RPP);
	
	tracker->setImageProcessingMode(ARToolKitPlus::IMAGE_FULL_RES);
	
    // switch to simple ID based markers
    // use the tool in tools/IdPatGen to generate markers
    tracker->setMarkerMode(ARToolKitPlus::MARKER_ID_SIMPLE);
	
	
	netThread = new NetworkThread(this);
	netThread->start();
	
	//load textures
	ofDisableArbTex();
	ofSetTextureWrap();
	textures[0].loadImage("grass.png");
	textures[1].loadImage("cobble.png");	
	textures[2].loadImage("dirt.png");	
	textures[3].loadImage("lava.png");	
	textures[4].loadImage("rock.png");	
	textures[5].loadImage("sand.png");	
	textures[6].loadImage("snow.png");	
	textures[7].loadImage("tree.png");
	textures[8].loadImage("leaves.png");
	
	
	mapWidth = 20;
	mapHeight = 20;
	mapDepth = 20;
	mapLocked = false;
	
	//fill our 3d vector with 20x20x20
	mapLocked = true;
	array3D.resize(mapWidth);
	for (int i = 0; i < mapWidth; ++i) {
		array3D[i].resize(mapHeight);
		
		for (int j = 0; j < mapHeight; ++j)
			array3D[i][j].resize(mapDepth);
	}
	
	//create block face data and clear map 
	Block b;	
	
	vList[0] = ofxVec3f(0.0f, 0.0f, -1.0f);
	vList[1] = ofxVec3f(-1.0f, 0.0f, -1.0f);
	vList[2] = ofxVec3f(-1.0f, 0.0f, 0.0f);
	vList[3] = ofxVec3f(0.0f, 0.0f, 0.0f);
	vList[4] = ofxVec3f(-1.0f, -1.0f, 0.0f);
	vList[5] = ofxVec3f(0.0f, -1.0f, 0.0f);
	vList[6] = ofxVec3f(0.0f, -1.0f, -1.0f);
	vList[7] = ofxVec3f(-1.0f, -1.0f, -1.0f);
	
	//vertex indices for faces
	const static int faceVals[6][4] = {
		{2, 1, 0, 3}, //top
		{5, 4, 2, 3}, //front
		{0, 6, 5, 3},//right
		{4, 7, 1, 2},//left
		{5, 6, 7, 5},//bottom
		{0, 1, 7, 6} //back
	};
		
	
	for(int x=0; x < mapWidth; x++){
		for(int y=0; y < mapHeight; y++){
			for(int z=0; z < mapDepth; z++){
				b.type = NONE;
				b.textured = false;
				b.visMask = VIS_TOP;
				
				
				for(int a = 0; a < 6; a++){
					for (int c = 0; c < 4; c++){
						b.faceList[a][c] = faceVals[a][c];
					}
				}
				
				
				array3D[x][y][z] = b;		
				
			}
		}
	}
	
	//add some test blocks to play with when offline
	b.type = GRASS;
	b.textured = true;
	b.textureRef = 0;
	b.visMask = 63;
	array3D[1][1][5] = b;	
	array3D[2][1][5] = b;
	array3D[3][1][5] = b;
	array3D[4][1][5] = b;
	array3D[5][1][5] = b;
	array3D[6][1][5] = b;

	//testBlock = b;
	
	//run the face visibility and normal calculations
	updateVisibility();
	
	//dont draw the gui
	guiDraw = false;
	
	//scale and offset for map
	mapScale = 1.0f;
	offset.x = -100.0f;
	offset.y = 100.0f;
	
	scVal = 1.0f;
	
	//used as light colour (when lights eventually work)
	sceneWhiteLevel = ofColor(255,255,255);
	
	#ifdef SYPHON
	//start up syphon and set framerate
	mainOutputSyphonServer.setName("Minecraft");
	#endif
	
	ofSetFrameRate(60);
	
	//try and set up some lights
	
	light light = {
		{0,50,0,1},  //position (the final 1 means the light is positional)
		{1,1,1,1},    //diffuse
		{0,0,0,1},    //specular
		{0,0,0,1}     //ambient
    };
	
	light0 = light;
	
	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT0);
	//glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,0);  //sets lighting to one-sided
	glLightfv(GL_LIGHT0, GL_POSITION, light0.pos);
	doLights();
	
	
	//turn on backface culling
	glEnable(GL_CULL_FACE);
	
}
コード例 #21
0
ファイル: MFixedRenderer.cpp プロジェクト: galek/MIngEd
void MFixedRenderer::drawScene(MScene * scene, MOCamera * camera)
{
    M_PROFILE_SCOPE(MFixedRenderer::drawScene);
	struct MEntityLight
	{
		MBox3d lightBox;
		MOLight * light;
	};
	
	struct MSubMeshPass
	{
		unsigned int subMeshId;
		unsigned int lightsNumber;
		MObject3d * object;
		MOLight * lights[4];
	};
	
	// sub objects
	#define MAX_TRANSP_SUBOBJ 4096
	static int transpList[MAX_TRANSP_SUBOBJ];
	static float transpZList[MAX_TRANSP_SUBOBJ];
	static MSubMeshPass transpSubObjs[MAX_TRANSP_SUBOBJ];
	
	// lights list
	#define MAX_ENTITY_LIGHTS 256
	static int entityLightsList[MAX_ENTITY_LIGHTS];
	static float entityLightsZList[MAX_ENTITY_LIGHTS];
	static MEntityLight entityLights[MAX_ENTITY_LIGHTS];

	
	// get render
	MRenderingContext * render = MEngine::getInstance()->getRenderingContext();
	render->enableLighting();
	render->enableBlending();

	
	// make frustum
	MFrustum * frustum = camera->getFrustum();
	frustum->makeVolume(camera);
	
	// update visibility
	updateVisibility(scene, camera);
	
	// fog
	enableFog(camera);
	
	// camera
	MVector3 cameraPos = camera->getTransformedPosition();
	
	
	// transp sub obj number
	unsigned int transpSubObsNumber = 0;
	
	// lights
	unsigned int l;
	unsigned int lSize = scene->getLightsNumber();
	
	// entities
	unsigned int i;
	unsigned int eSize = scene->getEntitiesNumber();
	for(i=0; i<eSize; i++)
	{
		// get entity
		MOEntity * entity = scene->getEntityByIndex(i);
		MMesh * mesh = entity->getMesh();
		
		if(! entity->isActive())
			continue;
		
		if(! entity->isVisible())
		{
			if(mesh)
			{
				MArmature * armature = mesh->getArmature();
				MArmatureAnim * armatureAnim = mesh->getArmatureAnim();
				if(armature)
				{
					// animate armature
					if(armatureAnim)
						animateArmature(
										mesh->getArmature(),
										mesh->getArmatureAnim(),
										entity->getCurrentFrame()
										);
					
					// TODO : optimize and add a tag to desactivate it
					updateSkinning(mesh, armature);
					(*entity->getBoundingBox()) = (*mesh->getBoundingBox());
				}
			}
			
			continue;
		}
		
		// draw mesh
		if(mesh)
		{
			MVector3 scale = entity->getTransformedScale();
			MBox3d * entityBox = entity->getBoundingBox();
			
			float minScale = scale.x;
			minScale = MIN(minScale, scale.y);
			minScale = MIN(minScale, scale.z);
			minScale = 1.0f / minScale;
			
			unsigned int entityLightsNumber = 0;
			for(l=0; l<lSize; l++)
			{
				// get entity
				MOLight * light = scene->getLightByIndex(l);
				
				if(! light->isActive())
					continue;
				
				if(! light->isVisible())
					continue;
				
				// light box
				MVector3 lightPos = light->getTransformedPosition();
				MVector3 localPos = entity->getInversePosition(lightPos);
				
				float localRadius = light->getRadius() * minScale;
				
				MBox3d lightBox(
								MVector3(localPos - localRadius),
								MVector3(localPos + localRadius)
								);
				
				if(! entityBox->isInCollisionWith(&lightBox))
					continue;
				
				MEntityLight * entityLight = &entityLights[entityLightsNumber];
				entityLight->lightBox = lightBox;
				entityLight->light = light;
				
				entityLightsNumber++;
				if(entityLightsNumber == MAX_ENTITY_LIGHTS)
					break;
			}
			
			// animate armature
			if(mesh->getArmature() && mesh->getArmatureAnim())
				animateArmature(
								mesh->getArmature(),
								mesh->getArmatureAnim(),
								entity->getCurrentFrame()
								);
			
			// animate textures
			if(mesh->getTexturesAnim())
				animateTextures(mesh, mesh->getTexturesAnim(), entity->getCurrentFrame());
			
			// animate materials
			if(mesh->getMaterialsAnim())
				animateMaterials(mesh, mesh->getMaterialsAnim(), entity->getCurrentFrame());
			
			unsigned int s;
			unsigned int sSize = mesh->getSubMeshsNumber();
			for(s=0; s<sSize; s++)
			{
				MSubMesh * subMesh = &mesh->getSubMeshs()[s];
				MBox3d * box = subMesh->getBoundingBox();
				
				// check if submesh visible
				if(sSize > 1)
				{
					MVector3 * min = box->getMin();
					MVector3 * max = box->getMax();
					
					MVector3 points[8] = {
						entity->getTransformedVector(MVector3(min->x, min->y, min->z)),
						entity->getTransformedVector(MVector3(min->x, max->y, min->z)),
						entity->getTransformedVector(MVector3(max->x, max->y, min->z)),
						entity->getTransformedVector(MVector3(max->x, min->y, min->z)),
						entity->getTransformedVector(MVector3(min->x, min->y, max->z)),
						entity->getTransformedVector(MVector3(min->x, max->y, max->z)),
						entity->getTransformedVector(MVector3(max->x, max->y, max->z)),
						entity->getTransformedVector(MVector3(max->x, min->y, max->z))
					};
					
					if(! frustum->isVolumePointsVisible(points, 8))
						continue;
				}
				
				// subMesh center
				MVector3 center = (*box->getMin()) + ((*box->getMax()) - (*box->getMin()))*0.5f;
				center = entity->getTransformedVector(center);
				
				// sort entity lights
				unsigned int lightsNumber = 0;
				for(l=0; l<entityLightsNumber; l++)
				{
					MEntityLight * entityLight = &entityLights[l];
					if(! box->isInCollisionWith(&entityLight->lightBox))
						continue;
					
					MOLight * light = entityLight->light;
					
					float z = (center - light->getTransformedPosition()).getLength();
					entityLightsList[lightsNumber] = l;
					entityLightsZList[l] = (1.0f/z)*light->getRadius();
					lightsNumber++;
				}
				
				if(lightsNumber > 1)
					sortFloatList(entityLightsList, entityLightsZList, 0, (int)lightsNumber-1);
				
				// local lights
				if(lightsNumber > 4)
					lightsNumber = 4;
				
				for(l=0; l<lightsNumber; l++)
				{
					MEntityLight * entityLight = &entityLights[entityLightsList[l]];
					MOLight * light = entityLight->light;
					
					// attenuation
					float quadraticAttenuation = (8.0f / light->getRadius());
					quadraticAttenuation = (quadraticAttenuation*quadraticAttenuation)*light->getIntensity();
					
					// color
					MVector3 color = light->getFinalColor();
					
					// set light
					render->enableLight(l);
					render->setLightPosition(l, light->getTransformedPosition());
					render->setLightDiffuse(l, MVector4(color));
					render->setLightSpecular(l, MVector4(color));
					render->setLightAmbient(l, MVector3(0, 0, 0));
					render->setLightAttenuation(l, 1, 0, quadraticAttenuation);
					
					// spot
					render->setLightSpotAngle(l, light->getSpotAngle());
					if(light->getSpotAngle() < 90){
						render->setLightSpotDirection(l, light->getRotatedVector(MVector3(0, 0, -1)).getNormalized());
						render->setLightSpotExponent(l, light->getSpotExponent());
					}
					else {
						render->setLightSpotExponent(l, 0.0f);
					}
				}
				
				for(l=lightsNumber; l<4; l++){
					render->disableLight(l);
				}
				
				render->pushMatrix();
				render->multMatrix(entity->getMatrix());
				
				// draw opaques
				drawOpaques(subMesh, mesh->getArmature());
				
				if(subMesh->hasTransparency())
				{
					if(transpSubObsNumber < MAX_TRANSP_SUBOBJ)
					{
						// transparent subMesh pass
						MSubMeshPass * subMeshPass = &transpSubObjs[transpSubObsNumber];
						
						// lights
						subMeshPass->lightsNumber = lightsNumber;
						for(l=0; l<lightsNumber; l++)
							subMeshPass->lights[l] = entityLights[entityLightsList[l]].light;
						
						// z distance to camera
						float z = getDistanceToCam(camera, center);
						
						// set values
						transpList[transpSubObsNumber] = transpSubObsNumber;
						transpZList[transpSubObsNumber] = z;
						subMeshPass->subMeshId = s;
						subMeshPass->object = entity;
						
						transpSubObsNumber++;
					}
				}
				
				render->popMatrix();
			}
			
			mesh->updateBoundingBox();
			(*entity->getBoundingBox()) = (*mesh->getBoundingBox());
		}
	}
	
	
	// texts
	unsigned int tSize = scene->getTextsNumber();
	for(i=0; i<tSize; i++)
	{
		MOText * text = scene->getTextByIndex(i);
		if(text->isActive() && text->isVisible())
		{
			// transparent pass
			MSubMeshPass * subMeshPass = &transpSubObjs[transpSubObsNumber];
			
			// center
			MBox3d * box = text->getBoundingBox();
			MVector3 center = (*box->getMin()) + ((*box->getMax()) - (*box->getMin()))*0.5f;
			center = text->getTransformedVector(center);
			
			// z distance to camera
			float z = getDistanceToCam(camera, center);
			
			// set values
			transpList[transpSubObsNumber] = transpSubObsNumber;
			transpZList[transpSubObsNumber] = z;
			subMeshPass->object = text;
			
			transpSubObsNumber++;
		}
	}
	
	
	// sort transparent list
	if(transpSubObsNumber > 1)
		sortFloatList(transpList, transpZList, 0, (int)transpSubObsNumber-1);
	
	// draw transparents
	for(i=0; i<transpSubObsNumber; i++)
	{
		MSubMeshPass * subMeshPass = &transpSubObjs[transpList[i]];
		MObject3d * object = subMeshPass->object;
		
		// objects
		switch(object->getType())
		{
			case M_OBJECT3D_ENTITY:
			{
				MOEntity * entity = (MOEntity *)object;
				unsigned int subMeshId = subMeshPass->subMeshId;
				MMesh * mesh = entity->getMesh();
				MSubMesh * subMesh = &mesh->getSubMeshs()[subMeshId];
				
				// animate armature
				if(mesh->getArmature() && mesh->getArmatureAnim())
					animateArmature(
									mesh->getArmature(),
									mesh->getArmatureAnim(),
									entity->getCurrentFrame()
									);
				
				// animate textures
				if(mesh->getTexturesAnim())
					animateTextures(mesh, mesh->getTexturesAnim(), entity->getCurrentFrame());
				
				// animate materials
				if(mesh->getMaterialsAnim())
					animateMaterials(mesh, mesh->getMaterialsAnim(), entity->getCurrentFrame());
				
				// lights
				for(l=0; l<subMeshPass->lightsNumber; l++)
				{
					MOLight * light = subMeshPass->lights[l];
					
					// attenuation
					float quadraticAttenuation = (8.0f / light->getRadius());
					quadraticAttenuation = (quadraticAttenuation*quadraticAttenuation)*light->getIntensity();
					
					// color
					MVector3 color = light->getFinalColor();
					
					// set light
					render->enableLight(l);
					render->setLightPosition(l, light->getTransformedPosition());
					render->setLightDiffuse(l, MVector4(color));
					render->setLightSpecular(l, MVector4(color));
					render->setLightAmbient(l, MVector3(0, 0, 0));
					render->setLightAttenuation(l, 1, 0, quadraticAttenuation);
					
					// spot
					render->setLightSpotAngle(l, light->getSpotAngle());
					if(light->getSpotAngle() < 90){
						render->setLightSpotDirection(l, light->getRotatedVector(MVector3(0, 0, -1)).getNormalized());
						render->setLightSpotExponent(l, light->getSpotExponent());
					}
					else {
						render->setLightSpotExponent(l, 0.0f);
					}
				}
				
				for(l=subMeshPass->lightsNumber; l<4; l++){
					render->disableLight(l);
				}
				
				render->pushMatrix();
				render->multMatrix(entity->getMatrix());
				drawTransparents(subMesh, mesh->getArmature());
				render->popMatrix();
				
				mesh->updateBoundingBox();
				(*entity->getBoundingBox()) = (*mesh->getBoundingBox());
			}
				break;
				
			case M_OBJECT3D_TEXT:
			{
				MOText * text = (MOText *)object;
				
				render->pushMatrix();
				render->multMatrix(text->getMatrix());
				drawText(text);
				render->popMatrix();
			}
				break;
		}
	}
	
	render->disableLighting();
	render->disableFog();	
}
コード例 #22
0
ファイル: testApp.cpp プロジェクト: fridgehead/ArCraft
void testApp::processShit(const string& s){
	char * results;
	char * cstr;
	//cout << "mess: " << s << endl;

	cstr = new char [s.size()+1];
	strcpy (cstr, s.c_str());
	results = strtok(cstr, ",");

	if(results[0]  == 's'){	
		//cout << "mess: " << results[0] <<endl;
		int currentY, currentZ;
		currentY = 0;
		currentZ = 0;
		int curCount = 0;
		int ct = 0;

		
		
		while (results != NULL){
			
			if(ct == 1){
				currentY = atoi(results);
				ct++;
			} else if (ct == 2){
				currentZ = atoi(results);

				//clear that row
				for(int x = 0; x < 20; x++){
					array3D[x][currentY][currentZ].type = NONE;
				}	
				//	cout << "HOT DOGGETY" << endl;
				curCount = 0;
				ct++;
			} else {
				int type = atoi(results);
				setBlock(curCount,currentY,currentZ, type);
				curCount++;
				ct++;
			}
			results = strtok(NULL, ",");

			
		}
		
		/*
	} else if(s.substr(0, 4) == "del:"){			//<([-]?[0-9]*):([-]?[0-9]*):([-]?[0-9]*)>
	} else if(s.substr(0, 4) == "add:"){			//<([0-9]*)><([-]?[0-9]*):([-]?[0-9]*):([-]?[0-9]*)>
	} else if(s.substr(0, 7) == "player:"){			//<([0-9]*)><([-]?[0-9\\.]*):([-]?[0-9\\.]*):([-]?[0-9\\.]*)>
		//get the player pos, this should happen every 50ms
		
		
	} else if(s.substr(0, 9) == "starting:"){		//<([-]?[0-9]*)><([-]?[0-9]*)><([-]?[0-9]*)><([-]?[0-9]*)><([-]?[0-9]*)><([-]?[0-9]*)>
		
		*/
		updateVisibility();

		
	} else if(results[0]  == 'a'){
		int ct = 0;
		int currentX = -1;
		int currentY = -1;
		int currentZ = -1;
		int type = 0;
		while (results != NULL){
			
			if(ct == 1){
				type = atoi(results);
				cout << "add block id: " << type << endl;
				ct++;
			} else if (ct == 2){
				currentX = atoi(results);
				
				ct++;
			} else if (ct == 3){
				currentY = atoi(results);
				
				ct++;
			}else if (ct == 4){
				currentZ = atoi(results);
					
				ct++;
			} else {
				ct++;
			}
			results = strtok(NULL, ",");
		}
		if(currentX >= 0 && currentX < mapWidth && currentY >= 0 && currentY < mapHeight && currentZ >= 0 && currentZ < mapDepth){
			setBlock(currentX, currentY, currentZ, type);
			cout << "added" << endl;
		}
		updateVisibility();

	} else if(results[0]  == 'd'){
		int ct = 0;
		int currentX = -1;
		int currentY = -1;
		int currentZ = -1;
		int type = 0;
		while (results != NULL){
			
			if (ct == 1){
				currentX = atoi(results);
				
				ct++;
			} else if (ct == 2){
				currentY = atoi(results);
				
				ct++;
			}else if (ct == 3){
				currentZ = atoi(results);
				
				ct++;
			} else {
				ct++;
			}
			results = strtok(NULL, ",");
		}
		if(currentX >= 0 && currentX < mapWidth && currentY >= 0 && currentY < mapHeight && currentZ >= 0 && currentZ < mapDepth){
			setBlock(currentX, currentY, currentZ, 0);
			cout << "delete" << endl;
		}
		updateVisibility();
	} else if(results[0]  == 'p'){
			int ct = 0;
			float currentX = -1;
			float currentY = -1;
			float currentZ = -1;
			int playerId = 0;
			while (results != NULL){
				
				if (ct == 1){
					//player id
					
					playerId = atoi(results);
					//cout << "player id: " << playerId << endl;
					
					ct++;
				} else if (ct == 2){
					//x
					p.xPos = strtod(results,NULL);
					//cout << currentX << endl;

					
					ct++;
				}else if (ct == 3){
					//y
					p.yPos = strtod(results,NULL);
					ct++;
				} else if (ct == 4){
					//z
					
					p.zPos = strtod(results,NULL);
					ct++;
				} else {
					
					ct++;
				}
				results = strtok(NULL, ",");
				
			}
			//cout << "pos" << endl;
		p.lastUpdateTime = ofGetElapsedTimeMillis();
		
		}
//	delete cstr;
//	delete results;
}
コード例 #23
0
ファイル: editable_label.cpp プロジェクト: bdajeje/QTNotes
void EditableLabel::showInput()
{
  m_label_shown = false;
  updateVisibility();
  m_input->setFocus();
}
コード例 #24
0
ファイル: tabbar.cpp プロジェクト: agnelterry/arora
void TabBar::tabInserted(int position)
{
    Q_UNUSED(position);
    updateVisibility();
}
コード例 #25
0
    JointInfo::JointInfo(const std::string name, rviz::Property* parent_category) {
        name_ = name;
        effort_ = 0;
        max_effort_ = 0;
        last_update_ = ros::Time::now();

        //info->category_ = new Property( QString::fromStdString( info->name_ ) , QVariant(), "", joints_category_);
        category_ = new rviz::Property( QString::fromStdString( name_ ) , true, "", parent_category, SLOT( updateVisibility() ), this);

        effort_property_ = new rviz::FloatProperty( "Effort", 0, "Effort value of this joint.", category_);
        effort_property_->setReadOnly( true );

        max_effort_property_ = new rviz::FloatProperty( "Max Effort", 0, "Max Effort value of this joint.", category_);
        max_effort_property_->setReadOnly( true );
    }
コード例 #26
0
ファイル: tabbar.cpp プロジェクト: agnelterry/arora
void TabBar::tabRemoved(int position)
{
    Q_UNUSED(position);
    updateVisibility();
}
コード例 #27
0
ファイル: gfx_light.cpp プロジェクト: grit-engine/grit-engine
void GfxLight::setSpecularColour (const Vector3 &v)
{
    if (dead) THROW_DEAD(className);
    specular = v;
    updateVisibility();
}
コード例 #28
0
SUMOTime
MSDevice_BTreceiver::BTreceiverUpdate::execute(SUMOTime /*currentTime*/) {
    // build rtree with senders
    NamedRTree rt;
    for (std::map<std::string, MSDevice_BTsender::VehicleInformation*>::const_iterator i = MSDevice_BTsender::sVehicles.begin(); i != MSDevice_BTsender::sVehicles.end(); ++i) {
        MSDevice_BTsender::VehicleInformation* vi = (*i).second;
        Boundary b = vi->getBoxBoundary();
        b.grow(POSITION_EPS);
        const float cmin[2] = {(float) b.xmin(), (float) b.ymin()};
        const float cmax[2] = {(float) b.xmax(), (float) b.ymax()};
        rt.Insert(cmin, cmax, vi);
    }

    // check visibility for all receivers
    OptionsCont& oc = OptionsCont::getOptions();
    bool allRecognitions = oc.getBool("device.btreceiver.all-recognitions");
    bool haveOutput = oc.isSet("bt-output");
    for (std::map<std::string, MSDevice_BTreceiver::VehicleInformation*>::iterator i = MSDevice_BTreceiver::sVehicles.begin(); i != MSDevice_BTreceiver::sVehicles.end();) {
        // collect surrounding vehicles
        MSDevice_BTreceiver::VehicleInformation* vi = (*i).second;
        Boundary b = vi->getBoxBoundary();
        b.grow(vi->range);
        const float cmin[2] = {(float) b.xmin(), (float) b.ymin()};
        const float cmax[2] = {(float) b.xmax(), (float) b.ymax()};
        std::set<std::string> surroundingVehicles;
        Named::StoringVisitor sv(surroundingVehicles);
        rt.Search(cmin, cmax, sv);

        // loop over surrounding vehicles, check visibility status
        for (std::set<std::string>::const_iterator j = surroundingVehicles.begin(); j != surroundingVehicles.end(); ++j) {
            if ((*i).first == *j) {
                // seeing oneself? skip
                continue;
            }
            updateVisibility(*vi, *MSDevice_BTsender::sVehicles.find(*j)->second);
        }

        if (vi->haveArrived) {
            // vehicle has left the simulation; remove
            if (haveOutput) {
                writeOutput((*i).first, vi->seen, allRecognitions);
            }
            delete vi;
            MSDevice_BTreceiver::sVehicles.erase(i++);
        } else {
            // vehicle is still in the simulation; reset state
            vi->updates.erase(vi->updates.begin(), vi->updates.end() - 1);
            ++i;
        }
    }

    // remove arrived senders / reset state
    for (std::map<std::string, MSDevice_BTsender::VehicleInformation*>::iterator i = MSDevice_BTsender::sVehicles.begin(); i != MSDevice_BTsender::sVehicles.end();) {
        MSDevice_BTsender::VehicleInformation* vi = (*i).second;
        if (vi->haveArrived) {
            delete vi;
            MSDevice_BTsender::sVehicles.erase(i++);
        } else {
            vi->updates.erase(vi->updates.begin(), vi->updates.end() - 1);
            ++i;
        }
    }
    return DELTA_T;
}
コード例 #29
0
ファイル: gfx_light.cpp プロジェクト: grit-engine/grit-engine
void GfxLight::setFade (float f)
{
    if (dead) THROW_DEAD(className);
    fade = f;
    updateVisibility();
}
コード例 #30
0
ファイル: tabview.cpp プロジェクト: Zekom/kcachegrind
TabView::TabView(TraceItemView* parentView,
                 QWidget* parent, const char* name)
  : QWidget(parent), TraceItemView(parentView)
{
  setFocusPolicy(Qt::StrongFocus);
  setObjectName(name);

  _isCollapsed = true;

  QVBoxLayout* vbox = new QVBoxLayout( this );
  vbox->setSpacing( 6 );
  vbox->setMargin( 6 );

  _nameLabel = new QLabel(this); //KSqueezedTextLabel( this);
  _nameLabel->setSizePolicy(QSizePolicy( QSizePolicy::Ignored,
					 QSizePolicy::Fixed ));
  _nameLabel->setObjectName( "nameLabel" );
  _nameLabel->setText(tr("(No profile data file loaded)"));
  vbox->addWidget( _nameLabel );
  updateNameLabel(tr("(No profile data file loaded)"));

  _mainSplitter   = new QSplitter(Qt::Horizontal, this);
  _leftSplitter   = new Splitter(Qt::Vertical, _mainSplitter, "Left");
  vbox->addWidget( _mainSplitter );

  _rightTW = new TabWidget(this, _mainSplitter, "Right");
  connect(_rightTW, SIGNAL(currentChanged(QWidget*)),
          this, SLOT(tabChanged(QWidget*)));
  connect(_rightTW, SIGNAL(visibleRectChanged(TabWidget*)),
          this, SLOT(visibleRectChangedSlot(TabWidget*)));

  _topTW = new TabWidget(this, _leftSplitter, "Top");
  connect(_topTW, SIGNAL(currentChanged(QWidget*)),
          this, SLOT(tabChanged(QWidget*)));
  connect(_topTW, SIGNAL(visibleRectChanged(TabWidget*)),
          this, SLOT(visibleRectChangedSlot(TabWidget*)));

  _bottomSplitter = new Splitter(Qt::Horizontal,
                                  _leftSplitter, "Bottom");

  _leftTW = new TabWidget(this, _bottomSplitter, "Left");
  _leftTW->setTabPosition(QTabWidget::Bottom);
  connect(_leftTW, SIGNAL(currentChanged(QWidget*)),
          this, SLOT(tabChanged(QWidget*)));
  connect(_leftTW, SIGNAL(visibleRectChanged(TabWidget*)),
          this, SLOT(visibleRectChangedSlot(TabWidget*)));

  _bottomTW = new TabWidget(this, _bottomSplitter, "Bottom");
  _bottomTW->setTabPosition(QTabWidget::Bottom);
  connect(_bottomTW, SIGNAL(currentChanged(QWidget*)),
          this, SLOT(tabChanged(QWidget*)));
  connect(_bottomTW, SIGNAL(visibleRectChanged(TabWidget*)),
          this, SLOT(visibleRectChangedSlot(TabWidget*)));

  CallView* callerView = new CallView(true, this);
  CallView* calleeView = new CallView(false, this);
  CoverageView * allCallerView = new CoverageView(true, this);
  CoverageView * allCalleeView = new CoverageView(false, this);

  // Options of visualization views are stored by their view name
  callerView->setObjectName("CallerView");
  calleeView->setObjectName("CalleeView");
  allCallerView->setObjectName("AllCallerView");
  allCalleeView->setObjectName("AllCalleeView");

  // default positions...
  // Keep following order in sync with DEFAULT_xxxTABS defines!

  addTop( addTab( tr("Types"),
		  new EventTypeView(this, 0,
				   "EventTypeView")));
  addTop( addTab( tr("Callers"), callerView) );
  addTop( addTab( tr("All Callers"), allCallerView) );
  addTop( addTab( tr("Callee Map"),
		  new CallMapView(false, this, 0,
				  "CalleeMapView")));
  addTop( addTab( tr("Source Code"),
		  new SourceView(this, 0,
				 "SourceView")));

  addBottom( addTab( tr("Parts"),
		     new PartView(this, 0,
				  "PartView")));
  addBottom( addTab( tr("Callees"), calleeView) );
  addBottom( addTab( tr("Call Graph"),
		     new CallGraphView(this, 0,
				       "CallGraphView")));
  addBottom( addTab( tr("All Callees"), allCalleeView) );
  addBottom( addTab( tr("Caller Map"),
		     new CallMapView(true, this, 0,
				     "CallerMapView")));
  addBottom( addTab( tr("Machine Code"),
		     new InstrView(this, 0,
				   "InstrView")));

  // after all child widgets are created...
  _lastFocus = 0;
  _active = false;
  installFocusFilters();

  updateVisibility();

  this->setWhatsThis( whatsThis() );
}