Referenzen von Variablen Funktionen übergeben die noch nicht da sind. (Graphische Oberflächen)

[thread]17195[/thread]

Referenzen von Variablen Funktionen übergeben die noch nicht da sind.

Tags: perl5 GUI Tk Ähnliche Threads

Leser: 16

Articles: hide open all | hide show old branches

+8 replies
Gast unwichtig

2012-02-25 19:49
Hallo,
ich will folgendes in Tk umsetzen:
Ich habe einen Button der eine Progressbar loslaufen lässt, nach dem drücken auf den Button soll dieser deativiert werden, ist die Progressbar fertig soll er wieder aktiviert werden.

Jetzt ist mein Problem der -command - parameter. Dort müsste ich eine sub aufrufen die den button referenziert, obwohl der Button noch gar nicht erzeugt wurde.
Mache ich das nach der Erzeugung des Buttons per configure( -command => subaufruf) läuft die funktion sofort los, danach passiert nix mehr wenn man nochmal auf den Button drückt.

Hier mal der Code:
Code: (dl )

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

#!/usr/bin/perl use Tk; use Tk::ProgressBar; use Time::HiRes; #use warnings; #use strict; my $mw = MainWindow->new(-title => 'ProgressBar example'); $mw->configure(-width=>200, -height=>80); $mw->packPropagate(0); # jetzt wird auf die grösse gepackt my $progress = $mw->ProgressBar( -relief => 'sunken', -borderwidth => 2, -width => 24, -from => 0, -to => 100, -blocks => 20, -colors => [ 0, 'green', 50, 'yellow', 80, 'red'], -variable => \$percent_done )->pack(-fill => 'x', -padx=> 4, -pady=>4); sub go { $_[0]->configure( -state => 'disabled'); for ($i = 0; $i < 1000; $i++) { $percent_done = $i/10; print "$i\n"; #Time::HiRes::sleep(0.3); $mw->update; } $_[0]->configure( -state => 'active'); } $b = $mw->Button( -text => 'Go!', -width => 20 #-command => &go($b) # hier bräuchte ich eine referenz auf den Button )->pack(-side => 'bottom', -pady=>4, -padx=>4); $b->configure( -command => go($b) ); # läuft sofort los MainLoop;
Last edited: 2012-02-25 19:53:56 +0100 (CET)
- +7 replies
- Linuxer
  
  2012-02-25 19:58
  User since
  2006-01-27
  3890 Artikel
  HausmeisterIn
  Hi,
  
  Code (perl): (dl )
  
  my %whatever = ( -command => go($b) ); # läuft sofort los
  
  go() muss sofort loslaufen, weil Du es so programmiert hast.
  go() wird ausgeführt und die Rückgabe wird als "Value" zu "-command" verwendet.
  
  Richtiger in Deinem Sinne sollte es wahrscheinlich so sein:
  
  Code (perl): (dl )
  
  1 2 3 4 5 6 7
  
  # wenn nur go() ohne argumente aufgerufen werden soll # Referenz auf go() wird direkt verwendet my %whatever = ( -command => \&go ); # läuft sofort los # wenn Du Argumente mitgeben willst, kannst Du das so tun: # Referenz auf anonyme Subroutine, die ihrerseits go() mit Argument $b aufruft my %whatever = ( -command => sub { go($b) } ); # läuft sofort los
  
  edit: \&go() - () ==> \&go :/edit
  Last edited: 2012-02-25 20:52:34 +0100 (CET)
  meine Beiträge: I.d.R. alle Angaben ohne Gewähr und auf Linux abgestimmt!
  Die Sprache heisst Perl, nicht PERL. - Bitte Crossposts als solche kenntlich machen!
  - +6 replies
  - Gast unwichtig
    
    2012-02-25 20:44
    Ok danke, mein Fehler leuchtet mir jetzt ein, ich hätte die Funktion per Referenz angeben sollen, wie bei -variable \$percent_done.
    
    2012-02-25T18:58:34 Linuxer
    Hi,
    
    Code: (dl )
    
    1 2 3
    
    #wenn Du Argumente mitgeben willst, kannst Du das so tun: #Referenz auf anonyme Subroutine, die ihrerseits go() mit Argument $b aufruft my %whatever = ( -command => sub { go($b) } );
    
    ...wieso geht hier nicht auch:
    my %whatever = ( -command => \&go($b) );
    
    Wieso geht bei parameterlosen Funktionen die Referenz , warum bei
    Funktionen mit Parametern nicht, dürfte das nicht unabhängig von der Parameteranzahl sein, oder? Woran liegt das?
    Last edited: 2012-02-25 20:48:40 +0100 (CET)
    - +5 replies
    - Linuxer
      
      2012-02-25 20:58
      
      User since
      2006-01-27
      3890 Artikel
      HausmeisterIn
      
      Hi,
      
      1. ich hatte einen Bug in meinem obigen Code, ist nun gefixt; korrekt muss es heissen: \&go (also ohne Klammern)
      
      2. Wenn Du eine benannte Sub referenzieren willst, nimmmst Du den Namen der Sub, setzt \& davor, und das war es. Argumente, egal wie viele, können auf diese Art nicht ermittelt/übergeben werden. Wenn man das aus irgendeinem Grund braucht; muss man entweder a) eine weitere benannte Sub schreiben, die die erste mit Argumenten aufruft und dann die zweite Referenzieren; oder man verwendet b) sub {} und definiert eine anonyme Sub, die die gewünschte Sub mit Argumenten aufruft.
      meine Beiträge: I.d.R. alle Angaben ohne Gewähr und auf Linux abgestimmt!
      Die Sprache heisst Perl, nicht PERL. - Bitte Crossposts als solche kenntlich machen!
      - +4 replies
      - unwichtig
        
        2012-02-25 21:09
        
        User since
        2012-02-25
        2 Artikel
        BenutzerIn
        
        2012-02-25T19:58:15 Linuxer
        Hi,
        1. ich hatte einen Bug in meinem obigen Code, ist nun gefixt; korrekt muss es heissen: \&go (also ohne Klammern)
        
        Ja, habe ich gemerkt.
        
        Quote
        2. Wenn Du eine benannte Sub referenzieren willst, nimmmst Du den Namen der Sub, setzt \& davor, und das war es.
        
        Ja soweit alles klar.
        
        Quote
        Argumente, egal wie viele, können auf diese Art nicht ermittelt/übergeben werden. Wenn man das aus irgendeinem Grund braucht; muss man entweder a) eine weitere benannte Sub schreiben, die die erste mit Argumenten aufruft und dann die zweite Referenzieren; oder man verwendet b) sub {} und definiert eine anonyme Sub, die die gewünschte Sub mit Argumenten aufruft.
        
        Also das ist also normales Verhalten von Perl, wusste ich noch nicht.
        
        Irgendwo hatte ich auch mal sowas gesehen:
        
        Code: (dl )
        
        1 2 3 4 5 6
        
        use Tk; my $main = MainWindow->new; $main->Button(-text => 'End', -command => [$main => 'destroy'] )->pack; MainLoop;
        
        Was bewirken die eckigen Klammern? Ist das eine Kurzschreibweise für annonyme Funktionen?
        
        Irgendwie habe ich den Eindruck dass mir die Feinheiten von Perl
        nicht geläufig sind.
        Kennt jemand ein Buch oder Tutorial das solche Feinheiten ausnahmslos erklärt?
        Last edited: 2012-02-25 21:13:25 +0100 (CET)
        
        +3 replies
        
        Linuxer
        
        2012-02-25 21:31
        
        User since
        2006-01-27
        3890 Artikel
        HausmeisterIn
        
        Naja, ein Buch/Tutorial und dieses "ausnahmslos" ... schwer.
        
        Grundlage ist die http://perldoc.perl.org/, die eigentlich auch bei jeder Installation dabei sein sollte.
        In der perldoc sollten auch alle relevanten Features dargelegt werden. Man darf nur keine Angst vor englischer Dokumentation haben.
        
        Code (perl): (dl )
        
        1 2 3 4 5 6
        
        use Tk; my $main = MainWindow->new; $main->Button(-text => 'End', -command => [$main => 'destroy'] )->pack; MainLoop;
        
        Hier wird keine Sub-Referenz erzeugt. Die eckigen Klammern erzeugen eine Referenz auf einen anonymen Array, der zwei Argumente enthält, $main und 'destroy'.
        
        perldoc zum Thema Referenzen:
        http://perldoc.perl.org/perlref.html - Grundlagen Referenzen
        http://perldoc.perl.org/perldsc.html - Komplexe Datenstrukturen (auf Basis von Referenzen)
        meine Beiträge: I.d.R. alle Angaben ohne Gewähr und auf Linux abgestimmt!
        Die Sprache heisst Perl, nicht PERL. - Bitte Crossposts als solche kenntlich machen!
        
        +2 replies
        
        unwichtig
        
        2012-02-25 21:48
        
        User since
        2012-02-25
        2 Artikel
        BenutzerIn
        
        2012-02-25T20:31:26 Linuxer
        Hier wird keine Sub-Referenz erzeugt. Die eckigen Klammern erzeugen eine Referenz auf einen anonymen Array, der zwei Argumente enthält, $main und 'destroy'.
        
        Wusste nicht, dass sowas auch bei -command angegeben werden kann, sondern nur Funktionsaufrufe. Ich hätte da sowas erwartet: $main->destroy und kein assoziatives array.
        
        Quote
        perldoc zum Thema Referenzen: ...
        
        Genau sowas habe ich gesucht und auch noch per Perl-Version auswählbar! Danke!
        
        Linuxer
        
        2012-02-25 22:13
        
        User since
        2006-01-27
        3890 Artikel
        HausmeisterIn
        
        Das ist ein wenig Magie/Vodoo, was da gemacht wird.
        Da spielen noch weitere Möglichkeiten mit rein, die durch die Objekt-Orientierung geboten werden.
        Das hat nicht unbedingt mehr was mit den klassischen Datenstrukturen auf Referenz-Basis zu tun. Hier steckt mehr dahinter; aber ich muss gestehen, dass geht mir hier zu weit zu erläutern.
        
        Das ist kein assoziatives Array, sondern ein Array (bzw. entsprechende Referenzen).
        Ein assoziatives Array wäre in Perl der Hash; für den man wiederum eigene Klammern verwendet, um Referenzen auf anonyme Exemplare zu erzeugen.
        
        Code (perl): (dl )
        
        1 2
        
        my $hash_ref = { bla => 1 }; my $array_ref = [ 'bla', 1 ];
        
        Etwas besonders ist hier der =>; dieser Operator wird auch "fettes Komma" genannt.
        Der macht etwas mehr als das Komma, bleibt aber ein Komma.
        Für Hashes ist der Operator sehr schön, weil die Zuordnung der Schlüssel=>Wert Paare sehr schön dargestellt werden kann; aber letzten Endes werden Hashes mit Listen (mit gerader Anzahl Elementen) gefüttert, bei der eben das erste Element mit dem zweiten "verbunden" steht, das dritte mit dem vierten, usw.
        
        Code (perl): (dl )
        
        -command => [$main => 'destroy']
        
        Also ist das hier eine einfache Array-Referenz.
        Es wird aber eine besondere Beziehung zwischen $main und 'destroy' hervorgehoben.
        Die wird im Kontext der Tk-Module bedeutsam; daher mag ich das hier auch nicht näher versuchen zu beleuchten.
        (Dazu müsste ich mich selber in die Quellen von Tk einlesen...)
        
        Ein $main->destroy stellt so wieder einen direkten Aufruf der Methode 'destroy' des Objektes $main dar; das will man ja so auch nicht; es soll ja erst ausgeführt werden, wenn das entsprechende Ereignis ausgelöst wird (z.B. Button wird gedrückt).
        
        Weitere interessante Links dürftest Du dort finden: http://perl-tutorial.org/
        meine Beiträge: I.d.R. alle Angaben ohne Gewähr und auf Linux abgestimmt!
        Die Sprache heisst Perl, nicht PERL. - Bitte Crossposts als solche kenntlich machen!

View all threads created 2012-02-25 19:49.