Example #1
0
        protected override void ExecuteImpl()
        {
            GroupInfo gi = GroupInfoManager.FindGroup(m_groupKey);

            if (gi != null)
            {
                if (m_text.Contains(TextCommand_IsAlive))
                {
                    OutgoingPackagePool.AddFirst(NetPackageGenerater.AppendGroupTextMessage(gi.Key, MsgInputConfig.FormatMessage("I'm alive."), m_remoteIP));
                    return;
                }
                else if (m_text.Contains(TextCommand_Version))
                {
                    OutgoingPackagePool.AddFirst(NetPackageGenerater.AppendGroupTextMessage(gi.Key, MsgInputConfig.FormatMessage(DataManager.Version), m_remoteIP));
                    return;
                }
                else if (m_text.Contains(TextCommand_Dead_Pkg_Count))
                {
                    OutgoingPackagePool.AddFirst(NetPackageGenerater.AppendTextMessage(MsgInputConfig.FormatMessage(Logger.Get_Dead_Pkg_Counter()), m_remoteIP));
                    return;
                }
            }

            UserInfo usr = UserInfoManager.FindUser(m_remoteIP);

            if (gi != null && usr != null)
            {
                gi.AppendMessage(m_text, usr.Username);
            }
        }
Example #2
0
        public static void AddClient(string name, IPEndPoint remoteIP)
        {
            s_singleton.Invoke(new DoAction(delegate
            {
                IPAddress addr = remoteIP.Address;
                int port       = remoteIP.Port;

                UserInfo user = UserInfoManager.FindUser(remoteIP);
                if (user == null)
                {
                    user = new UserInfo(new IPEndPoint(addr, port), name);
                    UserInfoManager.AddUser(user);

                    GroupInfo[] groups = GroupInfoManager.GetGroupArray();
                    foreach (GroupInfo grp in groups)
                    {
                        OutgoingPackagePool.AddFirst(NetPackageGenerater.FindGroupUser(grp.Key, remoteIP));
                    }
                }
                else if (user.Username != name)
                {
                    user.Username = name;
                    s_singleton.m_users.UpdateUserName(user);
                }

                user.IsAlive = true;
                s_singleton.m_users.AddUser(user);
            }));
        }
Example #3
0
        protected override void ExecuteImpl()
        {
            GroupInfo gi   = GroupInfoManager.FindGroup(m_groupKey);
            UserInfo  user = UserInfoManager.FindUser(m_remoteIP);

            Workbench.GroupAddUser(gi, user);
        }
Example #4
0
        public static void ClientLeave(IPEndPoint remoteIP)
        {
            UserInfo user = UserInfoManager.FindUser(remoteIP);

            if (user == null)
            {
                return;
            }

            s_singleton.Invoke(new DoAction(delegate
            {
                IPAddress addr = remoteIP.Address;
                int port       = remoteIP.Port;

                Logger.WriteLine(string.Format("User Leave: {0}, IP: {1}", user.Username, user.RemoteIP));

                user.IsAlive = false;
                s_singleton.m_users.DeleteUser(user);

                GroupInfo[] groups = GroupInfoManager.GetGroupArray();
                foreach (GroupInfo group in groups)
                {
                    group.DeleteUser(user);
                }
            }));
        }
Example #5
0
        public GroupList()
        {
            InitializeComponent();

            GroupConfig.Load();
            m_list.Items.AddRange(GroupInfoManager.GetGroupArray());
        }
Example #6
0
        public static void QuitGroup(GroupInfo group)
        {
            if (group == null)
            {
                return;
            }

            s_singleton.Invoke(new DoAction(delegate
            {
                Logger.WriteLine(string.Format("Quit Group: {0}. with key: {1}", group.Name, group.Key));

                GroupInfoManager.DeleteGroup(group);
                s_singleton.m_groups.DeleteGroup(group);
            }));
        }
Example #7
0
            void m_timer_Tick(object sender, EventArgs e)
            {
                m_timer.Start();

                if (m_flashingUser != null && !m_flashingUser.IsReceiveNewMessage)
                {
                    m_flashingUser = null;
                }

                if (m_flashingGroup != null && !m_flashingGroup.IsReceiveNewMessage)
                {
                    m_flashingGroup = null;
                }

                if (m_flashingUser == null)
                {
                    m_flashingUser = UserInfoManager.FindUserWhichHaveNewMessage();
                }

                if (m_flashingUser == null)
                {
                    m_flashingGroup = GroupInfoManager.FindGroupWhichHaveNewMessage();
                }

                if (m_flashingUser == null && m_flashingGroup == null)
                {
                    m_tray.Icon = IconManager.Tray_Normal;
                    return;
                }
                else
                {
                    m_state = !m_state;

                    if (m_state)
                    {
                        m_tray.Icon = IconManager.Tray_Normal;
                    }
                    else
                    {
                        m_tray.Icon = IconManager.Tray_Blank;
                    }
                }
            }
Example #8
0
        public static void AddGroup(string groupKey, string name)
        {
            if (string.IsNullOrEmpty(groupKey) || string.IsNullOrEmpty(name))
            {
                return;
            }

            if (GroupInfoManager.FindGroup(groupKey) != null)
            {
                return;
            }

            s_singleton.Invoke(new DoAction(delegate
            {
                Logger.WriteLine(string.Format("Add Group: {0}. with key: {1}", name, groupKey));

                GroupInfo gi = new GroupInfo(groupKey, name);
                GroupInfoManager.AddGroup(gi);
                s_singleton.m_groups.AddGroup(gi);
            }));
        }
Example #9
0
        protected override void ExecuteImpl()
        {
            if (string.IsNullOrEmpty(m_groupKey))
            {
                return;
            }

            UserInfo usr = UserInfoManager.FindUser(m_remoteIP);

            if (usr == null)
            {
                Workbench.AddClient(m_username, m_remoteIP);
            }

            GroupInfo grp = GroupInfoManager.FindGroup(m_groupKey);

            if (grp != null)
            {
                Workbench.GroupAddUser(grp, usr);
                OutgoingPackagePool.AddFirst(NetPackageGenerater.AddGroupUser(m_groupKey, m_remoteIP));
            }
        }
Example #10
0
        public NP_AppendGroupImageMessageCmd(byte[] data, IPEndPoint remoteIP)
        {
            m_user = UserInfoManager.FindUser(remoteIP);

            int key_length = Helper.GetInt(data);

            m_group = GroupInfoManager.FindGroup(Helper.GetString(data, 4, key_length));

            int length = Helper.GetInt(data, key_length + 4);

            m_filename = Helper.GetString(data, key_length + 8, length);
            m_filename = Path.Combine(DataManager.GetCustomFaceFolderPath(), m_filename);

            int fileDataOffset = 4 + key_length + length + 4;
            int fileDataLength = data.Length - fileDataOffset;

            MemoryStream ms = new MemoryStream(data, fileDataOffset, fileDataLength);

            byte[] imgData = ms.ToArray();
            ms.Dispose();

            GenerateImageFile(imgData, ref m_filename);
        }
Example #11
0
        public GroupSelectionForm()
        {
            InitializeComponent();

            comboBox1.Items.AddRange(GroupInfoManager.GetGroupArray());
        }