    # File lib/graphviz.rb, line 367
      def output( hOpts = {} )
        xDOTScript = ""
        xLastType = nil
        xSeparator = ""
        xData = ""
        lNotHugly = []

        @elements_order.each { |kElement|
          if xLastType.nil? == true or xLastType != kElement["type"]

            if xData.length > 0
              case xLastType
                when "graph_attr"
                  xDOTScript << "  " + xData + ";\n"

                when "node_attr"
                  xDOTScript << "  node [" + xData + "];\n"

                when "edge_attr"
                  xDOTScript << "  edge [" + xData + "];\n"
              end
            end

            xSeparator = ""
            xData = ""
          end

          xLastType = kElement["type"]

          #Modified by
          #Brandon Coleman
          #verify value is NOT NULL
          if kElement["value"] == nil then
            raise ArgumentError, "#{kElement["name"]} has a nil value!"
          end

          case kElement["type"]
            when "graph_attr"
              xData << xSeparator + kElement["name"] + " = " + kElement["value"].to_gv
              xSeparator = "; "

            when "node_attr"
              xData << xSeparator + kElement["name"] + " = " + kElement["value"].to_gv
              xSeparator = ", "

            when "edge_attr"
              xData << xSeparator + kElement["name"] + " = " + kElement["value"].to_gv
              xSeparator = ", "

            when "node"
              xDOTScript << "  " + kElement["value"].output() + "\n"

            when "edge"
              xDOTScript << "  " + kElement["value"].output( @oGraphType ) + "\n"

            when "graph"
              xDOTScript << kElement["value"].output() + "\n"

            else
              raise ArgumentError, "Don't know what to do with element type '#{kElement['type']}'"
          end
        }

        if xData.length > 0
          case xLastType
            when "graph_attr"
              xDOTScript << "  " + xData + ";\n"

            when "node_attr"
              xDOTScript << "  node [" + xData + "];\n"

            when "edge_attr"
              xDOTScript << "  edge [" + xData + "];\n"
          end
        end
        xDOTScript << "}"

        if @oParentGraph.nil? == false
          xDOTScript = "subgraph #{GraphViz.escape(@name, :unquote_empty => true)} {\n" << xDOTScript

          return( xDOTScript )
        else
          hOutput = {}

          hOpts.each do |xKey, xValue|
            xValue = xValue.to_s unless xValue.nil? or [Class, TrueClass, FalseClass].include?(xValue.class)
            case xKey.to_s
              when "output"
                warn ":output option is deprecated, please use :<format> => :<file> -- BE CAREFUL, it will be removed in the 1.0 version!"
                if FORMATS.index( xValue ).nil? == true
                  raise ArgumentError, "output format '#{xValue}' invalid"
                end
                @format = xValue
              when "file"
                warn ":file option is deprecated, please use :<format> => :<file> -- BE CAREFUL, it will be removed in the 1.0 version!"
                @filename = xValue
              when "use"
                if PROGRAMS.index( xValue ).nil? == true
                  raise ArgumentError, "can't use '#{xValue}'"
                end
                @prog = xValue
              when "path"
                @path = xValue.split( "," ).map{ |x| x.strip }
              when "errors"
                @errors = xValue
              when "extlib"
                @extlibs = xValue.split( "," ).map{ |x| x.strip }
              when "scale"
                # Scale input by 'v' (=72)
                @scale = xValue
              when "inverty"
                # Invert y coordinate in output
                @inverty = xValue
              when "no_layout"
                # No layout mode 'v' (=1)
                @no_layout = xValue
              when "reduce"
                # Reduce graph
                @reduce_graph = xValue
              when "Lg"
                # Don't use grid
                @Lg = xValue
              when "LO"
                # Use old attractive force
                @LO = xValue
              when "Ln"
                # Set number of iterations to i
                @Ln = xValue
              when "LU"
                # Set unscaled factor to i
                @LU = xValue
              when "LC"
                # Set overlap expansion factor to v
                @LC = xValue
              when "LT"
                # Set temperature (temperature factor) to v
                @LT = xValue
              when "nothugly"
                begin
                  require 'graphviz/nothugly'
                  @nothugly = true
                rescue
                  warn "You must install ruby-xslt to use nothugly option!"
                  @nothugly = false
                end
              else
                if FORMATS.index( xKey.to_s ).nil? == true
                  raise ArgumentError, "output format '#{xValue}' invalid"
                end
                hOutput[xKey.to_s] = xValue
            end
          end

          @output = hOutput if hOutput.size > 0

          xStict = ((@strict && @oGraphType == "digraph") ? "strict " : "")
          xDOTScript = ("#{xStict}#{@oGraphType} #{GraphViz.escape(@name, :unquote_empty => true)} {\n" << xDOTScript).gsub( "\0", "" )

          xOutputString = (@filename == String ||
            @output.any? {|format, file| file == String })

          xOutput = ""
          if @format.to_s == "none" or @output.any? {|fmt, fn| fmt.to_s == "none"}
            if xOutputString
              xOutput << xDOTScript
            else
              xFileName = @output["none"] || @filename
              open( xFileName, "w" ) do |h|
                h.puts xDOTScript
              end
            end
          end

          if (@format.to_s != "none" and not @format.nil?) or (@output.any? {|format, file| format != "none" } and @output.size > 0)
            ## Act: Save script and send it to dot
            t = Tempfile::open( File.basename(__FILE__) )
            t.print( xDOTScript )
            t.close

            cmd = find_executable( @prog, @path )
            if cmd == nil
              raise StandardError, "GraphViz not installed or #{@prog} not in PATH. Install GraphViz or use the 'path' option"
            end

            cmd = escape_path_containing_blanks(cmd) if IS_JRUBY

            xOutputWithFile = ""
            xOutputWithoutFile = ""
            unless @format.nil? or @format == "none"
              lNotHugly << @filename if @format.to_s == "svg" and @nothugly
              if @filename.nil? or @filename == String
                xOutputWithoutFile = "-T#{@format} "
              else
                xOutputWithFile = "-T#{@format} -o#{@filename} "
              end
            end
            @output.each_except( :key => ["none"] ) do |format, file|
              lNotHugly << file if format.to_s == "svg" and @nothugly
              if file.nil? or file == String
                xOutputWithoutFile << "-T#{format} "
              else
                xOutputWithFile << "-T#{format} -o#{file} "
              end
            end

            xExternalLibraries = ""
            @extlibs.each do |lib|
              xExternalLibraries << "-l#{lib} "
            end

            xOtherOptions = ""
            xOtherOptions += " -s#{@scale}" unless @scale.nil?
            xOtherOptions += " -y" if @inverty == true
            unless @no_layout.nil?
              xOtherOptions += " -n"
              xOtherOptions += "2" if @no_layout.to_i == 2
            end
            xOtherOptions += " -x" if @reduce_graph == true
            xOtherOptions += " -Lg" if @Lg == true
            xOtherOptions += " -LO" if @LO == true
            xOtherOptions += " -Ln#{@Ln}" unless @LN.nil?
            xOtherOptions += " -LU#{@LU}" unless @LU.nil?
            xOtherOptions += " -LC#{@LC}" unless @LC.nil?
            xOtherOptions += " -LT#{@LT}" unless @LT.nil?

            if IS_JRUBY
              xCmd = "#{cmd} -q#{@errors} #{xExternalLibraries} #{xOtherOptions} #{xOutputWithFile} #{xOutputWithoutFile} #{t.path}"
            elsif IS_CYGWIN
              tmpPath = t.path
              begin
                tmpPath = "'" + `cygpath -w #{t.path}`.chomp + "'"
              rescue
                warn "cygpath is not installed!"
              end
              xCmd = "\"#{cmd}\" -q#{@errors} #{xExternalLibraries} #{xOtherOptions} #{xOutputWithFile} #{xOutputWithoutFile} #{tmpPath}"
            else
              xCmd = "\"#{cmd}\" -q#{@errors} #{xExternalLibraries} #{xOtherOptions} #{xOutputWithFile} #{xOutputWithoutFile} #{t.path}"
            end

            xOutput << output_from_command( xCmd )
          end

          # Not Hugly
          lNotHugly.each do |f|
            if f.nil? or f == String
              xOutput = GraphViz.nothugly( xOutput, false )
            else
              GraphViz.nothugly( f, true )
            end
          end

          if xOutputString
            xOutput
          else
            print xOutput
          end
        end
      end