Geek asks and answers

No event loop graphics in Perl Plus X Window?

On the Apple II BASIC in the 1980s, you would use “HGR” to go to the screen, “HCOLOR” set the color, and “HPLOT” would display the dots. You can also manipulate screen byte data, and you do not have to transfer program control to any event handler. This ridiculous rudimentary functionality seems to be missing today in every language and in every library.

So, I wrote a small library to do this in C using the X Window API: HGR (x, y) puts the XWindow, HCOLOR (i) sets the color, and HPLOT (i, j) displays the dot, plus you extract the bitmap of the window and you can change it and display the changed thing. It was not easy, and I do not want to repeat it again.

I am using Perl for some things now, and I need a tool for Perl, something where you can call a routine that preferably returns without creating a new thread, displaying a window where you can add graphic material to windows and request events, when your program is like this. This is the functionality of the 80s BASIC, so it should not be difficult. But the tools that I saw did not do this:

  • GD: As far as I could see, it makes image files, not image windows. It seems you need to transfer it to another program.
  • Gtk2: I have to unlock a separate thread to catch events, otherwise it will not display a window. I don’t want to wag anything, and I basically don’t care about any events, unless I specifically ask for later to see things gathered in the queue.
  • Qt : here you must also give control to the event handler, without passing, without displaying. In the C ++ version, I could get Qt to render and draw without a handover.
  • PerlTk: again with a stupid handover.
  • OpenGL: Here I do not know how to catch X Window events, such as keystrokes, when I want to see what happened.

- , XWindow , GUI, , , , ? API- X Window Perl, , C, C Perl . . , , . HGR Perl ?

, , , . , , C. , .

+5
4

GUI- . tk

#!/usr/bin/perl --
use strict;
use warnings;
use Tk;
my $mw = tkinit();
my $ca = $mw->Canvas(
    background => 'white'
)->pack(qw/-expand 1 -fill both /);
$mw->geometry( '500x600+10+10' );
for my $cc (
    { red   => \&red, green => \&der, blue => \&erd },
    { green => \&red, red   => \&der, blue => \&erd },
    { green => \&red, blue  => \&der, red  => \&erd },
  )
{
    $ca->delete('all');
    my %color = %$cc;

    for my $fill ( keys %color ) {
        my $red = $color{$fill};
        for my $t ( 10 .. 220 ) {
            my $d = 0.1;
            my ( $x, $y ) = $red->( $t, 0.1 );
            $_ += 250 for $x, $y;
            $ca->createOval(
                $x, $y,
                ( $t * 2 * $d ) + $x,
                ( $t * 2 * $d ) + $y,
                -fill => $fill,
            );
            $mw->update;
            select undef, undef, undef, 0.001;
        }
        $mw->update;
    }
}

Tk::DoOneEvent(0) while Tk::MainWindow->Count; ## MainLoop;
exit 0;

sub red {
    my ( $t, $d ) = @_;
    my $x = $t * sin( $t * $d );
    my $y = $t * cos( $t * $d );
    $x, $y;
}

sub der {
    my ( $t, $d ) = @_;
    my $x = $t * sin( $t * $d );
    my $y = $t * cos( $t * 2 * $d );
    $x, $y;
}

sub erd {
    my ( $t, $d ) = @_;
    my $x = $t * sin( $t * 2 * $d );
    my $y = $t * cos( $t * $d );
    $x, $y;
}

__END__

Gtk2 Wx : //..., , , MainLoop ,

wxTheApp->Dispatch       while wxTheApp->Pending;
Gtk2->main_iteration     while Gtk2->events_pending;
+4

Perl Inline:: C. C Perl. C "AUTOWRAP" . , Inline:: C XS.

+1

, , , , , App::Prima::REPL. Perl/PDL, Prima . , REPL , REPL . , Prima , , REPL, REPL . - !

0

I think you missed out on a plot like GLib/ to some extent GTK. Very easy to handle GTKwithout overlay; in fact, if you are doing something like a fork, you are probably doing it wrong. What you describe should be easily possible with GTK.

0
source

More articles:


All Articles