void Avatars_OnAvatarNames(object sender, UUIDNameReplyEventArgs e)
{
if (IsDisposing)
{
return;
}
var names = e.Names;
if (InvokeRequired)
{
Invoke(new MethodInvoker(delegate() { Avatars_OnAvatarNames(sender, e); }));
return;
}
lstPrims.BeginUpdate();
lock (lstPrims.Items)
{
foreach (ListViewItem item in lstPrims.Items)
{
SimObject prim = item.Tag as SimObject;
if (prim.Properties != null && names.ContainsKey(prim.Properties.OwnerID))
{
item.Text = GetObjectName(prim);
}
}
}
lstPrims.EndUpdate();
RegisterWorldSystemEvents();
}
/// <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));
}
}
public override void Avatars_OnAvatarNames(object sender, UUIDNameReplyEventArgs e1)
{
foreach (KeyValuePair <UUID, string> kvp in e1.Names)
{
AddName2Key(kvp.Value, kvp.Key);
}
}
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();
}
}
}
protected void Key2NameEvent(object sender, UUIDNameReplyEventArgs e)
{
foreach (KeyValuePair <UUID, string> pair in e.Names)
{
AddAvatarToDB(pair.Key, pair.Value);
}
}
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;
});
}
}
}
}
/// <summary>
/// Loop through all (pending) replies for UUID/Avatar names
/// and process them if they contain any key we're looking for.
/// </summary>
/// <param name="sender">parameter ignored</param>
/// <param name="e">List of UUID/Avatar names</param>
/// <returns>void</returns>
/// <remarks>obsolete syntax changed</remarks>
private static void Avatars_OnAvatarNames(
object?sender,
UUIDNameReplyEventArgs e
)
{
DebugUtilities
.WriteInfo("Avatars_OnAvatarNames(): Processing " +
e.Names.Count.ToString() +
" AvatarNames replies");
foreach (KeyValuePair <UUID, string> kvp in e.Names)
{
if (!avatarNames.ContainsKey(kvp.Key) || avatarNames[kvp.Key] == null)
{
DebugUtilities
.WriteInfo("Avatars_OnAvatarNames(): Reply Name: " +
kvp.Value +
" Key : " +
kvp.Key.ToString());
lock (avatarNames)
{
// avatarNames[kvp.Key] = new Avatar(); // why all this trouble?
// FIXME: Change this to .name when we move inside libsecondlife
// avatarNames[kvp.Key].Name = kvp.Value; // protected
avatarNames[kvp.Key] = kvp.Value;
}
if (NameLookupEvents.ContainsKey(kvp.Key))
{
NameLookupEvents[kvp.Key].Set();
}
}
}
} // end Avatars_OnAvatarNames()
void Names_NameUpdated(object sender, UUIDNameReplyEventArgs e)
{
if (e.Names.ContainsKey(agentID))
{
SetName(e.Names[agentID]);
}
}
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 Avatars_OnAvatarNames(object sender, UUIDNameReplyEventArgs e)
{
foreach (KeyValuePair <UUID, string> kvp in e.Names)
{
result.AppendLine("Avatar: " + kvp.Value + " " + kvp.Key);
}
waitQuery.Set();
}
public void Avatars_UUIDNameReply(object sender, UUIDNameReplyEventArgs e)
{
Hashtable item = new Hashtable();
item.Add("MessageType", "AvatarNames");
item.Add("Names", e.Names);
enqueue(item);
}
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()));
}
}
void Avatars_UUIDNameReply(object sender, UUIDNameReplyEventArgs e)
{
if (e.Names.ContainsKey(owner))
{
instance.Names.NameUpdated -= new EventHandler <UUIDNameReplyEventArgs>(Avatars_UUIDNameReply);
UpdateResident();
}
}
// separate thread
private void Avatars_OnAvatarNames(object sender, UUIDNameReplyEventArgs names)
{
//BeginInvoke(new MethodInvoker(delegate()
//{
// OwnerReceived(names.Names);
//}));
OwnerReceived(names.Names);
}
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)
{
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();
}
private void AvatarNamesHandler(object sender, UUIDNameReplyEventArgs e)
{
lock (Names)
{
foreach (KeyValuePair <UUID, string> agent in e.Names)
{
Names[agent.Key] = agent.Value;
}
}
UpdateNames();
}
//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);
}
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
{
;
}
}
}
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();
});
}
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);
}));
}
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)
{
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 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 key2name_reply(object sender, UUIDNameReplyEventArgs e)
{
DiscoveredNames = e.Names;
k2n.Set();
}
void Avatars_OnAvatarNames(object sender, UUIDNameReplyEventArgs e)
{
foreach (KeyValuePair<UUID, string> kvp in e.Names)
result.AppendLine("Avatar: " + kvp.Value + " " + kvp.Key);
waitQuery.Set();
}
private void Avatars_UUIDNameReply(object sender, UUIDNameReplyEventArgs e)
{
MakeAgentIdentities(e.Names);
}
