Cleanup: trailing space

Remove from blender/nodes, collada, blenfont & render.

5 files changed, 145 insertions, 145 deletions

diff --git a/source/blender/nodes/intern/node_common.c b/source/blender/nodes/intern/node_common.c
index c465f7a9be5..4a47bf7035c 100644
--- a/source/blender/nodes/intern/node_common.c
+++ b/source/blender/nodes/intern/node_common.c
@@ -98,16 +98,16 @@ int nodeGroupPoll(bNodeTree *nodetree, bNodeTree *grouptree)
 {
 	bNode *node;
 	int valid = 1;
-	
+
 	/* unspecified node group, generally allowed
 	 * (if anything, should be avoided on operator level)
 	 */
 	if (grouptree == NULL)
 		return 1;
-	
+
 	if (nodetree == grouptree)
 		return 0;
-	
+
 	for (node = grouptree->nodes.first; node; node = node->next) {
 		if (node->typeinfo->poll_instance && !node->typeinfo->poll_instance(node, nodetree)) {
 			valid = 0;
@@ -121,27 +121,27 @@ int nodeGroupPoll(bNodeTree *nodetree, bNodeTree *grouptree)
 static bNodeSocket *group_verify_socket(bNodeTree *ntree, bNode *gnode, bNodeSocket *iosock, ListBase *verify_lb, int in_out)
 {
 	bNodeSocket *sock;
-	
+
 	for (sock = verify_lb->first; sock; sock = sock->next) {
 		if (STREQ(sock->identifier, iosock->identifier))
 			break;
 	}
 	if (sock) {
 		strcpy(sock->name, iosock->name);
-		
+
 		if (iosock->typeinfo->interface_verify_socket)
 			iosock->typeinfo->interface_verify_socket(ntree, iosock, gnode, sock, "interface");
 	}
 	else {
 		sock = nodeAddSocket(ntree, gnode, in_out, iosock->idname, iosock->identifier, iosock->name);
-		
+
 		if (iosock->typeinfo->interface_init_socket)
 			iosock->typeinfo->interface_init_socket(ntree, iosock, gnode, sock, "interface");
 	}
-	
+
 	/* remove from list temporarily, to distinguish from orphaned sockets */
 	BLI_remlink(verify_lb, sock);
-	
+
 	return sock;
 }
 
@@ -150,9 +150,9 @@ static void group_verify_socket_list(bNodeTree *ntree, bNode *gnode,
                                      ListBase *iosock_lb, ListBase *verify_lb, int in_out)
 {
 	bNodeSocket *iosock, *sock, *nextsock;
-	
+
 	/* step by step compare */
-	
+
 	iosock = iosock_lb->first;
 	for (; iosock; iosock = iosock->next) {
 		/* abusing new_sock pointer for verification here! only used inside this function */
@@ -195,9 +195,9 @@ static void node_frame_init(bNodeTree *UNUSED(ntree), bNode *node)
 {
 	NodeFrame *data = (NodeFrame *)MEM_callocN(sizeof(NodeFrame), "frame node storage");
 	node->storage = data;
-	
+
 	data->flag |= NODE_FRAME_SHRINK;
-	
+
 	data->label_size = 20;
 }
 
@@ -211,7 +211,7 @@ void register_node_type_frame(void)
 	node_type_storage(ntype, "NodeFrame", node_free_standard_storage, node_copy_standard_storage);
 	node_type_size(ntype, 150, 100, 0);
 	node_type_compatibility(ntype, NODE_OLD_SHADING | NODE_NEW_SHADING);
-	
+
 	ntype->needs_free = 1;
 	nodeRegisterType(ntype);
 }
@@ -251,11 +251,11 @@ void register_node_type_reroute(void)
 {
 	/* frame type is used for all tree types, needs dynamic allocation */
 	bNodeType *ntype = MEM_callocN(sizeof(bNodeType), "frame node type");
-	
+
 	node_type_base(ntype, NODE_REROUTE, "Reroute", NODE_CLASS_LAYOUT, 0);
 	node_type_init(ntype, node_reroute_init);
 	node_type_internal_links(ntype, node_reroute_update_internal_links);
-	
+
 	ntype->needs_free = 1;
 	nodeRegisterType(ntype);
 }
@@ -267,14 +267,14 @@ static void node_reroute_inherit_type_recursive(bNodeTree *ntree, bNode *node, i
 	bNodeLink *link;
 	int type = SOCK_FLOAT;
 	const char *type_idname = nodeStaticSocketType(type, PROP_NONE);
-	
+
 	/* XXX it would be a little bit more efficient to restrict actual updates
 	 * to rerout nodes connected to an updated node, but there's no reliable flag
 	 * to indicate updated nodes (node->update is not set on linking).
 	 */
-	
+
 	node->done = 1;
-	
+
 	/* recursive update */
 	for (link = ntree->links.first; link; link = link->next) {
 		bNode *fromnode = link->fromnode;
@@ -283,7 +283,7 @@ static void node_reroute_inherit_type_recursive(bNodeTree *ntree, bNode *node, i
 			continue;
 		if (nodeLinkIsHidden(link))
 			continue;
-		
+
 		if (flag & REFINE_FORWARD) {
 			if (tonode == node && fromnode->type == NODE_REROUTE && !fromnode->done)
 				node_reroute_inherit_type_recursive(ntree, fromnode, REFINE_FORWARD);
@@ -293,7 +293,7 @@ static void node_reroute_inherit_type_recursive(bNodeTree *ntree, bNode *node, i
 				node_reroute_inherit_type_recursive(ntree, tonode, REFINE_BACKWARD);
 		}
 	}
-	
+
 	/* determine socket type from unambiguous input/output connection if possible */
 	if (input->limit == 1 && input->link) {
 		type = input->link->fromsock->type;
@@ -303,7 +303,7 @@ static void node_reroute_inherit_type_recursive(bNodeTree *ntree, bNode *node, i
 		type = output->link->tosock->type;
 		type_idname = nodeStaticSocketType(type, PROP_NONE);
 	}
-	
+
 	if (input->type != type) {
 		bNodeSocket *ninput = nodeAddSocket(ntree, node, SOCK_IN, type_idname, "input", "Input");
 		for (link = ntree->links.first; link; link = link->next) {
@@ -314,7 +314,7 @@ static void node_reroute_inherit_type_recursive(bNodeTree *ntree, bNode *node, i
 		}
 		nodeRemoveSocket(ntree, node, input);
 	}
-	
+
 	if (output->type != type) {
 		bNodeSocket *noutput = nodeAddSocket(ntree, node, SOCK_OUT, type_idname, "output", "Output");
 		for (link = ntree->links.first; link; link = link->next) {
@@ -324,7 +324,7 @@ static void node_reroute_inherit_type_recursive(bNodeTree *ntree, bNode *node, i
 		}
 		nodeRemoveSocket(ntree, node, output);
 	}
-	
+
 	nodeUpdateInternalLinks(ntree, node);
 }
 
@@ -334,11 +334,11 @@ static void node_reroute_inherit_type_recursive(bNodeTree *ntree, bNode *node, i
 void ntree_update_reroute_nodes(bNodeTree *ntree)
 {
 	bNode *node;
-	
+
 	/* clear tags */
 	for (node = ntree->nodes.first; node; node = node->next)
 		node->done = 0;
-	
+
 	for (node = ntree->nodes.first; node; node = node->next)
 		if (node->type == NODE_REROUTE && !node->done)
 			node_reroute_inherit_type_recursive(ntree, node, REFINE_FORWARD | REFINE_BACKWARD);
@@ -411,7 +411,7 @@ void node_group_input_verify(bNodeTree *ntree, bNode *node, ID *id)
 	if (id == (ID *)ntree) {
 		/* value_in_out inverted for interface nodes to get correct socket value_property */
 		group_verify_socket_list(ntree, node, &ntree->inputs, &node->outputs, SOCK_OUT);
-		
+
 		/* add virtual extension socket */
 		nodeAddSocket(ntree, node, SOCK_OUT, "NodeSocketVirtual", "__extend__", "");
 	}
@@ -426,23 +426,23 @@ static void node_group_input_update(bNodeTree *ntree, bNode *node)
 	 * so they can be recreated after verification.
 	 */
 	ListBase tmplinks;
-	
+
 	/* find links from the extension socket and store them */
 	BLI_listbase_clear(&tmplinks);
 	for (link = ntree->links.first; link; link = linknext) {
 		linknext = link->next;
 		if (nodeLinkIsHidden(link))
 			continue;
-		
+
 		if (link->fromsock == extsock) {
 			bNodeLink *tlink = MEM_callocN(sizeof(bNodeLink), "temporary link");
 			*tlink = *link;
 			BLI_addtail(&tmplinks, tlink);
-			
+
 			nodeRemLink(ntree, link);
 		}
 	}
-	
+
 	/* find valid link to expose */
 	exposelink = NULL;
 	for (link = tmplinks.first; link; link = link->next) {
@@ -456,22 +456,22 @@ static void node_group_input_update(bNodeTree *ntree, bNode *node)
 			break;
 		}
 	}
-	
+
 	if (exposelink) {
 		bNodeSocket *gsock, *newsock;
-		
+
 		gsock = ntreeAddSocketInterfaceFromSocket(ntree, exposelink->tonode, exposelink->tosock);
-		
+
 		node_group_input_verify(ntree, node, (ID *)ntree);
 		newsock = node_group_input_find_socket(node, gsock->identifier);
-		
+
 		/* redirect links from the extension socket */
 		for (link = tmplinks.first; link; link = link->next) {
 			nodeAddLink(ntree, node, newsock, link->tonode, link->tosock);
 		}
-		
+
 	}
-	
+
 	BLI_freelistN(&tmplinks);
 }
 
@@ -479,13 +479,13 @@ void register_node_type_group_input(void)
 {
 	/* used for all tree types, needs dynamic allocation */
 	bNodeType *ntype = MEM_callocN(sizeof(bNodeType), "node type");
-	
+
 	node_type_base(ntype, NODE_GROUP_INPUT, "Group Input", NODE_CLASS_INTERFACE, 0);
 	node_type_size(ntype, 140, 80, 400);
 	node_type_init(ntype, node_group_input_init);
 	node_type_update(ntype, node_group_input_update, node_group_input_verify);
 	node_type_compatibility(ntype, NODE_OLD_SHADING | NODE_NEW_SHADING);
-	
+
 	ntype->needs_free = 1;
 	nodeRegisterType(ntype);
 }
@@ -510,7 +510,7 @@ void node_group_output_verify(bNodeTree *ntree, bNode *node, ID *id)
 	if (id == (ID *)ntree) {
 		/* value_in_out inverted for interface nodes to get correct socket value_property */
 		group_verify_socket_list(ntree, node, &ntree->outputs, &node->inputs, SOCK_IN);
-		
+
 		/* add virtual extension socket */
 		nodeAddSocket(ntree, node, SOCK_IN, "NodeSocketVirtual", "__extend__", "");
 	}
@@ -525,23 +525,23 @@ static void node_group_output_update(bNodeTree *ntree, bNode *node)
 	 * so they can be recreated after verification.
 	 */
 	ListBase tmplinks;
-	
+
 	/* find links to the extension socket and store them */
 	BLI_listbase_clear(&tmplinks);
 	for (link = ntree->links.first; link; link = linknext) {
 		linknext = link->next;
 		if (nodeLinkIsHidden(link))
 			continue;
-		
+
 		if (link->tosock == extsock) {
 			bNodeLink *tlink = MEM_callocN(sizeof(bNodeLink), "temporary link");
 			*tlink = *link;
 			BLI_addtail(&tmplinks, tlink);
-			
+
 			nodeRemLink(ntree, link);
 		}
 	}
-	
+
 	/* find valid link to expose */
 	exposelink = NULL;
 	for (link = tmplinks.first; link; link = link->next) {
@@ -555,22 +555,22 @@ static void node_group_output_update(bNodeTree *ntree, bNode *node)
 			break;
 		}
 	}
-	
+
 	if (exposelink) {
 		bNodeSocket *gsock, *newsock;
-		
+
 		/* XXX what if connecting virtual to virtual socket?? */
 		gsock = ntreeAddSocketInterfaceFromSocket(ntree, exposelink->fromnode, exposelink->fromsock);
-		
+
 		node_group_output_verify(ntree, node, (ID *)ntree);
 		newsock = node_group_output_find_socket(node, gsock->identifier);
-		
+
 		/* redirect links to the extension socket */
 		for (link = tmplinks.first; link; link = link->next) {
 			nodeAddLink(ntree, link->fromnode, link->fromsock, node, newsock);
 		}
 	}
-	
+
 	BLI_freelistN(&tmplinks);
 }
 
@@ -578,13 +578,13 @@ void register_node_type_group_output(void)
 {
 	/* used for all tree types, needs dynamic allocation */
 	bNodeType *ntype = MEM_callocN(sizeof(bNodeType), "node type");
-	
+
 	node_type_base(ntype, NODE_GROUP_OUTPUT, "Group Output", NODE_CLASS_INTERFACE, 0);
 	node_type_size(ntype, 140, 80, 400);
 	node_type_init(ntype, node_group_output_init);
 	node_type_update(ntype, node_group_output_update, node_group_output_verify);
 	node_type_compatibility(ntype, NODE_OLD_SHADING | NODE_NEW_SHADING);
-	
+
 	ntype->needs_free = 1;
 	nodeRegisterType(ntype);
 }
diff --git a/source/blender/nodes/intern/node_exec.c b/source/blender/nodes/intern/node_exec.c
index 9782c2f4a2c..a5be5dad534 100644
--- a/source/blender/nodes/intern/node_exec.c
+++ b/source/blender/nodes/intern/node_exec.c
@@ -61,14 +61,14 @@ bNodeStack *node_get_socket_stack(bNodeStack *stack, bNodeSocket *sock)
 void node_get_stack(bNode *node, bNodeStack *stack, bNodeStack **in, bNodeStack **out)
 {
 	bNodeSocket *sock;
-	
+
 	/* build pointer stack */
 	if (in) {
 		for (sock = node->inputs.first; sock; sock = sock->next) {
 			*(in++) = node_get_socket_stack(stack, sock);
 		}
 	}
-	
+
 	if (out) {
 		for (sock = node->outputs.first; sock; sock = sock->next) {
 			*(out++) = node_get_socket_stack(stack, sock);
@@ -127,13 +127,13 @@ static struct bNodeStack *setup_stack(bNodeStack *stack, bNodeTree *ntree, bNode
 	bNodeStack *ns = node_get_socket_stack(stack, sock);
 	if (!ns)
 		return NULL;
-	
+
 	/* don't mess with remote socket stacks, these are initialized by other nodes! */
 	if (sock->link)
 		return ns;
-	
+
 	ns->sockettype = sock->type;
-	
+
 	switch (sock->type) {
 		case SOCK_FLOAT:
 			ns->vec[0] = node_socket_get_float(ntree, node, sock);
@@ -145,7 +145,7 @@ static struct bNodeStack *setup_stack(bNodeStack *stack, bNodeTree *ntree, bNode
 			node_socket_get_color(ntree, node, sock, ns->vec);
 			break;
 	}
-	
+
 	return ns;
 }
 
@@ -161,29 +161,29 @@ bNodeTreeExec *ntree_exec_begin(bNodeExecContext *context, bNodeTree *ntree, bNo
 	bNode **nodelist;
 	int totnodes, n;
 	/* XXX texnodes have threading issues with muting, have to disable it there ... */
-	
+
 	/* ensure all sock->link pointers and node levels are correct */
 	ntreeUpdateTree(G.main, ntree);
-	
+
 	/* get a dependency-sorted list of nodes */
 	ntreeGetDependencyList(ntree, &nodelist, &totnodes);
-	
+
 	/* XXX could let callbacks do this for specialized data */
 	exec = MEM_callocN(sizeof(bNodeTreeExec), "node tree execution data");
 	/* backpointer to node tree */
 	exec->nodetree = ntree;
-	
+
 	/* set stack indices */
 	index = 0;
 	for (n = 0; n < totnodes; ++n) {
 		node = nodelist[n];
-		
+
 		node->stack_index = index;
-		
+
 		/* init node socket stack indexes */
 		for (sock = node->inputs.first; sock; sock = sock->next)
 			node_init_input_index(sock, &index);
-		
+
 		if (node->flag & NODE_MUTED || node->type == NODE_REROUTE) {
 			for (sock = node->outputs.first; sock; sock = sock->next)
 				node_init_output_index(sock, &index, &node->internal_links);
@@ -193,48 +193,48 @@ bNodeTreeExec *ntree_exec_begin(bNodeExecContext *context, bNodeTree *ntree, bNo
 				node_init_output_index(sock, &index, NULL);
 		}
 	}
-	
+
 	/* allocated exec data pointers for nodes */
 	exec->totnodes = totnodes;
 	exec->nodeexec = MEM_callocN(exec->totnodes * sizeof(bNodeExec), "node execution data");
 	/* allocate data pointer for node stack */
 	exec->stacksize = index;
 	exec->stack = MEM_callocN(exec->stacksize * sizeof(bNodeStack), "bNodeStack");
-	
+
 	/* all non-const results are considered inputs */
 	for (n = 0; n < exec->stacksize; ++n)
 		exec->stack[n].hasinput = 1;
-	
+
 	/* prepare all nodes for execution */
 	for (n = 0, nodeexec = exec->nodeexec; n < totnodes; ++n, ++nodeexec) {
 		node = nodeexec->node = nodelist[n];
 		nodeexec->freeexecfunc = node->typeinfo->freeexecfunc;
-		
+
 		/* tag inputs */
 		for (sock = node->inputs.first; sock; sock = sock->next) {
 			/* disable the node if an input link is invalid */
 			if (sock->link && !(sock->link->flag & NODE_LINK_VALID))
 				node->need_exec = 0;
-			
+
 			ns = setup_stack(exec->stack, ntree, node, sock);
 			if (ns)
 				ns->hasoutput = 1;
 		}
-		
+
 		/* tag all outputs */
 		for (sock = node->outputs.first; sock; sock = sock->next) {
 			/* ns = */ setup_stack(exec->stack, ntree, node, sock);
 		}
-		
+
 		nodekey = BKE_node_instance_key(parent_key, ntree, node);
 		nodeexec->data.preview = context->previews ? BKE_node_instance_hash_lookup(context->previews, nodekey) : NULL;
 		if (node->typeinfo->initexecfunc)
 			nodeexec->data.data = node->typeinfo->initexecfunc(context, node, nodekey);
 	}
-	
+
 	if (nodelist)
 		MEM_freeN(nodelist);
-	
+
 	return exec;
 }
 
@@ -242,18 +242,18 @@ void ntree_exec_end(bNodeTreeExec *exec)
 {
 	bNodeExec *nodeexec;
 	int n;
-	
+
 	if (exec->stack)
 		MEM_freeN(exec->stack);
-	
+
 	for (n = 0, nodeexec = exec->nodeexec; n < exec->totnodes; ++n, ++nodeexec) {
 		if (nodeexec->freeexecfunc)
 			nodeexec->freeexecfunc(nodeexec->data.data);
 	}
-	
+
 	if (exec->nodeexec)
 		MEM_freeN(exec->nodeexec);
-	
+
 	MEM_freeN(exec);
 }
 
@@ -263,14 +263,14 @@ bNodeThreadStack *ntreeGetThreadStack(bNodeTreeExec *exec, int thread)
 {
 	ListBase *lb = &exec->threadstack[thread];
 	bNodeThreadStack *nts;
-	
+
 	for (nts = lb->first; nts; nts = nts->next) {
 		if (!nts->used) {
 			nts->used = true;
 			break;
 		}
 	}
-	
+
 	if (!nts) {
 		nts = MEM_callocN(sizeof(bNodeThreadStack), "bNodeThreadStack");
 		nts->stack = MEM_dupallocN(exec->stack);
@@ -293,9 +293,9 @@ bool ntreeExecThreadNodes(bNodeTreeExec *exec, bNodeThreadStack *nts, void *call
 	bNodeExec *nodeexec;
 	bNode *node;
 	int n;
-	
+
 	/* nodes are presorted, so exec is in order of list */
-	
+
 	for (n = 0, nodeexec = exec->nodeexec; n < exec->totnodes; ++n, ++nodeexec) {
 		node = nodeexec->node;
 		if (node->need_exec) {
@@ -310,7 +310,7 @@ bool ntreeExecThreadNodes(bNodeTreeExec *exec, bNodeThreadStack *nts, void *call
 				node->typeinfo->execfunc(callerdata, thread, node, &nodeexec->data, nsin, nsout);
 		}
 	}
-	
+
 	/* signal to that all went OK, for render */
 	return true;
 }
diff --git a/source/blender/nodes/intern/node_exec.h b/source/blender/nodes/intern/node_exec.h
index bf4c29bad8e..6771df76bf9 100644
--- a/source/blender/nodes/intern/node_exec.h
+++ b/source/blender/nodes/intern/node_exec.h
@@ -51,17 +51,17 @@ struct bNodeStack;
 typedef struct bNodeExec {
 	struct bNode *node;				/* backpointer to node */
 	bNodeExecData data;
-	
+
 	NodeFreeExecFunction freeexecfunc; /* free function, stored in exec itself to avoid dangling node pointer access */
 } bNodeExec;
 
 /* Execution Data for each instance of node tree execution */
 typedef struct bNodeTreeExec {
 	struct bNodeTree *nodetree;		/* backpointer to node tree */
-	
+
 	int totnodes;					/* total node count */
 	struct bNodeExec *nodeexec;		/* per-node execution data */
-	
+
 	int stacksize;
 	struct bNodeStack *stack;		/* socket data stack */
 	/* only used by material and texture trees to keep one stack for each thread */
diff --git a/source/blender/nodes/intern/node_socket.c b/source/blender/nodes/intern/node_socket.c
index 6e2cdb65a86..d1903a53334 100644
--- a/source/blender/nodes/intern/node_socket.c
+++ b/source/blender/nodes/intern/node_socket.c
@@ -52,9 +52,9 @@ struct Main;
 struct bNodeSocket *node_add_socket_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp, int in_out)
 {
 	bNodeSocket *sock = nodeAddStaticSocket(ntree, node, in_out, stemp->type, stemp->subtype, stemp->identifier, stemp->name);
-	
+
 	sock->flag |= stemp->flag;
-	
+
 	/* initialize default_value */
 	switch (stemp->type) {
 		case SOCK_FLOAT:
@@ -99,14 +99,14 @@ struct bNodeSocket *node_add_socket_from_template(struct bNodeTree *ntree, struc
 			break;
 		}
 	}
-	
+
 	return sock;
 }
 
 static bNodeSocket *verify_socket_template(bNodeTree *ntree, bNode *node, int in_out, ListBase *socklist, bNodeSocketTemplate *stemp)
 {
 	bNodeSocket *sock;
-	
+
 	for (sock = socklist->first; sock; sock = sock->next) {
 		if (STREQLEN(sock->name, stemp->name, NODE_MAXSTR))
 			break;
@@ -127,7 +127,7 @@ static bNodeSocket *verify_socket_template(bNodeTree *ntree, bNode *node, int in
 	/* remove the new socket from the node socket list first,
 	 * will be added back after verification. */
 	BLI_remlink(socklist, sock);
-	
+
 	return sock;
 }
 
@@ -135,7 +135,7 @@ static void verify_socket_template_list(bNodeTree *ntree, bNode *node, int in_ou
 {
 	bNodeSocket *sock, *nextsock;
 	bNodeSocketTemplate *stemp;
-	
+
 	/* no inputs anymore? */
 	if (stemp_first == NULL) {
 		for (sock = (bNodeSocket *)socklist->first; sock; sock = nextsock) {
@@ -155,7 +155,7 @@ static void verify_socket_template_list(bNodeTree *ntree, bNode *node, int in_ou
 			nextsock = sock->next;
 			nodeRemoveSocket(ntree, node, sock);
 		}
-		
+
 		/* and we put back the verified sockets */
 		stemp = stemp_first;
 		if (socklist->first) {
@@ -199,10 +199,10 @@ void node_socket_init_default_value(bNodeSocket *sock)
 {
 	int type = sock->typeinfo->type;
 	int subtype = sock->typeinfo->subtype;
-	
+
 	if (sock->default_value)
 		return; /* already initialized */
-	
+
 	switch (type) {
 		case SOCK_FLOAT:
 		{
@@ -211,7 +211,7 @@ void node_socket_init_default_value(bNodeSocket *sock)
 			dval->value = 0.0f;
 			dval->min = -FLT_MAX;
 			dval->max = FLT_MAX;
-		
+
 			sock->default_value = dval;
 			break;
 		}
@@ -222,7 +222,7 @@ void node_socket_init_default_value(bNodeSocket *sock)
 			dval->value = 0;
 			dval->min = INT_MIN;
 			dval->max = INT_MAX;
-		
+
 			sock->default_value = dval;
 			break;
 		}
@@ -230,7 +230,7 @@ void node_socket_init_default_value(bNodeSocket *sock)
 		{
 			bNodeSocketValueBoolean *dval = MEM_callocN(sizeof(bNodeSocketValueBoolean), "node socket value bool");
 			dval->value = false;
-		
+
 			sock->default_value = dval;
 			break;
 		}
@@ -242,7 +242,7 @@ void node_socket_init_default_value(bNodeSocket *sock)
 			copy_v3_v3(dval->value, default_value);
 			dval->min = -FLT_MAX;
 			dval->max = FLT_MAX;
-		
+
 			sock->default_value = dval;
 			break;
 		}
@@ -251,7 +251,7 @@ void node_socket_init_default_value(bNodeSocket *sock)
 			static float default_value[] = { 0.0f, 0.0f, 0.0f, 1.0f };
 			bNodeSocketValueRGBA *dval = MEM_callocN(sizeof(bNodeSocketValueRGBA), "node socket value color");
 			copy_v4_v4(dval->value, default_value);
-		
+
 			sock->default_value = dval;
 			break;
 		}
@@ -260,7 +260,7 @@ void node_socket_init_default_value(bNodeSocket *sock)
 			bNodeSocketValueString *dval = MEM_callocN(sizeof(bNodeSocketValueString), "node socket value string");
 			dval->subtype = subtype;
 			dval->value[0] = '\0';
-		
+
 			sock->default_value = dval;
 			break;
 		}
@@ -272,12 +272,12 @@ void node_socket_copy_default_value(bNodeSocket *to, bNodeSocket *from)
 	/* sanity check */
 	if (to->type != from->type)
 		return;
-	
+
 	/* make sure both exist */
 	if (!from->default_value)
 		return;
 	node_socket_init_default_value(to);
-	
+
 	switch (from->typeinfo->type) {
 		case SOCK_FLOAT:
 		{
@@ -330,7 +330,7 @@ static void standard_node_socket_interface_init_socket(bNodeTree *UNUSED(ntree),
 {
 	/* initialize the type value */
 	sock->type = sock->typeinfo->type;
-	
+
 	/* XXX socket interface 'type' value is not used really,
 	 * but has to match or the copy function will bail out
 	 */
@@ -345,12 +345,12 @@ static void standard_node_socket_interface_verify_socket(bNodeTree *UNUSED(ntree
 	/* sanity check */
 	if (sock->type != stemp->typeinfo->type)
 		return;
-	
+
 	/* make sure both exist */
 	if (!stemp->default_value)
 		return;
 	node_socket_init_default_value(sock);
-	
+
 	switch (stemp->typeinfo->type) {
 		case SOCK_FLOAT:
 		{
@@ -389,65 +389,65 @@ static void standard_node_socket_interface_from_socket(bNodeTree *UNUSED(ntree),
 static bNodeSocketType *make_standard_socket_type(int type, int subtype)
 {
 	extern void ED_init_standard_node_socket_type(bNodeSocketType *);
-	
+
 	const char *socket_idname = nodeStaticSocketType(type, subtype);
 	const char *interface_idname = nodeStaticSocketInterfaceType(type, subtype);
 	bNodeSocketType *stype;
 	StructRNA *srna;
-	
+
 	stype = MEM_callocN(sizeof(bNodeSocketType), "node socket C type");
 	BLI_strncpy(stype->idname, socket_idname, sizeof(stype->idname));
-	
+
 	/* set the RNA type
 	 * uses the exact same identifier as the socket type idname */
 	srna = stype->ext_socket.srna = RNA_struct_find(socket_idname);
 	BLI_assert(srna != NULL);
 	/* associate the RNA type with the socket type */
 	RNA_struct_blender_type_set(srna, stype);
-	
+
 	/* set the interface RNA type */
 	srna = stype->ext_interface.srna = RNA_struct_find(interface_idname);
 	BLI_assert(srna != NULL);
 	/* associate the RNA type with the socket type */
 	RNA_struct_blender_type_set(srna, stype);
-	
+
 	/* extra type info for standard socket types */
 	stype->type = type;
 	stype->subtype = subtype;
-	
+
 	/* XXX bad-level call! needed for setting draw callbacks */
 	ED_init_standard_node_socket_type(stype);
-	
+
 	stype->interface_init_socket = standard_node_socket_interface_init_socket;
 	stype->interface_from_socket = standard_node_socket_interface_from_socket;
 	stype->interface_verify_socket = standard_node_socket_interface_verify_socket;
-	
+
 	return stype;
 }
 
 static bNodeSocketType *make_socket_type_virtual(void)
 {
 	extern void ED_init_node_socket_type_virtual(bNodeSocketType *);
-	
+
 	const char *socket_idname = "NodeSocketVirtual";
 	bNodeSocketType *stype;
 	StructRNA *srna;
-	
+
 	stype = MEM_callocN(sizeof(bNodeSocketType), "node socket C type");
 	BLI_strncpy(stype->idname, socket_idname, sizeof(stype->idname));
-	
+
 	/* set the RNA type
 	 * uses the exact same identifier as the socket type idname */
 	srna = stype->ext_socket.srna = RNA_struct_find(socket_idname);
 	BLI_assert(srna != NULL);
 	/* associate the RNA type with the socket type */
 	RNA_struct_blender_type_set(srna, stype);
-	
+
 	/* extra type info for standard socket types */
 	stype->type = SOCK_CUSTOM;
-	
+
 	ED_init_node_socket_type_virtual(stype);
-	
+
 	return stype;
 }
 
@@ -455,21 +455,21 @@ static bNodeSocketType *make_socket_type_virtual(void)
 void register_standard_node_socket_types(void)
 {
 	/* draw callbacks are set in drawnode.c to avoid bad-level calls */
-	
+
 	nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_NONE));
 	nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_UNSIGNED));
 	nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_PERCENTAGE));
 	nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_FACTOR));
 	nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_ANGLE));
 	nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_TIME));
-	
+
 	nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_NONE));
 	nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_UNSIGNED));
 	nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_PERCENTAGE));
 	nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_FACTOR));
-	
+
 	nodeRegisterSocketType(make_standard_socket_type(SOCK_BOOLEAN, PROP_NONE));
-	
+
 	nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_NONE));
 	nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_TRANSLATION));
 	nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_DIRECTION));
@@ -477,12 +477,12 @@ void register_standard_node_socket_types(void)
 	nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_ACCELERATION));
 	nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_EULER));
 	nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_XYZ));
-	
+
 	nodeRegisterSocketType(make_standard_socket_type(SOCK_RGBA, PROP_NONE));
-	
+
 	nodeRegisterSocketType(make_standard_socket_type(SOCK_STRING, PROP_NONE));
-	
+
 	nodeRegisterSocketType(make_standard_socket_type(SOCK_SHADER, PROP_NONE));
-	
+
 	nodeRegisterSocketType(make_socket_type_virtual());
 }
diff --git a/source/blender/nodes/intern/node_util.c b/source/blender/nodes/intern/node_util.c
index 45409a2dfad..19529794c7c 100644
--- a/source/blender/nodes/intern/node_util.c
+++ b/source/blender/nodes/intern/node_util.c
@@ -165,10 +165,10 @@ static int node_count_links(bNodeTree *ntree, bNodeSocket *sock)
 static bNodeSocket *node_find_linkable_socket(bNodeTree *ntree, bNode *node, bNodeSocket *cur)
 {
 	/* link swapping: try to find a free slot with a matching name */
-	
+
 	bNodeSocket *first = cur->in_out == SOCK_IN ? node->inputs.first : node->outputs.first;
 	bNodeSocket *sock;
-	
+
 	sock = cur->next ? cur->next : first; /* wrap around the list end */
 	while (sock != cur) {
 		if (!nodeSocketIsHidden(sock) && node_link_socket_match(sock, cur)) {
@@ -177,7 +177,7 @@ static bNodeSocket *node_find_linkable_socket(bNodeTree *ntree, bNode *node, bNo
 			if (link_count + 1 <= sock->limit)
 				return sock; /* found a valid free socket we can swap to */
 		}
-		
+
 		sock = sock->next ? sock->next : first; /* wrap around the list end */
 	}
 	return NULL;
@@ -187,18 +187,18 @@ void node_insert_link_default(bNodeTree *ntree, bNode *node, bNodeLink *link)
 {
 	bNodeSocket *sock = link->tosock;
 	bNodeLink *tlink, *tlink_next;
-	
+
 	/* inputs can have one link only, outputs can have unlimited links */
 	if (node != link->tonode)
 		return;
-	
+
 	for (tlink = ntree->links.first; tlink; tlink = tlink_next) {
 		bNodeSocket *new_sock;
 		tlink_next = tlink->next;
-		
+
 		if (sock != tlink->tosock)
 			continue;
-		
+
 		new_sock = node_find_linkable_socket(ntree, node, sock);
 		if (new_sock && new_sock != sock) {
 			/* redirect existing link */
@@ -287,12 +287,12 @@ static bNodeSocket *select_internal_link_input(bNode *node, bNodeSocket *output)
 	int i;
 	int sel_priority = -1;
 	bool sel_is_linked = false;
-	
+
 	for (input = node->inputs.first, i = 0; input; input = input->next, ++i) {
 		int priority = node_datatype_priority(input->type, output->type);
 		bool is_linked = (input->link != NULL);
 		bool preferred;
-		
+
 		if (nodeSocketIsHidden(input) ||                /* ignore hidden sockets */
 		    input->flag & SOCK_NO_INTERNAL_LINK ||      /* ignore if input is not allowed for internal connections */
 		    priority < 0 ||                             /* ignore incompatible types */
@@ -300,18 +300,18 @@ static bNodeSocket *select_internal_link_input(bNode *node, bNodeSocket *output)
 		{
 			continue;
 		}
-		
+
 		/* determine if this input is preferred over the currently selected */
 		preferred = (priority > sel_priority) ||    /* prefer higher datatype priority */
 		            (is_linked && !sel_is_linked);  /* prefer linked over unlinked */
-		
+
 		if (preferred) {
 			selected = input;
 			sel_is_linked = is_linked;
 			sel_priority = priority;
 		}
 	}
-	
+
 	return selected;
 }
 
@@ -319,29 +319,29 @@ void node_update_internal_links_default(bNodeTree *ntree, bNode *node)
 {
 	bNodeLink *link;
 	bNodeSocket *output, *input;
-	
+
 	/* sanity check */
 	if (!ntree)
 		return;
-	
+
 	/* use link pointer as a tag for handled sockets (for outputs is unused anyway) */
 	for (output = node->outputs.first; output; output = output->next)
 		output->link = NULL;
-	
+
 	for (link = ntree->links.first; link; link = link->next) {
 		if (nodeLinkIsHidden(link))
 			continue;
-		
+
 		output = link->fromsock;
 		if (link->fromnode != node || output->link)
 			continue;
 		if (nodeSocketIsHidden(output) || output->flag & SOCK_NO_INTERNAL_LINK)
 			continue;
 		output->link = link; /* not really used, just for tagging handled sockets */
-		
+
 		/* look for suitable input */
 		input = select_internal_link_input(node, output);
-		
+
 		if (input) {
 			bNodeLink *ilink = MEM_callocN(sizeof(bNodeLink), "internal node link");
 			ilink->fromnode = node;
@@ -353,7 +353,7 @@ void node_update_internal_links_default(bNodeTree *ntree, bNode *node)
 			BLI_addtail(&node->internal_links, ilink);
 		}
 	}
-	
+
 	/* clean up */
 	for (output = node->outputs.first; output; output = output->next)
 		output->link = NULL;