/// <summary>
 /// Deserialization constructor for root category only
 /// </summary>
 /// <param name="src">Source Serializable Market Group</param>
 public MarketGroup(SerializableMarketGroup src)
 {
     m_id = src.ID;
     m_name = src.Name;
     m_subCategories = new MarketGroupCollection(this, src.SubGroups);
     m_items = new ItemCollection(this, src.Items);
 }

        internal FunctionImportMappingNonComposable(
            EdmFunction functionImport,
            EdmFunction targetFunction,
            List<List<FunctionImportStructuralTypeMapping>> structuralTypeMappingsList,
            ItemCollection itemCollection)
            : base(functionImport, targetFunction)
        {
            //Contract.Requires(structuralTypeMappingsList != null);
            //Contract.Requires(itemCollection != null);
            Debug.Assert(!functionImport.IsComposableAttribute, "!functionImport.IsComposableAttribute");
            Debug.Assert(!targetFunction.IsComposableAttribute, "!targetFunction.IsComposableAttribute");

            if (structuralTypeMappingsList.Count == 0)
            {
                ResultMappings = new OM.ReadOnlyCollection<FunctionImportStructuralTypeMappingKB>(
                    new[]
                        {
                            new FunctionImportStructuralTypeMappingKB(new List<FunctionImportStructuralTypeMapping>(), itemCollection)
                        });
                noExplicitResultMappings = true;
            }
            else
            {
                Debug.Assert(functionImport.ReturnParameters.Count == structuralTypeMappingsList.Count);
                ResultMappings = new OM.ReadOnlyCollection<FunctionImportStructuralTypeMappingKB>(
                    structuralTypeMappingsList
                        .Select(
                            (structuralTypeMappings) => new FunctionImportStructuralTypeMappingKB(
                                                            structuralTypeMappings,
                                                            itemCollection))
                        .ToArray());
                noExplicitResultMappings = false;
            }
        }

        public void ContainsItemWhenMore()
        {
            var collection = new ItemCollection {Item(quantity:5)};

            Assert.IsTrue(collection.Contains(Item(quantity:5)));
            Assert.IsTrue(collection.Contains(Item(quantity:4)));
        }

    public Catalog(Database db,
			string name,
			string table,
			string shortDescription,
			string longDescription,
			string image,
			int weight)
    {
        this.database = db;
        this.name   = name;
        this.table  = table;
        this.itemCollection = new ItemCollection (db, table, name);
        itemCollection.OnChanged += ItemCollectionChanged;

        this.shortDescription = shortDescription;
        this.longDescription = longDescription;
        this.weight = weight;

        this.image = new Gtk.Image();
        try {
            this.image.FromPixbuf = Pixbuf.LoadFromResource (image);
        }
        catch {
            this.image = null;
        }
    }

        /// <summary>
        /// Base Constructor
        /// </summary>
        /// <param name="manager">ScreenManager</param>
        public TabControl(IScreenManager manager)
            : base(manager)
        {
            Manager = manager;

            Pages = new ItemCollection<TabPage>();
            Pages.OnInsert += OnInsert;
            Pages.OnRemove += OnRemove;

            tabControlStack = new StackPanel(manager);
            tabControlStack.HorizontalAlignment = HorizontalAlignment.Stretch;
            tabControlStack.VerticalAlignment = VerticalAlignment.Stretch;
            Content = tabControlStack;

            tabListStack = new StackPanel(manager);
            tabListStack.HorizontalAlignment = HorizontalAlignment.Stretch;
            tabListStack.Orientation = Orientation.Horizontal;
            tabListStack.Background = TabListBackground;
            tabControlStack.Controls.Add(tabListStack);

            tabPage = new ContentControl(manager);
            tabPage.HorizontalAlignment = HorizontalAlignment.Stretch;
            tabPage.VerticalAlignment = VerticalAlignment.Stretch;
            tabPage.Margin = new Border(0, 10, 0, 10);
            tabPage.Background = TabPageBackground;
            tabControlStack.Controls.Add(tabPage);
            tabPage.Margin = new Border(0, -50, 0, 0);

            ApplySkin(typeof(TabControl));
        }

        /// <summary>
        /// Base Constructor
        /// </summary>
        /// <param name="manager">ScreenManager</param>
        public TabControl(BaseScreenComponent manager)
            : base(manager)
        {
            Pages = new ItemCollection<TabPage>();
            Pages.OnInsert += OnInsert;
            Pages.OnRemove += OnRemove;

            tabControlGrid = new Grid(manager)
            {
                HorizontalAlignment = HorizontalAlignment.Stretch,
                VerticalAlignment = VerticalAlignment.Stretch
            };
            tabControlGrid.Columns.Add(new ColumnDefinition() {ResizeMode = ResizeMode.Parts, Width = 1});
            tabControlGrid.Rows.Add(new RowDefinition() {ResizeMode = ResizeMode.Auto});
            tabControlGrid.Rows.Add(new RowDefinition() {ResizeMode = ResizeMode.Parts, Height =  1});
            Content = tabControlGrid;

            tabListStack = new StackPanel(manager);
            tabListStack.HorizontalAlignment = HorizontalAlignment.Stretch;
            tabListStack.Orientation = Orientation.Horizontal;
            tabListStack.Background = TabListBackground;
            tabControlGrid.AddControl(tabListStack, 0, 0);

            tabPage = new ContentControl(manager);
            tabPage.HorizontalAlignment = HorizontalAlignment.Stretch;
            tabPage.VerticalAlignment = VerticalAlignment.Stretch;
            tabPage.Background = TabPageBackground;
            tabControlGrid.AddControl(tabPage, 0, 1);

            ApplySkin(typeof(TabControl));
        }

 public void ExoticCoverage()
 {
     var r = new Mock<IItemReader>(MockBehavior.Strict);
     var collection = new ItemCollection(r.Object);
     IEnumerable enumerable = collection;
     enumerable.GetEnumerator().Should().Not.Be.Null();
 }

        public void ContainsItem()
        {
            var item = Item();
            var collection = new ItemCollection {item};

            Assert.IsTrue(collection.Contains(item));
        }

        public void AddItem()
        {
            var collection = new ItemCollection();
            collection.Add(_itemFactory.Build(ItemCode.LightFrigate, 1));

            Assert.That(collection.Count, Is.EqualTo(1));
        }

        public ListViewCombos()
        {
            ListView list = new ListView ();
            var indexField = new DataField<int> ();

            var indexField2 = new DataField<int> ();
            var itemsField = new DataField<ItemCollection> ();

            ListStore store = new ListStore (indexField, indexField2, itemsField);
            list.DataSource = store;
            list.GridLinesVisible = GridLines.Horizontal;

            var comboCellView = new ComboBoxCellView { Editable = true, SelectedIndexField = indexField };
            comboCellView.Items.Add (1, "one");
            comboCellView.Items.Add (2, "two");
            comboCellView.Items.Add (3, "three");

            list.Columns.Add (new ListViewColumn ("List 1", comboCellView));

            var comboCellView2 = new ComboBoxCellView { Editable = true, SelectedIndexField = indexField2, ItemsField = itemsField };
            list.Columns.Add (new ListViewColumn ("List 2", comboCellView2));

            int p = 0;
            for (int n = 0; n < 10; n++) {
                var r = store.AddRow ();
                store.SetValue (r, indexField, n % 3);
                var col = new ItemCollection ();
                for (int i = 0; i < 3; i++) {
                    col.Add (p, "p" + p);
                    p++;
                }
                store.SetValues (r, indexField2, n % 3, itemsField, col);
            }
            PackStart (list, true);
        }

 public ToolboxItemsTab(ItemCollection items)
 {
     this._items = items;
     this.Text = "Toolbox Items";
     this.AllowDelete = false;
     this.Owner = items.Owner;
 }

        internal FunctionImportMappingNonComposable(
            EdmFunction functionImport,
            EdmFunction targetFunction,
            List<List<FunctionImportStructuralTypeMapping>> structuralTypeMappingsList,
            ItemCollection itemCollection)
            : base(functionImport, targetFunction)
        {
            EntityUtil.CheckArgumentNull(structuralTypeMappingsList, "structuralTypeMappingsList");
            EntityUtil.CheckArgumentNull(itemCollection, "itemCollection");
            Debug.Assert(!functionImport.IsComposableAttribute, "!functionImport.IsComposableAttribute");
            Debug.Assert(!targetFunction.IsComposableAttribute, "!targetFunction.IsComposableAttribute");

            if (structuralTypeMappingsList.Count == 0)
            {
                this.ResultMappings = new OM.ReadOnlyCollection<FunctionImportStructuralTypeMappingKB>(
                    new FunctionImportStructuralTypeMappingKB[] { 
                        new FunctionImportStructuralTypeMappingKB(new List<FunctionImportStructuralTypeMapping>(), itemCollection) });
                this.noExplicitResultMappings = true;
            }
            else
            {
                Debug.Assert(functionImport.ReturnParameters.Count == structuralTypeMappingsList.Count);
                this.ResultMappings = new OM.ReadOnlyCollection<FunctionImportStructuralTypeMappingKB>(
                    EntityUtil.CheckArgumentNull(structuralTypeMappingsList, "structuralTypeMappingsList")
                        .Select((structuralTypeMappings) => new FunctionImportStructuralTypeMappingKB(
                            EntityUtil.CheckArgumentNull(structuralTypeMappings, "structuralTypeMappings"),
                            itemCollection))
                        .ToArray());
                this.noExplicitResultMappings = false;
            }
        }

		public override void Initialize (OptionsDialog dialog, object dataObject)
		{
			base.Initialize (dialog, dataObject);

			config = (SolutionRunConfigInfo)dataObject;

			store = new ListStore (selectedField, projectNameField, projectField, runConfigField, projectRunConfigsField);
			listView = new ListView (store);

			var col1 = new ListViewColumn (GettextCatalog.GetString ("Solution Item"));
			var cb = new CheckBoxCellView (selectedField);
			cb.Toggled += SelectionChanged;
			cb.Editable = true;
			col1.Views.Add (cb);
			col1.Views.Add (new TextCellView (projectNameField));
			listView.Columns.Add (col1);

			var configSelView = new ComboBoxCellView (runConfigField);
			configSelView.Editable = true;
			configSelView.ItemsField = projectRunConfigsField;
			var col2 = new ListViewColumn (GettextCatalog.GetString ("Run Configuration"), configSelView);
			listView.Columns.Add (col2);

			foreach (var it in config.Solution.GetAllSolutionItems ().Where (si => si.SupportsExecute ()).OrderBy (si => si.Name)) {
				var row = store.AddRow ();
				var si = config.EditedConfig.Items.FirstOrDefault (i => i.SolutionItem == it);
				var sc = si?.RunConfiguration?.Name ?? it.GetDefaultRunConfiguration ()?.Name;
				var configs = new ItemCollection ();
				foreach (var pc in it.GetRunConfigurations ())
					configs.Add (pc.Name);
				store.SetValues (row, selectedField, si != null, projectNameField, it.Name, projectField, it, runConfigField, sc, projectRunConfigsField, configs);
			}
		}

 public ItemCollection GetValues()
 {
     ItemCollection sizes = new ItemCollection();
     sizes.Add(Smile.INNERBRACE,"Inner");
     sizes.Add(Smile.OUTERBRACE, "Outer");
     return sizes;
 }

 public ItemCollection GetValues()
 {
     ItemCollection sizes = new ItemCollection();
     for(var i = 1; i < 33; i++){
     sizes.Add(""+i);
     }
     return sizes;
 }

 /// <summary>
 /// Gets all (concrete) entity types implied by this type mapping.
 /// </summary>
 internal IEnumerable<EntityType> GetMappedEntityTypes(ItemCollection itemCollection)
 {
     const bool includeAbstractTypes = false;
     return this.EntityTypes.Concat(
         this.IsOfTypeEntityTypes.SelectMany(entityType =>
             MetadataHelper.GetTypeAndSubtypesOf(entityType, itemCollection, includeAbstractTypes)
             .Cast<EntityType>()));
 }

	    public ProtobuildModule ()
	    {
            shadowSolutions = new Dictionary<string, Solution> ();
			Packages = new ProtobuildPackages(this);
			Submodules = new ItemCollection<ProtobuildSubmodule>();
			Definitions = new ItemCollection<IProtobuildDefinition>();
			Initialize(this);
        }

        public void CannotRemoveMoreThanWhatWeHave()
        {
            var collection = new ItemCollection {Item(quantity:5)};
            Assert.That(collection.Remove(Item(quantity:6)), Is.False);

            Assert.That(collection.Count, Is.EqualTo(1));
            Assert.That(collection.ItemCount, Is.EqualTo(5));
        }

        public void Clear()
        {
            var item = Item();
            var collection = new ItemCollection {item};
            collection.Clear();

            Assert.That(collection, Is.Empty);
        }

        public void AddItemOfSameType()
        {
            var collection = new ItemCollection();
            collection.Add(Item());
            collection.Add(Item(quantity:2));

            Assert.That(collection.ItemCount, Is.EqualTo(3));
        }