mainshell.java

用java实现的

    public MainShell() {
		this.display = new Display();
		shell = new Shell(display, SWT.CLOSE | SWT.MIN | SWT.RESIZE);
		// 设置shell属性
		shell.setImage(icons.getResource(IconHolder.icoQQ));
		// 设置layout
		GridLayout layout = new GridLayout();
		layout.marginHeight = layout.marginWidth = layout.verticalSpacing = layout.horizontalSpacing = 0;
		layout.numColumns = 2;
		shell.setLayout(layout);
		// 添加事件监听器
		shell.addDisposeListener(this);
		shell.addShellListener(this);
		shell.addControlListener(this);
		display.addFilter(SWT.KeyDown, new Listener() {
			public void handleEvent(Event e) {
				if(e.keyCode == 'z' && (e.stateMask & SWT.CTRL) != 0 && (e.stateMask & SWT.ALT) != 0) {
					if(mq.hasNext()) {
						int source = mq.nextMessageSource();
						if(source == QQ.QQ_IM_FROM_SYS)
							openReceiveSystemMessageShell(mq.getSystemMessage());
						else {
							int sender = mq.nextSender();
							openMessageShell(sender);								
						}
					} else {
						statusMenu.setVisible(false);
						shell.setLocation(loc);
						shell.setMinimized(false);
						shell.setVisible(true);									
					}
				}
			}			
		});
		
		// 初始化变量
		loginFrames = new Image[] {
			icons.getResource(IconHolder.icoOffline),
			icons.getResource(IconHolder.icoAway),
			icons.getResource(IconHolder.icoHidden),
			icons.getResource(IconHolder.icoOnline)
		};
		processor = new QQEventProcessor(this);
		qqNumMatcher = new QQNumberMatcher();
		blacklistMatcher = new BlacklistMatcher();
		strangerMatcher = new StrangerMatcher();
		friendlyMatcher = new FriendlyMatcher();
		clusterMatcher = new ClusterMatcher();
		clusterIdMatcher = new ClusterIdMatcher();
		mq = MessageQueue.getInstance();
		blinkRunnable = new Blink();
		rmsMap = new Hashtable();
		smsMap = new Hashtable();
		uisMap = new Hashtable();
		cisMap = new Hashtable();
		scmsMap = new Hashtable();
		deleteToMap = new Hashtable();
		itemMouseListener = new ItemMouseListener(this);
		itemMouseTrackListener = new ItemMouseTrackListener(this);
		groupMouseListener = new GroupMouseListener(this);
		currentOnlineNumber = LumaQQ.getResourceString("search.current.online.unknown");
		blsll = new BlackListShutterLabelListener();
		fsll = new FriendShutterLabelListener();
		soundDaemon = new SoundDaemon();
		currentOnlines = new ArrayList();
		addTos = new Hashtable();
		messageTipShell = new MessageTipShell(this);
		working = false;
		// 初始化组件
		initLayout();
		// 初始化菜单
		initMenu();
    }  

	/**
	 * 初始化快捷回复消息
	 */
	private void initReplies() {
		// 检查快捷回复信息文件，如果没有则创建一个，如果创建失败则退出
		File replyFile = new File(LumaQQ.REPLIES);
		if(!checkReplyFile(replyFile)) {
			return;
		}
		// 读入回复信息文件
		try {
			Replies r = RepliesUnmarshaller.unmarshal(replyFile);
			replies.setRepliesModel(r);
			replies.setFileName(replyFile.getAbsolutePath());
		} catch (IOException e) {
			log.error("无法读取回复信息文件，自动回复和快捷回复功能将受到影响");
			return;
		}
		renewAawyMenu();
	}
	
	/**
	 * 初始化代理列表
	 */
	private void initProxies() {
		// 检查代理列表文件，如果没有则创建一个，如果创建失败则退出
		File proxyFile = new File(LumaQQ.PROXIES);
		if(!checkProxyFile(proxyFile)) {
			return;
		}
		// 读入代理列表文件
		try {
		    Proxies p = ProxiesUnmarshaller.unmarshal(proxyFile);
		    proxies.setProxiesModel(p);
		    proxies.setFileName(proxyFile.getAbsolutePath());
		} catch(IOException e) {
		    log.error("无法读取代理列表文件");
		    return;
		}
	}

	/**
	 * 检查快捷回复文件的存在性，如果没有就创建一个缺省的，如果创建也失败则返回false
	 * @param file
	 * @return
	 */
	private boolean checkReplyFile(File file) {
        if(!file.exists()) {
            try {
            	ModelUtils.createDefaultReplyXmlFile(file);
	        } catch (IOException e) {
	            log.error("无法创建回复信息文件");
	            return false;
	        }
        } 
        return true;
	}

	/**
     * 检查分组信息文件的存在性，如果不存在就创建一个，如果创建也失败则返回false
     * @param file
     * @return
     */
    private boolean checkGroupFile(File file) {
        if(!file.exists()) {
            try {
            	ModelUtils.createDefaultGroupXmlFile(file);
	        } catch (IOException e) {
	            log.error("无法创建分组信息文件");
	            return false;
	        }
        } 
        return true;
    }
    
    /**
     * 检查系统设置文件是否存在，不存在就创建一个，如果创建也失败则返回false
     * @param file
     * @return
     */
    private boolean checkSysOptFile(File file) {
        if(!file.exists()) {
            try {
            	ModelUtils.createDefaultSysOptFile(file);
	        } catch (IOException e) {
	            log.error("无法创建系统设置文件");
	            return false;
	        }
        } 
        return true;
    }
    
    /**
     * 检查用户备注信息文件是否存在，不存在就创建一个，如果创建也失败则返回false
     * @param file
     * @return
     */
    private boolean checkRemarkFile(File file) {
        if(!file.exists()) {
            try {
            	ModelUtils.createDefaultRemarkXmlFile(file);
	        } catch (IOException e) {
	            log.error("无法创建备注信息文件");
	            return false;
	        }
        } 
        return true;
    }
    
    /**
     * 检查代理列表信息文件是否存在，不存在就创建一个，如果创建也失败则返回false
     * @param file
     * @return
     */
    private boolean checkProxyFile(File file) {
        if(!file.exists()) {
            try {
            	ModelUtils.createDefaultProxyXmlFile(file);
	        } catch (IOException e) {
	            log.error("无法创建代理列表文件");
	            return false;
	        }
        } 
        return true;
    }
    
    /**
	 * 初始化model，从groups.xml中读取组信息和好友信息，如果不存在这个文件
	 * 则创建一个
	 */
	private void initModel() {
		// 检查分组信息文件，如果没有则创建一个，如果创建失败则退出
		File groupFile = new File(LumaQQ.GROUPS);
		if(!checkGroupFile(groupFile)) {
			log.error("无法创建分组信息文件，程序退出");
			close();
		}
		// 读入分组信息文件，失败则退出
		try {
			groups = GroupsUnmarshaller.unmarshal(groupFile);
		} catch (IOException e) {
			log.error("无法读取分组信息文件，程序退出");
			close();
		}
		// 创建model对象
		DefaultShutterModel newModel = new DefaultShutterModel();
		// 初始化model
		Iterator groupIter = groups.getGroupList().iterator();
		int i = 0;
		while(groupIter.hasNext()) {
			Group group = (Group)groupIter.next();
			GroupModel g = ModelUtils.createGroupModel(group);
			newModel.addTab(g);
			// 根据改组是否是群组，调用不同的model创建方法
			if(g.isCluster()) {
				/* 当前组为群组 */
				Iterator clusterIter = group.getClusterList().iterator();
				while(clusterIter.hasNext()) {
					Hashtable members = new Hashtable();
					Cluster cluster = (Cluster)clusterIter.next();
					ClusterModel cModel = ModelUtils.createClusterModel(cluster);
					newModel.addItem(i, cModel);
					// 加入群中的成员
					List list = cluster.getFriendList();
					Iterator memberIter = list.iterator();
					while(memberIter.hasNext()) {
						Friend friend = (Friend)memberIter.next();
						FriendModel fModel = ModelUtils.createFriendModel(friend);
						fModel.addProperty("parent", cModel);
						members.put(fModel, fModel);
						//newModel.addItem(i, fModel);
					}
					cModel.addProperty("members", members);
				}
			} else {
				/* 当前组为普通组 */
				Iterator friendIter = group.getFriendList().iterator();
				while(friendIter.hasNext()) {
					Friend friend = (Friend)friendIter.next();
					newModel.addItem(i, ModelUtils.createFriendModel(friend));
				}				
			}
			i++;
		}
		// 检查是否需要从服务器获得好友列表，如果xml文件中有好友，则认为
		//     好友已经保存在本地了，不再从服务器获取，这个判断方法比较简单
		//     以后可以修改，或者添加一个强制刷新好友列表的菜单项
		if(newModel.getAllItemCount() > 0) {
			getFriendFromServer = false;
			friendListFinished = true;
		} else {
			getFriendFromServer = true;
			friendListFinished = false;
		}
		// 设置model
		setModel(newModel);
		// 查找黑名单组，如果可视属性为false，隐藏它
		int[] blacklist = model.findTabIndex(blacklistMatcher);
		if (blacklist != null) {
			GroupModel blacklistGroup = (GroupModel)model.getTab(blacklist[0]);
			if ("false".equals(blacklistGroup.getProperty("visible"))) {
				shutter.hideTab(blacklist[0], true);
				blacklistVisible = false;
			} else
				blacklistVisible = true;
		}
	}

	// 设置model
	protected void setModel(ShutterModel newModel) {
		model = newModel;
		// 设置model
		shutter.setModel(model);
		// 添加listener
		int size = model.getTabCount();
		for(int i = 0; i < size; i++) {
			// 添加事件监听器
			shutter.addItemMouseListener(itemMouseListener, i);				
			shutter.addItemMouseTrackListener(itemMouseTrackListener, i);				
			shutter.addContentMouseListener(groupMouseListener, i);
		}
		// 把this添加为model listener，这是为了判断model是否数据有改变，如果不用listener
		//     而是每个可能改变的操作里面都加上相应的代码，显的过于繁琐，且不好管理
		model.addGeneralModelListener(this);
		model.addPropertyListener(this);
		// 设置消息队列的model为这个model
		mq.setModel(model);
		// 根据系统设置中的是否只显示在线好友，来调整当前显示状态
		if(options.isShowOnlineOnly())
			showOnlineFriendOnly();
		// 根据系统设置中的是否显示小头像，来调整当前显示状态
		showSmallFace(options.isSmallFace());
	}

	/**
	 * 创建所有菜单
	 */
	private void initMenu() {
		initStatusMenu();
		initSysMenu();
		initGroupMenu();
		initFriendMenu();
		initClusterMenu();
	}

	// 初始化群菜单
	private void initClusterMenu() {
		clusterMenu = new Menu(shell, SWT.POP_UP);
		// 发群组消息
		MenuItem mi = new MenuItem(clusterMenu, SWT.PUSH);
		mi.setText(LumaQQ.getResourceString("menu.cluster.send"));
		mi.setImage(icons.getResource(IconHolder.icoSendReceiveMessage));
		mi.addSelectionListener(
			new SelectionAdapter() {
				public void widgetSelected(SelectionEvent e) {					
					openClusterMessageShell((ShutterLabel)clusterMenu.getData());
				}
			}
		);
		// 查看群组资料
		mi = new MenuItem(clusterMenu, SWT.PUSH);
		mi.setText(LumaQQ.getResourceString("menu.cluster.viewinfo"));
		mi.setImage(icons.getResource(IconHolder.icoPersonInfo));
		mi.addSelectionListener(
			new SelectionAdapter() {
				public void widgetSelected(SelectionEvent e) {					
					openClusterInfoShell((ShutterLabel)clusterMenu.getData());
				}
			}
		);
		// separator
		mi = new MenuItem(clusterMenu, SWT.SEPARATOR);
		// 消息管理菜单
		mi = new MenuItem(clusterMenu, SWT.CASCADE);
		mi.setText(LumaQQ.getResourceString("menu.cluster.message.manage"));
		mi.setImage(icons.getResource(IconHolder.icoMessageManage));
		Menu msgMenu = new Menu(mi);
		mi.setMenu(msgMenu);
		// 导出为文本文件菜单
		mi = new MenuItem(msgMenu, SWT.PUSH);
		mi.setText(LumaQQ.getResourceString("menu.cluster.message.export"));
		mi.setImage(icons.getResource(IconHolder.icoTxtFile));
		mi.addSelectionListener(
			new SelectionAdapter() {
				public void widgetSelected(SelectionEvent e) {