@@ -9,7 +9,7 @@

 AdditiveUnit = setClass("AdditiveUnit")

 # == title

-# Constructor method for AdditiveUnit class

+# Constructor Method for AdditiveUnit Class

 #

 # == param

 # -... black hole arguments.

@@ -23,21 +23,17 @@ AdditiveUnit = setClass("AdditiveUnit")

 # == author

 # Zuguang Gu <z.gu@dkfz.de>

 #

-# == example

-# # no example for this function

-# NULL

-#

 AdditiveUnit = function(...) {

     new("AdditiveUnit", ...)

 }

 # == title

-# Add heatmaps or row annotations to a heatmap list

+# Horizontally Add Heatmaps or Annotations to a Heatmap List

 #

 # == param

-# -x a `Heatmap-class` object, a `HeatmapAnnotation-class` object or a `HeatmapList-class` object.

-# -y a `Heatmap-class` object, a `HeatmapAnnotation-class` object or a `HeatmapList-class` object.

+# -x A `Heatmap-class` object, a `HeatmapAnnotation-class` object or a `HeatmapList-class` object.

+# -y A `Heatmap-class` object, a `HeatmapAnnotation-class` object or a `HeatmapList-class` object.

 #

 # == detail

 # It is only a helper function. It actually calls `add_heatmap,Heatmap-method`, `add_heatmap,HeatmapList-method`

@@ -48,6 +44,9 @@ AdditiveUnit = function(...) {

 # == value

 # A `HeatmapList-class` object.

 #

+# == seealso

+# `%v%` operator is used for vertical heatmap list.

+#

 # == author

 # Zuguang Gu <z.gu@dkfz.de>

 #

@@ -64,9 +63,11 @@ AdditiveUnit = function(...) {

     }

     if(is.null(x)) {

         ht_list = new("HeatmapList")

+        ht_list@direction = "horizontal"

         add_heatmap(ht_list, y)

     } else if(is.null(y)) {

         ht_list = new("HeatmapList")

+        ht_list@direction = "horizontal"

         add_heatmap(ht_list, x)

     } else {

         add_heatmap(x, y)

@@ -74,6 +75,28 @@ AdditiveUnit = function(...) {

 }

+# == title

+# Vertically Add Heatmaps or Annotations to a Heatmap List

+#

+# == param

+# -x A `Heatmap-class` object, a `HeatmapAnnotation-class` object or a `HeatmapList-class` object.

+# -y A `Heatmap-class` object, a `HeatmapAnnotation-class` object or a `HeatmapList-class` object.

+#

+# == detail

+# It is only a helper function. It actually calls `add_heatmap,Heatmap-method`, `add_heatmap,HeatmapList-method`

+# or `add_heatmap,HeatmapAnnotation-method` depending on the class of the input objects.

+#

+# The `HeatmapAnnotation-class` object to be added should only be column annotations.

+#

+# == value

+# A `HeatmapList-class` object.

+#

+# == seealso

+# `+.AdditiveUnit` operator is used for vertical heatmap list.

+#

+# == author

+# Zuguang Gu <z.gu@dkfz.de>

+#

 "%v%" = function(x, y) {

     if(inherits(x, "HeatmapAnnotation")) {

         if(x@which != "column") {

@@ -87,9 +110,11 @@ AdditiveUnit = function(...) {

     }

     if(is.null(x)) {

         ht_list = new("HeatmapList")

+        ht_list@direction = "vertical"

         add_heatmap(ht_list, y, direction = "vertical")

     } else if(is.null(y)) {

         ht_list = new("HeatmapList")

+        ht_list@direction = "vertical"

         add_heatmap(ht_list, x, direction = "vertical")

     } else {

         add_heatmap(x, y, direction = "vertical")

@@ -91,14 +91,17 @@ ColorMapping = function(name, colors = NULL, levels = NULL,

 			if(is.null(breaks)) {

 				stop("You should provide breaks.\n")

 			}

-		}

+		

-		le1 = grid.pretty(range(breaks))

-		le2 = pretty(breaks, n = 3)

-		if(abs(length(le1) - 5) < abs(length(le2) - 5)) {

-			le = le1

+			le1 = grid.pretty(range(breaks))

+			le2 = pretty(breaks, n = 3)

+			if(abs(length(le1) - 5) < abs(length(le2) - 5)) {

+				le = le1

+			} else {

+				le = le2

+			}

 		} else {

-			le = le2

+			le = breaks

 		}

 		.Object@colors = col_fun(le)

@@ -245,7 +248,7 @@ setMethod(f = "color_mapping_legend",

 	plot = TRUE,

 	title = object@name,

 	title_gp = gpar(fontsize = 10, fontface = "bold"),

-	title_position = c("topleft", "topcenter", "leftcenter", "lefttop"),

+	title_position = "topleft",

 	color_bar = object@type,

 	grid_height = unit(4, "mm"),

 	grid_width = unit(4, "mm"),

@@ -237,6 +237,7 @@ Heatmap = function(matrix, col, name,

     rect_gp = gpar(col = NA), 

     border = NA,

     cell_fun = NULL,

+    layer_fun = NULL,

     row_title = character(0), 

     row_title_side = c("left", "right"), 

@@ -291,9 +292,9 @@ Heatmap = function(matrix, col, name,

     row_split = split,

     column_km = 1,

     column_split = NULL,

-    gap = unit(1, "mm"),

-    row_gap = unit(1, "mm"),

-    column_gap = unit(1, "mm"),

+    gap = unit(0.5, "mm"),

+    row_gap = unit(0.5, "mm"),

+    column_gap = unit(0.5, "mm"),

     width = unit(1, "npc"),

     heatmap_body_width = NULL,

@@ -473,6 +474,7 @@ Heatmap = function(matrix, col, name,

     if(identical(border, TRUE)) border = "black"

     .Object@matrix_param$border = border

     .Object@matrix_param$cell_fun = cell_fun

+    .Object@matrix_param$layer_fun = layer_fun

     if(!missing(heatmap_body_width)) {

         if(is_abs_unit(heatmap_body_width)) {

@@ -492,7 +494,6 @@ Heatmap = function(matrix, col, name,

     }

     .Object@matrix_param$width = heatmap_body_width

     .Object@matrix_param$height = heatmap_body_height

-    

     ### color for main matrix #########

     if(ncol(matrix) > 0 && nrow(matrix) > 0) {

@@ -721,8 +722,8 @@ Heatmap = function(matrix, col, name,

         }

         nb = nobs(left_annotation)

         if(!is.na(nb)) {

-            if(nb != ncol(.Object@matrix)) {

-                stop("number of items in left anntotion should be same as number of columns of the matrix.")

+            if(nb != nrow(.Object@matrix)) {

+                stop("number of items in left anntotion should be same as number of rows of the matrix.")

             }

         }

     }

@@ -741,8 +742,8 @@ Heatmap = function(matrix, col, name,

         }

         nb = nobs(right_annotation)

         if(!is.na(nb)) {

-            if(nb != ncol(.Object@matrix)) {

-                stop("number of items in left anntotion should be same as number of columns of the matrix.")

+            if(nb != nrow(.Object@matrix)) {

+                stop("number of items in right anntotion should be same as number of rows of the matrix.")

             }

         }

     }

@@ -781,6 +782,15 @@ Heatmap = function(matrix, col, name,

     .Object@heatmap_param$raster_device_param = raster_device_param

     .Object@heatmap_param$verbose = verbose

+    if(nrow(matrix) == 0) {

+        .Object@heatmap_param$height = unit(0, "mm")

+        .Object@matrix_param$height = unit(0, "mm")

+    }

+    if(ncol(matrix) == 0) {

+        .Object@heatmap_param$width = unit(0, "mm")

+        .Object@matrix_param$width = unit(0, "mm")

+    }

+

     return(.Object)

 }

@@ -1235,1426 +1245,114 @@ make_cluster = function(object, which = c("row", "column")) {

 }

 # == title

-# Make the Layout of a Single Heatmap

+# Draw a Single Heatmap

 #

 # == param

 # -object A `Heatmap-class` object.

-# 

-# == detail

-# The layout of the single heatmap will be established by setting the size of each heatmap components.

-# Also functions that make graphics for heatmap components will be recorded by saving as functions.

+# -internal If ``TRUE``, it is only used inside the calling of `draw,HeatmapList-method`. 

+#           It only draws the heatmap without legends where the legend will be drawn by `draw,HeatmapList-method`. 

+# -test Only for testing. If it is ``TRUE``, the heatmap body is directly drawn.

+# -... Pass to `draw,HeatmapList-method`.

 #

-# Whether to apply row clustering or column clustering affects the layout, so clustering should be applied 

-# first before making the layout.

+# == detail

+# The function creates a `HeatmapList-class` object which only contains a single heatmap

+# and call `draw,HeatmapList-method` to make the final heatmap.

 #

-# This function is only for internal use.

+# There are some arguments which control the global setting of the heatmap such as legends.

+# Please go to `draw,HeatmapList-method` for these arguments.

 #

 # == value

-# A `Heatmap-class` object.

+# A `HeatmapList-class` object.

 #

 # == author

 # Zuguang Gu <z.gu@dkfz.de>

 #

-setMethod(f = "make_layout",

+setMethod(f = "draw",

     signature = "Heatmap",

-    definition = function(object) {

-

-    # position of each row-slice

-    row_gap = object@matrix_param$row_gap

-    column_gap = object@matrix_param$column_gap

-    nr_slice = length(object@row_order_list)

-    nc_slice = length(object@column_order_list)

-

-    snr = sapply(object@row_order_list, length)

-    snc = sapply(object@column_order_list, length)

-    if(nr_slice == 1) {

-        slice_height = unit(1, "npc")

-    } else {

-        slice_height = (unit(1, "npc") - sum(row_gap[seq_len(nr_slice-1)]))*(snr/sum(snr))

-    }

-    for(i in seq_len(nr_slice)) {

-        if(i == 1) {

-            slice_y = unit(1, "npc")

-        } else {

-            slice_y = unit.c(slice_y, unit(1, "npc") - sum(slice_height[seq_len(i-1)]) - sum(row_gap[seq_len(i-1)]))

-        }

-    }

-

-    if(nc_slice == 1) {

-        slice_width = unit(1, "npc")

-    } else {

-        slice_width = (unit(1, "npc") - sum(column_gap[seq_len(nc_slice-1)]))*(snc/sum(snc))

-    }

-    for(i in seq_len(nc_slice)) {

-        if(i == 1) {

-            slice_x = unit(0, "npc")

-        } else {

-            slice_x = unit.c(slice_x, sum(slice_width[seq_len(i-1)]) + sum(column_gap[seq_len(i-1)]))

-        }

-    }

-    object@layout$slice = list(

-        x = slice_x, 

-        y = slice_y, 

-        width = slice_width, 

-        height = slice_height,

-        just = c("left", "top")

-    )

-

-    if(length(object@matrix)) {

-        

-        ###########################################

-        ## heatmap body

-        object@layout$layout_index = rbind(heatmapb_body = heatmap_layout_index("heatmap_body"))

-        object@layout$graphic_fun_list = list(function(object) {

-            for(i in seq_len(nr_slice)) {

-                for(j in seq_len(nc_slice)) {

-                    draw_heatmap_body(object, kr = i, kc = j, x = slice_x[j], y = slice_y[i], width = slice_width[j], height = slice_height[i], just = c("left", "top"))

-                }

-            }

-        })

-    }

-

-    ############################################

-    ## title on top or bottom

-    column_title = object@column_title

-    column_title_side = object@column_title_param$side

-    column_title_gp = object@column_title_param$gp

-    column_title_rot = object@column_title_param$rot

-    if(length(column_title) > 0) {

-        if(column_title_side == "top") {

-            if(column_title_rot %in% c(0, 180)) {

-                object@layout$layout_size$column_title_top_height = grobHeight(textGrob(column_title, gp = column_title_gp)) + TITLE_PADDING*2

-            } else {

-                object@layout$layout_size$column_title_top_height = grobWidth(textGrob(column_title, gp = column_title_gp)) + TITLE_PADDING*2

-            }

-            object@layout$layout_index = rbind(object@layout$layout_index, column_title_top = heatmap_layout_index("column_title_top"))

-        } else {

-            if(column_title_rot %in% c(0, 180)) {

-                object@layout$layout_size$column_title_bottom_height = grobHeight(textGrob(column_title, gp = column_title_gp)) + TITLE_PADDING*2

-            } else {

-                object@layout$layout_size$column_title_bottom_height = grobWidth(textGrob(column_title, gp = column_title_gp)) + TITLE_PADDING*2

-            }

-            object@layout$layout_index = rbind(object@layout$layout_index, column_title_bottom = heatmap_layout_index("column_title_bottom"))

-        }

-        object@layout$graphic_fun_list = c(object@layout$graphic_fun_list, function(object) {

-            if(length(column_title) == 1 && nc_slice > 1) {

-                draw_title(object, k = 1, which = "column")

-            } else {

-                for(i in seq_len(nc_slice)) {

-                    draw_title(object, k = i, which = "column", x = slice_x[i], width = slice_width[i], just = "left")

-                }

-            }

-        })

-    }

-

-    ############################################

-    ## title on left or right

-    row_title = object@row_title

-    row_title_side = object@row_title_param$side

-    row_title_gp = object@row_title_param$gp

-    row_title_rot = object@row_title_param$rot

-    if(length(row_title) > 0) {

-        if(row_title_side == "left") {

-            if(row_title_rot %in% c(0, 180)) {

-                object@layout$layout_size$row_title_left_width = max_text_width(row_title, gp = row_title_gp) + TITLE_PADDING*2

-            } else {

-                object@layout$layout_size$row_title_left_width = max_text_height(row_title, gp = row_title_gp) + TITLE_PADDING*2

-            }

-            object@layout$layout_index = rbind(object@layout$layout_index, row_title_left = heatmap_layout_index("row_title_left"))

-        } else {

-            if(row_title_rot %in% c(0, 180)) {

-                object@layout$layout_size$row_title_right_width = max_text_width(row_title, gp = row_title_gp) + TITLE_PADDING*2

-            } else {

-                object@layout$layout_size$row_title_right_width = max_text_height(row_title, gp = row_title_gp) + TITLE_PADDING*2

-            }

-            object@layout$layout_index = rbind(object@layout$layout_index, row_title_right = heatmap_layout_index("row_title_right"))

-        }

-        object@layout$graphic_fun_list = c(object@layout$graphic_fun_list, function(object) {

-            if(length(row_title) == 1 && nr_slice > 1) {

-                draw_title(object, k = 1, which = "row")

-            } else {

-                for(i in seq_len(nr_slice)) {

-                    draw_title(object, k = i, which = "row", y = slice_y[i], height = slice_height[i], just = "top")

-                }

-            }

-        })

-    }

+    definition = function(object, internal = FALSE, test = FALSE, ...) {

-    ##########################################

-    ## dend on left or right

-    show_row_dend = object@row_dend_param$show

-    row_dend_side = object@row_dend_param$side

-    row_dend_width = object@row_dend_param$width

-    row_dend_slice = object@row_dend_slice

-    if(show_row_dend) {

-        if(row_dend_side == "left") {

-            object@layout$layout_size$row_dend_left_width = row_dend_width

-            object@layout$layout_index = rbind(object@layout$layout_index, row_dend_left = heatmap_layout_index("row_dend_left"))

+    if(test) {

+        object = prepare(object)

+        grid.newpage()

+        if(is_abs_unit(object@heatmap_param$width)) {

+            width = object@heatmap_param$width

         } else {

-            object@layout$layout_size$row_dend_right_width = row_dend_width

-            object@layout$layout_index = rbind(object@layout$layout_index, row_dend_right = heatmap_layout_index("row_dend_right"))

+            width = 0.8

         }

-        row_dend_max_height = dend_heights(row_dend_slice) + max(dend_heights(object@row_dend_list))

-        object@layout$graphic_fun_list = c(object@layout$graphic_fun_list, function(object) {

-            

-            if(row_dend_side == "left") {

-                pushViewport(viewport(x = unit(0, "npc"), width = unit(1, "npc") - DENDROGRAM_PADDING, just = "left"))

-            } else {

-                pushViewport(viewport(x = DENDROGRAM_PADDING, width = unit(1, "npc") - DENDROGRAM_PADDING, just = "left"))

-            }

-            for(i in seq_len(nr_slice)) {

-                draw_dend(object, k = i, which = "row", y = slice_y[i], height = slice_height[i], just = "top",

-                    max_height = row_dend_max_height)

-            }

-

-            if(nr_slice > 1) {

-                if(row_dend_side == "left") {

-                    pushViewport(viewport(xscale = c(0, row_dend_max_height)))

-                } else {

-                    pushViewport(viewport(xscale = c(0, row_dend_max_height)))

-                }

-                p = sapply(object@row_dend_list, function(x) {

-                    attr(x, "x")/nobs(x)

-                })

-

-                nb = sapply(object@row_dend_list, nobs)

-

-                slice_leaf_pos = slice_y

-                for(i in seq_len(nr_slice)) {

-                    slice_leaf_pos[i] = slice_leaf_pos[i] - slice_height[i]*p[i]

-                }

-                row_dend_slice = merge(row_dend_slice, object@row_dend_list, only_parent = TRUE)

-                row_dend_slice = adjust_dend_by_x(row_dend_slice, slice_leaf_pos)

-                grid.dendrogram(row_dend_slice, facing = ifelse(row_dend_side == "left", "right", "left"))

-                popViewport()

-            }

-            upViewport()

-        })

-    }

-

-    ##########################################

-    ## dend on top or bottom

-    show_column_dend = object@column_dend_param$show

-    column_dend_side = object@column_dend_param$side

-    column_dend_height = object@column_dend_param$height

-    column_dend_slice = object@column_dend_slice

-    if(show_column_dend) {

-        if(column_dend_side == "top") {

-            object@layout$layout_size$column_dend_top_height = column_dend_height

-            object@layout$layout_index = rbind(object@layout$layout_index, column_dend_top = heatmap_layout_index("column_dend_top"))

+        if(is_abs_unit(object@heatmap_param$height)) {

+            height = object@heatmap_param$height

         } else {

-            object@layout$layout_size$column_dend_bottom_height = column_dend_height

-            object@layout$layout_index = rbind(object@layout$layout_index, column_dend_bottom = heatmap_layout_index("column_dend_bottom"))

+            height = 0.8

         }

-        column_dend_max_height = dend_heights(column_dend_slice) + max(dend_heights(object@column_dend_list))

-        object@layout$graphic_fun_list = c(object@layout$graphic_fun_list, function(object) {

-            if(column_dend_side == "top") {

-                pushViewport(viewport(y = DENDROGRAM_PADDING, height = unit(1, "npc") - DENDROGRAM_PADDING, just = "bottom"))

-            } else {

-                pushViewport(viewport(y = unit(0, "npc"), height = unit(1, "npc") - DENDROGRAM_PADDING, just = "bottom"))

-            }

-            for(i in seq_len(nc_slice)) {

-                draw_dend(object, k = i, which = "column", x = slice_x[i], width = slice_width[i], just = "left",

-                    max_height = column_dend_max_height)

-            }

-

-            if(nc_slice > 1) {

-                if(column_dend_side == "top") {

-                    pushViewport(viewport(yscale = c(0, column_dend_max_height)))

+        pushViewport(viewport(width = width, height = height))

+        draw(object, internal = TRUE)

+        upViewport()

+    } else {

+        if(internal) {  # a heatmap without legend

+            if(ncol(object@matrix) == 0 || nrow(object@matrix) == 0) return(invisible(NULL))

+            layout = grid.layout(nrow = length(HEATMAP_LAYOUT_COLUMN_COMPONENT), 

+                ncol = length(HEATMAP_LAYOUT_ROW_COMPONENT), widths = component_width(object), 

+                heights = component_height(object))

+            pushViewport(viewport(layout = layout))

+            ht_layout_index = object@layout$layout_index

+            ht_graphic_fun_list = object@layout$graphic_fun_list

+            for(j in seq_len(nrow(ht_layout_index))) {

+                if(HEATMAP_LAYOUT_COLUMN_COMPONENT["heatmap_body"] %in% ht_layout_index[j, 1] && 

+                   HEATMAP_LAYOUT_ROW_COMPONENT["heatmap_body"] %in% ht_layout_index[j, 2]) {

+                    pushViewport(viewport(layout.pos.row = ht_layout_index[j, 1], layout.pos.col = ht_layout_index[j, 2], name = paste(object@name, "heatmap_body_wrap", sep = "_")))

                 } else {

-                    pushViewport(viewport(yscale = c(0, column_dend_max_height)))

-                }

-                p = sapply(object@column_dend_list, function(x) {

-                    attr(x, "x")/nobs(x)

-                })

-

-                nb = sapply(object@column_dend_list, nobs)

-

-                slice_leaf_pos = slice_x

-                for(i in seq_len(nc_slice)) {

-                    slice_leaf_pos[i] = slice_leaf_pos[i] + slice_width[i]*p[i]

+                    pushViewport(viewport(layout.pos.row = ht_layout_index[j, 1], layout.pos.col = ht_layout_index[j, 2]))

                 }

-                column_dend_slice = merge(column_dend_slice, object@column_dend_list, only_parent = TRUE)

-                column_dend_slice = adjust_dend_by_x(column_dend_slice, slice_leaf_pos)

-                grid.dendrogram(column_dend_slice, facing = ifelse(column_dend_side == "top", "bottom", "top"))

-                popViewport()

+                ht_graphic_fun_list[[j]](object)

+                upViewport()

             }

             upViewport()

-        })

-    }

-

-    #######################################

-    ## row_names on left or right

-    row_names_side = object@row_names_param$side

-    show_row_names = object@row_names_param$show

-    row_names_anno = object@row_names_param$anno

-    if(show_row_names) {

-        row_names_width = row_names_anno@width + DIMNAME_PADDING*2

-        row_names_width = min(row_names_width, object@row_names_param$max_width)

-        if(row_names_side == "left") {

-            object@layout$layout_size$row_names_left_width = row_names_width

-            object@layout$layout_index = rbind(object@layout$layout_index, row_names_left = heatmap_layout_index("row_names_left"))

-        } else {

-            object@layout$layout_size$row_names_right_width = row_names_width

-            object@layout$layout_index = rbind(object@layout$layout_index, row_names_right = heatmap_layout_index("row_names_right"))

-        }

-        object@layout$graphic_fun_list = c(object@layout$graphic_fun_list, function(object) {

-            for(i in seq_len(nr_slice)) {

-                draw_dimnames(object, k = i, which = "row", y = slice_y[i], 

-                    height = slice_height[i], width = unit(1, "npc") - DIMNAME_PADDING*2, just = "top")

-            }

-        })

-    }

-

-    #########################################

-    ## column_names on top or bottom

-    column_names_side = object@column_names_param$side

-    show_column_names = object@column_names_param$show

-    column_names_anno = object@column_names_param$anno

-    if(show_column_names) {

-        column_names_height = column_names_anno@height + DIMNAME_PADDING*2

-        column_names_height = min(column_names_height, object@column_names_param$max_height)

-        if(column_names_side == "top") {

-            object@layout$layout_size$column_names_top_height = column_names_height

-            object@layout$layout_index = rbind(object@layout$layout_index, column_names_top = heatmap_layout_index("column_names_top"))

         } else {

-            object@layout$layout_size$column_names_bottom_height = column_names_height

-            object@layout$layout_index = rbind(object@layout$layout_index, column_names_bottom = heatmap_layout_index("column_names_bottom"))

-        }

-        object@layout$graphic_fun_list = c(object@layout$graphic_fun_list, function(object) {

-            for(i in seq_len(nc_slice)) {

-                draw_dimnames(object, k = i, which = "column", x = slice_x[i], 

-                    width = slice_width[i], height = unit(1, "npc") - DIMNAME_PADDING*2, just = "left")

+            if(ncol(object@matrix) == 0) {

+                stop("Single heatmap should contains a matrix with at least one column. Zero-column matrix can only be appended to the heatmap list.")

             }

-        })

-    }

-    

-    ##########################################

-    ## annotation on top

-    annotation = object@top_annotation

-    annotation_height = object@top_annotation_param$height

-    if(!is.null(annotation)) {

-        if(length(annotation@anno_list) > 0) {

-            object@layout$layout_size$column_anno_top_height = annotation_height

-            object@layout$layout_index = rbind(object@layout$layout_index, column_anno_top = heatmap_layout_index("column_anno_top"))

-            

-            object@layout$graphic_fun_list = c(object@layout$graphic_fun_list, function(object) {

-                for(i in seq_len(nc_slice)) {

-                    draw_annotation(object, k = i, which = "top", x = slice_x[i], width = slice_width[i], 

-                        y = COLUMN_ANNO_PADDING, height = unit(1, "npc") - COLUMN_ANNO_PADDING, 

-                        just = c("left", "bottom"))

-                }

-            }) 

-        }

-    }

-

-    ##########################################

-    ## annotation on bottom

-    annotation = object@bottom_annotation

-    annotation_height = object@bottom_annotation_param$height

-    if(!is.null(annotation)) {

-        if(length(annotation@anno_list) > 0) {

-            object@layout$layout_size$column_anno_bottom_height = annotation_height

-            object@layout$layout_index = rbind(object@layout$layout_index, column_anno_bottom = heatmap_layout_index("column_anno_bottom"))

-            object@layout$graphic_fun_list = c(object@layout$graphic_fun_list, function(object) {

-                for(i in seq_len(nc_slice)) {

-                    draw_annotation(object, k = i, which = "bottom", x = slice_x[i], width = slice_width[i], 

-                        y = unit(0, "npc"), height = unit(1, "npc") - COLUMN_ANNO_PADDING, 

-                        just = c("left", "bottom"))

-                }

-            })

-        }

-    }

-

-    ##########################################

-    ## annotation on left

-    annotation = object@left_annotation

-    annotation_width = object@left_annotation_param$width

-    if(!is.null(annotation)) {

-        if(length(annotation@anno_list) > 0) {

-            object@layout$layout_size$row_anno_left_width = annotation_width

-            object@layout$layout_index = rbind(object@layout$layout_index, row_anno_left = heatmap_layout_index("row_anno_left"))

-            object@layout$graphic_fun_list = c(object@layout$graphic_fun_list, function(object) {

-                    for(i in seq_len(nr_slice)) {

-                        draw_annotation(object, k = i, which = "left",  y = slice_y[i], height = slice_height[i], 

-                            x = unit(0, "npc"), width = unit(1, "npc") - ROW_ANNO_PADDING, 

-                            just = c("left", "top"))

-                    }

-                }

-            )

-        }

-    }

-

-    ##########################################

-    ## annotation on right

-    annotation = object@right_annotation

-    annotation_width = object@right_annotation_param$width

-    if(!is.null(annotation)) {

-        if(length(annotation@anno_list) > 0) {

-            object@layout$layout_size$row_anno_right_width = annotation_width

-            object@layout$layout_index = rbind(object@layout$layout_index, row_anno_right = heatmap_layout_index("row_anno_right"))

-            object@layout$graphic_fun_list = c(object@layout$graphic_fun_list, function(object) {

-                for(i in seq_len(nr_slice)) {

-                    draw_annotation(object, k = i, which = "right", y = slice_y[i], height = slice_height[i], 

-                        x = ROW_ANNO_PADDING, width = unit(1, "npc") - ROW_ANNO_PADDING, 

-                        just = c("left", "top"))

-                }

-            })

-        }

-    }

-

-    layout_size = object@layout$layout_size

-    if(is_abs_unit(object@heatmap_param$width)) {

-        # recalcualte the width of heatmap body

-        object@matrix_param$width = object@heatmap_param$width -

-            sum(layout_size$row_title_left_width,

-                layout_size$row_dend_left_width,

-                layout_size$row_anno_left_width,

-                layout_size$row_names_left_width,

-                layout_size$row_dend_right_width,

-                layout_size$row_anno_right_width,

-                layout_size$row_names_right_width,

-                layout_size$row_title_right_width)   

-    } else if(is_abs_unit(object@matrix_param$width)) {  # e.g. unit(1, "npc")

-        object@heatmap_param$width = sum(

-            layout_size$row_title_left_width,

-            layout_size$row_dend_left_width,

-            layout_size$row_names_left_width,

-            layout_size$row_dend_right_width,

-            layout_size$row_names_right_width,

-            layout_size$row_title_right_width,

-            layout_size$row_anno_left_width,

-            layout_size$row_anno_right_width

-        ) + object@matrix_param$width

-        if(nr_slice > 1) {

-            object@heatmap_param$width = object@heatmap_param$width + sum(row_gap[seq_len(nr_slice-1)])

-        }

-    } else {

-        if(!is.unit(object@heatmap_param$width)) {

-            warning("width of the heatmap can only be set as an absolute unit.")

-        }

-        object@heatmap_param$width = unit(1, "npc")

-    }

-

-    if(is_abs_unit(object@heatmap_param$height)) {

-        object@matrix_param$height = object@heatmap_param$height - 

-            sum(layout_size$column_title_top_height,

-                layout_size$column_dend_top_height,

-                layout_size$column_anno_top_height,

-                layout_size$column_names_top_height,

-                layout_size$column_title_bottom_height,

-                layout_size$column_dend_bottom_height,

-                layout_size$column_anno_bottom_height,

-                layout_size$column_names_bottom_height)

-    } else if(is_abs_unit(object@matrix_param$height)) {

-        object@heatmap_param$height = sum(

-            layout_size$column_title_top_height,

-            layout_size$column_dend_top_height,

-            layout_size$column_anno_top_height,

-            layout_size$column_names_top_height,

-            layout_size$column_title_bottom_height,

-            layout_size$column_dend_bottom_height,

-            layout_size$column_anno_bottom_height,

-            layout_size$column_names_bottom_height

-        ) + object@matrix_param$height

-        if(nc_slice > 1) {

-            object@heatmap_param$height = object@heatmap_param$height + sum(column_gap[seq_len(nc_slice-1)])

+            ht_list = new("HeatmapList")

+            ht_list = add_heatmap(ht_list, object)

+            draw(ht_list, ...)

         }

-    } else {

-        object@heatmap_param$height = unit(1, "npc")

     }

-

-    object@heatmap_param$width_is_absolute_unit = is_abs_unit(object@heatmap_param$width) 

-    object@heatmap_param$height_is_absolute_unit = is_abs_unit(object@heatmap_param$height) 

-    

-    return(object)

 })

 # == title

-# Draw the Single Heatmap with Defaults

-#

-# == param

-# -object A `Heatmap-class` object.

-#

-# == details

-# It actually calls `draw,Heatmap-method`, but only with default parameters. If users want to customize the heatmap,

-# they can pass parameters directly to `draw,Heatmap-method`.

-#

-# == value

-# The `HeatmapList-class` object.

-#

-# == author

-# Zuguang Gu <z.gu@dkfz.de>

-#

-setMethod(f = "show",

-    signature = "Heatmap",

-    definition = function(object) {

-

-    draw(object)

-})

-

-# == title

-# Add Heatmap to the Heatmap List

+# Prepare the Heatmap

 #

 # == param

 # -object A `Heatmap-class` object.

-# -x a `Heatmap-class` object, a `HeatmapAnnotation-class` object or a `HeatmapList-class` object.

-# -direction Whether the heatmap is added horizontal or vertically?

-#

-# == details

-# There is a shortcut function ``+.AdditiveUnit``.

-#

-# == value

-# A `HeatmapList-class` object.

-#

-# == author

-# Zuguang Gu <z.gu@dkfz.de>

-#

-setMethod(f = "add_heatmap",

-    signature = "Heatmap",

-    definition = function(object, x, direction = c("horizontal", "vertical")) {

-

-    direction = match.arg(direction)[1]

-

-    ht_list = new("HeatmapList")

-    ht_list@direction = direction

-    

-    ht_list = add_heatmap(ht_list, object, direction = direction)

-    ht_list = add_heatmap(ht_list, x, direction = direction)

-    return(ht_list)

-

-})

-

-# == title

-# Draw the heatmap body

+# -process_rows Whether to process rows of the heatmap.

 #

-# == param

-# -object A `Heatmap-class` object.

-# -kr Row slice index.

-# -kc Column slice index.

-# -... Pass to `grid::viewport` which includes the subset of heatmap body.

+# == detail

+# The preparation of the heatmap includes following steps:

 #

-# == details

-# A viewport is created which contains subset rows and columns of the heatmap.

+# - making clustering on rows if it is specified (by calling `make_row_cluster,Heatmap-method`)

+# - making clustering on columns (by calling `make_column_cluster,Heatmap-method`)

+# - making the layout of the heatmap (by calling `make_layout,Heatmap-method`)

 #

 # This function is only for internal use.

 #

 # == value

-# This function returns no value.

+# The `Heatmap-class` object.

 #

 # == author

 # Zuguang Gu <z.gu@dkfz.de>

 #

-setMethod(f = "draw_heatmap_body",

+setMethod(f = "prepare",

     signature = "Heatmap",

-    definition = function(object, kr = 1, kc = 1, ...) {

-

-    if(ncol(object@matrix) == 0 || nrow(object@matrix) == 0) {

-        return(invisible(NULL))

-    }

-

-    row_order = object@row_order_list[[kr]]

-    column_order = object@column_order_list[[kc]]

-

-    gp = object@matrix_param$gp

-    border = object@matrix_param$border

-

-    use_raster = object@heatmap_param$use_raster

-    raster_device = object@heatmap_param$raster_device

-    raster_quality = object@heatmap_param$raster_quality

-    raster_device_param = object@heatmap_param$raster_device_param

-    if(length(raster_device_param) == 0) raster_device_param = list()

-

-    pushViewport(viewport(name = paste(object@name, "heatmap_body", kr, kc, sep = "_"), ...))

-

-    mat = object@matrix[row_order, column_order, drop = FALSE]

-    col_matrix = map_to_colors(object@matrix_color_mapping, mat)

-

-    nc = ncol(mat)

-    nr = nrow(mat)

-    x = (seq_len(nc) - 0.5) / nc

-    y = (rev(seq_len(nr)) - 0.5) / nr

-    expand_index = expand.grid(seq_len(nr), seq_len(nc))

-    

-    cell_fun = object@matrix_param$cell_fun

-    if(!is.null(cell_fun)) {

-        use_raster = FALSE

-    }

-        

-    if(use_raster) {

-        # write the image into a temporary file and read it back

-        device_info = switch(raster_device,

-            png = c("grDevices", "png", "readPNG"),

-            jpeg = c("grDevices", "jpeg", "readJPEG"),

-            tiff = c("grDevices", "tiff", "readTIFF"),

-            CairoPNG = c("Cairo", "png", "readPNG"),

-            CairoJPEG = c("Cairo", "jpeg", "readJPEG"),

-            CairoTIFF = c("Cairo", "tiff", "readTIFF")

-        )

-        if(!requireNamespace(device_info[1])) {

-            stop(paste0("Need ", device_info[1], " package to write image."))

-        }

-        if(!requireNamespace(device_info[2])) {

-            stop(paste0("Need ", device_info[2], " package to read image."))

-        }

-        # can we get the size of the heatmap body?

-        heatmap_width = convertWidth(unit(1, "npc"), "bigpts", valueOnly = TRUE)

-        heatmap_height = convertHeight(unit(1, "npc"), "bigpts", valueOnly = TRUE)

-        if(heatmap_width <= 0 || heatmap_height <= 0) {

-            stop("The width or height of the raster image is zero, maybe you forget to turn off the previous graphic device or it was corrupted. Run `dev.off()` to close it.")

-        }

-        

-        temp_dir = tempdir()

-                # dir.create(tmp_dir, showWarnings = FALSE)

-        temp_image = tempfile(pattern = paste0(".heatmap_body_", object@name, "_", kr, "_", kc), tmpdir = temp_dir, fileext = paste0(".", device_info[2]))

-        #getFromNamespace(raster_device, ns = device_info[1])(temp_image, width = heatmap_width*raster_quality, height = heatmap_height*raster_quality)

-        device_fun = getFromNamespace(raster_device, ns = device_info[1])

-

-        do.call(device_fun, c(list(filename = temp_image, width = max(c(heatmap_width*raster_quality, 1)), height = max(c(heatmap_height*raster_quality, 1))), raster_device_param))

-        grid.rect(x[expand_index[[2]]], y[expand_index[[1]]], width = unit(1/nc, 'npc'), height = unit(1/nr, 'npc'), gp = do.call('gpar', c(list(fill = col_matrix), gp)))

-        dev.off2()

-        

-        # ############################################

-        # ## make the heatmap body in a another process

-        # temp_R_data = tempfile(pattern = paste0(".heatmap_body_", object@name, "_", kr, "_", kc), tmpdir = temp_dir, fileext = paste0(".RData"))

-        # temp_R_file = tempfile(pattern = paste0(".heatmap_body_", object@name, "_", kr, "_", kc), tmpdir = temp_dir, fileext = paste0(".R"))

-        # if(Sys.info()["sysname"] == "Windows") {

-        #     temp_image = gsub("\\\\", "/", temp_image)

-        #     temp_R_data = gsub("\\\\", "/", temp_R_data)

-        #     temp_R_file = gsub("\\\\", "/", temp_R_file)

-        # }

-        # save(device_fun, device_info, temp_image, heatmap_width, raster_quality, heatmap_height, raster_device_param,

-        #     gp, x, expand_index, nc, nr, col_matrix, row_order, column_order, y,

-        #     file = temp_R_data)

-        # R_cmd = qq("

-        # library(@{device_info[1]})

-        # library(grid)

-        # load('@{temp_R_data}')

-        # do.call('device_fun', c(list(filename = temp_image, width = max(c(heatmap_width*raster_quality, 1)), height = max(c(heatmap_height*raster_quality, 1))), raster_device_param))

-        # grid.rect(x[expand_index[[2]]], y[expand_index[[1]]], width = unit(1/nc, 'npc'), height = unit(1/nr, 'npc'), gp = do.call('gpar', c(list(fill = col_matrix), gp)))

-        # dev.off()

-        # q(save = 'no')

-        # ", code.pattern = "@\\{CODE\\}")

-        # writeLines(R_cmd, con = temp_R_file)

-        # if(grepl(" ", temp_R_file)) {

-        #     if(is_windows()) {

-        #         oe = try(system(qq("\"@{normalizePath(R_binary(), winslash='/')}\" --vanilla < \'@{temp_R_file}\'", code.pattern = "@\\{CODE\\}"), ignore.stdout = TRUE, ignore.stderr = TRUE, show.output.on.console = FALSE), silent = TRUE)

-        #     } else {

-        #         oe = try(system(qq("\"@{normalizePath(R_binary(), winslash='/')}\" --vanilla < \'@{temp_R_file}\'", code.pattern = "@\\{CODE\\}"), ignore.stdout = TRUE, ignore.stderr = TRUE), silent = TRUE)