luminous.java

Java 范例实战 光盘使用说明 ========================== 本光盘的文件结构如下所示： =====================================

        {
        	
            ntext = 0;
            text = getParameter("TEXT" + ntext,"No TEXT0");
            
        }
        ntext++;
        text = parsetext(text);
        step = -maxstep;
        tgg.setColor(new Color(0));
        tgg.fillRect(0, 0, w_width, w_height);
        tgg.setFont(font);
        int i = fm.stringWidth(text);
        int j = fm.getMaxAscent();
        tgg.setColor(new Color(0xffffff));
        tgg.drawString(text, w_width - i >> 1, w_height + j >> 1);
        pgtext = new PixelGrabber(textimage, 0, 0, 
                     w_width, w_height, textpixels, 0, w_width);
        try
        {
        	
            pgtext.grabPixels();
            
        }
        catch(InterruptedException _ex) { }
        Vector vector = new Vector();
        for(int k = 0; k < w_width; k++)
        {
            
            for(int l = 0; l < w_height; l++)
                if((textpixels[l * w_width + k] & 0xffffff) != 0)
                {
                	
                    Point point = new Point(k, l);
                    vector.addElement(point);
                    
                }

        }

        pixx = new int[vector.size()];
        pixy = new int[vector.size()];
        for(int l = 0; l < vector.size(); l++)
        {
        	
            pixx[l] = ((Point)vector.elementAt(l)).x;
            pixy[l] = ((Point)vector.elementAt(l)).y;
            
        }

    }

    public void draw()
    {
    	
        if(mt != null && (mt.statusID(0, true) & 0x8) != 0 && !done)
        {
        
            for(int i = 0; 
                i < w_width; 
                i += backimage.getWidth(this))
            {
        
                for(int k = 0; 
                    k < w_height; 
                    k += backimage.getHeight(this))
                    backig.drawImage(backimage, i, k, this);

            }

            done = true;
            pgbg = new PixelGrabber(backimage, 0, 0, 
                       w_width, w_height, bgpixels, 0, w_width);
            try
            {
            	
                pgbg.grabPixels();
                
            }
            catch(InterruptedException _ex)
            {
                
                done = false;
                
            }
            
        }
        int nRed = textcolor.getRGB() | 0xff000000;
        int l = bgcolor.getRGB() | 0xff000000;
        int nGreen = l;
        int nLength = pixx.length;
        double d = (double)Math.abs(step) / (double)maxstep;
        d = 20D * d + d * d * d * 100D;
        int nBlue = (int)((Math.abs(step) / (double)maxstep)*256D);
        int ai[] = new int[w_width * w_height];
        if(step < 0)
            mode = frommode;
        else
            mode = tomode;
        if(mode == 0)
        {
        	
            for(int j6 = 0; j6 < nLength; j6++)
            {
                
                int i4 = pixx[j6];
                int i5 = pixy[j6];
                int k2 = i4 + (int)((Math.random() - 0.5D) * d);
                int j3 = i5 + (int)((Math.random() - 0.5D) * d);
                if(k2 > 0&&k2 < w_width && j3 > 0&&j3 < w_height)
                {
                	
                    if(done)
                        nGreen = bgpixels[j3 * w_width + k2];
                    int j1 = fade(nRed, nGreen, nBlue);
                    ai[j3 * w_width + k2] = j1;
                    
                }
                
            }

        }
        if(mode == 3)
        {
            
            double d1 = (Math.PI * (double)step) / 
                        (double)(maxstep << 1);
            int l6 = (int)(256D * Math.sin(d1));
            int j7 = (int)(256D * Math.cos(d1));
            int l7 = w_width >> 1;
            int j8 = w_height >> 1;
            for(int l8 = 0; l8 < nLength; l8++)
            {
            
                int j4 = pixx[l8];
                int j5 = pixy[l8];
                int k3 = ((j5 - j8) * j7 >> 8) + j8;
                int l2 = j4 + (((j4 - l7) * (j5 - j8) * l6) /
                         w_height >> 8);
                if(l2 > 0&&l2 < w_width&&k3 > 0&&k3 < w_height)
                {
            
                    if(done)
                        nGreen = bgpixels[k3 * w_width + l2];
                    int k1 = fade(nRed, nGreen, nBlue);
                    ai[k3 * w_width + l2] = k1;
                    
                }
                
            }

        }
        if(mode == 2)
        {
            
            double d2 = (Math.PI * (double)step) / 
                        (double)(maxstep << 1);
            int i7 = (int)(256D * Math.cos(d2));
            int k7 = (int)(256D * Math.sin(d2));
            int i8 = w_width >> 1;
            int k8 = w_height >> 1;
            for(int i9 = 0; i9 < nLength; i9++)
            {
                
                int k4 = pixx[i9];
                int k5 = pixy[i9];
                int ai_x = ((k4 - i8) * i7 >> 8) + i8;
                int ai_y = k5 + (((k5 - k8) * (k4 - i8) * k7) /
                           w_width >> 8);
                if(ai_x>0&&ai_x<w_width&&ai_y>0&&ai_y<w_height)
                {
                	
                    if(done)
                        nGreen = bgpixels[ai_y * w_width + ai_x];
                    int pix_color = fade(nRed, nGreen, nBlue);
                    ai[ai_y * w_width + ai_x] = pix_color;
                    
                }
                
            }

        }
        if(mode == 1)
        {
            
            for(int k6 = 0; k6 < nLength; k6++)
            {
            
                int l4 = pixx[k6];
                int l5 = pixy[k6];
                if(done)
                    nGreen = bgpixels[l5 * w_width + l4];
                int i2 = fade(nRed, nGreen, nBlue);
                if(l4>0 && l4<w_width && l5>0 && l5<w_height)
                    ai[l5 * w_width + l4] = i2;
                    
            }

        }
        tim = createImage(new MemoryImageSource(w_width, 
                          w_height, ai, 0, w_width));
        repaint();
        if(step >= maxstep)
            nextText();
            
    }

    public int fade(int i, int j, int k)
    {
        
        int cRed= i & 0xff0000;
        int cGreen = i & 0xff00;
        int cBlue = i & 0xff;
        return cRed+ (((j & 0xff0000) - cRed) * k >> 8) & 0xff0000 |
               cGreen + (((j & 0xff00) - cGreen) * k >> 8) & 0xff00|
               cBlue + (((j & 0xff) - cBlue) * k >> 8) & 0xff | 
               0xff000000;
        
    }

    public void update(Graphics g)
    {
        
        if(done)
        {
        
            bgg.drawImage(backi, 0, 0, this);
        
        }
        else
        {
        
            bgg.setColor(bgcolor);
            bgg.fillRect(0, 0, w_width, w_height);
        
        }
        if(tim != null)
            bgg.drawImage(tim, 0, 0, this);
        g.drawImage(bgi, 0, 0, this);
        
    }

    public void paint(Graphics g)
    {
        
        update(g);
        
    }

    public void start()
    {
        
        if(mythread == null)
            mythread = new Thread(this);
        mythread.start();
        
    }

    public void stop()
    {
        
        mythread = null;
    
    }

    public void run()
    {
    
        Thread.currentThread().setPriority(1);
        while(Thread.currentThread() == mythread) 
        {
    
            step++;
            draw();
            try
            {
    
                Thread.sleep(delay);
    
            }
            catch(InterruptedException _ex)
            {
    
                return;
    
            }
    
        }
    
    }
}