@@ -25,7 +25,7 @@ setGeneric('prepare', function(object, ...) standardGeneric('prepare'))

 setGeneric('draw_annotation', function(object, ...) standardGeneric('draw_annotation'))

-setGeneric('get_color_mapping_param_list', function(object, ...) standardGeneric('get_color_mapping_param_list'))

+setGeneric('get_legend_param_list', function(object, ...) standardGeneric('get_legend_param_list'))

 setGeneric('draw_dimnames', function(object, ...) standardGeneric('draw_dimnames'))

@@ -55,4 +55,5 @@ setGeneric('row_dend', function(object, ...) standardGeneric('row_dend'))

 setGeneric('copy_all', function(object, ...) standardGeneric('copy_all'))

 setGeneric('resize', function(object, ...) standardGeneric('resize'))

+setGeneric('adjust_heatmap_list', function(object, ...) standardGeneric('adjust_heatmap_list'))

@@ -223,10 +223,10 @@ setMethod(f = "show",

 	cat("  items:", ifelse(object@n == 0, "unknown", object@n), "\n")

 	cat("  width:", as.character(object@width), "\n")

 	cat("  height:", as.character(object@height), "\n")

-	var_imported = names(anno@var_env)

+	var_imported = names(object@var_env)

 	if(length(var_imported)) {

 		cat("  imported variable:", paste(var_imported, collapse = ", "), "\n")

-		var_subsetable = names(anno@subset_rule)

+		var_subsetable = names(object@subset_rule)

 		if(length(var_subsetable)) {

 			cat("  subsetable variable:", paste(var_subsetable, collapse = ", "), "\n")

 		}

@@ -442,19 +442,19 @@ anno_image = function(image, which = c("column", "row"), border = TRUE,

 			if(!requireNamespace("png")) {

 				stop("Need png package to read png images.")

 			}

-			image_list[[i]] = getFromNamespace("readPNG", ns = "png")(image[i])

+			image_list[[i]] = png::readPNG(image[i])

 			image_class[i] = "raster"

 		} else if(image_type[i] %in% c("jpeg", "jpg")) {

 			if(!requireNamespace("jpeg")) {

 				stop("Need jpeg package to read jpeg/jpg images.")

 			}

-			image_list[[i]] = getFromNamespace("readJPEG", ns = "jpeg")(image[i])

+			image_list[[i]] = jpeg::readJPEG(image[i])

 			image_class[i] = "raster"

 		} else if(image_type[i] == "tiff") {

 			if(!requireNamespace("tiff")) {

 				stop("Need tiff package to read tiff images.")

 			}

-			image_list[[i]] = getFromNamespace("readTIFF", ns = "tiff")(image[i])

+			image_list[[i]] = tiff::readTIFF(image[i])

 			image_class[i] = "raster"

 		} else if(image_type[i] %in% c("pdf", "eps")) {

 			if(!requireNamespace("grImport")) {

@@ -462,7 +462,7 @@ anno_image = function(image, which = c("column", "row"), border = TRUE,

 			}

 			temp_file = tempfile()

 			getFromNamespace("PostScriptTrace", ns = "grImport")(image[[i]], temp_file)

-			image_list[[i]] = getFromNamespace("readPicture", ns = "grImport")(temp_file)

+			image_list[[i]] = grImport::readPicture(temp_file)

 			file.remove(temp_file)

 			image_class[i] = "grImport::Picture"

 		} else if(image_type[i] == "svg") {

@@ -473,8 +473,8 @@ anno_image = function(image, which = c("column", "row"), border = TRUE,

 				stop("Need rsvg package to convert svg images.")

 			}

 			temp_file = tempfile()

-			getFromNamespace("rsvg_svg", ns = "rsvg")(image[i], temp_file)

-			image_list[[i]] = getFromNamespace("readPicture", ns = "grImport2")(temp_file)

+			rsvg::rsvg_svg(image[i], temp_file)

+			image_list[[i]] = grImport2::readPicture(temp_file)

 			file.remove(temp_file)

 			image_class[i] = "grImport2::Picture"

 		}

@@ -781,6 +781,147 @@ update_anno_extend = function(anno, axis_grob, axis_param) {

 	return(extended)

 }

+anno_lines = function(x, which = c("column", "row"), border = TRUE, gp = gpar(), 

+	add_points = TRUE, pch = 16, size = unit(2, "mm"), pt_gp = gpar(), ylim = NULL, 

+	extend = 0.05, axis = TRUE, axis_param = default_axis_param(which),

+	width = NULL, height = NULL) {

+

+	if(is.null(.ENV$current_annotation_which)) {

+		which = match.arg(which)[1]

+	} else {

+		which = .ENV$current_annotation_which

+	}

+

+	if(is.data.frame(x)) x = as.matrix(x)

+	if(is.matrix(x)) {

+		if(ncol(x) == 1) {

+			x = x[, 1]

+		}

+	}

+	input_is_matrix = is.matrix(x)

+

+	anno_size = anno_width_and_height(which, width, height, unit(1, "cm"))

+

+	if(is.matrix(x)) {

+		n = nrow(x)

+		nr = n

+		nc = ncol(x)

+	} else {

+		n = length(x)

+		nr = n

+		nc = 1

+	}

+

+	if(is.atomic(x)) {

+		gp = recycle_gp(gp, 1)

+		pt_gp = recycle_gp(pt_gp, n)

+		if(length(pch) == 1) pch = rep(pch, n)

+		if(length(size) == 1) size = rep(size, n)

+	} else if(input_is_matrix) {

+		gp = recycle_gp(gp, nc)

+		pt_gp = recycle_gp(pt_gp, nc)

+		if(length(pch) == 1) pch = rep(pch, nc)

+		if(length(size) == 1) size = rep(size, nc)

+	}

+	

+	if(is.null(ylim)) {

+		data_scale = range(x, na.rm = TRUE)

+	} else {

+		data_scale = ylim

+	}

+	data_scale = data_scale + c(-extend, extend)*(data_scale[2] - data_scale[1])

+

+	value = x

+

+	axis_param = validate_axis_param(axis_param, which)

+	axis_grob = if(axis) construct_axis_grob(axis_param, which, data_scale) else NULL

+

+	row_fun = function(index) {

+		n = length(index)

+

+		pushViewport(viewport(xscale = data_scale, yscale = c(0.5, n+0.5)))

+		if(is.matrix(value)) {

+			for(i in seq_len(ncol(value))) {

+				grid.lines(value[index, i], n - seq_along(index) + 1, gp = subset_gp(gp, i), 

+					default.units = "native")

+				if(add_points) {

+					grid.points(value[index, i], n - seq_along(index) + 1, gp = subset_gp(pt_gp, i), 

+						default.units = "native", pch = pch[i], size = size[i])

+				}

+			}

+		} else {

+			grid.lines(value[index, i], n - seq_along(index) + 1, gp = gp, 

+				default.units = "native")

+			if(add_points) {

+				grid.points(value[index], n - seq_along(index) + 1, gp = gp, default.units = "native", 

+					pch = pch[index], size = size[index])

+			}

+		}

+		if(axis) grid.draw(axis_grob)

+		if(border) grid.rect(gp = gpar(fill = "transparent"))

+		popViewport()

+	}

+

+	column_fun = function(index) {

+		n = length(index)

+		

+		pushViewport(viewport(yscale = data_scale, xscale = c(0.5, n+0.5)))

+		if(is.matrix(value)) {

+			for(i in seq_len(ncol(value))) {

+				grid.lines(seq_along(index), value[index, i], gp = subset_gp(gp, i), 

+					default.units = "native")

+				if(add_points) {

+					grid.points(seq_along(index), value[index, i], gp = subset_gp(pt_gp, i), 

+						default.units = "native", pch = pch[i], size = size[i])

+				}

+			}

+		} else {

+			grid.lines(seq_along(index), value[index], gp = gp, default.units = "native")

+			if(add_points) {

+				grid.points(seq_along(index), value[index], gp = pt_gp, default.units = "native", 

+					pch = pch[index], size = size[index])

+			}

+		}

+		if(axis) grid.draw(axis_grob)

+		if(border) grid.rect(gp = gpar(fill = "transparent"))

+		popViewport()

+	}

+

+	if(which == "row") {

+		fun = row_fun

+	} else if(which == "column") {

+		fun = column_fun

+	}

+

+	anno = AnnotationFunction(

+		fun = fun,

+		fun_name = "anno_points",

+		which = which,

+		width = anno_size$width,

+		height = anno_size$height,

+		n = n,

+		data_scale = data_scale,

+		var_import = list(value, gp, border, pch, size, pt_gp, axis, axis_param, axis_grob, data_scale, add_points)

+	)

+

+	anno@subset_rule$gp = subset_vector

+	if(input_is_matrix) {

+		anno@subset_rule$value = subset_matrix_by_row

+	} else {

+		anno@subset_rule$value = subset_vector

+		anno@subset_rule$gp = subset_gp

+		anno@subset_rule$pt_gp = subset_gp

+		anno@subset_rule$size = subset_vector

+		anno@subset_rule$pch = subset_vector

+	}

+

+	anno@subsetable = TRUE

+

+	anno@extended = update_anno_extend(anno, axis_grob, axis_param)

+		

+	return(anno) 

+}

+

 # == title

 # Using barplot as annotation

 #

@@ -1526,7 +1667,7 @@ anno_text = function(x, which = c("column", "row"), gp = gpar(),

 		unit(ifelse(which == "column", 1, 0), "npc")

 	}

-	rot = rot[1]

+	rot = rot[1] %% 360

 	just = just[1]

 	if(!missing(offset)) {

 		warning("`offset` is deprecated, use `location` instead.")

@@ -307,7 +307,7 @@ setMethod(f = "color_mapping_legend",

 	if(plot) {

 		pushViewport(viewport(..., width = grobWidth(gf), height = grobHeight(gf), name = paste0("legend_", object@name)))

 		grid.draw(gf)

-		upViewport()

+		popViewport()

 	}

 	#size = unit.c(vp_width, vp_height)

@@ -71,24 +71,23 @@ Heatmap = setClass("Heatmap",

         matrix = "matrix",  # one or more matrix which are spliced by rows

         matrix_param = "list",

         matrix_color_mapping = "ANY",

-        matrix_color_mapping_param = "ANY",

+        matrix_legend_param = "ANY",

         row_title = "ANY",

-        row_title_rot = "numeric",

-        row_title_just = "numeric",

         row_title_param = "list",

         column_title = "ANY",

         column_title_param = "list",

-        column_title_rot = "numeric",

-        column_title_just = "numeric",

         row_dend_list = "list", # one or more row clusters

+        row_dend_slice = "ANY",

         row_dend_param = "list", # parameters for row cluster

         row_order_list = "list",

         row_order = "numeric",

-        column_dend = "ANY",

+        column_dend_list = "list",

+        column_dend_slice = "ANY",

         column_dend_param = "list", # parameters for column cluster

+        column_order_list = "list",

         column_order = "numeric",

         row_names_param = "list",

@@ -96,7 +95,6 @@ Heatmap = setClass("Heatmap",

         top_annotation = "ANY", # NULL or a `HeatmapAnnotation` object

         top_annotation_param = "list",

-

         bottom_annotation = "ANY",

         bottom_annotation_param = "list",

@@ -231,7 +229,9 @@ Heatmap = function(matrix, col, name,

     na_col = "grey", 

     color_space = "LAB",

     rect_gp = gpar(col = NA), 

+    border = NA,

     cell_fun = NULL,

+

     row_title = character(0), 

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

     row_title_gp = gpar(fontsize = 14), 

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

     column_title_side = c("top", "bottom"), 

     column_title_gp = gpar(fontsize = 14), 

     column_title_rot = 0,

+

     cluster_rows = TRUE, 

     clustering_distance_rows = "euclidean",

     clustering_method_rows = "complete", 

@@ -248,11 +249,6 @@ Heatmap = function(matrix, col, name,

     show_row_dend = TRUE, 

     row_dend_reorder = TRUE,

     row_dend_gp = gpar(), 

-    row_hclust_side = row_dend_side,

-    row_hclust_width = row_dend_width, 

-    show_row_hclust = show_row_dend, 

-    row_hclust_reorder = row_dend_reorder,

-    row_hclust_gp = row_dend_gp, 

     cluster_columns = TRUE, 

     clustering_distance_columns = "euclidean", 

     clustering_method_columns = "complete",

@@ -261,89 +257,95 @@ Heatmap = function(matrix, col, name,

     show_column_dend = TRUE, 

     column_dend_gp = gpar(), 

     column_dend_reorder = TRUE,

-    column_hclust_side = column_dend_side, 

-    column_hclust_height = column_dend_height, 

-    show_column_hclust = show_column_dend, 

-    column_hclust_gp = column_dend_gp, 

-    column_hclust_reorder = column_dend_reorder,

+

     row_order = NULL, 

     column_order = NULL,

+

+    row_labels = rownames(matrix),

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

     show_row_names = TRUE, 

-    row_names_max_width = default_row_names_max_width(), 

+    row_names_max_width = unit(6, "cm"), 

     row_names_gp = gpar(fontsize = 12), 

+    row_names_rot = 0,

+    column_labels = colnames(matrix),

     column_names_side = c("bottom", "top"), 

     show_column_names = TRUE, 

-    column_names_max_height = default_column_names_max_height(), 

+    column_names_max_height = unit(6, "cm"), 

     column_names_gp = gpar(fontsize = 12),

+    column_names_rot = 90,

+

     top_annotation = new("HeatmapAnnotation"),

     top_annotation_height = top_annotation@size,

     bottom_annotation = new("HeatmapAnnotation"),

     bottom_annotation_height = bottom_annotation@size,

+

     km = 1, 

-    km_title = "cluster%i",

     split = NULL, 

+    row_km = km,

+    row_split = split,

     column_km = 1,

-    column_km_title = "cluster%i",

     column_split = NULL,

     gap = unit(1, "mm"),

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

-    combined_name_fun = function(x) paste(x, collapse = "/"),

-    width = NULL, 

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

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

+

+    width = unit(1, "npc"),

+    heatmap_body_width = NULL,

+    height = unit(1, "npc"), 

+    heatmap_body_height = NULL,

+

     show_heatmap_legend = TRUE,

     heatmap_legend_param = list(title = name),

-    use_raster = FALSE, 

+

+    use_raster = nrow(matrix) > 5000, 

     raster_device = c("png", "jpeg", "tiff", "CairoPNG", "CairoJPEG", "CairoTIFF"),

     raster_quality = 2,

     raster_device_param = list()) {

+    verbose = ht_global_opt("verbose")

+

+    if(!dev.interactive()) {

+        pdf(file = NULL)

+        on.exit(dev.off())

+    }

+

+    .Object = new("Heatmap")

+    if(missing(name)) {

+        name = paste0("matrix_", get_heatmap_index() + 1)

+        increase_heatmap_index()

+    }

+    .Object@name = name

+

     # re-define some of the argument values according to global settings

     called_args = names(as.list(match.call())[-1])

-    e = environment()

     for(opt_name in c("row_names_gp", "column_names_gp", "row_title_gp", "column_title_gp")) {

         opt_name2 = paste0("heatmap_", opt_name)

         if(! opt_name %in% called_args) { # if this argument is not called

             if(!is.null(ht_global_opt(opt_name2))) {

-                assign(opt_name, ht_global_opt(opt_name2), envir = e)

+                if(verbose) qqcat("re-assign @{opt_name} with `ht_global_opt('@{opt_name2}'')`\n")

+                assign(opt_name, ht_global_opt(opt_name2))

             }

         }

     }

-    for(ca in called_args) {

-        if(ca %in% c("row_hclust_side", "row_hclust_width", "show_row_hclust", "row_hclust_reorder", "row_hclust_gp",

-                     "column_hclust_side", "column_hclust_height", "show_column_hclust", "column_hclust_gp", "column_hclust_reorder")) {

-            ca_new = gsub("hclust", "dend", ca)

-            if(!ca_new %in% called_args) {

-                assign(ca_new, get(ca))

-            }

-            warning(paste0("'", ca, "' is deprecated in the future, use '", ca_new, "' instead."))

-        }

-    }

-   

     if("heatmap_legend_param" %in% called_args) {

         for(opt_name in setdiff(c("title_gp", "title_position", "labels_gp", "grid_width", "grid_height", "grid_border"), names(heatmap_legend_param))) {

             opt_name2 = paste0("heatmap_legend_", opt_name)

             if(!is.null(ht_global_opt(opt_name2)))

+                if(verbose) qqcat("re-assign heatmap_legend_param$@{opt_name} with `ht_global_opt('@{opt_name2}'')`\n")

                 heatmap_legend_param[[opt_name]] = ht_global_opt(opt_name2)

         }

     } else {

         for(opt_name in c("title_gp", "title_position", "labels_gp", "grid_width", "grid_height", "grid_border")) {

             opt_name2 = paste0("heatmap_legend_", opt_name)

             if(!is.null(ht_global_opt(opt_name2)))

+                if(verbose) qqcat("re-assign heatmap_legend_param$@{opt_name} with `ht_global_opt('@{opt_name2}'')`\n")

                 heatmap_legend_param[[opt_name]] = ht_global_opt(opt_name2)

         }

     }

-    .Object = new("Heatmap")

-

-    .Object@heatmap_param$width = width

-    .Object@heatmap_param$show_heatmap_legend = show_heatmap_legend

-    .Object@heatmap_param$use_raster = use_raster

-    .Object@heatmap_param$raster_device = match.arg(raster_device)[1]

-    .Object@heatmap_param$raster_quality = raster_quality

-    .Object@heatmap_param$raster_device_param = raster_device_param

-

     if(is.data.frame(matrix)) {

+        if(verbose) qqcat("convert data frame to matrix\n")

         matrix = as.matrix(matrix)

     }

     if(!is.matrix(matrix)) {

@@ -352,20 +354,22 @@ Heatmap = function(matrix, col, name,

             matrix = matrix(matrix, ncol = 1)

             if(!is.null(rn)) rownames(matrix) = rn

             if(!missing(name)) colnames(matrix) = name

+            if(verbose) qqcat("convert simple vector to one-column matrix\n")

         } else {

             stop("If data is not a matrix, it should be a simple vector.")

         }

     }

-    if(is.null(width)) {

-        .Object@heatmap_param$width = ncol(matrix)

-    }

-

     if(ncol(matrix) == 0) {

         .Object@heatmap_param$show_heatmap_legend = FALSE

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

     }

+    ### normalize km/split and row_km/row_split

+    if(missing(row_km)) row_km = km

+    if(missing(row_split)) row_split = split

+    if(missing(row_gap)) row_gap = gap

+

+    ####### zero and one column matrix ########

     if(ncol(matrix) == 0 || nrow(matrix) == 0) {

         if(!inherits(cluster_columns, c("dendrogram", "hclust"))) {

             cluster_columns = FALSE

@@ -375,21 +379,27 @@ Heatmap = function(matrix, col, name,

             cluster_rows = FALSE

             show_row_dend = FALSE

         }

-        km = 1

+        row_km = 1

+        column_km = 1

+        if(verbose) qqcat("zero row/column matrix, set cluster_columns/rows to FALSE\n")

     }

     if(ncol(matrix) == 1) {

         if(!inherits(cluster_columns, c("dendrogram", "hclust"))) {

             cluster_columns = FALSE

             show_column_dend = FALSE

         }

+        column_km = 1

+        if(verbose) qqcat("one-column matrix, set cluster_columns to FALSE\n")

     }

     if(nrow(matrix) == 1) {

         if(!inherits(cluster_rows, c("dendrogram", "hclust"))) {

             cluster_rows = FALSE

             show_row_dend = FALSE

         }

-        km = 1

+        row_km = 1

+        if(verbose) qqcat("one-row matrix, set cluster_rows to FALSE\n")

     }

+

     if(is.character(matrix)) {

         called_args = names(match.call()[-1])

         if("clustering_distance_rows" %in% called_args) {

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

             show_row_dend = FALSE

         }

         row_dend_reorder = FALSE

+

         if("clustering_distance_columns" %in% called_args) {

         } else if(inherits(cluster_columns, c("dendrogram", "hclust"))) {

         } else {

@@ -406,32 +417,34 @@ Heatmap = function(matrix, col, name,

             show_column_dend = FALSE

         }

         column_dend_reorder = FALSE

-        km = 1

+        row_km = 1

+        column_km = 1

+        if(verbose) qqcat("matrix is character. Do not cluster unless distance method is provided.\n")

     }

     .Object@matrix = matrix

-    .Object@matrix_param$km = km

-    .Object@matrix_param$km_title = km_title

-    .Object@matrix_param$gap = gap

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

+    .Object@matrix_param$row_km = row_km

+    .Object@matrix_param$row_gap = row_gap

+    .Object@matrix_param$column_km = column_km

+    .Object@matrix_param$column_gap = column_gap

+

+    ### check row_split and column_split ###

+    if(!is.null(row_split)) {

         if(inherits(cluster_rows, c("dendrogram", "hclust"))) {

-            .Object@matrix_param$split = split

+            .Object@matrix_param$row_split = row_split

         } else {

-            if(identical(cluster_rows, TRUE) && is.numeric(split) && length(split) == 1) {

+            if(identical(cluster_rows, TRUE) && is.numeric(row_split) && length(row_split) == 1) {

             } else {

-                if(!is.data.frame(split)) split = data.frame(split)

-                if(nrow(split) != nrow(matrix)) {

-                    stop("Length or number of rows of `split` should be same as rows in `matrix`.")

+                if(!is.data.frame(row_split)) row_split = data.frame(row_split)

+                if(nrow(row_split) != nrow(matrix)) {

+                    stop("Length or number of rows of `row_split` should be same as rows in `matrix`.")

                 }

             }

         }

     }

-    .Object@matrix_param$split = split

+    .Object@matrix_param$row_split = row_split

-

-    .Object@matrix_param$column_km = column_km

-    .Object@matrix_param$column_gap = column_gap

     if(!is.null(column_split)) {

         if(inherits(cluster_columns, c("dendrogram", "hclust"))) {

             .Object@matrix_param$column_split = column_split

@@ -440,7 +453,7 @@ Heatmap = function(matrix, col, name,

             } else {

                 if(!is.data.frame(column_split)) column_split = data.frame(column_split)

-                if(nrow(column_split) != nrow(matrix)) {

+                if(nrow(column_split) != ncol(matrix)) {

                     stop("Length or number of columns of `column_split` should be same as columns in `matrix`.")

                 }

             }

@@ -448,100 +461,132 @@ Heatmap = function(matrix, col, name,

     }

     .Object@matrix_param$column_split = column_split

-    .Object@matrix_param$gp =check_gp(rect_gp)

+

+    ### parameters for heatmap body ###

+    .Object@matrix_param$gp = check_gp(rect_gp)

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

+    .Object@matrix_param$border = border

     .Object@matrix_param$cell_fun = cell_fun

-    if(missing(name)) {

-        name = paste0("matrix_", get_heatmap_index() + 1)

-        increase_heatmap_index()

+    if(!missing(heatmap_body_width)) {

+        if(is_abs_unit(heatmap_body_width)) {

+            width = unit(1, "npc") # since width is a relative unit and all components are absolute, it will be refit

+        }

     }

-    .Object@name = name

-

-    # if(ncol(matrix) == 1 && is.null(colnames(matrix))) {

-    #     colnames(matrix) = name

-    #     .Object@matrix = matrix

-    # }

+    if(!missing(heatmap_body_height)) {

+        if(is_abs_unit(heatmap_body_height)) {

+            height = unit(1, "npc")

+        }

+    }

+    if(is.null(heatmap_body_width)) {

+        heatmap_body_width = unit(ncol(matrix), "null")

+    }

+    if(is.null(heatmap_body_height)) {

+        heatmap_body_height = unit(nrow(matrix), "null")

+    }

+    .Object@matrix_param$width = heatmap_body_width

+    .Object@matrix_param$height = heatmap_body_height

+    

-    # color for main matrix

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

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

         if(missing(col)) {

             col = default_col(matrix, main_matrix = TRUE)

+            if(verbose) qqcat("color is not specified, use randomly generated colors\n")

         }

         if(is.function(col)) {

             .Object@matrix_color_mapping = ColorMapping(col_fun = col, name = name, na_col = na_col)

+            if(verbose) qqcat("input color is a color mapping function\n")

         } else {

             if(is.null(names(col))) {

                 if(length(col) == length(unique(as.vector(matrix)))) {

                     names(col) = sort(unique(as.vector(matrix)))

                     .Object@matrix_color_mapping = ColorMapping(colors = col, name = name, na_col = na_col)

+                    if(verbose) qqcat("input color is a vector with no names, treat it as discrete color mapping\n")

                 } else if(is.numeric(matrix)) {

                     col = colorRamp2(seq(min(matrix, na.rm = TRUE), max(matrix, na.rm = TRUE), length = length(col)),

                                      col, space = color_space)

                     .Object@matrix_color_mapping = ColorMapping(col_fun = col, name = name, na_col = na_col)

+                    if(verbose) qqcat("input color is a vector with no names, treat it as continuous color mapping\n")

                 } else {

                     stop("`col` should have names to map to values in `mat`.")

                 }

             } else {

                 col = col[intersect(c(names(col), "_NA_"), as.character(matrix))]

                 .Object@matrix_color_mapping = ColorMapping(colors = col, name = name, na_col = na_col)

+                if(verbose) qqcat("input color is a named vector\n")

             }

         }

-        .Object@matrix_color_mapping_param = heatmap_legend_param

+        .Object@matrix_legend_param = heatmap_legend_param

     }

+    ##### titles, should also consider titles after row splitting #####

     if(length(row_title) == 0) {

-        row_title = character(0)

     } else if(!inherits(row_title, c("expression", "call"))) {

-            if(is.na(row_title)) {

+        if(is.na(row_title)) {

             row_title = character(0)

         } else if(row_title == "") {

             row_title = character(0)

         }

     }

     .Object@row_title = row_title

-    .Object@row_title_rot = row_title_rot %% 360

+    .Object@row_title_param$rot = row_title_rot %% 360

     .Object@row_title_param$side = match.arg(row_title_side)[1]

     .Object@row_title_param$gp = check_gp(row_title_gp)  # if the number of settings is same as number of row-splits, gp will be adjusted by `make_row_dend`

-    .Object@row_title_param$combined_name_fun = combined_name_fun

-    .Object@row_title_just = get_text_just(rot = row_title_rot, side = .Object@row_title_param$side)

+    .Object@row_title_param$just = get_text_just(rot = row_title_rot, side = .Object@row_title_param$side)

     if(length(column_title) == 0) {

-        column_title = character(0)

     } else if(!inherits(column_title, c("expression", "call"))) {

-            if(is.na(column_title)) {

+        if(is.na(column_title)) {

             column_title = character(0)

         } else if(column_title == "") {

             column_title = character(0)

         }

     }

     .Object@column_title = column_title

-    .Object@column_title_rot = column_title_rot %% 360

+    .Object@column_title_param$rot = column_title_rot %% 360

     .Object@column_title_param$side = match.arg(column_title_side)[1]

     .Object@column_title_param$gp = check_gp(column_title_gp)

-    .Object@column_title_just = get_text_just(rot = column_title_rot, side = .Object@column_title_param$side)

+    .Object@column_title_param$just = get_text_just(rot = column_title_rot, side = .Object@column_title_param$side)

+    ### row labels/column labels ###

     if(is.null(rownames(matrix))) {

         show_row_names = FALSE

     }

+    .Object@row_names_param$labels = row_labels

     .Object@row_names_param$side = match.arg(row_names_side)[1]

     .Object@row_names_param$show = show_row_names

     .Object@row_names_param$gp = check_gp(row_names_gp)

-    default_row_names_max_width = function() {

-        min(unit.c(unit(6, "cm")), max_text_width(rownames(matrix), gp = .Object@row_names_param$gp))

-    }

+    .Object@row_names_param$rot = row_names_rot

     .Object@row_names_param$max_width = row_names_max_width + unit(2, "mm")

+    # we use anno_text to draw row/column names because it already takes care of text rotation

+    if(length(row_labels)) {

+        row_names_anno = anno_text(row_labels, which = "row", gp = row_names_gp, rot = row_names_rot,

+            location = ifelse(.Object@row_names_param$side == "left", 1, 0), 

+            just = ifelse(.Object@row_names_param$side == "left", "right", "left"))

+        .Object@row_names_param$anno = row_names_anno

+    }

     if(is.null(colnames(matrix))) {

         show_column_names = FALSE

     }

+    .Object@column_names_param$labels = column_labels

     .Object@column_names_param$side = match.arg(column_names_side)[1]

     .Object@column_names_param$show = show_column_names

     .Object@column_names_param$gp = check_gp(column_names_gp)

-    default_column_names_max_height = function() {

-        min(unit.c(unit(6, "cm")), max_text_width(colnames(matrix), gp = .Object@column_names_param$gp))

-    }

+    .Object@column_names_param$rot = column_names_rot

     .Object@column_names_param$max_height = column_names_max_height + unit(2, "mm")

+    if(length(column_labels)) {

+        column_names_anno = anno_text(column_labels, which = "column", gp = column_names_gp, rot = column_names_rot,

+            location = ifelse(.Object@column_names_param$side == "top", 0, 1), 

+            just = ifelse(.Object@column_names_param$side == "top", "left", "right"))

+        .Object@column_names_param$anno = column_names_anno

+    }

+    #### dendrograms ########

+    if(missing(cluster_rows) && !missing(row_order)) {

+        cluster_rows = FALSE

+    }

     if(inherits(cluster_rows, "dendrogram") || inherits(cluster_rows, "hclust")) {

         .Object@row_dend_param$obj = cluster_rows

         .Object@row_dend_param$cluster = TRUE

@@ -576,6 +621,9 @@ Heatmap = function(matrix, col, name,

         .Object@row_order = row_order

     }

+    if(missing(cluster_columns) && !missing(column_order)) {

+        cluster_columns = FALSE

+    }

     if(inherits(cluster_columns, "dendrogram") || inherits(cluster_columns, "hclust")) {

         .Object@column_dend_param$obj = cluster_columns

         .Object@column_dend_param$cluster = TRUE

@@ -592,7 +640,7 @@ Heatmap = function(matrix, col, name,

     if(!show_column_dend) {

         column_dend_height = unit(0, "mm")

     }

-    .Object@column_dend = NULL

+    .Object@column_dend_list = list()

     .Object@column_dend_param$distance = clustering_distance_columns

     .Object@column_dend_param$method = clustering_method_columns

     .Object@column_dend_param$side = match.arg(column_dend_side)[1]

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

         .Object@column_order = column_order

     }

+    ######### annotations #############

     .Object@top_annotation = top_annotation # a `HeatmapAnnotation` object

     if(is.null(top_annotation)) {

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

@@ -638,117 +687,41 @@ Heatmap = function(matrix, col, name,

     }

     .Object@layout = list(

-        layout_column_title_top_height = unit(0, "mm"),

-        layout_column_dend_top_height = unit(0, "mm"),

-        layout_column_anno_top_height = unit(0, "mm"),

-        layout_column_names_top_height = unit(0, "mm"),

-        layout_column_title_bottom_height = unit(0, "mm"),

-        layout_column_dend_bottom_height = unit(0, "mm"),

-        layout_column_anno_bottom_height = unit(0, "mm"),

-        layout_column_names_bottom_height = unit(0, "mm"),

-

-        layout_row_title_left_width = unit(0, "mm"),

-        layout_row_dend_left_width = unit(0, "mm"),

-        layout_row_names_left_width = unit(0, "mm"),

-        layout_row_dend_right_width = unit(0, "mm"),

-        layout_row_names_right_width = unit(0, "mm"),

-        layout_row_title_right_width = unit(0, "mm"),

-

-        layout_heatmap_width = width, # for the layout of heatmap list

-

-        layout_index = matrix(nrow = 0, ncol = 2),

+        layout_size = list(

+            column_title_top_height = unit(0, "mm"),

+            column_dend_top_height = unit(0, "mm"),

+            column_anno_top_height = unit(0, "mm"),

+            column_names_top_height = unit(0, "mm"),

+            column_title_bottom_height = unit(0, "mm"),

+            column_dend_bottom_height = unit(0, "mm"),

+            column_anno_bottom_height = unit(0, "mm"),

+            column_names_bottom_height = unit(0, "mm"),

+

+            row_title_left_width = unit(0, "mm"),

+            row_dend_left_width = unit(0, "mm"),

+            row_names_left_width = unit(0, "mm"),

+            row_dend_right_width = unit(0, "mm"),

+            row_names_right_width = unit(0, "mm"),

+            row_title_right_width = unit(0, "mm")

+        ),

+

+        layout_index = data.frame(),

         graphic_fun_list = list()

     )

+    .Object@heatmap_param$width = width

+    .Object@heatmap_param$height = height

+    .Object@heatmap_param$show_heatmap_legend = show_heatmap_legend

+    .Object@heatmap_param$use_raster = use_raster

+    .Object@heatmap_param$raster_device = match.arg(raster_device)[1]

+    .Object@heatmap_param$raster_quality = raster_quality

+    .Object@heatmap_param$raster_device_param = raster_device_param

+    .Object@heatmap_param$verbose = verbose

+

     return(.Object)

 }

-# == title

-# Make cluster on columns

-#

-# == param

-# -object a `Heatmap-class` object.

-#

-# == details

-# The function will fill or adjust ``column_dend`` and ``column_order`` slots.

-#

-# This function is only for internal use.

-#

-# == value

-# A `Heatmap-class` object.

-#

-# == author

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

-#

-setMethod(f = "make_column_cluster",

-    signature = "Heatmap",

-    definition = function(object) {

-    

-    if(ht_global_opt("fast_hclust")) {

-        hclust = fastcluster::hclust

-    } else {

-        hclust = stats::hclust

-    }

-    

-    mat = object@matrix

-    distance = object@column_dend_param$distance

-    method = object@column_dend_param$method

-    order = object@column_order

-    reorder = object@column_dend_param$reorder

-

-    if(object@column_dend_param$cluster) {

-        if(!is.null(object@column_dend_param$obj)) {

-            object@column_dend = object@column_dend_param$obj

-        } else if(!is.null(object@column_dend_param$fun)) {

-            object@column_dend = object@column_dend_param$fun(t(mat))

-        } else {

-            object@column_dend = hclust(get_dist(t(mat), distance), method = method)

-        }

-        column_order = get_dend_order(object@column_dend)  # we don't need the pre-defined orders

-

-        if(inherits(object@column_dend, "hclust")) {

-            object@column_dend = as.dendrogram(object@column_dend)

-        }

-

-        if(identical(reorder, NULL)) {

-            if(is.numeric(mat)) {

-                reorder = TRUE

-            } else {

-                reorder = FALSE

-            }

-        }

-

-        do_reorder = TRUE

-        if(identical(reorder, NA) || identical(reorder, FALSE)) {

-            do_reorder = FALSE

-        }

-        if(identical(reorder, TRUE)) {

-            do_reorder = TRUE

-            reorder = colMeans(mat, na.rm = TRUE)

-        }

-

-        if(do_reorder) {

-            if(length(reorder) != ncol(mat)) {

-                stop("weight of reordering should have same length as number of columns.\n")

-            }

-            object@column_dend = reorder(object@column_dend, reorder)

-            column_order = order.dendrogram(object@column_dend)

-        }

-    } else {

-        column_order = order

-    }

-

-    # re-order

-    object@column_order = column_order

-