void OpenSMOKE_Droplet::SetInitialConditions()
{	
	// Resetting initial conditions
	{
		T = data->TDroplet0;
		Omega = 0.;
	}

	// From zero
	if (data->iBackupFromBinaryFile == false)
	{
		T = data->TDroplet0;
		for(int i=1;i<=N;i++)
			for(int j=1;j<=NC;j++)
				Omega[i][j] = data->OmegaDroplet[data->jFuel[j]];

		UpdateProperties();
	}

	// From backup file
	else if (data->iBackupFromBinaryFile == true)
	{
		ErrorMessage("Backup not yet implemented...");
	//	ReadFromBackupFile(*mix, data->nameBackupFile, grid.x, T, Omega);
	//	UpdateProperties();
	}
	
	// Properties
	UpdateProperties();
}
Exemple #2
0
void TrackPropDlg::SetTrackAndUpdate( Route *pR )
{
    m_pRoute = pR;

    m_lcPoints->DeleteAllItems();
    
    if( m_pMyLinkList )
        delete m_pMyLinkList;
    m_pMyLinkList = new HyperlinkList();
    int NbrOfLinks = m_pRoute->m_HyperlinkList->GetCount();
    if( NbrOfLinks > 0 ) {
        wxHyperlinkListNode *linknode = m_pRoute->m_HyperlinkList->GetFirst();
        while( linknode ) {
            Hyperlink *link = linknode->GetData();

            Hyperlink* h = new Hyperlink();
            h->DescrText = link->DescrText;
            h->Link = link->Link;
            h->LType = link->LType;

            m_pMyLinkList->Append( h );

            linknode = linknode->GetNext();
        }
    }

    InitializeList();
    UpdateProperties();
}
TrackDisplay::TrackDisplay(Track* track, ViewManager* view) :
ComponentDisplay(view), mTrack(track)
{
	UpdateProperties();
	mView->GetMapRenderer()->AddComponent(mTrack);
	mView->GetMapRenderer()->Invalidate();
}
MultiBoxView::MultiBoxView(BRect frame, float ncols, float rheight)
		 :BView(frame, "MultiBoxView",  B_FOLLOW_ALL_SIDES, B_WILL_DRAW | B_FRAME_EVENTS)
{
	numcols = ncols;
	rowheight = rheight;
	UpdateProperties();
}
Exemple #5
0
void OpenSMOKE_ICEM::ODESystem_ICEM(BzzVector &y, double t, BzzVector &dy)
{
    int i;

	UpdateAngleAndVolume(t);

    // Recovering variables;
    for (i=1;i<=NC;i++)	omega[i]    = y[i];
    T				                = y[NC+1];

	// Updating Exchange area
	UpdateExchangeArea(t, MINUSONE);
    UpdateHeatFlux(t, MINUSONE);


    // Evaluation of properties
    UpdateProperties(ODE_ICEM_Object.jacobianIndex, NC+1);

    // Conservation equations for all the species (Batch)
    domega	= R / rho ;

    // Conservation equations for energy (Batch)
    dT   = volume*UReaction - P*dvolume_over_dt - A*Qe;
    dT  /= (mass*Cv);
 
    // Soot Two Equation Model
    if (iTwoEquationModel == true)	UpdateTwoEquationModel(y, dy);

    // Recovering residuals (Soot 2E are already updated)
    for (i=1;i<=NC;i++)	dy[i]	= domega[i];
    dy[NC+1]					= dT;
}
Exemple #6
0
void AspectWithVersionedProperties<
    BaseT, DerivedT, PropertiesData,
    CompositeT, updateProperties>::notifyPropertiesUpdate()
{
  UpdateProperties(static_cast<Derived*>(this));
  this->incrementVersion();
}
Exemple #7
0
void TfrmEditLightAnim::SetCurrentItem(CLAItem* I, ListItem* owner)
{
	m_CurrentItem 				= I;
    m_CurrentOwner				= owner;
    paItemProps->Visible 		= !!I;
    UpdateProperties			();
}
//==============================================================================
void PlanarJointAddon::setArbitraryPlane(const Eigen::Vector3d& _axis1,
                                         const Eigen::Vector3d& _axis2)
{
  mProperties.setArbitraryPlane(_axis1, _axis2);
  UpdateProperties(this);
  incrementSkeletonVersion();
}
Exemple #9
0
void TClipMaker::ShowEditor(CEditableObject* O)
{
	m_CurrentObject = O; VERIFY(O);
	Show			();
    UpdateClips		();
    UpdateProperties();
}
void OpenSMOKE_Droplet::DAESystemNoMomentum(BzzVector &x, double t, BzzVector &f)
{
	// --------------------------------------------------------------------------------------
	// 1. Recovering
	// --------------------------------------------------------------------------------------
	recoverUnknowns(x);

	// -------------------------------------------------------------------------------------		
	// 2. Properties
	// -------------------------------------------------------------------------------------
	UpdateProperties();
	DiffusionVelocities();
	GiveMeSpatialDerivatives();

	// --------------------------------------------------------------------------------------
	// 3. Equations
	// --------------------------------------------------------------------------------------
	GiveMeDT(t);
	GiveMeDOmega(t);
	
	// --------------------------------------------------------------------------------------
	// 4. Recovering
	// --------------------------------------------------------------------------------------
	recoverResiduals(f);	
}
void CheckBoxObject::Init(const CheckBoxObject &other)
{
    position = other.position;
    fontName = other.fontName;
    obj = sfg::CheckButton::Create(other.obj->GetLabel());
    backgroundColor = new ColorScheme(*(other.backgroundColor));
    borderColor = new ColorScheme(*(other.borderColor));
    textColor = new ColorScheme(*(other.textColor));
    checkColor = new ColorScheme(*(other.checkColor));
    SetChecked(other.IsChecked());
    width = other.width;
    height = other.height;
    fontSize = other.fontSize;
    borderWidth = other.borderWidth;
    padding = other.padding;
    boxSize = other.boxSize;
    checkSignSize = other.checkSignSize;

    obj->SetId(ToString<void*>(this));

    ConnectSignals();
    ResetEventInformations();

    UpdateSize();
    UpdateProperties();
}
void CheckBoxObject::EditObject( wxWindow* parent, Game & game, MainEditorCommand & mainEditorCommand )
{
    CheckBoxObjectEditor dialog(parent, game, *this, mainEditorCommand);
    dialog.ShowModal();

    UpdateProperties();
    UpdateSize();
}
Exemple #13
0
void __fastcall TfrmEditLightAnim::ebCreateKeyClick(TObject *Sender)
{
    u32 color				= m_CurrentItem->InterpolateRGB(sePointer->Value);

    m_CurrentItem->InsertKey(sePointer->Value,color);
    UpdateProperties		();
    OnModified				();
}                    
void CSiteGroupAutoCheckPage::OnHScroll(UINT sbCode, UINT pos, CScrollBar *scrollBar)
{
    if (scrollBar->m_hWnd == m_slider.m_hWnd) {
        UpdateText();
        UpdateProperties();
    }

    CPropertyPage::OnHScroll(sbCode, pos, scrollBar);
}
void CheckBoxObject::SetCheckColorScheme(const ColorScheme &cs)
{
    checkColor->focusedColor = cs.focusedColor;
    checkColor->unfocusedColor = cs.unfocusedColor;
    checkColor->hoveredColor = cs.hoveredColor;
    checkColor->disabledColor = cs.disabledColor;

    UpdateProperties();
}
void PropertySetting::UpdateFromPanel(PropertySettingPanel* panel)
{
	wxPropertyGrid* pg = panel->GetPropertyGrid();
	if (panel->GetType() == m_type) {
		UpdateProperties(pg);
	} else {
		InitProperties(pg);
	}
}
void cWidgetListBox::OnChangeSize()
{
    if(mpSlider)
        {
            mpSlider->SetSize(cVector2f(mfSliderWidth,mvSize.y));
            mpSlider->SetPosition(cVector3f(mvSize.x - mfSliderWidth, 0, 0.2f));

            UpdateProperties();
        }
}
Exemple #18
0
void TClipMaker::SelectClip(CUIClip* clip)
{
	if (sel_clip!=clip){
        AnsiString nm	= clip?*clip->name:"";
        sel_clip		= clip;
        m_ClipList->SelectItem(nm.c_str(),true,false,true);
        RepaintClips	();
        UpdateProperties();
    }
}
void CheckBoxObject::SetFont(string fontName_)
{
    fontName = fontName_;

    UpdateProperties();

    /*FontManager * fontManager = FontManager::GetInstance();
    text.SetFont(*fontManager->GetFont(fontName));*/
    //text.SetOrigin(text.GetRect().Width/2, text.GetRect().Height/2);
}
Exemple #20
0
void PathProp::SetPathAndUpdate( Path *pB, bool only_points )
{
    if( NULL == pB )
        return;

    //  Fetch any config file values
    if ( !only_points )
    {
        //      long LMT_Offset = 0;                    // offset in seconds from UTC for given location (-1 hr / 15 deg W)
        m_tz_selection = 1;

        if( m_pPath ) {
            m_pPath->m_iBlink--;
            if(m_pPath->m_iBlink < 0 ) 
                m_pPath->m_iBlink = 0;
        }
        m_pPath = pB;
        m_pPath->m_iBlink++;
        if(m_pPath->m_iBlink > 2) m_pPath->m_iBlink = 2;
        
        m_PathNameCtl->SetValue( m_pPath->m_PathNameString );

        m_PathNameCtl->SetFocus();
    }
    m_opList->DeleteAllItems();

#if 0
    // Select the proper list control, and add it to List sizer
    m_pListSizer->Clear();

    if( m_pPath ) {
        m_opList->Show();
        m_pListSizer->Add( m_opList, 2, wxEXPAND | wxALL, 5 );
    }
//    GetSizer()->Fit( this );
    GetSizer()->Layout();
#endif


    InitializeList();

    UpdateProperties( pB );

    if( m_pPath )
        m_opList->Show();

//    GetSizer()->Fit( this );
//    GetSizer()->Layout();

    Refresh( false );

}
void CheckBoxObject::SetCheckColorScheme(const std::string &focused, const std::string &hovered, const std::string &unfocused, const std::string &disabled)
{
    if(focused != "")
        checkColor->focusedColor = WidgetsCommonTools::GetColorFromString(focused, 255);
    if(hovered != "")
        checkColor->hoveredColor = WidgetsCommonTools::GetColorFromString(hovered, 255);
    if(unfocused != "")
        checkColor->unfocusedColor = WidgetsCommonTools::GetColorFromString(unfocused, 255);
    if(disabled != "")
        checkColor->disabledColor = WidgetsCommonTools::GetColorFromString(disabled, 255);

    UpdateProperties();
}
void MultiBoxView::AllAttached(void)
{
	rgb_color fLowColor;

	if(Parent() != NULL)
		fLowColor = Parent()->ViewColor();
	else
		fLowColor.red = fLowColor.green = fLowColor.blue = 255;
	
	SetLowColor(fLowColor);
	SetViewColor(B_TRANSPARENT_COLOR);

	UpdateProperties();
}
void
KeyframeEffect::SetTarget(const Nullable<ElementOrCSSPseudoElement>& aTarget)
{
  Maybe<OwningAnimationTarget> newTarget = ConvertTarget(aTarget);
  if (mTarget == newTarget) {
    // Assign the same target, skip it.
    return;
  }

  if (mTarget) {
    UnregisterTarget();
    ResetIsRunningOnCompositor();
    // We don't need to reset the mWinsInCascade member since it will be updated
    // when we later associate with a different target (and until that time this
    // flag is not used).

    RequestRestyle(EffectCompositor::RestyleType::Layer);

    nsAutoAnimationMutationBatch mb(mTarget->mElement->OwnerDoc());
    if (mAnimation) {
      nsNodeUtils::AnimationRemoved(mAnimation);
    }
  }

  mTarget = newTarget;

  if (mTarget) {
    UpdateTargetRegistration();
    RefPtr<nsStyleContext> styleContext = GetTargetStyleContext();
    if (styleContext) {
      UpdateProperties(styleContext);
    } else if (mEffectOptions.mSpacingMode == SpacingMode::paced) {
      KeyframeUtils::ApplyDistributeSpacing(mKeyframes);
    }

    MaybeUpdateFrameForCompositor();

    RequestRestyle(EffectCompositor::RestyleType::Layer);

    nsAutoAnimationMutationBatch mb(mTarget->mElement->OwnerDoc());
    if (mAnimation) {
      nsNodeUtils::AnimationAdded(mAnimation);
    }
  } else if (mEffectOptions.mSpacingMode == SpacingMode::paced) {
    // New target is null, so fall back to distribute spacing.
    KeyframeUtils::ApplyDistributeSpacing(mKeyframes);
  }
}
CheckBoxObject::CheckBoxObject(std::string name_) :
Object(name_),
borderWidth(1),
padding(5)
{
    //Create the SFGUI CheckBox object
    obj = sfg::CheckButton::Create("Texte");

    SetString("Case à cocher");

    //Default size of the object
    SetWidth(180);
    SetHeight(24);

    fontSize = 12;

    //Colors "Schemes"
    borderColor = new ColorScheme(sf::Color(146, 147, 151, 255),
                                  sf::Color(146, 147, 151, 255),
                                  sf::Color(146, 147, 151, 255),
                                  sf::Color(173, 173, 173, 255));

    backgroundColor = new ColorScheme(sf::Color(255, 255, 255, 255),
                                      sf::Color(201, 201, 201, 255),
                                      sf::Color(230, 230, 230, 255),
                                      sf::Color(140, 140, 140, 255));

    textColor = new ColorScheme(sf::Color(0, 0, 0, 255),
                                sf::Color(0, 0, 0, 255),
                                sf::Color(0, 0, 0, 255),
                                sf::Color(100, 100, 100, 255));

    checkColor = new ColorScheme(sf::Color(122, 122, 122, 255));

    SetBoxSize(14);
    SetCheckSignSize(6);

    obj->SetPosition( sf::Vector2f( GetX(), GetY() ) );

    obj->SetId(ToString<void*>(this));

    ConnectSignals();
    ResetEventInformations();

    UpdateProperties();
}
Exemple #25
0
void OpenSMOKE_ICEM::Initialize()
{
	ChangeDimensions(NC, &u);
	ChangeDimensions(NC, &lambdaMap);
	ChangeDimensions(NC, &muMap);
	
	UpdateAngleAndVolume(0.);
	arm_La = (compression_ratio-1.)/2.*volume_clearance/area_base;
	arm_Lc = arm_ratio*arm_La;
	velocity_piston = 2.*arm_La*rotation_rate;	// [m/s]

    T            = inletStream->T;
	P            = inletStream->P;
    omega        = inletStream->omega;
	mass         = inletStream->rho*volume;

	UpdateProperties(MINUSONE, NC+1);
}
Exemple #26
0
void TrackPropDlg::OnExtendBtnClick( wxCommandEvent& event ) 
{
    RoutePoint *pLastPoint = m_pRoute->GetPoint( 1 );

    if( IsThisTrackExtendable() ) {
        int begin = 1;
        if( pLastPoint->GetCreateTime() == m_pExtendPoint->GetCreateTime() ) begin = 2;
        pSelect->DeleteAllSelectableTrackSegments( m_pExtendRoute );
        m_pExtendRoute->CloneTrack( m_pRoute, begin, m_pRoute->GetnPoints(), _("_plus") );
        pSelect->AddAllSelectableTrackSegments( m_pExtendRoute );
        pSelect->DeleteAllSelectableTrackSegments( m_pRoute );
        m_pRoute->ClearHighlights();
        g_pRouteMan->DeleteTrack( m_pRoute );

        SetTrackAndUpdate( m_pExtendRoute );
        UpdateProperties();

        if( pRouteManagerDialog && pRouteManagerDialog->IsShown() )
            pRouteManagerDialog->UpdateTrkListCtrl();
    }
}
void MultiBoxView::Draw(BRect urect)
{
	UpdateProperties();

	BRect rect;
	int32 element;
	for (int32 i=0; i<numcols; i++) {
		for (int32 j=0; j<numrows; j++) {
//_sPrintf("i: %d, j: %d\n", i, j);
			element = GetElementAt(j, i);
			GetRectAt(element, &rect);
			if (urect.Intersects(rect))
			{
				DrawContentBox(element);
			}
		}
	}
	// clear bottom area of view
	rect = Bounds();
	rect.top = numrows * rowheight + 1;
	SetHighColor(ui_color(B_PANEL_BACKGROUND_COLOR));
	FillRect(rect);
}
void OpenSMOKE_Droplet::DAESystemOnlyTemperature(BzzVector &x, double t, BzzVector &f)
{
	// --------------------------------------------------------------------------------------
	// 1. Recovering
	// --------------------------------------------------------------------------------------
	recoverUnknowns(x);

	// -------------------------------------------------------------------------------------		
	// 2. Properties
	// -------------------------------------------------------------------------------------
	UpdateProperties();
	GiveMeSpatialDerivatives();

	// --------------------------------------------------------------------------------------
	// 3. Equations
	// --------------------------------------------------------------------------------------
	GiveMeDT(t);
	
	// --------------------------------------------------------------------------------------
	// 4. Recovering
	// --------------------------------------------------------------------------------------
	recoverResiduals(f);	
}
Exemple #29
0
void TClipMaker::RealRepaintClips()
{
    m_RTFlags.set		(flRT_RepaintClips,FALSE);
    // repaint
    paClips->Repaint	();
    gtClip->Repaint		();
    paBP0->Repaint		();
    paBP1->Repaint		();
    paBP2->Repaint		();
    paBP3->Repaint		();          
    paFXs->Repaint		();

	// set BP name                   
    CEditableObject* O	= m_CurrentObject;
    u32 k				= 0;
    if (O){
	    BPVec& bps 		= O->BoneParts();
        for (; k<bps.size(); k++)
        	m_LB[k]->Caption = bps[k].alias.c_str();
    }
	for (; k<4; k++)	m_LB[k]->Caption	= "-";
    UpdateProperties	();
}
Exemple #30
0
void TrackPropDlg::OnSplitBtnClick( wxCommandEvent& event ) 
{
    m_sdbBtmBtnsSizerSplit->Enable( false );

    if( m_pRoute->m_bIsInLayer )
        return;

    if( ( m_nSelected > 1 ) && ( m_nSelected < m_pRoute->GetnPoints() ) ) {
        m_pHead = new Track();
        m_pTail = new Track();
        m_pHead->CloneTrack( m_pRoute, 1, m_nSelected, _("_A") );
        m_pTail->CloneTrack( m_pRoute, m_nSelected, m_pRoute->GetnPoints(), _("_B") );
        pRouteList->Append( m_pHead );
        pConfig->AddNewRoute( m_pHead, -1 );
        m_pHead->RebuildGUIDList();

        pRouteList->Append( m_pTail );
        pConfig->AddNewRoute( m_pTail, -1 );
        m_pTail->RebuildGUIDList();

        pConfig->DeleteConfigRoute( m_pRoute );

        pSelect->DeleteAllSelectableRoutePoints( m_pRoute );
        pSelect->DeleteAllSelectableRouteSegments( m_pRoute );
        g_pRouteMan->DeleteRoute( m_pRoute );
        pSelect->AddAllSelectableRouteSegments( m_pTail );
        pSelect->AddAllSelectableRoutePoints( m_pTail );
        pSelect->AddAllSelectableRouteSegments( m_pHead );
        pSelect->AddAllSelectableRoutePoints( m_pHead );

        SetTrackAndUpdate( m_pTail );
        UpdateProperties();

        if( pRouteManagerDialog && pRouteManagerDialog->IsShown() )
            pRouteManagerDialog->UpdateTrkListCtrl();
    }
}