public ChangeBlockTypeCommand( BlockKey blockKey, BlockType blockType) : base(blockKey) { BlockType = blockType; }
/// <summary> /// Initializes a new instance of the <see cref="Block" /> class. /// </summary> /// <param name="blocks">The ownerCollection.</param> /// <param name="initialBlockType">Initial type of the block.</param> /// <param name="text">The text.</param> public Block( ProjectBlockCollection blocks, BlockType initialBlockType, string text = "") { BlockKey = BlockKey.GetNext(); Blocks = blocks; blockType = initialBlockType; this.text = text; Properties = new PropertiesDictionary(); TextSpans = new TextSpanCollection(); accessLock = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion); previouslyAnalyzedPlugins = new HashSet<IBlockAnalyzerProjectPlugin>(); }
protected override void Do( BlockCommandContext context, Block block) { // We need to keep track of the previous block type so we can change // it back with Undo. previousBlockType = block.BlockType; // Set the block type. block.SetBlockType(BlockType); // Save the position from this command. if (UpdateTextPosition.HasFlag(DoTypes.Do)) { context.Position = new BlockPosition(BlockKey, 0); } }
/// <summary> /// Sets the type of the block and fires the events to update the internal /// structure. If the block type is identical, no events are fired. /// </summary> /// <param name="newBlockType">New type of the block.</param> public void SetBlockType(BlockType newBlockType) { // Make sure we have a sane state. if (newBlockType == null) { throw new ArgumentNullException("newBlockType"); } if (Blocks.Project != newBlockType.Supervisor.Project) { throw new InvalidOperationException( "Cannot assign a block type with a different Project than the block's Project."); } // We only do things if we are changing the block type. bool changed = blockType != newBlockType; if (changed) { // Assign the new block type. BlockType oldBlockType = blockType; blockType = newBlockType; // Raise an event that the block type had changed. This is done // before the plugins are called because they may make additional // changes and we want to avoid recursion. Project.Blocks.RaiseBlockTypeChanged(this, oldBlockType); } }
public void ChangeBlockType( Block block, BlockType oldBlockType) { // We need a write lock on the blocks while we make this change. using (block.AcquireBlockLock(RequestLock.Write)) { // Report what we're doing if we have logging on. Log("ChangeBlockType: {0}: Old Type {1}", block, oldBlockType); //// Figure out the deltas for this block. //var deltas = new Dictionary<HierarchicalPath, int>(); //deltas[WordCounterPathUtility.GetPath(oldBlockType)] = -1; //deltas[WordCounterPathUtility.GetPath(block.BlockType)] = 1; //// Update the parent types. //UpdateDeltas(block, deltas); //UpdateDeltas(block.Project, deltas); } }
/// <summary> /// Raises an event that a block's type had changed. /// </summary> /// <param name="block"></param> /// <param name="oldBlockType"></param> public void RaiseBlockTypeChanged( Block block, BlockType oldBlockType) { EventHandler<BlockEventArgs> listeners = BlockTypeChanged; if (listeners != null) { var args = new BlockEventArgs(block); listeners(this, args); } }
/// <summary> /// Initializes a new instance of the <see cref="BlockTypeSupervisor"/> class. /// </summary> /// <param name="project">The project.</param> public BlockTypeSupervisor(Project project) { // Save the project so we can associated the Supervisor with its project. Project = project; // Create the standard project block types. var paragraph = new BlockType(this) { Name = ParagraphName, IsSystem = true, IsStructural = false, }; var story = new BlockType(this) { Name = StoryName, IsSystem = true, IsStructural = true, }; var book = new BlockType(this) { Name = BookName, IsSystem = true, IsStructural = true, }; var chapter = new BlockType(this) { Name = ChapterName, IsSystem = true, IsStructural = true, }; var scene = new BlockType(this) { Name = SceneName, IsSystem = true, IsStructural = true, }; var epigraph = new BlockType(this) { Name = EpigraphName, IsSystem = true, IsStructural = true, }; var attribution = new BlockType(this) { Name = EpigraphAttributionName, IsSystem = true, IsStructural = true, }; // Initialize the collection of block types. BlockTypes = new Dictionary<string, BlockType>(); BlockTypes[ParagraphName] = paragraph; BlockTypes[StoryName] = story; BlockTypes[BookName] = book; BlockTypes[ChapterName] = chapter; BlockTypes[SceneName] = scene; BlockTypes[EpigraphName] = epigraph; BlockTypes[EpigraphAttributionName] = attribution; }
/// <summary> /// Adds the specified block type to the collection. /// </summary> /// <param name="blockTypeName">Name of the block type.</param> /// <param name="isStructural">if set to <c>true</c> [is structural].</param> /// <param name="isSystem">if set to <c>true</c> [is system].</param> public void Add( string blockTypeName, bool isStructural, bool isSystem = false) { var blockType = new BlockType(this) { Name = blockTypeName, IsStructural = isStructural, IsSystem = isSystem }; BlockTypes.Add(blockTypeName, blockType); }
/// <summary> /// Gets the child structure associated with a given block type. /// </summary> /// <param name="blockType">Type of the block.</param> /// <returns>A child structure of the given type.</returns> /// <exception cref="System.IndexOutOfRangeException">Cannot find child block type: + blockType</exception> public BlockStructure GetChildStructure(BlockType blockType) { foreach (BlockStructure childStructure in ChildStructures.Where( childStructure => childStructure.BlockType == blockType)) { return childStructure; } throw new IndexOutOfRangeException( "Cannot find child block type: " + blockType); }
/// <summary> /// Determines whether this instance contains a child structure of the given block type. /// </summary> /// <param name="blockType">Type of the block.</param> /// <returns> /// <c>true</c> if [contains child structure] [the specified block type]; otherwise, <c>false</c>. /// </returns> public bool ContainsChildStructure(BlockType blockType) { return ChildStructures.Any(childStructure => childStructure.BlockType == blockType); }