private void UserNames(object sender, UUIDNameReplyEventArgs e)
{
if (!IsExporting) return;
foreach (KeyValuePair<UUID, string> name in e.Names)
{
lock (fileWriterLock) File.WriteAllText(siminfoDir + "" + name.Key + ".avatar", name.Value);
}
}
void Avatars_UUIDNameReply(object sender, UUIDNameReplyEventArgs e)
{
if(active==false)
return;
foreach (KeyValuePair<UUID, string> kvp in e.Names)
{
lock(agent_names_requested)
{
if(agent_names_requested.ContainsKey(kvp.Key))
{
agent_names_recieved.Add(kvp.Key, kvp.Value);
agent_names_requested.Remove(kvp.Key);
}
}
}
}
//runs on the GUI thread
private void OwnerReceived(object sender, UUIDNameReplyEventArgs names)
{
int iDx = lbxPrims.SelectedIndex;
if (iDx == -1) return;
ObjectsListItem item = (ObjectsListItem)lbxPrims.Items[iDx];
Primitive sPr = new Primitive();
sPr = item.Prim;
foreach (KeyValuePair<UUID, string> av in names.Names)
{
if (av.Key == sPr.Properties.OwnerID)
{
label9.Text = av.Value;
pictureBox1.Enabled = true;
pictureBox1.Cursor = Cursors.Hand;
}
if (av.Key == sPr.Properties.CreatorID)
{
txtCreator.Text = av.Value;
pictureBox2.Enabled = true;
pictureBox2.Cursor = Cursors.Hand;
label21.Text = sPr.Properties.CreatorID.ToString();
}
if (!instance.avnames.ContainsKey(av.Key))
{
instance.avnames.Add(av.Key, av.Value);
}
}
}
///<summary>Raises the UUIDNameReply Event</summary>
/// <param name="e">A UUIDNameReplyEventArgs object containing
/// the data sent from the simulator</param>
protected virtual void OnUUIDNameReply(UUIDNameReplyEventArgs e)
{
EventHandler<UUIDNameReplyEventArgs> handler = m_UUIDNameReply;
if (handler != null)
handler(this, e);
}
/// <summary>
/// This handles the asynchronous response of a RequestAvatarNames call.
/// </summary>
/// <param name="sender"></param>
/// <param name="e">names cooresponding to the the list of IDs sent the the RequestAvatarNames call.</param>
private void Avatars_OnAvatarNames(object sender, UUIDNameReplyEventArgs e)
{
Dictionary<UUID, string> newNames = new Dictionary<UUID, string>();
foreach (KeyValuePair<UUID, string> kvp in e.Names)
{
FriendInfo friend;
lock (FriendList.Dictionary)
{
if (FriendList.TryGetValue(kvp.Key, out friend))
{
if (friend.Name == null)
newNames.Add(kvp.Key, e.Names[kvp.Key]);
friend.Name = e.Names[kvp.Key];
FriendList[kvp.Key] = friend;
}
}
}
if (newNames.Count > 0 && m_FriendNames != null)
{
OnFriendNames(new FriendNamesEventArgs(newNames));
}
}
void Names_NameUpdated(object sender, UUIDNameReplyEventArgs e)
{
if (InvokeRequired)
{
if (!instance.MonoRuntime || IsHandleCreated)
BeginInvoke(new MethodInvoker(() => Names_NameUpdated(sender, e)));
return;
}
lock (AvatarListSyncRoot)
{
Participants.BeginUpdate();
foreach (KeyValuePair<UUID, string> kvp in e.Names)
{
if (Participants.Items.ContainsKey(kvp.Key.ToString()))
Participants.Items[kvp.Key.ToString()].Text = kvp.Value;
}
Participants.Sort();
Participants.EndUpdate();
}
}
void Names_NameUpdated(object sender, UUIDNameReplyEventArgs e)
{
if (InvokeRequired)
{
if (IsHandleCreated || !instance.MonoRuntime)
BeginInvoke((MethodInvoker)(() => Names_NameUpdated(sender, e)));
return;
}
lock (participants)
{
foreach (var name in e.Names)
{
if (participants.Items.ContainsKey(name.Key.ToString()))
{
participants.Items[name.Key.ToString()].Text = name.Value;
((VoiceParticipant)participants.Items[name.Key.ToString()].Tag).Name = name.Value;
}
}
}
}
void Avatars_UUIDNameReply(object sender, UUIDNameReplyEventArgs e)
{
if (!e.Names.ContainsKey(ev.OwnerID)) return;
instance.Names.NameUpdated -= new EventHandler<UUIDNameReplyEventArgs>(Avatars_UUIDNameReply);
if (InvokeRequired)
{
if (!instance.MonoRuntime || IsHandleCreated)
BeginInvoke(new MethodInvoker(() => Avatars_UUIDNameReply(sender, e)));
return;
}
SetText();
}
void Names_NameUpdated(object sender, UUIDNameReplyEventArgs e)
{
if (InvokeRequired)
{
BeginInvoke(new MethodInvoker(() => Names_NameUpdated(sender, e)));
return;
}
if (e.Names.ContainsKey(group.FounderID))
{
lblFounded.Text = "Founded by: " + e.Names[group.FounderID];
}
lvwMemberDetails.BeginUpdate();
lvwGeneralMembers.BeginUpdate();
bool modified = false;
foreach (KeyValuePair<UUID, string> name in e.Names)
{
if (lvwGeneralMembers.Items.ContainsKey(name.Key.ToString()))
{
lvwGeneralMembers.Items[name.Key.ToString()].Text = name.Value;
modified = true;
}
if (!isMember)
continue;
if (lvwMemberDetails.Items.ContainsKey(name.Key.ToString()))
{
lvwMemberDetails.Items[name.Key.ToString()].Text = name.Value;
}
}
if (modified)
{
lvwGeneralMembers.Sort();
if (isMember) lvwMemberDetails.Sort();
}
lvwGeneralMembers.EndUpdate();
lvwMemberDetails.EndUpdate();
}
private void Avatars_OnAvatarNames(object sender, UUIDNameReplyEventArgs names)
{
if (InvokeRequired)
{
BeginInvoke(new MethodInvoker(delegate()
{
Avatars_OnAvatarNames(sender, names);
}));
return;
}
BeginInvoke(new MethodInvoker(delegate()
{
UpdateChatList(names.Names);
}));
}
private void Avatars_OnAvatarNames(object sender, UUIDNameReplyEventArgs e)
{
foreach (KeyValuePair<UUID, string> av in e.Names)
{
try
{
BeginInvoke(new OnSetPartnerText(SetPartnerText), new object[] { av });
break;
}
catch
{
;
}
}
}
void Avatars_UUIDNameReply(object sender, UUIDNameReplyEventArgs e)
{
if(e.Names.ContainsKey(av_target))
try_update_name_label(av_target);
}
//comes up in a separate thread
private void Avatars_OnAvatarNames(object sender, UUIDNameReplyEventArgs e)
{
if (InvokeRequired)
{
BeginInvoke((MethodInvoker)delegate { Avatars_OnAvatarNames(sender, e); });
return;
}
//using parent to invoke for avoiding race condition between this event and whether this control is disposed
//BeginInvoke((MethodInvoker)delegate { CreatorOwnerReceived(e.Names); });
CreatorOwnerReceived(e.Names);
}
public virtual void Avatars_OnAvatarNames(object sender, UUIDNameReplyEventArgs e) { OnEvent("On-Avatar-Names", paramNamesOnAvatarNames, paramTypesOnAvatarNames, e); }
// separate thread
private void Avatars_OnAvatarNames(object sender, UUIDNameReplyEventArgs names)
{
BeginInvoke(new MethodInvoker(delegate()
{
OwnerReceived(sender, names);
}));
}
void Avatars_UUIDNameReply(object sender, UUIDNameReplyEventArgs e)
{
lock (_UntrackedAvatars)
{
foreach (KeyValuePair<UUID, string> name in e.Names)
{
TrackedAvatar trackedAvatar;
if (_UntrackedAvatars.TryGetValue(name.Key, out trackedAvatar))
{
trackedAvatar.Name = name.Value;
if (OnAvatarAdded != null && trackedAvatar.ListViewItem.Text == "(Loading...)")
{
try { OnAvatarAdded(trackedAvatar); }
catch (Exception ex) { Logger.Log(ex.Message, Helpers.LogLevel.Error, Client, ex); }
}
this.BeginInvoke((MethodInvoker)delegate
{
trackedAvatar.ListViewItem.Text = name.Value;
});
}
}
}
}
void Avatars_UUIDNameReply(object sender, UUIDNameReplyEventArgs e)
{
if (e.Names.ContainsKey(owner))
{
instance.Names.NameUpdated -= new EventHandler<UUIDNameReplyEventArgs>(Avatars_UUIDNameReply);
UpdateResident();
}
}
public void Avatars_UUIDNameReply(object sender, UUIDNameReplyEventArgs e)
{
Hashtable item = new Hashtable();
item.Add("MessageType", "AvatarNames");
item.Add("Names", e.Names);
enqueue(item);
}
void Names_NameUpdated(object sender, UUIDNameReplyEventArgs e)
{
if (e.Names.ContainsKey(agentID))
{
SetName(e.Names[agentID]);
}
}
void Avatars_UUIDNameReply(object sender, UUIDNameReplyEventArgs e)
{
if (InvokeRequired)
{
BeginInvoke(new MethodInvoker(delegate() { Avatars_UUIDNameReply(sender, e); }));
return;
}
lstPrims.BeginUpdate();
lock (lstPrims.Items)
{
foreach (ListViewItem item in lstPrims.Items)
{
Primitive prim = item.Tag as Primitive;
if (prim.Properties != null && e.Names.ContainsKey(prim.Properties.OwnerID))
{
item.Text = GetObjectName(prim);
}
}
}
lstPrims.EndUpdate();
}
private void AvatarNamesHandler(object sender, UUIDNameReplyEventArgs e)
{
lock (Names)
{
foreach (KeyValuePair<UUID, string> av in e.Names)
{
Names[av.Key] = av.Value;
}
}
BeginInvoke((MethodInvoker)delegate
{
UpdateNames();
});
}
void Avatars_UUIDNameReply(object sender, UUIDNameReplyEventArgs e)
{
lock(av_names)
{
foreach(KeyValuePair <UUID,string> kvp in e.Names)
{
lock(getting)
{
if(getting.Contains(kvp.Key))
getting.Remove(kvp.Key);
}
if(!av_names.ContainsKey(kvp.Key))
{
av_names.Add(kvp.Key,kvp.Value);
}
}
}
}
void Avatars_UUIDNameReply(object sender, UUIDNameReplyEventArgs e)
{
if (e.Names.Keys.Contains(msg.FromAgentID))
{
instance.Names.NameUpdated -= new EventHandler<UUIDNameReplyEventArgs>(Avatars_UUIDNameReply);
BeginInvoke(new MethodInvoker(() => txtInfo.Text = objectOfferText()));
}
}
private void Avatars_UUIDNameReply(object sender, UUIDNameReplyEventArgs e)
{
MakeAgentIdentities(e.Names);
}
void Names_NameUpdated(object sender, UUIDNameReplyEventArgs e)
{
if (InvokeRequired)
{
BeginInvoke(new MethodInvoker(() => Names_NameUpdated(sender, e)));
return;
}
if (!(txtEventOrganizer.Tag is UUID))
{
return;
}
UUID organizer = (UUID)txtEventOrganizer.Tag;
foreach (var name in e.Names)
{
if (name.Key == organizer)
{
txtEventOrganizer.Text = name.Value;
break;
}
}
}
private void Avatars_OnAvatarNames(object sender, UUIDNameReplyEventArgs e)
{
if (InvokeRequired)
{
BeginInvoke(new MethodInvoker(delegate()
{
Avatars_OnAvatarNames(sender, e);
}));
return;
}
BeginInvoke(new MethodInvoker(delegate()
{
NameReceived(e.Names);
}));
}
void Names_NameUpdated(object sender, UUIDNameReplyEventArgs e)
{
bool moded = false;
foreach (var id in e.Names.Keys)
{
if (client.Friends.FriendList.ContainsKey(id))
{
moded = true;
break;
}
}
if (moded)
{
if (InvokeRequired)
BeginInvoke(new MethodInvoker(() => listFriends.Invalidate()));
else
listFriends.Invalidate();
}
}
void Avatars_UUIDNameReply(object sender, UUIDNameReplyEventArgs e)
{
Dictionary<UUID, string> ret = new Dictionary<UUID, string>();
foreach (KeyValuePair<UUID, string> kvp in e.Names)
{
// Remove from the list of active requests if in UUID only (standard mode)
if (Mode == NameMode.Standard)
{
lock (activeRequests)
{
activeRequests.Remove(kvp.Key);
}
}
lock (names)
{
if (!names.ContainsKey(kvp.Key))
{
names[kvp.Key] = new AgentDisplayName();
names[kvp.Key].ID = kvp.Key;
names[kvp.Key].NextUpdate = UUIDNameOnly;
names[kvp.Key].IsDefaultDisplayName = true;
}
names[kvp.Key].Updated = DateTime.Now;
string[] parts = kvp.Value.Trim().Split(' ');
if (parts.Length == 2)
{
if (InvalidName(names[kvp.Key].DisplayName))
{
names[kvp.Key].DisplayName = string.Format("{0} {1}", parts[0], parts[1]);
}
names[kvp.Key].LegacyFirstName = parts[0];
names[kvp.Key].LegacyLastName = parts[1];
if (names[kvp.Key].LegacyLastName == "Resident")
{
names[kvp.Key].UserName = names[kvp.Key].LegacyFirstName.ToLower();
}
else
{
names[kvp.Key].UserName = string.Format("{0}.{1}", parts[0], parts[1]).ToLower();
}
ret.Add(kvp.Key, FormatName(names[kvp.Key]));
}
}
}
TriggerEvent(ret);
TriggerCacheSave();
}
void Names_NameUpdated(object sender, UUIDNameReplyEventArgs e)
{
if (!e.Names.ContainsKey(client.Self.AgentID)) return;
if (InvokeRequired)
{
if (IsHandleCreated || !instance.MonoRuntime)
{
BeginInvoke(new MethodInvoker(() => Names_NameUpdated(sender, e)));
}
return;
}
RefreshWindowTitle();
RefreshStatusBar();
}
public void Avatars_UUIDNameReply(object sender, UUIDNameReplyEventArgs e)
{
Hashtable item = new Hashtable();
item.Add("MT", "avname");
item.Add("names", e.Names);
enqueue(item);
}
