C# Gtk.AppendValues方法代码示例

		static void BuildTreeChildren (Gtk.TreeStore store, Gtk.TreeIter parent, XContainer p)
		{
			foreach (XNode n in p.Nodes) {
				Gtk.TreeIter childIter;
				if (!parent.Equals (Gtk.TreeIter.Zero))
					childIter = store.AppendValues (parent, n);
				else
					childIter = store.AppendValues (n);
				
				XContainer c = n as XContainer;
				if (c != null && c.FirstChild != null)
					BuildTreeChildren (store, childIter, c);
			}
		}

    public static void CargarListaCafeteria(ref Gtk.ListStore listaStore)
    {
        listaStore.Clear();
        MySQL.consultar("SELECT `ID_articulo`, `descripcion`, `precio` FROM cafeteria_articulos");
        /*
        // Miremos primero si no han agregado este articulo a la lista
        TreeIter iter = new TreeIter();
        Boolean Encontrado = false;
        if (MySQL.Reader.Read() && tvLista.Model.GetIterFirst(ref iter)) {
        do {
            if (tvLista.Model.GetValue(iter,0).ToString() == MySQL.Reader["ID_articulo"].ToString())
            {
                int CantidadActual = int.Parse(tvLista.Model.GetValue (iter, 1).ToString());
                tvLista.Model.SetValue(iter,1,++CantidadActual);
                Encontrado = true;
            }
        } while(tvLista.Model.IterNext(ref iter));

        }

        if (!Encontrado && MySQL.Reader.HasRows)
            listaStore.AppendValues (MySQL.Reader["ID_articulo"].ToString(),MySQL.Reader["codigo_barra"].ToString(), 0, MySQL.Reader["descripcion"].ToString(),double.Parse(MySQL.Reader["precio"].ToString()));
        */

        while (MySQL.Reader.Read())
        listaStore.AppendValues (MySQL.Reader["ID_articulo"].ToString(), 0, MySQL.Reader["descripcion"].ToString(),double.Parse(MySQL.Reader["precio"].ToString()));
    }

 private static void SetChildItems(Gtk.TreeStore syncItems, Gtk.TreeIter iter, IEnumerable<SyncItem> items)
 {
     foreach (var item in items)
     {
         var childIter = syncItems.AppendValues(iter, item);
         if (item.ChildItems.Count > 0)
         {
             SetChildItems(syncItems, childIter, item.ChildItems.Values);
         }
     }
 }

        public static void LoadCertificateTree(Gtk.TreeStore certStore)
        {
            foreach (EveCertGroup group in m_CertGroups.Values)
            {
                Gtk.TreeIter groupIter = certStore.AppendValues(group.Name, -1, group.ID, true);
                group.TreeReference = new Gtk.TreeRowReference(certStore, certStore.GetPath(groupIter));
            }

            foreach (EveCertificate cert in m_Certificates.Values)
            {
                EveCertGroup group = m_CertGroups[cert.GroupID];
                Gtk.TreeIter groupIter;
                Gtk.TreeIter certIter;

                if (certStore.GetIter(out groupIter, group.TreeReference.Path))
                {
                    certIter = certStore.AppendValues(groupIter, cert.Name, cert.Grade, cert.ID, false);
                    cert.TreeReference = new Gtk.TreeRowReference(certStore, certStore.GetPath(certIter));
                }
            }
        }

        void showpowers(Gtk.TreeStore store,GroupPowers powers)
        {
            Gtk.TreeIter iterx;
                    bool test;
                    iterx = store.AppendValues(folder_open, "Membership Managment", GroupPowers.None);
                    test=(powers & GroupPowers.Invite) == GroupPowers.Invite;
                    store.AppendValues(iterx,test?tick:cross,"Invite people to group",GroupPowers.Invite);
                    test=(powers & GroupPowers.Eject) == GroupPowers.Eject;
                    store.AppendValues(iterx,test?tick:cross,"Eject members",GroupPowers.Eject);
                    test=(powers & GroupPowers.ChangeOptions) == GroupPowers.ChangeOptions; //?????????
                    store.AppendValues(iterx,test?tick:cross,"Toggle Open Enrollment",GroupPowers.ChangeOptions);

                    iterx = store.AppendValues(folder_open, "Roles", GroupPowers.None);
                    test=(powers & GroupPowers.CreateRole) == GroupPowers.CreateRole; //?????????
                    store.AppendValues(iterx,test?tick:cross,"Toggle Open Enrollment",GroupPowers.CreateRole);
                    test=(powers & GroupPowers.DeleteRole) == GroupPowers.DeleteRole; //?????????
                    store.AppendValues(iterx,test?tick:cross,"Delete ROles",GroupPowers.DeleteRole);
                    test=(powers & GroupPowers.RoleProperties) == GroupPowers.RoleProperties; //?????????
                    store.AppendValues(iterx,test?tick:cross,"Change ROle names,titles",GroupPowers.RoleProperties);
                    test=(powers & GroupPowers.AssignMemberLimited) == GroupPowers.AssignMemberLimited; //?????????
                    store.AppendValues(iterx,test?tick:cross,"Assign Members to Assigners Role",GroupPowers.AssignMemberLimited);
                    test=(powers & GroupPowers.AssignMember) == GroupPowers.AssignMember; //?????????
                    store.AppendValues(iterx,test?tick:cross,"Assign Members to Any Role",GroupPowers.AssignMember);
                    test=(powers & GroupPowers.RemoveMember) == GroupPowers.RemoveMember; //?????????
                    store.AppendValues(iterx,test?tick:cross,"Remove Members from Roles",GroupPowers.RemoveMember);
                    test=(powers & GroupPowers.ChangeIdentity) == GroupPowers.ChangeIdentity; //?????????
                    store.AppendValues(iterx,test?tick:cross,"Assign and Remove Abilities",GroupPowers.ChangeIdentity);

                    iterx = store.AppendValues(folder_open, "Parcel Managment", GroupPowers.None);
                    test=(powers & GroupPowers.LandDeed) == GroupPowers.LandDeed; //?????????
                    store.AppendValues(iterx,test?tick:cross,"Deed land and buy land for group",GroupPowers.LandDeed);
                    test=(powers & GroupPowers.LandRelease) == GroupPowers.LandRelease; //?????????
                    store.AppendValues(iterx,test?tick:cross,"Abandon land",GroupPowers.LandRelease);
                    test=(powers & GroupPowers.LandSetSale) == GroupPowers.LandSetSale; //?????????
                    store.AppendValues(iterx,test?tick:cross,"Set land for sale info",GroupPowers.LandSetSale);
                    test=(powers & GroupPowers.LandDivideJoin) == GroupPowers.LandDivideJoin;
                    store.AppendValues(iterx,test?tick:cross,"Join and Divide Parcels",GroupPowers.LandDivideJoin);

                    iterx = store.AppendValues(folder_open, "Parcel Identy", GroupPowers.None);
                    test=(powers & GroupPowers.FindPlaces) == GroupPowers.FindPlaces;
                    store.AppendValues(iterx,test?tick:cross,"Toggle show in Find Places",GroupPowers.FindPlaces);
                    test=(powers & GroupPowers.LandChangeIdentity) == GroupPowers.LandChangeIdentity;
                    store.AppendValues(iterx,test?tick:cross,"Change parcel name and Description",GroupPowers.LandChangeIdentity);
                    test=(powers & GroupPowers.SetLandingPoint) == GroupPowers.SetLandingPoint;
                    store.AppendValues(iterx,test?tick:cross,"Set Landing point",GroupPowers.SetLandingPoint);

                    iterx = store.AppendValues(folder_open, "Parcel Settings", GroupPowers.None);
                    test=(powers & GroupPowers.ChangeMedia) == GroupPowers.ChangeMedia;
                    store.AppendValues(iterx,test?tick:cross,"Change music & media settings",GroupPowers.ChangeMedia);
                    test=(powers & GroupPowers.ChangeOptions) == GroupPowers.ChangeOptions;
                    store.AppendValues(iterx,test?tick:cross,"Toggle various about->land options",GroupPowers.ChangeOptions);

                    iterx = store.AppendValues(folder_open, "Parcel Powers", GroupPowers.None);
                    test=(powers & GroupPowers.AllowEditLand) == GroupPowers.AllowEditLand;
                    store.AppendValues(iterx,test?tick:cross,"Always allow Edit Terrain",GroupPowers.AllowEditLand);
                    test=(powers & GroupPowers.AllowFly) == GroupPowers.AllowFly;
                    store.AppendValues(iterx,test?tick:cross,"Always allow fly",GroupPowers.AllowFly);
                    test=(powers & GroupPowers.AllowRez) == GroupPowers.AllowRez;
                    store.AppendValues(iterx,test?tick:cross,"Always allow Create Objects",GroupPowers.AllowRez);
                    test=(powers & GroupPowers.AllowLandmark) == GroupPowers.AllowLandmark;
                    store.AppendValues(iterx, test?tick:cross, "Always allow Create Landmarks", GroupPowers.AllowLandmark);
                    test=(powers & GroupPowers.AllowSetHome) == GroupPowers.AllowSetHome;
                    store.AppendValues(iterx,test?tick:cross,"Allow Set Home to Hete on group land",GroupPowers.AllowSetHome);

                    iterx = store.AppendValues(folder_open, "Parcel Access", GroupPowers.None);
                    test=(powers & GroupPowers.LandManageAllowed) == GroupPowers.LandManageAllowed;
                    store.AppendValues(iterx,test?tick:cross,"Manage parcel Access lists",GroupPowers.LandManageAllowed);
                    test=(powers & GroupPowers.LandManageBanned) == GroupPowers.LandManageBanned;
                    store.AppendValues(iterx,test?tick:cross,"Manage Ban lists",GroupPowers.LandManageBanned);
                    test=(powers & GroupPowers.LandEjectAndFreeze) == GroupPowers.LandEjectAndFreeze;
                    store.AppendValues(iterx,test?tick:cross,"Eject and freeze Residents on parcel",GroupPowers.LandEjectAndFreeze);

                    iterx = store.AppendValues(folder_open, "Parcel Content", GroupPowers.None);
                    test=(powers & GroupPowers.ReturnGroupOwned) == GroupPowers.ReturnGroupOwned;
                    store.AppendValues(iterx,test?tick:cross,"Return objects owner by group",GroupPowers.ReturnGroupSet);
                    test=(powers & GroupPowers.ReturnGroupSet) == GroupPowers.ReturnGroupSet;
                    store.AppendValues(iterx,test?tick:cross,"Return objects set to group",GroupPowers.ReturnGroupSet);
                    test=(powers & GroupPowers.ReturnNonGroup) == GroupPowers.ReturnNonGroup;
                    store.AppendValues(iterx,test?tick:cross,"Return non-group objects",GroupPowers.ReturnNonGroup);
                    test=(powers & GroupPowers.LandGardening) == GroupPowers.LandGardening;
                    store.AppendValues(iterx,test?tick:cross,"Landscaping using Linden Plants",GroupPowers.LandGardening);

                    iterx = store.AppendValues(folder_open, "Object Managment", GroupPowers.None);
                    test=(powers & GroupPowers.DeedObject) == GroupPowers.DeedObject;
                    store.AppendValues(iterx,test?tick:cross,"Deed objects to group",GroupPowers.DeedObject);
                    test=(powers & GroupPowers.ObjectManipulate) == GroupPowers.ObjectManipulate;
                    store.AppendValues(iterx,test?tick:cross,"Manipulate (move,copy,modify) group objetcs",GroupPowers.ObjectManipulate);
                    test=(powers & GroupPowers.ObjectSetForSale) == GroupPowers.ObjectSetForSale;
                    store.AppendValues(iterx,test?tick:cross,"Set group objects for sale",GroupPowers.ObjectSetForSale);

                    iterx = store.AppendValues(folder_open, "Notices", GroupPowers.None);
                    test=(powers & GroupPowers.SendNotices) == GroupPowers.SendNotices;
                    store.AppendValues(iterx,test?tick:cross,"Send Notices",GroupPowers.SendNotices);
                    test=(powers & GroupPowers.ReceiveNotices) == GroupPowers.ReceiveNotices;
                    store.AppendValues(iterx,test?tick:cross,"Receive Notices and view past Notices",GroupPowers.ReceiveNotices);

                    iterx = store.AppendValues(folder_open, "Proposals", GroupPowers.None);
                    test=(powers & GroupPowers.StartProposal) == GroupPowers.StartProposal;
                    store.AppendValues(iterx,test?tick:cross,"Create Proposals",GroupPowers.StartProposal);
                    test=(powers & GroupPowers.VoteOnProposal) == GroupPowers.VoteOnProposal;
//.........这里部分代码省略.........

 protected void updateSymbolTable(Hashtable symbolTable, Gtk.ListStore symbolTree)
 {
     symbolTree.Clear ();
     foreach(DictionaryEntry pair in symbolTable) {
         symbolTree.AppendValues (pair.Key, pair.Value);
     }
 }

 private void AddNoteToStore(Note note, Gtk.ListStore notesStore)
 {
     if (note.TreeIter.Equals (Gtk.TreeIter.Zero)) {
         note.TreeIter = notesStore.AppendValues (note.Title, note);
         Debug.Assert(!note.TreeIter.Equals(Gtk.TreeIter.Zero));
     } else {
         notesStore.SetValue(note.TreeIter, (int)NoteCols.Title, note.Title);
     }
 }

		void AddToTree (Gtk.TreeStore treeStore, Gtk.TreeIter iter, PArray arr)
		{
			iterTable[arr] = iter;
			
			for (int i = 0; i < arr.Count; i++) {
				var item = arr[i];
				
				var txt = string.Format (GettextCatalog.GetString ("Item {0}"), i);
				var subIter = iter.Equals (TreeIter.Zero) ? treeStore.AppendValues (txt, item) : treeStore.AppendValues (iter, txt, item);
				
				if (item is PArray)
					AddToTree (treeStore, subIter, (PArray)item);
				if (item is PDictionary)
					AddToTree (treeStore, subIter, (PDictionary)item);
				if (expandedObjects.Contains (item))
					treeview.ExpandRow (treeStore.GetPath (subIter), true);
			}

			AddCreateNewEntry  (iter);
			
			if (!rebuildArrays.Contains (arr)) {
				rebuildArrays.Add (arr);
				arr.Changed += HandleArrRebuild;
			}
		}

		void RefillOutlineStore (T4ParsedDocument doc, Gtk.TreeStore store)
		{
			if (doc == null)
				return;
			
			Gdk.Color normal   = new Gdk.Color (0x00, 0x00, 0x00);
			Gdk.Color blue     = new Gdk.Color (0x10, 0x40, 0xE0);
			Gdk.Color green    = new Gdk.Color (0x08, 0xC0, 0x30);
			Gdk.Color orange   = new Gdk.Color (0xFF, 0xA0, 0x00);
			Gdk.Color red      = new Gdk.Color (0xC0, 0x00, 0x20);
			
			Gtk.TreeIter parent = Gtk.TreeIter.Zero;
			foreach (Mono.TextTemplating.ISegment segment in doc.TemplateSegments) {
				Mono.TextTemplating.Directive dir = segment as Mono.TextTemplating.Directive;
				if (dir != null) {
					parent = Gtk.TreeIter.Zero;
					store.AppendValues ("<#@ " + dir.Name + " #>", red, segment);
					continue;
				}
				Mono.TextTemplating.TemplateSegment ts = segment as Mono.TextTemplating.TemplateSegment;
				if (ts != null) {
					string name;
					if (ts.Text.Length > 40) {
						name = ts.Text.Substring (0, 40) + "...";
					} else {
						name = ts.Text;
					}
					name = name.Replace ('\n', ' ').Trim ();
					if (name.Length == 0)
						continue;
					
					if (ts.Type == Mono.TextTemplating.SegmentType.Expression) {
						store.AppendValues (parent, "<#= " + name + " #>", orange, segment);
					} else {
						if (ts.Type == Mono.TextTemplating.SegmentType.Block) {
							name = "<#" + name + " #>";
							store.AppendValues (name, blue, segment);
							parent = Gtk.TreeIter.Zero;
						} else if (ts.Type == Mono.TextTemplating.SegmentType.Helper) {
							name = "<#+" + name + " #>";
							store.AppendValues (name, green, segment);
							parent = Gtk.TreeIter.Zero;
						} else if (ts.Type == Mono.TextTemplating.SegmentType.Content) {
							parent = store.AppendValues (name, normal, segment);
						}
					}
				}
			}
		}

        //DL rempixbuf
        //        protected bool renderImage(VirtualTreeRow row, VirtualTreeRow childrow)
        //        {
        ////			if ((row.Cells[0].CustomOption != null) && (row.Cells[0].CustomOption.Equals("nopic")))
        ////			{
        ////				return false;
        ////			}
        //            if (childrow.BaseRow != null)
        //            {
        //                VirtualGridCell cell = childrow.BaseRow.getCell(row.HeaderColumn);
        //                if (cell != null)
        //                {
        //                    if (cell.CustomOption.Equals("nopic",StringComparison.OrdinalIgnoreCase))
        //                    {
        //                        return false;
        //                    }
        //                }
        //            }
        //                                    
        //            if (row.HeaderColumn.CustomOption.Equals("pixbuf", StringComparison.OrdinalIgnoreCase))
        //            {
        //                return true;
        //            }
        //            return false;
        //        }
        protected void addData(Gtk.TreeStore store, Gtk.TreeIter iter, VirtualTreeRow row, bool withiter)
        {
            //Console.WriteLine("->"  + row.NodeValue);
            //store.AppendValues(row.Data);
            foreach (KeyValuePair<String,VirtualTreeRow> kp in row.Children)
            {
                //GroupedChildRows grp = kp.Value;
                VirtualTreeRow childrow = kp.Value;

                Gtk.TreeIter it;
                bool wi = withiter;
                if (! withiter)
                {
                    //DL rempixbuf
            //                    if (renderImage(row, childrow))
            //                    {
            //                        it = store.AppendValues(childrow.DataWithImage);
            //
            //                        wi = true;
            //                    }
                    //else
                    {
                        it = store.AppendValues(childrow.Data);
                        wi = true;
                    }
                } else
                {
            //                    if (renderImage(row, childrow))
            //                    {
            //                        it = store.AppendValues(iter, childrow.DataWithImage);
            //                    }
            //                    else
            //                    {
            //
            //                    }
                    it = store.AppendValues(iter, childrow.Data);
                }

                addData(store,it,childrow,wi);
            } //foreach

            //add the data into a row
            if (row.HeaderColumn.ChildColumn == null)
            {
                //startStopWatch("AppendValues");
                if ((row.Rows != null) && (row.Rows.Count > 1)) //TODO Count > 1 check .. or option ??
                {
                    //foreach (VirtualGridRow vr in row.Rows)
                    int idx = 0;
                    if (SkipFirstChildrow)
                    {
                        idx = 1;
                    }

                    for (int i=idx;i<row.Rows.Count;i++)
                    {
                        VirtualGridRow vr = row.Rows[i];
            //DL rempixbuf
            //	                    bool tmp = LoadPixBuf;
            //	                    if (!PixBufInRow)
            //	                    {
            //	                        LoadPixBuf = false;
            //	                    }
                        store.AppendValues(iter,vr.Datas);
                        //DL rempixbuf
                        //LoadPixBuf = tmp;
                    }
                }
                //stopStopWatch("AppendValues");
            }
        }

		void BuildTreeChildren (Gtk.TreeStore store, Gtk.TreeIter parent, ParentNode p, IList<Block> blocks)
		{
			foreach (Node node in p) {
				if (!(node is TagNode)) {
					var startLoc = new TextLocation (node.Location.BeginLine, node.Location.BeginColumn);
					var endLoc = new TextLocation (node.Location.EndLine, node.Location.EndColumn);
					var doc = defaultDocument.Editor.Document;

					var blocksBetween = blocks.Where (n => n.Start.AbsoluteIndex >= doc.GetOffset (startLoc)
						&& n.Start.AbsoluteIndex <= doc.GetOffset (endLoc));

					foreach (var block in blocksBetween) {
						var outlineNode = new OutlineNode (block) {
							Location = new DomRegion (doc.OffsetToLocation (block.Start.AbsoluteIndex),
								doc.OffsetToLocation (block.Start.AbsoluteIndex + block.Length))
						};
						if (!parent.Equals (Gtk.TreeIter.Zero))
							store.AppendValues (parent, outlineNode);
						else
							store.AppendValues (outlineNode);
					}
					continue;
				}

				Gtk.TreeIter childIter;
				if (!parent.Equals (Gtk.TreeIter.Zero))
					childIter = store.AppendValues (parent, new OutlineNode(node as TagNode));
				else
					childIter = store.AppendValues (new OutlineNode(node as TagNode));

				ParentNode pChild = node as ParentNode;
				if (pChild != null)
					BuildTreeChildren (store, childIter, pChild, blocks);
			}
		}

 static void BuildSubTree(Gtk.TreeStore fileListStore, TreeModelData data)
 {
     Gtk.TreeIter subIter = fileListStore.AppendValues(data.Name);
     foreach (var item in data.GetChildren())
     {
         BuildSubTree(fileListStore, subIter, item);
     }
 }

 static void BuildListStore(Gtk.ListStore listStore, ListModel model)
 {
     foreach (var item in model.GetItems())
     {
         string[] values = new string[] {
             item.Extension,
             item.Color.ToString(),
             item.Description,
             ListModel.FormatSizeString(item.Bytes),
             string.Format("{0:P1}", (item.PercentBytes)),
             item.FileCount.ToString()
         };
         listStore.AppendValues(values);
     }
 }

        public void FillStoreNames(Gtk.TreeStore tree_store)
        {
            XmlDocument doc = this.GetXmlDocument();
            XmlNodeList nodelist = doc.SelectNodes("/sites/site/name");

            // Iterate on the node set

            foreach (XmlNode n in nodelist)
            {
                Console.WriteLine(n.InnerText);
                tree_store.AppendValues(n.InnerText);
            }

            doc = null;
            nodelist = null;
        }

 private void AddTagToStore(Tag tag, Gtk.ListStore tagStore)
 {
     if(tag.TreeIter.Equals (Gtk.TreeIter.Zero)) {
         tag.TreeIter = tagStore.AppendValues(tag.Name, tag.Count);
         Debug.Assert(!tag.TreeIter.Equals(Gtk.TreeIter.Zero));
     } else {
         tagStore.SetValue(tag.TreeIter, (int)TagCols.Count, tag.Count);
     }
 }