h4iku/coconut_java2006_preprocessed · Datasets at Hugging Face

super(new GridLayout(0, 4));

super(new GridLayout(0, 3));

public ControlPanel(final AudioPlayer owner) { super(new GridLayout(0, 4)); this.owner = owner; prev.setBorderPainted(false); pause.setBorderPainted(false); play.setBorderPainted(false); next.setBorderPainted(false); prev.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.prev(); } }); pause.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.pause(); } }); play.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.play(); } }); next.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.next(); } }); add(prev); add(pause); add(play); add(next); }

pause.setBorderPainted(false);

prev.setFocusPainted(false);

public ControlPanel(final AudioPlayer owner) { super(new GridLayout(0, 4)); this.owner = owner; prev.setBorderPainted(false); pause.setBorderPainted(false); play.setBorderPainted(false); next.setBorderPainted(false); prev.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.prev(); } }); pause.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.pause(); } }); play.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.play(); } }); next.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.next(); } }); add(prev); add(pause); add(play); add(next); }

pause.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.pause(); } });

public ControlPanel(final AudioPlayer owner) { super(new GridLayout(0, 4)); this.owner = owner; prev.setBorderPainted(false); pause.setBorderPainted(false); play.setBorderPainted(false); next.setBorderPainted(false); prev.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.prev(); } }); pause.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.pause(); } }); play.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.play(); } }); next.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.next(); } }); add(prev); add(pause); add(play); add(next); }

mainPanel.play();

if (mainPanel.isPlaying()) { mainPanel.pause(); } else { mainPanel.play(); }

public ControlPanel(final AudioPlayer owner) { super(new GridLayout(0, 4)); this.owner = owner; prev.setBorderPainted(false); pause.setBorderPainted(false); play.setBorderPainted(false); next.setBorderPainted(false); prev.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.prev(); } }); pause.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.pause(); } }); play.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.play(); } }); next.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.next(); } }); add(prev); add(pause); add(play); add(next); }

add(pause);

public ControlPanel(final AudioPlayer owner) { super(new GridLayout(0, 4)); this.owner = owner; prev.setBorderPainted(false); pause.setBorderPainted(false); play.setBorderPainted(false); next.setBorderPainted(false); prev.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.prev(); } }); pause.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.pause(); } }); play.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.play(); } }); next.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.next(); } }); add(prev); add(pause); add(play); add(next); }

mainPanel.pause();

if (mainPanel.isPlaying()) { mainPanel.pause(); } else { mainPanel.play(); }

public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.pause(); }

mainPanel.play();

mainPanel.next();

public void actionPerformed(ActionEvent e) { MainPanel mainPanel = (MainPanel)owner.getPanelInstance(); mainPanel.play(); }

(TimeInterval)update.multiplyBy(speed);

(TimeInterval)timeInterval.multiplyBy(speed); lastDate = now;

public void startTimer() { if (timer == null) { timer = new javax.swing.Timer((int)update.convertTo(UnitImpl.MILLISECOND).value, new ActionListener() { public void actionPerformed(ActionEvent e) { if (beginTime != null && speed != 0) { width = (TimeInterval)update.multiplyBy(speed); setAllBeginTime(beginTime.add(width)); getRegistrar().updateTimeSyncListeners(); System.out.println("Timer: updateTimeSyncListeners() speed="+speed); } // end of if (beginTime != null) } }); timer.setCoalesce(true); timer.start(); } }

(TimeInterval)update.multiplyBy(speed);

(TimeInterval)timeInterval.multiplyBy(speed); lastDate = now;

public void actionPerformed(ActionEvent e) { if (beginTime != null && speed != 0) { width = (TimeInterval)update.multiplyBy(speed); setAllBeginTime(beginTime.add(width)); getRegistrar().updateTimeSyncListeners(); System.out.println("Timer: updateTimeSyncListeners() speed="+speed); } // end of if (beginTime != null) }

if (form.getAutoDeleteSponsors() &&

if (form.retrieveConfig().getAutoDeleteSponsors() &&

public static void deleteEvent(BwActionFormBase form, BwEvent event) throws Throwable { CalSvcI svci = form.fetchSvci(); svci.deleteEvent(event, false); /* If we auto delete and if sponsor id no longer exists in events table then delete this sponsor. */ if (form.getAutoDeleteSponsors() && svci.getSponsorRefs(event.getSponsor()).size() == 0) { svci.deleteSponsor(event.getSponsor()); } /* If we auto delete and if location id no longer exists in events table then delete this location. */ if (form.getAutoDeleteLocations() && svci.getLocationRefs(event.getLocation()).size() == 0) { svci.deleteLocation(event.getLocation()); } }

if (form.getAutoDeleteLocations() &&

if (form.retrieveConfig().getAutoDeleteLocations() &&

public static void deleteEvent(BwActionFormBase form, BwEvent event) throws Throwable { CalSvcI svci = form.fetchSvci(); svci.deleteEvent(event, false); /* If we auto delete and if sponsor id no longer exists in events table then delete this sponsor. */ if (form.getAutoDeleteSponsors() && svci.getSponsorRefs(event.getSponsor()).size() == 0) { svci.deleteSponsor(event.getSponsor()); } /* If we auto delete and if location id no longer exists in events table then delete this location. */ if (form.getAutoDeleteLocations() && svci.getLocationRefs(event.getLocation()).size() == 0) { svci.deleteLocation(event.getLocation()); } }

iterator.setTotalShift(currentIterator.getTotalShift() + shift);

public void dragPlot(SeismogramShapeIterator iterator){ iterator.copyBasicInfo(currentIterator); double shiftPercentage = getShiftPercentage(currentIterator.getTime(), iterator.getTime()); double pixels = currentIterator.getSize().width * shiftPercentage + currentIterator.getLeftoverPixels(); //checks if the pixel shift is within 1/1000 of being an even pixel pixels *= 1000; pixels = Math.round(pixels); pixels /= 1000; int shift = 0; if(pixels >= 1){ shift = (int)Math.floor(pixels); drag(shift, 0, iterator); }else if(pixels <= -1){ shift = (int)Math.ceil(pixels); drag(shift, -shift, iterator); }else{ iterator.setSeisPoints(currentIterator.getSeisPoints()); iterator.setDrawnPixels(currentIterator.getDrawnPixels()); } iterator.setLeftoverPixels(pixels - shift); currentIterator = iterator; }

if(seisPoints[1] < 0 || seisPoints[0] > dss.getSeismogram().getNumPoints()){ displayPixels[0] = -1; displayPixels[1] = -1; iterator.setDrawnPixels(displayPixels); return displayPixels; }

public int[] getPixels(SeismogramShapeIterator iterator){ int[] displayPixels = new int[2]; int[] seisPoints = iterator.getSeisPoints(); double pointsPerPixel = iterator.getPointsPerPixel(); int displayWidth = iterator.getSize().width; double seisPointRange = seisPoints[1] - seisPoints[0]; if(seisPoints[0] >= 0){ displayPixels[0] = 0; }else{ displayPixels[0] =(int)Math.round(-seisPoints[0]/pointsPerPixel); } if(seisPoints[1] < dss.getSeismogram().getNumPoints()){ displayPixels[1] = displayWidth - 1; }else{ displayPixels[1] = (int)Math.round((dss.getSeismogram().getNumPoints() - seisPoints[0])/ seisPointRange * displayWidth); } iterator.setDrawnPixels(displayPixels); return displayPixels; }

if(newIterator.isDraggedFrom(currentIterator) && newIterator.hasSimilarAmp(currentIterator)){

if(lessThanOnePointPerPixel(newIterator)){ }else if(newIterator.isDraggedFrom(currentIterator) && newIterator.hasSimilarAmp(currentIterator)){

public void update(MicroSecondTimeRange time, UnitRangeImpl amp, Dimension size){ SeismogramShapeIterator newIterator = new SeismogramShapeIterator(time, amp, size); if(newIterator.isDraggedFrom(currentIterator) && newIterator.hasSimilarAmp(currentIterator)){ dragPlot(newIterator); }else{ plot(newIterator); } }

logger.debug("Iterator drawing on " + startIndex + ", " + endIndex);

public void setDrawnPixels(int[] drawnPixels){ this.drawnPixels = drawnPixels; startIndex = drawnPixels[0]; endIndex = drawnPixels[1]; currentIndex = startIndex; }

public SeismogramShapeIterator(MicroSecondTimeRange time, UnitRangeImpl amp, Dimension size){ this.time = time; this.amp = amp; this.size = size;

public SeismogramShapeIterator(SeismogramShapeIterator brother){ this(brother.getTime(), brother.getAmp(), brother.getSize());

public SeismogramShapeIterator(MicroSecondTimeRange time, UnitRangeImpl amp, Dimension size){ this.time = time; this.amp = amp; this.size = size; }

Iterator i = invocationStack_.iterator(); while (i.hasNext()) { InvocationFrame frame = (InvocationFrame) i.next(); s.println(Evaluator.toString(frame.invocation));

if(!invocationStack_.isEmpty()) { s.println("origin:"); ListIterator i = invocationStack_.listIterator(); while (i.hasNext()) { i.next(); } while(i.hasPrevious()) { InvocationFrame frame = (InvocationFrame) i.previous(); s.println("at "+Evaluator.toString(frame.invocation)); }

public void printStackTrace(PrintStream s) { Iterator i = invocationStack_.iterator(); while (i.hasNext()) { InvocationFrame frame = (InvocationFrame) i.next(); s.println(Evaluator.toString(frame.invocation)); } }

this.setDefaultAttributeName("uid");

public ComplexStubPersonAttributeDao() { this.setDefaultAttributeName("uid"); }

throw new IllegalArgumentException("The default attribute name must be null");

throw new IllegalArgumentException("The default attribute name may not be null");

public final void setDefaultAttributeName(final String name) { if (name == null) throw new IllegalArgumentException("The default attribute name must be null"); this.defaultAttribute = name; }

public void set(Text other) { set(other.bytes, other.length);

public void set(String string) throws CharacterCodingException { ByteBuffer bb = encode(string); bytes = bb.array(); length = bb.limit();

public void set(Text other) { set(other.bytes, other.length); }

public Interval(Object interval) { super(interval, null);

public Interval(long startInstant, long endInstant) { super(startInstant, endInstant, null);

public Interval(Object interval) { super(interval, null); }

public static UnitRangeImpl getBestForDisplay(UnitRangeImpl inRange) { UnitRangeImpl outRange = inRange; if (inRange.getUnit().isConvertableTo(UnitImpl.METER_PER_SECOND)) { inRange = inRange.convertTo(UnitImpl.METER_PER_SECOND); if (Math.abs(inRange.getMinValue()) < .000001 && Math.abs(inRange.getMaxValue()) < .000001) { outRange = inRange.convertTo(UnitImpl.NANOMETER_PER_SECOND); } else if (Math.abs(inRange.getMinValue()) < .001 && Math.abs(inRange.getMaxValue()) < .001) { outRange = inRange.convertTo(UnitImpl.MICRON_PER_SECOND); } else if (Math.abs(inRange.getMinValue()) < 1 && Math.abs(inRange.getMaxValue()) < 1) { outRange = inRange.convertTo(UnitImpl.MILLIMETER_PER_SECOND); } } else if (inRange.getUnit().isConvertableTo(UnitImpl.METER)) { inRange = inRange.convertTo(UnitImpl.METER); if (Math.abs(inRange.getMinValue()) < .000001 && Math.abs(inRange.getMaxValue()) < .000001) { outRange = inRange.convertTo(UnitImpl.NANOMETER); } else if (Math.abs(inRange.getMinValue()) < .001 && Math.abs(inRange.getMaxValue()) < .001) { outRange = inRange.convertTo(UnitImpl.MICRON); } else if (Math.abs(inRange.getMinValue()) < 1 && Math.abs(inRange.getMaxValue()) < 1) { outRange = inRange.convertTo(UnitImpl.MILLIMETER); } } else if (inRange.getUnit().isConvertableTo(UnitImpl.METER_PER_SECOND_PER_SECOND)) { inRange = inRange.convertTo(UnitImpl.METER_PER_SECOND_PER_SECOND); if (Math.abs(inRange.getMinValue()) < .000001 && Math.abs(inRange.getMaxValue()) < .000001) { outRange = inRange.convertTo(UnitImpl.NANOMETER_PER_SECOND_PER_SECOND); } else if (Math.abs(inRange.getMinValue()) < .001 && Math.abs(inRange.getMaxValue()) < .001) { outRange = inRange.convertTo(UnitImpl.MICROMETER_PER_SECOND_PER_SECOND); } else if (Math.abs(inRange.getMinValue()) < 1 && Math.abs(inRange.getMaxValue()) < 1) { outRange = inRange.convertTo(UnitImpl.MILLIMETER_PER_SECOND_PER_SECOND); } } else if (inRange.getUnit().isConvertableTo(UnitImpl.COUNT)) { inRange = inRange.convertTo(UnitImpl.COUNT); if (Math.abs(inRange.getMinValue()) < .001 && Math.abs(inRange.getMaxValue()) < .001) { outRange = inRange.convertTo(UnitImpl.MICROCOUNT); } else if (Math.abs(inRange.getMinValue()) < 1 && Math.abs(inRange.getMaxValue()) < 1) { outRange = inRange.convertTo(UnitImpl.MILLICOUNT); } else if (Math.abs(inRange.getMinValue()) < 1000 && Math.abs(inRange.getMaxValue()) < 1000) { outRange = inRange.convertTo(UnitImpl.COUNT); } else if (Math.abs(inRange.getMinValue()) < 1000000 && Math.abs(inRange.getMaxValue()) < 1000000) { outRange = inRange.convertTo(UnitImpl.KILOCOUNT); } else { outRange = inRange.convertTo(UnitImpl.MEGACOUNT); } } else { } return outRange;

public static QuantityImpl getBestForDisplay(QuantityImpl quantity) { UnitRangeImpl inRange = new UnitRangeImpl(quantity.getValue(), quantity.getValue(), quantity.getUnit()); inRange = getBestForDisplay(inRange); return new QuantityImpl(inRange.getMinValue(), inRange.getUnit());

public static UnitRangeImpl getBestForDisplay(UnitRangeImpl inRange) { // just in case we don't have a case for this unit UnitRangeImpl outRange = inRange; if (inRange.getUnit().isConvertableTo(UnitImpl.METER_PER_SECOND)) { // velocity inRange = inRange.convertTo(UnitImpl.METER_PER_SECOND); if (Math.abs(inRange.getMinValue()) < .000001 && Math.abs(inRange.getMaxValue()) < .000001) { // use micron/sec outRange = inRange.convertTo(UnitImpl.NANOMETER_PER_SECOND); } else if (Math.abs(inRange.getMinValue()) < .001 && Math.abs(inRange.getMaxValue()) < .001) { // use micron/sec outRange = inRange.convertTo(UnitImpl.MICRON_PER_SECOND); } else if (Math.abs(inRange.getMinValue()) < 1 && Math.abs(inRange.getMaxValue()) < 1) { // use mm/sec outRange = inRange.convertTo(UnitImpl.MILLIMETER_PER_SECOND); } } else if (inRange.getUnit().isConvertableTo(UnitImpl.METER)) { // displacement inRange = inRange.convertTo(UnitImpl.METER); if (Math.abs(inRange.getMinValue()) < .000001 && Math.abs(inRange.getMaxValue()) < .000001) { // use nanometer outRange = inRange.convertTo(UnitImpl.NANOMETER); } else if (Math.abs(inRange.getMinValue()) < .001 && Math.abs(inRange.getMaxValue()) < .001) { // use micron outRange = inRange.convertTo(UnitImpl.MICRON); } else if (Math.abs(inRange.getMinValue()) < 1 && Math.abs(inRange.getMaxValue()) < 1) { // use mm outRange = inRange.convertTo(UnitImpl.MILLIMETER); } } else if (inRange.getUnit().isConvertableTo(UnitImpl.METER_PER_SECOND_PER_SECOND)) { //acceleration inRange = inRange.convertTo(UnitImpl.METER_PER_SECOND_PER_SECOND); if (Math.abs(inRange.getMinValue()) < .000001 && Math.abs(inRange.getMaxValue()) < .000001) { // use nanometer/sec/sec outRange = inRange.convertTo(UnitImpl.NANOMETER_PER_SECOND_PER_SECOND); } else if (Math.abs(inRange.getMinValue()) < .001 && Math.abs(inRange.getMaxValue()) < .001) { // use micron/sec/sec outRange = inRange.convertTo(UnitImpl.MICROMETER_PER_SECOND_PER_SECOND); } else if (Math.abs(inRange.getMinValue()) < 1 && Math.abs(inRange.getMaxValue()) < 1) { // use mm/sec/sec outRange = inRange.convertTo(UnitImpl.MILLIMETER_PER_SECOND_PER_SECOND); } } else if (inRange.getUnit().isConvertableTo(UnitImpl.COUNT)) { //acceleration inRange = inRange.convertTo(UnitImpl.COUNT); if (Math.abs(inRange.getMinValue()) < .001 && Math.abs(inRange.getMaxValue()) < .001) { outRange = inRange.convertTo(UnitImpl.MICROCOUNT); } else if (Math.abs(inRange.getMinValue()) < 1 && Math.abs(inRange.getMaxValue()) < 1) { outRange = inRange.convertTo(UnitImpl.MILLICOUNT); } else if (Math.abs(inRange.getMinValue()) < 1000 && Math.abs(inRange.getMaxValue()) < 1000) { outRange = inRange.convertTo(UnitImpl.COUNT); } else if (Math.abs(inRange.getMinValue()) < 1000000 && Math.abs(inRange.getMaxValue()) < 1000000) { outRange = inRange.convertTo(UnitImpl.KILOCOUNT); } else { outRange = inRange.convertTo(UnitImpl.MEGACOUNT); } } else { // logger.debug("No case, using amp range of "+outRange.getMinValue()+" to " // +outRange.getMaxValue()+" "+ // outRange.getUnit()); } return outRange; }

r.setForeground(new Color(192,192,255));

r.setForeground(new Color(128,128,255));

public Component prepareRenderer(TableCellRenderer renderer, int row, int column) { MessageTableModel dm = (MessageTableModel)getModel(); int tagColumn = getTagColumn( row, dm ); String value = dm.getValueAt( row, tagColumn ).toString(); if( tagColumn < 0 ) return super.prepareRenderer(renderer, row, column); DefaultTableCellRenderer r = (DefaultTableCellRenderer)renderer; r.setForeground( Color.black ); int tag = Integer.parseInt(value); DataDictionary dataDictionary = dm.getDataDictionary(); if( dataDictionary.isHeaderField(tag) || dataDictionary.isTrailerField(tag) ) { if( column == tagColumn ) r.setForeground(new Color(192,192,255)); else if( column == tagColumn + 1 ) r.setForeground(new Color(128,128,255)); else if( column == tagColumn + 2 ) r.setForeground(Color.black); else if( column == tagColumn + 3 ) r.setForeground(new Color(255,128,255)); else if( column == tagColumn + 4 ) r.setForeground(new Color(255,128,255)); } else { if( column == tagColumn ) r.setForeground(new Color(64,64,255)); else if( column == tagColumn + 1 ) r.setForeground(new Color(0,0,255)); else if( column == tagColumn + 2 ) r.setForeground(Color.black); else if( column == tagColumn + 3 ) r.setForeground(new Color(255,0,255)); else if( column == tagColumn + 4 ) r.setForeground(new Color(255,0,255)); } return super.prepareRenderer(renderer, row, column); }

r.setForeground(new Color(64,64,255));

r.setForeground(new Color(0,0,255));

public Component prepareRenderer(TableCellRenderer renderer, int row, int column) { MessageTableModel dm = (MessageTableModel)getModel(); int tagColumn = getTagColumn( row, dm ); String value = dm.getValueAt( row, tagColumn ).toString(); if( tagColumn < 0 ) return super.prepareRenderer(renderer, row, column); DefaultTableCellRenderer r = (DefaultTableCellRenderer)renderer; r.setForeground( Color.black ); int tag = Integer.parseInt(value); DataDictionary dataDictionary = dm.getDataDictionary(); if( dataDictionary.isHeaderField(tag) || dataDictionary.isTrailerField(tag) ) { if( column == tagColumn ) r.setForeground(new Color(192,192,255)); else if( column == tagColumn + 1 ) r.setForeground(new Color(128,128,255)); else if( column == tagColumn + 2 ) r.setForeground(Color.black); else if( column == tagColumn + 3 ) r.setForeground(new Color(255,128,255)); else if( column == tagColumn + 4 ) r.setForeground(new Color(255,128,255)); } else { if( column == tagColumn ) r.setForeground(new Color(64,64,255)); else if( column == tagColumn + 1 ) r.setForeground(new Color(0,0,255)); else if( column == tagColumn + 2 ) r.setForeground(Color.black); else if( column == tagColumn + 3 ) r.setForeground(new Color(255,0,255)); else if( column == tagColumn + 4 ) r.setForeground(new Color(255,0,255)); } return super.prepareRenderer(renderer, row, column); }

public static String getEventInfo(EventAccessOperations event, String format) { return getEventInfo(event, format, new SimpleDateFormat( "MM/dd/yyyy HH:mm:sss z"));

public static String getEventInfo(EventAccessOperations event) { return getEventInfo(event, NO_ARG_STRING);

public static String getEventInfo(EventAccessOperations event, String format) { return getEventInfo(event, format, new SimpleDateFormat( "MM/dd/yyyy HH:mm:sss z")); }

xml.addNs(CaldavUWDef.caldavNamespace); xml.addNs(CaldavUWDef.icalNamespace);

xml.addNs(CaldavDefs.caldavNamespace); xml.addNs(CaldavDefs.icalNamespace);

public void addNamespace() throws WebdavIntfException { try { xml.addNs(CaldavUWDef.caldavNamespace); xml.addNs(CaldavUWDef.icalNamespace); } catch (Throwable t) { throw new WebdavIntfException(t); } }

xml.openTag(WebdavTags.acl); if (aces != null) { Iterator it = aces.iterator(); while (it.hasNext()) { Ace ace = (Ace)it.next(); emitAce(ace, true); emitAce(ace, false); } } xml.closeTag(WebdavTags.acl); } catch (WebdavIntfException wi) { throw wi;

emitAccess.emitAces(aces);

public void emitAcl(WebdavNsNode node) throws WebdavIntfException { CaldavBwNode uwnode = getBwnode(node); CaldavURI cdUri = uwnode.getCDURI(); Collection aces = null; try { if (cdUri.isCalendar()) { aces = getSvci().getAces(cdUri.getCal()); } else { aces = getSvci().getAces(((CaldavComponentNode)node).getEvent()); } xml.openTag(WebdavTags.acl); if (aces != null) { Iterator it = aces.iterator(); while (it.hasNext()) { Ace ace = (Ace)it.next(); emitAce(ace, true); emitAce(ace, false); } } xml.closeTag(WebdavTags.acl); } catch (WebdavIntfException wi) { throw wi; } catch (Throwable t) { throw new WebdavIntfException(t); } }

emitAccess = new EmitAccess(namespacePrefix, xml);

public void init(WebdavServlet servlet, HttpServletRequest req, Properties props, boolean debug) throws WebdavIntfException { super.init(servlet, req, props, debug); try { HttpSession session = req.getSession(); ServletContext sc = session.getServletContext(); String appName = sc.getInitParameter("bwappname"); if ((appName == null) || (appName.length() == 0)) { appName = "unknown-app-name"; } envPrefix = "org.bedework.app." + appName + "."; namespacePrefix = WebdavUtils.getUrlPrefix(req); namespace = namespacePrefix + "/schema"; publicCalendarRoot = getSvci().getSyspars().getPublicCalendarRoot(); userCalendarRoot = getSvci().getSyspars().getUserCalendarRoot(); } catch (Throwable t) { throw new WebdavIntfException(t); } }

for (priv = 0; priv < privTags.length; priv++) { if (MethodBase.nodeMatches(el, privTags[priv])) {

for (priv = 0; priv < AccessUtil.privTags.length; priv++) { if (MethodBase.nodeMatches(el, AccessUtil.privTags[priv])) {

public void parsePrivilege(AclInfo ainfo, Node nd, boolean grant) throws WebdavIntfException { CdAclInfo info = (CdAclInfo)ainfo; if (!grant) { // There's probably a way to block this throw WebdavIntfException.badRequest(); } Element el = getOnlyChild(nd); int priv; findPriv: { for (priv = 0; priv < privTags.length; priv++) { if (MethodBase.nodeMatches(el, privTags[priv])) { break findPriv; } } throw WebdavIntfException.badRequest(); } info.aces.add(new Ace(info.who, info.notWho, info.whoType, acl.makePriv(priv))); }

int rights,

public CalSvcIPars(String authUser, int rights, String user, String envPrefix, boolean publicAdmin, boolean caldav, String synchId, boolean debug) { this.authUser = authUser; this.rights = rights; this.user = user; this.envPrefix = envPrefix; this.publicAdmin = publicAdmin; this.caldav = caldav; this.synchId = synchId; this.debug = debug; }

this.rights = rights;

public CalSvcIPars(String authUser, int rights, String user, String envPrefix, boolean publicAdmin, boolean caldav, String synchId, boolean debug) { this.authUser = authUser; this.rights = rights; this.user = user; this.envPrefix = envPrefix; this.publicAdmin = publicAdmin; this.caldav = caldav; this.synchId = synchId; this.debug = debug; }

public IcalTranslator(IcalCallback cb, boolean debug) { this.cb = cb; this.debug = debug;

public IcalTranslator(IcalCallback cb) { this(cb, false);

public IcalTranslator(IcalCallback cb, boolean debug) { this.cb = cb; this.debug = debug; }

if (how.length == 0) { ca.accessAllowed = ca.privileges.getAnyAllowed(); return ca; }

public CurrentAccess evaluateAccess(AccessPrincipal who, String owner, Privilege[] how, char[] acl, PrivilegeSet filter) throws AccessException { boolean authenticated = !who.getUnauthenticated(); boolean isOwner = false; CurrentAccess ca = new CurrentAccess(); ca.desiredAccess = how; ca.acl = this; decode(acl); if (authenticated) { isOwner = who.getAccount().equals(owner); } StringBuffer debugsb = null; if (debug) { debugsb = new StringBuffer("Check access for '"); debugsb.append(new String(acl)); debugsb.append("' with authenticated = "); debugsb.append(authenticated); debugsb.append(" isOwner = "); debugsb.append(isOwner); } getPrivileges: { if (!authenticated) { ca.privileges = Ace.findMergedPrivilege(this, null, Ace.whoTypeUnauthenticated); break getPrivileges; } if (isOwner) { ca.privileges = Ace.findMergedPrivilege(this, null, Ace.whoTypeOwner); if (ca.privileges == null) { ca.privileges = PrivilegeSet.makeDefaultOwnerPrivileges(); } break getPrivileges; } // Not owner - look for user ca.privileges = Ace.findMergedPrivilege(this, who.getAccount(), Ace.whoTypeUser); if (ca.privileges != null) { if (debug) { debugsb.append("... For user got: " + ca.privileges); } break getPrivileges; } // No specific user access - look for group access if (who.getGroupNames() != null) { Iterator it = who.getGroupNames().iterator(); while (it.hasNext()) { String group = (String)it.next(); if (debug) { debugsb.append("...Try access for group " + group); } PrivilegeSet privs = Ace.findMergedPrivilege(this, group, Ace.whoTypeGroup); if (privs != null) { ca.privileges = PrivilegeSet.mergePrivileges(ca.privileges, privs, false); } } } if (ca.privileges != null) { if (debug) { debugsb.append("...For groups got: " + ca.privileges); } break getPrivileges; } // "other" access set? ca.privileges = Ace.findMergedPrivilege(this, null, Ace.whoTypeOther); if (ca.privileges != null) { if (debug) { debugsb.append("...For other got: " + ca.privileges); } break getPrivileges; } } // getPrivileges if (ca.privileges == null) { if (debug) { debugMsg(debugsb.toString() + "...Check access denied (noprivs)"); } return ca; } ca.privileges.setUnspecified(isOwner); if (filter != null) { ca.privileges.filterPrivileges(filter); } for (int i = 0; i < how.length; i++) { char priv = ca.privileges.getPrivilege(how[i].getIndex()); if ((priv != allowed) && (priv != allowedInherited)) { if (debug) { debugMsg(debugsb.toString() + "...Check access denied (!allowed)"); } return ca; } } if (debug) { debugMsg(debugsb.toString() + "...Check access allowed"); } ca.accessAllowed = true; return ca; }

public void decode(EncodedAcl acl, boolean getPrivileges) throws AccessException { decodeWhoType(acl); decodeHow(acl, getPrivileges);

public boolean decode(EncodedAcl acl, boolean getPrivileges, String name, int whoType) throws AccessException { acl.rewind(); while (acl.hasMore()) { decodeWhoType(acl); if ((whoType != getWhoType()) || !whoMatch(name)) { skipHow(acl); } else { decodeHow(acl, getPrivileges); return true; } } return false;

public void decode(EncodedAcl acl, boolean getPrivileges) throws AccessException { decodeWhoType(acl); decodeHow(acl, getPrivileges); }

return (Privilege)privs[privType].clone();

return privs[privType];

public static Privilege makePriv(int privType) { return (Privilege)privs[privType].clone(); }

sb.append("AclVO{");

sb.append("EncodedAcl{pos="); sb.append(pos);

public String toString() { StringBuffer sb = new StringBuffer(); sb.append("AclVO{");// sb.append(entityId); sb.append("}"); return sb.toString(); }

if (debug) { debugMsg("rewind"); }

public void rewind() { pos = 0; }

if (debug) { debugMsg("getChar='" + c + "'"); }

public char getChar() { if ((encoded == null) || (pos == encoded.length)) { return (char)-1; } char c = encoded[pos]; pos++; return c; }

sb.append("AceVO{who=");

sb.append("Ace{who=");

public String toString() { StringBuffer sb = new StringBuffer(); sb.append("AceVO{who="); sb.append(who); sb.append(", notWho="); sb.append(notWho); sb.append(", whoType="); sb.append(whoTypeNames[whoType]); sb.append("("); sb.append(whoType); sb.append(")"); if (how != null) { sb.append(", how="); sb.append(how); } sb.append(", \nprivs=["); Iterator it = getPrivs().iterator(); while (it.hasNext()) { Privilege p = (Privilege)it.next(); sb.append(p.toString()); sb.append("\n"); } sb.append("]"); sb.append("}"); return sb.toString(); }

start = ev.getDtend().getDate();

end = ev.getDtend().getDate();

void setEntity(Object o) throws CalFacadeException { entity = o; if (o instanceof EventInfo) { EventInfo ei = (EventInfo)o; BwEvent ev = ei.getEvent(); start = ev.getDtstart().getDate(); start = ev.getDtend().getDate(); return; } if (o instanceof EventPeriod) { EventPeriod ep = (EventPeriod)o; start = String.valueOf(ep.getStart()); start = String.valueOf(ep.getEnd()); return; } if (o instanceof Period) { Period p = (Period)o; start = String.valueOf(p.getStart()); start = String.valueOf(p.getEnd()); return; } start = null; end = null; }

start = String.valueOf(ep.getEnd());

end = String.valueOf(ep.getEnd());

void setEntity(Object o) throws CalFacadeException { entity = o; if (o instanceof EventInfo) { EventInfo ei = (EventInfo)o; BwEvent ev = ei.getEvent(); start = ev.getDtstart().getDate(); start = ev.getDtend().getDate(); return; } if (o instanceof EventPeriod) { EventPeriod ep = (EventPeriod)o; start = String.valueOf(ep.getStart()); start = String.valueOf(ep.getEnd()); return; } if (o instanceof Period) { Period p = (Period)o; start = String.valueOf(p.getStart()); start = String.valueOf(p.getEnd()); return; } start = null; end = null; }

start = String.valueOf(p.getEnd());

end = String.valueOf(p.getEnd());

void setEntity(Object o) throws CalFacadeException { entity = o; if (o instanceof EventInfo) { EventInfo ei = (EventInfo)o; BwEvent ev = ei.getEvent(); start = ev.getDtstart().getDate(); start = ev.getDtend().getDate(); return; } if (o instanceof EventPeriod) { EventPeriod ep = (EventPeriod)o; start = String.valueOf(ep.getStart()); start = String.valueOf(ep.getEnd()); return; } if (o instanceof Period) { Period p = (Period)o; start = String.valueOf(p.getStart()); start = String.valueOf(p.getEnd()); return; } start = null; end = null; }

public String getDefaultTimeZoneId() throws CalFacadeException;

public String getDefaultTimeZoneId() throws CalFacadeException { return defaultTimeZoneId; }

public String getDefaultTimeZoneId() throws CalFacadeException;

String name =seis.getProperty("name");

String name =seis.getProperty(seisNameKey);

public void addSeismogram(LocalSeismogramImpl seis, AuditInfo[] audit) { // Note this does not set the xlink, as the seis has not been saved anywhere yet. Document doc = config.getOwnerDocument(); Element sac = doc.createElement("SacSeismogram"); String name =seis.getProperty("name"); if (name == null || name.length() == 0) { name = edu.iris.Fissures.network.ChannelIdUtil.toStringNoDates(seis.channel_id); } Element nameE = doc.createElement("name"); nameE.setNodeValue(name); sac.appendChild(nameE); Property[] props = seis.getProperties(); Element propE, propNameE, propValueE; for (int i=0; i<props.length; i++) { if (props[i].name != "name") { propE = doc.createElement("property"); propNameE = doc.createElement("name"); propNameE.setNodeValue(props[i].name); propValueE = doc.createElement("value"); propValueE.setNodeValue(props[i].value); propE.appendChild(propNameE); propE.appendChild(propValueE); sac.appendChild(propE); } } config.appendChild(sac); seismogramCache.put(name, seis); logger.debug("added seis now "+getSeismogramNames().length+" seisnogram names.");xpath = new CachedXPathAPI(); logger.debug("2 added seis now "+getSeismogramNames().length+" seisnogram names."); }

if (props[i].name != "name") {

if (props[i].name != seisNameKey) {

public void addSeismogram(LocalSeismogramImpl seis, AuditInfo[] audit) { // Note this does not set the xlink, as the seis has not been saved anywhere yet. Document doc = config.getOwnerDocument(); Element sac = doc.createElement("SacSeismogram"); String name =seis.getProperty("name"); if (name == null || name.length() == 0) { name = edu.iris.Fissures.network.ChannelIdUtil.toStringNoDates(seis.channel_id); } Element nameE = doc.createElement("name"); nameE.setNodeValue(name); sac.appendChild(nameE); Property[] props = seis.getProperties(); Element propE, propNameE, propValueE; for (int i=0; i<props.length; i++) { if (props[i].name != "name") { propE = doc.createElement("property"); propNameE = doc.createElement("name"); propNameE.setNodeValue(props[i].name); propValueE = doc.createElement("value"); propValueE.setNodeValue(props[i].value); propE.appendChild(propNameE); propE.appendChild(propValueE); sac.appendChild(propE); } } config.appendChild(sac); seismogramCache.put(name, seis); logger.debug("added seis now "+getSeismogramNames().length+" seisnogram names.");xpath = new CachedXPathAPI(); logger.debug("2 added seis now "+getSeismogramNames().length+" seisnogram names."); }

if (props[i].name != "name") {

if (props[i].name != seisNameKey) {

public void addSeismogramRef(URL seisURL, String name, Property[] props, ParameterRef[] parm_ids, AuditInfo[] audit) { String baseStr = base.toString(); String seisStr = seisURL.toString(); if (seisStr.startsWith(baseStr)) { // use relative URL seisStr = seisStr.substring(baseStr.length()); } // end of if (seisStr.startsWith(baseStr)) Document doc = config.getOwnerDocument(); Element sac = doc.createElement("SacSeismogram"); sac.setAttributeNS(xlinkNS, "xlink:type", "simple"); sac.setAttributeNS(xlinkNS, "xlink:href", seisStr); Element nameE = doc.createElement("name"); Text text = doc.createTextNode(name); nameE.appendChild(text); sac.appendChild(nameE); Element propE, propNameE, propValueE; for (int i=0; i<props.length; i++) { if (props[i].name != "name") { propE = doc.createElement("property"); propNameE = doc.createElement("name"); text = doc.createTextNode(props[i].name); propNameE.appendChild(text); propValueE = doc.createElement("value"); text = doc.createTextNode(props[i].value); propValueE.appendChild(text); propE.appendChild(propNameE); propE.appendChild(propValueE); sac.appendChild(propE); } } config.appendChild(sac); }

newProps[newProps.length-1] = new Property("name",

newProps[newProps.length-1] = new Property(seisNameKey,

public LocalSeismogramImpl getSeismogram(String name) { if (seismogramCache.containsKey(name)) { return (LocalSeismogramImpl)seismogramCache.get(name); } // end of if (seismogramCache.containsKey(name)) String urlString = "NONE"; NodeList nList = evalNodeList(config, "SacSeismogram[name="+dquote+name+dquote+"]"); if (nList != null && nList.getLength() != 0) { try { Node n = nList.item(0); if (n instanceof Element) { Element e = (Element)n; urlString = e.getAttribute("xlink:href"); if (urlString == null || urlString == "") { throw new MalformedURLException(name+" does not have an xlink:href attribute"); } // end of if (urlString == null || urlString == "") URL sacURL = new URL(base, urlString); DataInputStream dis = new DataInputStream(new BufferedInputStream(sacURL.openStream())); SacTimeSeries sac = new SacTimeSeries(); sac.read(dis); LocalSeismogramImpl seis = SacToFissures.getSeismogram(sac); NodeList propList = evalNodeList(e, "property"); if (propList != null && propList.getLength() != 0) { Property[] props = seis.getProperties(); Property[] newProps = new Property[1+props.length+nList.getLength()]; System.arraycopy(props, 0, newProps, 0, props.length); for (int i=0; i<propList.getLength(); i++) { Element propElement = (Element)propList.item(i); newProps[props.length+i] = new Property(xpath.eval(propElement, "name/text()").str(), xpath.eval(propElement, "value/text()").str()); } // end of for newProps[newProps.length-1] = new Property("name", name); seis.setProperties(newProps); } if (seis != null) { seismogramCache.put(name, seis); } // end of if (seis != null) return seis; } } catch (MalformedURLException e) { logger.error("Couldn't get seismogram "+name, e); logger.error(urlString); } catch (Exception e) { logger.error("Couldn't get seismogram "+name, e); logger.error(urlString); } // end of try-catch } return null; }

TimeRange fileTimeWindow = new TimeRange(beginTime.getFissuresTime(), endTime.getFissuresTime());

MicroSecondTimeRange fileTimeWindow = new MicroSecondTimeRange(beginTime, endTime);

private TimeInterval processAllChannels(File file, String unitIdNumber) throws IOException { String fileName = file.getName(); String yearAndDay = file.getParentFile() .getParentFile() .getParentFile() .getName(); MicroSecondDate beginTime = FileNameParser.getBeginTime(yearAndDay, fileName); beginTime = LeapSecondApplier.applyLeapSecondCorrection(unitIdNumber, beginTime); TimeInterval nominalLengthOfData = new TimeInterval(new QuantityImpl(Double.valueOf(pp.getString("nominalLengthOfData")) .doubleValue(), UnitImpl.MILLISECOND)); MicroSecondDate endTime = beginTime.add(nominalLengthOfData); TimeRange fileTimeWindow = new TimeRange(beginTime.getFissuresTime(), endTime.getFissuresTime()); TimeInterval seismogramTime = new TimeInterval(0, UnitImpl.MILLISECOND); PacketType[] seismogramDataPacketArray; try { seismogramDataPacketArray = rtFileReader.processRT130Data(file.getCanonicalPath(), true, fileTimeWindow); } catch(RT130FormatException e) { reportFormatException(file, e); return seismogramTime; } System.out.println(file.getCanonicalPath()); LocalSeismogramImpl[] seis = toSeismogram.convert(seismogramDataPacketArray); Channel[] chans = toSeismogram.getChannels(); for(int i = 0; i < seis.length; i++) { // Add one sample period to end time to pad to the start of the next // packet MicroSecondDate end = seis[i].getEndTime() .add(seis[i].getSampling().getPeriod()); for(int j = 0; j < chans.length; j++) { if(chans[j].get_id() == seis[i].channel_id) { addToReport(chans[j], seis[i].getBeginTime(), end); break; } } // Get the time from the first seismogram if(flags.contains(RT130FileHandlerFlag.FULL) && seismogramTime.value == 0) { seismogramTime = new TimeInterval(seis[i].getBeginTime(), end); } } return seismogramTime; }

MicroSecondDate beginTime = getBeginTime(file, unitIdNumber);

public boolean scan(File file) throws IOException { if(file.getName().endsWith("00000000")) { return read(file); } String unitIdNumber = getUnitId(file); MicroSecondDate beginTime = getBeginTime(file, unitIdNumber); TimeInterval lengthOfData; try { lengthOfData = FileNameParser.getLengthOfData(file.getName()); } catch(RT130FormatException e) { reportFormatException(file, e); return false; } if(lengthOfData.value > acceptableLengthOfData) { reportBadName(file, file.getName() + " indicates more data than in a regular rt130 file. The file will be read to determine its true length."); return read(file); } TimeInterval nominalLengthOfData = new TimeInterval(new QuantityImpl(Double.valueOf(pp.getString("nominalLengthOfData")) .doubleValue(), UnitImpl.MILLISECOND)); MicroSecondDate nominalEndTime = beginTime.add(nominalLengthOfData); TimeRange fileTimeWindow = new TimeRange(beginTime.getFissuresTime(), nominalEndTime.getFissuresTime()); Channel[] channel; try { channel = chanCreator.create(unitIdNumber, beginTime, file.getCanonicalPath(), fileTimeWindow); } catch(RT130FormatError err) { reportFormatException(file, err); return false; } MicroSecondDate endTime = beginTime.add(lengthOfData); for(int i = 0; i < channel.length; i++) { addToReport(channel[i], beginTime, endTime); } return true; }

TimeRange fileTimeWindow = new TimeRange(beginTime.getFissuresTime(), nominalEndTime.getFissuresTime());

MicroSecondTimeRange fileTimeWindow = new MicroSecondTimeRange(beginTime, nominalEndTime);

public boolean scan(File file) throws IOException { if(file.getName().endsWith("00000000")) { return read(file); } String unitIdNumber = getUnitId(file); MicroSecondDate beginTime = getBeginTime(file, unitIdNumber); TimeInterval lengthOfData; try { lengthOfData = FileNameParser.getLengthOfData(file.getName()); } catch(RT130FormatException e) { reportFormatException(file, e); return false; } if(lengthOfData.value > acceptableLengthOfData) { reportBadName(file, file.getName() + " indicates more data than in a regular rt130 file. The file will be read to determine its true length."); return read(file); } TimeInterval nominalLengthOfData = new TimeInterval(new QuantityImpl(Double.valueOf(pp.getString("nominalLengthOfData")) .doubleValue(), UnitImpl.MILLISECOND)); MicroSecondDate nominalEndTime = beginTime.add(nominalLengthOfData); TimeRange fileTimeWindow = new TimeRange(beginTime.getFissuresTime(), nominalEndTime.getFissuresTime()); Channel[] channel; try { channel = chanCreator.create(unitIdNumber, beginTime, file.getCanonicalPath(), fileTimeWindow); } catch(RT130FormatError err) { reportFormatException(file, err); return false; } MicroSecondDate endTime = beginTime.add(lengthOfData); for(int i = 0; i < channel.length; i++) { addToReport(channel[i], beginTime, endTime); } return true; }

beginTime,

public boolean scan(File file) throws IOException { if(file.getName().endsWith("00000000")) { return read(file); } String unitIdNumber = getUnitId(file); MicroSecondDate beginTime = getBeginTime(file, unitIdNumber); TimeInterval lengthOfData; try { lengthOfData = FileNameParser.getLengthOfData(file.getName()); } catch(RT130FormatException e) { reportFormatException(file, e); return false; } if(lengthOfData.value > acceptableLengthOfData) { reportBadName(file, file.getName() + " indicates more data than in a regular rt130 file. The file will be read to determine its true length."); return read(file); } TimeInterval nominalLengthOfData = new TimeInterval(new QuantityImpl(Double.valueOf(pp.getString("nominalLengthOfData")) .doubleValue(), UnitImpl.MILLISECOND)); MicroSecondDate nominalEndTime = beginTime.add(nominalLengthOfData); TimeRange fileTimeWindow = new TimeRange(beginTime.getFissuresTime(), nominalEndTime.getFissuresTime()); Channel[] channel; try { channel = chanCreator.create(unitIdNumber, beginTime, file.getCanonicalPath(), fileTimeWindow); } catch(RT130FormatError err) { reportFormatException(file, err); return false; } MicroSecondDate endTime = beginTime.add(lengthOfData); for(int i = 0; i < channel.length; i++) { addToReport(channel[i], beginTime, endTime); } return true; }

System.err.println("The file is not 18 characters in length."); throw new RT130FormatException(); } else { String stringLengthOfData = fileName.substring(10, 18); long longLengthOfData = Long.parseLong(stringLengthOfData, 16); TimeInterval lengthOfData = new TimeInterval(longLengthOfData, UnitImpl.MILLISECOND); return lengthOfData;

throw new RT130FormatException("The file '" + fileName + "'is not 18 characters in length.");

public static TimeInterval getLengthOfData(String fileName) throws RT130FormatException { if(fileName.length() != 18) { System.err.println("The file is not 18 characters in length."); throw new RT130FormatException(); } else { String stringLengthOfData = fileName.substring(10, 18); long longLengthOfData = Long.parseLong(stringLengthOfData, 16); TimeInterval lengthOfData = new TimeInterval(longLengthOfData, UnitImpl.MILLISECOND); return lengthOfData; } }

String stringLengthOfData = fileName.substring(10, 18); long longLengthOfData = Long.parseLong(stringLengthOfData, 16); TimeInterval lengthOfData = new TimeInterval(longLengthOfData, UnitImpl.MILLISECOND); return lengthOfData;

public static TimeInterval getLengthOfData(String fileName) throws RT130FormatException { if(fileName.length() != 18) { System.err.println("The file is not 18 characters in length."); throw new RT130FormatException(); } else { String stringLengthOfData = fileName.substring(10, 18); long longLengthOfData = Long.parseLong(stringLengthOfData, 16); TimeInterval lengthOfData = new TimeInterval(longLengthOfData, UnitImpl.MILLISECOND); return lengthOfData; } }

double mean = (basic.getMaxValue() - basic.getMinValue())/2; double offset = basic.getMaxValue() - mean;

double offset = (basic.getMaxValue() - basic.getMinValue())/2;

protected UnitRangeImpl calcGenericAmp(UnitRangeImpl inAmp, DataSetSeismogram seis) { UnitRangeImpl basic = super.calcGenericAmp(inAmp, seis); double mean = (basic.getMaxValue() - basic.getMinValue())/2; double offset = basic.getMaxValue() - mean; UnitRangeImpl out = new UnitRangeImpl(-1 * offset, offset , basic.getUnit()); return UnitDisplayUtil.getBestForDisplay(out); }

form.getMsg().emit("org.bedework.client.message.admingroup.updated");

public String doAction(HttpServletRequest request, BwSession sess, PEActionForm form) throws Throwable { /* Check access */ if (!form.getUserAuth().isSuperUser()) { return "noAccess"; } String reqpar = request.getParameter("delete"); if (reqpar != null) { return "delete"; } Groups adgrps = form.getCalSvcI().getGroups(); form.assignChoosingGroup(false); // reset boolean add = form.getAddingAdmingroup(); BwAdminGroup updgrp = form.getUpdAdminGroup(); if (updgrp == null) { // That's not right return "done"; } CalSvcI svci = form.getCalSvcI(); if (request.getParameter("addGroupMember") != null) { /** Add a user to the group we are updating. */ String mbr = form.getUpdGroupMember(); if (mbr != null) { BwUser u = svci.findUser(mbr); if (u != null) { /* Ensure the authorised user exists - create an entry if not * * @param val BwUser account */ UserAuth uauth = svci.getUserAuth(); BwAuthUser au = uauth.getUser(u.getAccount()); if ((au != null) && (au.getUsertype() == UserAuth.noPrivileges)) { return "notAllowed"; } if (au == null) { au = new BwAuthUser(u, UserAuth.publicEventUser); uauth.updateUser(au); } adgrps.addMember(updgrp, u); } } } else if (request.getParameter("removeGroupMember") != null) { /** Remove a user from the group we are updating. */ String mbr = form.getUpdGroupMember(); if (mbr != null) { BwUser u = form.getCalSvcI().findUser(mbr); if (u != null) { adgrps.removeMember(updgrp, u); } } } else if (add) { if (!validateNewAdminGroup(form)) { return "retry"; } adgrps.addGroup(updgrp); } else { if (!validateAdminGroup(form)) { return "retry"; } if (debug) { debugMsg("About to update " + updgrp); } adgrps.updateGroup(updgrp); } /** Refetch the group */ updgrp = (BwAdminGroup)adgrps.findGroup(updgrp.getAccount()); adgrps.getMembers(updgrp); form.setUpdAdminGroup(updgrp); return "continue"; }

this.color = color;

public ParticleMotion(DataSetSeismogram hSeis, DataSetSeismogram vSeis, TimeConfig tc, Color color, String key, boolean horizPlane) { horiz = new SeismogramContainer(this,hSeis); vert = new SeismogramContainer(this, vSeis); this.tc = tc; this.key = key; setUpConfigs(); this.horizPlane = horizPlane; if(horizPlane){ pmd.displayBackAzimuth(hSeis.getDataSet(), hSeis.getRequestFilter().channel_id, color); } this.color = color; tc.fireTimeEvent(); }

public void add(NamedFilter filter){ if(!filterToParMo.containsKey(filter))

public void add(NamedFilter filter, Color color){ if(!filterToParMo.containsKey(filter)){

public void add(NamedFilter filter){ if(!filterToParMo.containsKey(filter)) filterToParMo.put(filter, new ParticleMotion(FilteredDataSetSeismogram.getFiltered(horiz.getDataSetSeismogram(), filter), FilteredDataSetSeismogram.getFiltered(vert.getDataSetSeismogram(), filter), tc, SeismogramDisplay.COLORS[filterCount++ % SeismogramDisplay.COLORS.length], key, horizPlane)); }

SeismogramDisplay.COLORS[filterCount++ % SeismogramDisplay.COLORS.length],

color,

public void add(NamedFilter filter){ if(!filterToParMo.containsKey(filter)) filterToParMo.put(filter, new ParticleMotion(FilteredDataSetSeismogram.getFiltered(horiz.getDataSetSeismogram(), filter), FilteredDataSetSeismogram.getFiltered(vert.getDataSetSeismogram(), filter), tc, SeismogramDisplay.COLORS[filterCount++ % SeismogramDisplay.COLORS.length], key, horizPlane)); }

if(statusTable != null) statusTable.setComponent(this, generateLabel()); }

public void add(NamedFilter filter){ if(!filterToParMo.containsKey(filter)) filterToParMo.put(filter, new ParticleMotion(FilteredDataSetSeismogram.getFiltered(horiz.getDataSetSeismogram(), filter), FilteredDataSetSeismogram.getFiltered(vert.getDataSetSeismogram(), filter), tc, SeismogramDisplay.COLORS[filterCount++ % SeismogramDisplay.COLORS.length], key, horizPlane)); }

int[]hPixels = SimplePlotUtil.getPlottableSimple(horiz.getIterator(tr), ae.getAmp(horiz.getDataSetSeismogram()), size); int[] vPixels = SimplePlotUtil.getPlottableSimple(vert.getIterator(tr), ae.getAmp(vert.getDataSetSeismogram()), size); SimplePlotUtil.flipArray(hPixels, size.width); g2D.draw(getParticleMotionPath(hPixels, vPixels));

GeneralPath generalPath = new GeneralPath(GeneralPath.WIND_EVEN_ODD); boolean prevPointBad = true; SeismogramIterator hIt = horiz.getIterator(tr); double hMin = ae.getAmp(horiz.getDataSetSeismogram()).getMinValue(); double hMax = ae.getAmp(horiz.getDataSetSeismogram()).getMaxValue(); SeismogramIterator vIt = vert.getIterator(tr); double vMin = ae.getAmp(vert.getDataSetSeismogram()).getMinValue(); double vMax = ae.getAmp(vert.getDataSetSeismogram()).getMaxValue(); while(hIt.hasNext() && vIt.hasNext()){ float hVal = getVal(hIt, hMin, hMax, size.height); float vVal = getVal(vIt, vMin, vMax, size.height); if(hVal == Integer.MAX_VALUE || vVal == Integer.MAX_VALUE){ prevPointBad = true; }else{ hVal *= -1; hVal += size.height; if(prevPointBad){ generalPath.moveTo(hVal, vVal); prevPointBad = false; }else{ generalPath.lineTo(hVal, vVal); } } } g2D.draw(generalPath);

public void draw(Graphics g, Dimension size) { if(visible){ Graphics2D g2D = (Graphics2D) g; if(horiz.getIterator(tr).numPointsLeft() <= 0 || vert.getIterator(tr).numPointsLeft() <= 0){ return; } g2D.setColor(color); g2D.setStroke(DisplayUtils.TWO_PIXEL_STROKE); int[]hPixels = SimplePlotUtil.getPlottableSimple(horiz.getIterator(tr), ae.getAmp(horiz.getDataSetSeismogram()), size); int[] vPixels = SimplePlotUtil.getPlottableSimple(vert.getIterator(tr), ae.getAmp(vert.getDataSetSeismogram()), size); SimplePlotUtil.flipArray(hPixels, size.width); g2D.draw(getParticleMotionPath(hPixels, vPixels)); } Iterator it = filterToParMo.keySet().iterator(); while(it.hasNext()){ ((ParticleMotion)filterToParMo.get(it.next())).draw(g, size); } }

if(statusTable != null) statusTable.setComponent(this, generateLabel());

public void remove(NamedFilter filter){ if(filterToParMo.containsKey(filter)){ ((ParticleMotion)filterToParMo.get(filter)).tearDownConfigs(); filterToParMo.remove(filter); } }

((ParticleMotion)it.next()).add(filter);

ParticleMotion cur = (ParticleMotion)it.next(); cur.add(filter, getColor(cur.getTimeConfig(), filter));

public void add(NamedFilter filter){ Iterator it = parMos.iterator(); while(it.hasNext()){ ((ParticleMotion)it.next()).add(filter); } repaint(); }

public synchronized void drawAzimuth(ParticleMotion particleMotion, Graphics2D graphics2D) {

public void drawAzimuth(ParticleMotion particleMotion, Graphics2D graphics2D) {

public synchronized void drawAzimuth(ParticleMotion particleMotion, Graphics2D graphics2D) { if(!particleMotion.isHorizontalPlane()) return; Shape sector = getSectorShape(); graphics2D.setPaint(Color.LIGHT_GRAY); graphics2D.fill(sector); graphics2D.draw(sector); drawAzimuths(graphics2D); graphics2D.setStroke(DisplayUtils.ONE_PIXEL_STROKE); }

g2D.setColor(new Color(parMoCo.getRed(), parMoCo.getGreen(), parMoCo.getBlue(), 96)); GeneralPath generalPath = new GeneralPath(); double degrees = key.doubleValue(); int x = (int)(fmin * Math.cos(Math.toRadians(degrees))); int y = (int)(fmax * Math.sin(Math.toRadians(degrees))); generalPath.moveTo(newx+x, newy-y); generalPath.lineTo(newx-x, newy+y); g2D.draw(generalPath);

if(parMoCo != null){ g2D.setColor(new Color(parMoCo.getRed(), parMoCo.getGreen(), parMoCo.getBlue(), 96)); GeneralPath generalPath = new GeneralPath(); double degrees = key.doubleValue(); int x = (int)(fmin * Math.cos(Math.toRadians(degrees))); int y = (int)(fmax * Math.sin(Math.toRadians(degrees))); generalPath.moveTo(newx+x, newy-y); generalPath.lineTo(newx-x, newy+y); g2D.draw(generalPath); }

public void drawAzimuths(Graphics2D g2D) { Insets insets = getInsets(); double fmin = super.getSize().getWidth() - insets.left - insets.right; double fmax = super.getSize().getHeight() - insets.top - insets.bottom; int originx = (int)(fmin/2); int originy = (int)(fmax/2); int newx = originx; int newy = originy; Iterator it = azimuths.keySet().iterator(); g2D.setStroke(DisplayUtils.TWO_PIXEL_STROKE); while(it.hasNext()){ Double key = (Double)it.next(); Color parMoCo =(Color)azimuths.get(key); g2D.setColor(new Color(parMoCo.getRed(), parMoCo.getGreen(), parMoCo.getBlue(), 96)); GeneralPath generalPath = new GeneralPath(); double degrees = key.doubleValue(); int x = (int)(fmin * Math.cos(Math.toRadians(degrees))); int y = (int)(fmax * Math.sin(Math.toRadians(degrees))); generalPath.moveTo(newx+x, newy-y); generalPath.lineTo(newx-x, newy+y); g2D.draw(generalPath); } }

public SeismogramContainer(SeismogramContainerListener initialListener, DataSetSeismogram seismogram){ if(initialListener != null){ listeners.add(initialListener); } this.seismogram = seismogram; seismogram.addSeisDataChangeListener(this); seismogram.addRequestFilterChangeListener(this);

public SeismogramContainer(DataSetSeismogram seismogram){ this(null, seismogram);

public SeismogramContainer(SeismogramContainerListener initialListener, DataSetSeismogram seismogram){ if(initialListener != null){ listeners.add(initialListener); } this.seismogram = seismogram; seismogram.addSeisDataChangeListener(this); seismogram.addRequestFilterChangeListener(this); }

public SeismogramIterator getIterator(MicroSecondTimeRange timeRange){ SoftReference iteratorReference = null; synchronized(threadToIterator){ iteratorReference = (SoftReference)threadToIterator.get(Thread.currentThread());

public SeismogramIterator getIterator(){ MicroSecondTimeRange fullTime = time; if(fullTime == null){ fullTime = DisplayUtils.getFullTime(getSeismograms()); time = fullTime;

public SeismogramIterator getIterator(MicroSecondTimeRange timeRange){ SoftReference iteratorReference = null; synchronized(threadToIterator){ iteratorReference = (SoftReference)threadToIterator.get(Thread.currentThread()); } if(iteratorReference != null){ SeismogramIterator it = (SeismogramIterator)iteratorReference.get(); if(it != null && it.hasNext()){ if(it.getTimeRange().equals(timeRange)){ return it; }else if(timeRange != null){ it.setTimeRange(timeRange); return it; } } } SeismogramIterator it = new SeismogramIterator(seismogram.getName(), getSeismograms(), timeRange); synchronized(threadToIterator){ threadToIterator.put(Thread.currentThread(),new SoftReference(it)); } return it; }

if(iteratorReference != null){ SeismogramIterator it = (SeismogramIterator)iteratorReference.get(); if(it != null && it.hasNext()){ if(it.getTimeRange().equals(timeRange)){ return it; }else if(timeRange != null){ it.setTimeRange(timeRange); return it; } } } SeismogramIterator it = new SeismogramIterator(seismogram.getName(), getSeismograms(), timeRange); synchronized(threadToIterator){ threadToIterator.put(Thread.currentThread(),new SoftReference(it)); } return it;

return getIterator(fullTime);

public SeismogramIterator getIterator(MicroSecondTimeRange timeRange){ SoftReference iteratorReference = null; synchronized(threadToIterator){ iteratorReference = (SoftReference)threadToIterator.get(Thread.currentThread()); } if(iteratorReference != null){ SeismogramIterator it = (SeismogramIterator)iteratorReference.get(); if(it != null && it.hasNext()){ if(it.getTimeRange().equals(timeRange)){ return it; }else if(timeRange != null){ it.setTimeRange(timeRange); return it; } } } SeismogramIterator it = new SeismogramIterator(seismogram.getName(), getSeismograms(), timeRange); synchronized(threadToIterator){ threadToIterator.put(Thread.currentThread(),new SoftReference(it)); } return it; }

System.out.println(" calendars: " + calendars);

public void stats() { System.out.println(" syspars: " + syspars); System.out.println(" users: " + users); System.out.println(" timezones: " + timezones); System.out.println(" subscribedUsers: " + subscribedUsers); System.out.println(" subscriptions: " + subscriptions); System.out.println(" locations: " + locations); System.out.println(" sponsors: " + sponsors); System.out.println(" organizers: " + organizers); System.out.println(" attendees: " + attendees); System.out.println(" alarms: " + valarms); System.out.println(" categories: " + categories); System.out.println(" authusers: " + authusers); System.out.println(" events: " + events); System.out.println(" eventAnnotations: " + eventAnnotations); System.out.println(" filters: " + filters); System.out.println(" adminGroups: " + adminGroups); }

logger.debug("---------------___----------> RETURNING THE CHANNELS");

public Channel[] retrieve_grouping( Channel[] channels, Channel channel) { ChannelId channelId = channel.get_id(); String givenChannelStr = channelId.channel_code; String givenPrefixStr = givenChannelStr.substring(0, givenChannelStr.length() - 1); char givenOrientation = givenChannelStr.charAt(givenChannelStr.length() - 1); String searchString = ""; Channel[] rtnchannels = new Channel[3]; for(int j = 0; j < channels.length; j++) { System.out.println("THe channel Str is "+ ChannelIdUtil.toString(channels[j].get_id())); } //System.out.println("The given Channel is "+givenChannelStr+" given Orientation is "+givenOrientation); for(int i = 0; i < patterns.length; i++) { if(patterns[i].indexOf(givenOrientation) != -1) { searchString = patterns[i]; //System.out.println("The search String is "+searchString); searchString = searchString.replace(givenOrientation, '_'); //System.out.println("The search string after is "+searchString); } else { return new Channel[0]; } int count = 0; rtnchannels = new Channel[3]; rtnchannels[count] = channel; count++; //System.out.println("The length of the channels is "+channels.length); for(int counter = 0; counter < channels.length; counter++) { String channelStr = channels[counter].get_id().channel_code; String prefixStr = channelStr.substring(0, channelStr.length() - 1); char orientation = channelStr.charAt(channelStr.length() - 1); //System.out.println("The channelstr is "+channelStr); if(prefixStr.equals(givenPrefixStr) && searchString.indexOf(orientation) != -1) { //System.out.println("The searchString is "+searchString); searchString = searchString.replace(orientation,'_'); rtnchannels[count] = channels[counter]; count++; //System.out.println("ORIENTATION "+orientation+"The matched channelStr is "+channelStr); } } if( searchString.equals("___") ) { //System.out.println("---------------___----------> RETURNING THE CHANNELS"); for(int counter = 0; counter < rtnchannels.length; counter++) { //if(rtnchannels[counter] == null) //System.out.println(" IS NULL "); // else //System.out.println(" IS NOT NULL "); } return rtnchannels; } } return new Channel[0]; }

if(rtnchannels[counter] == null) System.out.println(" IS NULL "); else System.out.println(" IS NOT NULL ");

public Channel[] retrieve_grouping( Channel[] channels, Channel channel) { ChannelId channelId = channel.get_id(); String givenChannelStr = channelId.channel_code; String givenPrefixStr = givenChannelStr.substring(0, givenChannelStr.length() - 1); char givenOrientation = givenChannelStr.charAt(givenChannelStr.length() - 1); String searchString = ""; Channel[] rtnchannels = new Channel[3]; for(int j = 0; j < channels.length; j++) { System.out.println("THe channel Str is "+ ChannelIdUtil.toString(channels[j].get_id())); } //System.out.println("The given Channel is "+givenChannelStr+" given Orientation is "+givenOrientation); for(int i = 0; i < patterns.length; i++) { if(patterns[i].indexOf(givenOrientation) != -1) { searchString = patterns[i]; //System.out.println("The search String is "+searchString); searchString = searchString.replace(givenOrientation, '_'); //System.out.println("The search string after is "+searchString); } else { return new Channel[0]; } int count = 0; rtnchannels = new Channel[3]; rtnchannels[count] = channel; count++; //System.out.println("The length of the channels is "+channels.length); for(int counter = 0; counter < channels.length; counter++) { String channelStr = channels[counter].get_id().channel_code; String prefixStr = channelStr.substring(0, channelStr.length() - 1); char orientation = channelStr.charAt(channelStr.length() - 1); //System.out.println("The channelstr is "+channelStr); if(prefixStr.equals(givenPrefixStr) && searchString.indexOf(orientation) != -1) { //System.out.println("The searchString is "+searchString); searchString = searchString.replace(orientation,'_'); rtnchannels[count] = channels[counter]; count++; //System.out.println("ORIENTATION "+orientation+"The matched channelStr is "+channelStr); } } if( searchString.equals("___") ) { //System.out.println("---------------___----------> RETURNING THE CHANNELS"); for(int counter = 0; counter < rtnchannels.length; counter++) { //if(rtnchannels[counter] == null) //System.out.println(" IS NULL "); // else //System.out.println(" IS NOT NULL "); } return rtnchannels; } } return new Channel[0]; }

public abstract int getMaximumValue(long instant);

public abstract int getMaximumValue();

public abstract int getMaximumValue(long instant);

ClassLoader cl = SeismogramDisplayConfigurationTest.class.getClassLoader();

ClassLoader cl = DOMHelper.class.getClassLoader();

public static Element createElement(String loc) throws Exception { ClassLoader cl = SeismogramDisplayConfigurationTest.class.getClassLoader(); InputStream source = cl.getResourceAsStream(loc); DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setNamespaceAware(true); DocumentBuilder builder = factory.newDocumentBuilder(); Document doc = builder.parse(source); return doc.getDocumentElement(); }

dss.setDataSet(this);

public void addDataSetSeismogram(DataSetSeismogram dss, AuditInfo[] audit) { String name; name = dss.getName(); if ( name == null || name.length() == 0) { name = ChannelIdUtil.toStringNoDates(dss.getRequestFilter().channel_id); } // end of if () name = XMLUtil.getUniqueName(getDataSetSeismogramNames(), name); if ( ! name.equals(dss.getName()) ) { dss.setName(name); } // end of if () dssNames.add(name); dataSetSeismograms.put(name, dss); }

if(href.startsWith("file:")) { href = href.substring(href.indexOf("file:")+1); } href.replace(' ', '_');

public static void insertParameterRef(Element paramRef, String name, String href, Object value) { // write(href, value); //Element paramRef = doc.createElement("parameterRef"); paramRef.setAttribute("name", name); paramRef.setAttributeNS(xlinkNS,"xlink:type", "type/xml"); paramRef.setAttributeNS(xlinkNS, "xlink:href", href); if(!(value instanceof String)) { paramRef.setAttribute("objectType", getObjectType(value)); } /* try { DocumentBuilderFactory factory = DocumentBuilderFactory.getInstance(); DocumentBuilder builder = factory.newDocumentBuilder(); } catch(Exception e) { e.printStackTrace(); }*/ }

return new NATAsyncMessage(ctx.base_getSelf(), this.getSelector(),

return new NATAsyncMessage(ctx.base_getSelf(), this.base_getSelector(),

public ATObject meta_eval(ATContext ctx) throws NATException { return new NATAsyncMessage(ctx.base_getSelf(), this.getSelector(), Evaluator.evaluateArguments(this.base_getArguments().asNativeTable(), ctx)); }

public String getAsShortText(int fieldValue, Locale locale) { return getAsText(fieldValue, locale);

public String getAsShortText(long instant, Locale locale) { return getAsShortText(get(instant), locale);

public String getAsShortText(int fieldValue, Locale locale) { return getAsText(fieldValue, locale); }

public String getAsText(int fieldValue, Locale locale) { return Integer.toString(fieldValue);

public String getAsText(long instant, Locale locale) { return getAsText(get(instant), locale);

public String getAsText(int fieldValue, Locale locale) { return Integer.toString(fieldValue); }

if( chanMap.containsKey(keyStr)) { System.out.println("Found the channelID: "); return (ChannelId)(chanMap.get(keyStr)); } else { System.out.println("The channelID is not Found"); return null;

System.out.println("### Passed channelID: " + keyStr);

public ChannelId getChannelId(String keyStr) { if( chanMap.containsKey(keyStr)) { System.out.println("Found the channelID: "); return (ChannelId)(chanMap.get(keyStr)); } else { System.out.println("The channelID is not Found"); return null; } }

}

ChannelId foundChannelId = null; Iterator it = chanIdMap.keySet().iterator(); while (it.hasNext()) { java.lang.Object key = it.next(); String stkey = (String)key; if(stkey.equals(keyStr)) { System.out.println("Found the channelID: "+stkey); foundChannelId = (ChannelId)(chanIdMap.get(keyStr)); } } if(foundChannelId==null) System.out.println(keyStr + "'s ChannelId could not be found."); return foundChannelId;

public ChannelId getChannelId(String keyStr) { if( chanMap.containsKey(keyStr)) { System.out.println("Found the channelID: "); return (ChannelId)(chanMap.get(keyStr)); } else { System.out.println("The channelID is not Found"); return null; } }

chanIdkey = netCode + "." + stationCode + "." + siteCode + "." + channelCode; chanIdMap.put(chanIdkey,thechannelid );

public void setChannels(String netCode, String stationCode) { NetworkAccess netAccess = (edu.iris.Fissures.IfNetwork.NetworkAccess) netMap.get(netCode); Station station = (edu.iris.Fissures.IfNetwork.Station) staMap.get(stationCode); Channel[] allChannels = netAccess.retrieve_for_station(station.get_id()); sitMap.clear(); chanMap.clear(); for (int i=0; i<allChannels.length; i++) { edu.iris.Fissures.IfNetwork.Site thesite = allChannels[i].my_site; edu.iris.Fissures.IfNetwork.SiteId thesiteid = thesite.get_id(); String siteCode = thesiteid .site_code; sitMap.put(siteCode, thesite); edu.iris.Fissures.IfNetwork.ChannelId thechannelid = allChannels[i].get_id(); String channelCode = thechannelid.channel_code; chanMap.put(channelCode, allChannels[i]); } TreeSet sitTree = new TreeSet(sitMap.keySet()); sites = (String[])sitTree.toArray(new String[0]); TreeSet chaTree = new TreeSet(chanMap.keySet()); channels = (String[])chaTree.toArray(new String[0]); }

if (form.getGuest()) {

if (!form.getUserAuth().isSuperUser()) {

public String doAction(HttpServletRequest request, HttpServletResponse response, BwSession sess, BwActionFormBase form) throws Throwable { if (form.getGuest()) { return "noAccess"; // First line of defence } CalSvcI svc = form.getCalSvcI(); BwPreferences prefs; String str = request.getParameter("user"); if (str != null) { if (!form.getUserAuth().isSuperUser()) { return "noAccess"; // First line of defence } BwUser user = svc.findUser(str); if (user == null) { form.getErr().emit("org.bedework.client.error.nosuchuserid", str); return "notFound"; } prefs = svc.getUserPrefs(user); } else { prefs = svc.getUserPrefs(); } form.setUserPreferences(prefs); return "success"; }

BwPreferences prefs; String str = request.getParameter("user"); if (str != null) { if (!form.getUserAuth().isSuperUser()) { return "noAccess"; } BwUser user = svc.findUser(str); if (user == null) { form.getErr().emit("org.bedework.client.error.nosuchuserid", str); return "notFound"; } prefs = svc.getUserPrefs(user); } else { prefs = svc.getUserPrefs();

String str = getReqPar(request, "user"); if (str == null) { return "success";

public String doAction(HttpServletRequest request, HttpServletResponse response, BwSession sess, BwActionFormBase form) throws Throwable { if (form.getGuest()) { return "noAccess"; // First line of defence } CalSvcI svc = form.getCalSvcI(); BwPreferences prefs; String str = request.getParameter("user"); if (str != null) { if (!form.getUserAuth().isSuperUser()) { return "noAccess"; // First line of defence } BwUser user = svc.findUser(str); if (user == null) { form.getErr().emit("org.bedework.client.error.nosuchuserid", str); return "notFound"; } prefs = svc.getUserPrefs(user); } else { prefs = svc.getUserPrefs(); } form.setUserPreferences(prefs); return "success"; }

form.setUserPreferences(prefs);

BwUser user = svc.findUser(str); if (user == null) { form.getErr().emit("org.bedework.client.error.nosuchuserid", str); return "notFound"; } form.setUserPreferences(svc.getUserPrefs(user));

public String doAction(HttpServletRequest request, HttpServletResponse response, BwSession sess, BwActionFormBase form) throws Throwable { if (form.getGuest()) { return "noAccess"; // First line of defence } CalSvcI svc = form.getCalSvcI(); BwPreferences prefs; String str = request.getParameter("user"); if (str != null) { if (!form.getUserAuth().isSuperUser()) { return "noAccess"; // First line of defence } BwUser user = svc.findUser(str); if (user == null) { form.getErr().emit("org.bedework.client.error.nosuchuserid", str); return "notFound"; } prefs = svc.getUserPrefs(user); } else { prefs = svc.getUserPrefs(); } form.setUserPreferences(prefs); return "success"; }

System.out.println("THEEE TIME TAKEN FOR getFISSURESTIME is *&&&&&&&&&&&&&&&&&&&********"+(endTime.getTime() - startTime.getTime()));

public static edu.iris.Fissures.Time getFissuresTime(Element element) { Date startTime = Calendar.getInstance().getTime(); NodeList nodeList = element.getChildNodes(); String date_time = ""; int leap_seconds_version = 0; for(int counter = 0; counter < nodeList.getLength(); counter++) { if(nodeList.item(counter) instanceof Element) { Element elem = (Element)nodeList.item(counter); if(elem.getNodeName().equals("date_time")) { System.out.println(" THE VALUE is "+XMLUtil.getText(elem)); date_time = XMLUtil.getText(elem); } else if(elem.getNodeName().equals("leap_seconds_version")) { leap_seconds_version = Integer.parseInt(XMLUtil.getText(elem)); } } //String date_time = XMLUtil.evalString(element, "date_time"); //int leap_seconds_version = Integer.parseInt(XMLUtil.evalString(element,"leap_seconds_version")); } Date endTime = Calendar.getInstance().getTime(); System.out.println("THEEE TIME TAKEN FOR getFISSURESTIME is *&&&&&&&&&&&&&&&&&&&********"+(endTime.getTime() - startTime.getTime())); return new edu.iris.Fissures.Time(date_time, leap_seconds_version); }

Locale loc = scal.getCalInfo().getLocale(); scal = new MyCalendarVO(scal.getTime(), loc);

public String doAction(HttpServletRequest request, BwActionForm form) throws Throwable { BwUser user; CalSvcI svci = form.fetchSvci(); gotoDateView(this, form, form.getDate(), form.getViewTypeI(), debug); String userId = getReqPar(request, "userid"); if (userId != null) { user = svci.findUser(userId); if (user == null) { form.getErr().emit("org.bedework.client.error.usernotfound"); return "notFound"; } } else { user = svci.getUser(); } MyCalendarVO scal; Calendar start; Calendar end; Calendar endDay; String st = getReqPar(request, "start"); if (st == null) { /* Set period and start from the current timeview */ TimeView tv = form.getCurTimeView(); scal = tv.getFirstDay(); start = scal.getCalendar(); end = tv.getLastDay().getTomorrow().getCalendar(); } else { Locale loc = Locale.getDefault(); // XXX Locale Date jdt = CalFacadeUtil.fromISODate(st); scal = new MyCalendarVO(jdt, loc); scal = scal.getFirstDayOfThisWeek(); start = scal.getCalendar(); //BwDateTime startDt = form.getEventStartDate().getDateTime(); end = scal.getNextWeek().getCalendar(); } endDay = scal.getTomorrow().getCalendar(); int interval = getIntReqPar(request, "interval", 1); if (interval <= 0) { form.getErr().emit("org.bedework.client.error.badinterval"); return "error"; } String intunitStr = getReqPar(request, "intunit"); BwDuration dur = new BwDuration(); if (intunitStr != null) { if ("minutes".equals(intunitStr)) { dur.setMinutes(interval); } else if ("hours".equals(intunitStr)) { dur.setHours(interval); } else if ("days".equals(intunitStr)) { dur.setDays(interval); } else if ("weeks".equals(intunitStr)) { dur.setWeeks(interval); } else { form.getErr().emit("org.bedework.client.error.badintervalunit"); return "error"; } } else { dur.setHours(interval); } //int maxRequests = 1000; CalTimezones tzs = svci.getTimezones(); Collection freeBusy = new ArrayList(); /* Get the free busy in daily chunks and process for display */ while (start.before(end)) { Date sdt = start.getTime(); Date edt = endDay.getTime(); if (debug) { debugMsg("getFreeBusy for start = " + sdt + " end = " + edt); } try { BwFreeBusy fb = svci.getFreeBusy(null, user, CalFacadeUtil.getDateTime(sdt, false, false, tzs), CalFacadeUtil.getDateTime(edt, false, false, tzs), dur, true); FormattedFreeBusy ffb = new FormattedFreeBusy(fb); freeBusy.add(ffb); start.add(Calendar.DAY_OF_MONTH, 1); endDay.add(Calendar.DAY_OF_MONTH, 1); } catch (CalFacadeAccessException cfae) { form.getErr().emit("org.bedework.client.error.noaccess"); return "noAccess"; } } form.assignFreeBusy(freeBusy); return "success"; }

public abstract String doAction(HttpServletRequest request, BwActionForm form) throws Throwable;

public String doAction(HttpServletRequest request, HttpServletResponse response, BwSession sess, BwActionFormBase frm) throws Throwable { BwActionForm form = (BwActionForm)frm; String forward = doAction(request, form); return forward; }

public abstract String doAction(HttpServletRequest request, BwActionForm form) throws Throwable;

firstDay.set(Calendar.HOUR_OF_DAY, 0); firstDay.set(Calendar.MINUTE, 0); firstDay.set(Calendar.SECOND, 0); firstDay.set(Calendar.MILLISECOND, 0);

public MyCalendarVO getFirstDayOfThisWeek() { Calendar firstDay = (Calendar)calendar.clone(); firstDay.set(Calendar.DAY_OF_WEEK, calInfo.getFirstDayOfWeek()); return new MyCalendarVO(firstDay, calInfo.getLocale()); }

if(it.next().toString().equals(seismogram.toString())){

DataSetSeismogram current = ((LayoutData)it.next()).getSeis(); if(current.equals(seismogram)){

public int sort(DataSetSeismogram seismogram){ DataSetSeismogram[] dss = {seismogram}; layoutConfig.add(dss); Iterator it = layoutConfig.generateLayoutEvent().iterator(); int i = 0; while(it.hasNext()){ if(it.next().toString().equals(seismogram.toString())){ return i; } i++; } return 0; }

orderedSeis.add(0, seis[0]);

orderedSeis.add(seis[0]);

public synchronized LayoutEvent generateLayoutEvent(){ DataSetSeismogram[] seis = getSeismograms(); if(seis.length > 0){ List orderedSeis = new ArrayList(seis.length); orderedSeis.add(0, seis[0]); double minDistBetween = Double.POSITIVE_INFINITY; for (int i = 1; i < seis.length; i++){ DataSetSeismogram curSeis = seis[i]; double curSeisDelt = ((QuantityImpl)distanceMap.get(curSeis)).getValue(); ListIterator orIt = orderedSeis.listIterator(); boolean added = false; while(orIt.hasNext()){ DataSetSeismogram orSeis = (DataSetSeismogram)orIt.next(); double orSeisDelt = ((QuantityImpl)distanceMap.get(orSeis)).getValue(); if(curSeisDelt < orSeisDelt){ orIt.previous(); orIt.add(curSeis); added = true; break; } double distDiff = Math.abs(orSeisDelt - curSeisDelt); if(distDiff != 0 && distDiff < minDistBetween){ minDistBetween = distDiff; } } if(!added){ orderedSeis.add(curSeis); } } if(minDistBetween == Double.POSITIVE_INFINITY){//if minDistBetween hasn't changed, there is only one seis LayoutData[] data = { new LayoutData(seis[0], 0.0, 1.0)}; return new LayoutEvent(data, LayoutEvent.ONE_DEGREE); } double offset = minDistBetween * scale/2; double startDist = ((QuantityImpl)distanceMap.get(orderedSeis.get(0))).getValue() - offset; double endDist = ((QuantityImpl)distanceMap.get(orderedSeis.get(orderedSeis.size() - 1))).getValue() + offset; double totalDistance = endDist - startDist; double percentageOffset = offset/totalDistance; LayoutData[] data = new LayoutData[seis.length]; for (int i = 0; i < data.length; i++){ DataSetSeismogram cur = (DataSetSeismogram)orderedSeis.get(i); double curDist = ((QuantityImpl)distanceMap.get(cur)).getValue(); double centerPercentage = (curDist - startDist)/totalDistance; data[i] = new LayoutData(cur, centerPercentage - percentageOffset, centerPercentage + percentageOffset); } UnitRangeImpl range = new UnitRangeImpl(startDist, endDist, UnitImpl.DEGREE); return new LayoutEvent(data, range); } return LayoutEvent.EMPTY_EVENT; }

while(orIt.hasNext()){

while(orIt.hasNext() && !added){

public synchronized LayoutEvent generateLayoutEvent(){ DataSetSeismogram[] seis = getSeismograms(); if(seis.length > 0){ List orderedSeis = new ArrayList(seis.length); orderedSeis.add(0, seis[0]); double minDistBetween = Double.POSITIVE_INFINITY; for (int i = 1; i < seis.length; i++){ DataSetSeismogram curSeis = seis[i]; double curSeisDelt = ((QuantityImpl)distanceMap.get(curSeis)).getValue(); ListIterator orIt = orderedSeis.listIterator(); boolean added = false; while(orIt.hasNext()){ DataSetSeismogram orSeis = (DataSetSeismogram)orIt.next(); double orSeisDelt = ((QuantityImpl)distanceMap.get(orSeis)).getValue(); if(curSeisDelt < orSeisDelt){ orIt.previous(); orIt.add(curSeis); added = true; break; } double distDiff = Math.abs(orSeisDelt - curSeisDelt); if(distDiff != 0 && distDiff < minDistBetween){ minDistBetween = distDiff; } } if(!added){ orderedSeis.add(curSeis); } } if(minDistBetween == Double.POSITIVE_INFINITY){//if minDistBetween hasn't changed, there is only one seis LayoutData[] data = { new LayoutData(seis[0], 0.0, 1.0)}; return new LayoutEvent(data, LayoutEvent.ONE_DEGREE); } double offset = minDistBetween * scale/2; double startDist = ((QuantityImpl)distanceMap.get(orderedSeis.get(0))).getValue() - offset; double endDist = ((QuantityImpl)distanceMap.get(orderedSeis.get(orderedSeis.size() - 1))).getValue() + offset; double totalDistance = endDist - startDist; double percentageOffset = offset/totalDistance; LayoutData[] data = new LayoutData[seis.length]; for (int i = 0; i < data.length; i++){ DataSetSeismogram cur = (DataSetSeismogram)orderedSeis.get(i); double curDist = ((QuantityImpl)distanceMap.get(cur)).getValue(); double centerPercentage = (curDist - startDist)/totalDistance; data[i] = new LayoutData(cur, centerPercentage - percentageOffset, centerPercentage + percentageOffset); } UnitRangeImpl range = new UnitRangeImpl(startDist, endDist, UnitImpl.DEGREE); return new LayoutEvent(data, range); } return LayoutEvent.EMPTY_EVENT; }

if(curSeisDelt < orSeisDelt){

double distDiff = orSeisDelt - curSeisDelt; if(distDiff > 0){

public synchronized LayoutEvent generateLayoutEvent(){ DataSetSeismogram[] seis = getSeismograms(); if(seis.length > 0){ List orderedSeis = new ArrayList(seis.length); orderedSeis.add(0, seis[0]); double minDistBetween = Double.POSITIVE_INFINITY; for (int i = 1; i < seis.length; i++){ DataSetSeismogram curSeis = seis[i]; double curSeisDelt = ((QuantityImpl)distanceMap.get(curSeis)).getValue(); ListIterator orIt = orderedSeis.listIterator(); boolean added = false; while(orIt.hasNext()){ DataSetSeismogram orSeis = (DataSetSeismogram)orIt.next(); double orSeisDelt = ((QuantityImpl)distanceMap.get(orSeis)).getValue(); if(curSeisDelt < orSeisDelt){ orIt.previous(); orIt.add(curSeis); added = true; break; } double distDiff = Math.abs(orSeisDelt - curSeisDelt); if(distDiff != 0 && distDiff < minDistBetween){ minDistBetween = distDiff; } } if(!added){ orderedSeis.add(curSeis); } } if(minDistBetween == Double.POSITIVE_INFINITY){//if minDistBetween hasn't changed, there is only one seis LayoutData[] data = { new LayoutData(seis[0], 0.0, 1.0)}; return new LayoutEvent(data, LayoutEvent.ONE_DEGREE); } double offset = minDistBetween * scale/2; double startDist = ((QuantityImpl)distanceMap.get(orderedSeis.get(0))).getValue() - offset; double endDist = ((QuantityImpl)distanceMap.get(orderedSeis.get(orderedSeis.size() - 1))).getValue() + offset; double totalDistance = endDist - startDist; double percentageOffset = offset/totalDistance; LayoutData[] data = new LayoutData[seis.length]; for (int i = 0; i < data.length; i++){ DataSetSeismogram cur = (DataSetSeismogram)orderedSeis.get(i); double curDist = ((QuantityImpl)distanceMap.get(cur)).getValue(); double centerPercentage = (curDist - startDist)/totalDistance; data[i] = new LayoutData(cur, centerPercentage - percentageOffset, centerPercentage + percentageOffset); } UnitRangeImpl range = new UnitRangeImpl(startDist, endDist, UnitImpl.DEGREE); return new LayoutEvent(data, range); } return LayoutEvent.EMPTY_EVENT; }

break;

public synchronized LayoutEvent generateLayoutEvent(){ DataSetSeismogram[] seis = getSeismograms(); if(seis.length > 0){ List orderedSeis = new ArrayList(seis.length); orderedSeis.add(0, seis[0]); double minDistBetween = Double.POSITIVE_INFINITY; for (int i = 1; i < seis.length; i++){ DataSetSeismogram curSeis = seis[i]; double curSeisDelt = ((QuantityImpl)distanceMap.get(curSeis)).getValue(); ListIterator orIt = orderedSeis.listIterator(); boolean added = false; while(orIt.hasNext()){ DataSetSeismogram orSeis = (DataSetSeismogram)orIt.next(); double orSeisDelt = ((QuantityImpl)distanceMap.get(orSeis)).getValue(); if(curSeisDelt < orSeisDelt){ orIt.previous(); orIt.add(curSeis); added = true; break; } double distDiff = Math.abs(orSeisDelt - curSeisDelt); if(distDiff != 0 && distDiff < minDistBetween){ minDistBetween = distDiff; } } if(!added){ orderedSeis.add(curSeis); } } if(minDistBetween == Double.POSITIVE_INFINITY){//if minDistBetween hasn't changed, there is only one seis LayoutData[] data = { new LayoutData(seis[0], 0.0, 1.0)}; return new LayoutEvent(data, LayoutEvent.ONE_DEGREE); } double offset = minDistBetween * scale/2; double startDist = ((QuantityImpl)distanceMap.get(orderedSeis.get(0))).getValue() - offset; double endDist = ((QuantityImpl)distanceMap.get(orderedSeis.get(orderedSeis.size() - 1))).getValue() + offset; double totalDistance = endDist - startDist; double percentageOffset = offset/totalDistance; LayoutData[] data = new LayoutData[seis.length]; for (int i = 0; i < data.length; i++){ DataSetSeismogram cur = (DataSetSeismogram)orderedSeis.get(i); double curDist = ((QuantityImpl)distanceMap.get(cur)).getValue(); double centerPercentage = (curDist - startDist)/totalDistance; data[i] = new LayoutData(cur, centerPercentage - percentageOffset, centerPercentage + percentageOffset); } UnitRangeImpl range = new UnitRangeImpl(startDist, endDist, UnitImpl.DEGREE); return new LayoutEvent(data, range); } return LayoutEvent.EMPTY_EVENT; }

double distDiff = Math.abs(orSeisDelt - curSeisDelt); if(distDiff != 0 && distDiff < minDistBetween){ minDistBetween = distDiff;

if(distDiff != 0 && Math.abs(distDiff) < minDistBetween){ minDistBetween = Math.abs(distDiff);

public synchronized LayoutEvent generateLayoutEvent(){ DataSetSeismogram[] seis = getSeismograms(); if(seis.length > 0){ List orderedSeis = new ArrayList(seis.length); orderedSeis.add(0, seis[0]); double minDistBetween = Double.POSITIVE_INFINITY; for (int i = 1; i < seis.length; i++){ DataSetSeismogram curSeis = seis[i]; double curSeisDelt = ((QuantityImpl)distanceMap.get(curSeis)).getValue(); ListIterator orIt = orderedSeis.listIterator(); boolean added = false; while(orIt.hasNext()){ DataSetSeismogram orSeis = (DataSetSeismogram)orIt.next(); double orSeisDelt = ((QuantityImpl)distanceMap.get(orSeis)).getValue(); if(curSeisDelt < orSeisDelt){ orIt.previous(); orIt.add(curSeis); added = true; break; } double distDiff = Math.abs(orSeisDelt - curSeisDelt); if(distDiff != 0 && distDiff < minDistBetween){ minDistBetween = distDiff; } } if(!added){ orderedSeis.add(curSeis); } } if(minDistBetween == Double.POSITIVE_INFINITY){//if minDistBetween hasn't changed, there is only one seis LayoutData[] data = { new LayoutData(seis[0], 0.0, 1.0)}; return new LayoutEvent(data, LayoutEvent.ONE_DEGREE); } double offset = minDistBetween * scale/2; double startDist = ((QuantityImpl)distanceMap.get(orderedSeis.get(0))).getValue() - offset; double endDist = ((QuantityImpl)distanceMap.get(orderedSeis.get(orderedSeis.size() - 1))).getValue() + offset; double totalDistance = endDist - startDist; double percentageOffset = offset/totalDistance; LayoutData[] data = new LayoutData[seis.length]; for (int i = 0; i < data.length; i++){ DataSetSeismogram cur = (DataSetSeismogram)orderedSeis.get(i); double curDist = ((QuantityImpl)distanceMap.get(cur)).getValue(); double centerPercentage = (curDist - startDist)/totalDistance; data[i] = new LayoutData(cur, centerPercentage - percentageOffset, centerPercentage + percentageOffset); } UnitRangeImpl range = new UnitRangeImpl(startDist, endDist, UnitImpl.DEGREE); return new LayoutEvent(data, range); } return LayoutEvent.EMPTY_EVENT; }

if(minDistBetween == Double.POSITIVE_INFINITY){ LayoutData[] data = { new LayoutData(seis[0], 0.0, 1.0)};

if(minDistBetween == Double.POSITIVE_INFINITY){ LayoutData[] data = new LayoutData[seis.length]; for (int i = 0; i < data.length; i++){ data[i] = new LayoutData(seis[i], 0.0, 1.0); }

public synchronized LayoutEvent generateLayoutEvent(){ DataSetSeismogram[] seis = getSeismograms(); if(seis.length > 0){ List orderedSeis = new ArrayList(seis.length); orderedSeis.add(0, seis[0]); double minDistBetween = Double.POSITIVE_INFINITY; for (int i = 1; i < seis.length; i++){ DataSetSeismogram curSeis = seis[i]; double curSeisDelt = ((QuantityImpl)distanceMap.get(curSeis)).getValue(); ListIterator orIt = orderedSeis.listIterator(); boolean added = false; while(orIt.hasNext()){ DataSetSeismogram orSeis = (DataSetSeismogram)orIt.next(); double orSeisDelt = ((QuantityImpl)distanceMap.get(orSeis)).getValue(); if(curSeisDelt < orSeisDelt){ orIt.previous(); orIt.add(curSeis); added = true; break; } double distDiff = Math.abs(orSeisDelt - curSeisDelt); if(distDiff != 0 && distDiff < minDistBetween){ minDistBetween = distDiff; } } if(!added){ orderedSeis.add(curSeis); } } if(minDistBetween == Double.POSITIVE_INFINITY){//if minDistBetween hasn't changed, there is only one seis LayoutData[] data = { new LayoutData(seis[0], 0.0, 1.0)}; return new LayoutEvent(data, LayoutEvent.ONE_DEGREE); } double offset = minDistBetween * scale/2; double startDist = ((QuantityImpl)distanceMap.get(orderedSeis.get(0))).getValue() - offset; double endDist = ((QuantityImpl)distanceMap.get(orderedSeis.get(orderedSeis.size() - 1))).getValue() + offset; double totalDistance = endDist - startDist; double percentageOffset = offset/totalDistance; LayoutData[] data = new LayoutData[seis.length]; for (int i = 0; i < data.length; i++){ DataSetSeismogram cur = (DataSetSeismogram)orderedSeis.get(i); double curDist = ((QuantityImpl)distanceMap.get(cur)).getValue(); double centerPercentage = (curDist - startDist)/totalDistance; data[i] = new LayoutData(cur, centerPercentage - percentageOffset, centerPercentage + percentageOffset); } UnitRangeImpl range = new UnitRangeImpl(startDist, endDist, UnitImpl.DEGREE); return new LayoutEvent(data, range); } return LayoutEvent.EMPTY_EVENT; }

public BasicSeismogramDisplay(DataSetSeismogram[] seismos, String[] names, VerticalSeismogramDisplay parent)throws IllegalArgumentException{ this(seismos, new BasicTimeConfig(seismos), new RMeanAmpConfig(seismos), names, parent);

public BasicSeismogramDisplay(DataSetSeismogram[] seismos, VerticalSeismogramDisplay parent)throws IllegalArgumentException{ this(seismos, new BasicTimeConfig(seismos), new RMeanAmpConfig(seismos), parent);

public BasicSeismogramDisplay(DataSetSeismogram[] seismos, String[] names, VerticalSeismogramDisplay parent)throws IllegalArgumentException{ this(seismos, new BasicTimeConfig(seismos), new RMeanAmpConfig(seismos), names, parent); }

public void add(DataSetSeismogram[] seismos, String[] names){

public void add(DataSetSeismogram[] seismos){

public void add(DataSetSeismogram[] seismos, String[] names){ registrar.add(seismos); for(int i = 0; i < seismos.length; i++){ if(seismos[i] != null){ seismograms.add(seismos[i]); SeismogramShape newPlotter; if (autoColor) { newPlotter = new SeismogramShape(seismos[i], seisColors[seisCount%seisColors.length], names[i]); }else { newPlotter = new SeismogramShape(seismos[i], Color.blue, names[i]); } // end of else if(parent != null){ newPlotter.setVisibility(parent.getOriginalVisibility()); } plotters.add(seisCount, newPlotter); seisCount++; } } Iterator e = globalFilters.iterator(); while(e.hasNext()){ applyFilter((ColoredFilter)e.next()); } seismogramArray = null; }

newPlotter = new SeismogramShape(seismos[i], seisColors[seisCount%seisColors.length], names[i]);

newPlotter = new SeismogramShape(seismos[i], seisColors[seisCount%seisColors.length]);

public void add(DataSetSeismogram[] seismos, String[] names){ registrar.add(seismos); for(int i = 0; i < seismos.length; i++){ if(seismos[i] != null){ seismograms.add(seismos[i]); SeismogramShape newPlotter; if (autoColor) { newPlotter = new SeismogramShape(seismos[i], seisColors[seisCount%seisColors.length], names[i]); }else { newPlotter = new SeismogramShape(seismos[i], Color.blue, names[i]); } // end of else if(parent != null){ newPlotter.setVisibility(parent.getOriginalVisibility()); } plotters.add(seisCount, newPlotter); seisCount++; } } Iterator e = globalFilters.iterator(); while(e.hasNext()){ applyFilter((ColoredFilter)e.next()); } seismogramArray = null; }

newPlotter = new SeismogramShape(seismos[i], Color.blue, names[i]);

newPlotter = new SeismogramShape(seismos[i], Color.blue);

public void add(DataSetSeismogram[] seismos, String[] names){ registrar.add(seismos); for(int i = 0; i < seismos.length; i++){ if(seismos[i] != null){ seismograms.add(seismos[i]); SeismogramShape newPlotter; if (autoColor) { newPlotter = new SeismogramShape(seismos[i], seisColors[seisCount%seisColors.length], names[i]); }else { newPlotter = new SeismogramShape(seismos[i], Color.blue, names[i]); } // end of else if(parent != null){ newPlotter.setVisibility(parent.getOriginalVisibility()); } plotters.add(seisCount, newPlotter); seisCount++; } } Iterator e = globalFilters.iterator(); while(e.hasNext()){ applyFilter((ColoredFilter)e.next()); } seismogramArray = null; }

this.arrivals = arrivals;

public void addFlags(Arrival[] arrivals) { try{ MicroSecondDate originTime = new MicroSecondDate(((XMLDataSet)((DataSetSeismogram)seismograms.getFirst()).getDataSet()). getEvent().get_preferred_origin().origin_time); for(int i = 0; i < arrivals.length; i++){ FlagPlotter current = new FlagPlotter(new MicroSecondDate((long)(arrivals[i].getTime() * 1000000) + originTime.getMicroSecondTime()), arrivals[i].getPhase().getName()); plotters.addLast(current); flagCount++; } }catch(Exception e){} repaint(); }

arrivals = null;

public void removeAllFlags(){ plotters.subList(filterCount + seisCount, plotters.size()).clear(); flagCount = 0; repaint(); }