1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
package org.bukkit.event.player;
import java.util.IllegalFormatException;
import java.util.Set;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
/**
* This event will sometimes fire synchronously, depending on how it was
* triggered.
* <p>
* The constructor provides a boolean to indicate if the event was fired
* synchronously or asynchronously. When asynchronous, this event can be
* called from any thread, sans the main thread, and has limited access to the
* API.
* <p>
* If a player is the direct cause of this event by an incoming packet, this
* event will be asynchronous. If a plugin triggers this event by compelling a
* player to chat, this event will be synchronous.
* <p>
* Care should be taken to check {@link #isAsynchronous()} and treat the event
* appropriately.
*/
public class AsyncPlayerChatEvent extends PlayerEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private boolean cancel = false;
private String message;
private String format = "<%1$s> %2$s";
private final Set<Player> recipients;
/**
*
* @param async This changes the event to a synchronous state.
* @param who the chat sender
* @param message the message sent
* @param players the players to receive the message. This may be a lazy
* or unmodifiable collection.
*/
public AsyncPlayerChatEvent(final boolean async, final Player who, final String message, final Set<Player> players) {
super(who, async);
this.message = message;
recipients = players;
}
/**
* Gets the message that the player is attempting to send. This message
* will be used with {@link #getFormat()}.
*
* @return Message the player is attempting to send
*/
public String getMessage() {
return message;
}
/**
* Sets the message that the player will send. This message will be used
* with {@link #getFormat()}.
*
* @param message New message that the player will send
*/
public void setMessage(String message) {
this.message = message;
}
/**
* Gets the format to use to display this chat message.
* <p>
* When this event finishes execution, the first format parameter is the
* {@link Player#getDisplayName()} and the second parameter is {@link
* #getMessage()}
*
* @return {@link String#format(String, Object...)} compatible format
* string
*/
public String getFormat() {
return format;
}
/**
* Sets the format to use to display this chat message.
* <p>
* When this event finishes execution, the first format parameter is the
* {@link Player#getDisplayName()} and the second parameter is {@link
* #getMessage()}
*
* @param format {@link String#format(String, Object...)} compatible
* format string
* @throws IllegalFormatException if the underlying API throws the
* exception
* @throws NullPointerException if format is null
* @see String#format(String, Object...)
*/
public void setFormat(final String format) throws IllegalFormatException, NullPointerException {
// Oh for a better way to do this!
try {
String.format(format, player, message);
} catch (RuntimeException ex) {
ex.fillInStackTrace();
throw ex;
}
this.format = format;
}
/**
* Gets a set of recipients that this chat message will be displayed to.
* <p>
* The set returned is not guaranteed to be mutable and may auto-populate
* on access. Any listener accessing the returned set should be aware that
* it may reduce performance for a lazy set implementation.
* <p>
* Listeners should be aware that modifying the list may throw {@link
* UnsupportedOperationException} if the event caller provides an
* unmodifiable set.
*
* @return All Players who will see this chat message
*/
public Set<Player> getRecipients() {
return recipients;
}
public boolean isCancelled() {
return cancel ;
}
public void setCancelled(boolean cancel) {
this.cancel = cancel;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
|
