[Gelöst]Python Backgrounding (GTK) - asyncore.loop() beenden

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
maxi_king_333
User
Beiträge: 110
Registriert: Freitag 25. Dezember 2009, 03:42

Hi,

nun habe ich das Problem, dass die genrandomid() Funktion nicht global ist, ich kann sie also in den Klassen nicht verwenden.

So, nun ist es endlich auf BerliOS: http://developer.berlios.de/projects/fbcallnotify/
Unter GIT könnt Ihr euch den Code angucken bzw. herunterladen.
Habe auch die Änderungen da drin (funktioniert nur nicht, wegen genrandomid()).

Viele Grüße
Maxi

P.S. Ich hbae mal ein neues Thema unter Projekte erstellt, weil das passt nicht mehr so ganz zum ursprünglichen Thema: http://www.python-forum.de/topic-21399.html
Hier geht's dann weiter ;).
Dav1d
User
Beiträge: 1437
Registriert: Donnerstag 30. Juli 2009, 12:03
Kontaktdaten:

Wobei ich mir nicht sicher bin, ob immer garantiert ist, dass man bei dem `recv()`-Aufruf Datenblöcke ganze Zeilen bekommt, und nicht auch mal eine Zeile über zwei `recv()`-Aufrufe verteilt sein kann!? Das sollte man klären.
mit recv() bekommt man nicht immer komplette Zeilen! es kann einem passieren das erst mit dem nächsten Zeilenblock die Zeile beendet wird, zum Beispiel durch \r\n

Edit: ich würde die If-Statements in der Funktion run in der parse.py durch ein dict ersetzten, z.B. so:

Code: Alles auswählen

class Parse(threading.Thread):
    def __init__(self, pool):
         threading.Thread.__init__(self)
         ....
         self.foo = {'bar' : self.on_bar}
    def run(self):
        ....
        if not info is None:
            if info[1] in self.foo:
                self.foo[info[1]](info)
the more they change the more they stay the same
Benutzeravatar
HWK
User
Beiträge: 1295
Registriert: Mittwoch 7. Juni 2006, 20:44

maxi_king_333 hat geschrieben:Ich erzeuge 2, da ich irgendwie mit nur einer keine 10 Stelligen Zahlen hinbekomme.

Code: Alles auswählen

>>> '%010i' % randint(1, 9999999999)
'0084238386'
>>> 
MfG
HWK
BlackJack

PEP8 erlaubt zwar auch Tabs, bevorzugt aber ziemlich deutlich Leerzeichen: `For new projects, spaces-only are strongly recommended over tabs.` Wirklich ein Problem ist das vermischen von Tabs und Leerzeichen, da die meisten Leute aber Leerzeichen verwenden, wird es schwieriger Quelltext auszutauschen, wenn man Tabs verwendet.

Leerzeichen bekommt man mit dem richtigen Editor, also im Grunde jeder der als Editor zum Programmieren taugt, auch einfach wieder weg. Wenn ich die Rückschritt-Taste drücke, dann verschwinden bei eingerücktem Quellext auch gleich alle Leerzeichen die zu einer Ebene gehören und nicht nur ein Einzelnes. Eben das was man an der Stelle gerne hätte.

Mal davon abgesehen, dass es in der Standardbibliothek, insbesondere bei Python 2.x Namensgebungen gibt, die sich nicht an PEP8 halten, sind `os` und `sys` keine Klassen, sondern Module. Und als solche halten sie sich an die Empfehlungen von PEP8. `Tkinter` hält sich da zum Beispiel nicht dran, ist in Python 3 deshalb auch in `tkinter` umbenannt worden.

Klassen sind in sofern etwas besonderes als das sie a) eine Vorlage für Objekte von ihrem Typ sind und man b) davon andere Klassen ableiten kann. Ausserdem ist es praktisch, dass man, wenn einem kein besserer Name für ein Exemplar einfällt, einfach den Klassennamen klein geschrieben dafür verwenden kann. Also zum Beispiel bei einer Klasse `Person` kann man einfach ``person = Person('Klaus')`` schreiben. Die Standardbibliothek hält sich da auch nicht immer dran, und besonders bei `socket` habe ich schon geflucht. Wenn ich ein `socket.socket`-Exemplar erstelle, wäre `socket` oft ein passender Name dafür, aber den kann man ja leider nicht verwenden ohne Modul oder Klasse zu verdecken. Ich importiere den Typ deshalb immer so ``from socket import socket as Socket``.

Ich finde Operatoren ohne Leerzeichen seltsam. Liest sich zumindest IMHO schlechter wenn alles "zusammenklebt". Und das obwohl ich das früher auf dem C64 und auch in der Anfangszeit auf dem PC in BASIC und Pascal auch noch gemacht habe. Beim C64 hatte das aber auch einen Grund: nur 40 Zeichen pro (Bildschirm)Zeile und jedes gesparte Leerzeichen war ein gespartes Byte. :-)

Hm, tja *Zahlen* werden mit ``+`` halt addiert und nicht aneinandergehängt. Wieso Du eine 10-stellige Zahl nicht in einem Schritt hinbekommst, verstehe ich nicht:

Code: Alles auswählen

In [111]: n = random.randint(1000000000, 9999999999)

In [112]: n
Out[112]: 3779966062L

In [113]: len(str(n))
Out[113]: 10
Ich habe den Sinn der Dictionaries mit den Zufallszahlen als Schlüsseln auch nach der Beschreibung nicht verstanden. Vielleicht solltest Du solch eine Komplexität erst einbauen, wenn sie auch wirklich *gebraucht* wird, und nicht schon auf "Vorrat".

Funktionen kann man in einem Thread über die Klasse `threading.Thread` ausführen. Der kann man im Konstruktor ein aufrufbares Objekt und auch Argumente für diese Aufruf mitgeben.

Das eine Funktion nicht global ist, sollte in der Regel kein Problem sein, denn globale Funktionen sollte man ja nach Möglichkeit vermeiden. :-) Wenn man eine Funktion in mehreren Modulen braucht, schreibt man die in ein Modul, das die anderen Module dann importieren können. Wobei die Funktion ja letztendlich durch einen einzigen Aufruf von `random.randint()` ersetzt werden kann, also sich die Frage stellt, ob man dafür eine eigene Funktion braucht.
maxi_king_333
User
Beiträge: 110
Registriert: Freitag 25. Dezember 2009, 03:42

Hi,
Mal davon abgesehen, dass es in der Standardbibliothek, insbesondere bei Python 2.x Namensgebungen gibt, die sich nicht an PEP8 halten, sind `os` und `sys` keine Klassen, sondern Module. Und als solche halten sie sich an die Empfehlungen von PEP8. `Tkinter` hält sich da zum Beispiel nicht dran, ist in Python 3 deshalb auch in `tkinter` umbenannt worden.

Klassen sind in sofern etwas besonderes als das sie a) eine Vorlage für Objekte von ihrem Typ sind und man b) davon andere Klassen ableiten kann. Ausserdem ist es praktisch, dass man, wenn einem kein besserer Name für ein Exemplar einfällt, einfach den Klassennamen klein geschrieben dafür verwenden kann. Also zum Beispiel bei einer Klasse `Person` kann man einfach ``person = Person('Klaus')`` schreiben. Die Standardbibliothek hält sich da auch nicht immer dran, und besonders bei `socket` habe ich schon geflucht. Wenn ich ein `socket.socket`-Exemplar erstelle, wäre `socket` oft ein passender Name dafür, aber den kann man ja leider nicht verwenden ohne Modul oder Klasse zu verdecken. Ich importiere den Typ deshalb immer so ``from socket import socket as Socket``.
Em also das ist unlogisch oder verstehe ich das falsch?
Du sorgst dafür, dass socket in Socket umbenannt wird - weil die Namen ja groß sein sollen.
Und in Python 3 ist Tkinter in tkinter umbenannt worden - warum, ich dachte die Namen sollen groß sein.
Ansonsten - überredet - ich habe die Tabs durch Leerzeichen ersetzt.
Wieso Du eine 10-stellige Zahl nicht in einem Schritt hinbekommst, verstehe ich nicht:
Keine Sorge, ich auch nicht ;).
Auf wundersame Weise läuft jetzt das, was gestern so nicht gelaufen ist - vielleicht hatte ich irgendetwas übersehen oder falsch gemacht.
Naja, egal - es läuft.
Ich habe den Sinn der Dictionaries mit den Zufallszahlen als Schlüsseln auch nach der Beschreibung nicht verstanden. Vielleicht solltest Du solch eine Komplexität erst einbauen, wenn sie auch wirklich *gebraucht* wird, und nicht schon auf "Vorrat".
Es wird ja schon jetzt gebraucht, es fehlt einfach nur noch die Funktion, die die Konfiguration einliest - mehr Code, mehr Bugs, deshalb möchte ich, dass es erstmal so funktioniert.
Also, das soll ja ein Anrufmonitor werden.
Jetzt führst Du aber 2 Gespräche, dann brauchst Du auch 6 Objekte.
3 pro Gespräch Anruf/Angerufen Angenommen Aufgelegt.
Und da Anruf auch noch ausgeführt werden kann wenn man schon auflegt, muss es eben immer ein neues Objekt sein.
Diese brauchen auch irgendeinen Speicherort und dieser ist eben das Dict mit den Zufallszahlen.
Funktionen kann man in einem Thread über die Klasse `threading.Thread` ausführen. Der kann man im Konstruktor ein aufrufbares Objekt und auch Argumente für diese Aufruf mitgeben.
Danke, das wird doch dann durch target (Einfach der Name der Funktion) angegeben ,oder?

Code: Alles auswählen

threading.Thread(None, target)
Das eine Funktion nicht global ist, sollte in der Regel kein Problem sein, denn globale Funktionen sollte man ja nach Möglichkeit vermeiden. Smile Wenn man eine Funktion in mehreren Modulen braucht, schreibt man die in ein Modul, das die anderen Module dann importieren können. Wobei die Funktion ja letztendlich durch einen einzigen Aufruf von `random.randint()` ersetzt werden kann, also sich die Frage stellt, ob man dafür eine eigene Funktion braucht.
Und was ist, wenn es sich um eine Klasse handelt?
Naja, egal, ich habe jetzt einfach die Funktion direkt eingebaut.
mit recv() bekommt man nicht immer komplette Zeilen! es kann einem passieren das erst mit dem nächsten Zeilenblock die Zeile beendet wird, zum Beispiel durch \r\n
Aber die kommen vom Router und sind immer nur \n.
recv() liest doch einfach nur das aus, was der Socket empfangen hat, oder verstehe ich das falsch?
Und dann liest sie eben "test\ntest1\n" - wo liegt da das Problem?
Edit: ich würde die If-Statements in der Funktion run in der parse.py durch ein dict ersetzten, z.B. so:
Was für Vorteile soll das haben?
Das run() nicht so groß ist und schneller ausgeführt werden kann?
Dav1d hat geschrieben:Gut du verwendest dicts

Ich würde jetzt randomid durch eine Instanz einer Klasse austauschen, ich kenne deinen Code jetzt nicht
So ganz bin ich mit meiner bisherigen Struktur auch nicht zufrieden, da ich haufenweise Variablen habe, die die Verschiedenen Notify Stufen halten.
Diese Variablen müssen auch irgendwann gelöscht werden.
Am besten durch das Objekt dem sie zugeordnet sind.
Z.B. das "Objekt" als Schlüssel für das dict
So, das wollte ich eigentlich wissen, wie ich das machen soll.
Also es sollen ja nur nach Abschluss von dem Notifyer Thread die Objekte aus dem Zufallszahlen Dict gelöscht werden.

Viele Grüße
Maxi
BlackJack

@maxi_king_333: Die Namen von *Klassen* sollten gross geschrieben werden. `Tkinter` ist doch keine Klasse, sondern ein Modul. Und bei dem `socket`-Beispiel binde ich nicht das Modul `socket` an den Namen `Socket`, sondern die Klasse `socket` *aus* diesem Modul. Interessanterweise heist die Klasse ursprünglich `_socketobject` und wird erst nachträglich an den Namen `socket` gebunden:

Code: Alles auswählen

In [137]: socket.socket
Out[137]: <class 'socket._socketobject'>
Die Komplexität wird *jetzt* noch nicht gebraucht. Auf die Objekte in den Dictionaries wird nicht zugegriffen, also kann man sie auch weglassen.

Und ich versteh's immer noch nicht. Mir ist klar, dass man für verschiedene Ereignisse, die man Melden möchte, jeweils Objekte benötigt, die diese Verarbeiten, den Benutzer informieren, oder auch andere Aktionen auslösen. Aber warum muss man die in diese Dictionaries stecken? Warum mit Zufallszahlen als Schlüssel? Wie soll man da je wieder *gezielt* herankommen? Und wenn man das nicht kann, warum stecken die dann nicht einfach in Listen? Warum willst Du da später noch einmal drauf zugreifen? Gib doch mal bitte ein konkretes Beispiel.

Das mit `Thread` kann man so schreiben, aber ich würde in dem Fall die Schlüsselworte explizit hinschreiben, statt Platzhalterargumente anzugeben.

Code: Alles auswählen

In [141]: def say_hello(to):
   .....:     print 'Hello, %s!' % to
   .....:

In [142]: t = threading.Thread(target=say_hello, args=['world'])

In [143]: t.start()

Hello, world!
Die Frage mit der Klasse habe ich nicht verstanden!? Man kann in Klassen auf alle Namen zugreifen, die auf Modulebene bekannt sind.

Das Problem mit `recv()` ist, dass die Gegenseite 'test\ntest1\n' nicht an einem Stück senden muss, sondern bei Dir auch bei einem `recv()`-Aufruf 'test\nte' und beim nächsten dann erst 'st1\n' ankommen kann. Es ist nicht wirklich garantiert, dass die Zeilen immer an einem Stück ankommen.

Das mit dem `dict()` in `parse.run()` hat einmal den Vorteil, dass `run()` nicht so gross wird und zum zweiten kann man es dann leichter erweitern. Das ist ausserdem die "pythonische" Art eine ``switch``-Anweisung auszudrücken, die es in anderen Programmiersprachen gibt. Ich würde an der Stelle wohl einen dynamischen "dispatch" anhand von ``info[1]`` machen, sofern man davon ausgehen kann, dass für die Fälle, die man behandeln möchte, immer etwas steht, was als Suffix eines gültigen Namens in Python durchgeht. Ungetestet: http://paste.pocoo.org/show/161268/

Nur um sicher zu gehen: Du weisst, dass die `Thread`-Objekte solange existieren, bis sie durchgelaufen sind? Auch wenn man keine Referenzen mehr darauf hält. Solange das Hauptprogramm läuft, braucht man sich da nicht mehr weiter zu kümmern. Für das Verhalten wenn das Hauptprogramm endet und noch Threads laufen, ist `Thread.setDaemon()` auf den jeweiligen `Thread`-Exemplaren. verantwortlich.
Dav1d
User
Beiträge: 1437
Registriert: Donnerstag 30. Juli 2009, 12:03
Kontaktdaten:

BlackJack hats zwar schon gesagt...
mit recv() bekommt man nicht immer komplette Zeilen! es kann einem passieren das erst mit dem nächsten Zeilenblock die Zeile beendet wird, zum Beispiel durch \r\n
\r\n war ein Beispiel

recv() empfängt immer Datenblöcke, allerdings kennt recv() den Delimiter nicht. Ein Beispieltext der gesendet wird:

Code: Alles auswählen

Hallo ich\r\n
bin ein Beispiel\r\n
Text mit unsinnigen Buchstaben am Ende\r\n
Jetzt könnte recv() das zum Beispiel so empfangen

Code: Alles auswählen

# Block 1
Hallo ich\r\nbin ein Bespiel\r\nText mit
# Block 2
unsinnigen Buchstaben am Ende\r\n
the more they change the more they stay the same
maxi_king_333
User
Beiträge: 110
Registriert: Freitag 25. Dezember 2009, 03:42

Hi,

schonmal Vielen Dank - ich habe wieder einiges dazu gelernt.
@maxi_king_333: Die Namen von *Klassen* sollten gross geschrieben werden. `Tkinter` ist doch keine Klasse, sondern ein Modul. Und bei dem `socket`-Beispiel binde ich nicht das Modul `socket` an den Namen `Socket`, sondern die Klasse `socket` *aus* diesem Modul. Interessanterweise heist die Klasse ursprünglich `_socketobject` und wird erst nachträglich an den Namen `socket` gebunden:
Man muss sich erstmal den Unterschied zwischen Funktionen und Modulen klar werden.
Ich denke ich habe es jetzt Verstanden.
Die Komplexität wird *jetzt* noch nicht gebraucht. Auf die Objekte in den Dictionaries wird nicht zugegriffen, also kann man sie auch weglassen.

Und ich versteh's immer noch nicht. Mir ist klar, dass man für verschiedene Ereignisse, die man Melden möchte, jeweils Objekte benötigt, die diese Verarbeiten, den Benutzer informieren, oder auch andere Aktionen auslösen. Aber warum muss man die in diese Dictionaries stecken? Warum mit Zufallszahlen als Schlüssel? Wie soll man da je wieder *gezielt* herankommen? Und wenn man das nicht kann, warum stecken die dann nicht einfach in Listen? Warum willst Du da später noch einmal drauf zugreifen? Gib doch mal bitte ein konkretes Beispiel.
Em also ich möchte da garnicht mehr drauf zugreifen, im Gegenteil - wenn die fertig gelaufen sind soll das Ding ja wieder gelöscht werden.
Darum geht es ja eigentlich - würde das mit Listen gehen - wobei ich muss höchstens 1 Mal drauf zugreifen nämlich wenn ich den Thread starte.
Also gut, ein Beispiel:
Der Nutzer hat folgende Konfiguration:
2 Telefone mit den Nummern 333 444.
Bei einem ausgehenden Anruf über 333: Notify (über Libnotify) "Ausgehender Anruf von 333 zu xxx"; Musik leiser; Wenn die Verbindung steht Musik aus
Bei einem ankommenden Anruf an 333: Notify (über Libnotify) "Ausgehender Anruf von xxx zu 333"; Musik leiser; Wenn die Verbindung steht Musik aus
Bei der Nummer 444 nichts tun.
Die Nummer 333 gehört ihm, die andere einem anderen Familien Mitglied.
Nun wird ein Anruf von 333 getätigt - Die Callmonitor Klasse empfängt das Signal.
Jetzt kommt Parse und wertet es aus - die Notifyer Klasse wird gestartet bzw. es wird ein neues Objekt von ihr erstellt.
Dieses *soll* nun die Konfiguration einlesen (Das macht sie jetzt noch nicht, also von mir aus schreiben wir es eben direkt in den Code) und daraus 3 Notify Objekte erzeugen.
Die Notify Objekte führen jetzt die Oben Genannten Dinge aus.
Und wenn der Anruf Ankommt passiert eben genau das gleiche.
Sollte irgendetwas mit der Nummer 444 an Notifer übergeben werden passiert nichts.
Nur um sicher zu gehen: Du weisst, dass die `Thread`-Objekte solange existieren, bis sie durchgelaufen sind? Auch wenn man keine Referenzen mehr darauf hält. Solange das Hauptprogramm läuft, braucht man sich da nicht mehr weiter zu kümmern. Für das Verhalten wenn das Hauptprogramm endet und noch Threads laufen, ist `Thread.setDaemon()` auf den jeweiligen `Thread`-Exemplaren. verantwortlich.
Ja, jetzt schon.
Aber es wird nicht alles als Thread gestartet - Die Notify Klasse gibt es 2 mal einmal ohne und einmal mit Thread - Wobei ich daraus heute Abend/Nacht ja eh Funktionen mache, die ich dann entweder als Thread oder eben nicht als Thread starte.
Die Frage mit der Klasse habe ich nicht verstanden!? Man kann in Klassen auf alle Namen zugreifen, die auf Modulebene bekannt sind.
Und wie heißt das Modul der Hauptdatei (fbcallnotify.py) - fbcallnotify?
Also theoretisch fbcallnotify.genrandomid()?
Das Problem mit `recv()` ist, dass die Gegenseite 'test\ntest1\n' nicht an einem Stück senden muss, sondern bei Dir auch bei einem `recv()`-Aufruf 'test\nte' und beim nächsten dann erst 'st1\n' ankommen kann. Es ist nicht wirklich garantiert, dass die Zeilen immer an einem Stück ankommen.

Das mit dem `dict()` in `parse.run()` hat einmal den Vorteil, dass `run()` nicht so gross wird und zum zweiten kann man es dann leichter erweitern. Das ist ausserdem die "pythonische" Art eine ``switch``-Anweisung auszudrücken, die es in anderen Programmiersprachen gibt. Ich würde an der Stelle wohl einen dynamischen "dispatch" anhand von ``info[1]`` machen, sofern man davon ausgehen kann, dass für die Fälle, die man behandeln möchte, immer etwas steht, was als Suffix eines gültigen Namens in Python durchgeht. Ungetestet: http://paste.pocoo.org/show/161268/
Asch so ist das gemeint - dann bau ich eine Schleife ein, die wartet bis nichts mehr kommt.

Viele Grüße
Maxi
Dav1d
User
Beiträge: 1437
Registriert: Donnerstag 30. Juli 2009, 12:03
Kontaktdaten:

Man muss sich erstmal den Unterschied zwischen Funktionen und Modulen klar werden.
Ich denke ich habe es jetzt Verstanden.
Eher den Unterschied zwischen Modulen, Klassen und Funktionen
Asch so ist das gemeint - dann bau ich eine Schleife ein, die wartet bis nichts mehr kommt.
Du könntest den Datenblock spllitten z.B. bei '\n', dann jede Zeile prüfen ob sie auf '\r' endet, wenn nicht die Zeile "speichern" und dann mit der 1. Zeile des nächsten Datenblocks zusammen führen, wenn der Delimiter \n ist, musst du dir was anderes überlegen oder ein data.replace('\n', '\r\n') machen
the more they change the more they stay the same
maxi_king_333
User
Beiträge: 110
Registriert: Freitag 25. Dezember 2009, 03:42

Du könntest den Datenblock spllitten z.B. bei '\n', dann jede Zeile prüfen ob sie auf '\r' endet, wenn nicht die Zeile "speichern" und dann mit der 1. Zeile des nächsten Datenblocks zusammen führen, wenn der Delimiter \n ist, musst du dir was anderes überlegen oder ein data.replace('\n', '\r\n') machen
Da das alles von einem Linux gesendet wird gibt es nun mal nur ein \n.
Oder mischt da Python noch mit?
Kann ich das nicht durch eine Schleife Lösen?

Code: Alles auswählen

infostr = ""
tmpinfo = self.recv(8192)
while tmpinfo != "":
    infostr += tmpinfo
    tmpinfo = self.recv(8192)
Dav1d
User
Beiträge: 1437
Registriert: Donnerstag 30. Juli 2009, 12:03
Kontaktdaten:

Diese Schleife würde existieren bis die Verbindung beendet wird.

Code: Alles auswählen

buf = ''
while True:
    data = s.recv(2**14)
    if data:
        data = buf + data
        foo = False
        if data.endswith('\n'):
            foo = True
        splitted_data = data.splitlines()
        if not foo:
            buf = splitted_data.pop()
    else:
        break
wäre auch eine Möglichkeit

Code erweitert
the more they change the more they stay the same
maxi_king_333
User
Beiträge: 110
Registriert: Freitag 25. Dezember 2009, 03:42

Hi,

also Vielen Dank für Eure Hilfe.
Ich habe einiges umgeschrieben und mir ist aufgefallen, dass ich so manche Klasse lieber durch ein Modul ersetzen sollte.
Nun hoffe ich, dass Ihr Zeit dafür habt noch einmal einen Blick drüber zu werfen und zu schauen ob nun alles gut ist.
In der Parse Klasse habe ich die Events noch nicht in ein Dict verbaut, aber dafür mein neues Wissen gleich bei dem Modul notifyer angewendet.
Dort sind die Events in einem Dict verzeichnet.
Ein Problem habe ich dort allerdings noch - event_libnotify() funktioniert nicht.
Also ich bekomme keine Fehlermeldung oder so - es wird einfach nur kein Notify Ballon angezeigt.

Viele Grüße und nochmal Danke an Alle
Maxi
maxi_king_333
User
Beiträge: 110
Registriert: Freitag 25. Dezember 2009, 03:42

Hi,

libnotify funktioniert jetzt - ich habe erst noch libnotify-dev installieren müssen.
Kann ich das irgendwie umgehen, also so, dass man nicht extra die dev Pakete installieren muss?

Viele Grüße
Maxi
Leonidas
Python-Forum Veteran
Beiträge: 16025
Registriert: Freitag 20. Juni 2003, 16:30
Kontaktdaten:

maxi_king_333 hat geschrieben:Kann ich das irgendwie umgehen, also so, dass man nicht extra die dev Pakete installieren muss?
Also nachdem man die Libraries kompiliert hat, benötigt man die -dev-Pakete eigentlich nicht mehr.
My god, it's full of CARs! | Leonidasvoice vs (former) Modvoice
maxi_king_333
User
Beiträge: 110
Registriert: Freitag 25. Dezember 2009, 03:42

Hi,
Also nachdem man die Libraries kompiliert hat, benötigt man die -dev-Pakete eigentlich nicht mehr.
OK, Vielen Dank, war bestimmt irgendein anderer andere Fehler von mir .

Viele Grüße
Maxi
Antworten