Merge branch 'dev' of github.com:Vector35/binaryninja-api into dev

7 files changed, 669 insertions, 0 deletions

diff --git a/backgroundtask.cpp b/backgroundtask.cpp
new file mode 100644
index 00000000..aebf980c
--- /dev/null
+++ b/backgroundtask.cpp
@@ -0,0 +1,75 @@
+#include "binaryninjaapi.h"
+
+using namespace std;
+using namespace BinaryNinja;
+
+
+BackgroundTask::BackgroundTask(BNBackgroundTask* task)
+{
+	m_object = task;
+}
+
+
+BackgroundTask::BackgroundTask(const string& initialText, bool canCancel)
+{
+	m_object = BNBeginBackgroundTask(initialText.c_str(), canCancel);
+}
+
+
+bool BackgroundTask::CanCancel() const
+{
+	return BNCanCancelBackgroundTask(m_object);
+}
+
+
+bool BackgroundTask::IsCancelled() const
+{
+	return BNIsBackgroundTaskCancelled(m_object);
+}
+
+
+bool BackgroundTask::IsFinished() const
+{
+	return BNIsBackgroundTaskFinished(m_object);
+}
+
+
+string BackgroundTask::GetProgressText() const
+{
+	char* text = BNGetBackgroundTaskProgressText(m_object);
+	string result = text;
+	BNFreeString(text);
+	return result;
+}
+
+
+void BackgroundTask::Cancel()
+{
+	BNCancelBackgroundTask(m_object);
+}
+
+
+void BackgroundTask::Finish()
+{
+	BNFinishBackgroundTask(m_object);
+}
+
+
+void BackgroundTask::SetProgressText(const string& text)
+{
+	BNSetBackgroundTaskProgressText(m_object, text.c_str());
+}
+
+
+vector<Ref<BackgroundTask>> BackgroundTask::GetRunningTasks()
+{
+	size_t count;
+	BNBackgroundTask** tasks = BNGetRunningBackgroundTasks(&count);
+
+	vector<Ref<BackgroundTask>> result;
+	for (size_t i = 0; i < count; i++)
+		result.push_back(new BackgroundTask(BNNewBackgroundTaskReference(tasks[i])));
+
+	BNFreeBackgroundTaskList(tasks, count);
+	return result;
+}
diff --git a/basicblock.cpp b/basicblock.cpp
index 377c5704..93a279a1 100644
--- a/basicblock.cpp
+++ b/basicblock.cpp
@@ -172,3 +172,113 @@ vector<DisassemblyTextLine> BasicBlock::GetDisassemblyText(DisassemblySettings*
 	BNFreeDisassemblyTextLines(lines, count);
 	return result;
 }
+
+
+BNHighlightColor BasicBlock::GetBasicBlockHighlight()
+{
+	return BNGetBasicBlockHighlight(m_object);
+}
+
+
+void BasicBlock::SetAutoBasicBlockHighlight(BNHighlightColor color)
+{
+	BNSetAutoBasicBlockHighlight(m_object, color);
+}
+
+
+void BasicBlock::SetAutoBasicBlockHighlight(BNHighlightStandardColor color, uint8_t alpha)
+{
+	BNHighlightColor hc;
+	hc.style = StandardHighlightColor;
+	hc.color = color;
+	hc.mixColor = NoHighlightColor;
+	hc.mix = 0;
+	hc.r = 0;
+	hc.g = 0;
+	hc.b = 0;
+	hc.alpha = alpha;
+	SetAutoBasicBlockHighlight(hc);
+}
+
+
+void BasicBlock::SetAutoBasicBlockHighlight(BNHighlightStandardColor color, BNHighlightStandardColor mixColor,
+	uint8_t mix, uint8_t alpha)
+{
+	BNHighlightColor hc;
+	hc.style = MixedHighlightColor;
+	hc.color = color;
+	hc.mixColor = mixColor;
+	hc.mix = mix;
+	hc.r = 0;
+	hc.g = 0;
+	hc.b = 0;
+	hc.alpha = alpha;
+	SetAutoBasicBlockHighlight(hc);
+}
+
+
+void BasicBlock::SetAutoBasicBlockHighlight(uint8_t r, uint8_t g, uint8_t b, uint8_t alpha)
+{
+	BNHighlightColor hc;
+	hc.style = CustomHighlightColor;
+	hc.color = NoHighlightColor;
+	hc.mixColor = NoHighlightColor;
+	hc.mix = 0;
+	hc.r = r;
+	hc.g = g;
+	hc.b = b;
+	hc.alpha = alpha;
+	SetAutoBasicBlockHighlight(hc);
+}
+
+
+void BasicBlock::SetUserBasicBlockHighlight(BNHighlightColor color)
+{
+	BNSetUserBasicBlockHighlight(m_object, color);
+}
+
+
+void BasicBlock::SetUserBasicBlockHighlight(BNHighlightStandardColor color, uint8_t alpha)
+{
+	BNHighlightColor hc;
+	hc.style = StandardHighlightColor;
+	hc.color = color;
+	hc.mixColor = NoHighlightColor;
+	hc.mix = 0;
+	hc.r = 0;
+	hc.g = 0;
+	hc.b = 0;
+	hc.alpha = alpha;
+	SetUserBasicBlockHighlight(hc);
+}
+
+
+void BasicBlock::SetUserBasicBlockHighlight(BNHighlightStandardColor color, BNHighlightStandardColor mixColor,
+	uint8_t mix, uint8_t alpha)
+{
+	BNHighlightColor hc;
+	hc.style = MixedHighlightColor;
+	hc.color = color;
+	hc.mixColor = mixColor;
+	hc.mix = mix;
+	hc.r = 0;
+	hc.g = 0;
+	hc.b = 0;
+	hc.alpha = alpha;
+	SetUserBasicBlockHighlight(hc);
+}
+
+
+void BasicBlock::SetUserBasicBlockHighlight(uint8_t r, uint8_t g, uint8_t b, uint8_t alpha)
+{
+	BNHighlightColor hc;
+	hc.style = CustomHighlightColor;
+	hc.color = NoHighlightColor;
+	hc.mixColor = NoHighlightColor;
+	hc.mix = 0;
+	hc.r = r;
+	hc.g = g;
+	hc.b = b;
+	hc.alpha = alpha;
+	SetUserBasicBlockHighlight(hc);
+}
diff --git a/binaryninjaapi.h b/binaryninjaapi.h
index d4df479b..3400cca7 100644
--- a/binaryninjaapi.h
+++ b/binaryninjaapi.h
@@ -1561,6 +1561,18 @@ namespace BinaryNinja
 		std::vector<std::vector<InstructionTextToken>> GetAnnotations();
 
 		std::vector<DisassemblyTextLine> GetDisassemblyText(DisassemblySettings* settings);
+
+		BNHighlightColor GetBasicBlockHighlight();
+		void SetAutoBasicBlockHighlight(BNHighlightColor color);
+		void SetAutoBasicBlockHighlight(BNHighlightStandardColor color, uint8_t alpha = 255);
+		void SetAutoBasicBlockHighlight(BNHighlightStandardColor color, BNHighlightStandardColor mixColor,
+			uint8_t mix, uint8_t alpha = 255);
+		void SetAutoBasicBlockHighlight(uint8_t r, uint8_t g, uint8_t b, uint8_t alpha = 255);
+		void SetUserBasicBlockHighlight(BNHighlightColor color);
+		void SetUserBasicBlockHighlight(BNHighlightStandardColor color, uint8_t alpha = 255);
+		void SetUserBasicBlockHighlight(BNHighlightStandardColor color, BNHighlightStandardColor mixColor,
+			uint8_t mix, uint8_t alpha = 255);
+		void SetUserBasicBlockHighlight(uint8_t r, uint8_t g, uint8_t b, uint8_t alpha = 255);
 	};
 
 	struct StackVariable
@@ -1633,6 +1645,7 @@ namespace BinaryNinja
 		bool NeedsUpdate() const;
 
 		std::vector<Ref<BasicBlock>> GetBasicBlocks() const;
+		Ref<BasicBlock> GetBasicBlockAtAddress(Architecture* arch, uint64_t addr) const;
 		void MarkRecentUse();
 
 		std::string GetCommentForAddress(uint64_t addr) const;
@@ -1692,6 +1705,22 @@ namespace BinaryNinja
 		void SetIntegerConstantDisplayType(Architecture* arch, uint64_t instrAddr, uint64_t value, size_t operand,
 			BNIntegerDisplayType type);
 
+		BNHighlightColor GetInstructionHighlight(Architecture* arch, uint64_t addr);
+		void SetAutoInstructionHighlight(Architecture* arch, uint64_t addr, BNHighlightColor color);
+		void SetAutoInstructionHighlight(Architecture* arch, uint64_t addr, BNHighlightStandardColor color,
+			uint8_t alpha = 255);
+		void SetAutoInstructionHighlight(Architecture* arch, uint64_t addr, BNHighlightStandardColor color,
+			BNHighlightStandardColor mixColor, uint8_t mix, uint8_t alpha = 255);
+		void SetAutoInstructionHighlight(Architecture* arch, uint64_t addr, uint8_t r, uint8_t g, uint8_t b,
+			uint8_t alpha = 255);
+		void SetUserInstructionHighlight(Architecture* arch, uint64_t addr, BNHighlightColor color);
+		void SetUserInstructionHighlight(Architecture* arch, uint64_t addr, BNHighlightStandardColor color,
+			uint8_t alpha = 255);
+		void SetUserInstructionHighlight(Architecture* arch, uint64_t addr, BNHighlightStandardColor color,
+			BNHighlightStandardColor mixColor, uint8_t mix, uint8_t alpha = 255);
+		void SetUserInstructionHighlight(Architecture* arch, uint64_t addr, uint8_t r, uint8_t g, uint8_t b,
+			uint8_t alpha = 255);
+
 		void Reanalyze();
 
 		void RequestAdvancedAnalysisData();
@@ -1731,6 +1760,7 @@ namespace BinaryNinja
 	public:
 		FunctionGraphBlock(BNFunctionGraphBlock* block);
 
+		Ref<BasicBlock> GetBasicBlock() const;
 		Ref<Architecture> GetArchitecture() const;
 		uint64_t GetStart() const;
 		uint64_t GetEnd() const;
@@ -2230,4 +2260,23 @@ namespace BinaryNinja
 	public:
 		virtual void AddMainThreadAction(MainThreadAction* action) = 0;
 	};
+
+	class BackgroundTask: public CoreRefCountObject<BNBackgroundTask,
+		BNNewBackgroundTaskReference, BNFreeBackgroundTask>
+	{
+	public:
+		BackgroundTask(BNBackgroundTask* task);
+		BackgroundTask(const std::string& initialText, bool canCancel);
+
+		bool CanCancel() const;
+		bool IsCancelled() const;
+		bool IsFinished() const;
+		std::string GetProgressText() const;
+
+		void Cancel();
+		void Finish();
+		void SetProgressText(const std::string& text);
+
+		static std::vector<Ref<BackgroundTask>> GetRunningTasks();
+	};
 }
diff --git a/binaryninjacore.h b/binaryninjacore.h
index 51bf3391..89dceba1 100644
--- a/binaryninjacore.h
+++ b/binaryninjacore.h
@@ -102,6 +102,7 @@ extern "C"
 	struct BNScriptingProvider;
 	struct BNScriptingInstance;
 	struct BNMainThreadAction;
+	struct BNBackgroundTask;
 
 	//! Console log levels
 	enum BNLogLevel
@@ -1020,6 +1021,35 @@ extern "C"
 		size_t size;
 	};
 
+	enum BNHighlightColorStyle
+	{
+		StandardHighlightColor = 0,
+		MixedHighlightColor = 1,
+		CustomHighlightColor = 2
+	};
+
+	enum BNHighlightStandardColor
+	{
+		NoHighlightColor = 0,
+		BlueHighlightColor = 1,
+		GreenHighlightColor = 2,
+		CyanHighlightColor = 3,
+		RedHighlightColor = 4,
+		MagentaHighlightColor = 5,
+		YellowHighlightColor = 6,
+		OrangeHighlightColor = 7,
+		WhiteHighlightColor = 8,
+		BlackHighlightColor = 9
+	};
+
+	struct BNHighlightColor
+	{
+		BNHighlightColorStyle style;
+		BNHighlightStandardColor color;
+		BNHighlightStandardColor mixColor;
+		uint8_t mix, r, g, b, alpha;
+	};
+
 	BINARYNINJACOREAPI char* BNAllocString(const char* contents);
 	BINARYNINJACOREAPI void BNFreeString(char* str);
 
@@ -1418,6 +1448,7 @@ extern "C"
 	BINARYNINJACOREAPI void BNFreeBasicBlock(BNBasicBlock* block);
 	BINARYNINJACOREAPI BNBasicBlock** BNGetFunctionBasicBlockList(BNFunction* func, size_t* count);
 	BINARYNINJACOREAPI void BNFreeBasicBlockList(BNBasicBlock** blocks, size_t count);
+	BINARYNINJACOREAPI BNBasicBlock* BNGetFunctionBasicBlockAtAddress(BNFunction* func, BNArchitecture* arch, uint64_t addr);
 	BINARYNINJACOREAPI BNBasicBlock* BNGetRecentBasicBlockForAddress(BNBinaryView* view, uint64_t addr);
 	BINARYNINJACOREAPI BNBasicBlock** BNGetBasicBlocksForAddress(BNBinaryView* view, uint64_t addr, size_t* count);
 	BINARYNINJACOREAPI BNBasicBlock** BNGetBasicBlocksStartingAtAddress(BNBinaryView* view, uint64_t addr, size_t* count);
@@ -1575,6 +1606,15 @@ extern "C"
 	BINARYNINJACOREAPI void BNReanalyzeAllFunctions(BNBinaryView* view);
 	BINARYNINJACOREAPI void BNReanalyzeFunction(BNFunction* func);
 
+	BINARYNINJACOREAPI BNHighlightColor BNGetInstructionHighlight(BNFunction* func, BNArchitecture* arch, uint64_t addr);
+	BINARYNINJACOREAPI void BNSetAutoInstructionHighlight(BNFunction* func, BNArchitecture* arch, uint64_t addr,
+		BNHighlightColor color);
+	BINARYNINJACOREAPI void BNSetUserInstructionHighlight(BNFunction* func, BNArchitecture* arch, uint64_t addr,
+		BNHighlightColor color);
+	BINARYNINJACOREAPI BNHighlightColor BNGetBasicBlockHighlight(BNBasicBlock* block);
+	BINARYNINJACOREAPI void BNSetAutoBasicBlockHighlight(BNBasicBlock* block, BNHighlightColor color);
+	BINARYNINJACOREAPI void BNSetUserBasicBlockHighlight(BNBasicBlock* block, BNHighlightColor color);
+
 	// Disassembly settings
 	BINARYNINJACOREAPI BNDisassemblySettings* BNCreateDisassemblySettings(void);
 	BINARYNINJACOREAPI BNDisassemblySettings* BNNewDisassemblySettingsReference(BNDisassemblySettings* settings);
@@ -1622,6 +1662,7 @@ extern "C"
 	BINARYNINJACOREAPI BNFunctionGraphBlock* BNNewFunctionGraphBlockReference(BNFunctionGraphBlock* block);
 	BINARYNINJACOREAPI void BNFreeFunctionGraphBlock(BNFunctionGraphBlock* block);
 
+	BINARYNINJACOREAPI BNBasicBlock* BNGetFunctionGraphBasicBlock(BNFunctionGraphBlock* block);
 	BINARYNINJACOREAPI BNArchitecture* BNGetFunctionGraphBlockArchitecture(BNFunctionGraphBlock* block);
 	BINARYNINJACOREAPI uint64_t BNGetFunctionGraphBlockStart(BNFunctionGraphBlock* block);
 	BINARYNINJACOREAPI uint64_t BNGetFunctionGraphBlockEnd(BNFunctionGraphBlock* block);
@@ -1974,6 +2015,21 @@ extern "C"
 	BINARYNINJACOREAPI size_t BNGetWorkerThreadCount(void);
 	BINARYNINJACOREAPI void BNSetWorkerThreadCount(size_t count);
 
+	// Background task progress reporting
+	BINARYNINJACOREAPI BNBackgroundTask* BNBeginBackgroundTask(const char* initialText, bool canCancel);
+	BINARYNINJACOREAPI void BNFinishBackgroundTask(BNBackgroundTask* task);
+	BINARYNINJACOREAPI void BNSetBackgroundTaskProgressText(BNBackgroundTask* task, const char* text);
+	BINARYNINJACOREAPI bool BNIsBackgroundTaskCancelled(BNBackgroundTask* task);
+
+	BINARYNINJACOREAPI BNBackgroundTask** BNGetRunningBackgroundTasks(size_t* count);
+	BINARYNINJACOREAPI BNBackgroundTask* BNNewBackgroundTaskReference(BNBackgroundTask* task);
+	BINARYNINJACOREAPI void BNFreeBackgroundTask(BNBackgroundTask* task);
+	BINARYNINJACOREAPI void BNFreeBackgroundTaskList(BNBackgroundTask** tasks, size_t count);
+	BINARYNINJACOREAPI char* BNGetBackgroundTaskProgressText(BNBackgroundTask* task);
+	BINARYNINJACOREAPI bool BNCanCancelBackgroundTask(BNBackgroundTask* task);
+	BINARYNINJACOREAPI void BNCancelBackgroundTask(BNBackgroundTask* task);
+	BINARYNINJACOREAPI bool BNIsBackgroundTaskFinished(BNBackgroundTask* task);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/function.cpp b/function.cpp
index de12918f..109b6f49 100644
--- a/function.cpp
+++ b/function.cpp
@@ -100,6 +100,15 @@ vector<Ref<BasicBlock>> Function::GetBasicBlocks() const
 }
 
 
+Ref<BasicBlock> Function::GetBasicBlockAtAddress(Architecture* arch, uint64_t addr) const
+{
+	BNBasicBlock* block = BNGetFunctionBasicBlockAtAddress(m_object, arch->GetObject(), addr);
+	if (!block)
+		return nullptr;
+	return new BasicBlock(block);
+}
+
+
 void Function::MarkRecentUse()
 {
 	BNMarkFunctionAsRecentlyUsed(m_object);
@@ -582,6 +591,120 @@ void Function::SetIntegerConstantDisplayType(Architecture* arch, uint64_t instrA
 }
 
 
+BNHighlightColor Function::GetInstructionHighlight(Architecture* arch, uint64_t addr)
+{
+	return BNGetInstructionHighlight(m_object, arch->GetObject(), addr);
+}
+
+
+void Function::SetAutoInstructionHighlight(Architecture* arch, uint64_t addr, BNHighlightColor color)
+{
+	BNSetAutoInstructionHighlight(m_object, arch->GetObject(), addr, color);
+}
+
+
+void Function::SetAutoInstructionHighlight(Architecture* arch, uint64_t addr, BNHighlightStandardColor color,
+	uint8_t alpha)
+{
+	BNHighlightColor hc;
+	hc.style = StandardHighlightColor;
+	hc.color = color;
+	hc.mixColor = NoHighlightColor;
+	hc.mix = 0;
+	hc.r = 0;
+	hc.g = 0;
+	hc.b = 0;
+	hc.alpha = alpha;
+	SetAutoInstructionHighlight(arch, addr, hc);
+}
+
+
+void Function::SetAutoInstructionHighlight(Architecture* arch, uint64_t addr, BNHighlightStandardColor color,
+	BNHighlightStandardColor mixColor, uint8_t mix, uint8_t alpha)
+{
+	BNHighlightColor hc;
+	hc.style = MixedHighlightColor;
+	hc.color = color;
+	hc.mixColor = mixColor;
+	hc.mix = mix;
+	hc.r = 0;
+	hc.g = 0;
+	hc.b = 0;
+	hc.alpha = alpha;
+	SetAutoInstructionHighlight(arch, addr, hc);
+}
+
+
+void Function::SetAutoInstructionHighlight(Architecture* arch, uint64_t addr, uint8_t r, uint8_t g, uint8_t b,
+	uint8_t alpha)
+{
+	BNHighlightColor hc;
+	hc.style = CustomHighlightColor;
+	hc.color = NoHighlightColor;
+	hc.mixColor = NoHighlightColor;
+	hc.mix = 0;
+	hc.r = r;
+	hc.g = g;
+	hc.b = b;
+	hc.alpha = alpha;
+	SetAutoInstructionHighlight(arch, addr, hc);
+}
+
+
+void Function::SetUserInstructionHighlight(Architecture* arch, uint64_t addr, BNHighlightColor color)
+{
+	BNSetUserInstructionHighlight(m_object, arch->GetObject(), addr, color);
+}
+
+
+void Function::SetUserInstructionHighlight(Architecture* arch, uint64_t addr, BNHighlightStandardColor color,
+	uint8_t alpha)
+{
+	BNHighlightColor hc;
+	hc.style = StandardHighlightColor;
+	hc.color = color;
+	hc.mixColor = NoHighlightColor;
+	hc.mix = 0;
+	hc.r = 0;
+	hc.g = 0;
+	hc.b = 0;
+	hc.alpha = alpha;
+	SetUserInstructionHighlight(arch, addr, hc);
+}
+
+
+void Function::SetUserInstructionHighlight(Architecture* arch, uint64_t addr, BNHighlightStandardColor color,
+	BNHighlightStandardColor mixColor, uint8_t mix, uint8_t alpha)
+{
+	BNHighlightColor hc;
+	hc.style = MixedHighlightColor;
+	hc.color = color;
+	hc.mixColor = mixColor;
+	hc.mix = mix;
+	hc.r = 0;
+	hc.g = 0;
+	hc.b = 0;
+	hc.alpha = alpha;
+	SetUserInstructionHighlight(arch, addr, hc);
+}
+
+
+void Function::SetUserInstructionHighlight(Architecture* arch, uint64_t addr, uint8_t r, uint8_t g, uint8_t b,
+	uint8_t alpha)
+{
+	BNHighlightColor hc;
+	hc.style = CustomHighlightColor;
+	hc.color = NoHighlightColor;
+	hc.mixColor = NoHighlightColor;
+	hc.mix = 0;
+	hc.r = r;
+	hc.g = g;
+	hc.b = b;
+	hc.alpha = alpha;
+	SetUserInstructionHighlight(arch, addr, hc);
+}
+
+
 void Function::Reanalyze()
 {
 	BNReanalyzeFunction(m_object);
diff --git a/functiongraphblock.cpp b/functiongraphblock.cpp
index 436339f6..47261453 100644
--- a/functiongraphblock.cpp
+++ b/functiongraphblock.cpp
@@ -32,6 +32,12 @@ FunctionGraphBlock::FunctionGraphBlock(BNFunctionGraphBlock* block)
 }
 
 
+Ref<BasicBlock> FunctionGraphBlock::GetBasicBlock() const
+{
+	return new BasicBlock(BNGetFunctionGraphBasicBlock(m_object));
+}
+
+
 Ref<Architecture> FunctionGraphBlock::GetArchitecture() const
 {
 	return new CoreArchitecture(BNGetFunctionGraphBlockArchitecture(m_object));
diff --git a/python/__init__.py b/python/__init__.py
index 33202a2c..6abbdfa6 100644
--- a/python/__init__.py
+++ b/python/__init__.py
@@ -4381,6 +4381,93 @@ class IndirectBranchInfo:
 	def __repr__(self):
 		return "<branch %s:%#x -> %s:%#x>" % (self.source_arch.name, self.source_addr, self.dest_arch.name, self.dest_addr)
 
+class HighlightColor(object):
+	def __init__(self, color = None, mix_color = None, mix = None, red = None, green = None, blue = None, alpha = 255):
+		if (red is not None) and (green is not None) and (blue is not None):
+			self.style = core.CustomHighlightColor
+			self.red = red
+			self.green = green
+			self.blue = blue
+		elif (mix_color is not None) and (mix is not None):
+			self.style = core.MixedHighlightColor
+			if color is None:
+				self.color = core.NoHighlightColor
+			else:
+				self.color = color
+			self.mix_color = mix_color
+			self.mix = mix
+		else:
+			self.style = core.StandardHighlightColor
+			if color is None:
+				self.color = core.NoHighlightColor
+			else:
+				self.color = color
+		self.alpha = alpha
+
+	def _standard_color_to_str(self, color):
+		if color == core.NoHighlightColor:
+			return "none"
+		if color == core.BlueHighlightColor:
+			return "blue"
+		if color == core.GreenHighlightColor:
+			return "green"
+		if color == core.CyanHighlightColor:
+			return "cyan"
+		if color == core.RedHighlightColor:
+			return "red"
+		if color == core.MagentaHighlightColor:
+			return "magenta"
+		if color == core.YellowHighlightColor:
+			return "yellow"
+		if color == core.OrangeHighlightColor:
+			return "orange"
+		if color == core.WhiteHighlightColor:
+			return "white"
+		if color == core.BlackHighlightColor:
+			return "black"
+		return "%d" % color
+
+	def __repr__(self):
+		if self.style == core.StandardHighlightColor:
+			if self.alpha == 255:
+				return "<color: %s>" % self._standard_color_to_str(self.color)
+			return "<color: %s, alpha %d>" % (self._standard_color_to_str(self.color), self.alpha)
+		if self.style == core.MixedHighlightColor:
+			if self.alpha == 255:
+				return "<color: mix %s to %s factor %d>" % (self._standard_color_to_str(self.color),
+					self._standard_color_to_str(self.mix_color), self.mix)
+			return "<color: mix %s to %s factor %d, alpha %d>" % (self._standard_color_to_str(self.color),
+				self._standard_color_to_str(self.mix_color), self.mix, self.alpha)
+		if self.style == core.CustomHighlightColor:
+			if self.alpha == 255:
+				return "<color: #%.2x%.2x%.2x>" % (self.red, self.green, self.blue)
+			return "<color: #%.2x%.2x%.2x, alpha %d>" % (self.red, self.green, self.blue, self.alpha)
+		return "<color>"
+
+	def _get_core_struct(self):
+		result = core.BNHighlightColor()
+		result.style = self.style
+		result.color = core.NoHighlightColor
+		result.mix_color = core.NoHighlightColor
+		result.mix = 0
+		result.r = 0
+		result.g = 0
+		result.b = 0
+		result.alpha = self.alpha
+
+		if self.style == core.StandardHighlightColor:
+			result.color = self.color
+		elif self.style == core.MixedHighlightColor:
+			result.color = self.color
+			result.mixColor = self.mix_color
+			result.mix = self.mix
+		elif self.style == core.CustomHighlightColor:
+			result.r = self.red
+			result.g = self.green
+			result.b = self.blue
+
+		return result
+
 class Function(object):
 	def __init__(self, view, handle):
 		self._view = view
@@ -4790,6 +4877,32 @@ class Function(object):
 		core.BNReleaseAdvancedFunctionAnalysisData(self.handle)
 		self._advanced_analysis_requests -= 1
 
+	def get_basic_block_at(self, arch, addr):
+		block = core.BNGetFunctionBasicBlockAtAddress(self.handle, arch.handle, addr)
+		if not block:
+			return None
+		return BasicBlock(self._view, handle = block)
+
+	def get_instr_highlight(self, arch, addr):
+		color = core.BNGetInstructionHighlight(self.handle, arch.handle, addr)
+		if color.style == core.StandardHighlightColor:
+			return HighlightColor(color = color.color, alpha = color.alpha)
+		elif color.style == core.MixedHighlightColor:
+			return HighlightColor(color = color.color, mix_color = color.mixColor, mix = color.mix, alpha = color.alpha)
+		elif color.style == core.CustomHighlightColor:
+			return HighlightColor(red = color.r, green = color.g, blue = color.b, alpha = color.alpha)
+		return HighlightColor(color = core.NoHighlightColor)
+
+	def set_auto_instr_highlight(self, arch, addr, color):
+		if not isinstance(color, HighlightColor):
+			color = HighlightColor(color = color)
+		core.BNSetAutoInstructionHighlight(self.handle, arch.handle, addr, color._get_core_struct())
+
+	def set_user_instr_highlight(self, arch, addr, color):
+		if not isinstance(color, HighlightColor):
+			color = HighlightColor(color = color)
+		core.BNSetUserInstructionHighlight(self.handle, arch.handle, addr, color._get_core_struct())
+
 class AdvancedFunctionAnalysisDataRequestor(object):
 	def __init__(self, func = None):
 		self._function = func
@@ -4902,6 +5015,22 @@ class BasicBlock(object):
 	def disassembly_text(self):
 		return self.get_disassembly_text()
 
+	@property
+	def highlight(self):
+		"""Highlight color for basic block"""
+		color = core.BNGetBasicBlockHighlight(self.handle)
+		if color.style == core.StandardHighlightColor:
+			return HighlightColor(color = color.color, alpha = color.alpha)
+		elif color.style == core.MixedHighlightColor:
+			return HighlightColor(color = color.color, mix_color = color.mixColor, mix = color.mix, alpha = color.alpha)
+		elif color.style == core.CustomHighlightColor:
+			return HighlightColor(red = color.r, green = color.g, blue = color.b, alpha = color.alpha)
+		return HighlightColor(color = core.NoHighlightColor)
+
+	@highlight.setter
+	def highlight(self, value):
+		self.set_user_highlight(value)
+
 	def __setattr__(self, name, value):
 		try:
 			object.__setattr__(self,name,value)
@@ -4956,6 +5085,16 @@ class BasicBlock(object):
 		core.BNFreeDisassemblyTextLines(lines, count.value)
 		return result
 
+	def set_auto_highlight(self, color):
+		if not isinstance(color, HighlightColor):
+			color = HighlightColor(color = color)
+		core.BNSetAutoBasicBlockHighlight(self.handle, color._get_core_struct())
+
+	def set_user_highlight(self, color):
+		if not isinstance(color, HighlightColor):
+			color = HighlightColor(color = color)
+		core.BNSetUserBasicBlockHighlight(self.handle, color._get_core_struct())
+
 class LowLevelILBasicBlock(BasicBlock):
 	def __init__(self, view, handle, owner):
 		super(LowLevelILBasicBlock, self).__init__(view, handle)
@@ -4999,6 +5138,19 @@ class FunctionGraphBlock(object):
 		core.BNFreeFunctionGraphBlock(self.handle)
 
 	@property
+	def basic_block(self):
+		"""Basic block associated with this part of the funciton graph (read-only)"""
+		block = core.BNGetFunctionGraphBasicBlock(self.handle)
+		func = core.BNGetBasicBlockFunction(block)
+		if func is None:
+			core.BNFreeBasicBlock(block)
+			block = None
+		else:
+			block = BasicBlock(BinaryView(None, handle = core.BNGetFunctionData(func)), block)
+			core.BNFreeFunction(func)
+		return block
+
+	@property
 	def arch(self):
 		"""Function graph block architecture (read-only)"""
 		arch = core.BNGetFunctionGraphBlockArchitecture(self.handle)
@@ -9809,6 +9961,104 @@ class MainThreadActionHandler(object):
 	def add_action(self, action):
 		pass
 
+class _BackgroundTaskMetaclass(type):
+	@property
+	def list(self):
+		"""List all running background tasks (read-only)"""
+		count = ctypes.c_ulonglong()
+		tasks = core.BNGetRunningBackgroundTasks(count)
+		result = []
+		for i in xrange(0, count.value):
+			result.append(BackgroundTask(core.BNNewBackgroundTaskReference(tasks[i])))
+		core.BNFreeBackgroundTaskList(tasks)
+		return result
+
+	def __iter__(self):
+		_init_plugins()
+		count = ctypes.c_ulonglong()
+		tasks = core.BNGetRunningBackgroundTasks(count)
+		try:
+			for i in xrange(0, count.value):
+				yield BackgroundTask(core.BNNewBackgroundTaskReference(tasks[i]))
+		finally:
+			core.BNFreeBackgroundTaskList(tasks)
+
+class BackgroundTask(object):
+	__metaclass__ = _BackgroundTaskMetaclass
+
+	def __init__(self, initial_progress_text = "", can_cancel = False, handle = None):
+		if handle is None:
+			self.handle = core.BNBeginBackgroundTask(initial_progress_text, can_cancel)
+		else:
+			self.handle = handle
+
+	def __del__(self):
+		core.BNFreeBackgroundTask(self.handle)
+
+	@property
+	def progress(self):
+		"""Text description of the progress of the background task (displayed in status bar of the UI)"""
+		return core.BNGetBackgroundTaskProgressText(self.handle)
+
+	@progress.setter
+	def progress(self, value):
+		core.BNSetBackgroundTaskProgressText(self.handle, str(value))
+
+	@property
+	def can_cancel(self):
+		"""Whether the task can be cancelled (read-only)"""
+		return core.BNCanCancelBackgroundTask(self.handle)
+
+	@property
+	def finished(self):
+		"""Whether the task has finished"""
+		return core.BNIsBackgroundTaskFinished(self.handle)
+
+	@finished.setter
+	def finished(self, value):
+		if value:
+			self.finish()
+
+	def finish(self):
+		core.BNFinishBackgroundTask(self.handle)
+
+	@property
+	def cancelled(self):
+		"""Whether the task has been cancelled"""
+		return core.BNIsBackgroundTaskCancelled(self.handle)
+
+	@cancelled.setter
+	def cancelled(self, value):
+		if value:
+			self.cancel()
+
+	def cancel(self):
+		core.BNCancelBackgroundTask(self.handle)
+
+class BackgroundTaskThread(BackgroundTask):
+	def __init__(self, initial_progress_text = "", can_cancel = False):
+		class _Thread(threading.Thread):
+			def __init__(self, task):
+				threading.Thread.__init__(self)
+				self.task = task
+
+			def run(self):
+				self.task.run()
+				self.task.finish()
+				self.task = None
+
+		BackgroundTask.__init__(self, initial_progress_text, can_cancel)
+		self.thread = _Thread(self)
+
+	def run(self):
+		pass
+
+	def start(self):
+		self.thread.start()
+
+	def join(self):
+		self.thread.join()
+
 def LLIL_TEMP(n):
 	return n | 0x80000000