bool Interactor2DMeasure::ProcessMouseMoveEvent( QMouseEvent* event, RenderView* renderview )
{
RenderView2D* view = ( RenderView2D* )renderview;
if ( m_bDrawing )
{
UpdateCursor( event, view );
int posX = event->x();
int posY = event->y();
// LayerCollection* lc = MainWindow::GetMainWindowPointer()->GetLayerCollection( m_strLayerTypeName.c_str() );
// LayerVolumeBase* mri = ( LayerVolumeBase* )lc->GetActiveLayer();
if ( m_region )
{
if ( m_nAction == MM_Line )
{
((Region2DLine*)m_region)->SetPoint2( posX, posY );
}
else if ( m_nAction == MM_Spline || m_nAction == MM_Polyline )
{
((Region2DPolyline*)m_region)->UpdatePoint( -1, posX, posY );
}
else if ( m_nAction == MM_Rectangle )
{
((Region2DRectangle*)m_region)->SetBottomRight( posX, posY );
}
view->RequestRedraw();
}
return false;
}
else if ( m_bEditing )
{
UpdateCursor( event, view );
int offsetX = event->x() - m_nMousePosX;
int offsetY = event->y() - m_nMousePosY;
if ( m_region )
{
m_nMousePosX = event->x();
m_nMousePosY = event->y();
if ( m_nPointIndex >= 0 )
{
m_region->UpdatePoint( m_nPointIndex, m_nMousePosX, m_nMousePosY );
}
else
{
m_region->Offset( offsetX, offsetY );
}
view->RequestRedraw();
}
return false;
}
else
{
return Interactor2D::ProcessMouseMoveEvent( event, renderview );
}
}
// _SetMode
void
PathManipulator::_SetMode(uint32 mode)
{
if (fMode != mode) {
//printf("switching mode: %s -> %s\n", string_for_mode(fMode), string_for_mode(mode));
fMode = mode;
if (fMode == TRANSFORM_POINTS) {
_SetTransformBox(new TransformPointsBox(fCanvasView,
this,
fPath,
fSelection->Items(),
fSelection->CountItems()));
// fCanvasView->Perform(new EnterTransformPointsCommand(this,
// fSelection->Items(),
// fSelection->CountItems()));
} else {
if (fTransformBox)
_SetTransformBox(NULL);
}
if (BWindow* window = fCanvasView->Window()) {
window->PostMessage(MSG_UPDATE_SHAPE_UI);
}
UpdateCursor();
}
}
bool UITextEditor::Finalise(void)
{
if (m_template)
return true;
if (!m_textWidget)
{
UIWidget *text = FindChildByName("text");
if (text && text->Type() == UIText::kUITextType)
m_textWidget = static_cast<UIText*>(text);
}
if (!m_cursor && m_textWidget)
{
m_cursor = FindChildByName("cursor", true);
if (m_cursor)
{
connect(this, SIGNAL(Selected()), m_cursor, SLOT(Show()));
connect(this, SIGNAL(Deselected()), m_cursor, SLOT(Hide()));
if (!m_selected)
m_cursor->Hide();
}
}
UpdateCursor();
return UIWidget::Finalise();
}
void CChildView::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags)
{
if (theApp.m_map.IsEmpty()) goto mend;
UpdateCursor();
mend:
CWnd ::OnKeyUp(nChar, nRepCnt, nFlags);
}
void NEO::Screen::ColocarCursor(uint8_t x, uint8_t y)
{
cursor_x=x;
cursor_y=y;
UpdateCursor();
}
bool Interactor2DVolumeEdit::ProcessKeyDownEvent( QKeyEvent* event, RenderView* renderview )
{
UpdateCursor( event, renderview );
RenderView2D* view = ( RenderView2D* )renderview;
if ( event->modifiers() & Qt::AltModifier && event->key() == Qt::Key_H )
{
Contour2D* c2d = view->GetContour2D();
c2d->SetVisible( !c2d->IsVisible() );
view->RequestRedraw();
return false;
}
else if (event->modifiers() & Qt::ShiftModifier && event->key() == Qt::Key_C)
{
m_bColorPicking = true;
return false;
}
else if (event->key() == Qt::Key_Escape)
{
m_bColorPicking = false;
return false;
}
if ( !m_bEditing )
{
return Interactor2D::ProcessKeyDownEvent( event, renderview );
}
else
{
return false;
}
}
int
XGrabPointer(
Display *display,
Window grab_window,
Bool owner_events,
unsigned int event_mask,
int pointer_mode,
int keyboard_mode,
Window confine_to,
Cursor cursor,
Time time)
{
ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
display->request++;
tsdPtr->grabWinPtr = (TkWindow *) Tk_IdToWindow(display, grab_window);
tsdPtr->restrictWinPtr = NULL;
TkpSetCapture(tsdPtr->grabWinPtr);
if (TkPositionInTree(tsdPtr->lastWinPtr, tsdPtr->grabWinPtr)
!= TK_GRAB_IN_TREE) {
UpdateCursor(tsdPtr->grabWinPtr);
}
return GrabSuccess;
}
/**
* @brief Sets the cursor via software
* @param x The position of X
* @param y The position of y
* */
void ND::Screen::SetCursor(uint8_t x, uint8_t y)
{
cursor_x=x;
cursor_y=y;
UpdateCursor();
}
/// @todo Implement
void
Console::Erase(EraseDirection d, bool line)
{
const uint16_t attr = GetAttr(0);
if (line) {
switch(d) {
case FORWARD:
break;
case BACKWARD:
break;
case BOTH:
break;
}
} else {
switch(d) {
case FORWARD:
break;
case BACKWARD:
break;
case BOTH: {
_canvas.Fill(attr);
_cursor = _canvas.Buffer();
UpdateCursor();
Invalidate();
break;
}
}
}
}
void
Console::PrintChar (char c)
{
if (AnsiEscFilter(c)) {
UpdateCursor();
return;
}
switch(c) {
case '\n': PutNewLine(); break;
case '\t': PutTab(); break;
case '\r': PutReturn(); break;
case '\b': PutBackspace(); break;
default: PutChar(c); break;
}
UpdateCursor();
}
bool Interactor2DVolumeEdit::ProcessMouseUpEvent( QMouseEvent* event, RenderView* renderview )
{
// RenderView2D* view = ( RenderView2D* )renderview;
UpdateCursor( event, renderview );
if ( m_bEditing )
{
m_nMousePosX = event->x();
m_nMousePosY = event->y();
if ( event->button() != Qt::LeftButton ||
(m_nAction != EM_Polyline && m_nAction != EM_Livewire ) ||
m_dPolylinePoints.size() == 0 )
{
m_bEditing = false;
}
LayerCollection* lc = MainWindow::GetMainWindow()->GetLayerCollection( m_strLayerTypeName );
LayerVolumeBase* mri = ( LayerVolumeBase* )lc->GetActiveLayer();
// mri->SendBroadcast( "LayerEdited", mri );
return false;
}
else
{
return Interactor2D::ProcessMouseUpEvent( event, renderview );
}
}
//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
void
HostMain(void)
{
switch(iUSBState)
{
//
// This state is entered when the mouse is first detected.
//
case eStateMouseInit:
{
//
// Initialize the newly connected mouse.
//
USBHMouseInit(g_psMouseInstance);
//
// Proceed to the mouse connected state.
//
iUSBState = eStateMouseConnected;
//
// Update the status on the screen.
//
UpdateStatus(0, 0, true);
//
// Update the cursor on the screen.
//
UpdateCursor(GrContextDpyWidthGet(&g_sContext) / 2,
GrContextDpyHeightGet(&g_sContext)/ 2);
break;
}
case eStateMouseConnected:
{
//
// Nothing is currently done in the main loop when the mouse
// is connected.
//
break;
}
case eStateNoDevice:
{
//
// The mouse is not connected so nothing needs to be done here.
//
break;
}
default:
{
break;
}
}
//
// Periodically call the main loop for the Host controller driver.
//
USBHCDMain();
}
bool Interactor2DNavigate::ProcessMouseUpEvent( QMouseEvent* event, RenderView* renderview )
{
UpdateCursor( event, renderview );
m_bEditing = false;
return Interactor2D::ProcessMouseUpEvent( event, renderview );
}
void MoveCursor() {
if (cursor >= _tcslen(buffer))
buffer[cursor + 1] = 0;
lettercursor = FindEntryLetter(ToUpperASCII(buffer[cursor]));
UpdateCursor();
}
void CDragVirtualListCtrl::OnMouseMove(UINT nFlags, CPoint point)
{
if (m_Dragging) {
UpdateCursor(point);
AutoScroll(point);
}
CListCtrl::OnMouseMove(nFlags, point);
}
void EditFrame::SetGeomMode(EnumGeomMode geomMode)
{
if(m_GeomMode != geomMode)
{
m_GeomMode = geomMode;
UpdateCursor();
}
}
LRESULT Win32Window::WndProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if(inputManager && inputManager->ProcessWindowMessage(uMsg, wParam, lParam))
return 0;
switch(uMsg)
{
case WM_ACTIVATE:
{
unsigned state = LOWORD(wParam);
bool active = (state == WA_ACTIVE || state == WA_CLICKACTIVE);
// update activity flag
this->active = active;
// update mouse lock
UpdateMouseLock();
// update cursor visibility
UpdateCursorVisible();
}
return 0;
case WM_MOVE:
UpdateMouseLock();
return 0;
case WM_SIZE:
clientWidth = LOWORD(lParam);
clientHeight = HIWORD(lParam);
if(presenter)
presenter->Resize(clientWidth, clientHeight);
UpdateMouseLock();
return 0;
case WM_SETCURSOR:
if(LOWORD(lParam) == HTCLIENT)
{
UpdateCursor();
return 0;
}
break;
case WM_DPICHANGED:
{
dpiScale = float(LOWORD(wParam)) / float(USER_DEFAULT_SCREEN_DPI);
const RECT* rect = (const RECT*)lParam;
SetWindowPos(hWnd, NULL, rect->left, rect->top, rect->right - rect->left, rect->bottom - rect->top, SWP_NOACTIVATE | SWP_NOZORDER);
}
break;
case WM_CLOSE:
Close();
return 0;
case WM_DESTROY:
hWnd = 0;
ClipCursor(NULL);
if(own)
PostQuitMessage(0);
return 0;
}
if(prevWndProc)
return CallWindowProc(prevWndProc, hWnd, uMsg, wParam, lParam);
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
bool Interactor2DMeasure::ProcessMouseUpEvent( QMouseEvent* event, RenderView* renderview )
{
RenderView2D* view = ( RenderView2D* )renderview;
UpdateCursor( event, renderview );
if ( m_bDrawing )
{
if ( ( m_nAction == MM_Spline || m_nAction == MM_Polyline ) && m_region )
{
return false;
}
if ( m_nMousePosX != event->x() || m_nMousePosY != event->y() )
{
m_nMousePosX = event->x();
m_nMousePosY = event->y();
// if ( event->LeftUp() )
// LayerCollection* lc = MainWindow::GetMainWindowPointer()->GetLayerCollection( "MRI" );
// LayerVolumeBase* mri = ( LayerVolumeBase* )lc->GetActiveLayer();
// mri->SendBroadcast( "LayerEdited", mri );
if ( m_region )
{
if ( m_nAction == MM_Line )
{
((Region2DLine*)m_region)->SetPoint2( m_nMousePosX, m_nMousePosY );
}
else if ( m_nAction == MM_Rectangle )
{
((Region2DRectangle*)m_region)->SetBottomRight( m_nMousePosX, m_nMousePosY );
}
}
}
else
{
if ( m_region && m_nAction != MM_Polyline && m_nAction != MM_Spline )
{
view->DeleteRegion( m_region );
m_region = NULL;
}
}
m_bEditing = false;
m_bDrawing = false;
return false;
}
else if ( m_bEditing )
{
m_bEditing = false;
m_bDrawing = false;
return false;
}
else
{
return Interactor2D::ProcessMouseUpEvent( event, renderview );
}
}
bool Interactor2DRegionEdit::ProcessKeyDownEvent( wxKeyEvent& event, RenderView* renderview )
{
UpdateCursor( event, renderview );
if ( !m_bEditing )
return Interactor2D::ProcessKeyDownEvent( event, renderview );
else
return false;
}
EditFrame::EditFrame(QWidget *pWidget)
: QWidget(pWidget)
, m_GeomMode(GEOM_MODE_MOVE)
, m_MouseDown(false)
, m_Selected(false)
{
setMouseTracking(true);
UpdateCursor();
}
void EditFrame::SetMouseDown(bool b)
{
if(m_MouseDown != b)
{
m_MouseDown = b;
UpdateCursor();
emit grabbed(m_MouseDown ? this : 0);
}
}
void rvGEWorkspace::UpdateCursor ( void )
{
if ( mDragType == rvGESelectionMgr::HT_NONE )
{
POINT point;
idVec2 cursor;
GetCursorPos ( &point );
cursor.Set ( point.x, point.y );
WindowToWorkspace ( cursor );
UpdateCursor ( cursor.x, cursor.y );
}
else
{
UpdateCursor ( mDragType );
}
}
void OverlayControl::MouseDown(HWND hwnd, WPARAM wParam, LPARAM lParam)
{
if (!ActiveOverlay)
return;
// Left or right button clicked -- select the element under cursor.
RECT clipRect, clientRect;
GetWindowRect(hwnd, &clipRect);
GetClientRect(hwnd, &clientRect);
// Save original mouse position.
GetCursorPosition(hwnd, &clickAnchor);
// Element could be activated only if no element active AND user doesn't click
// within the active element.
if (!ActiveOverlay->ActiveElement ||
!ActiveOverlay->HitTestElement(ActiveOverlay->ActiveElement, &clientRect, &clickAnchor, &hitTestAnchor))
{
// Find overlay element under cursor.
OverlayElement *element = ActiveOverlay->FindElementFromPoint(&clientRect, &clickAnchor, &hitTestAnchor);
ActivateElement(hwnd, element);
}
if (!ActiveOverlay->ActiveElement)
{
ResetCursor();
}
if (0 != (wParam & MK_LBUTTON))
{
if (ActiveOverlay->ActiveElement)
{
ActiveOverlay->ActiveElement->GetRect(&clientRect, &elementRectAnchor);
// Show that we're about to drag the object.
UpdateCursor(hitTestAnchor);
// Capture the mouse.
SetCapture(hwnd);
ClipCursor(&clipRect);
}
return;
}
if (0 != (wParam & MK_RBUTTON))
{
// Show popup menu.
POINT pt;
GetCursorPos(&pt);
__raise RightMouseButtonClicked(ActiveOverlay->ActiveElement, &pt);
return;
}
}
/*******************************************************************
* OpenDribbleFile: Function will display the common file dialog and
* will open a dribble file.
******************************************************************/
void OpenDribbleFile ( HWND hMain, WORD wParam )
{ extern HANDLE hInst;
OPENFILENAME ofn;
char File[256], FileTitle[256], Filter[256];
UINT i, cbString;
char Replace;
HMENU hMenu = GetMenu(hMain);
if ( !DribbleActive() )
{ File[0] = '\0';
memset ( &ofn,0, sizeof (OPENFILENAME));
ofn.lpstrTitle = "Select CLIPS Dribble File";
if ((cbString = LoadString ( (HINSTANCE) hInst, IDS_DRIBBLE, Filter, sizeof (Filter))) == 0 )
return;
Replace = Filter[cbString-1];
for (i=0; Filter[i] != '\0'; i++)
if ( Filter[i] == Replace)
Filter[i] = '\0';
ofn.lStructSize = sizeof ( OPENFILENAME );
ofn.hwndOwner = hMain;
ofn.lpstrFilter = Filter;
ofn.nFilterIndex = 1;
ofn.lpstrFile = File;
ofn.nMaxFile = sizeof (File );
ofn.lpstrFileTitle = FileTitle;
ofn.nMaxFileTitle = sizeof (FileTitle);
ofn.lpstrInitialDir = NULL;
ofn.Flags = OFN_OVERWRITEPROMPT;
if ( GetSaveFileName ( &ofn ) )
{ UpdateCursor ( WAIT_CURSOR );
ModifyMenu (hMenu, wParam, MF_BYCOMMAND, wParam, "Turn Dribble Off");
DribbleOn ( ofn.lpstrFile );
}
}
else
{ UpdateCursor ( WAIT_CURSOR );
ModifyMenu (hMenu, wParam, MF_BYCOMMAND, wParam, "Turn Dribble On...");
DribbleOff( );
}
}
static void
MoveCursor()
{
if (cursor >= _tcslen(edittext))
edittext[cursor + 1] = 0;
lettercursor = FindEntryLetter(ToUpperASCII(edittext[cursor]));
UpdateCursor();
}
size_t TextTerminal::Print(const char* string, size_t stringlen)
{
ScopedLock lock(&termlock);
TextBuffer* textbuf = textbufhandle->Acquire();
for ( size_t i = 0; i < stringlen; i++ )
PutChar(textbuf, string[i]);
UpdateCursor(textbuf);
textbufhandle->Release(textbuf);
return stringlen;
}
static bool
FormKeyDown(unsigned key_code)
{
switch (key_code) {
case KEY_UP:
case KEY_LEFT:
if ((key_code == KEY_LEFT) ^ IsAltair()) {
if (cursor < 1)
return true; // min width
cursor--;
MoveCursor();
return true;
} else {
lettercursor--;
UpdateCursor();
return true;
}
case KEY_DOWN:
case KEY_RIGHT:
if ((key_code == KEY_RIGHT) ^ IsAltair()) {
if (cursor + 2 >= max_width)
return true; // max width
cursor++;
MoveCursor();
return true;
} else {
lettercursor++;
UpdateCursor();
return true;
}
case KEY_RETURN:
wf->SetModalResult(mrOK);
return true;
default:
return false;
}
}
/**
* @brief Puts the char on screen
* @param c The character to write
* */
void ND::Screen::PutChar(char c)
{
uint8_t attributeByte = (backColour << 4) | (foreColour & 0x0F);
uint16_t attribute = attributeByte << 8;
uint16_t *location;
if (c == 0x08 && cursor_x)
{
cursor_x--;
}else if(c == '\r')
{
cursor_x=0;
}else if(c == '\n')
{
cursor_x=0;
cursor_y++;
}
if(c >= ' ') /* Printable character */
{
location = vidmem + (cursor_y*80 + cursor_x);
*location = c | attribute;
cursor_x++;
}
if(cursor_x >= 80) /* New line, please*/
{
cursor_x = 0;
cursor_y++;
}
/* Scroll if needed*/
uint8_t attributeByte2 = (0 /*black*/ << 4) | (15 /*white*/ & 0x0F);
uint16_t blank = 0x20 /* space */ | (attributeByte2 << 8);
if(cursor_y >= 25)
{
int i;
for (i = 0*80; i < 24*80; i++)
{
vidmem[i] = vidmem[i+80];
}
// The last line should now be blank. Do this by writing
// 80 spaces to it.
for (i = 24*80; i < 25*80; i++)
{
vidmem[i] = blank;
}
// The cursor should now be on the last line.
cursor_y = 24;
}
/* Update cursor */
UpdateCursor();
}
void NEO::Screen::ColocarChar(char c)
{
uint8_t attributeByte = (colordefondo << 4) | (colordetexto & 0x0F);
uint16_t attribute = attributeByte << 8;
uint16_t *localizacion;
if (c == 0x08 && cursor_x)
{
cursor_x--;
}else if(c == '\r')
{
cursor_x=0;
}else if(c == '\n')
{
cursor_x=0;
cursor_y++;
}
if(c >= ' ')
{
localizacion = memvid + (cursor_y*80 + cursor_x);
*localizacion = c | attribute;
cursor_x++;
}
if(cursor_x >= 80)
{
cursor_x = 0;
cursor_y++;
}
//funcion de scroll
uint8_t attributeByte2 = (0 /*negro*/ << 4) | (15 /*blanco*/ & 0x0F);
uint16_t blank = 0x20 /* espacio */ | (attributeByte2 << 8);
if(cursor_y >= 25)
{
int i;
for (i = 0*80; i < 24*80; i++)
{
memvid[i] = memvid[i+80];
}
for (i = 24*80; i < 25*80; i++)
{
memvid[i] = blank;
}
cursor_y = 24;
}
UpdateCursor();
}
bool LandscapeEditorBase::Input(DAVA::UIEvent *touch)
{
Vector2 point;
bool isIntersect = GetLandscapePoint(touch->point, point);
point.x = (float32)((int32)point.x);
point.y = (float32)((int32)point.y);
landscapePoint = point;
UpdateCursor();
if(INVALID_TOUCH_ID == touchID || touchID == touch->tid)
{
if(UIEvent::BUTTON_1 == touch->tid)
{
inverseDrawingEnabled = IsKeyModificatorPressed(DVKEY_ALT);
if(UIEvent::PHASE_BEGAN == touch->phase)
{
touchID = touch->tid;
if(isIntersect)
{
prevDrawPos = Vector2(-100, -100);
InputAction(touch->phase, isIntersect);
}
return true;
}
else if(UIEvent::PHASE_DRAG == touch->phase)
{
InputAction(touch->phase, isIntersect);
if(!isIntersect)
{
prevDrawPos = Vector2(-100, -100);
}
return true;
}
else if(UIEvent::PHASE_ENDED == touch->phase || UIEvent::PHASE_CANCELLED == touch->phase)
{
touchID = INVALID_TOUCH_ID;
if(isIntersect)
{
InputAction(touch->phase, isIntersect);
prevDrawPos = Vector2(-100, -100);
}
return true;
}
}
}
return false;
}
