Beispiel #1
0
//////////////////
// Key down
int CScrollbar::DoKeyDown(UnicodeChar c, int keysym, const ModifiersState& modstate)
{
	switch (keysym)  {
	case SDLK_UP:
		if (iDirection == scrVertical)
			ScrollUp();
		break;

	case SDLK_DOWN:
		if (iDirection == scrVertical)
			ScrollDown();
		break;

	case SDLK_LEFT:
		if (iDirection == scrHorizontal)
			ScrollUp();
		break;

	case SDLK_RIGHT:
		if (iDirection == scrHorizontal)
			ScrollDown();
		break;
	}

	CWidget::DoKeyDown(c, keysym, modstate);
	return WID_NOT_PROCESSED;
}
Beispiel #2
0
int VgaText::Write(off_t, const void *buf, size_t size)
{
	cpu_flags fl = DisableInterrupts();
	char *s = (char*) buf;
	while (size-- > 0) {
		char c = *s++;
		switch (c) {
			case '\n':
				fOffset += kScreenWidth - (fOffset % kScreenWidth);
				if (fOffset >= kScreenWidth * kScreenHeight) {
					fOffset -= kScreenWidth;
					ScrollUp();
				}

				break;

			case '\010':	// Backspace
				if (fOffset > 0)
					fTextBuffer[--fOffset] = fCurrentAttribute | ' ';

				break;

			default:
				fTextBuffer[fOffset++] = fCurrentAttribute | c;
				if (fOffset > kScreenWidth * kScreenHeight) {
					fOffset -= kScreenWidth;
					ScrollUp();
				}
		}
	}

	UpdateHardwareCursor();
	RestoreInterrupts(fl);
	return E_NO_ERROR;
}
Beispiel #3
0
///////////////////
// Mouse wheel up
int CScrollbar::DoMouseWheelUp(int x, int y, int dx, int dy, const ModifiersState& modstate)
{
	if ((iDirection == scrVertical && !modstate.bShift) || (iDirection == scrHorizontal && modstate.bShift))
		ScrollUp();
	CWidget::DoMouseWheelDown(x, y, dx, dy, modstate);
	return WID_PROCESSED;
}
Beispiel #4
0
/* This callback is called when some action is performed on the
   scrollbar.
   -> action : type of action that call the event.
   -> x,y    : scrollbar thumb positions, value between 0 and 1
*/
int iupMatrixScrollCB(Ihandle* ih, int action, float x, float y)
{
  int err;

  x = IupGetFloat(ih, "POSX");
  y = IupGetFloat(ih, "POSY");

  IsCanvasSet(ih, err);
  if(err == CD_OK)
  {
    switch(action)
    {
      case IUP_SBUP      : ScrollUp(ih);       break;
      case IUP_SBDN      : ScrollDown(ih);     break;
      case IUP_SBPGUP    : ScrollPgUp(ih);     break;
      case IUP_SBPGDN    : ScrollPgDown(ih);   break;
      case IUP_SBRIGHT   : ScrollRight(ih);    break;
      case IUP_SBLEFT    : ScrollLeft(ih);     break;
      case IUP_SBPGRIGHT : ScrollPgRight(ih);  break;
      case IUP_SBPGLEFT  : ScrollPgLeft(ih);   break;
      case IUP_SBPOSV    : ScrollPosVer(ih,y); break;
      case IUP_SBPOSH    : ScrollPosHor(ih,x); break;
      case IUP_SBDRAGV   : ScrollPosVer(ih,y); break;
      case IUP_SBDRAGH   : ScrollPosHor(ih,x); break;
    }
  }

  {
    cdCanvasFlush(ih->data->cddbuffer);
    ih->data->redraw = 0;
  } /* always update */

  return IUP_DEFAULT;
}
Beispiel #5
0
/*------------------------------------------------------------------------------
-- FUNCTION:    MoveCursor
--
-- DATE:        Oct 19, 2010
--
-- REVISIONS:   (Date and Description)
--
-- DESIGNER:    Dean Morin
--
-- PROGRAMMER:  Dean Morin
--
-- INTERFACE:   VOID MoveCursor(HWND hWnd, UINT cxCoord, UINT cyCoord, 
--                              BOOL bScroll)
--                          hWnd        - the handle to the window
--                          cxCoord     - the x coordinate to move the cursor to
--                                        (1,1) origin
--                          cyCoord     - the y coordinate to move the cursor to
--                                        (1,1) origin
--                          bScroll     - whether or not to scroll when the
--                                        y coordinate is beyond the bounds of
--                                        screen
--
-- RETURNS:     VOID.
--
-- NOTES:
--              Moves the cursor to the specified position. The position passed 
--              in the arguments is based screen coordinates(1,1) origin).
--              If bScroll is true, then the screen will scroll when the top
--              of bottom lines of the window are reached.
------------------------------------------------------------------------------*/
VOID MoveCursor(HWND hWnd, INT cxCoord, INT cyCoord, BOOL bScroll) {
    PWNDDATA pwd = NULL;
    pwd = (PWNDDATA) GetWindowLongPtr(hWnd, 0);
    
    if (cxCoord < 1) {
        X = 0;
    } else if (cxCoord > CHARS_PER_LINE) {
        X = CHARS_PER_LINE - 1;
    } else {
        X = --cxCoord;
    }

    if (cyCoord < WINDOW_TOP + 1) {
        Y = WINDOW_TOP;
        if (bScroll) {
            ScrollUp(hWnd);
        }
    } else if (cyCoord > WINDOW_BOTTOM + 1) {
        Y = WINDOW_BOTTOM;
        if (bScroll) {
            ScrollDown(hWnd);
        }
    } else {
        Y = --cyCoord;
    }
}
Beispiel #6
0
void SimpleConsole::NextLine()
{
	cursorX = 0;
	cursorY ++;
	if(cursorY >= height)	//是否需要滚屏?
		ScrollUp();
}
bool pawsScrollBar::OnMouseDown(int button, int /*modifiers*/, int x, int y)
{
    if(button == csmbWheelUp || button == csmbHWheelLeft)
    {
        ScrollUp();
        // Always return true, we don't want the scroll to go to the parent widget(s)
        return true;
    }
    else if(button == csmbWheelDown || button == csmbHWheelRight)
    {
        ScrollDown();
        return true;
    }
    else if(WidgetAt(x, y) == thumb)
    {
        if(horizontal)
            thumbDragPoint = x - thumb->GetScreenFrame().xmin;
        else
            thumbDragPoint = y - thumb->GetScreenFrame().ymin;

        mouseIsDraggingThumb = true;
        thumb->SetBackground(thumbMoving);
    }
    else
    {
        MoveThumbToMouse();
    }

    return true;
}
Beispiel #8
0
/*------------------------------------------------------------------------------
-- FUNCTION:    DisplayFrameInfo
--
-- DATE:        Dec 2, 2010
--
-- REVISIONS:
--
-- DESIGNER:    Daniel Wright
--
-- PROGRAMMER:  Daniel Wright
--
-- INTERFACE:   DisplayFrameInfo(HWND hWnd, FRAME frame)
--                      hWnd			- a handle to the window
--						frame			- frame to display information about
--
-- RETURNS:     VOID.
--
-- NOTES:       Uses GetOpenFileName to get the name of the file to be
--				transmitted and opens it.
------------------------------------------------------------------------------*/
VOID DisplayFrameInfo(HWND hWnd, FRAME frame){
    PWNDDATA	pwd		= NULL;
    
    int a ;
    CHAR* b = (CHAR*)malloc(sizeof(CHAR)*4);
    CHAR* c = (CHAR*)malloc(sizeof(CHAR));
    int i = 0;
    int j;
    SetScrollRegion(hWnd,2,LINES_PER_SCRN);
    ScrollUp(hWnd);

    pwd = (PWNDDATA) GetWindowLongPtr(hWnd, 0);
    a= pwd->NumOfFrames;
    sprintf(b, "%04x", frame.length);
    sprintf(c, "%02x", frame.crc);
    
    MoveCursor( hWnd, 3,  2, FALSE);
    for(i = 0; i < 3; i++){
        j=(a)%(10);
        a /=10;
        UpdateDisplayBuf(hWnd, j+48);
        X -=2;
    }
    MoveCursor( hWnd, 12,  2, FALSE);
    for(i = 0; i < 4; i++)
        UpdateDisplayBuf(hWnd, b[i]);
    MoveCursor(hWnd, 29,  2, FALSE);
    for(i = 0; i < 3; i++){
        UpdateDisplayBuf(hWnd, c[i]);
    }
    InvalidateRect(hWnd,NULL,FALSE);
    
}
//-----------------------------------------------------------------------------
//!
//-----------------------------------------------------------------------------
void tAbstractChannelTable::mouseMoveEvent( QMouseEvent* pEvent )
{
    // only move if we started within the table.
    if ( m_MousePressed )
    {
        bool resetStart = false;
        int yChanged = m_MouseStartY - pEvent->pos().y();
        if ( -yChanged >= m_RowHeight )
        {
            // the user moved their finger towards the bottom enough to scroll the list.
            ScrollUp();
            
            resetStart = true;
        }
        else
        {
            if ( yChanged >= m_RowHeight )
            {
                // the user moved their finger towards the top enough to scroll the list.
                ScrollDown();

                resetStart = true;
            }   
        }

        if ( resetStart )
        {
            m_MouseStartY = pEvent->pos().y();
        }
    }
}
void SayA( unsigned char attrib, register char *cp )
{
	unsigned char far *scptr = CurrentPos();
	unsigned char far *scend = ScrPtr( 80, 25 );

	while (*cp) {
		switch( *cp ) {
			case '\n':
				scptr = (unsigned char far *) ((long) scptr + (long) 160 );
			case '\r':
				scptr = (unsigned char far *)
					( ( ( (long) scptr - (long) VIDSEG ) /
						  (long) 160 ) * (long) 160 + (long) VIDSEG );
				cp++;
				break;
			case BELL:
				Beep();
				cp++;
				break;
			case TAB:
				scptr = (unsigned char far *) ( (long) scptr / 16 * 16 );
				cp++;
				break;
			default:
				*scptr++ = *cp++;
				*scptr++ = attrib;
				break;
		}
		if ( scptr > scend ) {
			ScrollUp( 1, 1, 80, 25, 1 );
			scptr -= 160;
		}
	}
	RestoreCurPos( scptr );
}
void CXTPDatePickerList::ScrollDown(int nCount)
{
	int nMonth = m_dtMiddleMonth.GetMonth();
	int nYear = m_dtMiddleMonth.GetYear();

	ShiftMonthUp(nYear, nMonth, nCount);

	COleDateTime dtMinRange, dtMaxRange;
	DWORD dwRes = m_pControl->GetRange(&dtMinRange, &dtMaxRange);
	if (dwRes & GDTR_MAX)
	{
		int nBottomMonth = nMonth;
		int nBottomYear = nYear;
		ShiftMonthUp(nBottomYear, nBottomMonth, m_nItemsBelow);
		COleDateTime dtTmp(nBottomYear, nBottomMonth, m_dtMiddleMonth.GetDay(), 0, 0, 0);
		if (dtTmp > dtMaxRange)
		{
			nYear = dtMaxRange.GetYear();
			nMonth = dtMaxRange.GetMonth();
			ShiftMonthDown(nYear, nMonth, m_nItemsBelow);
		}
	}

	m_dtMiddleMonth.SetDate(nYear, nMonth, 1);

	ScrollUp(0);
}
void CXTPDatePickerList::OnTimer(UINT_PTR /*nIDEvent*/)
{
	// determine cursor position
	DWORD dwPos = ::GetMessagePos();
	POINTS ptsPos = MAKEPOINTS(dwPos);
	CPoint ptPos;
	ptPos.x = ptsPos.x;
	ptPos.y = ptsPos.y;

	CRect rcClient;
	GetClientRect(rcClient);
	ClientToScreen(rcClient);

	if (ptPos.y < rcClient.top)
	{
		int nDiff = rcClient.top - ptPos.y;
		int nScroll = nDiff / rcClient.Height() + 1;
		ScrollUp(nScroll);

		Invalidate();
	}
	else if (ptPos.y > rcClient.bottom)
	{
		int nDiff = ptPos.y - rcClient.bottom;
		int nScroll = nDiff / rcClient.Height() + 1;
		ScrollDown(nScroll);

		Invalidate();
	}
}
void CSkinVerticleScrollbar::OnTimer(UINT nIDEvent) 
{
	if(nIDEvent == 1)
	{
		if(bMouseDownArrowDown)
		{
			ScrollDown();
		}
		
		if(bMouseDownArrowUp)
		{
			ScrollUp();
		}
	}
	else if(nIDEvent == 2)
	{
		if(bMouseDownArrowDown)
		{
			KillTimer(2);
			SetTimer(1, 50, NULL);
		}
		
		if(bMouseDownArrowUp)
		{
			KillTimer(2);
			SetTimer(1, 50, NULL);
		}
	}
	CStatic::OnTimer(nIDEvent);
}
Beispiel #14
0
/*  ScrollWindow - scrolls a window which has a content region
 *
 *  arguements:
 *      hWnd        handle of window
 *      numLines    number of lines to scroll it
 *      dir         direction
 *                      any +num    scrolls window down (contents go up)
 *                      any -num    scrolls window up (contents go down)
 *  returns:
 *      no return value
 *
 */
VOID PASCAL INTERNAL ScrollWindow ( HW hWnd, INT numLines, INT direction )
{
    INT width = TWINWIDTH ( hWnd );
    INT height = TWINHEIGHT ( hWnd );
    INT cbContent;
    INT cbBlank;
    INT cbMove;

    if ((hWnd->pContent == NULL) || (numLines <= 0) || (direction == 0))
        return;

    numLines = min (height, numLines);
    cbContent = width * height * sizeof ( CHAR );
    cbBlank = width * numLines * sizeof ( CHAR );
    cbMove = cbContent - cbBlank;

    /*  cbContent   number of bytes in total content region
     *  cbBlank     number of bytes of blanking
     *  cbMove      number of bytes to move
     */
    if (direction > 0) {
        if (cbMove > 0)
            Move ((LPSTR) (hWnd->pContent + cbBlank),
                  (LPSTR) hWnd->pContent, cbMove);
        Fill ((LPSTR) (hWnd->pContent + cbMove), ' ', cbBlank);
        }
    else {
        if (cbMove > 0)
            Move ((LPSTR) hWnd->pContent,
                  (LPSTR) (hWnd->pContent + cbBlank), cbMove);
        Fill ((LPSTR) hWnd->pContent, ' ', cbBlank);
        }

    //
    //	If the window is on the top,
    //	or, if the command window is on top and this is the second window,
    //	use video scrolling.  don't use video scrolling for command window.
    //

    if ( (hWnd != hCommand) &&
	 ( (hWnd == winList) ||
	   ( (winList == hCommand) && (hWnd == winList->pNext) ) ) )  {

	if (direction > 0 && numLines > 0)
	    ScrollUp (hWnd->win.left+hWnd->lLeft, hWnd->win.top+1,
		      hWnd->win.right-hWnd->lRight, hWnd->win.bottom-hWnd->lBottom,
		      numLines, DefNorm);
	else
	if (direction < 0 && numLines > 0)
	    ScrollDn (hWnd->win.left+hWnd->lLeft, hWnd->win.top+1,
		      hWnd->win.right-hWnd->lRight, hWnd->win.bottom-hWnd->lBottom,
		      numLines, DefNorm);
	else
	    DrawWindow ( hWnd, FALSE );
	}
    else
	DrawWindow ( hWnd, FALSE );
    return;
}
Beispiel #15
0
///////////////////////////////////////////////////////////////////////////////
// OnTimer
void CXScrollBar::OnTimer(UINT nIDEvent)
{
	if (nIDEvent == TIMER_MOUSE_OVER_BUTTON)	// mouse is in an arrow button,
												// and left button is down
	{
		if (m_bMouseDownArrowLeft)
		{
			ScrollLeft();
		}

		if (m_bMouseDownArrowRight)
		{
			ScrollRight();
		}

		if (m_bMouseDownArrowUp)
		{
			ScrollUp();
		}

		if (m_bMouseDownArrowDown)
		{
			ScrollDown();
		}
	}
	else if (nIDEvent == TIMER_LBUTTON_PRESSED)	// mouse is in an arrow button,
												// and left button has just been pressed
	{
		KillTimer(nIDEvent);

		if (m_bMouseDownArrowLeft || 
			m_bMouseDownArrowRight || 
			m_bMouseDownArrowUp || 
			m_bMouseDownArrowDown)
		{
			// debounce left click
			SetTimer(TIMER_MOUSE_OVER_BUTTON, 100, NULL);
		}
	}
	else if (nIDEvent == TIMER_MOUSE_OVER_THUMB)	// mouse is over thumb
	{
		CPoint point;
		::GetCursorPos(&point);
		ScreenToClient(&point);

		if (!m_rectThumb.PtInRect(point))
		{
			// no longer over thumb, restore thumb color
			m_bThumbHover = FALSE;
			KillTimer(nIDEvent);
			::SetCursor(::LoadCursor(NULL, IDC_ARROW));
			Invalidate();
		}
	}

	CStatic::OnTimer(nIDEvent);
}
Beispiel #16
0
void
cyg_hal_plf_screen_putc(void *__ch_data, char ch)
{
    CYGARC_HAL_SAVE_GP();

	switch( ch )
	{
	case '\n':
		NewLine();
		return;

	case '\r':
		XPos = 0;
		MoveCursor();
		return;

	case '\b':
		if( XPos == 0 ) return;
		XPos--;
		MoveCursor();
		return;

	case '\t':
		do
		{
			DisplayChar(' ');
		} while( (XPos % 8) != 0 );
		return;

	case 0x0c:
		ClearScreen();
		XPos = YPos = 0;
		MoveCursor();
		return;		

	case 1:
		ScrollUp(1);
		XPos = 0;
		YPos = ScreenLength-1;
		return;

	case 2:
		ScrollDown(1);
		XPos = 0;
		YPos = 0;
		return;
	
		
	default:
		DisplayChar(ch);
		return;
	}

    CYGARC_HAL_RESTORE_GP();
}
Beispiel #17
0
/** Mouse Button Down */
void ScrollBar::OnMouseDown(unsigned short /*x*/, unsigned short y,
							unsigned short Button, unsigned short /*Mod*/)
{
	//removing the double click flag, use a more sophisticated method
	//if it is needed later
	Button&=GEM_MB_NORMAL;
	if (Button==GEM_MB_SCRLUP) {
		ScrollUp();
		return;
	}
	if (Button==GEM_MB_SCRLDOWN) {
		ScrollDown();
		return;
	}
	
	if (y <= GetFrameHeight(IE_GUI_SCROLLBAR_UP_UNPRESSED) ) {
		State |= UP_PRESS;
		ScrollUp();
		return;
	}
	if (y >= Height - GetFrameHeight(IE_GUI_SCROLLBAR_DOWN_UNPRESSED)) {
		State |= DOWN_PRESS;
		ScrollDown();
		return;
	}
	// check that stepPx is set if value is set
	if (Value && !stepPx) {
		SetMax(Value);
	}
	if (y >= SliderYPos && y < SliderYPos + GetFrameHeight(IE_GUI_SCROLLBAR_SLIDER)) {
		/*
		 TODO: factor in where we grab the slider and offset it when dragging.
		 */
		State |= SLIDER_GRAB;
		return;
	}
	// if we made it this far we will jump the nib y and "grab" it
	// this way we only need to click once to jump+scroll
	State |= SLIDER_GRAB;
	SetPosForY(y - GetFrameHeight(IE_GUI_SCROLLBAR_UP_UNPRESSED));
}
void CSkinVerticleScrollbar::OnLButtonUp(UINT nFlags, CPoint point) 
{
	UpdateThumbPosition();
	KillTimer(1);
	ReleaseCapture();
	
	bool bInChannel = true;

	CRect clientRect;
	GetClientRect(&clientRect);
	int nHeight = clientRect.Height() - 37;
	CRect rectUpArrow(0,11,20,37);
	CRect rectDownArrow(0,nHeight,20,nHeight+26);
	CRect rectThumb(0,nThumbTop,20,nThumbTop+26);



	if(rectUpArrow.PtInRect(point) && bMouseDownArrowUp)
	{
		ScrollUp();	
		bInChannel = false;
	}

	if(rectDownArrow.PtInRect(point) && bMouseDownArrowDown)
	{
		ScrollDown();
		bInChannel = false;
	}

	if(rectThumb.PtInRect(point))
	{
		bInChannel = false;
	}

	if(bInChannel == true && !bMouseDown)
	{
		if(point.y > nThumbTop)
		{
			PageDown();
		}
		else
		{
			PageUp();
		}
	}

	bMouseDown = false;
	bDragging = false;
	bMouseDownArrowUp = false;
	bMouseDownArrowDown = false;
	
	CStatic::OnLButtonUp(nFlags, point);
}
Beispiel #19
0
//****************************************************************************************
void CBCGPropSheetBar::EnsureVisible (int iButton)
{
	ASSERT_VALID (this);

	CBCGToolbarButton* pButton = GetButton (iButton);
	ASSERT_VALID (pButton);

	CRect rectButton = pButton->Rect ();

	CRect rectWork;
	GetWorkArea (rectWork);

	if (rectButton.Height () >= rectWork.Height ())
	{
		// Work area is too small, nothing to do
		return;
	}

	if (rectButton.top >= rectWork.top && rectButton.bottom <= rectWork.bottom)
	{
		// Already visible
		return;
	}

	if (rectButton.top < rectWork.top)
	{
		while (pButton->Rect ().top < rectWork.top)
		{
			int iScrollOffset = m_iScrollOffset;

			ScrollUp ();

			if (iScrollOffset == m_iScrollOffset)
			{
				break;
			}
		}
	}
	else
	{
		while (pButton->Rect ().bottom > rectWork.bottom)
		{
			int iScrollOffset = m_iScrollOffset;

			ScrollDown ();

			if (iScrollOffset == m_iScrollOffset)
			{
				break;
			}
		}
	}
}
Beispiel #20
0
void tAllChannelStatus::keyPressEvent(QKeyEvent *pEvent)
{
    int key = pEvent->key();

    switch(key)
    {
    case Key::Exit:
        if( pEvent->isAutoRepeat() == false)
        {
            pEvent->accept();
            emit Cancel();
        }
        break;

    case Key::Up:
        ScrollUp();
        pEvent->accept();
        break;

    case Key::Down:
        ScrollDown();
        pEvent->accept();
        break;

    case Key::Right:
    case Key::Left:
        if( pEvent->isAutoRepeat() == false )
        {
            ToggleFavorite();
            pEvent->accept();
        }
        break;

    case Key::Enter:
    case Key::Rotary:
        if( pEvent->isAutoRepeat() == false)
        {
            tAbstractChannelTable::keyPressEvent(pEvent);
            pEvent->accept();
        }
        break;

    case Key::Menu:
        pEvent->ignore();   //this makes it so the parent gets the event
        break;

    default:
        tAbstractChannelTable::keyPressEvent(pEvent);
        break;
    };
}
void FlameThread::Init( void )
{
        PrepPal();
        pBuffer = pBlitter->GetVirtualScreen()->GetBuffer();
        srand( 42 );

        while( TRUE )
        {
                ScrollUp();
                NewLine();
                pBlitter->Blit();
                DosSleep( 0 );
        } // while
} // FlameThread::Init
//activate the frame, raise it and set the timer
bool ToasterBoxWindow::Play()
{
	//do some checks to make sure this window is valid
	if (bottomRight.x < 1 || bottomRight.y < 1)
		return false;
	if (GetSize().GetWidth() < 50 || GetSize().GetWidth() < 50) {
		//toasterbox launches into a endless loop for some reason
		//when you try to make the window too small.
		return false;
	}
	ScrollUp();
	Start(pauseTime, true);
	return true;
}
Beispiel #23
0
void IncrementCursorRow()
{
     ACB *j;
     
     j = GetACBPtr();
     j->CursorRow++;
     if (j->CursorRow < j->VideoRows) {
         UpdateCursorPos();
         return;
     }
     j->CursorRow--;
     UpdateCursorPos();
     ScrollUp();
}
void ATotemCharacter::SetAbility(int32 index)
{
	int count = 0;
	if (index < NumAbilities && !CurrentAbility->isRightClickDown())
	{
		while (index != CurrentAbilityIndex())
		{
			ScrollUp();
			count++;
			if (count > NumAbilities)
			{
				break;
			}
		}
	}
}
Beispiel #25
0
BOOL CDXCtrlTreeview::OnMouseWheel(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	POINT p;
	p.x = LOWORD(lParam);
	p.y = HIWORD(lParam);
	ScreenToClient(hwnd, &p);
	if(IsVisible() && HitTest(p.x, p.y))
	{
		if(HIWORD(wParam) == 120)
			ScrollUp(3);
		else
			ScrollDown(3);
		return TRUE;
	}
	return FALSE;
}
Beispiel #26
0
Void GUIListModel::OnScroll( const Point2 & /*ptLocalPos*/, Int iWheelDelta, GUIEventFlag iFlags )
{
    if ( m_iDisplayCount >= m_arrNodes.Count() ) {
        if ( m_iDisplayTop != 0 )
            SetScroll( 0 );
        return;
    }

    // Flags
    Bool bCtrl = ( (iFlags & GUIEVENT_FLAG_CTRL) != 0 );

    // Deal event
    if ( iWheelDelta > 0 )
        ScrollUp( bCtrl ? 3 : 1 );
    else if ( iWheelDelta < 0 )
        ScrollDown( bCtrl ? 3 : 1 );
}
Beispiel #27
0
void Display::PrintLine(const char* text)
{
	// Scroll the display if necessary.
	if (_currentRow < LCD_ROW_COUNT - 1)
		_currentRow++;
	else
		ScrollUp();

	SetCursor(_currentRow, _currentColumn);

	// Pad text with spaces.
	String paddedText = String(text);
	paddedText.concat(_blankline);
	paddedText = paddedText.substring(0, 20);

	// Write text to the display.
	Print(paddedText);
}
Beispiel #28
0
void NewLine
(
	void
)
{

	XPos = 0;
	YPos++;
	
	if( YPos >= ScreenLength )
	{
		YPos = ScreenLength-1;
		ScrollUp(1);
	}

	MoveCursor();
	
} /* NewLine */
Beispiel #29
0
BOOL CDXCtrlTreeview::OnCommand(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	WORD wId, wCode;
	wId = LOWORD(wParam);
	wCode = HIWORD(wParam);
	if(wCode == BN_CLICKED)
	{
		if(wId == IDC_SCROLLUP && (PCDXCtrlBase)lParam == m_pChild->FindControl(IDC_SCROLLUP))
		{
			ScrollUp(1);
			return TRUE;
		}
		else if(wId == IDC_SCROLLDOWN && (PCDXCtrlBase)lParam == m_pChild->FindControl(IDC_SCROLLDOWN))
		{
			ScrollDown(1);
			return TRUE;
		}
	}
	return FALSE;
}
Beispiel #30
0
void Game_Map::UpdateScroll() {
	if (scroll_rest > 0) {
		int distance = (1 << scroll_speed) / 2;
		switch (scroll_direction) {
			case 2:
				ScrollDown(distance);
				break;
			case 4:
				ScrollLeft(distance);
				break;
			case 6:
				ScrollRight(distance);
				break;
			case 8:
				ScrollUp(distance);
				break;
		}
		scroll_rest -= distance;
	}
}