Changed delegate prototype to make it easier to use the renderer and customize it.

9 files changed, 122 insertions, 110 deletions

diff --git a/example/mac/macExample/macExample/MCTMsgViewController.m b/example/mac/macExample/macExample/MCTMsgViewController.m
index 421f9bcf..dcb6f41c 100644
--- a/example/mac/macExample/macExample/MCTMsgViewController.m
+++ b/example/mac/macExample/macExample/MCTMsgViewController.m
@@ -117,7 +117,7 @@ typedef void (^DownloadCallback)(NSError * error);
     NSLog(@"done: %@", blocks);
 }
 
-- (NSString *) MCOMessageView_templateForAttachment:(MCOMessageView *)view
+- (NSString *) MCOMessageView:(MCOMessageView *)view templateForAttachment:(MCOAbstractPart *)part
 {
     return @"<div><img src=\"http://www.iconshock.com/img_jpg/OFFICE/general/jpg/128/attachment_icon.jpg\"/></div>\
 {{#HASSIZE}}\
diff --git a/src/core/renderer/MCHTMLRenderer.cc b/src/core/renderer/MCHTMLRenderer.cc
index 0e52587f..5cffa106 100644
--- a/src/core/renderer/MCHTMLRenderer.cc
+++ b/src/core/renderer/MCHTMLRenderer.cc
@@ -198,12 +198,12 @@ static String * htmlForAbstractMessage(String * folder, AbstractMessage * messag
     content = htmlCallback->filterHTMLForMessage(content);
     
     HashMap * values = htmlCallback->templateValuesForHeader(message->header());
-    String * headerString = renderTemplate(htmlCallback->templateForMainHeader(), values);
+    String * headerString = renderTemplate(htmlCallback->templateForMainHeader(message->header()), values);
     
     HashMap * msgValues = new HashMap();
     msgValues->setObjectForKey(MCSTR("HEADER"), headerString);
     msgValues->setObjectForKey(MCSTR("BODY"), content);
-    String * result = renderTemplate(htmlCallback->templateForMessage(), msgValues);
+    String * result = renderTemplate(htmlCallback->templateForMessage(message), msgValues);
     msgValues->release();
     
     return result;
@@ -330,14 +330,14 @@ static String * htmlForAbstractSinglePart(AbstractPart * part, htmlRendererConte
                                                                             part->uniqueID()->UTF8Characters());
             HashMap * values = context->htmlCallback->templateValuesForPart(part);
             values->setObjectForKey(MCSTR("URL"), url);
-            content = renderTemplate(context->htmlCallback->templateForImage(), values);
+            content = renderTemplate(context->htmlCallback->templateForImage(part), values);
         }
         else {
             if (part->className()->isEqual(MCSTR("mailcore::IMAPPart"))) {
                 context->dataCallback->prefetchAttachmentIMAPPart(context->folder, (IMAPPart *) part);
             }
             HashMap * values = context->htmlCallback->templateValuesForPart(part);
-            content = renderTemplate(context->htmlCallback->templateForAttachment(), values);
+            content = renderTemplate(context->htmlCallback->templateForAttachment(part), values);
         }
         
         result->appendString(separatorString);
@@ -360,12 +360,12 @@ static String * htmlForAbstractMessagePart(AbstractMessagePart * part, htmlRende
     MCAssert(substring != NULL);
     
     HashMap * values = context->htmlCallback->templateValuesForHeader(part->header());
-    String * headerString = renderTemplate(context->htmlCallback->templateForEmbeddedMessageHeader(), values);
+    String * headerString = renderTemplate(context->htmlCallback->templateForEmbeddedMessageHeader(part->header()), values);
 	
 	HashMap * msgValues = new HashMap();
     msgValues->setObjectForKey(MCSTR("HEADER"), headerString);
     msgValues->setObjectForKey(MCSTR("BODY"), substring);
-    String * result = renderTemplate(context->htmlCallback->templateForEmbeddedMessage(), msgValues);
+    String * result = renderTemplate(context->htmlCallback->templateForEmbeddedMessage(part), msgValues);
     msgValues->release();
 
     return result;
diff --git a/src/core/renderer/MCHTMLRendererCallback.cc b/src/core/renderer/MCHTMLRendererCallback.cc
index 0d086e2b..5147e934 100644
--- a/src/core/renderer/MCHTMLRendererCallback.cc
+++ b/src/core/renderer/MCHTMLRendererCallback.cc
@@ -178,7 +178,7 @@ mailcore::HashMap * HTMLRendererTemplateCallback::templateValuesForPart(mailcore
     return result;
 }
 
-mailcore::String * HTMLRendererTemplateCallback::templateForMainHeader()
+mailcore::String * HTMLRendererTemplateCallback::templateForMainHeader(MessageHeader * header)
 {
     return MCSTR("<div style=\"background-color:#eee\">\
                  {{#HASFROM}}\
@@ -206,17 +206,17 @@ mailcore::String * HTMLRendererTemplateCallback::templateForMainHeader()
                  </div>");
 }
 
-mailcore::String * HTMLRendererTemplateCallback::templateForEmbeddedMessageHeader()
+mailcore::String * HTMLRendererTemplateCallback::templateForEmbeddedMessageHeader(MessageHeader * header)
 {
-    return templateForMainHeader();
+    return templateForMainHeader(header);
 }
 
-mailcore::String * HTMLRendererTemplateCallback::templateForImage()
+mailcore::String * HTMLRendererTemplateCallback::templateForImage(AbstractPart * part)
 {
     return MCSTR("");
 }
 
-mailcore::String * HTMLRendererTemplateCallback::templateForAttachment()
+mailcore::String * HTMLRendererTemplateCallback::templateForAttachment(AbstractPart * part)
 {
     return MCSTR("{{#HASSIZE}}\
                  <div>- {{FILENAME}}, {{SIZE}}</div>\
@@ -227,15 +227,15 @@ mailcore::String * HTMLRendererTemplateCallback::templateForAttachment()
                  ");
 }
 
-mailcore::String * HTMLRendererTemplateCallback::templateForMessage()
+mailcore::String * HTMLRendererTemplateCallback::templateForMessage(AbstractMessage * message)
 {
     return MCSTR("<div style=\"padding-bottom: 20px;\">{{HEADER}}</div><div>{{BODY}}</div>");
 }
 
 
-mailcore::String * HTMLRendererTemplateCallback::templateForEmbeddedMessage()
+mailcore::String * HTMLRendererTemplateCallback::templateForEmbeddedMessage(AbstractMessagePart * part)
 {
-    return templateForMessage();
+    return MCSTR("<div style=\"padding-bottom: 20px;\">{{HEADER}}</div><div>{{BODY}}</div>");
 }
 
 mailcore::String * HTMLRendererTemplateCallback::templateForAttachmentSeparator()
diff --git a/src/core/renderer/MCHTMLRendererCallback.h b/src/core/renderer/MCHTMLRendererCallback.h
index 3cd584a6..84292dad 100644
--- a/src/core/renderer/MCHTMLRendererCallback.h
+++ b/src/core/renderer/MCHTMLRendererCallback.h
@@ -34,12 +34,12 @@ namespace mailcore {
         virtual HashMap * templateValuesForHeader(MessageHeader * header);
         virtual HashMap * templateValuesForPart(AbstractPart * part);
         
-        virtual String * templateForMainHeader();
-        virtual String * templateForImage();
-        virtual String * templateForAttachment();
-        virtual String * templateForMessage();
-        virtual String * templateForEmbeddedMessage();
-        virtual String * templateForEmbeddedMessageHeader();
+        virtual String * templateForMainHeader(MessageHeader * header);
+        virtual String * templateForImage(AbstractPart * part);
+        virtual String * templateForAttachment(AbstractPart * part);
+        virtual String * templateForMessage(AbstractMessage * message);
+        virtual String * templateForEmbeddedMessage(AbstractMessagePart * part);
+        virtual String * templateForEmbeddedMessageHeader(MessageHeader * header);
         virtual String * templateForAttachmentSeparator();
 		
         // Can be used to filter some HTML tags.
diff --git a/src/objc/abstract/MCOAbstractMessageRendererCallback.h b/src/objc/abstract/MCOAbstractMessageRendererCallback.h
index 1df53ce2..f7bac82d 100644
--- a/src/objc/abstract/MCOAbstractMessageRendererCallback.h
+++ b/src/objc/abstract/MCOAbstractMessageRendererCallback.h
@@ -26,12 +26,12 @@ public:
     virtual bool shouldShowPart(mailcore::AbstractPart * part);
     virtual mailcore::HashMap * templateValuesForHeader(mailcore::MessageHeader * header);
     virtual mailcore::HashMap * templateValuesForPart(mailcore::AbstractPart * part);
-    virtual mailcore::String * templateForMainHeader();
-    virtual mailcore::String * templateForImage();
-    virtual mailcore::String * templateForAttachment();
-    virtual mailcore::String * templateForMessage();
-    virtual mailcore::String * templateForEmbeddedMessage();
-    virtual mailcore::String * templateForEmbeddedMessageHeader();
+    virtual mailcore::String * templateForMainHeader(mailcore::MessageHeader * header);
+    virtual mailcore::String * templateForImage(mailcore::AbstractPart * part);
+    virtual mailcore::String * templateForAttachment(mailcore::AbstractPart * part);
+    virtual mailcore::String * templateForMessage(mailcore::AbstractMessage * message);
+    virtual mailcore::String * templateForEmbeddedMessage(mailcore::AbstractMessagePart * part);
+    virtual mailcore::String * templateForEmbeddedMessageHeader(mailcore::MessageHeader * header);
     virtual mailcore::String * templateForAttachmentSeparator();
     virtual mailcore::String * filterHTMLForPart(mailcore::String * html);
     virtual mailcore::String * filterHTMLForMessage(mailcore::String * html);
diff --git a/src/objc/abstract/MCOAbstractMessageRendererCallback.mm b/src/objc/abstract/MCOAbstractMessageRendererCallback.mm
index 887798d5..20812058 100644
--- a/src/objc/abstract/MCOAbstractMessageRendererCallback.mm
+++ b/src/objc/abstract/MCOAbstractMessageRendererCallback.mm
@@ -12,6 +12,8 @@
 #import "MCOHTMLRendererIMAPDelegate.h"
 #import "MCOUtils.h"
 
+using namespace mailcore;
+
 MCOAbstractMessageRendererCallback::MCOAbstractMessageRendererCallback(MCOAbstractMessage * message, id <MCOHTMLRendererDelegate> rendererDelegate,
                                    id <MCOHTMLRendererIMAPDelegate> rendererIMAPDelegate)
 {
@@ -20,171 +22,171 @@ MCOAbstractMessageRendererCallback::MCOAbstractMessageRendererCallback(MCOAbstra
     mIMAPDelegate = rendererIMAPDelegate;
 }
 
-bool MCOAbstractMessageRendererCallback::canPreviewPart(mailcore::AbstractPart * part)
+bool MCOAbstractMessageRendererCallback::canPreviewPart(AbstractPart * part)
 {
     if ([mRendererDelegate respondsToSelector:@selector(MCOAbstractMessage:canPreviewPart:)]) {
         return [mRendererDelegate MCOAbstractMessage:mMessage canPreviewPart:MCO_TO_OBJC(part)];
     }
-    return mailcore::HTMLRendererTemplateCallback::canPreviewPart(part);
+    return HTMLRendererTemplateCallback::canPreviewPart(part);
 }
 
-bool MCOAbstractMessageRendererCallback::shouldShowPart(mailcore::AbstractPart * part)
+bool MCOAbstractMessageRendererCallback::shouldShowPart(AbstractPart * part)
 {
     if ([mRendererDelegate respondsToSelector:@selector(MCOAbstractMessage:shouldShowPart:)]) {
         return [mRendererDelegate MCOAbstractMessage:mMessage shouldShowPart:MCO_TO_OBJC(part)];
     }
-    return mailcore::HTMLRendererTemplateCallback::shouldShowPart(part);
+    return HTMLRendererTemplateCallback::shouldShowPart(part);
 }
 
-mailcore::HashMap * MCOAbstractMessageRendererCallback::templateValuesForHeader(mailcore::MessageHeader * header)
+HashMap * MCOAbstractMessageRendererCallback::templateValuesForHeader(MessageHeader * header)
 {
-    mailcore::HashMap * result = NULL;
+    HashMap * result = NULL;
     if ([mRendererDelegate respondsToSelector:@selector(MCOAbstractMessage:templateValuesForHeader:)]) {
-        result = MCO_FROM_OBJC(mailcore::HashMap, [mRendererDelegate MCOAbstractMessage:mMessage templateValuesForHeader:MCO_TO_OBJC(header)]);
+        result = MCO_FROM_OBJC(HashMap, [mRendererDelegate MCOAbstractMessage:mMessage templateValuesForHeader:MCO_TO_OBJC(header)]);
     }
     if (result == NULL) {
-        result = mailcore::HTMLRendererTemplateCallback::templateValuesForHeader(header);
+        result = HTMLRendererTemplateCallback::templateValuesForHeader(header);
     }
     return result;
 }
 
-mailcore::HashMap * MCOAbstractMessageRendererCallback::templateValuesForPart(mailcore::AbstractPart * part)
+HashMap * MCOAbstractMessageRendererCallback::templateValuesForPart(AbstractPart * part)
 {
-    mailcore::HashMap * result = NULL;
+    HashMap * result = NULL;
     if ([mRendererDelegate respondsToSelector:@selector(MCOAbstractMessage:templateValuesForPart:)]) {
-        result = MCO_FROM_OBJC(mailcore::HashMap, [mRendererDelegate MCOAbstractMessage:mMessage templateValuesForPart:MCO_TO_OBJC(part)]);
+        result = MCO_FROM_OBJC(HashMap, [mRendererDelegate MCOAbstractMessage:mMessage templateValuesForPart:MCO_TO_OBJC(part)]);
     }
     if (result == NULL) {
-        result = mailcore::HTMLRendererTemplateCallback::templateValuesForPart(part);
+        result = HTMLRendererTemplateCallback::templateValuesForPart(part);
     }
     return result;
 }
 
-mailcore::String * MCOAbstractMessageRendererCallback::templateForMainHeader()
+String * MCOAbstractMessageRendererCallback::templateForMainHeader(MessageHeader * header)
 {
-    mailcore::String * result = NULL;
-    if ([mRendererDelegate respondsToSelector:@selector(MCOAbstractMessage_templateForMainHeader:)]) {
-        result = MCO_FROM_OBJC(mailcore::String, [mRendererDelegate MCOAbstractMessage_templateForMainHeader:mMessage]);
+    String * result = NULL;
+    if ([mRendererDelegate respondsToSelector:@selector(MCOAbstractMessage:templateForMainHeader:)]) {
+        result = MCO_FROM_OBJC(String, [mRendererDelegate MCOAbstractMessage:mMessage templateForMainHeader:MCO_TO_OBJC(header)]);
     }
     if (result == NULL) {
-        result = mailcore::HTMLRendererTemplateCallback::templateForMainHeader();
+        result = HTMLRendererTemplateCallback::templateForMainHeader(header);
     }
     return result;
 }
 
-mailcore::String * MCOAbstractMessageRendererCallback::templateForImage()
+String * MCOAbstractMessageRendererCallback::templateForImage(AbstractPart * part)
 {
-    mailcore::String * result = NULL;
-    if ([mRendererDelegate respondsToSelector:@selector(MCOAbstractMessage_templateForImage:)]) {
-        result = MCO_FROM_OBJC(mailcore::String, [mRendererDelegate MCOAbstractMessage_templateForImage:mMessage]);
+    String * result = NULL;
+    if ([mRendererDelegate respondsToSelector:@selector(MCOAbstractMessage:templateForImage:)]) {
+        result = MCO_FROM_OBJC(String, [mRendererDelegate MCOAbstractMessage:mMessage templateForImage:MCO_TO_OBJC(part)]);
     }
     if (result == NULL) {
-        result = mailcore::HTMLRendererTemplateCallback::templateForImage();
+        result = HTMLRendererTemplateCallback::templateForImage(part);
     }
     return result;
 }
 
-mailcore::String * MCOAbstractMessageRendererCallback::templateForAttachment()
+String * MCOAbstractMessageRendererCallback::templateForAttachment(AbstractPart * part)
 {
-    mailcore::String * result = NULL;
-    if ([mRendererDelegate respondsToSelector:@selector(MCOAbstractMessage_templateForAttachment:)]) {
-        result = MCO_FROM_OBJC(mailcore::String, [mRendererDelegate MCOAbstractMessage_templateForAttachment:mMessage]);
+    String * result = NULL;
+    if ([mRendererDelegate respondsToSelector:@selector(MCOAbstractMessage:templateForAttachment:)]) {
+        result = MCO_FROM_OBJC(String, [mRendererDelegate MCOAbstractMessage:mMessage templateForAttachment:MCO_TO_OBJC(part)]);
     }
     if (result == NULL) {
-        result = mailcore::HTMLRendererTemplateCallback::templateForAttachment();
+        result = HTMLRendererTemplateCallback::templateForAttachment(part);
     }
     return result;
 }
 
-mailcore::String * MCOAbstractMessageRendererCallback::templateForMessage()
+String * MCOAbstractMessageRendererCallback::templateForMessage(AbstractMessage * message)
 {
-    mailcore::String * result = NULL;
+    String * result = NULL;
     if ([mRendererDelegate respondsToSelector:@selector(MCOAbstractMessage_templateForMessage:)]) {
-        result = MCO_FROM_OBJC(mailcore::String, [mRendererDelegate MCOAbstractMessage_templateForMessage:mMessage]);
+        result = MCO_FROM_OBJC(String, [mRendererDelegate MCOAbstractMessage_templateForMessage:mMessage]);
     }
     if (result == NULL) {
-        result = mailcore::HTMLRendererTemplateCallback::templateForMessage();
+        result = HTMLRendererTemplateCallback::templateForMessage(message);
     }
     return result;
 }
 
-mailcore::String * MCOAbstractMessageRendererCallback::templateForEmbeddedMessage()
+String * MCOAbstractMessageRendererCallback::templateForEmbeddedMessage(AbstractMessagePart * part)
 {
-    mailcore::String * result = NULL;
-    if ([mRendererDelegate respondsToSelector:@selector(MCOAbstractMessage_templateForEmbeddedMessage:)]) {
-        result = MCO_FROM_OBJC(mailcore::String, [mRendererDelegate MCOAbstractMessage_templateForEmbeddedMessage:mMessage]);
+    String * result = NULL;
+    if ([mRendererDelegate respondsToSelector:@selector(MCOAbstractMessage:templateForEmbeddedMessage:)]) {
+        result = MCO_FROM_OBJC(String, [mRendererDelegate MCOAbstractMessage:mMessage templateForEmbeddedMessage:MCO_TO_OBJC(part)]);
     }
     if (result == NULL) {
-        result = mailcore::HTMLRendererTemplateCallback::templateForEmbeddedMessage();
+        result = HTMLRendererTemplateCallback::templateForEmbeddedMessage(part);
     }
     return result;
 }
 
-mailcore::String * MCOAbstractMessageRendererCallback::templateForEmbeddedMessageHeader()
+String * MCOAbstractMessageRendererCallback::templateForEmbeddedMessageHeader(MessageHeader * header)
 {
-    mailcore::String * result = NULL;
-    if ([mRendererDelegate respondsToSelector:@selector(MCOAbstractMessage_templateForEmbeddedMessageHeader:)]) {
-        result = MCO_FROM_OBJC(mailcore::String, [mRendererDelegate MCOAbstractMessage_templateForEmbeddedMessageHeader:mMessage]);
+    String * result = NULL;
+    if ([mRendererDelegate respondsToSelector:@selector(MCOAbstractMessage:templateForEmbeddedMessageHeader:)]) {
+        result = MCO_FROM_OBJC(String, [mRendererDelegate MCOAbstractMessage:mMessage templateForEmbeddedMessageHeader:MCO_TO_OBJC(header)]);
     }
     if (result == NULL) {
-        result = mailcore::HTMLRendererTemplateCallback::templateForEmbeddedMessageHeader();
+        result = HTMLRendererTemplateCallback::templateForEmbeddedMessageHeader(header);
     }
     return result;
 }
 
-mailcore::String * MCOAbstractMessageRendererCallback::templateForAttachmentSeparator()
+String * MCOAbstractMessageRendererCallback::templateForAttachmentSeparator()
 {
-    mailcore::String * result = NULL;
+    String * result = NULL;
     if ([mRendererDelegate respondsToSelector:@selector(MCOAbstractMessage_templateForAttachmentSeparator:)]) {
-        result = MCO_FROM_OBJC(mailcore::String, [mRendererDelegate MCOAbstractMessage_templateForAttachmentSeparator:mMessage]);
+        result = MCO_FROM_OBJC(String, [mRendererDelegate MCOAbstractMessage_templateForAttachmentSeparator:mMessage]);
     }
     if (result == NULL) {
-        result = mailcore::HTMLRendererTemplateCallback::templateForAttachmentSeparator();
+        result = HTMLRendererTemplateCallback::templateForAttachmentSeparator();
     }
     return result;
 }
 
-mailcore::String * MCOAbstractMessageRendererCallback::filterHTMLForPart(mailcore::String * html)
+String * MCOAbstractMessageRendererCallback::filterHTMLForPart(String * html)
 {
-    mailcore::String * result = NULL;
+    String * result = NULL;
     if ([mRendererDelegate respondsToSelector:@selector(MCOAbstractMessage:filterHTMLForPart:)]) {
-        result = MCO_FROM_OBJC(mailcore::String, [mRendererDelegate MCOAbstractMessage:mMessage filterHTMLForPart:MCO_TO_OBJC(html)]);
+        result = MCO_FROM_OBJC(String, [mRendererDelegate MCOAbstractMessage:mMessage filterHTMLForPart:MCO_TO_OBJC(html)]);
     }
     if (result == NULL) {
-        result = mailcore::HTMLRendererTemplateCallback::filterHTMLForPart(html);
+        result = HTMLRendererTemplateCallback::filterHTMLForPart(html);
     }
     return result;
 }
 
-mailcore::String * MCOAbstractMessageRendererCallback::filterHTMLForMessage(mailcore::String * html)
+String * MCOAbstractMessageRendererCallback::filterHTMLForMessage(String * html)
 {
-    mailcore::String * result = NULL;
+    String * result = NULL;
     if ([mRendererDelegate respondsToSelector:@selector(MCOAbstractMessage:filterHTMLForMessage:)]) {
-        result = MCO_FROM_OBJC(mailcore::String, [mRendererDelegate MCOAbstractMessage:mMessage filterHTMLForMessage:MCO_TO_OBJC(html)]);
+        result = MCO_FROM_OBJC(String, [mRendererDelegate MCOAbstractMessage:mMessage filterHTMLForMessage:MCO_TO_OBJC(html)]);
     }
     if (result == NULL) {
-        result = mailcore::HTMLRendererTemplateCallback::filterHTMLForMessage(html);
+        result = HTMLRendererTemplateCallback::filterHTMLForMessage(html);
     }
     return result;
 }
 
-mailcore::Data * MCOAbstractMessageRendererCallback::dataForIMAPPart(mailcore::String * folder, mailcore::IMAPPart * part)
+Data * MCOAbstractMessageRendererCallback::dataForIMAPPart(String * folder, IMAPPart * part)
 {
-    mailcore::Data * result = NULL;
+    Data * result = NULL;
     if ([mIMAPDelegate respondsToSelector:@selector(MCOAbstractMessage:dataForIMAPPart:folder:)]) {
         result = [[mIMAPDelegate MCOAbstractMessage:mMessage dataForIMAPPart:MCO_TO_OBJC(part) folder:MCO_TO_OBJC(folder)] mco_mcData];
     }
     return result;
 }
 
-void MCOAbstractMessageRendererCallback::prefetchAttachmentIMAPPart(mailcore::String * folder, mailcore::IMAPPart * part)
+void MCOAbstractMessageRendererCallback::prefetchAttachmentIMAPPart(String * folder, IMAPPart * part)
 {
     if ([mIMAPDelegate respondsToSelector:@selector(MCOAbstractMessage:prefetchAttachmentIMAPPart:folder:)]) {
         [mIMAPDelegate MCOAbstractMessage:mMessage prefetchAttachmentIMAPPart:MCO_TO_OBJC(part) folder:MCO_TO_OBJC(folder)];
     }
 }
 
-void MCOAbstractMessageRendererCallback::prefetchImageIMAPPart(mailcore::String * folder, mailcore::IMAPPart * part)
+void MCOAbstractMessageRendererCallback::prefetchImageIMAPPart(String * folder, IMAPPart * part)
 {
     if ([mIMAPDelegate respondsToSelector:@selector(MCOAbstractMessage:prefetchImageIMAPPart:folder:)]) {
         [mIMAPDelegate MCOAbstractMessage:mMessage prefetchImageIMAPPart:MCO_TO_OBJC(part) folder:MCO_TO_OBJC(folder)];
diff --git a/src/objc/abstract/MCOHTMLRendererDelegate.h b/src/objc/abstract/MCOHTMLRendererDelegate.h
index daa8e626..dae1425a 100644
--- a/src/objc/abstract/MCOHTMLRendererDelegate.h
+++ b/src/objc/abstract/MCOHTMLRendererDelegate.h
@@ -23,6 +23,7 @@
 @class MCOAbstractPart;
 @class MCOAbstractMessage;
 @class MCOMessageHeader;
+@class MCOAbstractMessagePart;
 
 @protocol MCOHTMLRendererDelegate <NSObject>
 
@@ -51,14 +52,14 @@
 
 // This delegate method returns the template for the main header of the message.
 // See the content of MCHTMLRendererCallback.cpp for the default values of the template.
-- (NSString *) MCOAbstractMessage_templateForMainHeader:(MCOAbstractMessage *)msg;
+- (NSString *) MCOAbstractMessage:(MCOAbstractMessage *)msg templateForMainHeader:(MCOMessageHeader *)header;
 
 // This delegate method returns the template an image attachment.
-- (NSString *) MCOAbstractMessage_templateForImage:(MCOAbstractMessage *)msg;
+- (NSString *) MCOAbstractMessage:(MCOAbstractMessage *)msg templateForImage:(MCOAbstractPart *)header;
 
 // This delegate method returns the template attachment other than images.
 // See the content of MCHTMLRendererCallback.cpp for the default values of the template.
-- (NSString *) MCOAbstractMessage_templateForAttachment:(MCOAbstractMessage *)msg;
+- (NSString *) MCOAbstractMessage:(MCOAbstractMessage *)msg templateForAttachment:(MCOAbstractPart *)part;
 
 // This delegate method returns the template of the main message.
 // It should include HEADER and a BODY values.
@@ -68,11 +69,11 @@
 // This delegate method returns the template of an embedded message (included as attachment).
 // It should include HEADER and a BODY values.
 // See the content of MCHTMLRendererCallback.cpp for the default values of the template.
-- (NSString *) MCOAbstractMessage_templateForEmbeddedMessage:(MCOAbstractMessage *)msg;
+- (NSString *) MCOAbstractMessage:(MCOAbstractMessage *)msg templateForEmbeddedMessage:(MCOAbstractMessagePart *)part;
 
 // This delegate method returns the template for the header of an embedded message.
 // See the content of MCHTMLRendererCallback.cpp for the default values of the template.
-- (NSString *) MCOAbstractMessage_templateForEmbeddedMessageHeader:(MCOAbstractMessage *)msg;
+- (NSString *) MCOAbstractMessage:(MCOAbstractMessage *)msg templateForEmbeddedMessageHeader:(MCOMessageHeader *)header;
 
 // This delegate method returns the separator between the text of the message and the attachments.
 // This delegate method returns the template for the header of an embedded message.
diff --git a/src/ui/mac/MCOMessageView.h b/src/ui/mac/MCOMessageView.h
index fa25184f..e5b05143 100644
--- a/src/ui/mac/MCOMessageView.h
+++ b/src/ui/mac/MCOMessageView.h
@@ -30,17 +30,18 @@
 - (void) MCOMessageView:(MCOMessageView *)view fetchDataForPartWithUniqueID:(NSString *)partUniqueID
      downloadedFinished:(void (^)(NSError * error))downloadFinished;
 
-- (NSString *) MCOMessageView_templateForMainHeader:(MCOMessageView *)view;
-- (NSString *) MCOMessageView_templateForImage:(MCOMessageView *)view;
-- (NSString *) MCOMessageView_templateForAttachment:(MCOMessageView *)view;
+- (NSString *) MCOMessageView:(MCOMessageView *)view templateForMainHeader:(MCOMessageHeader *)header;
+- (NSString *) MCOMessageView:(MCOMessageView *)view templateForImage:(MCOAbstractPart *)part;
+- (NSString *) MCOMessageView:(MCOMessageView *)view templateForAttachment:(MCOAbstractPart *)part;
 - (NSString *) MCOMessageView_templateForMessage:(MCOMessageView *)view;
-- (NSString *) MCOMessageView_templateForEmbeddedMessage:(MCOMessageView *)view;
-- (NSString *) MCOMessageView_templateForEmbeddedMessageHeader:(MCOMessageView *)view;
+- (NSString *) MCOMessageView:(MCOMessageView *)view templateForEmbeddedMessage:(MCOAbstractMessagePart *)part;
+- (NSString *) MCOMessageView:(MCOMessageView *)view templateForEmbeddedMessageHeader:(MCOMessageHeader *)header;
 - (NSString *) MCOMessageView_templateForAttachmentSeparator:(MCOMessageView *)view;
 
 - (NSDictionary *) MCOMessageView:(MCOMessageView *)view templateValuesForPartWithUniqueID:(NSString *)uniqueID;
 - (NSDictionary *) MCOMessageView:(MCOMessageView *)view templateValuesForHeader:(MCOMessageHeader *)header;
 - (BOOL) MCOMessageView:(MCOMessageView *)view canPreviewPart:(MCOAbstractPart *)part;
+- (BOOL) MCOMessageView:(MCOMessageView *)msg shouldShowPart:(MCOAbstractPart *)part;
 
 - (NSString *) MCOMessageView:(MCOMessageView *)view filteredHTMLForPart:(NSString *)html;
 - (NSString *) MCOMessageView:(MCOMessageView *)view filteredHTMLForMessage:(NSString *)html;
diff --git a/src/ui/mac/MCOMessageView.mm b/src/ui/mac/MCOMessageView.mm
index 4e3b908c..bbcf0b1c 100644
--- a/src/ui/mac/MCOMessageView.mm
+++ b/src/ui/mac/MCOMessageView.mm
@@ -205,11 +205,19 @@
     }
     
     if (![[self delegate] respondsToSelector:@selector(MCOMessageView:canPreviewPart:)]) {
-        return false;
+        return NO;
     }
     return [[self delegate] MCOMessageView:self canPreviewPart:part];
 }
 
+- (BOOL) MCOAbstractMessage:(MCOAbstractMessage *)msg shouldShowPart:(MCOAbstractPart *)part
+{
+    if (![[self delegate] respondsToSelector:@selector(MCOMessageView:shouldShowPart:)]) {
+        return YES;
+    }
+    return [[self delegate] MCOMessageView:self shouldShowPart:part];
+}
+
 - (NSDictionary *) MCOAbstractMessage:(MCOAbstractMessage *)msg templateValuesForHeader:(MCOMessageHeader *)header
 {
     if (![[self delegate] respondsToSelector:@selector(MCOMessageView:templateValuesForHeader:)]) {
@@ -226,19 +234,19 @@
     return [[self delegate] MCOMessageView:self templateValuesForPartWithUniqueID:[part uniqueID]];
 }
 
-- (NSString *) MCOAbstractMessage_templateForMainHeader:(MCOAbstractMessage *)msg
+- (NSString *) MCOAbstractMessage:(MCOAbstractMessage *)msg templateForMainHeader:(MCOMessageHeader *)header
 {
-    if (![[self delegate] respondsToSelector:@selector(MCOMessageView_templateForMainHeader:)]) {
+    if (![[self delegate] respondsToSelector:@selector(MCOMessageView:templateForMainHeader:)]) {
         return nil;
     }
-    return [[self delegate] MCOMessageView_templateForMainHeader:self];
+    return [[self delegate] MCOMessageView:self templateForMainHeader:header];
 }
 
-- (NSString *) MCOAbstractMessage_templateForImage:(MCOAbstractMessage *)msg
+- (NSString *) MCOAbstractMessage:(MCOAbstractMessage *)msg templateForImage:(MCOAbstractPart *)part
 {
     NSString * templateString;
-    if ([[self delegate] respondsToSelector:@selector(MCOMessageView_templateForImage:)]) {
-        templateString = [[self delegate] MCOMessageView_templateForImage:self];
+    if ([[self delegate] respondsToSelector:@selector(MCOMessageView:templateForImage:)]) {
+        templateString = [[self delegate] MCOMessageView:self templateForImage:part];
     }
     else {
         templateString = @"<img src=\"{{URL}}\"/>";
@@ -247,12 +255,12 @@
     return templateString;
 }
 
-- (NSString *) MCOAbstractMessage_templateForAttachment:(MCOAbstractMessage *)msg
+- (NSString *) MCOAbstractMessage:(MCOAbstractMessage *)msg templateForAttachment:(MCOAbstractPart *)part
 {
-    if (![[self delegate] respondsToSelector:@selector(MCOMessageView_templateForAttachment:)]) {
+    if (![[self delegate] respondsToSelector:@selector(MCOMessageView:templateForAttachment:)]) {
         return NULL;
     }
-    NSString * templateString = [[self delegate] MCOMessageView_templateForAttachment:self];
+    NSString * templateString = [[self delegate] MCOMessageView:self templateForAttachment:part];
     templateString = [NSString stringWithFormat:@"<div id=\"{{CONTENTID}}\">%@</div>", templateString];
     return templateString;
 }
@@ -265,20 +273,20 @@
     return [[self delegate] MCOMessageView_templateForMessage:self];
 }
 
-- (NSString *) MCOAbstractMessage_templateForEmbeddedMessage:(MCOAbstractMessage *)msg
+- (NSString *) MCOAbstractMessage:(MCOAbstractMessage *)msg templateForEmbeddedMessage:(MCOAbstractMessagePart *)part
 {
-    if (![[self delegate] respondsToSelector:@selector(MCOMessageView_templateForEmbeddedMessage:)]) {
+    if (![[self delegate] respondsToSelector:@selector(MCOMessageView:templateForEmbeddedMessage:)]) {
         return NULL;
     }
-    return [[self delegate] MCOMessageView_templateForEmbeddedMessage:self];
+    return [[self delegate] MCOMessageView:self templateForEmbeddedMessage:part];
 }
 
-- (NSString *) MCOAbstractMessage_templateForEmbeddedMessageHeader:(MCOAbstractMessage *)msg
+- (NSString *) MCOAbstractMessage:(MCOAbstractMessage *)msg templateForEmbeddedMessageHeader:(MCOMessageHeader *)header
 {
-    if (![[self delegate] respondsToSelector:@selector(MCOMessageView_templateForEmbeddedMessageHeader:)]) {
+    if (![[self delegate] respondsToSelector:@selector(MCOMessageView:templateForEmbeddedMessageHeader:)]) {
         return NULL;
     }
-    return [[self delegate] MCOMessageView_templateForEmbeddedMessageHeader:self];
+    return [[self delegate] MCOMessageView:self templateForEmbeddedMessageHeader:header];
 }
 
 - (NSString *) MCOAbstractMessage_templateForAttachmentSeparator:(MCOAbstractMessage *)msg