KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > rero > client > output > ChatCapabilities


1 package rero.client.output;
2
3 import rero.client.Feature;
4 import rero.dcc.Chat;
5 import rero.dcc.DataDCC;
6 import rero.dcc.ProtocolDCC;
7 import rero.ircfw.InternalDataList;
8 import rero.net.SocketConnection;
9 import rero.util.ClientUtils;
10
11 import java.util.HashMap JavaDoc;
12 import java.util.NoSuchElementException JavaDoc;
13 import java.util.StringTokenizer JavaDoc;
14
15 public class ChatCapabilities extends Feature {
16   protected SocketConnection sock;
17   protected OutputCapabilities output;
18   protected DataDCC dccData;
19
20   public void init() {
21     sock = getCapabilities().getSocketConnection();
22     output = getCapabilities().getOutputCapabilities();
23     dccData = (DataDCC) getCapabilities().getDataStructure("dcc");
24   }
25
26   public void sendMessage(String JavaDoc nickname, String JavaDoc message) {
27     HashMap JavaDoc eventData = new HashMap JavaDoc();
28
29     if (nickname.charAt(0) == '=') {
30       String JavaDoc dnickname = nickname.substring(1, nickname.length());
31       Chat connection = (Chat) dccData.getSpecificConnection(dnickname, ProtocolDCC.DCC_CHAT);
32
33       if (connection == null) {
34         eventData.put("$target", dnickname);
35         eventData.put("$parms", message);
36         eventData.put("$data", dnickname + " " + message);
37         output.fireSetTarget(eventData, nickname, "SEND_CHAT_ERROR");
38         return;
39       }
40
41       connection.sendln(message);
42     } else {
43       int max = computeMaxMessageLength(nickname);
44       if (message.length() > max) {
45         // split and send as multiple messages
46
String JavaDoc[] messages = wrapMessageToStringsArray(message, max);
47         for (int i = 0; i < messages.length; i++) {
48           String JavaDoc msg = messages[i];
49           sock.println("PRIVMSG " + nickname + " :" + msg);
50         }
51       } else {
52         sock.println("PRIVMSG " + nickname + " :" + message);
53       }
54     }
55
56     if (nickname.charAt(0) == '=') {
57       eventData.put("$target", nickname.substring(1, nickname.length()));
58       eventData.put("$parms", message);
59       eventData.put("$data", nickname.substring(1, nickname.length()) + " " + message);
60
61       output.fireSetTarget(eventData, nickname, "SEND_CHAT");
62     } else if (ClientUtils.isChannel(nickname)) {
63       eventData.put("$target", nickname);
64       eventData.put("$channel", nickname);
65       eventData.put("$parms", message);
66       eventData.put("$data", nickname + " " + message);
67
68       output.fireSetTarget(eventData, nickname, output.chooseSet(nickname, "SEND_TEXT", "SEND_TEXT_INACTIVE"));
69     } else {
70       eventData.put("$target", nickname);
71       eventData.put("$parms", message);
72       eventData.put("$data", nickname + " " + message);
73
74       output.fireSetQuery(eventData, nickname, nickname, "SEND_MSG");
75     }
76   }
77
78   private int computeMaxMessageLength(String JavaDoc nickname) {
79     InternalDataList ci = ((InternalDataList) output.getCapabilities().getDataStructure("clientInformation"));
80     String JavaDoc fullAddress = ci.getMyUser().getFullAddress();
81     /* maximum allowed message text */
82     /* :nickname!username@host.com PRIVMSG #channel :text\r\n */
83     int max = 512;
84     max -= 14; /* :, " PRIVMSG ", " ", :, \r, \n */
85     max -= fullAddress.length();
86     max -= nickname.length();
87     return max;
88   }
89
90   public void sendNotice(String JavaDoc target, String JavaDoc message) {
91     sock.println("NOTICE " + target + " :" + message);
92
93     HashMap JavaDoc eventData = new HashMap JavaDoc();
94
95     eventData.put("$target", target);
96     eventData.put("$parms", message);
97     eventData.put("$data", target + " " + message);
98
99     output.fireSetConfused(eventData, target, "notice", "SEND_NOTICE");
100   }
101
102   public void sendAction(String JavaDoc target, String JavaDoc message) {
103     HashMap JavaDoc eventData = new HashMap JavaDoc();
104
105     if (target.charAt(0) == '=') {
106       eventData.put("$target", target.substring(1));
107       eventData.put("$parms", message);
108       eventData.put("$data", target.substring(1) + " " + message);
109
110       output.fireSetTarget(eventData, target, output.chooseSet(target, "SEND_ACTION", "SEND_ACTION_INACTIVE"));
111     } else if (ClientUtils.isChannel(target)) {
112       eventData.put("$target", target);
113       eventData.put("$channel", target);
114       eventData.put("$parms", message);
115       eventData.put("$data", target + " " + message);
116
117       output.fireSetTarget(eventData, target, output.chooseSet(target, "SEND_ACTION", "SEND_ACTION_INACTIVE"));
118     } else {
119       eventData.put("$target", target);
120       eventData.put("$parms", message);
121       eventData.put("$data", target + " " + message);
122
123       output.fireSetTarget(eventData, target, "SEND_ACTION");
124     }
125
126     if (target.charAt(0) == '=') {
127       Chat connection = (Chat) dccData.getSpecificConnection(target.substring(1), ProtocolDCC.DCC_CHAT);
128
129       if (connection == null) {
130         output.fireSetTarget(eventData, target, "SEND_CHAT_ERROR");
131         return;
132       }
133
134       connection.sendln((char) 1 + "ACTION " + message + (char) 1);
135     } else {
136       sock.println("PRIVMSG " + target + " :" + (char) 1 + "ACTION " + message + (char) 1);
137     }
138   }
139
140   public void sendRequest(String JavaDoc target, String JavaDoc type, String JavaDoc parms) {
141     HashMap JavaDoc eventData = new HashMap JavaDoc();
142
143     eventData.put("$target", target);
144     eventData.put("$parms", parms);
145     eventData.put("$type", type);
146     eventData.put("$data", target + " " + type + " " + parms);
147
148     if (type.equals("PING") && parms.equals("")) {
149       parms = System.currentTimeMillis() + "";
150     }
151
152     output.fireSetConfused(eventData, target, "reply", "SEND_CTCP");
153
154     if (parms.length() > 0) {
155       sock.println("PRIVMSG " + target + " :" + (char) 1 + type.toUpperCase() + " " + parms + (char) 1);
156     } else {
157       sock.println("PRIVMSG " + target + " :" + (char) 1 + type.toUpperCase() + (char) 1);
158     }
159   }
160
161   public void sendReply(String JavaDoc target, String JavaDoc type, String JavaDoc parms) {
162     sock.println("NOTICE " + target + " :" + (char) 1 + type.toUpperCase() + " " + parms + (char) 1);
163   }
164
165
166   public static String JavaDoc[] wrapMessageToStringsArray(String JavaDoc message, int length) {
167     String JavaDoc s = wrapText(message, "\n", length);
168     return s.split("\n");
169   }
170
171   /**
172    * Takes a block of text which might have long lines in it and wraps the long lines based on the supplied wrapColumn
173    * parameter. It was initially implemented for use by VelocityEmail. If there are tabs in inString, you are going to
174    * get results that are a bit strange, since tabs are a single character but are displayed as 4 or 8 spaces. Remove
175    * the tabs.
176    *
177    * @param inString Text which is in need of word-wrapping.
178    * @param newline The characters that define a newline.
179    * @param wrapColumn The column to wrap the words at.
180    * @return The text with all the long lines word-wrapped.
181    */

182   public static String JavaDoc wrapText(String JavaDoc inString, String JavaDoc newline,
183                                 int wrapColumn) {
184     StringTokenizer JavaDoc lineTokenizer = new StringTokenizer JavaDoc(
185       inString, newline, true);
186     StringBuffer JavaDoc stringBuffer = new StringBuffer JavaDoc();
187
188     while (lineTokenizer.hasMoreTokens()) {
189       try {
190         String JavaDoc nextLine = lineTokenizer.nextToken();
191
192         if (nextLine.length() > wrapColumn) {
193           // This line is long enough to be wrapped.
194
nextLine = wrapLine(nextLine, newline, wrapColumn);
195         }
196
197         stringBuffer.append(nextLine);
198       }
199       catch (NoSuchElementException JavaDoc nsee) {
200         // thrown by nextToken(), but I don't know why it would
201
break;
202       }
203     }
204
205     return (stringBuffer.toString());
206   }
207
208   /**
209    * Wraps a single line of text. Called by wrapText(). I can't think of any good reason for exposing this to the
210    * public, since wrapText should always be used AFAIK.
211    *
212    * @param line A line which is in need of word-wrapping.
213    * @param newline The characters that define a newline.
214    * @param wrapColumn The column to wrap the words at.
215    * @return A line with newlines inserted.
216    */

217   protected static String JavaDoc wrapLine(String JavaDoc line, String JavaDoc newline,
218                                    int wrapColumn) {
219     StringBuffer JavaDoc wrappedLine = new StringBuffer JavaDoc();
220
221     while (line.length() > wrapColumn) {
222       int spaceToWrapAt = line.lastIndexOf(' ', wrapColumn);
223
224       if (spaceToWrapAt >= 0) {
225         wrappedLine.append(line.substring(0, spaceToWrapAt));
226         wrappedLine.append(newline);
227         line = line.substring(spaceToWrapAt + 1);
228       } else {
229         // if no space found, force wrap at wrapColumn
230
spaceToWrapAt = wrapColumn;
231         wrappedLine.append(line.substring(0, spaceToWrapAt));
232         wrappedLine.append(newline);
233         line = line.substring(spaceToWrapAt);
234       }
235     }
236     // Whatever is left in line is short enough to just pass through,
237
// just like a small small kidney stone
238
wrappedLine.append(line);
239
240     return wrappedLine.toString();
241   }
242
243   /*public static void main(String[] args) {
244     String[] strings = wrapMessageToStringsArray("alpha beta gamma someshit", 6);
245     for (int i = 0; i < strings.length; i++) {
246       String string = strings[i];
247       System.out.println("string = " + string);
248     }
249   }*/

250 }
251
252
253
Popular Tags