private void DragBottom(double scale, DesignerItem item, SelectionService selectionService)
{
IEnumerable<DesignerItem> groupItems = selectionService.GetGroupMembers(item).Cast<DesignerItem>();
double groupTop = Canvas.GetTop(item);
foreach (DesignerItem groupItem in groupItems)
{
double groupItemTop = Canvas.GetTop(groupItem);
double delta = (groupItemTop - groupTop) * (scale - 1);
Canvas.SetTop(groupItem, groupItemTop + delta);
groupItem.Height = groupItem.ActualHeight * scale;
}
}
private void DragLeft(double scale, DesignerItem item, SelectionService selectionService)
{
IEnumerable<DesignerItem> groupItems = selectionService.GetGroupMembers(item).Cast<DesignerItem>();
double groupLeft = Canvas.GetLeft(item) + item.Width;
foreach (DesignerItem groupItem in groupItems)
{
double groupItemLeft = Canvas.GetLeft(groupItem);
double delta = (groupLeft - groupItemLeft) * (scale - 1);
Canvas.SetLeft(groupItem, groupItemLeft - delta);
groupItem.Width = groupItem.ActualWidth * scale;
}
}
/// <include file='doc\InstallerDesign.uex' path='docs/doc[@for="InstallerDesign.SelectComponents"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public static void SelectComponents(IComponent[] components)
{
SelectionService selContainer = (SelectionService)components[0].Site.GetService(typeof(ISelectionService));
selContainer.SetSelectedComponents(components);
/*
* IContainer container = host.Container;
* IComponent[] allComponents = container.Components;
* object[] allObjects = new object[allComponents.Length];
* for (int i = 0; i < allObjects.Length; i++)
* allObjects[i] = allComponents[i];
* selContainer.AllObjects = allObjects;
* object[] componentsAsObjects = new object[components.Length];
* for (int i = 0; i < components.Length; i++)
* componentsAsObjects[i] = components[i];
* selContainer.SelectObjects(1, componentsAsObjects, 0);
* ITrackSelection trackSel = (ITrackSelection) host.GetService(typeof(ITrackSelection));
* trackSel.OnSelectChange(selContainer);
*/
}
protected override bool EvaluateCanExecute(object parameter)
{
if (_state.Status != ParserState.Ready)
{
return(false);
}
var activeSelection = SelectionService.ActiveSelection();
if (!activeSelection.HasValue)
{
return(false);
}
var target = _state.DeclarationFinder.FindSelectedDeclaration(activeSelection.Value);
return(target != null &&
!_state.IsNewOrModified(target.QualifiedModuleName) &&
(target.DeclarationType == DeclarationType.Variable ||
target.DeclarationType == DeclarationType.Constant) &&
target.References.Any());
}
public AppController(ILauncherService launcherService, IAppInfoService appInfoService, IAppDataService appDataService, SelectionService selectionService,
Lazy <NewsFeedsController> newsFeedsController, Lazy <SettingsController> settingsController, Lazy <ShellViewModel> shellViewModel,
Lazy <FeedListViewModel> feedListViewModel, Lazy <FeedItemListViewModel> feedItemListViewModel, Lazy <FeedItemViewModel> feedItemViewModel)
{
this.launcherService = launcherService;
this.appInfoService = appInfoService;
this.appDataService = appDataService;
this.selectionService = selectionService;
this.newsFeedsController = newsFeedsController;
this.settingsController = settingsController;
this.shellViewModel = shellViewModel;
this.feedListViewModel = new Lazy <FeedListViewModel>(() => InitializeFeedListViewModel(feedListViewModel));
this.feedItemListViewModel = new Lazy <FeedItemListViewModel>(() => InitializeFeedItemListViewModel(feedItemListViewModel));
this.feedItemViewModel = new Lazy <FeedItemViewModel>(() => InitializeFeedItemViewModel(feedItemViewModel));
this.navigateBackCommand = new DelegateCommand(NavigateBack, CanNavigateBack);
this.showFeedListViewCommand = new DelegateCommand(() => SelectedNavigationItem = NavigationItem.FeedList);
this.showFeedItemListViewCommand = new DelegateCommand(ShowFeedItemListView);
this.showFeedItemViewCommand = new DelegateCommand(ShowFeedItemView);
this.showReviewViewCommand = new AsyncDelegateCommand(ShowReviewView);
this.showSettingsViewCommand = new DelegateCommand(ShowSettingsView);
this.navigationStack = new Stack <NavigationItem>();
}
public void LoadGuides()
{
//reset page-view when change page or change adaptive view.
_pageView = _page.PageViews.GetPageView(SelectionService.GetCurrentPage().CurAdaptiveViewGID);
if (_pageView == null)
{
_pageView = _page.PageViews.GetPageView(_document.AdaptiveViewSet.Base.Guid);
}
if (_pageView == null)
{
return;
}
if (GuideType == GuideType.Local)
{
LoadPageGuide();
}
else
{
LoadGlobalGuide();
}
}
protected override bool EvaluateCanExecute(object parameter)
{
//This should come first because it does not require COM access.
if (_state.Status != ParserState.Ready)
{
return(false);
}
var activeSelection = SelectionService.ActiveSelection();
if (!activeSelection.HasValue)
{
return(false);
}
var target = _state.DeclarationFinder.FindSelectedDeclaration(activeSelection.Value);
return(target != null &&
target.DeclarationType == DeclarationType.Variable &&
!target.ParentScopeDeclaration.DeclarationType.HasFlag(DeclarationType.Member) &&
!_state.IsNewOrModified(target.QualifiedModuleName));
}
public ManagerController(IShellService shellService, IEnvironmentService environmentService, SelectionService selectionService, CrawlerService crawlerService,
Lazy <ManagerViewModel> managerViewModel)
{
this.shellService = shellService;
this.environmentService = environmentService;
this.selectionService = selectionService;
this.crawlerService = crawlerService;
this.managerViewModel = managerViewModel;
this.blogFiles = new ObservableCollection <Blog>();
this.addBlogCommand = new DelegateCommand(AddBlog, CanAddBlog);
this.removeBlogCommand = new DelegateCommand(RemoveBlog, CanRemoveBlog);
this.showFilesCommand = new DelegateCommand(ShowFiles, CanShowFiles);
this.visitBlogCommand = new DelegateCommand(VisitBlog, CanVisitBlog);
this.enqueueSelectedCommand = new DelegateCommand(EnqueueSelected, CanEnqueueSelected);
this.crawlCommand = new DelegateCommand(Crawl, CanCrawl);
this.pauseCommand = new DelegateCommand(Pause, CanPause);
this.resumeCommand = new DelegateCommand(Resume, CanResume);
this.stopCommand = new DelegateCommand(Stop, CanStop);
this.listenClipboardCommand = new DelegateCommand(ListenClipboard);
this.autoDownloadCommand = new DelegateCommand(EnqueueAutoDownload, CanEnqueueAutoDownload);
this.runningTasks = new List <Task>();
}
protected override bool EvaluateCanExecute(object parameter)
{
if (_state.Status != ParserState.Ready)
{
return(false);
}
var activeSelection = SelectionService.ActiveSelection();
if (!activeSelection.HasValue)
{
return(false);
}
var target = _state.DeclarationFinder
.UserDeclarations(DeclarationType.Variable)
.FindVariable(activeSelection.Value);
return(target != null &&
!_state.IsNewOrModified(target.QualifiedModuleName) &&
target.ParentScopeDeclaration.DeclarationType.HasFlag(DeclarationType.Member));
}
protected virtual void OnMouseInput(InputObject input)
{
if (input.InputType != InputType.MouseButton1 || input.InputState != InputState.Begin ||
BaseHandles.IsMouseOverHandle)
{
return;
}
var sel = SelectionService.First();
if (_target == null)
{
Game.Selection.ClearSelection();
return;
}
if (_target.IsSelected)
{
ToolManager.PrimaryItem = _target;
return;
}
if (InputService.Service.IsKeyDown(Key.LeftControl))
{
if (_target != sel)
{
Game.Selection.Select(_target);
}
else
{
Game.Selection.Deselect(_target);
}
}
else
{
Game.Selection.Select(_target, true);
}
}
protected override void OnInitialize()
{
base.OnInitialize();
musicFileContext = Container.GetExportedValue <MockMusicFileContext>();
musicFiles = new ObservableCollection <MusicFile>()
{
musicFileContext.Create(@"C:\Users\Public\Music\Dancefloor\Culture Beat - Serenity.wav"),
musicFileContext.Create(@"C:\Culture Beat - Serenity - Epilog.wma"),
};
selectionService = Container.GetExportedValue <SelectionService>();
selectionService.Initialize(musicFiles);
playlistManager = new PlaylistManager();
controller = Container.GetExportedValue <MusicPropertiesController>();
controller.PlaylistManager = playlistManager;
controller.Initialize();
var shellService = Container.GetExportedValue <ShellService>();
view = (MockMusicPropertiesView)shellService.MusicPropertiesView;
viewModel = ViewHelper.GetViewModel <MusicPropertiesViewModel>(view);
}
protected virtual void Delete()
{
try
{
var deletables = GetSelectedDeleteables().ToArray();
if (deletables.Any())
{
foreach (var deletable in GetSelectedDeleteables())
{
deletable.Delete();
}
SelectionService.SelectNone();
UndoProvider?.SaveUndoState();
}
}
catch (Exception ex)
{
MessageBoxService.Show(ex);
}
}
protected virtual void OnItemDeselected(Instance instance)
{
var pv = instance as PVInstance;
if (pv == null)
{
return;
}
SelectionBox box;
if (_selectionBoxes.TryRemove(pv, out box))
{
box.Destroy();
}
if (ToolManager.PrimaryItem == instance)
{
ToolManager.PrimaryItem = SelectionService.Last();
}
UpdateHandles();
}
protected override bool EvaluateCanExecute(object parameter)
{
if (_state.Status != ParserState.Ready)
{
return(false);
}
var activeSelection = SelectionService.ActiveSelection();
if (!activeSelection.HasValue)
{
return(false);
}
var targetInterface = _state.DeclarationFinder.FindInterface(activeSelection.Value);
var targetClass = _state.DeclarationFinder.Members(activeSelection.Value.QualifiedName)
.SingleOrDefault(declaration => declaration.DeclarationType == DeclarationType.ClassModule);
return(targetInterface != null && targetClass != null &&
!_state.IsNewOrModified(targetInterface.QualifiedModuleName) &&
!_state.IsNewOrModified(targetClass.QualifiedModuleName));
}
private void Start()
{
selectionService = FindObjectOfType <SelectionService>();
}
private void DragTop(double scale, DesignerItem item, SelectionService selectionService)
{
var groupItems = selectionService.GetGroupMembers(item).Cast<DesignerItem>();
var groupBottom = Canvas.GetTop(item) + item.Height;
foreach (var groupItem in groupItems)
{
var groupItemTop = Canvas.GetTop(groupItem);
var delta = (groupBottom - groupItemTop)*(scale - 1);
Canvas.SetTop(groupItem, groupItemTop - delta);
groupItem.Height = groupItem.ActualHeight*scale;
}
}
public TodoController(SelectionService _service) : base(_service)
{
}
/// <summary>
/// load all widgets/groups which is not in a group in current page.
/// which means,only load top level widget/group.
/// </summary>
public void LoadPageWidgets()
{
if (_selectedWidget == null || _widgetShowHideAction == null)
{
DisableInteraction();
return;
}
WidgetList.Clear();
List <IWidgetPropertyData> allWidgets = SelectionService.GetCurrentPage().GetAllWidgets();
List <WidgetNode> TargetWidgets = new List <WidgetNode>();
foreach (IWidgetPropertyData it in allWidgets.Where(x => x.IsGroup == false))
{
WidgetViewModBase wdg = it as WidgetViewModBase;
if (wdg == null)
{
continue;
}
// load widget that is not in a group .
if ((wdg.ParentID == Guid.Empty))
{
bool bChecked = false;
IRegion targetObject = wdg.WidgetModel.WdgDom;
if (targetObject == null)
{
break;
}
//if the widget is already checked.
var selWidget = _widgetShowHideAction.TargetObjects.FirstOrDefault(x => x.Guid == targetObject.Guid);
if (selWidget != null)
{
bChecked = true;
}
TargetWidgets.Add(new WidgetNode(this, targetObject, wdg.Type, bChecked));
}
}
//load all groups.
foreach (IGroup group in _currentPage.Groups)
{
bool bChecked = false;
var selGroup = _widgetShowHideAction.TargetObjects.FirstOrDefault(x => x.Guid == group.Guid);
if (selGroup != null)
{
bChecked = true;
}
TargetWidgets.Add(new WidgetNode(this, group, ObjectType.Group, bChecked));
}
_isCheckAll = !TargetWidgets.Any(x => x.IsSelected == false);
WidgetList.AddRange(TargetWidgets);
FirePropertyChanged("IsCheckAll");
FirePropertyChanged("ShowHideType");
FirePropertyChanged("AnimateType");
FirePropertyChanged("AnimateTime");
FirePropertyChanged("IsShowHideEnabled");
}
private void DragRight(double scale, ElementVM elementVm, SelectionService selectionService)
{
elementVm.Width = elementVm.Width * scale;
}
public static (SynchronousParseCoordinator parser, IRewritingManager rewritingManager) CreateWithRewriteManager(IVBE vbe, RubberduckParserState state, IProjectsRepository projectRepository, string serializedComProjectsPath = null, IDictionary <string, IEnumerable <string> > documentModuleSupertypeNames = null)
{
var vbeVersion = double.Parse(vbe.Version, CultureInfo.InvariantCulture);
var compilationArgumentsProvider = MockCompilationArgumentsProvider(vbeVersion);
var compilationsArgumentsCache = new CompilationArgumentsCache(compilationArgumentsProvider);
var userComProjectsRepository = MockUserComProjectRepository();
var documentSuperTypesProvider = MockDocumentSuperTypeNamesProvider(documentModuleSupertypeNames);
var ignoredProjectsSettingsProvider = MockIgnoredProjectsSettingsProviderMock();
var projectsToBeLoadedFromComSelector = new ProjectsToResolveFromComProjectsSelector(projectRepository, ignoredProjectsSettingsProvider);
var path = serializedComProjectsPath ??
Path.Combine(Path.GetDirectoryName(Assembly.GetAssembly(typeof(MockParser)).Location), "Testfiles", "Resolver");
var preprocessorErrorListenerFactory = new PreprocessingParseErrorListenerFactory();
var preprocessorParser = new VBAPreprocessorParser(preprocessorErrorListenerFactory, preprocessorErrorListenerFactory);
var preprocessor = new VBAPreprocessor(preprocessorParser, compilationsArgumentsCache);
var mainParseErrorListenerFactory = new MainParseErrorListenerFactory();
var mainTokenStreamParser = new VBATokenStreamParser(mainParseErrorListenerFactory, mainParseErrorListenerFactory);
var tokenStreamProvider = new SimpleVBAModuleTokenStreamProvider();
var stringParser = new TokenStreamParserStringParserAdapterWithPreprocessing(tokenStreamProvider, mainTokenStreamParser, preprocessor);
var vbaParserAnnotationFactory = new VBAParserAnnotationFactory(WellKnownAnnotations());
var projectManager = new RepositoryProjectManager(projectRepository);
var moduleToModuleReferenceManager = new ModuleToModuleReferenceManager();
var supertypeClearer = new SynchronousSupertypeClearer(state);
var parserStateManager = new SynchronousParserStateManager(state);
var referenceRemover = new SynchronousReferenceRemover(state, moduleToModuleReferenceManager);
var baseComDeserializer = new XmlComProjectSerializer(new MockFileSystem(), path);
var comDeserializer = new StaticCachingComDeserializerDecorator(baseComDeserializer);
var declarationsFromComProjectLoader = new DeclarationsFromComProjectLoader();
var referencedDeclarationsCollector = new SerializedReferencedDeclarationsCollector(declarationsFromComProjectLoader, comDeserializer);
var userComProjectSynchronizer = new UserComProjectSynchronizer(state, declarationsFromComProjectLoader, userComProjectsRepository, projectsToBeLoadedFromComSelector);
var comSynchronizer = new SynchronousCOMReferenceSynchronizer(
state,
parserStateManager,
projectRepository,
referencedDeclarationsCollector);
var builtInDeclarationLoader = new BuiltInDeclarationLoader(
state,
new List <ICustomDeclarationLoader>
{
new DebugDeclarations(state),
new SpecialFormDeclarations(state),
new FormEventDeclarations(state),
new AliasDeclarations(state),
});
var codePaneComponentSourceCodeHandler = new CodeModuleComponentSourceCodeHandler();
var codePaneSourceCodeHandler = new ComponentSourceCodeHandlerSourceCodeHandlerAdapter(codePaneComponentSourceCodeHandler, projectRepository);
//We use the same handler because to achieve consistency between the return values.
var attributesSourceCodeHandler = codePaneSourceCodeHandler;
var moduleParser = new ModuleParser(
codePaneSourceCodeHandler,
attributesSourceCodeHandler,
stringParser,
vbaParserAnnotationFactory);
var parseRunner = new SynchronousParseRunner(
state,
parserStateManager,
moduleParser);
var declarationResolveRunner = new SynchronousDeclarationResolveRunner(
state,
parserStateManager,
comSynchronizer);
var referenceResolveRunner = new SynchronousReferenceResolveRunner(
state,
parserStateManager,
moduleToModuleReferenceManager,
referenceRemover,
documentSuperTypesProvider);
var parsingStageService = new ParsingStageService(
comSynchronizer,
builtInDeclarationLoader,
parseRunner,
declarationResolveRunner,
referenceResolveRunner,
userComProjectSynchronizer
);
var parsingCacheService = new ParsingCacheService(
state,
moduleToModuleReferenceManager,
referenceRemover,
supertypeClearer,
compilationsArgumentsCache,
userComProjectsRepository,
projectsToBeLoadedFromComSelector
);
var tokenStreamCache = new StateTokenStreamCache(state);
var moduleRewriterFactory = new ModuleRewriterFactory(
codePaneSourceCodeHandler,
attributesSourceCodeHandler);
var rewriterProvider = new RewriterProvider(tokenStreamCache, moduleRewriterFactory);
var selectionService = new SelectionService(vbe, projectRepository);
var selectionRecoverer = new SelectionRecoverer(selectionService, state);
var rewriteSessionFactory = new RewriteSessionFactory(state, rewriterProvider, selectionRecoverer);
var stubMembersAttributeRecoverer = new Mock <IMemberAttributeRecovererWithSettableRewritingManager>().Object;
var rewritingManager = new RewritingManager(rewriteSessionFactory, stubMembersAttributeRecoverer);
var parser = new SynchronousParseCoordinator(
state,
parsingStageService,
parsingCacheService,
projectManager,
parserStateManager,
rewritingManager);
return(parser, rewritingManager);
}
public NewsFeedsController(IResourceService resourceService, IAppService appService, ILauncherService launcherService, IMessageService messageService,
ISyndicationService syndicationService, INetworkInfoService networkInfoService, SelectionService selectionService, Lazy <FeedListViewModel> feedListViewModel)
{
this.resourceService = resourceService;
this.appService = appService;
this.launcherService = launcherService;
this.messageService = messageService;
this.networkInfoService = networkInfoService;
this.selectionService = selectionService;
this.feedListViewModel = feedListViewModel;
this.client = syndicationService.CreateClient();
this.addNewFeedCommand = new AsyncDelegateCommand(AddNewFeed);
this.removeFeedCommand = new AsyncDelegateCommand(RemoveFeedAsync, CanRemoveFeed);
this.refreshFeedCommand = new AsyncDelegateCommand(RefreshFeed, CanRefreshFeed);
this.readUnreadCommand = new DelegateCommand(MarkAsReadUnread, CanMarkAsReadUnread);
this.launchWebBrowserCommand = new AsyncDelegateCommand(LaunchWebBrowser, CanLaunchWebBrowser);
this.selectionService.PropertyChanged += SelectionServicePropertyChanged;
}
public FeedItemListViewModel(IFeedItemListView view, SelectionService selectionService) : base(view)
{
SelectionService = selectionService;
SelectionService.PropertyChanged += SelectionServicePropertyChanged;
UpdateItemsListView();
}
private ISelectedDeclarationProvider SelectedDeclarationProvider(IVBE vbe, RubberduckParserState state)
{
var selectionProvider = new SelectionService(vbe, state.ProjectsProvider);
return(new SelectedDeclarationProvider(selectionProvider, state));
}
/// <summary>
/// Navigates to the next page.
/// </summary>
protected void NavigateNextHandler(object sender, EventArgs e)
{
Control.GoNext();
SelectionService.SetSelectedComponents(new Component[] { Control.SelectedPage });
}
public SummaryController(StvContext db)
{
_db = db;
service = new SelectionService(_db);
}
private bool CanCopy()
{
return(SelectionService.GetSelected().Any());
}
private void DragRight(double scale, DesignerItem item, SelectionService selectionService)
{
var groupItems = selectionService.GetGroupMembers(item).Cast<DesignerItem>();
var groupLeft = Canvas.GetLeft(item);
foreach (var groupItem in groupItems)
{
var groupItemLeft = Canvas.GetLeft(groupItem);
var delta = (groupItemLeft - groupLeft)*(scale - 1);
Canvas.SetLeft(groupItem, groupItemLeft + delta);
groupItem.Width = groupItem.ActualWidth*scale;
}
}
private void Paste_Executed(object sender, ExecutedRoutedEventArgs e)
{
XElement root = LoadSerializedDataFromClipBoard();
if (root == null)
{
return;
}
// create DesignerItems
Dictionary <Guid, Guid> mappingOldToNewIDs = new Dictionary <Guid, Guid>();
List <ISelectable> newItems = new List <ISelectable>();
IEnumerable <XElement> itemsXML = root.Elements("DesignerItems").Elements("DesignerItem");
double offsetX = Double.Parse(root.Attribute("OffsetX").Value, CultureInfo.InvariantCulture);
double offsetY = Double.Parse(root.Attribute("OffsetY").Value, CultureInfo.InvariantCulture);
foreach (XElement itemXML in itemsXML)
{
Guid oldID = new Guid(itemXML.Element("ID").Value);
Guid newID = Guid.NewGuid();
mappingOldToNewIDs.Add(oldID, newID);
DesignerItem item = DeserializeDesignerItem(itemXML, newID, offsetX, offsetY);
this.Children.Add(item);
SetConnectorDecoratorTemplate(item);
newItems.Add(item);
}
// update group hierarchy
SelectionService.ClearSelection();
foreach (DesignerItem el in newItems)
{
if (el.ParentID != Guid.Empty)
{
el.ParentID = mappingOldToNewIDs[el.ParentID];
}
}
foreach (DesignerItem item in newItems)
{
if (item.ParentID == Guid.Empty)
{
SelectionService.AddToSelection(item);
}
}
// create Connections
IEnumerable <XElement> connectionsXML = root.Elements("Connections").Elements("Connection");
foreach (XElement connectionXML in connectionsXML)
{
Guid oldSourceID = new Guid(connectionXML.Element("SourceID").Value);
Guid oldSinkID = new Guid(connectionXML.Element("SinkID").Value);
if (mappingOldToNewIDs.ContainsKey(oldSourceID) && mappingOldToNewIDs.ContainsKey(oldSinkID))
{
Guid newSourceID = mappingOldToNewIDs[oldSourceID];
Guid newSinkID = mappingOldToNewIDs[oldSinkID];
String sourceConnectorName = connectionXML.Element("SourceConnectorName").Value;
String sinkConnectorName = connectionXML.Element("SinkConnectorName").Value;
Connector sourceConnector = GetConnector(newSourceID, sourceConnectorName);
Connector sinkConnector = GetConnector(newSinkID, sinkConnectorName);
Connection connection = new Connection(sourceConnector, sinkConnector);
Canvas.SetZIndex(connection, Int32.Parse(connectionXML.Element("zIndex").Value));
this.Children.Add(connection);
SelectionService.AddToSelection(connection);
}
}
DesignerCanvas.BringToFront.Execute(null, this);
// update paste offset
root.Attribute("OffsetX").Value = (offsetX + 10).ToString();
root.Attribute("OffsetY").Value = (offsetY + 10).ToString();
Clipboard.Clear();
Clipboard.SetData(DataFormats.Xaml, root);
}
// Start is called before the first frame update
public virtual void Awake()
{
selectionService = FindObjectOfType <SelectionService>();
stats = gameObject.GetComponent <Stats>();
}
private void SelectAll_Executed(object sender, ExecutedRoutedEventArgs e)
{
SelectionService.SelectAll();
}
public void Solve()
{
if (Settings.MutationType == MutationType.AfterSelection)
{
Settings.MutationChance = 0;
}
if (Settings.MutationType == MutationType.BeforeSelection)
{
Settings.MutationChanceAfterCrossing = 0;
}
FirstMutation = new Dictionary <Chromosome, Chromosome>();
foreach (var item in InitialChromosomes)
{
Chromosome chr = item.Mutate(Settings.MutationChance);
chr.GId = Id;
if (!item.EqualByGenes(chr))
{
if (chr.IsValid())
{
FirstMutation.Add(item, chr);
}
}
}
AfterFirstMutation = new List <Chromosome>();
AfterFirstMutation.AddRange(InitialChromosomes);
AfterFirstMutation.AddRange(FirstMutation.Values.AsEnumerable());
foreach (var item in FirstMutation.Keys)
{
if (FirstMutation[item].IsValid())
{
AfterFirstMutation.RemoveAll(ch => ch.EqualByGenes(item));
}
}
Pairs1 = new List <ChromosomePair>();
for (int i = 0; i < AfterFirstMutation.Count / 2; i++)
{
Pairs1.Add(SelectionService.GetPair(AfterFirstMutation, Settings.SelectionType));
}
Winners1 = Pairs1.Select(p => (p.Chr1.F > p.Chr2.F) ? p.Chr1 : p.Chr2).ToList();
Pairs2 = new List <ChromosomePair>();
for (int i = 0; i < AfterFirstMutation.Count / 2; i++)
{
Pairs2.Add(SelectionService.GetPair(AfterFirstMutation, Settings.SelectionType));
}
Winners2 = Pairs2.Select(p => (p.Chr1.F > p.Chr2.F) ? p.Chr1 : p.Chr2).ToList();
PairsForGeneticOperation = new List <ChromosomePair>();
for (int i = 0; i < Winners1.Count; i++)
{
PairsForGeneticOperation.Add(new ChromosomePair()
{
Chr1 = Winners1[i], Chr2 = Winners2[i]
});
}
GeneticOperationRezults = new List <Chromosome>();
foreach (var item in PairsForGeneticOperation)
{
List <Chromosome> pairRezult = CrossingService.DoCrossing(item, Settings.CrossingGenNumber, Settings.MutationChanceAfterCrossing);
for (int i = 0; i < pairRezult.Count; i++)
{
pairRezult[i].GId = Id;
}
GeneticOperationRezults.AddRange(pairRezult.Where(p => p.IsValid()));
}
AllFinishChromosome = new List <Chromosome>();
AllFinishChromosome.AddRange(AfterFirstMutation);
AllFinishChromosome.AddRange(GeneticOperationRezults);
ChromosomeComparer comparer = new ChromosomeComparer();
Output = AllFinishChromosome.Distinct(comparer).OrderByDescending(ch => ch.F).Take(Settings.SurvivedCount).ToList();
BestChromosome = Output[0];
BestF = BestChromosome.F;
IsSolved = true;
}
private void LoadActions()
{
List <IWidgetPropertyData> list = SelectionService.GetSelectedWidgets();
if (_currentPage == null ||
list == null ||
list.Count != 1 ||
!(list.ElementAt(0) is WidgetViewModBase) ||
(list.ElementAt(0) as WidgetViewModBase).IsGroup ||
(list.ElementAt(0) as WidgetViewModBase).Type == ObjectType.Master)
{
// Only support one selected widget.
DisableInteraction();
return;
}
IWidget widget = _currentPage.Widgets.GetWidget(list[0].WidgetID);
if (widget == null || _selectedWidget == widget ||
widget.WidgetType == WidgetType.HamburgerMenu ||
widget.WidgetType == WidgetType.DynamicPanel ||
widget.WidgetType == WidgetType.Toast)
{
// Selected item is not widget, or the same widget
DisableInteraction();
return;
}
CanEdit = true;
// Selected widget changed, get or create action from new widget.
_widgetOpenAction = null;
_widgetShowHideAction = null;
_selectedWidget = widget;
IInteractionEvent clickEvent = widget.Events[EventType.OnClick];
if (clickEvent == null)
{
return;
}
//Create action
IInteractionCase clickCase = clickEvent.Cases["clickCase"];
if (clickCase == null)
{
clickCase = clickEvent.CreateCase("clickCase");
}
// For now, we only have a open action in exsiting case
foreach (IInteractionAction action in clickCase.Actions)
{
if (action != null)
{
if (action.ActionType == ActionType.OpenAction)
{
_widgetOpenAction = action as IInteractionOpenAction;
LoadWidgetInteraction();
}
else if (action.ActionType == ActionType.ShowHideAction)
{
_widgetShowHideAction = action as IInteractionShowHideAction;
LoadPageWidgets();
}
}
}
if (_widgetOpenAction == null)
{
_widgetOpenAction = clickCase.CreateAction(ActionType.OpenAction) as IInteractionOpenAction;
LoadWidgetInteraction();
}
if (_widgetShowHideAction == null)
{
_widgetShowHideAction = clickCase.CreateAction(ActionType.ShowHideAction) as IInteractionShowHideAction;
//_widgetShowHideAction.AddTargetObject(widget.Guid); // Add the widget to the target list by default.
LoadPageWidgets();
}
}
private void GetEntities()
{
try
{
this.lockSelection = true;
Actor.Modes mode = this.selection.GetMode();
ActorTableOffset actorTableOffset;
BaseOffset targetOffset;
// clear the entity list
this.Entities.Clear();
if (mode == Actor.Modes.GPose)
{
actorTableOffset = Offsets.Main.GposeActorTable;
targetOffset = Offsets.Main.Gpose;
}
else if (mode == Actor.Modes.Overworld)
{
actorTableOffset = Offsets.Main.ActorTable;
targetOffset = Offsets.Main.Target;
}
else
{
throw new Exception("Unknown selection mode: " + mode);
}
byte count = actorTableOffset.GetCount();
HashSet <string> ids = new HashSet <string>();
for (byte i = 0; i < count; i++)
{
ActorTypes type = actorTableOffset.GetActorValue(i, Offsets.Main.ActorType);
string name = actorTableOffset.GetActorValue(i, Offsets.Main.Name);
string id = SelectionService.GetActorId(mode, type, name);
if (ids.Contains(id))
{
continue;
}
ids.Add(id);
if (string.IsNullOrEmpty(name))
{
name = "Unknown";
}
PossibleSelection selection = new PossibleSelection(type, actorTableOffset.GetBaseOffset(i), id, name, mode);
this.Entities.Add(selection);
}
if (this.selection.CurrentGameTarget != null)
{
this.InGameSelection = this.selection.CurrentGameTarget.Name;
this.InGameIcon = this.selection.CurrentGameTarget.Type.GetIcon();
}
else
{
this.InGameSelection = null;
this.InGameIcon = IconChar.None;
}
this.lockSelection = false;
}
catch (Exception ex)
{
Log.Write(ex);
}
}
private void DragBottom(double scale, ElementVM elementVm, SelectionService selectionService)
{
elementVm.Height = elementVm.Height * scale;
}
