    # 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>"
                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>"
                @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 "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

            if IS_JRUBY
              xCmd = "#{cmd} -q#{@errors} #{xExternalLibraries} #{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} #{xOutputWithFile} #{xOutputWithoutFile} #{tmpPath}"
            else
              xCmd = "\"#{cmd}\" -q#{@errors} #{xExternalLibraries} #{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