コード例 #1
0
ファイル: CustomGrid.cpp プロジェクト: OpenCPN/OpenCPN
void CustomGrid::OnLabeClick( wxGridEvent& event)
{
    int row = event.GetRow();
    int col = event.GetCol();
    wxPoint p = event.GetPosition();
    ClearSelection();
    if( row == wxNOT_FOUND && event.GetCol() == wxNOT_FOUND ){              //corner label
        //find the first visible row/col
        int frow = 0, fcol = 0;
        GetFirstVisibleCell(frow, fcol);
        //then scroll as requested;
        MakeCellVisible(frow, m_numCols - 1);
        MakeCellVisible(frow, m_gParent->m_pIndex);
    } else if( row != wxNOT_FOUND && col == wxNOT_FOUND ){ //numerical row label
        int idx = GetRowIndex(row);
        if( idx != wxNOT_FOUND ){
            if(m_IsDigit.GetChar(idx) == 'X' )
                m_IsDigit.SetChar(idx, '.');
            else
                m_IsDigit.SetChar(idx, 'X');
            for( int c = 0; c < m_numCols; c++){
                double value = m_NumRowVal[idx][c];
                /*Current direction is generally reported as the "flow" direction, which is opposite from wind convention. So, adjust.*/
                if( idx == R_CURRENT && m_IsDigit.GetChar(idx) == 'X' && value != GRIB_NOTDEF){
                    value += 180;
                    if(value >= 360) value -= 360;
                    if( value < 0 ) value += 360;
                }
                SetCellRenderer( row, c, new CustomRenderer(value, m_IsDigit.GetChar(idx) == 'X') );
            }
            m_tRefreshTimer.Start( 10, wxTIMER_ONE_SHOT );
        }
    }
}
コード例 #2
0
/** OnUpdateHideAddresses
  *
  * Called when the user wants change the hide memory address setting
  */
void OnUpdateHideAddresses(MemoryGrid* memory, MemoryView* memoryView, int mode)
{
    if (!memoryView) return;
    if (mode == SHOW_ALL)
        memoryView->ShowAllAddresses();
    else if (mode == SHOW_MODIFIED)
    {
        memoryView->ShowAllAddresses();
        memoryView->SetDefaultVisibility(ViewAction::HIDE);
        memoryView->ModifyAddresses(modified_addresses);
    }
    else if (mode == SHOW_NONZERO)
    {
        std::vector<ViewRange> ranges;
        int start = 0;
        for (int current = 1; current <= 0xFFFF; current++)
        {
            if (state.mem[current] != 0 && state.mem[current - 1] == 0)
                start = current;
            else if (state.mem[current] == 0 && state.mem[current - 1] != 0)
                ranges.emplace_back(start, current - 1);
        }
        if (state.mem[0xFFFF] != 0)
            ranges.emplace_back(start, 0xFFFF);
        memoryView->ShowAllAddresses();
        memoryView->SetDefaultVisibility(ViewAction::HIDE);
        memoryView->ModifyAddresses(ranges);
    }
    ///TODO learn the interface for updating a grid's dimensions via wxGridTableMessage
    // This is inefficient, but well...
    memory->SetView(memoryView);
    MakeCellVisible(memory, state.pc);
    memory->ForceRefresh();
}
コード例 #3
0
void LogMessagesViewer::appendMessages()
{
    wxCriticalSectionLocker lock( _messagesCS );

    if ( _messages.empty() ) { return; }

    BeginBatch();

    int row = GetNumberRows();
    AppendRows( _messages.size() );

    do
    {
        appendMessage( _messages.front(), row );
        _messages.pop();
        ++row;
    }
    while ( !_messages.empty() );

    AutoSizeColumns();

    EndBatch();

    MakeCellVisible( GetNumberRows()-1, 0 );
}
コード例 #4
0
ファイル: base_grid.cpp プロジェクト: sthenc/Aegisub
void BaseGrid::SetActiveLine(AssDialogue *new_line) {
	if (new_line != active_line) {
		assert(new_line == 0 || line_index_map.count(new_line));
		active_line = new_line;
		AnnounceActiveLineChanged(active_line);
		MakeCellVisible(GetDialogueIndex(active_line), 0, false);
		Refresh(false);
		extendRow = GetDialogueIndex(new_line);
	}
}
コード例 #5
0
ファイル: MemoryGrid.cpp プロジェクト: Kakarot/complx
/** SelectLocation
  *
  * Shows a location on the grid
  */
void MemoryGrid::SelectLocation(unsigned short location)
{
    last_address = location;
    // Handles close to edge!
    int n_location = (location + 8 + 1) > 0xFFFF ? location : location + 8 + 1;
    SelectRow(location);
    SetGridCursor(location, 0);
    MakeCellVisible((location < 16) ? location : n_location, 0);
    Refresh();
}
コード例 #6
0
/** OnGoto
  *
  * Called when the user wants to goto a certain address
  */
void OnGoto(MemoryGrid* memory)
{
    wxString wxaddress = wxGetTextFromUser(_("Input Address"), _("Goto Address"));
    if (wxaddress.IsEmpty()) return;
    int addr;
    int error = lc3_calculate(state, wxaddress.ToStdString(), addr);

    if (error)
    {
        PrintError(error);
        return;
    }

    MakeCellVisible(memory, addr);
}
コード例 #7
0
ファイル: DataGrid.cpp プロジェクト: lasyard/HomeAccount
void DataGrid::scrollToDay(int day)
{
	int i;
	for (i = 0; i < GetNumberRows(); i++) {
		wxString title = GetRowLabelValue(i);
		if (title.length() == DATE_LEN) {
			struct ymd_date ymd;
			str_to_ymd_date(&ymd, title);
			if (ymd.day == day) {
				MakeCellVisible(i, 1);
				break;
			}
		}
	}
}
コード例 #8
0
/////////////////////////
// Selects visible lines
void BaseGrid::SelectVisible() {
	int rows = GetRows();
	bool selectedOne = false;
	for (int i=0;i<rows;i++) {
		if (IsDisplayed(GetDialogue(i))) {
			if (!selectedOne) {
				SelectRow(i,false);
				MakeCellVisible(i,0);
				selectedOne = true;
			}
			else {
				SelectRow(i,true);
			}
		}
	}
}
コード例 #9
0
/** OnGoto
  *
  * Called when the user wants customize what memory addresses are shown
  */
void OnHideAddressesCustom(MemoryGrid* memory, MemoryView* memoryView)
{
    ///TODO come up with a better dialog for this.
    std::string rangesStr = wxGetTextFromUser(
                                "Enter a list of ranges in the format start-end,start2-end2,start3-end3\n"
                                "Ending address for range is inclusive\n"
                                "Example x3000-x3010,xE000-xF000",
                                "Custom Hide Addresses").ToStdString();
    if (rangesStr.empty()) return;
    std::vector<std::string> parsed_ranges;
    tokenize(rangesStr, parsed_ranges, ",");
    std::vector<ViewRange> ranges;
    for (const auto& parsed_range : parsed_ranges)
    {
        int start, end;
        std::vector<std::string> start_end;
        tokenize(parsed_range, start_end, "-");
        if (start_end.size() != 2)
        {
            wxMessageBox(wxString::Format("%s is not a valid range", parsed_range), "Error");
            return;
        }
        if (lc3_calculate(state, start_end[0], start) ||
                lc3_calculate(state, start_end[1], end))
        {
            wxMessageBox(wxString::Format("%s does not contain valid addresses or malformed", parsed_range), "Error");
            return;
        }
        ranges.emplace_back(start, end);
    }
    memoryView->ShowAllAddresses();
    memoryView->SetDefaultVisibility(ViewAction::HIDE);
    memoryView->ModifyAddresses(ranges);
    ///TODO learn the interface for updating a grid's dimensions via wxGridTableMessage
    // This is inefficient, but well...
    memory->SetView(memoryView);
    MakeCellVisible(memory, state.pc);
    memory->ForceRefresh();
}
コード例 #10
0
ファイル: CustomGrid.cpp プロジェクト: OpenCPN/OpenCPN
void CustomGrid::OnMouseEvent( wxMouseEvent& event )
{
    static wxPoint s_pevt;
    wxPoint pevt = event.GetPosition();
#ifdef __WXOSX__
    if (!m_bLeftDown && event.LeftIsDown()){
        m_bLeftDown = true;
        s_pevt = pevt;
    }
    else if (m_bLeftDown && !event.LeftIsDown()){
        m_bLeftDown = false;
        if (HasCapture()) ReleaseMouse();
    }
#else
    if(event.LeftDown())
        s_pevt = pevt;
    if(event.LeftUp()){
        if(HasCapture()) ReleaseMouse();
    }
#endif
    if(event.Dragging()){
        int frow, fcol, lrow, lcol;
        GetFirstVisibleCell(frow, fcol);
        GetLastVisibleCell(lrow, lcol);
        if( pevt != s_pevt ) {
            bool rfh = false;
            int diff = pevt.x - s_pevt.x;
            //scrolling right
            if( diff > SCROLL_SENSIBILITY ){
                s_pevt.x = pevt.x;
                if( fcol > 0 ){
                    MakeCellVisible(frow, fcol - 1 );
                    rfh = true;
                }
            }
            //scrolling left
            else  if ( -diff > SCROLL_SENSIBILITY ){
                s_pevt.x = pevt.x;
                if( lcol < m_numCols - 1 ){
                    MakeCellVisible(frow, lcol + 1);
                    rfh = true;
                }
            }
            //scrolling down
            diff = pevt.y - s_pevt.y;
            if( diff > SCROLL_SENSIBILITY ){
                s_pevt.y = pevt.y;
                if( frow > 0 ){
                    MakeCellVisible(frow - 1, fcol);
                    rfh = true;
                }
            }
            //scrolling up
            else if( -diff > SCROLL_SENSIBILITY ) {
                s_pevt.y = pevt.y;
                if( lrow < m_numRows - 1 ){
                    MakeCellVisible(lrow + 1, fcol);
                    MakeCellVisible(frow + 1, fcol);      //workaroud for what seems curious moving 2 rows instead of 1 in previous function
                    rfh = true;
                }
            }
            if(rfh)
                m_tRefreshTimer.Start( 10, wxTIMER_ONE_SHOT );
        }
    }
}
コード例 #11
0
ファイル: Grid.cpp プロジェクト: ducknoir/audacity
void Grid::OnKeyDown(wxKeyEvent &event)
{
    switch (event.GetKeyCode())
    {
    case WXK_LEFT:
    case WXK_RIGHT:
    {
        int rows = GetNumberRows();
        int cols = GetNumberCols();
        int crow = GetGridCursorRow();
        int ccol = GetGridCursorCol();

        if (event.GetKeyCode() == WXK_LEFT) {
            if (crow == 0 && ccol == 0) {
                // do nothing
            }
            else if (ccol == 0) {
                SetGridCursor(crow - 1, cols - 1);
            }
            else {
                SetGridCursor(crow, ccol - 1);
            }
        }
        else {
            if (crow == rows - 1 && ccol == cols - 1) {
                // do nothing
            }
            else if (ccol == cols - 1) {
                SetGridCursor(crow + 1, 0);
            }
            else {
                SetGridCursor(crow, ccol + 1);
            }
        }

#if wxUSE_ACCESSIBILITY
        // Make sure the NEW cell is made available to the screen reader
        mAx->SetCurrentCell(GetGridCursorRow(), GetGridCursorCol());
#endif
    }
    break;

    case WXK_TAB:
    {
        int rows = GetNumberRows();
        int cols = GetNumberCols();
        int crow = GetGridCursorRow();
        int ccol = GetGridCursorCol();

        if (event.ControlDown()) {
            int flags = wxNavigationKeyEvent::FromTab |
                        ( event.ShiftDown() ?
                          wxNavigationKeyEvent::IsBackward :
                          wxNavigationKeyEvent::IsForward );
            Navigate(flags);
            return;
        }
        else if (event.ShiftDown()) {
            if (crow == 0 && ccol == 0) {
                Navigate(wxNavigationKeyEvent::FromTab | wxNavigationKeyEvent::IsBackward);
                return;
            }
            else if (ccol == 0) {
                SetGridCursor(crow - 1, cols - 1);
            }
            else {
                SetGridCursor(crow, ccol - 1);
            }
        }
        else {
            if (crow == rows - 1 && ccol == cols - 1) {
                Navigate(wxNavigationKeyEvent::FromTab | wxNavigationKeyEvent::IsForward);
                return;
            }
            else if (ccol == cols - 1) {
                SetGridCursor(crow + 1, 0);
            }
            else {
                SetGridCursor(crow, ccol + 1);
            }
        }
        MakeCellVisible(GetGridCursorRow(), GetGridCursorCol());

#if wxUSE_ACCESSIBILITY
        // Make sure the NEW cell is made available to the screen reader
        mAx->SetCurrentCell(GetGridCursorRow(), GetGridCursorCol());
#endif
    }
    break;

    case WXK_RETURN:
    case WXK_NUMPAD_ENTER:
    {
        if (!IsCellEditControlShown()) {
            wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
            wxWindow *def = tlw->GetDefaultItem();
            if (def && def->IsEnabled()) {
                wxCommandEvent cevent(wxEVT_COMMAND_BUTTON_CLICKED,
                                      def->GetId());
                GetParent()->GetEventHandler()->ProcessEvent(cevent);
            }
        }
        else {
            wxGrid::OnKeyDown(event);

            // This looks strange, but what it does is selects the cell when
            // enter is pressed after editing.  Without it, Jaws and Window-Eyes
            // do not speak the NEW cell contents (the one below the edited one).
            SetGridCursor(GetGridCursorRow(), GetGridCursorCol());
        }
        break;
    }

    default:
        wxGrid::OnKeyDown(event);
        break;
    }
}
コード例 #12
0
ファイル: grid.cpp プロジェクト: antonvw/wxExtension
bool wex::grid::find_next(const std::string& text, bool forward)
{
  if (text.empty())
  {
    return false;
  }

  static bool recursive = false;
  static int start_row;
  static int end_row;
  static int init_row;
  static int start_col;
  static int end_col;

  wxString text_use = text;

  if (!find_replace_data::get()->match_case())
  {
    text_use.MakeUpper();
  }

  wxGridCellCoords grid_cursor(GetGridCursorRow(), GetGridCursorCol());

  if (forward)
  {
    init_row = 0;

    if (recursive)
    {
      start_row = init_row;
      start_col = 0;
    }
    else
    {
      start_row = grid_cursor.GetRow() + 1;
      start_col = grid_cursor.GetCol();
    }

    end_row = GetNumberRows();
    end_col = GetNumberCols();
  }
  else
  {
    init_row = GetNumberRows() - 1;

    if (recursive)
    {
      start_row = init_row;
      start_col = GetNumberCols() - 1;
    }
    else
    {
      start_row = grid_cursor.GetRow() - 1;
      start_col = grid_cursor.GetCol();
    }

    end_row = -1;
    end_col = -1;
  }
  
  if (start_col == -1)
  {
    start_col = 0;
  }

  if (start_row == -1)
  {
    start_row = 0;
  }
  
  wxGridCellCoords match;

  for (int j = start_col; j != end_col && !match; (forward ? j++: j--))
  {
    for (int i = (j == start_col ? start_row: init_row);
         i != end_row && !match;
         (forward ? i++: i--))
    {
      wxString text = GetCellValue(i, j);

      if (!find_replace_data::get()->match_case())
      {
        text.MakeUpper();
      }

      if (find_replace_data::get()->match_word())
      {
        if (text == text_use)
        {
          match = wxGridCellCoords(i, j);
        }
      }
      else
      {
        if (text.Contains(text_use))
        {
          match = wxGridCellCoords(i, j);
        }
      }
    }
  }

  if (!match)
  {
    bool result = false;
    
    frame::statustext(
      get_find_result(text, forward, recursive), std::string());
    
    if (!recursive)
    {
      recursive = true;
      result = find_next(text, forward);
      recursive = false;
    }
    
    return result;
  }
  else
  {
    recursive = false;
    SetGridCursor(match.GetRow(), match.GetCol());
    MakeCellVisible(match); // though docs say this isn't necessary, it is
    return true;
  }
}
コード例 #13
0
/////////////
// Key press
void BaseGrid::OnKeyPress(wxKeyEvent &event) {
	// Get size
	int w,h;
	GetClientSize(&w,&h);

	// Get scan code
	int key = event.KeyCode();
	bool ctrl = event.m_controlDown;
	bool alt = event.m_altDown;
	bool shift = event.m_shiftDown;

	// Left/right, forward to seek bar if video is loaded
	if (key == WXK_LEFT || key == WXK_RIGHT) {
		if (video->loaded) {
			video->ControlSlider->SetFocus();
			video->ControlSlider->AddPendingEvent(event);
			return;
		}
		event.Skip();
		return;
	}

	// Select all
	if (key == 'A' && ctrl && !alt && !shift) {
		int rows = GetRows();
		for (int i=0;i<rows;i++) SelectRow(i,true);
	}

	// Up/down
	int dir = 0;
	int step = 1;
	if (key == WXK_UP) dir = -1;
	if (key == WXK_DOWN) dir = 1;
	if (key == WXK_PRIOR) {
		dir = -1;
		step = h/lineHeight - 2;
	}
	if (key == WXK_NEXT) {
		dir = 1;
		step = h/lineHeight - 2;
	}
	if (key == WXK_HOME) {
		dir = -1;
		step = GetRows();
	}
	if (key == WXK_END) {
		dir = 1;
		step = GetRows();
	}

	// Moving
	if (dir) {
		// Move selection
		if (!ctrl && !shift && !alt) {
			// Move to extent first
			int curLine = editBox->linen;
			if (extendRow != -1) {
				curLine = extendRow;
				extendRow = -1;
			}

			int next = MID(0,curLine+dir*step,GetRows()-1);
			editBox->SetToLine(next);
			SelectRow(next);
			MakeCellVisible(next,0,false);
			return;
		}

		// Move active only
		if (alt && !shift && !ctrl) {
			extendRow = -1;
			int next = MID(0,editBox->linen+dir*step,GetRows()-1);
			editBox->SetToLine(next);
			Refresh(false);
			MakeCellVisible(next,0,false);
			return;
		}

		// Shift-selection
		if (shift && !ctrl && !alt) {
			// Find end
			if (extendRow == -1) extendRow = editBox->linen;
			extendRow = MID(0,extendRow+dir*step,GetRows()-1);

			// Set range
			int i1 = editBox->linen;
			int i2 = extendRow;
			if (i2 < i1) {
				int aux = i1;
				i1 = i2;
				i2 = aux;
			}

			// Select range
			ClearSelection();
			for (int i=i1;i<=i2;i++) {
				SelectRow(i,true);
			}

			MakeCellVisible(extendRow,0,false);
			return;
		}
	}

	// Other events, send to audio display
	if (video->audio->loaded) {
		video->audio->AddPendingEvent(event);
	}
	else event.Skip();
}
コード例 #14
0
ファイル: base_grid.cpp プロジェクト: sthenc/Aegisub
void BaseGrid::OnKeyDown(wxKeyEvent &event) {
	int w,h;
	GetClientSize(&w,&h);

	int key = event.GetKeyCode();
	bool ctrl = event.CmdDown();
	bool alt = event.AltDown();
	bool shift = event.ShiftDown();

	int dir = 0;
	int step = 1;
	if (key == WXK_UP) dir = -1;
	else if (key == WXK_DOWN) dir = 1;
	else if (key == WXK_PAGEUP) {
		dir = -1;
		step = h / lineHeight - 2;
	}
	else if (key == WXK_PAGEDOWN) {
		dir = 1;
		step = h / lineHeight - 2;
	}
	else if (key == WXK_HOME) {
		dir = -1;
		step = GetRows();
	}
	else if (key == WXK_END) {
		dir = 1;
		step = GetRows();
	}

	if (!dir) {
		event.Skip();
		return;
	}

	int old_extend = extendRow;
	int next = mid(0, GetDialogueIndex(active_line) + dir * step, GetRows() - 1);
	SetActiveLine(GetDialogue(next));

	// Move selection
	if (!ctrl && !shift && !alt) {
		SelectRow(next);
		return;
	}

	// Move active only
	if (alt && !shift && !ctrl) {
		Refresh(false);
		return;
	}

	// Shift-selection
	if (shift && !ctrl && !alt) {
		extendRow = old_extend;
		// Set range
		int begin = next;
		int end = extendRow;
		if (end < begin)
			std::swap(begin, end);

		// Select range
		Selection newsel;
		for (int i = begin; i <= end; i++)
			newsel.insert(GetDialogue(i));

		SetSelectedSet(newsel);

		MakeCellVisible(next, 0, false);
		return;
	}
}
コード例 #15
0
ファイル: base_grid.cpp プロジェクト: sthenc/Aegisub
void BaseGrid::OnMouseEvent(wxMouseEvent &event) {
	int h = GetClientSize().GetHeight();
	bool shift = event.ShiftDown();
	bool alt = event.AltDown();
	bool ctrl = event.CmdDown();

	// Row that mouse is over
	bool click = event.LeftDown();
	bool dclick = event.LeftDClick();
	int row = event.GetY() / lineHeight + yPos - 1;
	if (holding && !click) {
		row = mid(0,row,GetRows()-1);
	}
	AssDialogue *dlg = GetDialogue(row);
	if (!dlg) row = 0;

	if (event.ButtonDown() && OPT_GET("Subtitle/Grid/Focus Allow")->GetBool())
		SetFocus();

	if (holding) {
		if (!event.LeftIsDown()) {
			if (dlg)
				MakeCellVisible(row, 0, false);
			holding = false;
			ReleaseMouse();
		}
		else {
			// Only scroll if the mouse has moved to a different row to avoid
			// scrolling on sloppy clicks
			if (row != extendRow) {
				if (row <= yPos)
					ScrollTo(yPos - 3);
				// When dragging down we give a 3 row margin to make it easier
				// to see what's going on, but we don't want to scroll down if
				// the user clicks on the bottom row and drags up
				else if (row > yPos + h / lineHeight - (row > extendRow ? 3 : 1))
					ScrollTo(yPos + 3);
			}
		}
	}
	else if (click && dlg) {
		holding = true;
		CaptureMouse();
	}

	if ((click || holding || dclick) && dlg) {
		int old_extend = extendRow;

		// SetActiveLine will scroll the grid if the row is only half-visible,
		// but we don't want to scroll until the mouse moves or the button is
		// released, to avoid selecting multiple lines on a click
		int old_y_pos = yPos;
		SetActiveLine(dlg);
		ScrollTo(old_y_pos);

		// Toggle selected
		if (click && ctrl && !shift && !alt) {
			bool isSel = !!selection.count(dlg);
			if (isSel && selection.size() == 1) return;
			SelectRow(row, true, !isSel);
			return;
		}

		// Normal click
		if ((click || dclick) && !shift && !ctrl && !alt) {
			if (dclick) {
				context->audioBox->ScrollToActiveLine();
				context->videoController->JumpToTime(dlg->Start);
			}
			SelectRow(row, false);
			return;
		}

		// Change active line only
		if (click && !shift && !ctrl && alt)
			return;

		// Block select
		if ((click && shift && !alt) || holding) {
			extendRow = old_extend;
			int i1 = row;
			int i2 = extendRow;

			if (i1 > i2)
				std::swap(i1, i2);

			// Toggle each
			Selection newsel;
			if (ctrl) newsel = selection;
			for (int i = i1; i <= i2; i++) {
				newsel.insert(GetDialogue(i));
			}
			SetSelectedSet(newsel);
			return;
		}

		return;
	}

	// Mouse wheel
	if (event.GetWheelRotation() != 0) {
		if (ForwardMouseWheelEvent(this, event)) {
			int step = shift ? h / lineHeight - 2 : 3;
			ScrollTo(yPos - step * event.GetWheelRotation() / event.GetWheelDelta());
		}
		return;
	}

	event.Skip();
}