void CFrameWnd::InitialUpdateFrame( CDocument *pDoc, BOOL bMakeVisible )
/**********************************************************************/
{
UNUSED_ALWAYS( pDoc );
if( GetActiveView() == NULL ) {
CView *pView = (CView *)GetDescendantWindow( AFX_IDW_PANE_FIRST );
if( pView != NULL ) {
if( pView->IsKindOf( RUNTIME_CLASS( CView ) ) ) {
SetActiveView( pView );
} else if( pView->IsKindOf( RUNTIME_CLASS( CSplitterWnd ) ) ) {
pView = (CView *)pView->GetDescendantWindow( AFX_IDW_PANE_FIRST );
if( pView->IsKindOf( RUNTIME_CLASS( CView ) ) ) {
SetActiveView( pView );
}
}
}
}
if( pDoc != NULL ) {
pDoc->UpdateFrameCounts();
}
OnUpdateFrameTitle( TRUE );
SendMessageToDescendants( WM_INITIALUPDATE );
if( bMakeVisible ) {
CWinApp *pApp = AfxGetApp();
ASSERT( pApp != NULL );
if( pApp->m_pMainWnd == this ) {
ActivateFrame( pApp->m_nCmdShow );
pApp->m_nCmdShow = -1;
} else {
ActivateFrame();
}
}
}
void Manager::SwapTwoFrame(int Direction)
{
if (Direction)
{
int OldFramePos=FramePos;
FramePos+=Direction;
if (Direction>0)
{
if (FramePos>=FrameCount)
{
FramePos=0;
}
}
else
{
if (FramePos<0)
{
FramePos=FrameCount-1;
}
}
Frame *TmpFrame=FrameList[OldFramePos];
FrameList[OldFramePos]=FrameList[FramePos];
FrameList[FramePos]=TmpFrame;
ActivateFrame(OldFramePos);
}
DeactivatedFrame=CurrentFrame;
}
void Manager::DeactivateFrame(Frame *Deactivated,int Direction)
{
_MANAGER(CleverSysLog clv(L"Manager::DeactivateFrame (Frame *Deactivated,int Direction)"));
_MANAGER(SysLog(L"Deactivated=%p, Direction=%d",Deactivated,Direction));
if (Direction)
{
FramePos+=Direction;
if (Direction>0)
{
if (FramePos>=FrameCount)
{
FramePos=0;
}
}
else
{
if (FramePos<0)
{
FramePos=FrameCount-1;
}
}
ActivateFrame(FramePos);
}
else
{
// Direction==0
// Direct access from menu or (in future) from plugin
}
DeactivatedFrame=Deactivated;
}
void Manager::UpdateCommit()
{
_MANAGER(CleverSysLog clv(L"Manager::UpdateCommit()"));
_MANAGER(SysLog(L"DeletedFrame=%p, InsertedFrame=%p, ExecutedFrame=%p",DeletedFrame,InsertedFrame, ExecutedFrame));
if (ExecutedFrame)
{
DeleteCommit();
ExecuteCommit();
return;
}
int FrameIndex=IndexOf(DeletedFrame);
if (-1!=FrameIndex)
{
ActivateFrame(FrameList[FrameIndex] = InsertedFrame);
ActivatedFrame->FrameToBack=CurrentFrame;
DeleteCommit();
}
else
{
_MANAGER(SysLog(L"ERROR! DeletedFrame not found"));
}
}
static char Input (char* Prompt, char* Buf, unsigned char Count)
/* Read input from the user, return 1 on success, 0 if aborted */
{
int Frame;
unsigned char OldColor;
unsigned char OldCursor;
unsigned char x1;
unsigned char i;
unsigned char done;
char c;
/* Clear the current prompt line */
cclearxy (0, MAX_Y-1, MAX_X);
/* Display the new prompt */
OldColor = textcolor (COLOR_TEXTHIGH);
cputsxy (0, MAX_Y-1, Prompt);
(void) textcolor (COLOR_TEXTLOW);
/* Remember where we are, enable the cursor */
x1 = wherex ();
OldCursor = cursor (1);
/* Get input and handle it */
i = done = 0;
do {
c = cgetc ();
if (isalnum (c) && i < Count) {
Buf [i] = c;
cputcxy (x1 + i, MAX_Y-1, c);
++i;
} else if (i > 0 && c == CH_DEL) {
--i;
cputcxy (x1 + i, MAX_Y-1, ' ');
gotoxy (x1 + i, MAX_Y-1);
} else if (c == '\n') {
Buf [i] = '\0';
done = 1;
} else if (IsAbortKey (c)) {
/* Abort */
done = 2;
}
} while (!done);
/* Reset settings, display old prompt line */
cursor (OldCursor);
(void) textcolor (OldColor);
DrawFrames ();
Frame = ActiveFrame;
ActiveFrame = -1;
ActivateFrame (Frame, 0);
return (done == 1);
}
void Manager::ExecuteNonModal()
{
_MANAGER(CleverSysLog clv(L"Manager::ExecuteNonModal ()"));
_MANAGER(SysLog(L"ExecutedFrame=%p, InsertedFrame=%p, DeletedFrame=%p",ExecutedFrame, InsertedFrame, DeletedFrame));
Frame *NonModal=InsertedFrame?InsertedFrame:(ExecutedFrame?ExecutedFrame:ActivatedFrame);
if (!NonModal)
{
return;
}
/* $ 14.05.2002 SKV
Положим текущий фрэйм в список "родителей" полумодальных фрэймов
*/
//Frame *SaveFrame=CurrentFrame;
//AddSemiModalBackFrame(SaveFrame);
int NonModalIndex=IndexOf(NonModal);
if (-1==NonModalIndex)
{
InsertedFrame=NonModal;
ExecutedFrame=nullptr;
InsertCommit();
InsertedFrame=nullptr;
}
else
{
ActivateFrame(NonModalIndex);
}
//Frame* ModalStartLevel=NonModal;
for (;;)
{
Commit();
if (CurrentFrame!=NonModal || EndLoop)
{
break;
}
ProcessMainLoop();
}
//ExecuteModal(NonModal);
/* $ 14.05.2002 SKV
... и уберём его же.
*/
//RemoveSemiModalBackFrame(SaveFrame);
}
BOOL Manager::IsAnyFrameModified(int Activate)
{
for (int I=0; I<FrameCount; I++)
if (FrameList[I]->IsFileModified())
{
if (Activate)
{
ActivateFrame(I);
Commit();
}
return TRUE;
}
return FALSE;
}
static char HelpHandler (void)
/* Get characters and handle them */
{
/* Activate the frame */
int OldActive = ActiveFrame;
ActivateFrame (WIN_HELP, 1);
/* Say that we're waiting for a key */
AnyKeyPrompt ();
/* Get a character and discard it */
cgetc ();
/* Redraw the old stuff */
Redraw (OldActive);
/* Done, return no char */
return 0;
}
/* $ 29.12.2000 IS
Аналог CloseAll, но разрешает продолжение полноценной работы в фаре,
если пользователь продолжил редактировать файл.
Возвращает TRUE, если все закрыли и можно выходить из фара.
*/
BOOL Manager::ExitAll()
{
_MANAGER(CleverSysLog clv(L"Manager::ExitAll()"));
for (int i=this->ModalStackCount-1; i>=0; i--)
{
Frame *iFrame=this->ModalStack[i];
if (!iFrame->GetCanLoseFocus(TRUE))
{
int PrevFrameCount=ModalStackCount;
iFrame->ProcessKey(KEY_ESC);
Commit();
if (PrevFrameCount==ModalStackCount)
{
return FALSE;
}
}
}
for (int i=FrameCount-1; i>=0; i--)
{
Frame *iFrame=FrameList[i];
if (!iFrame->GetCanLoseFocus(TRUE))
{
ActivateFrame(iFrame);
Commit();
int PrevFrameCount=FrameCount;
iFrame->ProcessKey(KEY_ESC);
Commit();
if (PrevFrameCount==FrameCount)
{
return FALSE;
}
}
}
return TRUE;
}
static void RedrawStatic (char Frame)
/* Redraw static display stuff */
{
/* Reset the active frame */
ActiveFrame = -1;
/* Clear the screen hide the cursor */
(void) bordercolor (COLOR_BORDER);
(void) bgcolor (COLOR_BACKGROUND);
clrscr ();
cursor (0);
/* Build the frame layout of the screen */
(void) textcolor (COLOR_FRAMELOW);
DrawFrames ();
/* Draw the prompt line */
HelpPrompt ();
/* Activate the active frame */
ActivateFrame (Frame, 0);
}
void Manager::ActivateFrame(int Index)
{
_MANAGER(CleverSysLog clv(L"Manager::ActivateFrame(int Index)"));
_MANAGER(SysLog(L"Index=%i",Index));
ActivateFrame((*this)[Index]);
}
/*!
\return Возвращает nullptr если нажат "отказ" или если нажат текущий фрейм.
Другими словами, если немодальный фрейм не поменялся.
Если же фрейм поменялся, то тогда функция должна возвратить
указатель на предыдущий фрейм.
*/
Frame *Manager::FrameMenu()
{
/* $ 28.04.2002 KM
Флаг для определения того, что меню переключения
экранов уже активировано.
*/
static int AlreadyShown=FALSE;
if (AlreadyShown)
return nullptr;
int ExitCode, CheckCanLoseFocus=CurrentFrame->GetCanLoseFocus();
{
MenuItemEx ModalMenuItem;
VMenu2 ModalMenu(MSG(MScreensTitle),nullptr,0,ScrY-4);
ModalMenu.SetHelp(L"ScrSwitch");
ModalMenu.SetFlags(VMENU_WRAPMODE);
ModalMenu.SetPosition(-1,-1,0,0);
if (!CheckCanLoseFocus)
ModalMenuItem.SetDisable(TRUE);
for (int I=0; I<FrameCount; I++)
{
string strType, strName, strNumText;
FrameList[I]->GetTypeAndName(strType, strName);
ModalMenuItem.Clear();
if (I<10)
strNumText.Format(L"&%d. ",I);
else if (I<36)
strNumText.Format(L"&%c. ",I+55); // 55='A'-10
else
strNumText = L"& ";
//TruncPathStr(strName,ScrX-24);
ReplaceStrings(strName,L"&",L"&&",-1);
/* добавляется "*" если файл изменен */
ModalMenuItem.strName.Format(L"%s%-10.10s %c %s", strNumText.CPtr(), strType.CPtr(),(FrameList[I]->IsFileModified()?L'*':L' '), strName.CPtr());
ModalMenuItem.SetSelect(I==FramePos);
ModalMenu.AddItem(&ModalMenuItem);
}
AlreadyShown=TRUE;
ExitCode=ModalMenu.Run();
AlreadyShown=FALSE;
}
if (CheckCanLoseFocus)
{
if (ExitCode>=0)
{
ActivateFrame(ExitCode);
return (ActivatedFrame==CurrentFrame || !CurrentFrame->GetCanLoseFocus()?nullptr:CurrentFrame);
}
return (ActivatedFrame==CurrentFrame?nullptr:CurrentFrame);
}
return nullptr;
}
void CBMPFrame::OnViewOriginSize()
{
// TODO: 여기에 명령 처리기 코드를 추가합니다.
ActivateFrame();
}
void DbgEntry (void)
/* Start up the debugger */
{
static unsigned char FirstTime = 1;
char c;
char done;
/* If this is the first call, setup the display */
if (FirstTime) {
FirstTime = 0;
/* Draw the window, default active frame is ASM frame */
RedrawStatic (WIN_ASM);
InitAsm ();
InitReg ();
InitStack ();
InitCStack ();
UpdateDump ();
}
/* Only initialize variables here, don't do a display update. The actual
* display update will be done while waiting for user input.
*/
AsmHome ();
UpdateReg (); /* Must update this (static later) */
StackHome ();
CStackHome ();
/* Wait for user input */
done = 0;
while (!done) {
c = Frames [ActiveFrame]->fd_func ();
switch (c) {
case '1':
case '2':
case '3':
case '4':
case '5':
ActivateFrame (c - '1', 0);
break;
case '?':
#ifdef CH_F1
case CH_F1:
#endif
HelpHandler ();
break;
case 'u':
#ifdef CH_F3
case CH_F3:
#endif
/* Go until return */
SetRTSBreak ();
done = 1;
break;
case 'h':
#ifdef CH_F4
case CH_F4:
#endif
/* Go to cursor, only possible if cursor not at current PC */
if (AsmAddr != brk_pc) {
DbgSetTmpBreak (AsmAddr);
done = 1;
}
break;
case ' ':
#ifdef CH_F7
case CH_F7:
#endif
SingleStep (1);
if (DbgTmpBreaksOk ()) {
/* Could set breakpoints */
done = 1;
}
break;
case '\n':
#ifdef CH_F8
case CH_F8:
#endif
SingleStep (0);
if (DbgTmpBreaksOk ()) {
/* Could set breakpoints */
done = 1;
}
break;
case 'c':
case 0:
done = 1;
break;
case 's':
/* Skip instruction */
brk_pc += DbgDisAsmLen (brk_pc);
InitAsm ();
break;
case 'r':
/* Redraw screen */
Redraw (ActiveFrame);
break;
case 'q':
/* Quit program */
clrscr ();
exit (1);
}
}
}
void Manager::SwitchToPanels()
{
_MANAGER(CleverSysLog clv(L"Manager::SwitchToPanels()"));
ActivateFrame(0);
}
bool CMainFrame::SetLanguageMenu()
{
CMenu* pParentMenu = GetMenu();
CMenu* pMenu = GetMenu()->GetSubMenu( m_nLangOptionMenuPos );
CUStringConvert strCnv;
ASSERT( pMenu );
if ( NULL == m_pPopupMenu )
{
m_pPopupMenu = new CMenu;
m_pPopupMenu->CreatePopupMenu();
CUString strAdd( g_language.GetString( IDS_CHECKFORADDITIONAL_LANGUAGE_FILES ) );
CUStringConvert strCnv;
// Add Check for Updates
m_pPopupMenu->AppendMenu( MF_STRING | MF_ENABLED, ID_LANGUAGE_START, strCnv.ToT( strAdd ) );
// Add language menu items
for ( DWORD idx = 0; idx < g_language.GetNumLanguageStrings() ; idx++ )
{
CUString strAdd( g_language.GetLanguageString( idx ) );
m_pPopupMenu->AppendMenu( MF_STRING | MF_ENABLED, ID_LANGUAGE_START + idx + 1, strCnv.ToT( strAdd ) );
}
}
CString strCurrent;
pMenu->GetMenuString( m_nLangLangMenuPos, strCurrent, MF_BYPOSITION );
// Add language menu items
for ( DWORD idx = 0; idx < m_pPopupMenu->GetMenuItemCount(); idx++ )
{
CString strMenu;
if ( 0 == idx )
{
m_pPopupMenu->ModifyMenu( idx,
MF_BYPOSITION | MF_STRING,
ID_LANGUAGE_START,
strCnv.ToT( g_language.GetString( IDS_CHECKFORADDITIONAL_LANGUAGE_FILES ) ));
}
// get menu string
m_pPopupMenu->GetMenuString( idx, strMenu, MF_BYPOSITION );
// check if this is the selected language
if ( 0 == g_language.GetLanguage().CompareNoCase( CUString( strMenu ) ) )
{
m_pPopupMenu->CheckMenuItem( idx, MF_BYPOSITION | MF_CHECKED );
}
else
{
m_pPopupMenu->CheckMenuItem( idx, MF_BYPOSITION | MF_UNCHECKED );
}
}
// remove exisiting menu item
pMenu->RemoveMenu( m_nLangLangMenuPos, MF_BYPOSITION );
// insert new popup menu
pMenu->InsertMenu( m_nLangLangMenuPos,
MF_BYPOSITION | MF_POPUP,
(UINT)m_pPopupMenu->m_hMenu,
strCurrent );
// peform translation
g_language.TranslateMenu( GetMenu(), m_nMenuID );
// refresh frame windows
ActivateFrame( SW_HIDE );
ActivateFrame( SW_SHOW );
return true;
}
//! Удаляет DeletedFrame изо всех очередей!
//! Назначает следующий активный, (исходя из своих представлений)
//! Но только в том случае, если активный фрейм еще не назначен заранее.
void Manager::DeleteCommit()
{
_MANAGER(CleverSysLog clv(L"Manager::DeleteCommit()"));
_MANAGER(SysLog(L"DeletedFrame=%p",DeletedFrame));
if (!DeletedFrame)
{
return;
}
// <ifDoubleInstance>
//BOOL ifDoubI=ifDoubleInstance(DeletedFrame);
// </ifDoubleInstance>
int ModalIndex=IndexOfStack(DeletedFrame);
if (ModalIndex!=-1)
{
/* $ 14.05.2002 SKV
Надёжнее найти и удалить именно то, что
нужно, а не просто верхний.
*/
for (int i=0; i<ModalStackCount; i++)
{
if (ModalStack[i]==DeletedFrame)
{
for (int j=i+1; j<ModalStackCount; j++)
{
ModalStack[j-1]=ModalStack[j];
}
ModalStackCount--;
break;
}
}
if (ModalStackCount)
{
ActivateFrame(ModalStack[ModalStackCount-1]);
}
}
for (int i=0; i<FrameCount; i++)
{
if (FrameList[i]->FrameToBack==DeletedFrame)
{
FrameList[i]->FrameToBack=CtrlObject->Cp();
}
}
int FrameIndex=IndexOf(DeletedFrame);
if (-1!=FrameIndex)
{
DeletedFrame->DestroyAllModal();
for (int j=FrameIndex; j<FrameCount-1; j++)
{
FrameList[j]=FrameList[j+1];
}
FrameCount--;
if (FramePos >= FrameCount)
{
FramePos=0;
}
if (DeletedFrame->FrameToBack==CtrlObject->Cp())
{
ActivateFrame(FrameList[FramePos]);
}
else
{
ActivateFrame(DeletedFrame->FrameToBack);
}
}
/* $ 14.05.2002 SKV
Долго не мог понять, нужен всё же этот код или нет.
Но вроде как нужен.
SVS> Когда понадобится - в некоторых местах расскомментить куски кода
помеченные скобками <ifDoubleInstance>
if (ifDoubI && IsSemiModalBackFrame(ActivatedFrame)){
for(int i=0;i<ModalStackCount;i++)
{
if(ModalStack[i]==ActivatedFrame)
{
break;
}
}
if(i==ModalStackCount)
{
if (ModalStackCount == ModalStackSize){
ModalStack = (Frame **) xf_realloc (ModalStack, ++ModalStackSize * sizeof (Frame *));
}
ModalStack[ModalStackCount++]=ActivatedFrame;
}
}
*/
DeletedFrame->OnDestroy();
if (CurrentFrame==DeletedFrame)
{
CurrentFrame=0;
InterlockedExchange(&CurrentWindowType,-1);
}
if (DeletedFrame->GetDynamicallyBorn())
{
_MANAGER(SysLog(L"delete DeletedFrame %p", DeletedFrame));
/* $ 14.05.2002 SKV
Так как в деструкторе фрэйма неявно может быть
вызван commit, то надо подстраховаться.
*/
Frame *tmp=DeletedFrame;
DeletedFrame=nullptr;
delete tmp;
}
// Полагаемся на то, что в ActevateFrame не будет переписан уже
// присвоенный ActivatedFrame
if (ModalStackCount)
{
ActivateFrame(ModalStack[ModalStackCount-1]);
}
else
{
ActivateFrame(FramePos);
}
}
void CMainFrame::OnFileOpen()
{
CFileDialog dlg(
TRUE,
_T("UI state"),
_T(".\\Default.UI state"),
OFN_ENABLESIZING|OFN_EXPLORER
|OFN_LONGNAMES|OFN_PATHMUSTEXIST|OFN_FILEMUSTEXIST
|OFN_NOCHANGEDIR|OFN_NODEREFERENCELINKS
,
_T("UI state files (*.UI state)|*.UI state|All files (*.*)|*.*||"),
this
);
dlg.m_ofn.lpstrTitle = _T("Open UI state from file");
if( dlg.DoModal() != IDOK )
return;
ASSERT( dlg.m_ofn.lpstrFile != NULL );
try
{
CFile _file(
dlg.m_ofn.lpstrFile,
CFile::modeRead|CFile::shareExclusive
);
CArchive ar( &_file, CArchive::load);
CWinApp * pApp = ::AfxGetApp();
ASSERT( pApp != NULL );
ASSERT( pApp->m_pszRegistryKey != NULL );
ASSERT( pApp->m_pszRegistryKey[0] != _T('\0') );
ASSERT( pApp->m_pszProfileName != NULL );
ASSERT( pApp->m_pszProfileName[0] != _T('\0') );
VERIFY(
CExtControlBar::ProfileBarStateSerialize(
ar,
this,
&m_dataFrameWP
)
);
VERIFY(
g_CmdManager->SerializeState(
pApp->m_pszProfileName,
ar
)
);
ActivateFrame( SW_SHOW );
} // try
catch( CException * pXept )
{
CString sErrorDescription;
VERIFY(
pXept->GetErrorMessage(
sErrorDescription.GetBuffer(8192), 8192
)
);
sErrorDescription.ReleaseBuffer();
ASSERT( !sErrorDescription.IsEmpty() );
pXept->Delete();
MessageBox(
LPCTSTR(sErrorDescription),
_T("State load failed"),
MB_ICONERROR
);
} // catch( CException * pXept )
catch( ... )
{
MessageBox(
_T("Unknown exception caught"),
_T("State load failed"),
MB_ICONERROR
);
} // catch( ... )
}
bool ViewerIBA::OnKeyDown(int key) {
#ifdef __linux__
if (key == VW_KEY_CTRL_KEY_VALUE) {
m_ctrlDown = true;
return true;
}
if (m_ctrlDown) {
key = key - 'a' + 1;
}
#endif
if (Viewer::OnKeyDown(key)) {
return true;
}
//#ifdef CFG_DEBUG
#if 0
//#if 1
UT::Print("%d\n", key);
#endif
//#ifdef CFG_DEBUG
#if 0
if (key == '+' || key == '-') {
Camera &C = m_LBA->m_CsLF[m_iLFActive];
if (key == '+') {
C.m_p.y() += 0.1f;
} else {
C.m_p.y() -= 0.1f;
}
C.m_T.SetPosition(C.m_p);
return true;
}
#endif
#ifdef CFG_STEREO
if (key == '1' || key == '2') {
ActivateCamera(key == '2');
return true;
}
#endif
const int nKFs = GetKeyFrames();
const bool activeKF = m_iFrmActive < nKFs;
switch (key) {
case VW_KEY_XD_DRAW_VIEW_TYPE:
if (m_keyDrawViewType == DRAW_VIEW_PROFILE) {
m_keyDrawViewType = m_keyDrawViewTypeBkp;
} else {
m_keyDrawViewType.Press();
}
return true;
case VW_KEY_XD_PAUSE: m_keyPause.Press(); return true;
case VW_KEY_XD_STEP: m_keyStep.Press(); return true;
case VW_KEY_XD_SAVE:
if (m_fileNameSave == "") {
m_fileNameSave = UT::Input<std::string>("save_file");
}
m_iFrmSave = GetLocalFrame(m_iLF)->m_T.m_iFrm;
m_keyStep.Press();
//m_handler.Quit();
return true;
case VW_KEY_XD_SCREEN:
if (m_fileNameScreen == "") {
m_fileNameScreen = UT::Input<std::string>("screen_file");
}
if (m_fileNameScreen != "" && UT::FileNameExtractSuffix<int>(m_fileNameScreen) == -1) {
bool resize = m_pWnd->size().x != m_K.m_K.w() || m_pWnd->size().y != m_K.m_K.h();
if (resize) {
const char inp = UT::Input<char>("resize (y/n)");
if (inp != 'y' && inp != 'Y') {
resize = false;
}
}
SaveScreen(UT::FileNameAppendSuffix(m_fileNameScreen), resize);
}
return true;
//case VW_KEY_XD_ACTIVATE_NEXT_FRAME: ActivateFrame(m_iFrmActive + 1); return true;
//case VW_KEY_XD_ACTIVATE_LAST_FRAME: ActivateFrame(m_iFrmActive - 1); return true;
case VW_KEY_XD_ACTIVATE_NEXT_FRAME:
case VW_KEY_XD_ACTIVATE_LAST_FRAME: {
const bool next = key == VW_KEY_XD_ACTIVATE_NEXT_FRAME;
int iFrm = next ? m_iFrmActive + 1 : m_iFrmActive - 1;
if (m_iFtrActive.Valid()) {
const int nLFs = GetLocalFrames(), nFrms = nKFs + nLFs;
const int iKF = m_iFtrActive.m_ix.m_iKF, ix = m_iFtrActive.m_ix.m_ix;
while (iFrm >= 0 && iFrm < nFrms && iFrm != iKF) {
const FRM::Frame &F = *(iFrm < nKFs ? GetKeyFrame(iFrm) :
GetLocalFrame((iFrm - nKFs + m_iLF + 1) % nLFs));
const int iz = F.SearchFeatureMeasurement(iKF, ix);
if (iz != -1
#ifdef CFG_STEREO
&& (!m_rightActive && F.m_zs[iz].m_z.Valid() || m_rightActive && F.m_zs[iz].m_zr.Valid())
#endif
) {
break;
}
iFrm = next ? iFrm + 1 : iFrm - 1;
}
}
ActivateFrame(iFrm);
return true;
}
case VW_KEY_XD_ACTIVATE_KEY_FRAME:
if (m_iFtrActive.m_ix.Valid()) {
ActivateFrame(m_iFtrActive.m_ix.m_iKF);
} else {
ActivateFrame(m_iKFActive);
}
return true;
case VW_KEY_XD_ACTIVATE_LOCAL_FRAME:
if (m_iFtrActive.m_iz.Valid() && m_iFtrActive.m_iz.m_iLF != -1) {
ActivateLocalFrame(m_iFtrActive.m_iz.m_iLF);
} else if (activeKF) {
ActivateLocalFrame(m_iLFActive);
} else {
ActivateLocalFrame(m_iLFActiveLast);
}
return true;
case VW_KEY_XD_ACTIVATE_CURRENT_FRAME:
ActivateLocalFrame(m_iLF);
return true;
case VW_KEY_XD_DRAW_CAMERA_TYPE_NEXT:
case VW_KEY_XD_DRAW_CAMERA_TYPE_LAST:
if (activeKF) {
m_keyDrawCamTypeKF.Press(key == VW_KEY_XD_DRAW_CAMERA_TYPE_NEXT, false);
switch (m_keyDrawCamTypeKF) {
case DRAW_CAM_KF_LBA:
m_keyDrawCamTypeLF = DRAW_CAM_LF_LBA;
m_keyDrawDepType = DRAW_DEP_LBA;
break;
case DRAW_CAM_KF_GBA:
m_keyDrawDepType = DRAW_DEP_GBA;
break;
#ifdef CFG_GROUND_TRUTH
case DRAW_CAM_KF_GT:
m_keyDrawCamTypeLF = DRAW_CAM_LF_GT;
if (!m_solver->m_internal->m_DsGT.empty()) {
m_keyDrawDepType = DRAW_DEP_GT;
}
break;
#endif
}
} else {
m_keyDrawCamTypeLF.Press(key == VW_KEY_XD_DRAW_CAMERA_TYPE_NEXT, false);
switch (m_keyDrawCamTypeLF) {
case DRAW_CAM_LF_LBA:
m_keyDrawCamTypeKF = DRAW_CAM_KF_LBA;
m_keyDrawDepType = DRAW_DEP_LBA;
break;
#ifdef CFG_GROUND_TRUTH
case DRAW_CAM_LF_GT:
m_keyDrawCamTypeKF = DRAW_CAM_KF_GT;
if (!m_solver->m_internal->m_DsGT.empty()) {
m_keyDrawDepType = DRAW_DEP_GT;
}
break;
#endif
}
}
ActivateFrame(m_iFrmActive);
return true;
#ifdef CFG_GROUND_TRUTH
case VW_KEY_XD_DRAW_CAMERA_TYPE_GROUND_TRUTH:
if (activeKF && m_keyDrawCamTypeKF == DRAW_CAM_KF_GT) {
m_keyDrawCamTypeKF.Set(DRAW_CAM_KF_GBA);
m_keyDrawDepType = DRAW_DEP_GBA;
} else if (!activeKF && m_keyDrawCamTypeLF == DRAW_CAM_LF_GT) {
m_keyDrawCamTypeKF.Set(DRAW_CAM_KF_LBA);
m_keyDrawCamTypeLF = DRAW_CAM_LF_LBA;
m_keyDrawDepType = DRAW_DEP_LBA;
} else if (activeKF && GetCameraKF(m_iKFActive, DRAW_CAM_KF_GT).Valid() ||
!activeKF && GetCameraLF(m_iLFActive, DRAW_CAM_LF_GT).Valid()) {
m_keyDrawCamTypeKF.Set(DRAW_CAM_KF_GT);
m_keyDrawCamTypeLF = DRAW_CAM_LF_GT;
if (!m_solver->m_internal->m_DsGT.empty()) {
m_keyDrawDepType = DRAW_DEP_GT;
}
}
ActivateFrame(m_iFrmActive);
return true;
#endif
case VW_KEY_XD_DRAW_DEPTH_TYPE_NEXT:
case VW_KEY_XD_DRAW_DEPTH_TYPE_LAST:
m_keyDrawDepType.Press(key == VW_KEY_XD_DRAW_DEPTH_TYPE_NEXT, false);
return true;
case VW_KEY_XD_DRAW_STRING: m_keyDrawString.Press(); return true;
case VW_KEY_XD_DRAW_TIME_LINE: m_keyDrawTlnType.Press(); return true;
case VW_KEY_XD_DRAW_TIME_LINE_BRIGHTNESS_INCREASE_1:
case VW_KEY_XD_DRAW_TIME_LINE_BRIGHTNESS_DECREASE_1:
case VW_KEY_XD_DRAW_TIME_LINE_BRIGHTNESS_INCREASE_2:
case VW_KEY_XD_DRAW_TIME_LINE_BRIGHTNESS_DECREASE_2:
if (m_keyDrawTlnType == DRAW_TLN_FEATURE_MATCH) {
m_keyDrawTlnMaxFtrMatches.Press(key == VW_KEY_XD_DRAW_TIME_LINE_BRIGHTNESS_DECREASE_1 ||
key == VW_KEY_XD_DRAW_TIME_LINE_BRIGHTNESS_DECREASE_2);
} else if (key == VW_KEY_XD_DRAW_TIME_LINE_BRIGHTNESS_INCREASE_1 ||
key == VW_KEY_XD_DRAW_TIME_LINE_BRIGHTNESS_DECREASE_1) {
m_keyDrawTlnPriorVarPos.Press(key == VW_KEY_XD_DRAW_TIME_LINE_BRIGHTNESS_INCREASE_1);
} else {
m_keyDrawTlnPriorVarRot.Press(key == VW_KEY_XD_DRAW_TIME_LINE_BRIGHTNESS_INCREASE_2);
}
return true;
}
if (m_keyDrawViewType == DRAW_VIEW_2D || m_keyDrawViewType == DRAW_VIEW_3D) {
switch (key) {
case VW_KEY_XD_DRAW_AXIS:
m_keyDrawAxis.Press();
return true;
case VW_KEY_XD_DRAW_AXIS_LENGTH_INCREASE:
case VW_KEY_XD_DRAW_AXIS_LENGTH_DECREASE:
if (m_keyDrawAxis != DRAW_AXIS_NONE) {
m_keyDrawAxisLen.Press(key == VW_KEY_XD_DRAW_AXIS_LENGTH_INCREASE);
m_frustrum.SetAxisLength(m_keyDrawAxisLen);
m_frustrumActive.SetAxisLength(m_keyDrawAxisLen);
return true;
}
break;
case VW_KEY_XD_DRAW_DEPTH_PLANE:
m_keyDrawDepPlane.Press();
return true;
case VW_KEY_XD_DRAW_DEPTH_VARIANCE_INCREASE:
case VW_KEY_XD_DRAW_DEPTH_VARIANCE_DECREASE:
m_keyDrawDepVar.Press(key == VW_KEY_XD_DRAW_DEPTH_VARIANCE_INCREASE);
return true;
case VW_KEY_XD_DRAW_COVARIANCE_PROBABILITY_INCREASE:
case VW_KEY_XD_DRAW_COVARIANCE_PROBABILITY_DECREASE:
if (m_keyDrawTlnType != DRAW_TLN_NONE ||
(m_keyDrawViewType == DRAW_VIEW_2D && (m_keyDrawErrType2D == DRAW_ERR_ALL ||
m_keyDrawErrType2D == DRAW_ERR_COVARIANCE)) ||
(m_keyDrawViewType == DRAW_VIEW_3D && (m_keyDrawErrType3D == DRAW_ERR_ALL ||
m_keyDrawErrType3D == DRAW_ERR_COVARIANCE))) {
m_keyDrawCovProb.Press(key == VW_KEY_XD_DRAW_COVARIANCE_PROBABILITY_INCREASE);
return true;
}
break;
case VW_KEY_XD_DRAW_COVARIANCE_SCALE_INCREASE:
case VW_KEY_XD_DRAW_COVARIANCE_SCALE_DECREASE:
if (m_keyDrawTlnType != DRAW_TLN_NONE ||
(m_keyDrawViewType == DRAW_VIEW_2D && (m_keyDrawErrType2D == DRAW_ERR_ALL ||
m_keyDrawErrType2D == DRAW_ERR_COVARIANCE)
|| m_keyDrawViewType == DRAW_VIEW_3D && (m_keyDrawErrType3D == DRAW_ERR_ALL ||
m_keyDrawErrType3D == DRAW_ERR_COVARIANCE))) {
m_keyDrawCovScale.Press(key == VW_KEY_XD_DRAW_COVARIANCE_SCALE_INCREASE);
return true;
}
break;
case VW_KEY_XD_INPUT_ACTIVE_FEATURE: {
const int iFrm = UT::Input<int>(" Frame");
const std::vector<KeyFrame>::const_iterator iKF = std::lower_bound(m_GBA->m_KFs.begin(),
m_GBA->m_KFs.end(), iFrm);
if (iKF != m_GBA->m_KFs.end() && *iKF == iFrm) {
const int ix = UT::Input<int>("Source");
if (ix < 0 || ix >= static_cast<int>(iKF->m_xs.size())) {
return false;
}
const int _iKF = static_cast<int>(iKF - m_GBA->m_KFs.begin());
const FRM::Frame &F = *(activeKF ? GetKeyFrame(m_iKFActive) : GetLocalFrame(m_iLFActive));
const int iz = F.SearchFeatureMeasurement(_iKF, ix);
ActivateFeature(FeatureIndex::Source(_iKF, ix), iz);
}
return false;
}
case VW_KEY_PROFILE_ACTIVATE:
if (m_keyDrawViewType != DRAW_VIEW_PROFILE) {
m_keyDrawViewTypeBkp = m_keyDrawViewType;
m_keyDrawViewType = DRAW_VIEW_PROFILE;
}
return true;
}
} else if (m_keyDrawViewType == DRAW_VIEW_PROFILE) {
switch (key) {
case VW_KEY_PROFILE_ACTIVATE:
m_keyDrawViewType = m_keyDrawViewTypeBkp;
return true;
case VM_KEY_PROFILE_LEVEL_1_NEXT:
case VM_KEY_PROFILE_LEVEL_1_LAST: {
const int types[] = {DRAW_PRF_ACCELERATION, DRAW_PRF_IMU_DELTA_ROTATION_STATE,
DRAW_PRF_CAMERA_PRIOR_ROTATION_STATE, DRAW_PRF_REPROJECTION_ERROR,
DRAW_PRF_STATE_ROTATION_ABSOLUTE,
DRAW_PRF_TYPES};
const int N = sizeof(types) / sizeof(int);
DrawProfileTypeStep(types, N, key == VM_KEY_PROFILE_LEVEL_1_NEXT);
return true; }
case VM_KEY_PROFILE_LEVEL_2_NEXT:
case VM_KEY_PROFILE_LEVEL_2_LAST: {
const int types[] = {DRAW_PRF_ACCELERATION, DRAW_PRF_GYROSCOPE,
DRAW_PRF_IMU_DELTA_ROTATION_STATE,
DRAW_PRF_IMU_DELTA_POSITION_STATE,
DRAW_PRF_IMU_DELTA_VELOCITY_STATE,
DRAW_PRF_IMU_DELTA_BIAS_ACCELERATION_STATE,
DRAW_PRF_IMU_DELTA_BIAS_GYROSCOPE_STATE,
DRAW_PRF_CAMERA_PRIOR_ROTATION_STATE,
DRAW_PRF_CAMERA_PRIOR_POSITION_STATE,
DRAW_PRF_CAMERA_PRIOR_VELOCITY_STATE,
DRAW_PRF_CAMERA_PRIOR_BIAS_ACCELERATION_STATE,
DRAW_PRF_CAMERA_PRIOR_BIAS_GYROSCOPE_STATE,
DRAW_PRF_REPROJECTION_ERROR,
DRAW_PRF_STATE_ROTATION_ABSOLUTE,
DRAW_PRF_STATE_POSITION_ABSOLUTE,
DRAW_PRF_STATE_VELOCITY,
DRAW_PRF_STATE_BIAS_ACCELERATION,
DRAW_PRF_STATE_BIAS_GYROSCOPE,
DRAW_PRF_TYPES};
const int N = sizeof(types) / sizeof(int);
DrawProfileTypeStep(types, N, key == VM_KEY_PROFILE_LEVEL_2_NEXT);
return true; }
case VM_KEY_PROFILE_LEVEL_3_NEXT:
case VM_KEY_PROFILE_LEVEL_3_LAST: {
const int typeBkp = m_keyDrawPrfType;
while (m_keyDrawPrfType.Press(key == VM_KEY_PROFILE_LEVEL_3_NEXT, false) &&
!DrawProfileTypeValid()) {}
if (!DrawProfileTypeValid()) {
m_keyDrawPrfType = typeBkp;
}
return true; }
}
}
if (m_keyDrawViewType == DRAW_VIEW_2D) {
switch (key) {
case VW_KEY_2D_DRAW_FEATURE_TYPE: m_keyDrawFtrType.Press(); return true;
case VW_KEY_2D_DRAW_PROJECTION_TYPE: m_keyDrawPrjType.Press(); return true;
case VW_KEY_2D_DRAW_ERROR_TYPE: m_keyDrawErrType2D.Press(); return true;
}
} else if (m_keyDrawViewType == DRAW_VIEW_3D) {
switch (key) {
case VW_KEY_3D_DRAW_MOTION_TYPE:
if (activeKF) {
m_keyDrawMotTypeKF.Press();
} else {
m_keyDrawMotTypeLF.Press();
}
return true;
case VW_KEY_3D_DRAW_STRUCTURE_TYPE:
m_keyDrawStrType.Press();
return true;
case VW_KEY_3D_DRAW_DEPTH_COMPARE_TYPE:
if (m_keyDrawErrType3D == DRAW_ERR_ALL || m_keyDrawErrType3D == DRAW_ERR_MEAN) {
m_keyDrawDepTypeCMP.Press();
//while(m_keyDrawDepTypeCMP == m_keyDrawDepType)
// m_keyDrawDepTypeCMP.Press();
}
return true;
case VW_KEY_3D_DRAW_CAMERA_SIZE_INCREASE:
case VW_KEY_3D_DRAW_CAMERA_SIZE_DECREASE:
m_keyDrawCamSize.Press(key == VW_KEY_3D_DRAW_CAMERA_SIZE_INCREASE);
m_frustrum.SetSize(m_keyDrawCamSize);
m_frustrumActive.SetSize(m_keyDrawCamSize * VW_CAMERA_SIZE_ACTIVE_RATIO);
return true;
case VW_KEY_3D_DRAW_CAMERA_VELOCITY: m_keyDrawCamVelocity.Press(); break;
case VW_KEY_3D_DRAW_CAMERA_TEXTURE: m_keyDrawCamTex.Press(); break;
#ifdef CFG_GROUND_TRUTH
case VW_KEY_3D_DRAW_CAMERA_GROUND_TRUTH: m_keyDrawCamGT.Press(); break;
#endif
case VW_KEY_3D_DRAW_ERROR_TYPE:
m_keyDrawErrType3D.Press();
return true;
case VW_KEY_3D_DRAW_BACKGROUND_COLOR:
m_keyDrawBgClr.Press();
Update3DBackgroundColor();
return true;
case VW_KEY_3D_RESET_VIEW_POINT_ACTIVE:
case VW_KEY_3D_RESET_VIEW_POINT_VIRTUAL:
Reset3DViewPoint(key == VW_KEY_3D_RESET_VIEW_POINT_ACTIVE);
return true;
}
}
return false;
}
