shelllauncher.java

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

	 * @param viewPart 打开的窗口对象，SendSMSShell对象，失败返回null
	 */
	public void openSMSShell(CoolButton viewPart) {
		if(viewPart == null) return;
		Object modelObj = viewPart.getData();
		if(modelObj instanceof FriendModel)
		    openSMSShell((FriendModel)modelObj);
		else if(modelObj instanceof MobileModel)
		    openSMSShell((MobileModel)modelObj);
	}
    
    /**
     * 打开一个短消息发送窗口
     * 
     * @param f
     * 		好友model
     */
    public void openSMSShell(FriendModel f) {
	    SendSMSShell ssms = ShellFactory.createSendSMSShell(main);
	    ssms.setReceiver(f);
	    ssms.setSendToMobile(false);
		ssms.open();
    }
    
    /**
     * 打开一个短消息发送窗口
     * 
     * @param m
     * 		手机好友model
     */
    public void openSMSShell(MobileModel m) {
        SendSMSShell ssms = ShellFactory.createSendSMSShell(main);
        ssms.setReceiver(m);
        ssms.setSendToMobile(true);
        ssms.open();
    }
    
    /**
     * 打开一个短消息发送窗口，不初始化接收者
     */
    public void openSMSShell() {
	    SendSMSShell ssms = ShellFactory.createSendSMSShell(main);
		ssms.open();
    }
    
    /**
     * 打开一个短消息发送窗口，如果没有qq这个用户，创建一个陌生人再打开
     * 
     * @param qq
     * 		用户QQ号
     */
    public void openSMSShell(int qq) {
        MVCHelper mvcHelper = main.getMVCHelper();
        int[] index = mvcHelper.getFriendCoordinate(qq);
        if(index == null)
            index = mvcHelper.getStrangerIndex(qq);
        openSMSShell((FriendModel)main.getModel().getItem(index[0], index[1]));
    }
    	
	/**
	 * 打开一个消息窗口，不管sender到底是群还是好友
	 * 
	 * @param sender
	 * 		原始消息的发送者
	 */
	public void openIMShell(int sender) {
	    MVCHelper mvcHelper = main.getMVCHelper();
		ClusterModel c = mvcHelper.getClusterModel(sender);
		if(c == null)
			openNormalIMWindow(mvcHelper.getFriendViewPart(sender));
		else
			openClusterIMWindow(c);
	}
	
	/**
	 * 打开消息窗口，自动判断好友类型
	 * 
	 * @param model
	 * 		model对象，类型未知
	 */
	public void openIMShell(Object model) {
	    if(model instanceof FriendModel)
	        openNormalIMWindow((FriendModel)model);
	    else
	        openClusterIMWindow((ClusterModel)model);
	}	

	/**
	 * 打开消息发送或者接收窗口
	 * 
	 * @param f
	 * 		好友model
	 * @return
	 * 		打开的窗口对象，可能是SendMessageShell，也可能是ReceiveMessageShell
	 */
	public Object openNormalIMWindow(FriendModel f) {
	    MVCHelper mvcHelper = main.getMVCHelper();
	    ShellRegistry shellRegistry = main.getShellRegistry();
	    MessageQueue mq = main.getMessageQueue();
	    
		CoolButton viewPart = mvcHelper.getFriendViewPart(f);
		// 得到QQ号
		int qqNum = f.getQQ();
		// 判断是否是聊天模式，一共有两种模式，聊天模式和消息模式
		// 对于消息模式，有消息时打开一个查看消息窗口，一次看一条，用户点下一条按钮看其他的消息
		// 没有消息时，打开的是发送消息窗口
		// 但是如果是聊天模式情况就不一样，首先查看消息窗口是否被打开，而且将会一次性的
		// 把目前所有的消息都显示在发送消息窗口中。发送消息窗口有两种模式，分别对应于聊
		// 天模式和消息模式。这个模式信息就是保存在好友的model中。
		if(f.isTalkMode()) {
			// 如果还没有这个好友的发送消息窗口就创建一个，如果有就直接得到一个
			SendIMWindow sms = null;
			if(shellRegistry.hasSendIMWindow(f)) {
				sms = shellRegistry.getSendIMWindow(f);
				sms.setMinimized(false);
				sms.setActive();
				sms.setFocus();				
			} else {
				sms = ShellFactory.createSendIMWindow(main, f);
				sms.open();
			}
			// 把这个好友目前的所有消息都提取出来，显示到发送消息窗口中
			if(mq.hasMessage(qqNum)) {
				while(mq.hasMessage(qqNum)) {
					// 得到消息包
					ReceiveIMPacket packet = (ReceiveIMPacket)mq.getMessage(qqNum);
					sms.appendMessage(f, packet.normalIM, packet.normalHeader);
				}
				// 停止好友头像的跳动
				viewPart.stopBounceImage();
				viewPart.setImage(HeadFactory.getHeadByStatus(f));
				main.setFriendProperty(f, IQQNode.HAS_MESSAGE, "false");
				// 得到好友的组索引和组的view part，重设组的图标特效状态
				int g = mvcHelper.getFriendCoordinate(qqNum)[0];
				main.getUIHelper().resetGroupImageEffect(g);
				// 重设系统托盘区的图标特效状态
				main.getUIHelper().resetTrayImageEffect();				
			}
			return sms;
		} else {
			if(mq.hasMessage(qqNum)) { // 如果这个好友有消息未读，则打开的是读消息窗口
				// 得到消息包
				ReceiveIMPacket packet = (ReceiveIMPacket)mq.getMessage(qqNum);
				// 检查这个好友是否还有消息，如果没有了则停止闪烁
				if(!mq.hasMessage(qqNum)) {
					viewPart.stopBounceImage();
					viewPart.setImage(HeadFactory.getHeadByStatus(f));
					main.setFriendProperty(f, IQQNode.HAS_MESSAGE, "false");
				}
				// 得到好友的组索引和组的view part，重设组的图标特效状态
				int g = mvcHelper.getFriendCoordinate(qqNum)[0];
				main.getUIHelper().resetGroupImageEffect(g);
				// 重设系统托盘区的图标特效状态
				main.getUIHelper().resetTrayImageEffect();				
				// 检查是否当前已经有一个该好友的查看消息窗口打开了，如果是，则只需要设置
				// 消息，如果否，则需要创建一个新窗口并加入到哈希表中
				ReceiveIMWindow rms = null;
				if(shellRegistry.hasReceiveIMWindow(f)) {
					rms = shellRegistry.getReceiveIMWindow(f);
					rms.setMinimized(false);
				} else {
					// 打开读消息窗口
					rms = ShellFactory.createReceiveIMWindow(main, f);
					rms.open();
				}
				rms.setMessage(packet);
				rms.setNextButtonEnabled(mq.hasMessage(qqNum));
				rms.setActive();
				return rms;
			} else { // 否则我们打开发送消息窗口
				// 检查当前是否已经有一个发送消息窗口打开了，如果是，返回，如果否，创建一个新窗口
			    SendIMWindow sms = null;
				if(shellRegistry.hasSendIMWindow(f)) {
					sms = shellRegistry.getSendIMWindow(f);
					sms.setMinimized(false);
					sms.setFocus();
				} else {
					sms = ShellFactory.createSendIMWindow(main, f);
					sms.open();				
				}
				sms.setActive();
				return sms;
			}			
		}
	}
	
	/**
	 * 打开一个消息窗口，如果当前这个好友没有发消息来，打开的是发送消息窗口
	 * 如果这个好友有消息未读，打开的是读消息窗口
	 * 
	 * @param viewPart
	 * 		好友的view部分
	 * @return
	 * 		打开的窗口对象，可能是SendMessageShell，也可能是ReceiveMessageShell，失败返回null
	 */
	public Object openNormalIMWindow(CoolButton viewPart) {
		if(viewPart == null) return null;
		FriendModel f = (FriendModel)viewPart.getData();
		return openNormalIMWindow(f);
	}	

	/**
	 * 打开群组资料窗口
	 * 
	 * @param viewPart
	 * 		群的view部分
	 * @return
	 * 		群组资料窗口
	 */
	public ClusterInfoWindow openClusterInfoWindow(CoolButton viewPart) {
		ClusterModel c = (ClusterModel)viewPart.getData();
		return openClusterInfoWindow(c);
	}
	
	/**
	 * 打开群组资料窗口
	 * 
	 * @param c
	 * 		群model
	 * @return
	 * 		群组资料窗口
	 */
	public ClusterInfoWindow openClusterInfoWindow(ClusterModel c) {
	    ShellRegistry shellRegistry = main.getShellRegistry();
		if(shellRegistry.hasClusterInfoWindow(c)) {
			ClusterInfoWindow cis = shellRegistry.getClusterInfoWindow(c);
			cis.setMinimized(false);
			cis.setActive();
			return cis;
		} else {
			ClusterInfoWindow cis = ShellFactory.createClusterInfoWindow(main, c);
			shellRegistry.addClusterInfoWindow(c, cis);
			cis.open();
			return cis;
		}
	}	

	/**
	 * 打开一个浏览器窗口
	 * 
     * @param url
     * 		目的URL
     * @param title
     * 		窗口标题
     * @param errorString
     * 		如果出错，显示什么错误信息
     */
    public void openBrowserShell(String url, String title, String errorString) {
        // 查看是否设置了外部浏览器，如果设置了，就不使用缺省的浏览器
        String browser = OptionUtil.getInstance().getBrowser();
        try {
            if(browser.equals("")) {
        		MessageDialog dialog = new MessageDialog(main.getShell(),
        		        LumaQQ.getString("message.box.common.question.title"), 
        		        null,
        		        LumaQQ.getString("message.box.browser.not.set"),
        		        MessageDialog.QUESTION,
        		        new String[]{IDialogConstants.YES_LABEL, IDialogConstants.NO_LABEL, IDialogConstants.CANCEL_LABEL}, 
        		        0);
        		
                switch(dialog.open()) {
                    case 0:
	                    main.getShellLauncher().openSystemOptionWindow().setCurrentPage(SystemOptionWindow.OTHER);
                    	break;
                    case 1:
	    	            BrowserShell bs = ShellFactory.createBrowserShell(main);
	    	            bs.setUrl(url);
	    	            bs.setTitle(title);
	    	            bs.open();	
	    	            break;                    
                }
            } else
                Runtime.getRuntime().exec(browser.replaceAll("\\[URL\\]", url));
        } catch (Throwable t) {
            MessageDialog.openWarning(main.getShell(), LumaQQ.getString("message.box.common.warning.title"), errorString);
        } 
    }
	
	/**
	 * 打开一个系统消息查看窗口
	 * 
	 * @param packet
	 * 		系统消息包
	 */
	public void openReceiveSystemMessageShell(BasicInPacket packet) {
		// 如果没有系统消息了，停止闪烁消息按钮
		if(!main.getMessageQueue().hasSystemMessage())
			main.stopBlinkSystemMessageIcon();
		// 调整tray icon的闪烁状态
		main.getUIHelper().resetTrayImageEffect();
		// 打开查看系统消息窗口
		ReceiveSystemMessageShell rsms = ShellFactory.createReceiveSystemMessageShell(main);
		rsms.setSystemMessage(packet);
		rsms.open();
	}
	
	/**
	 * 打开一个好友资料查看窗口，窗口里的信息将通过从viewpart中得到的model来设置
	 * 
	 * @param viewPart
	 * 		好友的view部分
	 * @param style
	 * 		窗口样式
	 */
	public void openUserInfoWindow(CoolButton viewPart, int style) {
		FriendModel f = (FriendModel)viewPart.getData();
		openUserInfoWindow(f, style);
	}
	
	/**
	 * 打开一个好友资料查看窗口，窗口里的信息将根据friendmodel来设置
	 * 
	 * @param f
	 * 		好友model
	 * @param style
	 * 		窗口样式
	 */
	public void openUserInfoWindow(FriendModel f, int style) {
	    ShellRegistry shellRegistry = main.getShellRegistry();
		// 查找是否已经存在这个好友的资料查看窗口，如果是，使该窗口激活，如果否，创建一个新的
		if(shellRegistry.hasUserInfoWindow(f)) {
		    UserInfoWindow uis = shellRegistry.getUserInfoWindow(f);
			uis.setMinimized(false);
			uis.setActive();
		} else {
		    UserInfoWindow uis = ShellFactory.createUserInfoWindow(main, f, style);
			shellRegistry.addUserInfoWindow(f, uis);
			uis.open();
		}		
	}
	
	/**
	 * 打开一个表情管理窗口
	 * 
	 * @param main
	 */
	public void openFaceWindow(MainShell main) {
	    ShellRegistry shellRegistry = main.getShellRegistry();
	    if(shellRegistry.isFaceWindowOpened()) {
	        FaceWindow window = shellRegistry.getFaceWindow();
	        window.setMinimized(false);
	        window.setActive();
	    } else {
	        FaceWindow window = ShellFactory.createFaceWindow(main);
	        shellRegistry.registerFaceWindow(window);
	        window.open();
	    }
	}
}