bool UIListTreeType::MoveRight(bool do_refresh)
{
if (!currentpos || !currentlevel)
{
return true;
}
if (currentpos->childCount() > 0)
{
currentlevel->SetActive(false);
curlevel++;
CreateLevel(curlevel);
currentlevel = GetLevel(curlevel);
FillLevelFromTree(currentpos, currentlevel);
currentlevel->SetVisible(true);
currentlevel->SetActive(true);
SetCurrentPosition();
if (do_refresh)
{
Redraw();
}
return true;
}
return false;
}
/******************************Public*Routine******************************\
* VcdPlayerPauseCmd
*
\**************************************************************************/
BOOL
VcdPlayerPauseCmd(
void
)
{
BOOL fPlaying = (g_State & VCD_PLAYING);
BOOL fPaused = (g_State & VCD_PAUSED);
if(fPlaying)
{
if(pMpegMovie)
{
pMpegMovie->PauseMovie();
SetCurrentPosition(pMpegMovie->GetCurrentPosition());
}
g_State &= ~VCD_PLAYING;
g_State |= VCD_PAUSED;
}
else if(fPaused)
{
if(pMpegMovie)
{
pMpegMovie->PlayMovie();
}
g_State &= ~VCD_PAUSED;
g_State |= VCD_PLAYING;
}
return TRUE;
}
/******************************Public*Routine******************************\
* VcdPlayerCloseCmd
*
\**************************************************************************/
BOOL
VcdPlayerCloseCmd(
void
)
{
if(pMpegMovie)
{
LONG cx, cy;
g_State = VCD_NO_CD;
pMpegMovie->GetMoviePosition(&lMovieOrgX, &lMovieOrgY, &cx, &cy);
pMpegMovie->StopMovie();
pMpegMovie->CloseMovie();
SetDurationLength((REFTIME)0);
SetCurrentPosition((REFTIME)0);
delete pMpegMovie;
pMpegMovie = NULL;
}
g_bSecondFileLoaded = FALSE;
InvalidateRect(hwndApp, NULL, FALSE);
UpdateWindow(hwndApp);
return TRUE;
}
void UIListTreeType::MoveUp(int count)
{
if (!currentlevel)
{
return;
}
currentlevel->MoveUp(count);
SetCurrentPosition();
RedrawCurrent();
}
void UIListTreeType::MoveUp(MovementUnit unit)
{
if (!currentlevel)
{
return;
}
currentlevel->MoveUp((UIListBtnType::MovementUnit)unit);
SetCurrentPosition();
RedrawCurrent();
}
void Tree::Print(string n1, string n2){
SetCurrentPosition(Search(n1));
Item *end = Search(n2);
while(current != end){
PrintCurrentPosition();
Next();
}
PrintCurrentPosition();
}
bool UIListTreeType::incSearchNext(void)
{
bool res = currentlevel->incSearchNext();
if (res)
{
SetCurrentPosition();
RedrawCurrent();
}
return (res);
}
/******************************Public*Routine******************************\
* VcdPlayerSeekCmd
*
\**************************************************************************/
void
VcdPlayerSeekCmd(
REFTIME rtSeekBy
)
{
REFTIME rt;
REFTIME rtDur;
rtDur = pMpegMovie->GetDuration();
rt = pMpegMovie->GetCurrentPosition() + rtSeekBy;
rt = max(0, min(rt, rtDur));
pMpegMovie->SeekToPosition(rt,TRUE);
SetCurrentPosition(pMpegMovie->GetCurrentPosition());
}
/******************************Public*Routine******************************\
* VcdPlayerChangeTimeFormat
*
* Tries to change the time format to id. Returns the time format that
* actually got set. This may differ from id if the graph does not support
* the requested time format.
*
\**************************************************************************/
int
VcdPlayerChangeTimeFormat(
int id
)
{
// Menu items are disabled while we are playing
BOOL bRet = FALSE;
int idActual = id;
ASSERT(pMpegMovie);
ASSERT(pMpegMovie->StatusMovie() != MOVIE_NOTOPENED);
// Change the time format with the filtergraph
switch(id)
{
case IDM_FRAME:
bRet = pMpegMovie->SetTimeFormat(TIME_FORMAT_FRAME);
break;
case IDM_FIELD:
bRet = pMpegMovie->SetTimeFormat(TIME_FORMAT_FIELD);
break;
case IDM_SAMPLE:
bRet = pMpegMovie->SetTimeFormat(TIME_FORMAT_SAMPLE);
break;
case IDM_BYTES:
bRet = pMpegMovie->SetTimeFormat(TIME_FORMAT_BYTE);
break;
}
if(!bRet)
{
// IDM_TIME and all other cases, everyone should support IDM_TIME
bRet = pMpegMovie->SetTimeFormat(TIME_FORMAT_MEDIA_TIME);
ASSERT(bRet);
idActual = IDM_TIME;
}
// Pause the movie to get a current position
SetDurationLength(pMpegMovie->GetDuration());
SetCurrentPosition(pMpegMovie->GetCurrentPosition());
return idActual;
}
//CharacterSpawn::CharacterSpawn(std::shared_ptr<Settings> &settings, Map *map)
CharacterSpawn::CharacterSpawn(std::shared_ptr<BaseSettings> &settings)
{
hasImage_ = false;
hasColor_ = false;
hasImageReference_ = false;
currentRotation_ = 0;
settings_ = settings;
//map_ = map;
SetCurrentPosition(1, 1);
SetColor(al_map_rgb_f(1, 1, 1));
SetWidth(0.8);
SetHeight(0.8);
//fprintf(stderr, "An CharacterSpawn created\n");
}
Character::Character(Settings *settings, int mapWidth, int mapHeight, std::vector<std::vector<Cell>> *cellMap)
{
hasText_ = false;
movespeed_ = 0;
currentRotation_ = 0;
hasImage_ = false;
hasColor_ = false;
hasImageReference_ = false;
aiEnabled_ = true;
mapWidth_ = mapWidth;
mapHeight_ = mapHeight;
cellMap_ = cellMap;
settings_ = settings;
KeyLeft_ = false;
KeyRight_ = false;
KeySpace_ = false;
SetCurrentPosition(mapWidth_ / Constants::TileSize() + 1, mapHeight_ / Constants::TileSize() + 1);
SetColor(al_map_rgb_f(1, 1, 1));
SetWidth(0.8);
SetHeight(0.8);
SetGravityY(-9.8);
SetVelocityY(0.125);
SetMaxVelocityY(1);
SetAccelerationY(0.03125);
SetMoveSpeedDelta(0.0625);
SetMoveSpeed(30);
SetJumpSpeed(12);
font30_ = al_load_font("arial.ttf", Constants::TileSize(), 0);
SetCharacterYAxisState(CHARACTERYAXISSTATES::CHARACTERFALLING);
}
// Use this function when you want to set the scroll position via the position
// of the scrollbar thumb, e.g. when dragging the slider. This function scrolls
// the content in such a way that thumbRect.x/.y becomes aNewThumbPos.
void
nsSliderFrame::SetCurrentThumbPosition(nsIContent* aScrollbar, nscoord aNewThumbPos,
PRBool aIsSmooth, PRBool aImmediateRedraw, PRBool aMaySnap)
{
nsRect crect;
GetClientRect(crect);
nscoord offset = IsHorizontal() ? crect.x : crect.y;
PRInt32 newPos = NSToIntRound((aNewThumbPos - offset) / mRatio);
if (aMaySnap && mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::snap,
nsGkAtoms::_true, eCaseMatters)) {
// If snap="true", then the slider may only be set to min + (increment * x).
// Otherwise, the slider may be set to any positive integer.
PRInt32 increment = GetIncrement(aScrollbar);
newPos = NSToIntRound(newPos / float(increment)) * increment;
}
SetCurrentPosition(aScrollbar, newPos, aIsSmooth, aImmediateRedraw);
}
bool SoundClass::PlayWaveFileofKey(std::string key)
{
HRESULT result;
auto value = _waveBuffers[key];
if (value)
{
/* result = value->SetCurrentPosition(0);
if (FAILED(result))
{
return false;
}
}
else*/
{
result = value->SetCurrentPosition(0);
if (FAILED(result))
{
return false;
}
result = value->SetVolume(-2000);
if (FAILED(result))
{
return false;
}
result = value->Play(0, 0, 0);
if (FAILED(result))
{
return false;
}
}
return true;
}
return false;
}
/******************************Public*Routine******************************\
* VcdPlayerPlayCmd
*
\**************************************************************************/
BOOL
VcdPlayerStopCmd(
void
)
{
BOOL fPlaying = (g_State & VCD_PLAYING);
BOOL fPaused = (g_State & VCD_PAUSED);
if((fPlaying || fPaused))
{
if(pMpegMovie)
{
pMpegMovie->StopMovie();
SetCurrentPosition(pMpegMovie->GetCurrentPosition());
}
g_State &= ~(fPlaying ? VCD_PLAYING : VCD_PAUSED);
g_State |= VCD_STOPPED;
}
return TRUE;
}
CBackGround::CBackGround()
{
//파일 위치 지정
SetCimage(std::make_shared<CImage>());
WCHAR path[256];
GetCurrentDirectory(sizeof(path), path);
WCHAR backGroundPath[256];
wcscpy_s(backGroundPath, path);
wcscat_s(backGroundPath, L"/Image/sky.bmp");
SetCurrentDirectory(backGroundPath);
SetCurrentPosition(0.0, 0.0);
SetFileLocation(backGroundPath);
GetDrawImage()->Load(backGroundPath);
}
HRESULT CDXGraph::Stop()
{
if(pControl != NULL)
{
pControl->Pause();
HRESULT hr = SetCurrentPosition(0.0);
hr = pControl->Stop();
if (pBasicVideo)
{
//hack to make the stop action show the first frame.
if(aveTimePerFrame == 0.0)
{
pBasicVideo->get_AvgTimePerFrame(&aveTimePerFrame);
}
//hr = pControl->Run();
//Sleep(aveTimePerFrame*500);
hr = pControl->Stop();
}
return hr;
}
return E_FAIL;
}
void UIListTreeType::MoveLeft(bool do_refresh)
{
if (!currentlevel)
{
return;
}
if (curlevel > 0)
{
ClearLevel(currentlevel);
currentlevel->SetVisible(false);
curlevel--;
currentlevel = GetLevel(curlevel);
currentlevel->SetActive(true);
SetCurrentPosition();
if (do_refresh)
{
Redraw();
}
}
}
FVector ACitizenAIController::GetCurrentPosition()
{
SetCurrentPosition();
return BlackboardComp->GetValueAsVector(CurrentPositionName);
}
void GuiderOneStar::OnLClick(wxMouseEvent &mevent)
{
try
{
if (mevent.GetModifiers() == wxMOD_CONTROL)
{
double const scaleFactor = ScaleFactor();
wxRealPoint pt((double) mevent.m_x / scaleFactor,
(double) mevent.m_y / scaleFactor);
ToggleBookmark(pt);
m_showBookmarks = true;
pFrame->bookmarks_menu->Check(MENU_BOOKMARKS_SHOW, GetBookmarksShown());
Refresh();
Update();
return;
}
if (GetState() > STATE_SELECTED)
{
mevent.Skip();
throw THROW_INFO("Skipping event because state > STATE_SELECTED");
}
if (mevent.GetModifiers() == wxMOD_SHIFT)
{
// Deselect guide star
InvalidateCurrentPosition(true);
}
else
{
if ((mevent.m_x <= m_searchRegion) || (mevent.m_x + m_searchRegion >= XWinSize) || (mevent.m_y <= m_searchRegion) || (mevent.m_y + m_searchRegion >= YWinSize))
{
mevent.Skip();
throw THROW_INFO("Skipping event because click outside of search region");
}
usImage *pImage = CurrentImage();
if (pImage->NPixels == 0)
{
mevent.Skip();
throw ERROR_INFO("Skipping event m_pCurrentImage->NPixels == 0");
}
double scaleFactor = ScaleFactor();
double StarX = (double) mevent.m_x / scaleFactor;
double StarY = (double) mevent.m_y / scaleFactor;
SetCurrentPosition(pImage, PHD_Point(StarX, StarY));
if (!m_star.IsValid())
{
pFrame->SetStatusText(wxString::Format(_("No star found")));
}
else
{
SetLockPosition(m_star);
pFrame->SetStatusText(wxString::Format(_("Selected star at (%.1f, %.1f)"), m_star.X, m_star.Y), 1);
pFrame->SetStatusText(wxString::Format(_T("m=%.0f SNR=%.1f"), m_star.Mass, m_star.SNR));
EvtServer.NotifyStarSelected(CurrentPosition());
SetState(STATE_SELECTED);
pFrame->UpdateButtonsStatus();
pFrame->pProfile->UpdateData(pImage, m_star.X, m_star.Y);
}
Refresh();
Update();
}
}
catch (wxString Msg)
{
POSSIBLY_UNUSED(Msg);
}
}
/*****************************Private*Routine******************************\
* VideoCd_OnCreate
*
\**************************************************************************/
BOOL
VideoCd_OnCreate(
HWND hwnd,
LPCREATESTRUCT lpCreateStruct
)
{
RECT rc;
int Pane[2];
InitCommonControls();
/*
** Create the toolbar and statusbar.
*/
g_hwndToolbar = CreateToolbarEx(hwnd,
WS_VISIBLE | WS_CHILD |
TBSTYLE_TOOLTIPS | CCS_NODIVIDER,
ID_TOOLBAR, NUMBER_OF_BITMAPS,
hInst, IDR_TOOLBAR, tbButtons,
DEFAULT_TBAR_SIZE, dxBitmap, dyBitmap,
dxBitmap, dyBitmap, sizeof(TBBUTTON));
if(g_hwndToolbar == NULL)
{
return FALSE;
}
g_hwndStatusbar = CreateStatusWindow(WS_VISIBLE | WS_CHILD | CCS_BOTTOM,
TEXT("Example Text"), hwnd, ID_STATUSBAR);
GetWindowRect(g_hwndToolbar, &rc);
dyToolbar = rc.bottom - rc.top;
GetWindowRect(g_hwndStatusbar, &rc);
dyStatusbar = rc.bottom - rc.top;
dyTrackbar = 30;
GetClientRect(hwnd, &rc);
Pane[0] = (rc.right - rc.left) / 2 ;
Pane[1] = -1;
SendMessage(g_hwndStatusbar, SB_SETPARTS, 2, (LPARAM)Pane);
g_hwndTrackbar = CreateWindowEx(0, TRACKBAR_CLASS, TEXT("Trackbar Control"),
WS_CHILD | WS_VISIBLE |
TBS_AUTOTICKS | TBS_ENABLESELRANGE,
LEFT_MARGIN, dyToolbar - 1,
(rc.right - rc.left) - (2* LEFT_MARGIN),
dyTrackbar, hwnd, (HMENU)ID_TRACKBAR,
hInst, NULL);
SetDurationLength((REFTIME)0);
SetCurrentPosition((REFTIME)0);
SetTimer(hwnd, StatusTimer, 100, NULL);
if(g_hwndStatusbar == NULL || g_hwndTrackbar == NULL)
{
return FALSE;
}
return TRUE;
}
void CDataCollector::OnLBSPosition(float lon,float lat) { SetCurrentPosition(lon,lat); }
HRESULT CDXGraph::Grab(CString strFilePath)
{
if (pControl && pGrabber)
{
long evCode;
double cPosition = 0;
GetCurrentPosition(&cPosition);
//pControl->Stop();
HRESULT hr = pGrabber->SetOneShot(FALSE);
hr = pGrabber->SetBufferSamples(TRUE);
pControl->Run();
//don't add the following code, or it will pause the stream
//pEvent->WaitForCompletion(INFINITE, &evCode);
//Grab it
hr = SetCurrentPosition(cPosition);
//graph must be stopped if you want to call getcurrentbuffer.
pControl->StopWhenReady();
while(TRUE)
{
OAFilterState fs;
pControl->GetState(100, &fs);
if (fs == State_Stopped)
{
break;
}
Sleep(100);
}
long cbBuffer = 0;
hr = pGrabber->GetCurrentBuffer(&cbBuffer, NULL);
char *pBuffer = new char[cbBuffer];
if(!pBuffer)
{
return E_FAIL;
}
hr = pGrabber->GetCurrentBuffer(&cbBuffer, (long*)pBuffer);
//Display it
AM_MEDIA_TYPE mt;
hr = pGrabber->GetConnectedMediaType(&mt);
if (FAILED(hr)) return hr;
VIDEOINFOHEADER *pVih;
if((mt.formattype == FORMAT_VideoInfo) && (mt.cbFormat >= sizeof(VIDEOINFOHEADER)) && (mt.pbFormat != NULL))
{
pVih = (VIDEOINFOHEADER*)mt.pbFormat;
}
else
{
ZeroMemory(&mt, sizeof(AM_MEDIA_TYPE));
return VFW_E_INVALIDMEDIATYPE;
}
//CString fileName;
//fileName.Format(_T("D://Example%d.bmp"), grabCount++);
if(pVih->bmiHeader.biBitCount==32){
HANDLE hf = CreateFile(strFilePath, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, NULL);
if (hf == INVALID_HANDLE_VALUE)
{
return E_FAIL;
}
BITMAPFILEHEADER bfh;
ZeroMemory(&bfh, sizeof(bfh));
bfh.bfType = 'MB';
bfh.bfSize = sizeof(bfh) + cbBuffer*3/4 + sizeof(BITMAPINFOHEADER);
bfh.bfOffBits = sizeof(BITMAPFILEHEADER) +sizeof(BITMAPINFOHEADER);
DWORD dwWritten = 0;
WriteFile(hf, &bfh, sizeof(bfh), &dwWritten, NULL);
BITMAPINFOHEADER bih;
ZeroMemory(&bih, sizeof(bih));
bih.biSize = sizeof(bih);
bih.biWidth = pVih->bmiHeader.biWidth;
bih.biHeight = pVih->bmiHeader.biHeight;
bih.biPlanes = pVih->bmiHeader.biPlanes;
bih.biBitCount = 24 ;//pVih->bmiHeader.biBitCount;
dwWritten = 0;
WriteFile(hf, &bih, sizeof(bih), &dwWritten, NULL);
BYTE* tmpBuf = new BYTE[cbBuffer];
int tmpCbBuffer = 0;
for (int i = 0; i<cbBuffer;i++)
{
if((i&0x3)==0x3){
continue;
}
tmpBuf[tmpCbBuffer++] = pBuffer[i];
}
dwWritten = 0;
WriteFile(hf, tmpBuf, tmpCbBuffer, &dwWritten, NULL);
delete tmpBuf;
CloseHandle(hf);
}
ZeroMemory(&mt, sizeof(AM_MEDIA_TYPE));
delete(pBuffer);
hr = SetCurrentPosition(cPosition);
return hr;
}
return E_FAIL;
}
/*****************************Private*Routine******************************\
* VideoCd_OnHScroll
*
\**************************************************************************/
void
VideoCd_OnHScroll(
HWND hwnd,
HWND hwndCtl,
UINT code,
int pos
)
{
static BOOL fWasPlaying = FALSE;
static BOOL fBeginScroll = FALSE;
if(pMovie == NULL)
return;
if(hwndCtl == g_hwndTrackbar)
{
REFTIME rtCurrPos;
REFTIME rtTrackPos;
REFTIME rtDuration;
pos = (int)SendMessage(g_hwndTrackbar, TBM_GETPOS, 0, 0);
rtTrackPos = (REFTIME)pos * g_TrackBarScale;
switch(code)
{
case TB_BOTTOM:
rtDuration = pMovie->GetDuration();
rtCurrPos = pMovie->GetCurrentPosition();
VcdPlayerSeekCmd(rtDuration - rtCurrPos);
SetCurrentPosition(pMovie->GetCurrentPosition());
break;
case TB_TOP:
rtCurrPos = pMovie->GetCurrentPosition();
VcdPlayerSeekCmd(-rtCurrPos);
SetCurrentPosition(pMovie->GetCurrentPosition());
break;
case TB_LINEDOWN:
VcdPlayerSeekCmd(10.0);
SetCurrentPosition(pMovie->GetCurrentPosition());
break;
case TB_LINEUP:
VcdPlayerSeekCmd(-10.0);
SetCurrentPosition(pMovie->GetCurrentPosition());
break;
case TB_ENDTRACK:
fBeginScroll = FALSE;
if(fWasPlaying)
{
VcdPlayerPauseCmd();
fWasPlaying = FALSE;
}
break;
case TB_THUMBTRACK:
if(!fBeginScroll)
{
fBeginScroll = TRUE;
fWasPlaying = (g_State & VCD_PLAYING);
if(fWasPlaying)
{
VcdPlayerPauseCmd();
}
}
// Fall through
case TB_PAGEUP:
case TB_PAGEDOWN:
rtCurrPos = pMovie->GetCurrentPosition();
VcdPlayerSeekCmd(rtTrackPos - rtCurrPos);
SetCurrentPosition(pMovie->GetCurrentPosition());
break;
}
}
}
/*****************************Private*Routine******************************\
* VideoCd_OnTimer
*
\**************************************************************************/
void
VideoCd_OnTimer(
HWND hwnd,
UINT id
)
{
HRESULT hr;
if(pMovie && pMovie->StatusMovie() == MOVIE_PLAYING)
{
switch(id)
{
case StatusTimer:
{
REFTIME rt = pMovie->GetCurrentPosition();
TCHAR szFmt[64];
char sz[64];
long cx, cy;
static int iCharCount = 0;
static int iCharOffset = 40;
pMovie->GetNativeMovieSize(&cx, &cy);
#ifdef UNICODE
hr = StringCchPrintfA(sz, NUMELMS(sz),"%ls\0", FormatRefTime(szFmt, rt, NUMELMS(szFmt)));
#else
hr = StringCchPrintfA(sz, NUMELMS(sz), "%s\0", FormatRefTime(szFmt, rt,NUMELMS(szFmt)));
#endif
//
// Prepare the text array
//
memset(g_szLine21Text, ' ', sizeof(g_szLine21Text));
g_szLine21Text[ 40] = '\n';
g_szLine21Text[ 81] = '\n';
g_szLine21Text[122] = '\n';
g_szLine21Text[163] = '\0';
// add time
memcpy(g_szLine21Text, sz, min(lstrlenA(sz), sizeof(g_szLine21Text)));
char* lpL1 = &g_szLine21Text[ 41];
char* lpL2 = &g_szLine21Text[ 82];
char* lpL3 = &g_szLine21Text[123];
if(iCharCount <= 40)
{
memcpy(lpL3, g_Line21Msg, iCharCount);
}
else if(iCharCount <= 80)
{
memcpy(lpL2, g_Line21Msg + 0, 40);
memcpy(lpL3, g_Line21Msg + 40, iCharCount - 40);
}
else if(iCharCount <= 120)
{
memcpy(lpL1, g_Line21Msg + 0, 40);
memcpy(lpL2, g_Line21Msg + 40, 40);
memcpy(lpL3, g_Line21Msg + 80, iCharCount - 80);
}
else
{
memcpy(lpL1, g_Line21Msg + iCharOffset + 0, 40);
memcpy(lpL2, g_Line21Msg + iCharOffset + 40, 40);
memcpy(lpL3, g_Line21Msg + iCharOffset + 80, iCharCount - (iCharOffset + 80));
if(iCharCount % 40 == 0)
{
iCharOffset += 40;
}
}
iCharCount++;
if(iCharCount > (sizeof(g_Line21Msg) - 1))
{
iCharCount = 1;
iCharOffset = 40;
}
pMovie->SetAppText(g_szLine21Text);
SetCurrentPosition(rt);
}
break;
}
}
}
