1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.log4j.lf5.util;
18
19 import org.apache.log4j.lf5.LogLevel;
20 import org.apache.log4j.lf5.LogRecord;
21 import org.apache.log4j.lf5.viewer.LogBrokerMonitor;
22
23 import java.awt.*;
24 import java.util.Arrays;
25 import java.util.List;
26
27 /***
28 * <p>LogMonitorAdapter facilitates the usage of the LogMonitor</p>
29 *
30 * @author Richard Hurst
31 */
32
33
34
35 public class LogMonitorAdapter {
36
37
38
39 public static final int LOG4J_LOG_LEVELS = 0;
40 public static final int JDK14_LOG_LEVELS = 1;
41
42
43
44
45
46
47
48 private LogBrokerMonitor _logMonitor;
49 private LogLevel _defaultLevel = null;
50
51
52
53
54 private LogMonitorAdapter(List userDefinedLevels) {
55 super();
56
57 _defaultLevel = (LogLevel) userDefinedLevels.get(0);
58 _logMonitor = new LogBrokerMonitor(userDefinedLevels);
59
60 _logMonitor.setFrameSize(getDefaultMonitorWidth(),
61 getDefaultMonitorHeight());
62 _logMonitor.setFontSize(12);
63 _logMonitor.show();
64 }
65
66
67
68 /***
69 * <p>Creates an instance of LogMonitorAdapter using the
70 * log levels inticated by the parameter. Log4J and JDK1.4 both have default
71 * LogLevels which are set but these levels can be overriden.<p>
72 *
73 * @param loglevels An integer representing either Log4J or JDK1.4 logging levels
74 * @return LogMonitorAdapter
75 */
76 public static LogMonitorAdapter newInstance(int loglevels) {
77 LogMonitorAdapter adapter;
78 if (loglevels == JDK14_LOG_LEVELS) {
79 adapter = newInstance(LogLevel.getJdk14Levels());
80 adapter.setDefaultLevel(LogLevel.FINEST);
81 adapter.setSevereLevel(LogLevel.SEVERE);
82 } else {
83 adapter = newInstance(LogLevel.getLog4JLevels());
84 adapter.setDefaultLevel(LogLevel.DEBUG);
85 adapter.setSevereLevel(LogLevel.FATAL);
86 }
87 return adapter;
88 }
89
90 /***
91 * <p>Creates an instance of LogMonitorAdapter using the specified LogLevels.
92 * The first LogLevel in the array is used as the default LogLevel unless
93 * changed using the setDefaultLevel method.<p>
94 *
95 * @param userDefined An array of user defined LogLevel objects.
96 * @return LogMonitorAdapter
97 */
98 public static LogMonitorAdapter newInstance(LogLevel[] userDefined) {
99 if (userDefined == null) {
100 return null;
101 }
102 return newInstance(Arrays.asList(userDefined));
103 }
104
105 /***
106 * <p>Creates an instance of LogMonitorAdapter using the specified LogLevels.
107 * The first LogLevel in the List is used as the default LogLevel unless
108 * changed using the setDefaultLevel method.<p>
109 *
110 * @param userDefinedLevels A list of user defined LogLevel objects.
111 * @return LogMonitorAdapter
112 */
113 public static LogMonitorAdapter newInstance(List userDefinedLevels) {
114 return new LogMonitorAdapter(userDefinedLevels);
115 }
116
117 /***
118 * <p>Adds a LogRecord to the LogMonitor.<p>
119 *
120 * @param record The LogRecord object to be logged in the logging monitor.
121 */
122 public void addMessage(LogRecord record) {
123 _logMonitor.addMessage(record);
124 }
125
126 /***
127 * <p>Set the maximum number of records to be displayed in the monitor<p>
128 *
129 * @param maxNumberOfRecords
130 */
131 public void setMaxNumberOfRecords(int maxNumberOfRecords) {
132 _logMonitor.setMaxNumberOfLogRecords(maxNumberOfRecords);
133 }
134
135 /***
136 * <p>Set the default log level to be used when logging messages without
137 * specifying a LogLevel.<p>
138 *
139 * @param level
140 */
141 public void setDefaultLevel(LogLevel level) {
142 _defaultLevel = level;
143 }
144
145 /***
146 * <p>Gets the default LogLevel for the Adapter.<p>
147 *
148 * @return LogLevel
149 */
150 public LogLevel getDefaultLevel() {
151 return _defaultLevel;
152 }
153
154 /***
155 * <p>Sets the Severe LogLevel.</p>
156 *
157 * @param level
158 */
159 public void setSevereLevel(LogLevel level) {
160 AdapterLogRecord.setSevereLevel(level);
161 }
162
163 /***
164 * <p>Gets the current Severe LogLevel <p>
165 *
166 * @return LogLevel
167 */
168 public LogLevel getSevereLevel() {
169 return AdapterLogRecord.getSevereLevel();
170 }
171
172 /***
173 * <p>Log a complete message to the Monitor.<p>
174 *
175 * @param category The category to be used
176 * @param level The log level to apply to the message
177 * @param message The message
178 * @param t The throwable content of the message
179 * @param NDC The NDC really only applies to Log4J and the parameter can
180 * usually be ignored.
181 */
182 public void log(String category, LogLevel level, String message,
183 Throwable t, String NDC) {
184 AdapterLogRecord record = new AdapterLogRecord();
185 record.setCategory(category);
186 record.setMessage(message);
187 record.setNDC(NDC);
188 record.setThrown(t);
189
190 if (level == null) {
191 record.setLevel(getDefaultLevel());
192 } else {
193 record.setLevel(level);
194 }
195
196 addMessage(record);
197 }
198
199 /***
200 * <p>Log a message to the Monitor and use the default LogLevel.<p>
201 *
202 * @param category The category to be used
203 * @param message The message
204 */
205 public void log(String category, String message) {
206 log(category, null, message);
207 }
208
209 /***
210 * <p>Log a message to the Monitor.<p>
211 *
212 * @param category The category to be used
213 * @param level The log level to apply to the message
214 * @param message The message
215 * @param NDC
216 */
217 public void log(String category, LogLevel level, String message, String NDC) {
218 log(category, level, message, null, NDC);
219 }
220
221 /***
222 * <p>Log a message to the Monitor.<p>
223 *
224 * @param category The category to be used
225 * @param level The log level to apply to the message
226 * @param message The message
227 * @param t The throwable content of the message
228 */
229 public void log(String category, LogLevel level, String message,
230 Throwable t) {
231 log(category, level, message, t, null);
232 }
233
234 /***
235 * <p>Log a message to the Monitor.<p>
236 *
237 * @param category The category to be used
238 * @param level The log level to apply to the message
239 * @param message The message
240 */
241 public void log(String category, LogLevel level, String message) {
242 log(category, level, message, null, null);
243 }
244
245
246
247
248 /***
249 * @return the screen width from Toolkit.getScreenSize()
250 * if possible, otherwise returns 800
251 * @see java.awt.Toolkit
252 */
253 protected static int getScreenWidth() {
254 try {
255 return Toolkit.getDefaultToolkit().getScreenSize().width;
256 } catch (Throwable t) {
257 return 800;
258 }
259 }
260
261 /***
262 * @return the screen height from Toolkit.getScreenSize()
263 * if possible, otherwise returns 600
264 * @see java.awt.Toolkit
265 */
266 protected static int getScreenHeight() {
267 try {
268 return Toolkit.getDefaultToolkit().getScreenSize().height;
269 } catch (Throwable t) {
270 return 600;
271 }
272 }
273
274 protected static int getDefaultMonitorWidth() {
275 return (3 * getScreenWidth()) / 4;
276 }
277
278 protected static int getDefaultMonitorHeight() {
279 return (3 * getScreenHeight()) / 4;
280 }
281
282
283
284
285
286
287
288 }
289