static void GrModeRows( short rows )
//==================================
{
short font;
switch( _CurrState->vc.mode ) {
case _ERESNOCOLOR:
case _ERESCOLOR:
switch( rows ) {
case 25:
font = GR_FONT_8x14; // 8x14
break;
case _MAXTEXTROWS:
rows = 43;
case 43:
font = GR_FONT_8x8; // 8x8
break;
default:
_ErrorStatus = _GRINVALIDPARAMETER;
return;
}
break;
case _VRES2COLOR:
case _VRES16COLOR:
switch( rows ) {
case 30:
font = GR_FONT_8x16; // 8x16
break;
case 34:
font = GR_FONT_8x14; // 8x14
break;
case _MAXTEXTROWS:
rows = 60;
case 60:
font = GR_FONT_8x8; // 8x8
break;
default:
_ErrorStatus = _GRINVALIDPARAMETER;
return;
}
break;
// 25 rows for all other graphics modes
default:
if (rows != 25) {
_ErrorStatus = _GRERROR;
}
return;
}
VideoInt( _BIOS_SET_MODE + GetVideoMode(), 0, 0, 0 );
// Load pointer to character set
if( _CurrState->vc.adapter == _EGA ) {
VideoInt( font, 0, 0, rows - 1 ); // do this only for the EGA
} else {
VideoInt( font, 0, 0, rows );
}
_GrCursor = 0; // cursor is off
}
XnStatus LinkOniMapStream::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = LinkOniStream::Init();
XN_IS_STATUS_OK(nRetVal);
nRetVal = FillSupportedVideoModes();
XN_IS_STATUS_OK(nRetVal);
// read video mode
XnChar videoModeSection[255];
sprintf(videoModeSection, "%s.VideoMode", m_configSection);
OniVideoMode videoMode;
GetVideoMode(&videoMode);
// override with streams default values
GetDefaultVideoMode(&videoMode);
// override with INI config
XnInt32 temp32;
if (XN_STATUS_OK == xnOSReadIntFromINI(m_configFile, videoModeSection, "XResolution", &temp32))
{
videoMode.resolutionX = (int)temp32;
}
if (XN_STATUS_OK == xnOSReadIntFromINI(m_configFile, videoModeSection, "YResolution", &temp32))
{
videoMode.resolutionY = (int)temp32;
}
if (XN_STATUS_OK == xnOSReadIntFromINI(m_configFile, videoModeSection, "FPS", &temp32))
{
videoMode.fps = (int)temp32;
}
if (XN_STATUS_OK == xnOSReadIntFromINI(m_configFile, videoModeSection, "PixelFormat", &temp32))
{
videoMode.pixelFormat = (OniPixelFormat)temp32;
}
nRetVal = SetVideoMode(&videoMode);
XN_IS_STATUS_OK(nRetVal);
nRetVal = setIntPropertyFromINI("LinkPixelFormat", LINK_PROP_PIXEL_FORMAT);
XN_IS_STATUS_OK(nRetVal);
nRetVal = setIntPropertyFromINI("Compression", LINK_PROP_COMPRESSION);
XN_IS_STATUS_OK(nRetVal);
OniBool bMirror = TRUE;
if (XN_STATUS_OK == xnOSReadIntFromINI(m_configFile, m_configSection, "Mirror", &temp32))
{
bMirror = (temp32 == 1);
}
nRetVal = SetMirror(bMirror);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
static void Load_25( void )
/*===================
When we want to go back to a 25-row display, just do a set mode
and update a few variables. */
{
VideoInt( _BIOS_SET_MODE + GetVideoMode(), 0, 0, 0 );
*(char far *)_BIOS_data( INFO ) &= 0xFE; // cursor emulation off
VideoInt( _BIOS_CURSOR_SIZE, 0, 0x0607, 0 ); // reset the cursor
_GrCursor = 1; // cursor is on
}
OniStatus LinkOniMapStream::getProperty(int propertyId, void* data, int* pDataSize)
{
XnStatus nRetVal = XN_STATUS_ERROR;
switch(propertyId)
{
case ONI_STREAM_PROPERTY_VIDEO_MODE:
EXACT_PROP_SIZE(*pDataSize, OniVideoMode);
nRetVal = GetVideoMode((OniVideoMode*)data);
XN_IS_STATUS_OK_RET(nRetVal, ONI_STATUS_ERROR);
break;
case ONI_STREAM_PROPERTY_MIRRORING:
EXACT_PROP_SIZE(*pDataSize, OniBool);
nRetVal = GetMirror((OniBool*)data);
XN_IS_STATUS_OK_RET(nRetVal, ONI_STATUS_ERROR);
break;
case ONI_STREAM_PROPERTY_CROPPING:
EXACT_PROP_SIZE(*pDataSize, OniCropping);
nRetVal = GetCropping(*(OniCropping*)data);
XN_IS_STATUS_OK_RET(nRetVal, ONI_STATUS_ERROR);
break;
case LINK_PROP_PIXEL_FORMAT:
ENSURE_PROP_SIZE(*pDataSize, XnLinkPixelFormat);
ASSIGN_PROP_VALUE_INT(data, *pDataSize, m_pInputStream->GetVideoMode().m_nPixelFormat);
break;
case LINK_PROP_COMPRESSION:
ENSURE_PROP_SIZE(*pDataSize, XnLinkCompressionType);
ASSIGN_PROP_VALUE_INT(data, *pDataSize, m_pInputStream->GetVideoMode().m_nCompression);
break;
case PS_PROPERTY_GAIN:
{
ENSURE_PROP_SIZE(*pDataSize, XnUInt16);
XnUInt16 gain;
nRetVal = m_pInputStream->GetGain(gain);
XN_IS_STATUS_OK_RET(nRetVal, ONI_STATUS_ERROR);
ASSIGN_PROP_VALUE_INT(data, *pDataSize, gain);
}
break;
default:
{
return LinkOniStream::getProperty(propertyId, data, pDataSize);
}
}
return ONI_STATUS_OK;
}
static void Load_VGA( short scan, short font, short cursor )
/*==========================================================
This routines loads an alphanumeric font for the VGA. */
{
VideoInt( scan, 0x0030, 0, 0 ); // becomes effective at next set mode
VideoInt( _BIOS_SET_MODE + GetVideoMode(), 0, 0, 0 );
VideoInt( _BIOS_VIDEO_PAGE, 0, 0, 0 ); // set active page to 0
VideoInt( font, 0, 0, 0 ); // load character set
VideoInt( _BIOS_CURSOR_SIZE, 0, cursor, 0 ); // reset the cursor
_GrCursor = 1; // cursor is on
}
OniStatus getProperty(int propertyId, void* data, int* pDataSize)
{
if (propertyId == ONI_STREAM_PROPERTY_VIDEO_MODE)
{
if (*pDataSize != sizeof(OniVideoMode))
{
printf("Unexpected size: %d != %d\n", *pDataSize, (int)sizeof(OniVideoMode));
return ONI_STATUS_ERROR;
}
return GetVideoMode((OniVideoMode*)data);
}
return ONI_STATUS_NOT_IMPLEMENTED;
}
static void Load_EGA( short rows, short font, short cursor )
/*==========================================================
This routines loads an alphanumeric font for the EGA. */
{
VideoInt( _BIOS_VIDEO_PAGE, 0, 0, 0 ); // set active page to 0
VideoInt( _BIOS_SET_MODE + GetVideoMode(), 0, 0, 0 );
VideoInt( font, 0, 0, 0 ); // load pointer to character set in block 0
if( rows == 43 ) { // cursor emulation
*(char far *)_BIOS_data( INFO ) |= 1; // 43 rows only
} else {
outpw( 0x03D4, 0x1414 ); // reset underline location to none
}
VideoInt( _BIOS_CURSOR_SIZE, 0, cursor, 0 ); // reset the cursor
_GrCursor = 1; // cursor is on
}
static void Load_MCGA( short rows, short font, short cursor )
/*===========================================================
This routines loads an alphanumeric font for the MCGA. */
{
VideoInt( _BIOS_VIDEO_PAGE, 0, 0, 0 ); // set active page to 0
VideoInt( _BIOS_SET_MODE + GetVideoMode(), 0, 0, 0 );
_fmemset( MK_FP( _EgaSeg, _EgaOff ), 0, 0x2000 ); // must do for MCGA 40 rows
VideoInt( font & 0xFF0F, 0, 0, 0 ); // load character set
VideoInt( 0x1103, 0, 0, 0 );
VideoInt( _BIOS_CURSOR_SIZE, 0, cursor, 0 ); // reset the cursor
outpw( 0x03D4, ( cursor & 0xFF00 ) + 0x09 ); // # double scan lines
*(char far *)_BIOS_data( ROWS ) = rows - 1; // # of rows
// # of vertical points per character
*(short far *)_BIOS_data( POINTS ) = 2 * ( cursor & 0xFF + 1 );
_GrCursor = 1; // cursor is on
}
XnStatus LinkOniMapStream::SetVideoMode(OniVideoMode* pVideoMode)
{
XnStatus nRetVal = XN_STATUS_OK;
OniVideoMode current;
GetVideoMode(¤t);
if (!xnOSMemCmp(¤t, pVideoMode, sizeof(OniVideoMode)))
{
// nothing to do here
return (ONI_STATUS_OK);
}
// now look for the first mode that matches
const xnl::Array<XnFwStreamVideoMode>& supportedModes = m_pInputStream->GetSupportedVideoModes();
XnInt32 selectedIndex = -1;
for (XnUInt32 i = 0; i < supportedModes.GetSize(); ++i)
{
if (pVideoMode->resolutionX == (int)supportedModes[i].m_nXRes &&
pVideoMode->resolutionY == (int)supportedModes[i].m_nYRes &&
pVideoMode->fps == (int)supportedModes[i].m_nFPS)
{
selectedIndex = i;
break;
}
}
if (selectedIndex == -1)
{
xnLogError(XN_MASK_LINK, "Tried to set unsupported mode: %ux%u@%u fps",
pVideoMode->resolutionX, pVideoMode->resolutionY, pVideoMode->fps);
XN_ASSERT(FALSE);
return XN_STATUS_BAD_PARAM;
}
nRetVal = m_pInputStream->SetVideoMode(supportedModes[selectedIndex]);
XN_IS_STATUS_OK_LOG_ERROR("Set video mode", nRetVal);
nRetVal = m_pInputStream->SetOutputFormat(pVideoMode->pixelFormat);
XN_IS_STATUS_OK_LOG_ERROR("Set output format", nRetVal);
return XN_STATUS_OK;
}
short _SetMode( short mode )
/*==========================
This function sets the video mode on IBM PC family. */
{
char __far *p;
if( _ValidMode( mode ) ) {
p = _BIOS_data( EQUIP_FLAGS ); // equipment flags
*p &= 0xCF; // remove previous settings
if( mode == 7 || mode == 15 ) {
*p |= 0x30; // monochrome
} else {
*p |= 0x20; // colour
}
if( _NoClear ) {
mode |= 0x80; // set high bit, screen won't be cleared
}
VideoInt( _BIOS_SET_MODE + mode, 0, 0, 0 );
}
return( GetVideoMode() );
}
void InitConsole(int FirstInit)
{
InitRecodeOutTable();
if (FirstInit)
{
CancelIoInProgress = std::make_unique<DECLTYPE(CancelIoInProgress)::element_type>();
CancelIoInProgress->Open(true);
DWORD Mode;
if(!Global->Console->GetMode(Global->Console->GetInputHandle(), Mode))
{
HANDLE ConIn = CreateFile(L"CONIN$", GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, nullptr, OPEN_EXISTING, 0, nullptr);
SetStdHandle(STD_INPUT_HANDLE, ConIn);
}
if(!Global->Console->GetMode(Global->Console->GetOutputHandle(), Mode))
{
HANDLE ConOut = CreateFile(L"CONOUT$", GENERIC_READ|GENERIC_WRITE, FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, 0, nullptr);
SetStdHandle(STD_OUTPUT_HANDLE, ConOut);
SetStdHandle(STD_ERROR_HANDLE, ConOut);
}
}
Global->Console->SetControlHandler(CtrlHandler, true);
Global->Console->GetMode(Global->Console->GetInputHandle(),InitialConsoleMode);
Global->Console->GetTitle(Global->strInitTitle);
Global->Console->GetWindowRect(InitWindowRect);
Global->Console->GetSize(InitialSize);
Global->Console->GetCursorInfo(InitialCursorInfo);
// размер клавиатурной очереди = 1024 кода клавиши
if (!KeyQueue)
KeyQueue = std::make_unique<DECLTYPE(KeyQueue)::element_type>();
SetFarConsoleMode();
/* $ 09.04.2002 DJ
если размер консольного буфера больше размера окна, выставим
их равными
*/
if (FirstInit)
{
SMALL_RECT WindowRect;
Global->Console->GetWindowRect(WindowRect);
Global->Console->GetSize(InitSize);
if(Global->Opt->WindowMode)
{
Global->Console->ResetPosition();
}
else
{
if (WindowRect.Left || WindowRect.Top || WindowRect.Right != InitSize.X-1 || WindowRect.Bottom != InitSize.Y-1)
{
COORD newSize;
newSize.X = WindowRect.Right - WindowRect.Left + 1;
newSize.Y = WindowRect.Bottom - WindowRect.Top + 1;
Global->Console->SetSize(newSize);
Global->Console->GetSize(InitSize);
}
}
if (IsZoomed(Global->Console->GetWindow()))
ChangeVideoMode(1);
}
GetVideoMode(CurSize);
Global->ScrBuf->FillBuf();
Global->ConsoleIcons->setFarIcons();
}
void CameraDriver::OpenCamera(UVCCameraConfig &new_config) {
assert(state_ == kStopped);
int vendor_id = strtol(new_config.vendor.c_str(), NULL, 0);
int product_id = strtol(new_config.product.c_str(), NULL, 0);
ROS_INFO("Opening camera with vendor=0x%x, product=0x%x, serial=\"%s\", index=%d",
vendor_id, product_id, new_config.serial.c_str(), new_config.index);
uvc_device_t **devs;
// Implement missing index select behavior
// https://github.com/ros-drivers/libuvc_ros/commit/4f30e9a0
#if libuvc_VERSION > 00005 /* version > 0.0.5 */
uvc_error_t find_err = uvc_find_devices(
ctx_, &devs,
vendor_id,
product_id,
new_config.serial.empty() ? NULL : new_config.serial.c_str());
if (find_err != UVC_SUCCESS) {
uvc_perror(find_err, "uvc_find_device");
return;
}
// select device by index
dev_ = NULL;
int dev_idx = 0;
while (devs[dev_idx] != NULL) {
if(dev_idx == new_config.index) {
dev_ = devs[dev_idx];
}
else {
uvc_unref_device(devs[dev_idx]);
}
dev_idx++;
}
if(dev_ == NULL) {
ROS_ERROR("Unable to find device at index %d", new_config.index);
return;
}
#else
uvc_error_t find_err = uvc_find_device(
ctx_, &dev_,
vendor_id,
product_id,
new_config.serial.empty() ? NULL : new_config.serial.c_str());
if (find_err != UVC_SUCCESS) {
uvc_perror(find_err, "uvc_find_device");
return;
}
#endif
uvc_error_t open_err = uvc_open(dev_, &devh_);
if (open_err != UVC_SUCCESS) {
switch (open_err) {
case UVC_ERROR_ACCESS:
#ifdef __linux__
ROS_ERROR("Permission denied opening /dev/bus/usb/%03d/%03d",
uvc_get_bus_number(dev_), uvc_get_device_address(dev_));
#else
ROS_ERROR("Permission denied opening device %d on bus %d",
uvc_get_device_address(dev_), uvc_get_bus_number(dev_));
#endif
break;
default:
#ifdef __linux__
ROS_ERROR("Can't open /dev/bus/usb/%03d/%03d: %s (%d)",
uvc_get_bus_number(dev_), uvc_get_device_address(dev_),
uvc_strerror(open_err), open_err);
#else
ROS_ERROR("Can't open device %d on bus %d: %s (%d)",
uvc_get_device_address(dev_), uvc_get_bus_number(dev_),
uvc_strerror(open_err), open_err);
#endif
break;
}
uvc_unref_device(dev_);
return;
}
uvc_set_status_callback(devh_, &CameraDriver::AutoControlsCallbackAdapter, this);
uvc_stream_ctrl_t ctrl;
uvc_error_t mode_err = uvc_get_stream_ctrl_format_size(
devh_, &ctrl,
GetVideoMode(new_config.video_mode),
new_config.width, new_config.height,
new_config.frame_rate);
if (mode_err != UVC_SUCCESS) {
uvc_perror(mode_err, "uvc_get_stream_ctrl_format_size");
uvc_close(devh_);
uvc_unref_device(dev_);
ROS_ERROR("check video_mode/width/height/frame_rate are available");
uvc_print_diag(devh_, NULL);
return;
}
uvc_error_t stream_err = uvc_start_streaming(devh_, &ctrl, &CameraDriver::ImageCallbackAdapter, this, 0);
if (stream_err != UVC_SUCCESS) {
uvc_perror(stream_err, "uvc_start_streaming");
uvc_close(devh_);
uvc_unref_device(dev_);
return;
}
if (rgb_frame_)
uvc_free_frame(rgb_frame_);
rgb_frame_ = uvc_allocate_frame(new_config.width * new_config.height * 3);
assert(rgb_frame_);
state_ = kRunning;
}
int singleRes(int x, int y) {
OniVideoMode mode;
GetVideoMode( &mode );
return y * mode.resolutionX + x;
}
unsigned int Context::GetHeight( void )
{
return GetVideoMode().Height;
}
unsigned int Context::GetWidth( void )
{
return GetVideoMode().Width;
}
void InitConsole(int FirstInit)
{
InitRecodeOutTable();
if (FirstInit)
{
DWORD Mode;
if(!Console.GetMode(Console.GetInputHandle(), Mode))
{
HANDLE ConIn = CreateFile(L"CONIN$", GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, nullptr, OPEN_EXISTING, 0, nullptr);
SetStdHandle(STD_INPUT_HANDLE, ConIn);
}
if(!Console.GetMode(Console.GetOutputHandle(), Mode))
{
HANDLE ConOut = CreateFile(L"CONOUT$", GENERIC_READ|GENERIC_WRITE, FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, 0, nullptr);
SetStdHandle(STD_OUTPUT_HANDLE, ConOut);
SetStdHandle(STD_ERROR_HANDLE, ConOut);
}
}
Console.SetControlHandler(CtrlHandler,TRUE);
Console.GetMode(Console.GetInputHandle(),InitialConsoleMode);
Console.GetTitle(strInitTitle);
Console.GetWindowRect(InitWindowRect);
Console.GetSize(InitialSize);
Console.GetCursorInfo(InitialCursorInfo);
// размер клавиатурной очереди = 1024 кода клавиши
if (!KeyQueue)
KeyQueue=new FarQueue<DWORD>(1024);
SetFarConsoleMode();
/* $ 09.04.2002 DJ
если размер консольного буфера больше размера окна, выставим
их равными
*/
if (FirstInit)
{
SMALL_RECT WindowRect;
Console.GetWindowRect(WindowRect);
GetVideoMode(InitSize);
if(Opt.WindowMode)
{
Console.ResetPosition();
}
else
{
if (WindowRect.Left || WindowRect.Top || WindowRect.Right != InitSize.X-1 || WindowRect.Bottom != InitSize.Y-1)
{
COORD newSize;
newSize.X = WindowRect.Right - WindowRect.Left + 1;
newSize.Y = WindowRect.Bottom - WindowRect.Top + 1;
Console.SetSize(newSize);
GetVideoMode(InitSize);
}
}
if (IsZoomed(Console.GetWindow()))
ChangeVideoMode(1);
}
GetVideoMode(CurSize);
ScrBuf.FillBuf();
ConsoleIcons.setFarIcons();
}
bool pwEngineOptions::GetScaled()
{
return (GetVideoMode().width < GetInternGraphicsSize().x || GetVideoMode().height < GetInternGraphicsSize().y);
}
void InitConsole(int FirstInit)
{
RegisterConsoleScrollHook();
InitRecodeOutTable();
if (FirstInit)
{
CancelIoInProgress() = Event(Event::manual, Event::nonsignaled);
DWORD Mode;
if(!Console().GetMode(Console().GetInputHandle(), Mode))
{
HANDLE ConIn = CreateFile(L"CONIN$", GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, nullptr, OPEN_EXISTING, 0, nullptr);
SetStdHandle(STD_INPUT_HANDLE, ConIn);
}
if(!Console().GetMode(Console().GetOutputHandle(), Mode))
{
HANDLE ConOut = CreateFile(L"CONOUT$", GENERIC_READ|GENERIC_WRITE, FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, 0, nullptr);
SetStdHandle(STD_OUTPUT_HANDLE, ConOut);
SetStdHandle(STD_ERROR_HANDLE, ConOut);
}
}
Console().SetControlHandler(CtrlHandler, true);
Console().GetMode(Console().GetInputHandle(),InitialConsoleMode);
Global->strInitTitle = Console().GetPhysicalTitle();
Console().GetWindowRect(InitWindowRect);
Console().GetSize(InitialSize);
Console().GetCursorInfo(InitialCursorInfo);
SetFarConsoleMode();
/* $ 09.04.2002 DJ
если размер консольного буфера больше размера окна, выставим
их равными
*/
if (FirstInit)
{
SMALL_RECT WindowRect;
Console().GetWindowRect(WindowRect);
Console().GetSize(InitSize);
if(Global->Opt->WindowMode)
{
Console().ResetPosition();
}
else
{
if (WindowRect.Left || WindowRect.Top || WindowRect.Right != InitSize.X-1 || WindowRect.Bottom != InitSize.Y-1)
{
COORD newSize;
newSize.X = WindowRect.Right - WindowRect.Left + 1;
newSize.Y = WindowRect.Bottom - WindowRect.Top + 1;
Console().SetSize(newSize);
Console().GetSize(InitSize);
}
}
if (IsZoomed(Console().GetWindow()))
ChangeVideoMode(1);
}
GetVideoMode(CurSize);
Global->ScrBuf->FillBuf();
ConsoleIcons().setFarIcons();
}
int Manager::ProcessKey(DWORD Key)
{
int ret=FALSE;
if (CurrentFrame)
{
DWORD KeyM=(Key&(~KEY_CTRLMASK));
if (!((KeyM >= KEY_MACRO_BASE && KeyM <= KEY_MACRO_ENDBASE) || (KeyM >= KEY_OP_BASE && KeyM <= KEY_OP_ENDBASE))) // пропустим макро-коды
{
switch (CurrentFrame->GetType())
{
case MODALTYPE_PANELS:
{
_ALGO(CleverSysLog clv(L"Manager::ProcessKey()"));
_ALGO(SysLog(L"Key=%s",_FARKEY_ToName(Key)));
#ifndef NO_WRAPPER
if (CtrlObject->Cp()->ActivePanel->GetMode() == PLUGIN_PANEL)
{
PluginHandle *ph=(PluginHandle*)CtrlObject->Cp()->ActivePanel->GetPluginHandle();
if (ph && ph->pPlugin->IsOemPlugin())
if (CtrlObject->Cp()->ActivePanel->SendKeyToPlugin(Key,TRUE))
return TRUE;
}
#endif // NO_WRAPPER
break;
}
#if 0
case MODALTYPE_VIEWER:
//if(((FileViewer*)CurrentFrame)->ProcessViewerInput(FrameManager->GetLastInputRecord()))
// return TRUE;
break;
case MODALTYPE_EDITOR:
//if(((FileEditor*)CurrentFrame)->ProcessEditorInput(FrameManager->GetLastInputRecord()))
// return TRUE;
break;
case MODALTYPE_DIALOG:
//((Dialog*)CurrentFrame)->CallDlgProc(DN_KEY,((Dialog*)CurrentFrame)->GetDlgFocusPos(),Key);
break;
case MODALTYPE_VMENU:
case MODALTYPE_HELP:
case MODALTYPE_COMBOBOX:
case MODALTYPE_USER:
case MODALTYPE_FINDFOLDER:
default:
break;
#endif
}
}
#if defined(FAR_ALPHA_VERSION)
// сей код для проверки исключатор, просьба не трогать :-)
if (Key == KEY_CTRLALTAPPS || Key == KEY_RCTRLRALTAPPS || Key == KEY_CTRLRALTAPPS || Key == KEY_RCTRLALTAPPS)
{
struct __ECODE
{
NTSTATUS Code;
const wchar_t *Name;
} ECode[]=
{
{EXCEPTION_ACCESS_VIOLATION,L"Access Violation (Read)"},
{EXCEPTION_ACCESS_VIOLATION,L"Access Violation (Write)"},
{EXCEPTION_INT_DIVIDE_BY_ZERO,L"Divide by zero"},
{EXCEPTION_ILLEGAL_INSTRUCTION,L"Illegal instruction"},
{EXCEPTION_STACK_OVERFLOW,L"Stack Overflow"},
{EXCEPTION_FLT_DIVIDE_BY_ZERO,L"Floating-point divide by zero"},
{EXCEPTION_BREAKPOINT,L"Breakpoint"},
#ifdef _M_IA64
{EXCEPTION_DATATYPE_MISALIGNMENT,L"Alignment fault (IA64 specific)",},
#endif
/*
{EXCEPTION_FLT_OVERFLOW,"EXCEPTION_FLT_OVERFLOW"},
{EXCEPTION_SINGLE_STEP,"EXCEPTION_SINGLE_STEP",},
{EXCEPTION_ARRAY_BOUNDS_EXCEEDED,"EXCEPTION_ARRAY_BOUNDS_EXCEEDED",},
{EXCEPTION_FLT_DENORMAL_OPERAND,"EXCEPTION_FLT_DENORMAL_OPERAND",},
{EXCEPTION_FLT_INEXACT_RESULT,"EXCEPTION_FLT_INEXACT_RESULT",},
{EXCEPTION_FLT_INVALID_OPERATION,"EXCEPTION_FLT_INVALID_OPERATION",},
{EXCEPTION_FLT_STACK_CHECK,"EXCEPTION_FLT_STACK_CHECK",},
{EXCEPTION_FLT_UNDERFLOW,"EXCEPTION_FLT_UNDERFLOW",},
{EXCEPTION_INT_OVERFLOW,"EXCEPTION_INT_OVERFLOW",0},
{EXCEPTION_PRIV_INSTRUCTION,"EXCEPTION_PRIV_INSTRUCTION",0},
{EXCEPTION_IN_PAGE_ERROR,"EXCEPTION_IN_PAGE_ERROR",0},
{EXCEPTION_NONCONTINUABLE_EXCEPTION,"EXCEPTION_NONCONTINUABLE_EXCEPTION",0},
{EXCEPTION_INVALID_DISPOSITION,"EXCEPTION_INVALID_DISPOSITION",0},
{EXCEPTION_GUARD_PAGE,"EXCEPTION_GUARD_PAGE",0},
{EXCEPTION_INVALID_HANDLE,"EXCEPTION_INVALID_HANDLE",0},
*/
};
static union
{
int i;
int *iptr;
double d;
} zero_const; //, refers;
zero_const.i=0L;
MenuItemEx ModalMenuItem;
ModalMenuItem.Clear();
VMenu2 ModalMenu(L"Test Exceptions",nullptr,0,ScrY-4);
ModalMenu.SetFlags(VMENU_WRAPMODE);
ModalMenu.SetPosition(-1,-1,0,0);
for (size_t I=0; I<ARRAYSIZE(ECode); I++)
{
ModalMenuItem.strName = ECode[I].Name;
ModalMenu.AddItem(&ModalMenuItem);
}
int ExitCode=ModalMenu.Run();
switch (ExitCode)
{
case -1:
return TRUE;
case 0:
zero_const.i=*zero_const.iptr;
break;
case 1:
*zero_const.iptr = 0;
break;
case 2:
zero_const.i=1/zero_const.i;
break;
case 3:
#if defined(_MSC_VER)
#ifdef _M_IA64
#define __REG_IA64_IntR0 1024
__setReg(__REG_IA64_IntR0, 666);
#else
__ud2();
#endif
#elif defined(__GNUC__)
asm("ud2");
#else
#error "Unsupported compiler"
#endif
break;
case 4:
Test_EXCEPTION_STACK_OVERFLOW(nullptr);
break;
case 5:
//refers.d = 1.0/zero_const.d;
break;
case 6:
DebugBreak();
break;
#ifdef _M_IA64
case 7:
{
BYTE temp[10]={};
double* val;
val = (double*)(&temp[3]);
printf("%lf\n", *val);
}
#endif
}
Message(MSG_WARNING, 1, L"Test Exceptions failed", L"", ECode[ExitCode].Name, L"", MSG(MOk));
return TRUE;
}
#endif
/*** БЛОК ПРИВЕЛЕГИРОВАННЫХ КЛАВИШ ! ***/
/*** КОТОРЫЕ НЕЛЬЗЯ НАМАКРОСИТЬ ***/
switch (Key)
{
case KEY_ALT|KEY_NUMPAD0:
case KEY_RALT|KEY_NUMPAD0:
case KEY_ALTINS:
case KEY_RALTINS:
{
RunGraber();
return TRUE;
}
case KEY_CONSOLE_BUFFER_RESIZE:
Sleep(1);
ResizeAllFrame();
return TRUE;
}
/*** А вот здесь - все остальное! ***/
if (!Global->IsProcessAssignMacroKey)
// в любом случае если кому-то не нужны все клавиши или
{
bool scrollable = false;
if ( Global->Opt->WindowMode )
{
int frame_type = CurrentFrame->GetType();
scrollable = frame_type != MODALTYPE_EDITOR && frame_type != MODALTYPE_VIEWER;
};
switch (Key)
{
// <Удалить после появления макрофункции Scroll>
case KEY_CTRLALTUP:
case KEY_RCTRLRALTUP:
case KEY_CTRLRALTUP:
case KEY_RCTRLALTUP:
if(scrollable)
{
Global->Console->ScrollWindow(-1);
return TRUE;
}
break;
case KEY_CTRLALTDOWN:
case KEY_RCTRLRALTDOWN:
case KEY_CTRLRALTDOWN:
case KEY_RCTRLALTDOWN:
if(scrollable)
{
Global->Console->ScrollWindow(1);
return TRUE;
}
break;
case KEY_CTRLALTPGUP:
case KEY_RCTRLRALTPGUP:
case KEY_CTRLRALTPGUP:
case KEY_RCTRLALTPGUP:
if(scrollable)
{
Global->Console->ScrollWindow(-ScrY);
return TRUE;
}
break;
case KEY_CTRLALTHOME:
case KEY_RCTRLRALTHOME:
case KEY_CTRLRALTHOME:
case KEY_RCTRLALTHOME:
if(scrollable)
{
while(Global->Console->ScrollWindow(-ScrY));
return TRUE;
}
break;
case KEY_CTRLALTPGDN:
case KEY_RCTRLRALTPGDN:
case KEY_CTRLRALTPGDN:
case KEY_RCTRLALTPGDN:
if(scrollable)
{
Global->Console->ScrollWindow(ScrY);
return TRUE;
}
break;
case KEY_CTRLALTEND:
case KEY_RCTRLRALTEND:
case KEY_CTRLRALTEND:
case KEY_RCTRLALTEND:
if(scrollable)
{
while(Global->Console->ScrollWindow(ScrY));
return TRUE;
}
break;
// </Удалить после появления макрофункции Scroll>
case KEY_CTRLW:
case KEY_RCTRLW:
ShowProcessList();
return TRUE;
case KEY_F11:
PluginsMenu();
FrameManager->RefreshFrame();
//_MANAGER(SysLog(-1));
return TRUE;
case KEY_ALTF9:
case KEY_RALTF9:
{
//_MANAGER(SysLog(1,"Manager::ProcessKey, KEY_ALTF9 pressed..."));
Sleep(1);
SetVideoMode();
Sleep(1);
/* В процессе исполнения Alt-F9 (в нормальном режиме) в очередь
консоли попадает WINDOW_BUFFER_SIZE_EVENT, формируется в
ChangeVideoMode().
В режиме исполнения макросов ЭТО не происходит по вполне понятным
причинам.
*/
if (CtrlObject->Macro.IsExecuting())
{
int PScrX=ScrX;
int PScrY=ScrY;
Sleep(1);
GetVideoMode(CurSize);
if (PScrX+1 == CurSize.X && PScrY+1 == CurSize.Y)
{
//_MANAGER(SysLog(-1,"GetInputRecord(WINDOW_BUFFER_SIZE_EVENT); return KEY_NONE"));
return TRUE;
}
else
{
PrevScrX=PScrX;
PrevScrY=PScrY;
//_MANAGER(SysLog(-1,"GetInputRecord(WINDOW_BUFFER_SIZE_EVENT); return KEY_CONSOLE_BUFFER_RESIZE"));
Sleep(1);
return ProcessKey(KEY_CONSOLE_BUFFER_RESIZE);
}
}
//_MANAGER(SysLog(-1));
return TRUE;
}
case KEY_F12:
{
int TypeFrame=FrameManager->GetCurrentFrame()->GetType();
if (TypeFrame != MODALTYPE_HELP && TypeFrame != MODALTYPE_DIALOG)
{
DeactivateFrame(FrameMenu(),0);
//_MANAGER(SysLog(-1));
return TRUE;
}
break; // отдадим F12 дальше по цепочке
}
case KEY_CTRLALTSHIFTPRESS:
case KEY_RCTRLALTSHIFTPRESS:
{
if (!(Global->Opt->CASRule&1) && Key == KEY_CTRLALTSHIFTPRESS)
break;
if (!(Global->Opt->CASRule&2) && Key == KEY_RCTRLALTSHIFTPRESS)
break;
if (!Global->Opt->OnlyEditorViewerUsed)
{
if (CurrentFrame->FastHide())
{
int isPanelFocus=CurrentFrame->GetType() == MODALTYPE_PANELS;
if (isPanelFocus)
{
int LeftVisible=CtrlObject->Cp()->LeftPanel->IsVisible();
int RightVisible=CtrlObject->Cp()->RightPanel->IsVisible();
int CmdLineVisible=CtrlObject->CmdLine->IsVisible();
int KeyBarVisible=CtrlObject->Cp()->MainKeyBar.IsVisible();
CtrlObject->CmdLine->ShowBackground();
CtrlObject->Cp()->LeftPanel->Hide0();
CtrlObject->Cp()->RightPanel->Hide0();
switch (Global->Opt->PanelCtrlAltShiftRule)
{
case 0:
CtrlObject->CmdLine->Show();
CtrlObject->Cp()->MainKeyBar.Show();
break;
case 1:
CtrlObject->Cp()->MainKeyBar.Show();
break;
}
WaitKey(Key==KEY_CTRLALTSHIFTPRESS?KEY_CTRLALTSHIFTRELEASE:KEY_RCTRLALTSHIFTRELEASE);
if (LeftVisible) CtrlObject->Cp()->LeftPanel->Show();
if (RightVisible) CtrlObject->Cp()->RightPanel->Show();
if (CmdLineVisible) CtrlObject->CmdLine->Show();
if (KeyBarVisible) CtrlObject->Cp()->MainKeyBar.Show();
}
else
{
ImmediateHide();
WaitKey(Key==KEY_CTRLALTSHIFTPRESS?KEY_CTRLALTSHIFTRELEASE:KEY_RCTRLALTSHIFTRELEASE);
}
FrameManager->RefreshFrame();
}
return TRUE;
}
break;
}
case KEY_CTRLTAB:
case KEY_RCTRLTAB:
case KEY_CTRLSHIFTTAB:
case KEY_RCTRLSHIFTTAB:
if (CurrentFrame->GetCanLoseFocus())
{
DeactivateFrame(CurrentFrame,(Key==KEY_CTRLTAB||Key==KEY_RCTRLTAB)?1:-1);
}
_MANAGER(SysLog(-1));
return TRUE;
}
}
CurrentFrame->UpdateKeyBar();
CurrentFrame->ProcessKey(Key);
}
_MANAGER(SysLog(-1));
return ret;
}
