Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Username: Password: oppure
Cerchio3p - tela.rb

tela.rb

Caricato da: Poggi Marco
Scarica il programma completo

  1. require "tk"
  2.  
  3.  
  4. module Foglio
  5.        
  6.         class Punto
  7.  
  8.                 def initialize()
  9.                         @x=0.0
  10.                         @y=0.0
  11.                         @stato=true
  12.                 end
  13.                
  14.                 def copiaValoriIn(altro)
  15.                         altro.x=@x
  16.                         altro.y=@y
  17.                         altro.stato=@stato
  18.                 end
  19.                
  20.                 def distanza(altro)
  21.                         if @stato and altro.stato
  22.                                 dx=altro.x - @x
  23.                                 dy=altro.y - @y
  24.                                 return (dx * dx + dy * dy) ** 0.5
  25.                         end
  26.                         return 0.0
  27.                 end
  28.                
  29.                 def x=(valore)
  30.                         @x=valore.to_f()
  31.                 end
  32.                
  33.                 def x()
  34.                         return @x
  35.                 end
  36.                
  37.                 def y=(valore)
  38.                         @y=valore.to_f()
  39.                 end
  40.                
  41.                 def y()
  42.                         return @y
  43.                 end
  44.                
  45.                 def stato=(valore)
  46.                         @stato=valore
  47.                 end
  48.                
  49.                 def stato()
  50.                         return @stato
  51.                 end
  52.         end
  53.        
  54.         class Segmento
  55.        
  56.                 def initialize()
  57.                         @inizio=Punto.new()
  58.                         @fine=Punto.new()
  59.                 end
  60.                
  61.                 def lunghezza()
  62.                         return @inizio.distanza(@fine)
  63.                 end
  64.                
  65.                 def passo()
  66.                         @fine.copiaValoriIn(@inizio)
  67.                 end
  68.                
  69.                 attr_accessor :inizio
  70.                 attr_accessor :fine
  71.        
  72.         end
  73.        
  74.         class Pennino
  75.        
  76.                 def initialize()
  77.                         @spessore='1'
  78.                         @colore='#808080'
  79.                 end
  80.        
  81.                 attr_accessor :spessore
  82.                 attr_accessor :colore
  83.        
  84.         end
  85.  
  86.         class Grafica
  87.        
  88.                 def initialize(posto)
  89.                         @foglio=posto
  90.                         @scale=Punto.new()
  91.                         @limitiFoglio=Segmento.new()
  92.                         @penna=Pennino.new()
  93.                         isoDimensiona(-10.0, -7.5, 10.0)
  94.                 end
  95.                
  96.                 def isoDimensiona(x0, y0, xf)
  97.                         delta=xf - x0
  98.                         @scale.x=@foglio['width'] / delta
  99.                         @scale.y=@scale.x
  100.                         @limitiFoglio.inizio.x=x0
  101.                         @limitiFoglio.inizio.y=y0
  102.                         @limitiFoglio.fine.x=xf
  103.                         @limitiFoglio.fine.x=(@foglio['height'] / @scale.y) + @limitiFoglio.inizio.y
  104.                 end
  105.                
  106.                 def assi(colore)
  107.                         origine=trasla(Punto.new())
  108.                         TkcLine.new(@foglio, 0, origine.y.to_i(), @foglio['width'], origine.y.to_i(), 'width' => @penna.spessore, 'fill' => colore)
  109.                         TkcLine.new(@foglio, origine.x.to_i(), 0, origine.x.to_i(), @foglio['height'], 'width' => @penna.spessore, 'fill' => colore)
  110.                 end
  111.                
  112.                 def cancella(sfondo)
  113.                         TkcRectangle.new(@foglio, 0, 0, @foglio['width'], @foglio['height'], 'outline' => sfondo, 'fill' => sfondo)
  114.                 end
  115.                
  116.                 def linea(tratto)
  117.                         if tratto.inizio.stato and tratto.fine.stato
  118.                                 lato=Segmento.new()
  119.                                 lato.inizio=trasla(tratto.inizio)
  120.                                 lato.fine=trasla(tratto.fine)
  121.                                 TkcLine.new(@foglio, lato.inizio.x.to_i(), lato.inizio.y.to_i(), lato.fine.x.to_i(), lato.fine.y.to_i(), 'width' => @penna.spessore, 'fill' => @penna.colore)
  122.                         end
  123.                 end
  124.                
  125.                 def cerchio(centro, raggio)
  126.                         lato = Segmento.new
  127.                         lato.inizio.x = centro.x + raggio
  128.                         lato.inizio.y = centro.y
  129.                         alfa = 0
  130.                         omega = Math::PI * 2.0
  131.                         passo=(omega - alfa) / 500.0
  132.                         while alfa <= omega
  133.                                 alfa += passo
  134.                                 lato.fine.x = centro.x + raggio * Math.cos(alfa)
  135.                                 lato.fine.y = centro.y + raggio * Math.sin(alfa)
  136.                                 linea(lato)
  137.                                 lato.passo
  138.                         end
  139.                 end
  140.                
  141.                 def trasla(coordinata)
  142.                         p=Punto.new()
  143.                         p.x=@scale.x * (coordinata.x - @limitiFoglio.inizio.x)
  144.                         p.y=@foglio['height'] - @scale.y * (coordinata.y - @limitiFoglio.inizio.y)
  145.                         if p.x < 0
  146.                                 p.x = -1.0
  147.                         end
  148.                         if p.x > @foglio['width']
  149.                                 p.x=@foglio['width'] + 1.0
  150.                         end
  151.                         if p.y < 0
  152.                                 p.y = -1.0
  153.                         end
  154.                         if p.y > @foglio['height']
  155.                                 p.y=@foglio['height']
  156.                         end
  157.                         return p
  158.                 end
  159.                
  160.                 attr_accessor :penna
  161.                
  162.         end
  163. end