msdoc

 

ulis, 2007-02-10. Un package à la Tk pour contrôler MSWord avec TCom.

dernière version : 2007-02-10, v 1.0.1


Pourquoi

Pour faciliter l'usage de cette page : Word avec Tcl et Tcom.

Pour fournir un exemple pour en faire d'autres (mstable, oodoc...).


Comment

Bah... un petit package à la ulis.

Une procédure qui crée la référence du document. Et la référence qui appelle des procédures pour chaque fonction.

Remarque : n'hésitez pas à le modifier pour rajouter les fonctions dont vous avez besoin.

Il suffit de rajouter une ligne semblable aux autres dans la procédure de création.

Et de rajouter une procédure semblable aux autres pour la fonction.


Utilisation

  package require msdoc
  set doc [msdoc]
  $doc font Size 16 Bold 100 Italic 100 Underline 1
  $doc text "Statistiques du groupe fr.comp.lang.tcl pour 2006"
  # document
  set doc [msdoc]
  $doc font ?$key $value?...
  $doc text "$text"
  # tableau
  set table [$doc table $rows $columns]
  $table font $i $j ?$key $value?...
  $table text $i $j $text

(pour les autres opérations, bin il faut les faire)


Installation

  1. Télécharger le script ici : [1]
  2. Créer un répertoire msdoc dans le répertoire lib de Tcl.
  3. Y copier le script msdoc.tcl et le script pkgIndex.tcl ci-dessous.

Le script pkgIndex.tcl

  package ifneeded msdoc 1.0.1 [list source [file join $dir msdoc.tcl]]

Démo

(c'est l'exemple de GS revisité)

  # ==============
  # demo
  # ==============

  package require msdoc

  # -----------------------------------------------------------------
  set lmois {Janvier Février Mars Avril Mai Juin \
            Juillet Août Septembre Octobre Novembre Décembre}
  set lmsg {80 64 63 44 86 84 379 204 135 210 147 116}

  # -----------------------------------------------------------------
  set total [expr [join $lmsg +]]
  set moyenne [expr {$total / [llength $lmsg]}]
  set min [lindex [set ls [lsort -integer $lmsg]] 0]
  set max [lindex $ls end]

 # -----------------------------------------------------------------
 # Création du document MSWord
  set doc [msdoc]

 # Affichage de quelques lignes de texte

 # Titre en gras italique souligné 16 points pica
  $doc font Size 16 Bold 100 Italic 100 Underline 1
  $doc text "Statistiques du groupe fr.comp.lang.tcl pour 2006"
  $doc font Size 12 Bold 0 Italic 0 Underline 0

 # Quelques lignes vides
  $doc text "\n\n\n"

  $doc text "Nombre maximum de messages:\t $max  (Juillet)\n"
  $doc text "Nombre minimum de messages:\t $min  (Avril)\n"
  $doc text "Moyenne sur l'année: $moyenne"

 # Quelques lignes vides
  $doc text "\n\n\n"

 # Creation et remplissage d'un tableau de 14 lignes et 2 colonnes

  set table [$doc table 14 2]

  $table text 1 1 "Mois"
  $table text 1 2 "Messages"

  set i 2
  foreach mois $lmois msg $lmsg \
  {
    $table text $i 1 "$mois"
    $table text $i 2 "$msg"
    incr i
  }

  $table text $i 1 "Total"
  $table text $i 2 "$total"

  # graissage de l'entête et du pied du tableau
  set lbold {1 1 1 2 14 1 14 2}
  foreach {i j} $lbold \
  { $table font $i $j Bold 100 }

Le résultat


Package msdoc

  if {[info exists ::msdoc::version]} { return }

  namespace eval ::msdoc \
  {
  # ############################
  #
  #  package msdoc
  variable version 1.0.1
  #
  # Licence NOL (No Obligation Licence)
  # (C) ulis, 2007
  # ----------------------------
  # v1.0.1
  #   bug sur package provide (utilisation de $version)
  #   bug sur le nom associé à la table (utilisation de $table)
  # ############################

    # entry point
    namespace export msdoc

    # packages
    package require tcom
    package provide msdoc $version

    # create a doc
    proc msdoc {} \
    {
      set MSWord [::tcom::ref createobject "Word.Application"]
      $MSWord Visible 1
      [$MSWord Documents] Add
      set doc [$MSWord Selection]
      set name ::msdoc::[string map {:: -} $doc]
      set proc [string map [list %name% $name %doc% $doc] \
      {
        proc %name% {cmd args} \
        {
          set code [catch \
          {
            switch -glob -- $cmd \
            {
              fon*    { uplevel 1 ::msdoc::doc:font   %doc% $args }
              tab*    { uplevel 1 ::msdoc::doc:table  %doc% $args }
              tex*    { uplevel 1 ::msdoc::doc:text   %doc% $args }
              default { error "unknown msdoc doc command '$cmd'" }
            }
          } result]
          return -code $code $result
        }
      }]
      eval $proc
      return $name
    }

    # doc font
    proc doc:font {doc args} \
    {
      if {[llength $args] % 2 != 0} \
      { error "use is '\$doc font ?\$key \$value?...'" }
      set font [$doc Font]
      foreach {key value} $args { $font $key $value }
    }

    # doc text
    proc doc:text {doc args} \
    {
      if {[llength $args] != 1} \
      { error "use is '\$doc text \$text'" }
      set text [lindex $args 0]
      $doc TypeText $text
    }

    # create a table
    proc doc:table {doc args} \
    {
      if {[llength $args] != 2} \
      { error "use is '\$doc table \$rows \$columns'" }
      foreach {rows cols} $args break
      set table [[$doc Tables] Add [$doc Range] $rows $cols]
      set name ::msdoc::[string map {:: -} $table]
      set proc [string map [list %name% $name %table% $table] \
      {
        proc %name% {cmd args} \
        {
          set code [catch \
          {
            switch -glob -- $cmd \
            {
              fon*    { uplevel 1 ::msdoc::table:font %table% $args }
              tex*    { uplevel 1 ::msdoc::table:text %table% $args }
              default { error "unknown msdoc table command '$cmd'" }
            }
          } result]
          return -code $code $result
        }
      }]
      eval $proc
      return $name
    }

    # table font
    proc table:font {table args} \
    {
      if {[llength $args] % 2 != 0} \
      { error "use is '\$table font \$row \$column ?\$key \$value?...'" }
      foreach {i j} $args break
      if {![string is integer -strict $i] || ![string is integer -strict $j]} \
      { error "bad cell selection '$i $j'" }
      set font [[[$table Cell $i $j] Range] Font]
      foreach {key value} [lrange $args 2 end] \
      { $font $key $value }
    }

    # table text
    proc table:text {table args} \
    {
      if {[llength $args] != 3} \
      { error "use is '\$table text \$row \$column \$text'" }
      foreach {i j text} $args break
      if {![string is integer -strict $i] || ![string is integer -strict $j]} \
      { error "bad cell selection '$i $j'" }
      [[$table Cell $i $j] Range] Text $text
    }
  }

  namespace import ::msdoc::msdoc

Voir Aussi


Discussion

ulis Je vous encourage à modifier et compléter ce script pour l'adapter à vos besoins.

Par exemple pour ajouter la fonction $doc save $filename :

            switch -glob -- $cmd \
            {
              fon*    { uplevel 1 ::msdoc::doc:font   %doc% $args }
              sav*    { uplevel 1 ::msdoc::doc:save   %doc% $args }
              tab*    { uplevel 1 ::msdoc::doc:table  %doc% $args }
              tex*    { uplevel 1 ::msdoc::doc:text   %doc% $args }
              default { error "unknown msdoc doc command '$cmd'" }
            }
    # doc save
    proc doc:save {doc args} \
    {
      if {[llength $args] != 1} \
      { error "use is '\$doc save \$filename'" }
      set filename [lindex $args 0]
      [$doc Document] SaveAs $filename
    }

N'hésitez pas à publier votre script dans cette page (ou dans sa propre page) pour qu'il profite aux autres.


Catégorie Paquet