iconholder.java

java写的qq代码实现qq的部分功能

			extractLeafRgb();
        	// 拷贝N/A图标的RGB数据到原始图像的调色板中
        	int delta = facePalette.colors.length - leafRGB.length;
        	System.arraycopy(leafRGB, 0, facePalette.colors, delta, leafRGB.length);

        	// 替换
    	   	for(int x = startX, leafX = 0; x < faceBound.width; x++, leafX++) {
        		for(int y = startY, leafY = 0; y < faceBound.height; y++, leafY++) { 
        		    if(leafPixel[leafX][leafY] != 0)
        		        faceData.setPixel(x, y, leafPixel[leafX][leafY] + delta);
        		}
        	}  
    	   	
        	faceHidden = new Image(dispay, faceData);
        	face.dispose();
        	return faceHidden;
    	}
    }

    /**
     * <pre>
     * 得到头像
     * </pre>
     * 
     * @param headId
     * 			头像ID
     * @return 
     * 			头像Image对象
     */
    public Image getHead(int headId) {
        // 检查头像范围，如果超出了，调整之
        if(headId < 0) headId = 0;
        if(headId >= QQ_2004_FACE_MAX_INDEX) 
            headId = QQ_2004_FACE_MAX_INDEX - 3;
        
        // 计算头像的主号码和次号码，对于2004头像来说，次号码无用
    	int major = headId / 3 + 1;
    	int minor = headId % 3 + 1;
    	// 获得头像
        String face = HEAD_PATH_PREFIX + major + ".gif";
        if(minor == 1)
            return getImage(face);
        else if(minor == 2){
            // 检查cache中是否有不在线头像
            String faceOffline = face + ".offline";
            Image image = registry.get(faceOffline);
            if(image == null) {
                // 得到在线图像的灰度图像来用作不在线头像
                image = getImage(face);
                image = new Image(Display.getCurrent(), image, SWT.IMAGE_GRAY);
                registry.put(faceOffline, image);
            }
            return image;
        } else {
            // 检查cache中是否有离开头像
            String faceAway = face + ".away";
            Image image = registry.get(faceAway);
            if(image == null) {
                // 构建2004风格离开头像
            	image = create2004AwayImage(face);
                registry.put(faceAway, image);
            }
            return image;
        }
    }
    
    private RGB[] extractRgb(Image leaf, int[][] pixel) {
    	ImageData data = leaf.getImageData();
    	Rectangle bound = leaf.getBounds();
    	PaletteData palette = data.palette;
    	RGB[] ret;
    	
		// 构造N/A图标的indexed映象
    	if(palette.isDirect) {
			int index = 0;
			Map rgbMap = new HashMap();
			List temp = new ArrayList();
			for(int x = 0; x < bound.width; x++) {
				for(int y = 0; y < bound.height; y++) {
					RGB rgb = palette.getRGB(data.getPixel(x, y));
					if(rgbMap.containsKey(rgb)) {
						/* 已经有了这种颜色 */
						pixel[x][y] = ((Integer)rgbMap.get(rgb)).intValue();
					} else {
						/* 添加这种颜色 */
						rgbMap.put(rgb, new Integer(index));
						temp.add(rgb);
						pixel[x][y] = index++;
					}
				}
			}
			ret = (RGB[])temp.toArray(new RGB[0]);    		
    	} else {
    		ret = palette.getRGBs();
    		pixel = new int[bound.width][bound.height];
			for(int x = 0; x < bound.width; x++)
				for(int y = 0; y < bound.height; y++) 
				    pixel[x][y] = data.getPixel(x, y);
    	}
    	return ret;
    }
    
    /**
     * 提出叶子图标的RGB数组
     * 
     * @param leaf
     */
    private void extractLeafRgb() {
    	if(leafRGB != null)
    		return;
    	
		Image leaf = getImage(icoLeaf);
    	Rectangle leafBound = leaf.getBounds();
		leafPixel = new int[leafBound.width][leafBound.height];
		leafRGB = extractRgb(leaf, leafPixel);
    }
    
    /**
     * 提出N/A图标的RGB数组
     */
    private void extractNaRgb() {
    	if(naRGB != null)
    		return;
    	
		Image na = getImage(icoNA);
    	Rectangle naBound = na.getBounds();
		naPixel = new int[naBound.width][naBound.height];
		naRGB = extractRgb(na, naPixel);
    }
    
    /**
     * 组合一个2004的离开头像
     * 
     * @param path
     * 		头像路径
     * @return
     * 		Image对象
     */
    private Image create2004AwayImage(String path) {
    	// 载入原始图像
        Display dispay = Display.getCurrent();
        Image face = new Image(dispay, getClass().getResourceAsStream(path));
        Image faceAway = null;
        // 载入离开标志
        Image na = getImage(icoNA);
        
        // 得到图像数据和调色板和图像尺寸
        ImageData faceData = face.getImageData();
        ImageData naData = na.getImageData();
        PaletteData facePalette = faceData.palette;
        PaletteData naPalette = naData.palette;
    	Rectangle faceBound = face.getBounds();
    	Rectangle naBound = na.getBounds();
    	// 得到替换的起始坐标
    	int startX = faceBound.width - naBound.width;
    	int startY = faceBound.height - naBound.height;
    	if(facePalette.isDirect == naPalette.isDirect) {
    		if(facePalette.isDirect) {
            	// 替换
        	   	for(int x = startX, naX = 0; x < faceBound.width; x++, naX++) {
            		for(int y = startY, naY = 0; y < faceBound.height; y++, naY++) {
            			faceData.setPixel(x, y, naData.getPixel(naX, naY));
            		}
            	}  
    		} else {
    			// 提取N/A图标数据
    			extractNaRgb();
            	// 拷贝N/A图标的RGB数据到原始图像的调色板中
            	int delta = facePalette.colors.length - naRGB.length;
            	System.arraycopy(naRGB, 0, facePalette.colors, delta, naRGB.length);

            	// 替换
        	   	for(int x = startX, naX = 0; x < faceBound.width; x++, naX++) {
            		for(int y = startY, naY = 0; y < faceBound.height; y++, naY++) {
            			faceData.setPixel(x, y, naPixel[naX][naY] + delta);
            		}
            	}  
    		}
        	
        	faceAway = new Image(dispay, faceData);
        	face.dispose();
        	return faceAway;
    	} else if(facePalette.isDirect) {
        	simpleAreaCopy(face, na);      	
	        return face;
    	} else {
			// 提取N/A图标数据
			extractNaRgb();
        	// 拷贝N/A图标的RGB数据到原始图像的调色板中
        	int delta = facePalette.colors.length - naRGB.length;
        	System.arraycopy(naRGB, 0, facePalette.colors, delta, naRGB.length);

        	// 替换
    	   	for(int x = startX, naX = 0; x < faceBound.width; x++, naX++) {
        		for(int y = startY, naY = 0; y < faceBound.height; y++, naY++) {
        			faceData.setPixel(x, y, naPixel[naX][naY] + delta);
        		}
        	}  
    	   	
        	faceAway = new Image(dispay, faceData);
        	face.dispose();
        	return faceAway;
    	}
    }
    
    /**
     * 把from的内容copy到to的右下角
     * 
     * @param to
     * @param from
     */
    private void simpleAreaCopy(Image to, Image from) {
    	Rectangle toBound = to.getBounds();
    	Rectangle fromBound = from.getBounds();
    	int startX = toBound.width - fromBound.width;
    	int startY = toBound.height - fromBound.height;
    	
        GC gc = new GC(to);
        gc.drawImage(from, startX, startY);
        gc.dispose();	  
    }
    
    /**
     * 得到头像小图标，没办法，table控件中的图像在linux下，居然不会自动缩小，只好再搞一套
     * 小图标
     * 
     * @param faceId 
     * 			头像Id
     * @return 头像
     */
    public Image getSmallHead(int faceId) {
        // 检查头像范围，如果超出了，调整之
        if(faceId < 0) faceId = 0;
        if(faceId >= QQ_2004_FACE_MAX_INDEX) faceId = QQ_2004_FACE_MAX_INDEX - 3;
        
    	int major = faceId / 3 + 1;
    	int minor = faceId % 3 + 1;
    	String face = SMALL_HEAD_PATH_PREFIX + major + "-" + minor + ".gif";
    	return getImage(face);
    }
    
    /**
     * 得到群组头像图标，如果索引不对则返回null
     * @param faceId 群组头像，目前提供了18张
     * @return 群组头像图标，如果索引不对返回null
     */
    public Image getClusterHead(int faceId) {
    	if(faceId < 1 || faceId > 6) return null;
    	String face = CLUSTER_HEAD_PATH_PREFIX + faceId + ".gif";
    	return getImage(face);
    }
    
    /**
     * 得到群组头像小图标，如果索引不对则返回null，没办法，linux下面不会自动缩小
     * @param faceId
     * @return
     */
    public Image getSmallClusterHead(int faceId) {
    	if(faceId < 1 || faceId > 6) return null;
    	String face = CLUSTER_HEAD_PATH_PREFIX + faceId + "-1.gif";
    	return getImage(face);
    }
    
    /**
     * 通过表情的顺序号得到图像，顺序号是从0开始的整数，和code不同，code不是顺序的
     * 
     * @param seq
     * 		顺序号
     * @return
     * 		Image
     */
    public Image getFaceBySequence(int seq) {
        if(seq < 0 || seq >= smileyCodeSeq.length)
            return null;
    	String smiley = FACE_PATH_PREFIX + seq + ".gif";
    	return getImage(smiley);
    }
    
    /**
     * 根据表情代码得到表情的路径
     * 
     * @param code
     * 		表情代码
     * @return
     * 		路径
     */
    public String getFacePathByCode(int code) {
        return FACE_PATH_PREFIX + getFaceSequence(code) + ".gif";
    }
    
    /**
     * 根据表情代码得到表情的图片
     * 
     * @param code
     * 		表情代码
     * @return
     * 		Image
     */
    public Image getFaceByCode(int code) {
        return getFaceBySequence(getFaceSequence(code));
    }

    /**
     * 从文件创建Image对象
     * 
     * @param path
     *            the relative path to the icon 
     */
    private Image createImageFromJar(String path) {
        return createImageFromStream(IconHolder.class.getResourceAsStream(path));
    }
    
    /**
     * 从一个外部文件中创建一个图片
     * 
     * @param path
     * @return
     */
    private Image createImageFromFile(String path) {
        try {
            return createImageFromStream(new FileInputStream(path));
        } catch (FileNotFoundException e) {
            return null;
        }
    }
    
    /**
     * 从一个输入流中创建一个图片
     * 
     * @param is
     * @return
     */
    private Image createImageFromStream(InputStream is) {
        try {
            if (is != null) {
                ImageData imageData = new ImageData(is);
                if (imageData != null) {
                    ImageData mask = imageData.getTransparencyMask();
                    return new Image(Display.getCurrent(), imageData, mask);
                }
            }
        } catch (Exception e) {
            log.error(e.getMessage());
        } finally {
            try {
                if(is != null)
                    is.close();
            } catch (IOException e1) {
            }
        }
        return null;
    }
    
    /**
     * 根据顺序号，得到表情代码
     * 
     * @param seq
     * 		顺序号
     * @return
     * 		表情代码，失败则返回-1
     */
    public int getFaceCode(int seq) {
        if(seq < 0 || seq >= smileySeqCode.length)
            return -1;
        return smileySeqCode[seq][1];
    }
    
    /**
     * 根据表情代码，得到顺序号
     * 
     * @param code
     * 		表情代码
     * @return
     * 		表情顺序号，失败返回1
     */
    public int getFaceSequence(int code) {
        code -= 65;
        if(code < 0 || code >= smileyCodeSeq.length)
            return -1;
        return smileyCodeSeq[code][1];
    }
    
    /**
     * @return
     * 		表情个数
     */
    public int getFaceCount() {
        if(smileySeqCode == null)
            return 0;
        return smileySeqCode.length;
    }
    
    /**
     * 根据md5得到自定义表情的路径
     * 
     * @param md5	
     * 		md5
     * @return
     * 		路径
     */
    public String getCustomFacePath(String filename) {
        if(filename == null)
            return null;
    	return LumaQQ.CUSTOM_FACE_DIR + filename;
    }
    
    /**
     * 得到表情微缩图文件名
     * 
     * @param md5
     * 		图片md5字符串
     * @return
     */
    public String getSmallCustomFacePathByMd5(String md5) {
        if(md5 == null)
            return null;
        return LumaQQ.CUSTOM_FACE_DIR + md5 + "fixed.bmp";
    }
    
    /**
     * 得到自定义表情的缩略图
     * 
     * @param md5
     * 		自定义表情的md5
     * @return
     * 		Image对象
     */
    public Image getSmallCustomFace(String md5) {
        if(md5 == null)
            return null;
        String path = LumaQQ.CUSTOM_FACE_DIR + md5 + "fixed.bmp";
    	Image ret = registry.get(path);
    	if(ret == null) {
    		ret = createImageFromFile(path);
    		if(ret != null)
    			registry.put(path, ret);
    		return ret;
    	} else
    		return ret;
    }
    
    /**
     * 根据md5得到接收到的表情Image对象
     * 
     * @param filename
     * 		图片文件名
     * @return
     * 		Image对象，如果失败返回null
     */
    public Image getReceivedCustomFace(String filename) {
        if(filename == null)
            return null;
        String path = getReceivedCustomFacePath(filename);
    	Image ret = registry.get(path);
    	if(ret == null) {
    		ret = createImageFromFile(path);
    		if(ret != null)
    			registry.put(path, ret);
    		return ret;
    	} else
    		return ret;
    }
    
    /**
     * 得到接收到的表情文件路径
     * 
     * @param filename
     * @return
     */
    public String getReceivedCustomFacePath(String filename) {
        if(filename == null)
            return null;
        return LumaQQ.CUSTOM_FACE_RECV_DIR + filename;
    }
}