home *** CD-ROM | disk | FTP | other *** search
/ Chip 2000 May / Chip_2000-05_cd1.bin / zkuste / Perl / ActivePerl-5.6.0.613.msi / 䆊䌷䈹䈙䏵-䞅䞆䞀㡆䞃䄦䠥 / _f1f00f5767e9d2216eef3301417c4349 < prev    next >
Text File  |  2000-03-23  |  19KB  |  434 lines
  1.  
  2. <HTML>
  3. <HEAD>
  4. <TITLE>perl/Tk - Writing Tk applications in perl5.</TITLE>
  5. <LINK REL="stylesheet" HREF="../../../Active.css" TYPE="text/css">
  6. <LINK REV="made" HREF="mailto:">
  7. </HEAD>
  8.  
  9. <BODY>
  10. <TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>
  11. <TR><TD CLASS=block VALIGN=MIDDLE WIDTH=100% BGCOLOR="#cccccc">
  12. <STRONG><P CLASS=block> perl/Tk - Writing Tk applications in perl5.</P></STRONG>
  13. </TD></TR>
  14. </TABLE>
  15.  
  16. <A NAME="__index__"></A>
  17. <!-- INDEX BEGIN -->
  18.  
  19. <UL>
  20.  
  21.     <LI><A HREF="#name">NAME</A></LI><LI><A HREF="#supportedplatforms">SUPPORTED PLATFORMS</A></LI>
  22.  
  23.     <LI><A HREF="#description">DESCRIPTION</A></LI>
  24.     <LI><A HREF="#some background">Some background</A></LI>
  25.     <LI><A HREF="#first requirements">First requirements</A></LI>
  26.     <LI><A HREF="#item creation">Item creation</A></LI>
  27.     <LI><A HREF="#standard tk types">Standard Tk types</A></LI>
  28.     <LI><A HREF="#variables and callback routines">Variables and callback routines</A></LI>
  29.     <LI><A HREF="#the packer. grouping and frames.">The packer.  Grouping and frames.</A></LI>
  30.     <LI><A HREF="#more than one window">More than one window</A></LI>
  31.     <LI><A HREF="#more callbacks">More callbacks</A></LI>
  32.     <LI><A HREF="#canvases and tags">Canvases and tags</A></LI>
  33. </UL>
  34. <!-- INDEX END -->
  35.  
  36. <HR>
  37. <P>
  38. <H1><A NAME="name">NAME</A></H1>
  39. <P>perl/Tk - Writing Tk applications in perl5.</P>
  40. <P>
  41. <HR>
  42. <H1><A NAME="supportedplatforms">SUPPORTED PLATFORMS</A></H1>
  43. <UL>
  44. <LI>Linux</LI>
  45. <LI>Solaris</LI>
  46. <LI>Windows</LI>
  47. </UL>
  48. <HR>
  49. <H1><A NAME="description">DESCRIPTION</A></H1>
  50. <P>This manual page is for beginners.  It assumes you know some perl,
  51. and have got perl+Tk running.
  52. Please run the 'widget' demo before reading this text; it will teach you
  53. the various widget types supported by Tk.</P>
  54. <P>
  55. <HR>
  56. <H1><A NAME="some background">Some background</A></H1>
  57. <P>Tk GUI programming is event-driven.  (This may already be familiar to you.)
  58. In event-driven programs, the main GUI loop is outside of the user program
  59. and inside the GUI library.  This loop will watch all events of interest,
  60. and activate the correct handler procedures to handle these events.
  61. Some of these handler procedures may be user-supplied; others will be part
  62. of the library.</P>
  63. <P>For a programmer, this means that you're not watching what is happening;
  64. instead, you are requested by the toolkit to perform actions whenever
  65. necessary.
  66. So, you're not watching for 'raise window / close window / redraw window'
  67. requests, but you tell the toolkit which routine will handle such cases,
  68. and the toolkit will call the procedures when required.</P>
  69. <P>
  70. <HR>
  71. <H1><A NAME="first requirements">First requirements</A></H1>
  72. <P>Any perl program that uses Tk needs to include <CODE>use Tk</CODE>.
  73. A program should also use <CODE>use strict</CODE> and the <STRONG>-w</STRONG> switch to ensure
  74. the program is working without common errors.</P>
  75. <P>Any Tk application starts by creating the Tk main window.  You then create
  76. items inside the main window, or create new windows, before starting the
  77. mainloop.
  78. (You can also create more items and windows while you're running.)
  79. The items will be shown on the display after you <A HREF="../../../lib/Pod/perlfunc.html#item_pack"><CODE>pack</CODE></A> them;
  80. more info on this later.
  81. Then you do a Tk mainloop; this will start the GUI and handle all events.
  82. That's your application.
  83. A trivial one-window example is show below:</P>
  84. <PRE>
  85.         #! /usr/bin/perl5 -w</PRE>
  86. <PRE>
  87.         use strict;
  88.         use Tk;</PRE>
  89. <PRE>
  90.         my $main = MainWindow->new;
  91.         $main->Label(-text => 'Hello, world!')->pack;
  92.         $main->Button(-text => 'Quit',
  93.                       -command => [$main => 'destroy']
  94.                       )->pack;
  95.         MainLoop;</PRE>
  96. <P>Please run this example.  It shows you two items types also shown in the
  97. widget demo; it also shows you how items are created and packed.
  98. Finally, note the typical Tk style using <CODE>-option</CODE> => <CODE>value</CODE> pairs.</P>
  99. <P>
  100. <HR>
  101. <H1><A NAME="item creation">Item creation</A></H1>
  102. <P>Tk windows and widgets are hierarchical, i.e. one includes one or more
  103. others.  You create the first Tk window using <CODE>MainWindow->new</CODE>.
  104. This returns a window handle, assigned to <CODE>$main</CODE> in the example above.
  105. Keep track of the main handle.</P>
  106. <P>You can use any Tk handle to create sub-items within the window or widget.
  107. This is done by calling the Tk constructor method on the variable.
  108. In the example above, the <CODE>Label</CODE> method called from <CODE>$main</CODE> creates a
  109. label widget inside the main window.  In the constructor call, you can specify
  110. various options; you can later add or change options for any widget
  111. using the <CODE>configure</CODE> method, which takes the same parameters as the
  112. constructor.
  113. The one exception to the hierarchical structure is the <A HREF="#item_Toplevel"><CODE>Toplevel</CODE></A> constructor,
  114. which creates a new outermost window.</P>
  115. <P>After you create any widget, you must render it by calling <A HREF="../../../lib/Pod/perlfunc.html#item_pack"><CODE>pack</CODE></A>.  (This
  116. is not entirely true; more info later).  If you do not need to refer to
  117. the widget after construction and packing, call <A HREF="../../../lib/Pod/perlfunc.html#item_pack"><CODE>pack</CODE></A> off the constructor
  118. results, as shown for the label and button in the example above.
  119. Note that the result of the compound call is the result of <A HREF="../../../lib/Pod/perlfunc.html#item_pack"><CODE>pack</CODE></A>,
  120. which is a valid Tk handle.</P>
  121. <P>Windows and widgets are deleted by calling <CODE>destroy</CODE> on them;
  122. this will delete and un-draw the widget and all its children.</P>
  123. <P>
  124. <HR>
  125. <H1><A NAME="standard tk types">Standard Tk types</A></H1>
  126. <DL>
  127. <DT><STRONG><A NAME="item_Button">Button</A></STRONG><BR>
  128. <DD>
  129. <DT><STRONG><A NAME="item_Radiobutton">Radiobutton</A></STRONG><BR>
  130. <DD>
  131. <DT><STRONG><A NAME="item_Checkbutton">Checkbutton</A></STRONG><BR>
  132. <DD>
  133. <DT><STRONG><A NAME="item_Listbox">Listbox</A></STRONG><BR>
  134. <DD>
  135. <DT><STRONG><A NAME="item_Scrollbar">Scrollbar</A></STRONG><BR>
  136. <DD>
  137. <DT><STRONG><A NAME="item_Entry">Entry</A></STRONG><BR>
  138. <DD>
  139. <DT><STRONG><A NAME="item_Text">Text</A></STRONG><BR>
  140. <DD>
  141. <DT><STRONG><A NAME="item_Canvas">Canvas</A></STRONG><BR>
  142. <DD>
  143. <DT><STRONG><A NAME="item_Frame">Frame</A></STRONG><BR>
  144. <DD>
  145. <DT><STRONG><A NAME="item_Toplevel">Toplevel</A></STRONG><BR>
  146. <DD>
  147. <DT><STRONG><A NAME="item_Scale">Scale</A></STRONG><BR>
  148. <DD>
  149. <DT><STRONG><A NAME="item_Menu">Menu</A></STRONG><BR>
  150. <DD>
  151. <DT><STRONG><A NAME="item_Menubutton">Menubutton</A></STRONG><BR>
  152. <DD>
  153. </DL>
  154. <P>
  155. <HR>
  156. <H1><A NAME="variables and callback routines">Variables and callback routines</A></H1>
  157. <P>Most graphical interfaces are used to set up a set of values and conditions,
  158. and then perform the appropriate action.  The Tk toolkit is different
  159. from your average text-based prompting or menu driven system in that you do
  160. not collect settings yourself, and decide on an action based on an
  161. input code; instead, you leave these
  162. values to your toolkit and only get them when the action is performed.</P>
  163. <P>So, where a traditional text-based system would look like this:
  164. (yes, this is obviously dumb code)</P>
  165. <PRE>
  166.         #! /usr/bin/perl5 -w</PRE>
  167. <PRE>
  168.         use strict;</PRE>
  169. <PRE>
  170.         print "Please type a font name\n";
  171.         my $font = <>; chomp $font;
  172.         # Validate font</PRE>
  173. <PRE>
  174.         print "Please type a file name\n";
  175.         my $filename = <>; chomp $filename;
  176.         # Validate filename</PRE>
  177. <PRE>
  178.         print "Type <1> to fax, <2> to print\n";
  179.         my $option = <>; chomp $option;
  180.         if ($option eq 1) {
  181.             print "Faxing $filename in font $font\n";
  182.         } elsif ($option eq 2) {
  183.             print "Now sending $filename to printer in font $font\n";
  184.         }</PRE>
  185. <P>The (slightly larger) example below shows how to do this is Tk.
  186. Note the use of callbacks.  Note, also, that Tk handles the values, and
  187. the subroutine uses <CODE>get</CODE> to get at the values.
  188. If a user changes his mind and wants to change the font again,
  189. the application never notices; it's all handled by Tk.</P>
  190. <PRE>
  191.         #! /usr/bin/perl5 -w</PRE>
  192. <PRE>
  193.         use strict;
  194.         use Tk;</PRE>
  195. <PRE>
  196.         my $main = MainWindow->new;
  197.         $main->Label(-text => 'Print file')->pack;
  198.         my $font = $main->Entry(-width => 10);
  199.         $font->pack;
  200.         my $filename = $main->Entry(-width => 10);
  201.         $filename->pack;
  202.         $main->Button(-text => 'Fax',
  203.                       -command => sub{do_fax($filename, $font)}
  204.                       )->pack;
  205.         $main->Button(-text => 'Print',
  206.                       -command => sub{do_print($filename, $font)}
  207.                       )->pack;
  208.         MainLoop;</PRE>
  209. <PRE>
  210.         sub do_fax {
  211.             my ($file, $font) = @_;
  212.             my $file_val = $file->get;
  213.             my $font_val = $font->get;
  214.             print "Now faxing $file_val in $font_val\n";
  215.         }</PRE>
  216. <PRE>
  217.         sub do_print {
  218.             my ($file, $font) = @_;
  219.             my $file_val = $file->get;
  220.             my $font_val = $font->get;
  221.             print "Sending file $file_val to printer in $font_val\n";
  222.         }</PRE>
  223. <P>
  224. <HR>
  225. <H1><A NAME="the packer. grouping and frames.">The packer.  Grouping and frames.</A></H1>
  226. <P>In the examples above, you must have noticed the <A HREF="../../../site/lib/Tk/pack.html">pack</A> calls.
  227. This is one of the more complicated parts of Tk.  The basic idea
  228. is that any window or widget should be subject to a Tk widget placement manager;
  229. the <EM>packer</EM> is one of the placement managers.</P>
  230. <P>The actions of the packer are rather simple: when applied
  231. to a widget, the packer positions that widget on the indicated position
  232. within the remaining space in its parent.  By default, the position is
  233. on top; this means the next items will be put below.  You can also
  234. specify the left, right, or bottom positions.  Specify position
  235. using <STRONG>-side => 'right'</STRONG>.</P>
  236. <P>Additional packing parameters specify the behavior of the widget when
  237. there is some space left in the frame or when the window size is
  238. increased.  If widgets should maintain a fixed size, specify nothing;
  239. this is the default.  For widgets that you want to fill up the current
  240. horizontal space, specify <STRONG>-fill => 'x'</STRONG>, <STRONG>y</STRONG>, or <STRONG>both</STRONG>; for
  241. widgets that should grow, specify <STRONG>-expand => 1</STRONG>.  These
  242. parameters are not shown in the example below; see the widget demo.</P>
  243. <P>If you want to group some items within a window that have a different
  244. packing order than others, you can include them in a Frame.  This is a
  245. do-nothing window type that is meant for packing (and to play games
  246. with borders and colors).</P>
  247. <P>The example below shows the use of pack and frames:</P>
  248. <PRE>
  249.         #! /usr/bin/perl5 -w</PRE>
  250. <PRE>
  251.         use strict;
  252.         use Tk;</PRE>
  253. <PRE>
  254.         # Take top, the bottom -> now implicit top is in the middle
  255.         my $main = MainWindow->new;
  256.         $main->Label(-text => 'At the top (default)')->pack;
  257.         $main->Label(-text => 'At the bottom')->pack(-side => 'bottom');
  258.         $main->Label(-text => 'The middle remains')->pack;</PRE>
  259. <PRE>
  260.         # Since left and right are taken, bottom will not work...
  261.         my $top1 = $main->Toplevel;
  262.         $top1->Label(-text => 'Left')->pack(-side => 'left');
  263.         $top1->Label(-text => 'Right')->pack(-side => 'right');
  264.         $top1->Label(-text => '?Bottom?')->pack(-side => 'bottom');</PRE>
  265. <PRE>
  266.         # But when you use frames, things work quite alright
  267.         my $top2 = $main->Toplevel;
  268.         my $frame = $top2->Frame;
  269.         $frame->pack;
  270.         $frame->Label(-text => 'Left2')->pack(-side => 'left');
  271.         $frame->Label(-text => 'Right2')->pack(-side => 'right');
  272.         $top2->Label(-text => 'Bottom2')->pack(-side => 'bottom');</PRE>
  273. <PRE>
  274.         MainLoop;</PRE>
  275. <P>
  276. <HR>
  277. <H1><A NAME="more than one window">More than one window</A></H1>
  278. <P>Most real applications require more than one window.  As you read before,
  279. you can create more outermost windows by using Toplevel.  Each window
  280. is independent; destroying a toplevel window does not affect the others as
  281. long as they are not a child of the closed toplevel.
  282. Exiting the main window will end the application.
  283. The example below shows a trivial three-window application:</P>
  284. <PRE>
  285.         #! /usr/bin/perl5 -w</PRE>
  286. <PRE>
  287.         use strict;
  288.         use Tk;</PRE>
  289. <PRE>
  290.         my $main = MainWindow->new;
  291.         fill_window($main, 'Main');
  292.         my $top1 = $main->Toplevel;
  293.         fill_window($top1, 'First top-level');
  294.         my $top2 = $main->Toplevel;
  295.         fill_window($top2, 'Second top-level');
  296.         MainLoop;</PRE>
  297. <PRE>
  298.         sub fill_window {
  299.             my ($window, $header) = @_;
  300.             $window->Label(-text => $header)->pack;
  301.             $window->Button(-text => 'close',
  302.                             -command => [$window => 'destroy']
  303.                             )->pack(-side => 'left');
  304.             $window->Button(-text => 'exit',
  305.                             -command => [$main => 'destroy']
  306.                             )->pack(-side => 'right');
  307.         }</PRE>
  308. <P>
  309. <HR>
  310. <H1><A NAME="more callbacks">More callbacks</A></H1>
  311. <P>So far, all callback routines shown called a user procedure.
  312. You can also have a callback routine call another Tk routine.
  313. This is the way that scroll bars are implemented: scroll-bars
  314. can call a Tk item or a user procedure, whenever their position
  315. has changed.  The Tk item that has a scrollbar attached calls the
  316. scrollbar when its size or offset has changed.  In this way,
  317. the items are linked.  You can still ask a scrollbar's position,
  318. or set it by hand - but the defaults will be taken care of.</P>
  319. <P>The example below shows a listbox with a scroll bar.  Moving
  320. the scrollbar moves the listbox.  Scanning a listbox (dragging
  321. an item with the left mouse button) moves the scrollbar.</P>
  322. <PRE>
  323.         #! /usr/bin/perl5 -w</PRE>
  324. <PRE>
  325.         use strict;
  326.         use Tk;</PRE>
  327. <PRE>
  328.         my $main = MainWindow->new;
  329.         my $box = $main->Listbox(-relief => 'sunken',
  330.                                  -width => -1, # Shrink to fit
  331.                                  -height => 5,
  332.                                  -setgrid => 1);
  333.         my @items = qw(One Two Three Four Five Six Seven
  334.                        Eight Nine Ten Eleven Twelve);
  335.         foreach (@items) {
  336.            $box->insert('end', $_);
  337.         }
  338.         my $scroll = $main->Scrollbar(-command => ['yview', $box]);
  339.         $box->configure(-yscrollcommand => ['set', $scroll]);
  340.         $box->pack(-side => 'left', -fill => 'both', -expand => 1);
  341.         $scroll->pack(-side => 'right', -fill => 'y');</PRE>
  342. <PRE>
  343.         MainLoop;</PRE>
  344. <P>
  345. <HR>
  346. <H1><A NAME="canvases and tags">Canvases and tags</A></H1>
  347. <P>One of the most powerful window types in Tk is the Canvas window.
  348. In a canvas window, you can draw simple graphics and include
  349. other widgets.  The canvas area may be larger than the visible window,
  350. and may then be scrolled.  Any item you draw on the canvas has its own id,
  351. and may optionally have one or more <EM>tags</EM>.  You may refer to any
  352. item by its id, and may refer to any group of items by a common tag;
  353. you can move, delete, or change groups of items using these tags,
  354. and you can <EM>bind</EM> actions to tags.  For a properly designed (often
  355. structured) canvas, you can specify powerful actions quite simply.</P>
  356. <P>In the example below, actions are bound to circles (single click)
  357. and blue items (double-click); obviously, this can be extended to any
  358. tag or group of tags.</P>
  359. <PRE>
  360.         #! /usr/bin/perl5 -w</PRE>
  361. <PRE>
  362.         use strict;
  363.         use Tk;</PRE>
  364. <PRE>
  365.         # Create main window and canvas
  366.         my $main = MainWindow->new;
  367.         my $canvas = $main->Canvas;
  368.         $canvas->pack(-expand => 1, -fill => 'both');</PRE>
  369. <PRE>
  370.         # Create various items
  371.         create_item($canvas, 1, 1, 'circle', 'blue', 'Jane');
  372.         create_item($canvas, 4, 4, 'circle', 'red', 'Peter');
  373.         create_item($canvas, 4, 1, 'square', 'blue', 'James');
  374.         create_item($canvas, 1, 4, 'square', 'red', 'Patricia');</PRE>
  375. <PRE>
  376.         # Single-clicking with left on a 'circle' item invokes a procedure
  377.         $canvas->bind('circle', '<1>' => sub {handle_circle($canvas)});
  378.         # Double-clicking with left on a 'blue' item invokes a procedure
  379.         $canvas->bind('blue', '<Double-1>' => sub {handle_blue($canvas)});
  380.         MainLoop;</PRE>
  381. <PRE>
  382.         # Create an item; use parameters as tags (this is not a default!)
  383.         sub create_item {
  384.             my ($can, $x, $y, $form, $color, $name) = @_;</PRE>
  385. <PRE>
  386.             my $x2 = $x + 1;
  387.             my $y2 = $y + 1;
  388.             my $kind;
  389.             $kind = 'oval' if ($form eq 'circle');
  390.             $kind = 'rectangle' if ($form eq 'square');
  391.             $can->create(($kind, "$x" . 'c', "$y" . 'c',
  392.                           "$x2" . 'c', "$y2" . 'c'),
  393.                          -tags => [$form, $color, $name],
  394.                          -fill => $color);
  395.         }</PRE>
  396. <PRE>
  397.         # This gets the real name (not current, blue/red, square/circle)
  398.         # Note: you'll want to return a list in realistic situations...
  399.         sub get_name {
  400.             my ($can) = @_;
  401.             my $item = $can->find('withtag', 'current');
  402.             my @taglist = $can->gettags($item);
  403.             my $name;
  404.             foreach (@taglist) {
  405.                 next if ($_ eq 'current');
  406.                 next if ($_ eq 'red' or $_ eq 'blue');
  407.                 next if ($_ eq 'square' or $_ eq 'circle');
  408.                 $name = $_;
  409.                 last;
  410.             }
  411.             return $name;
  412.         }</PRE>
  413. <PRE>
  414.         sub handle_circle {
  415.             my ($can) = @_;
  416.             my $name = get_name($can);
  417.             print "Action on circle $name...\n";
  418.         }</PRE>
  419. <PRE>
  420.         sub handle_blue {
  421.             my ($can) = @_;
  422.             my $name = get_name($can);
  423.             print "Action on blue item $name...\n";
  424.         }</PRE>
  425. <TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>
  426. <TR><TD CLASS=block VALIGN=MIDDLE WIDTH=100% BGCOLOR="#cccccc">
  427. <STRONG><P CLASS=block> perl/Tk - Writing Tk applications in perl5.</P></STRONG>
  428. </TD></TR>
  429. </TABLE>
  430.  
  431. </BODY>
  432.  
  433. </HTML>
  434.