#! /usr/bin/wishx -f
# ============================= DEFINITIONS ============================
set monitor_gamma 1.6
set preview_res 40

set printer_res_x 360
set printer_res_y 360

set fax_res_x 200
set fax_res_y 200

set viewer [concat " | xv - "]
set printer { | lpr }
set fax { faxspool }


# ============================  READ INQUIRY  ==========================

exec umax-cli -I 2>._inquiry

set phys_width  [exec grep "^FB maximum scan width" ._inquiry | cut -f2 -d: | cut -f1 -di]
set phys_height [exec grep "^FB maximum scan length" ._inquiry | cut -f2 -d: | cut -f1 -di]

# =============================== CALCULATIONS =======================

set preview_width  [expr $phys_width  * $preview_res]
set preview_height [expr $phys_height * $preview_res]

# =============================== SET OUTFIT ===========================

wm title . {umaX-scan V.0.2, 20.03.97 by Oliver Rauch}

# =========================== AREA 1 ====================================
frame .area1


# ======= SCAN TYPE ========

frame .area1.scanmode -relief raised -borderwidth 2 
label .area1.scanmode.label -text "  Scan Type  " -relief raised -borderwidth 2


radiobutton .area1.scanmode.rgb \
  -value "-r" -variable scanmode \
  -text "RGB" \
  -relief flat \
  -command set_rgb
if { [catch { exec grep "^color mode" ._inquiry} ] } \
{ .area1.scanmode.halftone configure -state disabled }

radiobutton .area1.scanmode.grey \
  -value "-g" -variable scanmode \
  -text "Grey" \
  -relief flat \
  -command set_grey
if { [catch { exec grep "^grey mode" ._inquiry} ] } \
{ .area1.scanmode.grey configure -state disabled }

radiobutton .area1.scanmode.halftone \
  -value "-d" -variable scanmode \
  -text "Halftone" \
  -relief flat \
  -state normal \
  -command set_halftone
if { [catch { exec grep "^halftone mode" ._inquiry} ] } \
{ .area1.scanmode.halftone configure -state disabled }

radiobutton .area1.scanmode.lineart \
  -value "-l" -variable scanmode \
  -text "Lineart" \
  -relief flat \
  -command set_lineart
if { [catch { exec grep "^lineart mode" ._inquiry} ] } \
{ .area1.scanmode.lineart configure -state disabled }

set scanmode {-r}
pack .area1.scanmode.label \
     .area1.scanmode.rgb \
     .area1.scanmode.grey \
     .area1.scanmode.halftone \
     .area1.scanmode.lineart \
     -side top -anchor w  
pack .area1.scanmode -fill x 


# ======== DISTANCE =======

frame .area1.dist1
pack .area1.dist1 -pady 5

# ======== REVERSE ==========


frame .area1.reverse -relief raised -borderwidth 2 
checkbutton .area1.reverse.button -text {reverse} \
            -variable reverse_bit \
            -command \
	    {
	      set reverse ""
	      if {$reverse_bit} { set reverse "-i" }
	    }

pack .area1.reverse .area1.reverse.button -side top -anchor w -fill x


# ======== DISTANCE =======

frame .area1.dist2
pack .area1.dist2 -pady 5

# ======== SCANNER MODULES =======


frame .area1.scanmodule -relief raised -borderwidth 2 
label .area1.scanmodule.label -text "Scan Module " -relief raised -borderwidth 2

radiobutton .area1.scanmodule.fb \
  -value "" -variable scanmodule \
  -text flatbed \
  -relief flat 
set scanmodule ""

radiobutton .area1.scanmodule.adf \
  -value "--ADF" -variable scanmodule \
  -text ADF \
  -relief flat 
if { [catch { exec grep "..: automatic document feeder (ADF)" ._inquiry} ] } \
{ .area1.scanmodule.adf configure -state disabled }

radiobutton .area1.scanmodule.uta \
  -value "--UTA" -variable scanmodule \
  -text UTA \
  -relief flat 
if { [catch { \
  exec grep "^UTA (transparency).............: available" ._inquiry} ] } \
{ .area1.scanmodule.uta configure -state disabled }

pack .area1.scanmodule.label \
     .area1.scanmodule.fb \
     .area1.scanmodule.adf \
     .area1.scanmodule.uta \
     -side top -anchor w  

pack .area1.scanmodule


# ======== DISTANCE =======

frame .area1.dist3
pack .area1.dist3 -pady 5


# ======= GEOMETRY ========

frame .area1.geometry -relief raised -borderwidth 2 

menubutton .area1.geometry.menu -text {resolution} \
           -menu {.area1.geometry.menu.sub} \
	   -relief sunken

menu .area1.geometry.menu.sub -tearoff {0} 

.area1.geometry.menu.sub add command -command {setres 50} -label {50x50 dpi}
.area1.geometry.menu.sub add command -command {setres 100} -label {100x100 dpi}
.area1.geometry.menu.sub add command -command {setres 200} -label {200x200 dpi}
.area1.geometry.menu.sub add command -command {setres 300} -label {300x300 dpi}
.area1.geometry.menu.sub add command -command {setres 360} -label {360x360 dpi}
.area1.geometry.menu.sub add command -command {setres 400} -label {400x400 dpi}
.area1.geometry.menu.sub add command -command {setres 500} -label {500x500 dpi}
.area1.geometry.menu.sub add command -command {setres 600} -label {600x600 dpi}
.area1.geometry.menu.sub add command -command {setres 720} -label {720x720 dpi}

label .area1.geometry.x_res_label -text "x-resolution"
entry .area1.geometry.x_resolution -width 5 -textvariable x_res
bind .area1.geometry.x_resolution <Leave> {calculate}
set x_res 100

label .area1.geometry.y_res_label -text "y-resolution"
entry .area1.geometry.y_resolution -width 5 -textvariable y_res
bind .area1.geometry.y_resolution <Leave> {calculate}
set y_res 100

pack .area1.geometry.menu \
     .area1.geometry.x_res_label .area1.geometry.x_resolution \
     .area1.geometry.y_res_label .area1.geometry.y_resolution \
     -anchor s
pack .area1.geometry -fill x 





# =========================== AREA 2 ====================================
frame .area2

# ======= COMMAND BUTTONS ========

frame .area2.buttons -relief raised -borderwidth 2 

button .area2.buttons.quit    -text "Quit"    -command {quit}
button .area2.buttons.preview -text "Preview" -command {preview}
button .area2.buttons.scan    -text "Scan"    -command {scan $viewer}
button .area2.buttons.fax     -text "FAX"     -command {fax}
button .area2.buttons.copy    -text "Copy"    -command {copy}

pack .area2.buttons.quit \
     .area2.buttons.preview \
     .area2.buttons.scan \
     .area2.buttons.fax \
     .area2.buttons.copy \
     -side top -fill x -expand yes -anchor sw -padx 5 -pady 5
pack .area2.buttons  


# ======== DISTANCE =======

frame .area2.dist1
pack .area2.dist1 -pady 5


frame .area2.values -relief raised -borderwidth 2 

button .area2.values.settings -text {settings} -command open_settings

button .area2.values.gamma -text {gamma} -command open_gamma

button .area2.values.light -text {light} -command open_light

pack .area2.values.settings \
     .area2.values.gamma \
     .area2.values.light \
     -side top -fill x -expand yes -anchor sw -padx 5 -pady 5

pack .area2.values


# ============================== AREA 3 ===============================


frame .area3 -borderwidth 2 -relief raised
canvas .area3.rubberbox \
  -width $preview_width \
  -height $preview_height \
  -insertofftime 600 \
  -relief sunken \
  -borderwidth 2

bind .area3.rubberbox <Button-1>         {rubber_begin %x %y}
bind .area3.rubberbox <B1-ButtonRelease> {rubber_end %x %y}
bind .area3.rubberbox <B1-Motion>        {rubber_move %x %y}
bind .area3.rubberbox <B3-Motion>        {box_move %x %y}
bind .area3.rubberbox <B3-ButtonRelease> {box_move %x %y}

frame .area3.info
button .area3.info.button_all -text {Full Page} -command {rubber_no}
label .area3.info.size_label \
  -text "Image Size:" \
  -textvariable image_size


pack .area3.info.button_all .area3.info.size_label -side left

pack .area3.rubberbox .area3.info

# ============== DISPLAY ALL AREAS =====================


pack .area1 .area3 .area2 -side left -padx 5 -pady 5


# ================ SCAN TYPE PROCEDURES ==================

proc set_rgb {} \
{
  global gamma
  global light

  if $light \
  {
    .light.contrast.contrast   configure -state disabled
    .light.contrast.brightness configure -state disabled
    .light.contrast.threshold  configure -state disabled
  }
  calculate
  new_gamma
}




proc set_grey {} \
{
  global gamma
  global light

  if $light \
  {
    .light.contrast.contrast   configure -state disabled
    .light.contrast.brightness configure -state disabled
    .light.contrast.threshold  configure -state disabled
  }
  calculate
  new_gamma
}




proc set_halftone {} \
{
  global gamma
  global light

  if $light \
  {
    .light.contrast.contrast   configure -state normal
    .light.contrast.brightness configure -state normal
    .light.contrast.threshold  configure -state disabled
  }
  calculate
  new_gamma
}




proc set_lineart {} \
{
  global gamma
  global light

  if $light \
  {
    .light.contrast.contrast   configure -state disabled
    .light.contrast.brightness configure -state disabled
    .light.contrast.threshold  configure -state normal
  }
  calculate
  new_gamma
}


# ================== SET RESOLUTION  ===================

proc setres {res} \
{
  global x_res
  global y_res

  set x_res $res
  set y_res $res
  calculate
}

# ================= RUBBER PROCEDURES ==================

proc rubber_begin {x y} \
{
  global rubber_box rubber_x1 rubber_y1
  global preview_width preview_height

  catch {.area3.rubberbox delete $rubber_box(last)} ;# delete old one
  catch {unset rubber_box(last) }

  if {$x > $preview_width}  {set x $preview_width}
  if {$y > $preview_height} {set y $preview_height}

  set rubber_x1 $x
  set rubber_y1 $y
}



proc rubber_end {x y} \
{
  global rubber_box
  global rubber_x1 rubber_y1
  global rubber_x2 rubber_y2
  global preview_width preview_height

  if {$x < 0} {set x 0}
  if {$x > $preview_width} {set x $preview_width}
  set rubber_x2 $x
  if {$rubber_x2 < $rubber_x1} \
  {
    set rubber_x2 $rubber_x1
    set rubber_x1 $x
  }
  set rubber_x2 [expr $rubber_x2 - $rubber_x1 + 1]

  if {$y < 0} {set y 0}
  if {$y > $preview_height} {set y $preview_height}
  set rubber_y2 $y
  if {$rubber_y2 < $rubber_y1} \
  {
    set rubber_y2 $rubber_y1
    set rubber_y1 $y
  }
  set rubber_y2 [expr $rubber_y2 - $rubber_y1 + 1]
  calculate
}



proc rubber_move {x y} \
{
  global rubber_box
  global rubber_x1 rubber_y1
  global rubber_x2 rubber_y2
  global preview_width preview_height

  if {$x < 0} {set x 0}
  if {$x > $preview_width} {set x $preview_width}

  if {$y < 0} {set y 0}
  if {$y > $preview_height} {set y $preview_height}

  catch {.area3.rubberbox delete $rubber_box(last)}
  set rubber_box(last) \
  [ eval {.area3.rubberbox creat rect} {$rubber_x1 $rubber_y1 $x $y -tag box} ]
}



proc box_move {x y} \
{
  global rubber_box
  global rubber_x1 rubber_y1
  global rubber_x2 rubber_y2
  global rubber_move_x rubber_move_y
  global preview_width preview_height

  if {$x < 0} {set x 0}
  if {$y < 0} {set y 0}
  
  if {[expr $x+$rubber_x2] > $preview_width} \
     {set x [expr $preview_width  - $rubber_x2 + 1] }
  if {[expr $y+$rubber_y2] > $preview_height} \
     {set y [expr $preview_height - $rubber_y2 + 1] }

  catch { .area3.rubberbox move $rubber_box(last) \
         [expr $x - $rubber_x1] [expr $y - $rubber_y1] }
  set rubber_move_x [expr $rubber_move_x + ($x - $rubber_x1) ]
  set rubber_move_y [expr $rubber_move_y + ($y - $rubber_y1) ]

  set rubber_x1 $x
  set rubber_y1 $y
}



proc rubber_no {} \
{
  global rubber_x1 rubber_y1
  global rubber_x2 rubber_y2
  global preview_width preview_height
  global rubber_box

  set rubber_x1 0
  set rubber_y1 0
  set rubber_x2 $preview_width
  set rubber_y2 $preview_height

  catch {.area3.rubberbox delete $rubber_box(last)} 
  catch {unset rubber_box(last) }
  calculate
}


# ===================== WINDOWS  ======================

proc open_gamma {} \
{
  global scanmode
  global scanmode_old
  global gamma
  global analog_gamma_r
  global analog_gamma_g
  global analog_gamma_b
  global digital_gamma_r
  global digital_gamma_g
  global digital_gamma_b
  global analog_gamma_bind
  global digital_gamma_bind

  if $gamma \
  {
  }\
  else\
  {
    set scanmode_old $scanmode

    set gamma 1

    toplevel .gamma
    wm title .gamma {gamma correction}

    frame .gamma.analog

    frame .gamma.analog.header
    label .gamma.analog.header.label -text "analog gamma"
    checkbutton .gamma.analog.header.check -text "bind" \
                -variable analog_gamma_bind \
                -command {close_gamma; open_gamma}
    pack .gamma.analog.header.check .gamma.analog.header.label -side left
    pack .gamma.analog.header
  
    frame .gamma.analog.red
    label .gamma.analog.red.label -text "r"
    scale .gamma.analog.red.value \
      -from 1 -to 2 -resolution 0.01 \
      -length 256 \
      -orient horizontal \
      -state normal
    .gamma.analog.red.value set $analog_gamma_r
    pack .gamma.analog.red.label .gamma.analog.red.value -side left
    pack .gamma.analog.red

    frame .gamma.analog.green
    label .gamma.analog.green.label -text "g"
    scale .gamma.analog.green.value \
      -from 1 -to 2 -resolution 0.01 \
      -length 256 \
      -orient horizontal \
      -state normal
    .gamma.analog.green.value set $analog_gamma_g
    pack .gamma.analog.green.label .gamma.analog.green.value -side left
    pack .gamma.analog.green

    frame .gamma.analog.blue
    label .gamma.analog.blue.label -text "b"
    scale .gamma.analog.blue.value \
      -from 1 -to 2 -resolution 0.01 \
      -length 256 \
      -orient horizontal \
      -state normal
    .gamma.analog.blue.value set $analog_gamma_b
    pack .gamma.analog.blue.label .gamma.analog.blue.value -side left
    pack .gamma.analog.blue

    pack .gamma.analog.red \
         .gamma.analog.green \
         .gamma.analog.blue

    pack .gamma.analog



    frame .gamma.digital

    frame .gamma.digital.header
    label .gamma.digital.header.label -text "digital gamma"
    checkbutton .gamma.digital.header.check -text "bind" \
                -variable digital_gamma_bind \
                -command {close_gamma; open_gamma}
    pack .gamma.digital.header.check .gamma.digital.header.label -side left
    pack .gamma.digital.header
  
    frame .gamma.digital.red
    label .gamma.digital.red.label -text "r"
    scale .gamma.digital.red.value \
      -from 0.1 -to 5.0 -resolution 0.1 \
      -length 256 \
      -orient horizontal \
      -state normal
    .gamma.digital.red.value set $digital_gamma_r
    pack .gamma.digital.red.label .gamma.digital.red.value -side left
    pack .gamma.digital.red

    frame .gamma.digital.green
    label .gamma.digital.green.label -text "g"
    scale .gamma.digital.green.value \
      -from 0.1 -to 5.0 -resolution 0.1 \
      -length 256 \
      -orient horizontal \
      -state normal
    .gamma.digital.green.value set $digital_gamma_g
    pack .gamma.digital.green.label .gamma.digital.green.value -side left
    pack .gamma.digital.green

    frame .gamma.digital.blue
    label .gamma.digital.blue.label -text "b"
    scale .gamma.digital.blue.value \
      -from 0.1 -to 5.0 -resolution 0.1 \
      -length 256 \
      -orient horizontal \
      -state normal
    .gamma.digital.blue.value set $digital_gamma_b
    pack .gamma.digital.blue.label .gamma.digital.blue.value -side left
    pack .gamma.digital.blue

    pack .gamma.digital.red \
         .gamma.digital.green \
         .gamma.digital.blue

    pack .gamma.digital

    button .gamma.close -text {close} -command close_gamma

    pack .gamma.close

    if { [expr {$scanmode != "-r"}] || $analog_gamma_bind } \
    {
      destroy .gamma.analog.blue.label
      destroy .gamma.analog.blue.value
      destroy .gamma.analog.green.label
      destroy .gamma.analog.green.value
      destroy .gamma.analog.red.label
    }

    if { [expr {$scanmode != "-r"}] || $digital_gamma_bind } \
    {
      destroy .gamma.digital.blue.label
      destroy .gamma.digital.blue.value
      destroy .gamma.digital.green.label
      destroy .gamma.digital.green.value
      destroy .gamma.digital.red.label
    }
  }
}



proc close_gamma {} \
{
  global gamma

  get_gamma
  if $gamma {destroy .gamma}
  set gamma 0
}




proc new_gamma {} \
{
  global gamma

  if $gamma \
  {
    close_gamma
    open_gamma
  }
}




proc get_gamma {} \
{
  global analog_gamma_r
  global analog_gamma_g
  global analog_gamma_b
  global digital_gamma_r
  global digital_gamma_g
  global digital_gamma_b
  global scanmode_old
  global gamma
  global analog_gamma_bind_old
  global digital_gamma_bind_old
  global analog_gamma_bind
  global digital_gamma_bind


  if $gamma \
  {
    set analog_gamma_r  [.gamma.analog.red.value  get]
    set digital_gamma_r [.gamma.digital.red.value get]

    if [expr {$scanmode_old == "-r"}] \
    {
      if $analog_gamma_bind_old \
      {
        set analog_gamma_g $analog_gamma_r
        set analog_gamma_b $analog_gamma_r
      } \
      else \
      {
        set analog_gamma_g  [.gamma.analog.green.value get]
        set analog_gamma_b  [.gamma.analog.blue.value  get]
      }


      if $digital_gamma_bind_old \
      {
        set digital_gamma_g $digital_gamma_r
        set digital_gamma_b $digital_gamma_r
      } \
      else \
      {
        set digital_gamma_g  [.gamma.digital.green.value get]
        set digital_gamma_b  [.gamma.digital.blue.value  get]
      }
    }
  }

  set analog_gamma_bind_old $analog_gamma_bind
  set digital_gamma_bind_old $digital_gamma_bind
} 

# =================== LIGHT =======================0

proc open_light {} \
{
  global highlight
  global shadow
  global light
  global contrast
  global brightness
  global threshold

  if $light \
  {
  } \
  else \
  {
    set light 1

    toplevel .light

    wm title .light {Light}

    frame .light.lightrange -relief raised -borderwidth 2

    label .light.lightrange.label -text {highlight / shadow} \
          -relief raised -borderwidth 2

    scale .light.lightrange.highlight \
      -from 0 -to 255 -resolution 1 \
      -length 256 \
      -label "highlight" \
      -orient horizontal 
    .light.lightrange.highlight set $highlight

    if { [catch { exec grep "^support highlight function" ._inquiry} ] } \
    { .light.lightrange.highlight configure -state disabled }



    scale .light.lightrange.shadow \
      -from 0 -to 255 -resolution 1 \
      -length 256 \
      -label "shadow" \
      -orient horizontal 
    .light.lightrange.shadow set $shadow

    if { [catch { exec grep "^support shadow function" ._inquiry} ] } \
    { .light.lightrange.shadow configure -state disabled }

    pack .light.lightrange.label \
         .light.lightrange.highlight \
         .light.lightrange.shadow

    pack .light.lightrange



    frame .light.contrast -relief raised -borderwidth 2

    label .light.contrast.label -text {Contrast} \
          -relief raised -borderwidth 2

    scale .light.contrast.contrast \
      -from 0 -to 255 -resolution 1 \
      -length 256 \
      -label "contrast" \
      -orient horizontal 
    .light.contrast.contrast set $contrast

    scale .light.contrast.brightness \
      -from 0 -to 255 -resolution 1 \
      -length 256 \
      -label "brightness" \
      -orient horizontal 
    .light.contrast.brightness set $brightness

    scale .light.contrast.threshold \
      -from 0 -to 255 -resolution 1 \
      -length 256 \
      -label "threshold" \
      -orient horizontal 
    .light.contrast.threshold set $threshold


    pack .light.contrast.label \
         .light.contrast.contrast \
         .light.contrast.brightness \
         .light.contrast.threshold

    pack .light.contrast

    button .light.close -text {close} -command close_light
    pack .light.close
  }
}


proc close_light {} \
{
  global light

  get_light
  if $light {destroy .light}
  set light 0
}


proc get_light {} \
{
  global highlight
  global shadow
  global brightness
  global contrast
  global threshold
  global light


  if $light \
  {
    set highlight  [.light.lightrange.highlight  get]
    set shadow     [.light.lightrange.shadow     get]
    set brightness [.light.contrast.brightness   get]
    set contrast   [.light.contrast.contrast     get]
    set threshold  [.light.contrast.threshold    get]
  }
} 


# ================= SCAN PROCEDURES  ==================

proc quit {} \
{
  catch {exec rm ._inquiry }
  catch {exec rm ._preview.pnm }
  catch {exec rm ._preview.xbm }
  catch {exec rm ._fax }
  exit
}




proc abort {}\
{
  exec killall -2 umax-cli
  destroy .abort
} 




proc scan { output } \
{
  global scanmode
  global scanmodule
  global reverse
  global rubber_x1 rubber_y1
  global rubber_x2 rubber_y2
  global x_res
  global y_res
  global preview_res
  global analog_gamma_r
  global analog_gamma_g
  global analog_gamma_b
  global digital_gamma_r
  global digital_gamma_g
  global digital_gamma_b
  global gamma
  global highlight
  global shadow
  global brightness
  global contrast
  global threshold
  global light

  set scan_ulx    [expr ( $rubber_x1 * 1200 ) / $preview_res ]
  set scan_uly    [expr ( $rubber_y1 * 1200 ) / $preview_res ]
  set scan_width  [expr ( $rubber_x2 * $x_res ) / $preview_res ]
  set scan_height [expr ( $rubber_y2 * $y_res ) / $preview_res ]

if $gamma { get_gamma }
if $light { get_light }

  set options [ concat $scanmode \
                     $scanmodule \
		     $reverse \
                     " -x " $x_res \
		     " -y " $y_res \
		     " -X " $scan_ulx \
		     " -Y " $scan_uly \
		     " -w " $scan_width \
		     " -h " $scan_height \
		     " --Ared "   $analog_gamma_r \
		     " --Agreen " $analog_gamma_g \
		     " --Ablue "  $analog_gamma_b \
		     " --Gred "   $digital_gamma_r \
		     " --Ggreen " $digital_gamma_g \
		     " --Gblue "  $digital_gamma_b \
		     " -L " $highlight \
		     " -S " $shadow \
		     " -t " $threshold \
		     " -c " $contrast \
		     " -b " $brightness \
		     $output ]
		     
#  toplevel .abort  
#  button .abort.button -text {Abort Scan} -command abort
#  pack .abort.button

  eval exec umax-cli $options &
}



proc preview {} \
{
  global scanmode
  global scanmodule
  global reverse
  global rubber_x1 rubber_y1
  global rubber_x2 rubber_y2
  global x_res
  global y_res
  global dest
  global preview_res
  global preview_width preview_height
  global rubber_box
  global monitor_gamma
  global analog_gamma_r
  global analog_gamma_g
  global analog_gamma_b
  global digital_gamma_r
  global digital_gamma_g
  global digital_gamma_b
  global gamma
  global highlight
  global shadow
  global brightness
  global contrast
  global threshold
  global light
  global preview_picture

  set scan_ulx    [expr ( $rubber_x1 * 1200 ) / $preview_res ]
  set scan_uly    [expr ( $rubber_y1 * 1200 ) / $preview_res ]
  set scan_width  [expr ( $rubber_x2 * $x_res ) / $preview_res ]
  set scan_height [expr ( $rubber_y2 * $y_res ) / $preview_res ]

if $gamma { get_gamma }
if $light { get_light }

  catch {.area3.rubberbox delete $rubber_box(last)}

  set options [ concat $scanmode \
                     $scanmodule \
		     $reverse \
                     " -p " \
                     " -x " $preview_res \
                     " -y " $preview_res \
                     " -X 0 -Y 0" \
		     " --Ared "   $analog_gamma_r \
		     " --Agreen " $analog_gamma_g \
		     " --Ablue "  $analog_gamma_b \
		     " --Gred "   $digital_gamma_r \
		     " --Ggreen " $digital_gamma_g \
		     " --Gblue "  $digital_gamma_b \
		     " -L " $highlight \
		     " -S " $shadow \
		     " -t " $threshold \
		     " -c " $contrast \
		     " -b " $brightness \
                     " >._preview.pnm" ]
  eval exec umax-cli $options

  set width  [expr $preview_width / 2 ]
  set height [expr $preview_height / 2 ]
 
  if { [expr {$scanmode == "-r"}] || [expr {$scanmode == "-g"}] } \
  {
    image create photo image1 -file ._preview.pnm -gamma $monitor_gamma
    .area3.rubberbox create image $width $height -image image1
    set preview_picture {photo}
  } \
  else \
  {
    exec pgmtopbm < ._preview.pnm | pbmtoxbm > ._preview.xbm
    image create bitmap image1 -file ._preview.xbm
    .area3.rubberbox create image $width $height -image image1
    set preview_picture {bitmap}
  }

  set rubber_box(last) \
  [ eval {.area3.rubberbox creat rect} \
         { $rubber_x1 $rubber_y1 \
           [expr $rubber_x1 + $rubber_x2] \
	   [expr $rubber_y1 + $rubber_y2] \
	   -tag box } ]
}



proc fax {} \
{
  global x_res y_res
  global fax_res_x fax_res_y
  global fax

  set x_res $fax_res_x
  set y_res $fax_res_y
  set_lineart
  scan ._fax.pnm
  set faxnr 709262
  exec $fax $faxnr ._fax.pnm
}



proc copy {} \
{
  global x_res y_res
  global printer_res_x printer_res_y
  global printer

  set x_res $printer_res_x
  set y_res $printer_res_y
  scan $printer
}



proc calculate {} \
{
  global scanmode
  global rubber_x2 rubber_y2
  global x_res
  global y_res
  global preview_res
  global image_size

  set pixel_size 0.125
  if {$scanmode == "-g"} {set pixel_size 1}
  if {$scanmode == "-r"} {set pixel_size 3}

  set bytes_per_line [expr $pixel_size * $rubber_x2 * $x_res / $preview_res]
  set lines          [expr $rubber_y2 * $y_res / $preview_res]
  set size           [expr round ($bytes_per_line * $lines / 1024) ]
  set image_size [ concat "    Image Size: " [format "%4d" $size] "KB" ]
}


# ==================== SETTINGS ========================

proc open_settings {} \
{
  global monitor_gamma

  toplevel .settings
  wm title .settings {settings}

  scale .settings.monitor_gamma \
    -from 1 -to 5 -resolution 0.1 \
    -length 256 \
    -orient horizontal \
    -state normal \
    -label {monitor gamma}
  .settings.monitor_gamma set $monitor_gamma


  button .settings.close -text {apply} -command close_settings

  pack .settings.monitor_gamma \
       .settings.close
}


proc close_settings {} \
{
  global monitor_gamma
  global preview_picture
  global preview_width
  global preview_height

  set monitor_gamma  [.settings.monitor_gamma  get]

  set width  [expr $preview_width / 2 ]
  set height [expr $preview_height / 2 ]
  if [expr {$preview_picture == "photo"}] \
  {
    image create photo image1 -file ._preview.pnm -gamma $monitor_gamma
    .area3.rubberbox create image $width $height -image image1
  } \
  elseif [expr {$preview_picture == "bitmap"}] \
  {
    exec pgmtopbm < ._preview.pnm | pbmtoxbm > ._preview.xbm
    image create bitmap image1 -file ._preview.xbm
    .area3.rubberbox create image $width $height -image image1
  }



  destroy .settings
}

# ================= INITIALISATION =====================

set analog_gamma_r 1.0
set analog_gamma_g 1.0
set analog_gamma_b 1.0
set digital_gamma_r 1.0
set digital_gamma_g 1.0
set digital_gamma_b 1.0
set analog_gamma_bind 1
set analog_gamma_bind_old 1
set digital_gamma_bind 1
set digital_gamma_bind_old 1

set gamma 0
set light 0
set highlight 255
set shadow 0
set contrast 128
set brightness 128
set threshold 128
set reverse ""
set preview_picture "none"

set rubber_move_x 0
set rubber_move_y 0
set dest { | xv -}

rubber_no

if { ![catch { exec grep "^color mode" ._inquiry} ] } \
{ set scanmode "-r" } \
elseif { ![catch { exec grep "^grey mode" ._inquiry} ] } \
{ set scanmode "-g" } \
elseif { ![catch { exec grep "^halftone mode" ._inquiry} ] } \
{ set scanmode "-d" } \
else  \
{ set scanmode "-l" }

close_gamma
