bool EDIT_TOOL::makeSelection( const SELECTION& aSelection )
{
if( aSelection.Empty() ) // Try to find an item that could be modified
m_toolMgr->RunAction( COMMON_ACTIONS::selectionSingle, true );
return !aSelection.Empty();
}
bool SELECTION_CONDITIONS::sameNetFunc( const SELECTION& aSelection )
{
if( aSelection.Empty() )
return false;
int netcode = -1;
for( int i = 0; i < aSelection.Size(); ++i )
{
const BOARD_CONNECTED_ITEM* item =
dynamic_cast<const BOARD_CONNECTED_ITEM*>( aSelection.Item<EDA_ITEM>( i ) );
if( !item )
return false;
if( netcode < 0 )
{
netcode = item->GetNetCode();
if( netcode == NETINFO_LIST::UNCONNECTED )
return false;
}
else if( netcode != item->GetNetCode() )
{
return false;
}
}
return true;
}
bool SELECTION_CONDITIONS::onlyTypeFunc( const SELECTION& aSelection, KICAD_T aType )
{
if( aSelection.Empty() )
return false;
for( int i = 0; i < aSelection.Size(); ++i )
{
if( aSelection.Item<EDA_ITEM>( i )->Type() != aType )
return false;
}
return true;
}
bool SELECTION_CONDITIONS::OnlyConnectedItems( const SELECTION& aSelection )
{
if( aSelection.Empty() )
return false;
for( int i = 0; i < aSelection.Size(); ++i )
{
KICAD_T type = aSelection.Item<EDA_ITEM>( i )->Type();
if( type != PCB_PAD_T && type != PCB_VIA_T && type != PCB_TRACE_T && type != PCB_ZONE_T )
return false;
}
return true;
}
bool exitTASEditor()
{
if (!askToSaveProject()) return false;
// destroy window
taseditorWindow.exit();
disableGeneralKeyboardInput();
// release memory
editor.free();
pianoRoll.free();
markersManager.free();
greenzone.free();
bookmarks.free();
branches.free();
popupDisplay.free();
history.free();
playback.stopSeeking();
selection.free();
// restore "eoptions"
eoptions = saved_eoptions;
// restore autosaves
EnableAutosave = saved_EnableAutosave;
DoPriority();
// restore frame_display
frame_display = saved_frame_display;
UpdateCheckedMenuItems();
// switch off TAS Editor mode
movieMode = MOVIEMODE_INACTIVE;
FCEU_DispMessage("TAS Editor disengaged", 0);
FCEUMOV_CreateCleanMovie();
return true;
}
bool EDITOR::handleInputColumnSetUsingPattern(int joy, int button)
{
if (joy < 0 || joy >= joysticksPerFrame[getInputType(currMovieData)]) return false;
RowsSelection* current_selection = selection.getCopyOfCurrentRowsSelection();
if (current_selection->size() == 0) return false;
RowsSelection::iterator current_selection_begin(current_selection->begin());
RowsSelection::iterator current_selection_end(current_selection->end());
int pattern_offset = 0, current_pattern = taseditorConfig.currentPattern;
for(RowsSelection::iterator it(current_selection_begin); it != current_selection_end; it++)
{
// skip lag frames
if (taseditorConfig.autofirePatternSkipsLag && greenzone.lagLog.getLagInfoAtFrame(*it) == LAGGED_YES)
continue;
currMovieData.records[*it].setBitValue(joy, button, patterns[current_pattern][pattern_offset] != 0);
pattern_offset++;
if (pattern_offset >= (int)patterns[current_pattern].size())
pattern_offset -= patterns[current_pattern].size();
}
int first_changes = history.registerChanges(MODTYPE_PATTERN, *current_selection_begin, *current_selection->rbegin(), 0, patternsNames[current_pattern].c_str());
if (first_changes >= 0)
{
greenzone.invalidateAndUpdatePlayback(first_changes);
return true;
} else
return false;
}
void EDITOR::setMarkers()
{
RowsSelection* current_selection = selection.getCopyOfCurrentRowsSelection();
if (current_selection->size())
{
RowsSelection::iterator current_selection_begin(current_selection->begin());
RowsSelection::iterator current_selection_end(current_selection->end());
bool changes_made = false;
for(RowsSelection::iterator it(current_selection_begin); it != current_selection_end; it++)
{
if (!markersManager.getMarkerAtFrame(*it))
{
if (markersManager.setMarkerAtFrame(*it))
{
changes_made = true;
pianoRoll.redrawRow(*it);
}
}
}
if (changes_made)
{
selection.mustFindCurrentMarker = playback.mustFindCurrentMarker = true;
history.registerMarkersChange(MODTYPE_MARKER_SET, *current_selection_begin, *current_selection->rbegin());
}
}
}
bool EDIT_TOOL::hoverSelection( const SELECTION& aSelection, bool aSanitize )
{
if( aSelection.Empty() ) // Try to find an item that could be modified
{
m_toolMgr->RunAction( COMMON_ACTIONS::selectionCursor, true );
if( m_selectionTool->CheckLock() == SELECTION_LOCKED )
{
m_toolMgr->RunAction( COMMON_ACTIONS::selectionClear, true );
return false;
}
}
if( aSanitize )
m_selectionTool->SanitizeSelection();
if( aSelection.Empty() ) // TODO is it necessary?
m_toolMgr->RunAction( COMMON_ACTIONS::selectionClear, true );
return !aSelection.Empty();
}
bool POINT_EDITOR::addCornerCondition( const SELECTION& aSelection )
{
if( aSelection.Size() != 1 )
return false;
BOARD_ITEM* item = aSelection.Item<BOARD_ITEM>( 0 );
// Works only for zones and line segments
return item->Type() == PCB_ZONE_AREA_T ||
( ( item->Type() == PCB_LINE_T || item->Type() == PCB_MODULE_EDGE_T ) &&
static_cast<DRAWSEGMENT*>( item )->GetShape() == S_SEGMENT );
}
// following functions use current Selection to determine range of frames
bool EDITOR::handleColumnSet()
{
RowsSelection* current_selection = selection.getCopyOfCurrentRowsSelection();
if (current_selection->size() == 0) return false;
RowsSelection::iterator current_selection_begin(current_selection->begin());
RowsSelection::iterator current_selection_end(current_selection->end());
// inspect the selected frames, if they are all set, then unset all, else set all
bool unset_found = false, changes_made = false;
for(RowsSelection::iterator it(current_selection_begin); it != current_selection_end; it++)
{
if (!markersManager.getMarkerAtFrame(*it))
{
unset_found = true;
break;
}
}
if (unset_found)
{
// set all
for(RowsSelection::iterator it(current_selection_begin); it != current_selection_end; it++)
{
if (!markersManager.getMarkerAtFrame(*it))
{
if (markersManager.setMarkerAtFrame(*it))
{
changes_made = true;
pianoRoll.redrawRow(*it);
}
}
}
if (changes_made)
history.registerMarkersChange(MODTYPE_MARKER_SET, *current_selection_begin, *current_selection->rbegin());
} else
{
// unset all
for(RowsSelection::iterator it(current_selection_begin); it != current_selection_end; it++)
{
if (markersManager.getMarkerAtFrame(*it))
{
markersManager.removeMarkerFromFrame(*it);
changes_made = true;
pianoRoll.redrawRow(*it);
}
}
if (changes_made)
history.registerMarkersChange(MODTYPE_MARKER_REMOVE, *current_selection_begin, *current_selection->rbegin());
}
if (changes_made)
selection.mustFindCurrentMarker = playback.mustFindCurrentMarker = true;
return changes_made;
}
bool SELECTION_CONDITIONS::sameLayerFunc( const SELECTION& aSelection )
{
if( aSelection.Empty() )
return false;
LSET layerSet;
layerSet.set();
for( int i = 0; i < aSelection.Size(); ++i )
{
const BOARD_ITEM* item = dynamic_cast<const BOARD_ITEM*>( aSelection.Item<EDA_ITEM>( i ) );
if( !item )
return false;
layerSet &= item->GetLayerSet();
if( !layerSet.any() ) // there are no common layers left
return false;
}
return true;
}
bool SELECTION_CONDITIONS::onlyTypesFunc( const SELECTION& aSelection, const std::vector<KICAD_T>& aTypes )
{
if( aSelection.Empty() )
return false;
for( int i = 0; i < aSelection.Size(); ++i )
{
bool valid = false;
for( std::vector<KICAD_T>::const_iterator it = aTypes.begin(); it != aTypes.end(); ++it )
{
if( aSelection.Item<EDA_ITEM>( i )->Type() == *it )
{
valid = true;
break;
}
}
if( !valid )
return false;
}
return true;
}
bool PCB_SELECTION_CONDITIONS::OnlyConnectedItems( const SELECTION& aSelection )
{
if( aSelection.Empty() )
return false;
for( const auto &item : aSelection )
{
auto type = item->Type();
if( type != PCB_PAD_T && type != PCB_VIA_T && type != PCB_TRACE_T && type != PCB_ZONE_AREA_T )
return false;
}
return true;
}
wxPoint EDIT_TOOL::getModificationPoint( const SELECTION& aSelection )
{
if( aSelection.Size() == 1 )
{
return aSelection.Item<BOARD_ITEM>( 0 )->GetPosition() - m_offset;
}
else
{
// If EDIT_TOOL is not currently active then it means that the cursor position is not
// updated, so we have to fetch the latest value
if( m_toolMgr->GetCurrentToolId() != m_toolId )
m_cursor = getViewControls()->GetCursorPosition();
return wxPoint( m_cursor.x, m_cursor.y );
}
}
void PLAYBACK::handleMiddleButtonClick()
{
if (emuPausedState)
{
// Unpause or start seeking
// works only when right mouse button is released
if (GetAsyncKeyState(GetSystemMetrics(SM_SWAPBUTTON) ? VK_LBUTTON : VK_RBUTTON) >= 0)
{
if (GetAsyncKeyState(VK_SHIFT) < 0)
{
// if Shift is held, seek to nearest Marker
int last_frame = markersManager.getMarkersArraySize() - 1; // the end of movie Markers
int target_frame = currFrameCounter + 1;
for (; target_frame <= last_frame; ++target_frame)
if (markersManager.getMarkerAtFrame(target_frame)) break;
if (target_frame <= last_frame)
startSeekingToFrame(target_frame);
} else if (GetAsyncKeyState(VK_CONTROL) < 0)
{
// if Ctrl is held, seek to Selection cursor or replay from Selection cursor
int selection_beginning = selection.getCurrentRowsSelectionBeginning();
if (selection_beginning > currFrameCounter)
{
startSeekingToFrame(selection_beginning);
} else if (selection_beginning < currFrameCounter)
{
int saved_currFrameCounter = currFrameCounter;
if (selection_beginning < 0)
selection_beginning = 0;
jump(selection_beginning);
startSeekingToFrame(saved_currFrameCounter);
}
} else if (getPauseFrame() < 0 && getLastPosition() >= greenzone.getSize())
{
restoreLastPosition();
} else
{
unpauseEmulation();
}
}
} else
{
pauseEmulation();
}
}
bool EDITOR::handleColumnSetUsingPattern()
{
RowsSelection* current_selection = selection.getCopyOfCurrentRowsSelection();
if (current_selection->size() == 0) return false;
RowsSelection::iterator current_selection_begin(current_selection->begin());
RowsSelection::iterator current_selection_end(current_selection->end());
int pattern_offset = 0, current_pattern = taseditorConfig.currentPattern;
bool changes_made = false;
for(RowsSelection::iterator it(current_selection_begin); it != current_selection_end; it++)
{
// skip lag frames
if (taseditorConfig.autofirePatternSkipsLag && greenzone.lagLog.getLagInfoAtFrame(*it) == LAGGED_YES)
continue;
if (patterns[current_pattern][pattern_offset])
{
if (!markersManager.getMarkerAtFrame(*it))
{
if (markersManager.setMarkerAtFrame(*it))
{
changes_made = true;
pianoRoll.redrawRow(*it);
}
}
} else
{
if (markersManager.getMarkerAtFrame(*it))
{
markersManager.removeMarkerFromFrame(*it);
changes_made = true;
pianoRoll.redrawRow(*it);
}
}
pattern_offset++;
if (pattern_offset >= (int)patterns[current_pattern].size())
pattern_offset -= patterns[current_pattern].size();
}
if (changes_made)
{
history.registerMarkersChange(MODTYPE_MARKER_PATTERN, *current_selection_begin, *current_selection->rbegin(), patternsNames[current_pattern].c_str());
selection.mustFindCurrentMarker = playback.mustFindCurrentMarker = true;
return true;
} else
return false;
}
void GREENZONE::ungreenzoneSelectedFrames()
{
RowsSelection* current_selection = selection.getCopyOfCurrentRowsSelection();
if (current_selection->size() == 0) return;
bool changed = false;
int size = savestates.size();
int start_index = *current_selection->begin();
int end_index = *current_selection->rbegin();
RowsSelection::reverse_iterator current_selection_rend = current_selection->rend();
// degreenzone frames, going backwards
for (RowsSelection::reverse_iterator it(current_selection->rbegin()); it != current_selection_rend; it++)
changed = changed | clearSavestateAndFreeMemory(*it);
if (changed)
{
pianoRoll.redraw();
bookmarks.redrawBookmarksList();
}
}
bool PCB_SELECTION_CONDITIONS::sameNetFunc( const SELECTION& aSelection, bool aAllowUnconnected )
{
if( aSelection.Empty() )
return false;
int netcode = -1; // -1 stands for 'net code is not yet determined'
for( const auto& aitem : aSelection )
{
int current_netcode = -1;
const BOARD_CONNECTED_ITEM* item =
dynamic_cast<const BOARD_CONNECTED_ITEM*>( aitem );
if( item )
{
current_netcode = item->GetNetCode();
}
else
{
if( !aAllowUnconnected )
return false;
else
// if it is not a BOARD_CONNECTED_ITEM, treat it as if there was no net assigned
current_netcode = 0;
}
assert( current_netcode >= 0 );
if( netcode < 0 )
{
netcode = current_netcode;
if( netcode == NETINFO_LIST::UNCONNECTED && !aAllowUnconnected )
return false;
}
else if( netcode != current_netcode )
{
return false;
}
}
return true;
}
bool PCB_SELECTION_CONDITIONS::sameLayerFunc( const SELECTION& aSelection )
{
if( aSelection.Empty() )
return false;
LSET layerSet;
layerSet.set();
for( const auto& i : aSelection )
{
auto item = static_cast<BOARD_ITEM*>( i );
layerSet &= item->GetLayerSet();
if( !layerSet.any() ) // there are no common layers left
return false;
}
return true;
}
// everyframe function
void updateTASEditor()
{
if (taseditorWindow.hwndTASEditor)
{
// TAS Editor is engaged
// update all modules that need to be updated every frame
// the order is somewhat important, e.g. Greenzone must update before Bookmark Set, Piano Roll must update before Selection
taseditorWindow.update();
greenzone.update();
recorder.update();
pianoRoll.update();
markersManager.update();
playback.update();
bookmarks.update();
branches.update();
popupDisplay.update();
selection.update();
splicer.update();
history.update();
project.update();
// run Lua functions if needed
if (taseditorConfig.enableLuaAutoFunction)
TaseditorAutoFunction();
if (mustCallManualLuaFunction)
{
TaseditorManualFunction();
mustCallManualLuaFunction = false;
}
} else
{
// TAS Editor is not engaged
TaseditorAutoFunction(); // but we still should run Lua auto function
if (mustEngageTaseditor)
{
char fullname[1000];
strcpy(fullname, curMovieFilename);
if (enterTASEditor())
loadProject(fullname);
mustEngageTaseditor = false;
}
}
}
void createNewProject()
{
if (!askToSaveProject()) return;
static struct NewProjectParameters params;
if (DialogBoxParam(fceu_hInstance, MAKEINTRESOURCE(IDD_TASEDITOR_NEWPROJECT), taseditorWindow.hwndTASEditor, newProjectProc, (LPARAM)¶ms) > 0)
{
FCEUMOV_CreateCleanMovie();
// apply selected options
setInputType(currMovieData, params.inputType);
applyMovieInputConfig();
if (params.copyCurrentInput)
// copy Input from current snapshot (from history)
history.getCurrentSnapshot().inputlog.toMovie(currMovieData);
if (!params.copyCurrentMarkers)
markersManager.reset();
if (params.authorName != L"") currMovieData.comments.push_back(L"author " + params.authorName);
// reset Taseditor
project.init(); // new project has blank name
greenzone.reset();
if (params.copyCurrentInput)
// copy LagLog from current snapshot (from history)
greenzone.lagLog = history.getCurrentSnapshot().laglog;
playback.reset();
playback.restartPlaybackFromZeroGround();
bookmarks.reset();
branches.reset();
history.reset();
pianoRoll.reset();
selection.reset();
editor.reset();
splicer.reset();
recorder.reset();
popupDisplay.reset();
taseditorWindow.redraw();
taseditorWindow.updateCaption();
}
}
bool EDITOR::handleInputColumnSet(int joy, int button)
{
if (joy < 0 || joy >= joysticksPerFrame[getInputType(currMovieData)]) return false;
RowsSelection* current_selection = selection.getCopyOfCurrentRowsSelection();
if (current_selection->size() == 0) return false;
RowsSelection::iterator current_selection_begin(current_selection->begin());
RowsSelection::iterator current_selection_end(current_selection->end());
//inspect the selected frames, if they are all set, then unset all, else set all
bool newValue = false;
for(RowsSelection::iterator it(current_selection_begin); it != current_selection_end; it++)
{
if (!(currMovieData.records[*it].checkBit(joy,button)))
{
newValue = true;
break;
}
}
// apply newValue
for(RowsSelection::iterator it(current_selection_begin); it != current_selection_end; it++)
currMovieData.records[*it].setBitValue(joy,button,newValue);
int first_changes;
if (newValue)
{
first_changes = history.registerChanges(MODTYPE_SET, *current_selection_begin, *current_selection->rbegin());
} else
{
first_changes = history.registerChanges(MODTYPE_UNSET, *current_selection_begin, *current_selection->rbegin());
}
if (first_changes >= 0)
{
greenzone.invalidateAndUpdatePlayback(first_changes);
return true;
} else
return false;
}
int PCB_EDITOR_CONTROL::ZoneMerge( const TOOL_EVENT& aEvent )
{
SELECTION selection = m_toolMgr->GetTool<SELECTION_TOOL>()->GetSelection();
BOARD* board = getModel<BOARD>();
RN_DATA* ratsnest = board->GetRatsnest();
KIGFX::VIEW* view = getView();
if( selection.Size() < 2 )
return 0;
PICKED_ITEMS_LIST changes;
int netcode = -1;
// Loop through all combinations
for( int ia1 = 0; ia1 < selection.Size() - 1; ++ia1 )
{
ZONE_CONTAINER* curr_area = dynamic_cast<ZONE_CONTAINER*>( selection.Item<EDA_ITEM>( ia1 ) );
if( !curr_area )
continue;
netcode = curr_area->GetNetCode();
EDA_RECT b1 = curr_area->Outline()->GetBoundingBox();
bool mod_ia1 = false;
for( int ia2 = selection.Size() - 1; ia2 > ia1; --ia2 )
{
ZONE_CONTAINER* area2 = dynamic_cast<ZONE_CONTAINER*>( selection.Item<EDA_ITEM>( ia2 ) );
if( !area2 )
continue;
if( area2->GetNetCode() != netcode )
continue;
if( curr_area->GetPriority() != area2->GetPriority() )
continue;
if( curr_area->GetIsKeepout() != area2->GetIsKeepout() )
continue;
if( curr_area->GetLayer() != area2->GetLayer() )
continue;
EDA_RECT b2 = area2->Outline()->GetBoundingBox();
if( b1.Intersects( b2 ) )
{
EDA_ITEM* backup = curr_area->Clone();
bool ret = board->TestAreaIntersection( curr_area, area2 );
if( ret && board->CombineAreas( &changes, curr_area, area2 ) )
{
mod_ia1 = true;
selection.items.RemovePicker( ia2 );
ITEM_PICKER picker( curr_area, UR_CHANGED );
picker.SetLink( backup );
changes.PushItem( picker );
}
else
{
delete backup;
}
}
}
if( mod_ia1 )
--ia1; // if modified, we need to check it again
}
m_toolMgr->RunAction( COMMON_ACTIONS::selectionClear, true );
m_frame->SaveCopyInUndoList( changes, UR_UNSPECIFIED );
for( unsigned i = 0; i < changes.GetCount(); ++i )
{
ITEM_PICKER picker = changes.GetItemWrapper( i );
BOARD_ITEM* item = static_cast<BOARD_ITEM*>( picker.GetItem() );
if( picker.GetStatus() == UR_DELETED )
{
view->Remove( item );
ratsnest->Remove( item );
}
else if( picker.GetStatus() == UR_CHANGED )
{
item->ViewUpdate( KIGFX::VIEW_ITEM::ALL );
m_toolMgr->RunAction( COMMON_ACTIONS::selectItem, true, item );
}
}
return 0;
}
void PCB_TOOL::doInteractiveItemPlacement( INTERACTIVE_PLACER_BASE* aPlacer,
const wxString& aCommitMessage,
int aOptions )
{
using namespace std::placeholders;
std::unique_ptr<BOARD_ITEM> newItem;
Activate();
BOARD_COMMIT commit( frame() );
GetManager()->RunAction( PCB_ACTIONS::selectionClear, true );
// do not capture or auto-pan until we start placing an item
controls()->ShowCursor( true );
controls()->SetSnapping( true );
// Add a VIEW_GROUP that serves as a preview for the new item
SELECTION preview;
view()->Add( &preview );
aPlacer->m_board = board();
aPlacer->m_frame = frame();
if( aOptions & IPO_SINGLE_CLICK )
{
VECTOR2I cursorPos = controls()->GetCursorPosition();
newItem = aPlacer->CreateItem();
newItem->SetPosition( wxPoint( cursorPos.x, cursorPos.y ) );
preview.Add( newItem.get() );
}
// Main loop: keep receiving events
while( OPT_TOOL_EVENT evt = Wait() )
{
VECTOR2I cursorPos = controls()->GetCursorPosition();
if( TOOL_EVT_UTILS::IsCancelInteractive( *evt ) )
{
if( newItem )
{
// Delete the old item and have another try
newItem = nullptr;
preview.Clear();
if( aOptions & IPO_SINGLE_CLICK )
break;
controls()->SetAutoPan( false );
controls()->CaptureCursor( false );
controls()->ShowCursor( true );
}
else
{
break;
}
if( evt->IsActivate() ) // now finish unconditionally
break;
}
else if( evt->IsClick( BUT_LEFT ) )
{
if( !newItem )
{
// create the item if possible
newItem = aPlacer->CreateItem();
// no item created, so wait for another click
if( !newItem )
continue;
controls()->CaptureCursor( true );
controls()->SetAutoPan( true );
newItem->SetPosition( wxPoint( cursorPos.x, cursorPos.y ) );
preview.Add( newItem.get() );
if( newItem->Type() == PCB_MODULE_T )
{
auto module = dyn_cast<MODULE*>( newItem.get() );
// modules have more drawable parts
module->RunOnChildren( std::bind( &KIGFX::VIEW_GROUP::Add, &preview, _1 ) );
}
}
else
{
newItem->ClearFlags();
preview.Remove( newItem.get() );
aPlacer->PlaceItem( newItem.get() );
if( newItem->Type() == PCB_MODULE_T )
{
auto module = dyn_cast<MODULE*>( newItem.get() );
module->RunOnChildren( std::bind( &KIGFX::VIEW_GROUP::Remove, &preview, _1 ) );
}
commit.Add( newItem.release() );
commit.Push( aCommitMessage );
controls()->CaptureCursor( false );
controls()->SetAutoPan( false );
controls()->ShowCursor( true );
if( !( aOptions & IPO_REPEAT ) )
break;
if( aOptions & IPO_SINGLE_CLICK )
{
VECTOR2I pos = controls()->GetCursorPosition();
newItem = aPlacer->CreateItem();
newItem->SetPosition( wxPoint( pos.x, pos.y ) );
preview.Add( newItem.get() );
}
}
}
else if( newItem && evt->Category() == TC_COMMAND )
{
/*
* Handle any events that can affect the item as we move
* it around, eg rotate and flip
*/
if( TOOL_EVT_UTILS::IsRotateToolEvt( *evt ) && ( aOptions & IPO_ROTATE ) )
{
const auto rotationAngle = TOOL_EVT_UTILS::GetEventRotationAngle(
*frame(), *evt );
newItem->Rotate( newItem->GetPosition(), rotationAngle );
view()->Update( &preview );
}
else if( evt->IsAction( &PCB_ACTIONS::flip ) && ( aOptions & IPO_FLIP ) )
{
newItem->Flip( newItem->GetPosition() );
view()->Update( &preview );
}
}
else if( newItem && evt->IsMotion() )
{
// track the cursor
newItem->SetPosition( wxPoint( cursorPos.x, cursorPos.y ) );
// Show a preview of the item
view()->Update( &preview );
}
}
view()->Remove( &preview );
}
bool SELECTION_CONDITIONS::NotEmpty( const SELECTION& aSelection )
{
return !aSelection.Empty();
}
bool SELECTION_CONDITIONS::lessThanFunc( const SELECTION& aSelection, int aNumber )
{
return aSelection.Size() < aNumber;
}
bool SELECTION_CONDITIONS::countFunc( const SELECTION& aSelection, int aNumber )
{
return aSelection.Size() == aNumber;
}
// returns true if Taseditor is engaged at the end of the function
bool enterTASEditor()
{
if (taseditorWindow.hwndTASEditor)
{
// TAS Editor is already engaged, just set focus to its window
if (!taseditorConfig.windowIsMaximized)
ShowWindow(taseditorWindow.hwndTASEditor, SW_SHOWNORMAL);
SetForegroundWindow(taseditorWindow.hwndTASEditor);
return true;
} else if (FCEU_IsValidUI(FCEUI_TASEDITOR))
{
// start TAS Editor
// create window
taseditorWindow.init();
if (taseditorWindow.hwndTASEditor)
{
enableGeneralKeyboardInput();
// save "eoptions"
saved_eoptions = eoptions;
// set "Run in background"
eoptions |= EO_BGRUN;
// "Set high-priority thread"
eoptions |= EO_HIGHPRIO;
DoPriority();
// switch off autosaves
saved_EnableAutosave = EnableAutosave;
EnableAutosave = 0;
// switch on frame_display
saved_frame_display = frame_display;
frame_display = 1;
UpdateCheckedMenuItems();
// init modules
editor.init();
pianoRoll.init();
selection.init();
splicer.init();
playback.init();
greenzone.init();
recorder.init();
markersManager.init();
project.init();
bookmarks.init();
branches.init();
popupDisplay.init();
history.init();
taseditor_lua.init();
// either start new movie or use current movie
if (!FCEUMOV_Mode(MOVIEMODE_RECORD|MOVIEMODE_PLAY) || currMovieData.savestate.size() != 0)
{
if (currMovieData.savestate.size() != 0)
FCEUD_PrintError("This version of TAS Editor doesn't work with movies starting from savestate.");
// create new movie
FCEUI_StopMovie();
movieMode = MOVIEMODE_TASEDITOR;
FCEUMOV_CreateCleanMovie();
playback.restartPlaybackFromZeroGround();
} else
{
// use current movie to create a new project
FCEUI_StopMovie();
movieMode = MOVIEMODE_TASEDITOR;
}
// if movie length is less or equal to currFrame, pad it with empty frames
if (((int)currMovieData.records.size() - 1) < currFrameCounter)
currMovieData.insertEmpty(-1, currFrameCounter - ((int)currMovieData.records.size() - 1));
// ensure that movie has correct set of ports/fourscore
setInputType(currMovieData, getInputType(currMovieData));
// force the input configuration stored in the movie to apply to FCEUX config
applyMovieInputConfig();
// reset some modules that need MovieData info
pianoRoll.reset();
recorder.reset();
// create initial snapshot in history
history.reset();
// reset Taseditor variables
mustCallManualLuaFunction = false;
SetFocus(history.hwndHistoryList); // set focus only once, to show blue selection cursor
SetFocus(pianoRoll.hwndList);
FCEU_DispMessage("TAS Editor engaged", 0);
taseditorWindow.redraw();
return true;
} else
{
// couldn't init window
return false;
}
} else
{
// right now TAS Editor launch is not allowed by emulator
return true;
}
}
