// Window Window::Window(uint16 id, int16 xPos, int16 yPos, int16 width, int16 height, Bitmap* background) : fID(id), fBackground(background), fWidth(width), fHeight(height), fActiveControl(NULL) { fPosition.x = xPos; fPosition.y = yPos; // TODO: Not very nice. Here we check if the window would sit // on the right side on the screen on 640x480, and move it if // the screen is larger than that. We also check if the window would // span into the full width of the screen, and resize it accordingly. GFX::rect screenRect = GraphicsEngine::Get()->ScreenFrame(); if (screenRect.w > 640) { if (xPos + width == 640) { if (xPos == 0) { // Full screen window. Resize SetFrame(xPos, yPos, screenRect.w, screenRect.h); } else { SetFrame(screenRect.w - width, yPos, width, height); } } } }
CalcWindow::CalcWindow(BRect frame, BMessage* settings) : BWindow(frame, kWindowTitle, B_TITLED_WINDOW, B_ASYNCHRONOUS_CONTROLS) { // create calculator view with calculator description and // desktop background color BScreen screen(this); rgb_color baseColor = screen.DesktopColor(); SetSizeLimits(100.0, 400.0, 100.0, 400.0); frame.OffsetTo(B_ORIGIN); fCalcView = new CalcView(frame, baseColor, settings); // create replicant dragger BRect replicantFrame(frame); replicantFrame.top = replicantFrame.bottom - 7.0f; replicantFrame.left = replicantFrame.right - 7.0f; BDragger* dragger = new BDragger(replicantFrame, fCalcView, B_FOLLOW_RIGHT | B_FOLLOW_BOTTOM); // attach views AddChild(fCalcView); fCalcView->AddChild(dragger); BRect rect; if (settings->FindRect("window frame", &rect) == B_OK) SetFrame(rect); else SetFrame(frame, true); }
void Body::UpdateFrame() { if (!(GetFlags() & Body::FLAG_CAN_MOVE_FRAME)) return; // falling out of frames if (!GetFrame()->IsLocalPosInFrame(GetPosition())) { printf("%s leaves frame %s\n", GetLabel().c_str(), GetFrame()->GetLabel().c_str()); Frame *new_frame = GetFrame()->m_parent; if (new_frame) { // don't let fall out of root frame matrix4x4d m = matrix4x4d::Identity(); GetFrame()->ApplyLeavingTransform(m); vector3d new_pos = m * GetPosition(); matrix4x4d rot; GetRotMatrix(rot); SetRotMatrix(m * rot); m.ClearToRotOnly(); SetVelocity(GetFrame()->GetVelocity() + m*(GetVelocity() - GetFrame()->GetStasisVelocityAtPosition(GetPosition()))); SetFrame(new_frame); SetPosition(new_pos); Pi::luaOnFrameChanged->Queue(this); return; } } // entering into frames for (std::list<Frame*>::iterator j = GetFrame()->m_children.begin(); j != GetFrame()->m_children.end(); ++j) { Frame *kid = *j; matrix4x4d m; Frame::GetFrameTransform(GetFrame(), kid, m); vector3d pos = m * GetPosition(); if (!kid->IsLocalPosInFrame(pos)) continue; printf("%s enters frame %s\n", GetLabel().c_str(), kid->GetLabel().c_str()); SetPosition(pos); SetFrame(kid); matrix4x4d rot; GetRotMatrix(rot); SetRotMatrix(m * rot); // get rid of transforms m.ClearToRotOnly(); SetVelocity(m*(GetVelocity() - kid->GetVelocity()) + kid->GetStasisVelocityAtPosition(pos)); Pi::luaOnFrameChanged->Queue(this); break; } }
void ShipCockpit::RenderCockpit(Graphics::Renderer* renderer, const Camera* camera, Frame* frame) { PROFILE_SCOPED() renderer->ClearDepthBuffer(); SetFrame(frame); Render(renderer, camera, m_translate, m_transform); SetFrame(nullptr); }
void hgeAnimation::Play() { bPlaying=true; fSinceLastFrame=-1.0f; if(Mode & HGEANIM_REV) { nDelta = -1; SetFrame(nFrames-1); } else { nDelta = 1; SetFrame(0); } }
void hgeAnimation::SetMode(const int mode) { mode_ = mode; if (mode & HGEANIM_REV) { delta_ = -1; SetFrame(frames_ - 1); } else { delta_ = 1; SetFrame(0); } }
void hgeAnimation::Play() { is_playing_ = true; since_last_frame_ = -1.0f; if (mode_ & HGEANIM_REV) { delta_ = -1; SetFrame(frames_ - 1); } else { delta_ = 1; SetFrame(0); } }
void hgeAnimation::SetMode(int mode) { Mode=mode; if(mode & HGEANIM_REV) { nDelta = -1; SetFrame(nFrames-1); } else { nDelta = 1; SetFrame(0); } }
void hgeAnimation::SetMode(anim_mode_t mode) { m_play_mode = mode; if (mode & HGEANIM_REV) { m_delta = -1; SetFrame(m_frame_count - 1); } else { m_delta = 1; SetFrame(0); } }
void hgeAnimation::Play() { m_playing_flag = true; m_since_last_frame = -1.0f; if (m_play_mode & HGEANIM_REV) { m_delta = -1; SetFrame(m_frame_count - 1); } else { m_delta = 1; SetFrame(0); } }
void Vessel::SetFrameGroup(StartAndEndFrameInfo* pFameInfo, float FrameSpeed) { SetFrameStart( pFameInfo->StartFrame ); SetEndFrame( pFameInfo->EndFrame ); SetFrame( GetFrameStart() ); SetFrameSpeed( FrameSpeed ); }
void CWallHealth::Recharge(void) { EMIT_SOUND( this, CHAN_ITEM, "items/medshot4.wav", 1.0, ATTN_NORM ); m_iJuice = gSkillData.GetHealthChargerCapacity(); SetFrame( 0 ); SetThink( &CWallHealth::SUB_DoNothing ); }
// Clean up windows used for displaying the view. bool DrawingView::OnClose(bool deleteWindow) { if (!GetDocument()->Close()) return false; // Clear the canvas in case we're in single-window mode, // and the canvas stays. canvas->ClearBackground(); canvas->view = (wxView *) NULL; canvas = (MyCanvas *) NULL; wxString s(wxTheApp->GetAppName()); if (frame) frame->SetTitle(s); SetFrame((wxFrame*)NULL); Activate(false); if (deleteWindow) { delete frame; return true; } return true; }
void CE_CBeam::BeamInit( const char *pSpriteName, float width ) { SetColor( 255, 255, 255 ); SetBrightness( 255 ); SetNoise( 0 ); SetFrame( 0 ); SetScrollRate( 0 ); SetModelName( MAKE_STRING( pSpriteName ) ); SetRenderMode( kRenderTransTexture ); SetTexture( engine->PrecacheModel( pSpriteName ) ); SetWidth( width ); SetEndWidth( width ); SetFadeLength( 0 ); // No fade for (int i=0;i<MAX_BEAM_ENTS;i++) { Set_m_hAttachEntity(i,NULL); Set_m_nAttachIndex(i, 0); } m_nHaloIndex = 0; m_fHaloScale = BEAM_DEFAULT_HALO_SCALE; m_nBeamType = 0; m_nBeamFlags = 0; }
////////////////////////////////////////////////////////////////////////////////// //Calculates tensor in reaction CM frame //This is the same as KVTensP after using SetFrame("CM") //_________________________________________________________________ KVTensPCM::KVTensPCM(void) { // // Createur par default // SetFrame("CM"); }
// What to do when a view is created. Creates actual // windows for displaying the view. bool DrawingView::OnCreate(wxDocument *doc, long WXUNUSED(flags) ) { MyApp& app = wxGetApp(); if ( app.GetMode() != MyApp::Mode_Single ) { // create a new window and canvas inside it m_frame = app.CreateChildFrame(doc, this, true); m_frame->SetTitle("Drawing View"); m_canvas = new MyCanvas(this, m_frame); m_frame->Show(true); } else // single document mode { // reuse the existing window and canvas m_frame = wxStaticCast(app.GetTopWindow(), wxFrame); m_canvas = app.GetMainWindowCanvas(); m_canvas->SetView(this); // Associate the appropriate frame with this view. SetFrame(m_frame); // Make sure the document manager knows that this is the // current view. Activate(true); // Initialize the edit menu Undo and Redo items doc->GetCommandProcessor()->SetEditMenu(app.GetMainWindowEditMenu()); doc->GetCommandProcessor()->Initialize(); } return true; }
// Clean up windows used for displaying the view. bool DrawingView::OnClose(bool deleteWindow) { if ( !wxView::OnClose(deleteWindow) ) return false; Activate(false); // Clear the canvas in single-window mode in which it stays alive if ( wxGetApp().GetMode() == MyApp::Mode_Single ) { m_canvas->ClearBackground(); m_canvas->ResetView(); m_canvas = NULL; if (GetFrame()) wxStaticCast(GetFrame(), wxFrame)->SetTitle(wxTheApp->GetAppDisplayName()); } else // not single window mode { if ( deleteWindow ) { GetFrame()->Destroy(); SetFrame(NULL); } } return true; }
void SpriteEditWindow::AddFrame (sint32 add) { m_frame +=add; SetFrame(m_frame); }
void TableBackgroundPainter::TableBackgroundData::SetFull(nsIFrame* aFrame) { NS_PRECONDITION(aFrame, "null frame"); SetFrame(aFrame); SetData(); }
// Fonction à appeler à chaque tours de boucle, prend le temps // écoulé depuis le dernier appel à la fonction en paramètre void Animated::anim(float ElapsedTime) { // Si il n'est pas en pause et que l'animation est valide if (!Paused && myAnim != NULL) { // on retranche le temps écoulé a notre compteur myElapsedTime -= ElapsedTime; // Si Le temps entre chaque frame est atteint if (myElapsedTime <= 0.f) { // On réinitialise notre compteur myElapsedTime = myTime; // On passe a la frame suivante if (static_cast<unsigned>(myCurrentFrame + 1) < myAnim->Size()) myCurrentFrame++; else { // Ou on a la premiere if (myLoop) myCurrentFrame = 0; else { // Si le mode Loop est désactivé, on stop l'animation Stop(); } } // On change la frame SetFrame(myCurrentFrame); } } }
AboutWindow::AboutWindow(const Rect & r) :Window(r, "AboutAlbert", MSG_ABOUTWND_TITLE, // WND_NO_CLOSE_BUT | WND_NO_ZOOM_BUT | WND_NO_DEPTH_BUT | // WND_NO_BORDER | WND_NO_TITLE | WND_NOT_RESIZABLE, CURRENT_DESKTOP) { os::Resources cRes(get_image_id()); os::ResStream* pcStream = cRes.GetResourceStream("Calculator.png"); if(pcStream == NULL) throw(os::errno_exception("Can't find resource Calculator.png!")); m_pcImage = new BitmapImage( pcStream ); BitmapView* imv = new BitmapView( m_pcImage->GetBounds(), "bitmap", m_pcImage ); AddChild(imv); Rect frame = m_pcImage->GetBounds(); Desktop desktop; Point offset(desktop.GetResolution()); offset.x = offset.x/2 - frame.Width()/2; offset.y = offset.y/2 - frame.Height()/2; SetFrame(frame + offset); delete pcStream; }
void Image::Reset() { // Set amount of rows & cols if animation is non-null rows = (animation == nullptr) ? 1 : animation->rows; cols = (animation == nullptr) ? 1 : animation->cols; max_frame = rows * cols - 1; // Find dimensions of the texture int _query = SDL_QueryTexture(texture, NULL, NULL, &width, &height); // Check for texture error if (_query < 0) Log::s(Log::e << "Texture query error occured on an Image" << SDL_GetError()); frame_width = width / cols; frame_height = height / rows; src->w = frame_width; src->h = frame_height; // Reset routine for position, animation data, frame, and scale SetFrameDelay( (animation == nullptr) ? 1 : animation->delay ); SetAnimate(true); SetPosition(0, 0); SetFrame(0); Scale(1.0f); }
GUIinfoSelection::GUIinfoSelection(int x, int y, int w, int h):GUIpane(x, y, w, h) { SetFrame(false); SetResizeable(true); minW=220; minH=h; }
// // Sprite::VOnRestore - Chapter 10, page 321 // void Sprite::VOnUpdate(int deltaMS) { if (m_IsPaused) { return; } m_ElapsedTime += deltaMS; // Only call SetFrame() if we have to. // We're guaranteed to have to advance at least one frame... if (m_ElapsedTime >= m_MSPerFrame) { DWORD const numFramesToAdvance = (m_ElapsedTime / m_MSPerFrame); m_ElapsedTime -= (numFramesToAdvance * m_MSPerFrame); int desiredFrame = GetFrame() + numFramesToAdvance; //Check if we're looping... if ((false==m_LoopingAnim) && (desiredFrame >= GetFrameCount())) { desiredFrame = GetFrameCount() - 1; //Stay on last frame... } //Now advance our frame properly... SetFrame(desiredFrame); } }
PiranhaPlant::PiranhaPlant(int objectTypeID, int positionX, int positionY) { //Object //set id _Position = D3DXVECTOR2(positionX, positionY - 1.4 * 32); //set position: positionY - 1.4 * 32 mục đích cho đi từ trên xuống lúc bắt đầu _Sprite = SpriteManager::GetInstance()->GetSprite(eSpriteID::ePiranhaPlant); //set sprite _Size = D3DXVECTOR2(PIRANHAPLANT_WIDTH, PIRANHAPLANT_HEIGHT); //set size _Velocity = D3DXVECTOR2(0, PIRANHAPLANT_VELOCITY_Y); //set position _TypeSpriteID = eSpriteID::ePiranhaPlant; //set type spriteID _MonsterTypeID = objectTypeID; SetObjectType(eMonsterDead); //trạng thái chết tạm thời: để không bị va chạm khi mới vào: do đang ở dưới // PiranhaPlant _TimeStartFrame = GetTickCount(); //set time now _TimePerFrame = TIMES_TURN; //set time the turn _TimeStartVelocity = GetTickCount(); //set time now _TimePerVelocity = TIMES_TURN_VELOCITY; //set time the turn position+velocity SetFrame(objectTypeID); _MonsterVelocityX = -PIRANHAPLANT_VELOCITY_X; _MonsterVelocityY = -PIRANHAPLANT_VELOCITY_Y; _PositionY = positionY; //set position turn away _TimeStartStop = GetTickCount(); _TimePerStop = TIMES_TURN_STOP; _PiranhaPlantStop = false; _PiranhaPlantDanger = false; }
//________________________________________________________________ void KVFlowTensor::init_KVFlowTensor() { // PRIVATE method // Private initialisation method called by all constructors. // All member initialisations should be done here. // // You should also (if your variable calculates several different quantities) // set up a correspondance between named values and index number // using method SetNameIndex(const Char_t*,Int_t) // in order for GetValue(const Char_t*) to work correctly. // The index numbers should be the same as in your getvalue_int(Int_t) method. fType = KVVarGlob::kOneBody; // this is a 1-body variable // reference frame = "CM" // weight = NRKE [non-relativistic kinetic energy] (1/2m) SetFrame("CM"); SetOption("weight", "NRKE"); fTensor.Zero(); SetNameIndex("FlowAngle", kFlowAngle); SetNameIndex("KinFlowRatio13", kKinFlowRatio13); SetNameIndex("KinFlowRatio23", kKinFlowRatio23); SetNameIndex("PhiReacPlane", kPhiReacPlane); SetNameIndex("SqueezeAngle", kSqueezeAngle); SetNameIndex("SqueezeRatio", kSqueezeRatio); SetNameIndex("NumberParts", kNumberParts); }
int WebPDemuxGetFrame(const WebPDemuxer* dmux, int frame, WebPIterator* iter) { if (iter == NULL) return 0; memset(iter, 0, sizeof(*iter)); iter->private_ = (void*)dmux; return SetFrame(frame, iter); }
void SkeletalEntity::Update(){ if(!mAnimation.Get()) return; if(clock() - mLastUpdate > mUpdateInterval){ if(!mPaused) SetFrame(mCurFrame + 1); if(max_loops != 0 && nb_loops >= max_loops){ PauseAnimation(); } mLastUpdate = clock(); } for(unsigned int i = 0; i < mBoundEntities.Size(); ++i){ BoundEntity& bound = mBoundEntities[i]; bound.mEntity->SetTransform(mBoneMatricesAbs[mCurFrame][bound.mBoneID]); } BoundingBox tmp = mBoundingBox; tmp.mMax += Vector3(0.0f, 0.0f, 0.25f); mBoundingBoxTransformed.Reset(); mBoundingBoxTransformed.AddTransformedBox(tmp, mBoneMatrices[mCurFrame][0] * mTransform); }
ColorButton::ColorButton() { style = &ToolBar::StyleDefault().buttonstyle; SetFrame(NullFrame()); NoTrack(); Transparent(); }
LogPosPopUp::LogPosPopUp() { CtrlLayoutCancel(*this, ""); cktype = CKOKCANCEL; SetFrame(BlackFrame()); l.SetLabel("<"); r.SetLabel(">"); t.SetLabel("/\\"); b.SetLabel("\\/"); xa <<= THISBACK(XaCB); xb <<= THISBACK(XbCB); ya <<= THISBACK(YaCB); yb <<= THISBACK(YbCB); l <<= THISBACK(LRCB); r <<= THISBACK(LRCB); t <<= THISBACK(TBCB); b <<= THISBACK(TBCB); lt <<= THISBACK(LTCB); rt <<= THISBACK(RTCB); lb <<= THISBACK(LBCB); rb <<= THISBACK(RBCB); hc <<= THISBACK(HCCB); vc <<= THISBACK(VCCB); cc <<= THISBACK(CCCB); hs <<= THISBACK(HSCB); vs <<= THISBACK(VSCB); ss <<= THISBACK(SSCB); }