dodawanie modułu shgg w Visual Studio 2010 Ultimate

mam najnowszy moduł 0.652 stąd: http://code.google.com/p/shgg/downloads/list
ale nie mam pojęcia jak go dodać do projektu klienta gg xD przyznam, że w C# mało klepię, ale czasem lubię się porywać z motyką na słońce, bo na spontan często mi coś wychodzi :D
na forum są opisy tego modułu ale nie jest wytłumaczone jak to dodać, w necie też nigdzie nie znalazłem opisu jak się dodaje moduły szukałem w PL bo po ang. nie do końca mogę zrozumieć (chyba, że to jest tak banalne a mnie już zaciemnił napój energetyczny ;O )

kolejna część: jeśli już ktoś mi napisze jak się z tym uporać (:P) to polecenia np. odbierania wiadomości należy dodawać w listbox, zmiany statusu w combobox ? Tak, wiem to pewnie bardzo trywialne pytanie, ale takimi oto sposobami udało mi się jakiś czas temu zbudować odtwarzacz muzyki (nie jest pełny jeszcze) :P

Ogólnie:

1. jeśli masz jakąś bibliotekę .dll (.NET-ową, tzn. napisaną w jakimś języku platformy .NET (C#, VB np.)) to musisz ją dodać do referencji (w Solution Explorer czy coś takiego masz References -> Add Reference -> Browse (i szukasz pliku .dll))
   Potem musisz w usingach dodać tę bibliotekę (np. using SHgg) i już możesz korzystać z danej klasy.
2. jeśli natomiast jest to projekt (C# dla SHGG (.csproj)), dodaj go po prostu do swojej solucji i korzystaj z niego jak z normalnej klasy w projekcie.

Gdy już możesz posługiwać się daną klasą, tworzysz instancję tego SHGG i uruchamiasz to (zaczyna nasłuchiwać). Musisz mu podpiąć się do zdarzeń, ktore oferuje - na pewno ma jakieś zdarzenie np. na przyjście wiadomości. Odbierasz te zdarzenie (przypisujesz mu z góry jakąś metodę, która ma się wykonać, gdy zdarzenie zajdzie (ang. event)) i w tej metodzie np. otwierasz nowe okno rozmowy (jesli jeszcze nie istnieje) i dodajesz tam tekst, który otrzymałeś w danych ze zdarzenia (jakaś klasa xxxArgs). Ja bym to robił w HTML, tzn w każdym okienku rozmowy dał kontrolkę WebBrowser i umieszczał po prostu kod HTML w niej (pozwala to na ładną koordynację grafiki wewnątrz aplikacji, dużo piep...enia jest z RichTextBoxem i dodawaniem po linijce).

Natomiast lista userów - na początku zwykły ListBox, dodajesz do niego po prostu kolejny String, tzn nick osoby, tylko potem możesz mu przeciążyć (override) metodę OnPaint, jeśli chcesz np. wykorzystać motyw z gg, tzn żółte/czerwone słoneczko, które pojawia się przy nicku (można też to zrobić w HTML, ale proponowałbym się nad tym zastanowić najpierw).

Pozdro ; ]

Nie jestem pewny czy shgg jeszcze działa (dość dawno nic tam nie zmieniałem).

Co do opisanych pytań - tam chyba znajdziesz też dołączony manual jeśli dobrze pamiętam.

Daj znać czy wciąż działa.

nie wiem, albo to nie działa już na VS 2010 albo nie potrafię tego ogarnąć, wywala błędy w shgg w plikach cs
chyba, że ja źle kombinuję...
szkoda, że nie mogę podejrzeć chociaż przykładowego kodu aplikacji opartej na tym module

Występowanie błędów oznacza, że coś źle zrobiłeś. Przejście na wyższy .NET Framework prawie nigdy nie wywala błędów (za wyjątkiem, kiedy jakaś klasa zostanie oznaczona jako Obsolete).

Napisz jakie błędy widzisz?

w paczce jest kilka plików, główny SHGG.cs podłączam czy może wydzielić z niego inne klasy?
np. na połączenie:

 public void GGLogin() {
            GGLogin(GGServerAddress);
        }

itp.
natomiast jeżeli łączę wszystkie z paczki to w References widnieje znaczek błędu na nunit.framework i przez to też wywala błąd, choć nie wiem właściwie czemu

1. Usuń referencję do NUnit.framework.
2. Usuń wszystkie pliki, które używają NUnit.framework

powrócę do tematu, nie warto zakładać nowego bo to dotyczy całości:

buduję ten klient GG i nie może się zalogować, wywala mi błędy -> http://imageshack.us/photo/my-images/804/beztytuurc.jpg/
w tej chwili okno logowania wygląda następująco:

 using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using HAKGERSoft;

namespace WindowsFormsApplication9
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void GGNumber_TextChanged(object sender, EventArgs e)
        {
            sHGG aa = new sHGG();
            this.aa.GGNumber();
        }

        private void GGPassword_TextChanged(object sender, EventArgs e)
        {
            sHGG bb = new sHGG();
            this.bb.GGPassword();
        }

        private void GGLogin_Click(object sender, EventArgs e)
        {
            sHGG Polacz = new sHGG();
            Polacz.GGLogin(Polacz.GGServerAddress);
            Lista GGLogin = new Lista();
            GGLogin.Show();
        }

    }
}  

może ktoś pomóc? :P

Zgodnie ze screen'em z komunikatem wyrzuconego błędu należy wnioskować, że adres serwera, który przekazujesz podczas łącznia się z siecią GG jest nieprawidłowy tj. serwer nie działa, bądź to nie jest serwer GG. Aby naprawić ten błąd musisz zatem zmienić adres serwera, z którym pragniesz się połączyć - zgaduje, że to ta linijka za to odpowiada

Polacz.GGLogin(Polacz.GGServerAddress);

ok, tylko jak to poprawić?

tutaj dodaję kod shgg, z którego ja korzystam:

/* SHGG.cs

Copyright (c) HAKGERSoft 2000 - 2009 www.hakger.xorg.pl

This unit is owned by HAKGERSoft, any modifications without HAKGERSoft permission
are prohibited!

Authors:
 * DetoX [ reedi(at)poczta(dot)fm ]
 * mlesniew
 * Jacek Trublajewicz 'jotte' [ gothic(at)os(dot)pl ]

Unit description:
  .NET GG engine based on System.Net.Sockets.TcpClient,

Requirements:
  .NET 3.5 (at least) to develop
 
Version:
  0.652 / 25.01.2008

Remarks:
  Check new version at http://code.google.com/p/shgg
*/

using System;
using System.Linq;
using System.IO;
using System.Threading;
using System.Collections.Generic;
using System.Drawing;
using System.Net.Sockets;

namespace HAKGERSoft {

    /// <summary>
    /// Główna klasa obsługująca silnik klienta gadu-gadu
    /// </summary>
    public sealed partial class sHGG {
        TcpClient TcpEngine = null;
        Thread IdleEngine, pingTimer;
        NetworkStream NetStream;
        SynchronizationContext Sync = SynchronizationContext.Current;

        internal bool mock {
            get { return this.mockObj != null; }
        }
        internal ConnectionMock mockObj;
       

        /// <summary>
        /// Lista kontaktów
        /// </summary>
        public GGUsers Users;

        # region Properties

        /// <summary>
        /// <value>Określa adres IP serwera gadu-gadu</value>
        /// </summary>
        public string GGServerAddress {
            get { return vGGServerAddress; }
            set { vGGServerAddress = value; }
        }

        private string vGGServerAddress = DEFAULT_GG_HOST;

        /// <summary>
        /// <value>Określa numer gadu-gadu klienta (twój numer GG)</value>
        /// </summary>
        public string GGNumber {
            get { return vGGNumber; }
            set { vGGNumber = value; }
        }

        private string vGGNumber = "0";

        /// <summary>
        /// <value>Określa hasło klienta gadu-gadu (twoje hasło)</value>
        /// </summary>
        public string GGPassword {
            get { return vGGPassword; }
            set { vGGPassword = value; }
        }

        private string vGGPassword = string.Empty;

        /// <summary>
        /// <value>Określa status gadu-gadu</value>
        /// </summary>
        public GGStatusType GGStatus {
            get { return vGGStatus; }
            set {
                vGGStatus = value;
                if (this.IsGGLogged || this.mock)
                    this.OutStatus(); 
            } 
        }

        private GGStatusType vGGStatus = GGStatusType.NotAvailable;

        /// <summary>
        /// <value>Określa opis klienta gadu-gadu</value>
        /// </summary>
        public string GGDescription {
            get { return vGGDescription; }
            set {
                vGGDescription = value;
                if (vGGDescription.Length > MAX_DESCRIPTIONS_SIZE)
                    vGGDescription = vGGDescription.Substring(0, MAX_DESCRIPTIONS_SIZE);
                if (this.IsGGLogged || this.mock)
                    GGStatus = vGGStatus;
            }
        }

        private string vGGDescription = string.Empty;

        /// <summary>
        /// <vale>Jeśli właściwość ma wartość TRUE to włączony jest
        /// tryb "Pokazuj status tylko znajomym"</vale>
        /// </summary>
        public bool GGFriendsMask {
            get { return vGGFriendsMask; }
            set {
                vGGFriendsMask = value;
                if (this.IsGGLogged || this.mock)
                    GGStatus = vGGStatus;
            }
        }

        private bool vGGFriendsMask = false;

        /// <summary>
        /// <value>Pozwala określić maksymalną wielkość obrazka</value>
        /// </summary>
        public byte GGImageSize {
            get { return vGGImageSize; }
            set { vGGImageSize = value; } // todo: re login?
        }

        private byte vGGImageSize = (byte)255;

        /// <summary>
        /// <value>Właściwość jednoznacznie określa czy klient jest zalogowany
        /// w danej chwili do serwera gadu-gadu (tylko do odczytu)</value>
        /// </summary>
        public bool IsGGLogged {
            get { return vIsGGLogged; }
            private set { vIsGGLogged = value; }
        }
       
        private bool vIsGGLogged = false;

        /// <summary>
        /// Właściwość określa czy można szukać dalej w katalogu publicznym (tylko do odczytu)
        /// </summary>
        public bool PubDirCanSearchMore {
            get { return vNextStart != 0; }
        }

        # endregion

        # region Events

        public delegate void GenericEventHandler<A>(object sender, A args);
       
        /// <summary>
        /// Zdarzenie wykonuje się w memencie zalogowania do serwera
        /// </summary>
        public event GenericEventHandler<EventArgs> GGLogged;

        /// <summary>
        /// Zdarzenie wykonuje się w przypadku nieudanej próby zalogowania do serwera
        /// </summary>
        public event GenericEventHandler<EventArgs> GGLogFailed;

        /// <summary>
        /// Zdarzenie wykonuje się w przypadku, gdy serwer gadu-gadu rozłączy klienta
        /// </summary>
        public event GenericEventHandler<EventArgs> GGDisconnected;

        /// <summary>
        /// Zdarzenie wykonuje się gdy przyszła nowa wiadomość
        /// </summary>
        public event GenericEventHandler<MessageReceiveEventArgs> GGMessageReceive;
               
        public class MessageReceiveEventArgs : EventArgs {
            /// <summary>
            /// numer GG nadawcy wiadomości
            /// </summary>
            public int Number;

            /// <summary>
            /// treść wiadomości
            /// </summary>
            public string Message;

            /// <summary>
            /// czas wysłania wiadomości
            /// </summary>
            public DateTime Time;
        }

        /// <summary>
        /// Zdarzenie informuje o wynikach szukania osób w katalogu publicznym
        /// </summary>
        public event GenericEventHandler<SearchReplyEventArgs> GGSearchReply;

        public class SearchReplyEventArgs : EventArgs {
            /// <summary>
            /// znalezione osoby
            /// </summary>
            public List<GGUser> Users;
        }

        /// <summary>
        /// Zdarzenie wykonuje się gdy odczytano własne informacje w katalogu publicznym
        /// </summary>
        public event GenericEventHandler<PubDirReadReplyEventArgs> GGPubDirReadReply;

        public class PubDirReadReplyEventArgs : EventArgs {
            /// <summary>
            /// własne informacje w katalogu publicznym
            /// </summary>
            public GGUser User;
        }

        ///// <summary>
        ///// Zdarzenie wykonuje się w przypadku pomyślnego zapisania danych w katalogu publicznym
        ///// </summary>
        //public event GenericEventHandler<EventArgs> GGPubDirWriteReply;

        # endregion

        /// <summary>
        /// Konstruktor klasy sHGG
        /// </summary>
        public sHGG(): base() {
            Sync = Sync ?? new SynchronizationContext();
            this.Users = new GGUsers(this);
        }

        internal sHGG(ConnectionMock mockObj): this() {
            this.mockObj = mockObj;
        }

        /// <summary>
        /// Loguje się do serwera gadu-gadu (domyślny adres serwera GG)
        /// </summary>
        public void GGLogin() {
            GGLogin(GGServerAddress);
        }

        /// <summary>
        /// Loguje się do serwera gadu-gadu (dowolny adres serwera GG)
        /// </summary>
        /// <param name="serverAddress"></param>
        public void GGLogin(string serverAddress) {
            OutConnect(serverAddress);
        }

        /// <summary>
        /// Metoda wylogowuje z serwera gadu-gadu (rozłącza)
        /// </summary>
        public void GGLogout() {
            if (this.IsGGLogged) {
                StopIdleEngine();
                StopPing();
                TcpEngine.Close();
                IsGGLogged = false;
                NetStream.Close();
                this.Users.UsersRestart();
           }
        }

        /// <summary>
        /// Funkcja zwraca aktualnie czynny adres IP serwera gadu-gadu lub pusty
        /// string w przypadku, gdy żaden nie jest dostępny juz operacja nie
        /// powiedzie się
        /// </summary>
        /// <returns>adres IP serwera</returns>
        public string GGGetActiveServer() {
            return HttpGGGetActiveServer() ?? string.Empty;
        }

        /// <summary>
        /// Funkcja generuje token gadu-gadu
        /// </summary>
        /// <param name="tokenId">id (numer) tokenu</param>
        /// <param name="tokenUrl">pełen adres tokenu</param>
        /// <returns>obrazek z tokenem</returns>
        public Image GGGetToken(out string tokenId, out string tokenUrl) {
            return HttpGetToken(out tokenId, out tokenUrl);
        }

        /// <summary>
        /// Funkcja generuje token gadu-gadu
        /// </summary>
        /// <returns>obrazek z tokenem</returns>
        public Image GGGetToken() {
            string tokenId, tokenUrl;
            return HttpGetToken(out tokenId, out tokenUrl);
        }

        /// <summary>
        /// Rejestruje nowego użytkownika gadu-gadu
        /// </summary>
        /// <param name="email">adres e-mail użytkownika</param>
        /// <param name="password">hasło użytkownika</param>
        /// <param name="tokenId">numer tokenu (konieczny!)</param>
        /// <param name="tokenValue">wartość odczytana z tokenu (konieczna!)</param>
        /// <returns>nowo otrzymany numer gadu-gadu lub '0' gdy operacja się nie powiedzie</returns>
        public int GGRegisterAccount(string email, string password, string tokenId, string tokenValue) {
            return HttpRegisterAccount(email, password, tokenId, tokenValue);
        }

        /// <summary>
        /// Usuwa konto gadu-gadu
        /// </summary>
        /// <param name="GGNumber">numer GG użytkownika</param>
        /// <param name="password">hasło użytkownika</param>
        /// <param name="tokenId">numer tokenu (konieczny!)</param>
        /// <param name="tokenValue">wartość odczytana z tokenu (konieczna!)</param>
        /// <returns>zwraca TRUE jeśli operacja powiedzie się</returns>
        public bool GGDeleteAccount(int GGNumber, string password, string tokenId, string tokenValue) {
            return HttpDeleteAccount(GGNumber, password, tokenId, tokenValue);
        }

        /// <summary>
        /// Zmiana hasła GG
        /// </summary>
        /// <param name="GGNumber">numer GG użytkownika</param>
        /// <param name="password">aktualne hasło</param>
        /// <param name="newPassword">nowe hasło</param>
        /// <param name="email">adres e-mail użytkownika</param>
        /// <param name="tokenId">numer tokenu (konieczny!)</param>
        /// <param name="tokenValue">wartość odczytana z tokenu (konieczna!)</param>
        /// <returns>zwraca TRUE jeśli operacja powiedzie się</returns>
        public bool GGChangePassword(int GGNumber, string password, string newPassword, string email, string tokenId, string tokenValue) {
            return HttpChangePassword(GGNumber, password, newPassword, email, tokenId, tokenValue);
        }

        /// <summary>
        /// Zmiana adresu e-mail klienta
        /// </summary>
        /// <param name="GGNumber">numer GG użytkownika</param>
        /// <param name="password">hasło</param>
        /// <param name="newEmail">nowy adres e-mail</param>
        /// <param name="tokenId">numer tokenu (konieczny!)</param>
        /// <param name="tokenValue">wartość odczytana z tokenu (konieczna!)</param>
        /// <returns>zwraca TRUE jeśli operacja powiedzie się</returns>
        public bool GGChangeEmail(int GGNumber, string password, string newEmail, string tokenId, string tokenValue) {
            return HttpChangePassword(GGNumber, password, password, newEmail, tokenId, tokenValue);
        }

        // todo: funkcja nie działa
        //public bool GGPasswordRemind(int GGNumber, string tokenId, string tokenValue)
        //{
        //    return HttpPasswordRemind(GGNumber, tokenId, tokenValue);
        //}

        /// <summary>
        /// Wysyła wiadomość do użytkownika gadu-gadu
        /// </summary>
        /// <param name="recipient">numer GG użytkownika, do którego wiadomość ma być wysłana</param>
        /// <param name="message">treść wiadomości</param>
        public void GGSendMessage(int recipient, string message) {
            MessageEngine(new int[] {recipient}, message, null, false);
        }

        /// <summary>
        /// Wysyła wiadomość do kilku użytkowników gadu-gadu (konferencja)
        /// </summary>
        /// <param name="recipients">numery GG uczestników konferencji</param>
        /// <param name="message">treść wiadomości</param>
        public void GGSendMessage(int[] recipients, string message) {
            MessageEngine(recipients, message, null, true);
        }

        /// <summary>
        /// Wysyła sformatowaną wiadomość do użytkownika gadu-gadu
        /// </summary>
        /// <param name="recipient">numer GG użytkownika, do którego wiadomość ma być wysłana</param>
        /// <param name="message">treść wiadomości</param>
        /// <param name="messageFormat">obiekt opisujący formatowanie wiadomości (zobacz plik manual.txt)</param>
        public void GGSendMessage(int recipient, string message, SortedDictionary<short,string> messageFormat) {
            MessageEngine(new int[] { recipient }, message, messageFormat, false);
        }

        /// <summary>
        /// Wysyła sformatowaną wiadomość do kilku użytkowników gadu-gadu (konferencja)
        /// </summary>
        /// <param name="recipients">numery GG uczestników konferencji</param>
        /// <param name="message">treść wiadomości</param>
        /// <param name="messageFormat">obiekt opisujący formatowanie wiadomości (zobacz plik manual.txt)</param>
        [Obsolete("Uwaga! Wybrana wersja metody GGSendMessage jeszcze nie działa")]
        public void GGSendMessage(int[] recipients, string message, SortedDictionary<short, string> messageFormat) {
            MessageEngine(recipients, message, messageFormat, true);
        }

        /// <summary>
        /// Wysyła obrazek przez GG
        /// </summary>
        /// <param name="recipient">numer GG użytkownika, do którego obrazek ma być wysłany</param>
        /// <param name="image">obrazek</param>
        public void GGSendImage(int recipient, MemoryStream image) {
            ImageEngine(recipient, string.Empty, 0, image);
        }

        /// <summary>
        /// Wysyła obrazek przez GG
        /// </summary>
        /// <param name="recipient">numer GG użytkownika, do którego obrazek ma być wysłany</param>
        /// <param name="imagePath">pełna ścieżka do pliku z obrazkiem</param>
        public void GGSendImage(int recipient, string imagePath) {
            ImageEngine(recipient, string.Empty, 0, imagePath);
        }

        /// <summary>
        /// Wysyła obrazek przez GG
        /// </summary>
        /// <param name="recipient">numer GG użytkownika, do którego obrazek ma być wysłany</param>
        /// <param name="message">wiadomość dostarczona razem z obrazkiem</param>
        /// <param name="imagePos">pozycja w tekście pod jaką ma się pojawić obrazek</param>
        /// <param name="imagePath">pełna ścieżka do pliku z obrazkiem</param>
        public void GGSendImage(int recipient, string message, int imagePos, string imagePath) {
            ImageEngine(recipient, message, imagePos, imagePath);
        }

        /// <summary>
        /// Wysyła obrazek przez GG
        /// </summary>
        /// <param name="recipient">numer GG użytkownika, do którego obrazek ma być wysłany</param>
        /// <param name="message">wiadomość dostarczona razem z obrazkiem</param>
        /// <param name="imagePos">pozycja w tekście pod jaką ma się pojawić obrazek</param>
        /// <param name="image">obrazek</param>
        public void GGSendImage(int recipient, string message, int imagePos, MemoryStream image) {
            ImageEngine(recipient, message, imagePos, image);
        }

        /// <summary>
        /// Odczytuje informacje z katalogu publicznego
        /// </summary>
        public void PubDirRead() {
            PublicFolderRead();
        }

        /// <summary>
        /// Wyszukuje osoby w katalogu publicznym
        /// </summary>
        /// <param name="GGNumber">numer GG osoby (0 jeśli obojętnie)</param>
        /// <param name="firstname">imię osoby (pusty string jeśli obojętnie)</param>
        /// <param name="lastname">nazwisko osoby (pusty string jeśli obojętnie)</param>
        /// <param name="nickname">nick osoby (pusty string jeśli obojętnie)</param>
        /// <param name="birthYear">rok urodzenia osoby np. '1980' lub przedział - daty odzielone spacją, np. '1980 1984' (pusty string jeśli obojętnie)</param>
        /// <param name="city">miejscowość (pusty string jeśli obojętnie)</param>
        /// <param name="gender">płeć osoby</param>
        /// <param name="activeOnly">wartość TRUE jeśli szukamy tylko osób dostępnych</param>
        public void PubDirSearch(int GGNumber, string firstname, string lastname, string nickname, string birthYear,
                                         string city, GGGender gender, bool activeOnly)
        {
            PublicFolderSearch(GGNumber, firstname, lastname, nickname, birthYear, city, gender, activeOnly);
        }

        /// <summary>
        /// Szuka kolejnych osób w katalogu publicznym z ostatniego zapytania
        /// </summary>
        public void PubDirSearchNext() {
            PublicFolderSearchNext();
        }




    }
}