Saving image thumbnails size to the database and using this size in the HTML

boards/migrations/0017_auto__add_field_post_image_pre_width__add_field_post_image_pre_height.py

@@ -0,0 +1,92 b''
+# -*- coding: utf-8 -*-
+from south.utils import datetime_utils as datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Adding field 'Post.image_pre_width'
+        db.add_column(u'boards_post', 'image_pre_width',
+                      self.gf('django.db.models.fields.IntegerField')(default=0),
+                      keep_default=False)
+
+        # Adding field 'Post.image_pre_height'
+        db.add_column(u'boards_post', 'image_pre_height',
+                      self.gf('django.db.models.fields.IntegerField')(default=0),
+                      keep_default=False)
+
+
+    def backwards(self, orm):
+        # Deleting field 'Post.image_pre_width'
+        db.delete_column(u'boards_post', 'image_pre_width')
+
+        # Deleting field 'Post.image_pre_height'
+        db.delete_column(u'boards_post', 'image_pre_height')
+
+
+    models = {
+        'boards.ban': {
+            'Meta': {'object_name': 'Ban'},
+            'can_read': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'ip': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39'}),
+            'reason': ('django.db.models.fields.CharField', [], {'default': "'Auto'", 'max_length': '200'})
+        },
+        'boards.post': {
+            'Meta': {'object_name': 'Post'},
+            '_text_rendered': ('django.db.models.fields.TextField', [], {}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'image': ('boards.thumbs.ImageWithThumbsField', [], {'max_length': '100', 'blank': 'True'}),
+            'image_height': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'image_pre_height': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'image_pre_width': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'image_width': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'last_edit_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'poster_ip': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39'}),
+            'poster_user_agent': ('django.db.models.fields.TextField', [], {}),
+            'pub_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'referenced_posts': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'rfp+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Post']"}),
+            'text': ('markupfield.fields.MarkupField', [], {'rendered_field': 'True'}),
+            'text_markup_type': ('django.db.models.fields.CharField', [], {'default': "'markdown'", 'max_length': '30'}),
+            'thread': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['boards.Post']", 'null': 'True'}),
+            'thread_new': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['boards.Thread']", 'null': 'True'}),
+            'title': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['boards.User']", 'null': 'True'})
+        },
+        'boards.setting': {
+            'Meta': {'object_name': 'Setting'},
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['boards.User']"}),
+            'value': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        },
+        'boards.tag': {
+            'Meta': {'object_name': 'Tag'},
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'linked': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['boards.Tag']", 'null': 'True', 'blank': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'threads': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'tag+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Thread']"})
+        },
+        'boards.thread': {
+            'Meta': {'object_name': 'Thread'},
+            'bump_time': ('django.db.models.fields.DateTimeField', [], {}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'last_edit_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'replies': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'tre+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Post']"}),
+            'tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['boards.Tag']", 'symmetrical': 'False'})
+        },
+        'boards.user': {
+            'Meta': {'object_name': 'User'},
+            'fav_tags': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['boards.Tag']", 'null': 'True', 'blank': 'True'}),
+            'fav_threads': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Post']"}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'rank': ('django.db.models.fields.IntegerField', [], {}),
+            'registration_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'user_id': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        }
+    }
+
+    complete_apps = ['boards']
  No newline at end of file

boards/models/post.py

@@ -1,374 +1,379 b''
 from datetime import datetime, timedelta
 from datetime import time as dtime
 import os
 from random import random
 import time
 import math
 import re
 from django.core.cache import cache
 
 from django.db import models
 from django.http import Http404
 from django.utils import timezone
 from markupfield.fields import MarkupField
 
 from neboard import settings
 from boards import thumbs
 
 APP_LABEL_BOARDS = 'boards'
 
 CACHE_KEY_PPD = 'ppd'
 
 POSTS_PER_DAY_RANGE = range(7)
 
 BAN_REASON_AUTO = 'Auto'
 
 IMAGE_THUMB_SIZE = (200, 150)
 
 TITLE_MAX_LENGTH = 50
 
 DEFAULT_MARKUP_TYPE = 'markdown'
 
 NO_PARENT = -1
 NO_IP = '0.0.0.0'
 UNKNOWN_UA = ''
 ALL_PAGES = -1
 IMAGES_DIRECTORY = 'images/'
 FILE_EXTENSION_DELIMITER = '.'
 
 SETTING_MODERATE = "moderate"
 
 REGEX_REPLY = re.compile('>>(\d+)')
 
 
 class PostManager(models.Manager):
 
     def create_post(self, title, text, image=None, thread=None,
                     ip=NO_IP, tags=None, user=None):
         """
         Create new post
         """
 
         posting_time = timezone.now()
         if not thread:
             thread = Thread.objects.create(bump_time=posting_time,
                                            last_edit_time=posting_time)
         else:
             thread.bump()
             thread.last_edit_time = posting_time
             thread.save()
 
         post = self.create(title=title,
                            text=text,
                            pub_time=posting_time,
                            thread_new=thread,
                            image=image,
                            poster_ip=ip,
                            poster_user_agent=UNKNOWN_UA, # TODO Get UA at last!
                            last_edit_time=posting_time,
                            user=user)
 
         thread.replies.add(post)
         if tags:
             linked_tags = []
             for tag in tags:
                 tag_linked_tags = tag.get_linked_tags()
                 if len(tag_linked_tags) > 0:
                     linked_tags.extend(tag_linked_tags)
 
             tags.extend(linked_tags)
             map(thread.add_tag, tags)
 
         self._delete_old_threads()
         self.connect_replies(post)
 
         return post
 
     def delete_post(self, post):
         """
         Delete post and update its thread
         """
 
         thread = post.thread_new
         thread.last_edit_time = timezone.now()
         thread.save()
 
         post.delete()
 
     def delete_posts_by_ip(self, ip):
         """
         Delete all posts of the author with same IP
         """
 
         posts = self.filter(poster_ip=ip)
         map(self.delete_post, posts)
 
     # TODO Move this method to thread manager
     def get_threads(self, tag=None, page=ALL_PAGES,
                     order_by='-bump_time'):
         if tag:
             threads = tag.threads
 
             if not threads.exists():
                 raise Http404
         else:
             threads = Thread.objects.all()
 
         threads = threads.order_by(order_by)
 
         if page != ALL_PAGES:
             thread_count = threads.count()
 
             if page < self._get_page_count(thread_count):
                 start_thread = page * settings.THREADS_PER_PAGE
                 end_thread = min(start_thread + settings.THREADS_PER_PAGE,
                                  thread_count)
                 threads = threads[start_thread:end_thread]
 
         return threads
 
     # TODO Move this method to thread manager
     def get_thread_page_count(self, tag=None):
         if tag:
             threads = Thread.objects.filter(tags=tag)
         else:
             threads = Thread.objects.all()
 
         return self._get_page_count(threads.count())
 
     # TODO Move this method to thread manager
     def _delete_old_threads(self):
         """
         Preserves maximum thread count. If there are too many threads,
         delete the old ones.
         """
 
         # TODO Move old threads to the archive instead of deleting them.
         # Maybe make some 'old' field in the model to indicate the thread
         # must not be shown and be able for replying.
 
         threads = Thread.objects.all()
         thread_count = threads.count()
 
         if thread_count > settings.MAX_THREAD_COUNT:
             num_threads_to_delete = thread_count - settings.MAX_THREAD_COUNT
             old_threads = threads[thread_count - num_threads_to_delete:]
 
             map(Thread.delete_with_posts, old_threads)
 
     def connect_replies(self, post):
         """
         Connect replies to a post to show them as a reflink map
         """
 
         for reply_number in re.finditer(REGEX_REPLY, post.text.raw):
             post_id = reply_number.group(1)
             ref_post = self.filter(id=post_id)
             if ref_post.count() > 0:
                 referenced_post = ref_post[0]
                 referenced_post.referenced_posts.add(post)
                 referenced_post.last_edit_time = post.pub_time
                 referenced_post.save()
 
     def _get_page_count(self, thread_count):
         """
         Get number of pages that will be needed for all threads
         """
 
         return int(math.ceil(thread_count / float(settings.THREADS_PER_PAGE)))
 
     def get_posts_per_day(self):
         """
         Get average count of posts per day for the last 7 days
         """
 
         today = datetime.now().date()
         ppd = cache.get(CACHE_KEY_PPD + str(today))
         if ppd:
             return ppd
 
         posts_per_days = []
         for i in POSTS_PER_DAY_RANGE:
             day_end = today - timedelta(i + 1)
             day_start = today - timedelta(i + 2)
 
             day_time_start = timezone.make_aware(datetime.combine(day_start,
                 dtime()), timezone.get_current_timezone())
             day_time_end = timezone.make_aware(datetime.combine(day_end,
                 dtime()), timezone.get_current_timezone())
 
             posts_per_days.append(float(self.filter(
                 pub_time__lte=day_time_end,
                 pub_time__gte=day_time_start).count()))
 
         ppd = (sum(posts_per_day for posts_per_day in posts_per_days) /
                len(posts_per_days))
         cache.set(CACHE_KEY_PPD, ppd)
         return ppd
 
 
 class Post(models.Model):
     """A post is a message."""
 
     objects = PostManager()
 
     class Meta:
         app_label = APP_LABEL_BOARDS
 
     # TODO Save original file name to some field
     def _update_image_filename(self, filename):
         """Get unique image filename"""
 
         path = IMAGES_DIRECTORY
         new_name = str(int(time.mktime(time.gmtime())))
         new_name += str(int(random() * 1000))
         new_name += FILE_EXTENSION_DELIMITER
         new_name += filename.split(FILE_EXTENSION_DELIMITER)[-1:][0]
 
         return os.path.join(path, new_name)
 
     title = models.CharField(max_length=TITLE_MAX_LENGTH)
     pub_time = models.DateTimeField()
     text = MarkupField(default_markup_type=DEFAULT_MARKUP_TYPE,
                        escape_html=False)
 
     image_width = models.IntegerField(default=0)
     image_height = models.IntegerField(default=0)
 
+    image_pre_width = models.IntegerField(default=0)
+    image_pre_height = models.IntegerField(default=0)
+
     image = thumbs.ImageWithThumbsField(upload_to=_update_image_filename,
                                         blank=True, sizes=(IMAGE_THUMB_SIZE,),
                                         width_field='image_width',
-                                        height_field='image_height')
+                                        height_field='image_height',
+                                        preview_width_field='image_pre_width',
+                                        preview_height_field='image_pre_height')
 
     poster_ip = models.GenericIPAddressField()
     poster_user_agent = models.TextField()
 
     thread = models.ForeignKey('Post', null=True, default=None)
     thread_new = models.ForeignKey('Thread', null=True, default=None)
     last_edit_time = models.DateTimeField()
     user = models.ForeignKey('User', null=True, default=None)
 
     referenced_posts = models.ManyToManyField('Post', symmetrical=False,
                                               null=True,
                                               blank=True, related_name='rfp+')
 
     def __unicode__(self):
         return '#' + str(self.id) + ' ' + self.title + ' (' + \
                self.text.raw[:50] + ')'
 
     def get_title(self):
         title = self.title
         if len(title) == 0:
             title = self.text.raw[:20]
 
         return title
 
     def get_sorted_referenced_posts(self):
         return self.referenced_posts.order_by('id')
 
     def is_referenced(self):
         return self.referenced_posts.all().exists()
 
     def is_opening(self):
         return self.thread_new.get_replies()[0] == self
 
 
 class Thread(models.Model):
 
     class Meta:
         app_label = APP_LABEL_BOARDS
 
     tags = models.ManyToManyField('Tag')
     bump_time = models.DateTimeField()
     last_edit_time = models.DateTimeField()
     replies = models.ManyToManyField('Post', symmetrical=False, null=True,
                                      blank=True, related_name='tre+')
 
     def get_tags(self):
         """
         Get a sorted tag list
         """
 
         return self.tags.order_by('name')
 
     def bump(self):
         """
         Bump (move to up) thread
         """
 
         if self.can_bump():
             self.bump_time = timezone.now()
 
     def get_reply_count(self):
         return self.replies.count()
 
     def get_images_count(self):
         return self.replies.filter(image_width__gt=0).count()
 
     def can_bump(self):
         """
         Check if the thread can be bumped by replying
         """
 
         post_count = self.get_reply_count()
 
         return post_count < settings.MAX_POSTS_PER_THREAD
 
     def delete_with_posts(self):
         """
         Completely delete thread and all its posts
         """
 
         if self.replies.count() > 0:
             map(Post.objects.delete_post, self.replies.all())
 
         self.delete()
 
     def get_last_replies(self):
         """
         Get last replies, not including opening post
         """
 
         if settings.LAST_REPLIES_COUNT > 0:
             reply_count = self.get_reply_count()
 
             if reply_count > 0:
                 reply_count_to_show = min(settings.LAST_REPLIES_COUNT,
                                           reply_count - 1)
                 last_replies = self.replies.all().order_by('pub_time')[
                                reply_count - reply_count_to_show:]
 
                 return last_replies
 
     def get_replies(self):
         """
         Get sorted thread posts
         """
 
         return self.replies.all().order_by('pub_time')
 
     def add_tag(self, tag):
         """
         Connect thread to a tag and tag to a thread
         """
 
         self.tags.add(tag)
         tag.threads.add(self)
 
     def get_opening_post(self):
         """
         Get first post of the thread
         """
 
         return self.get_replies()[0]
 
     def __unicode__(self):
         return str(self.get_replies()[0].id)
 
     def get_pub_time(self):
         """
         Thread does not have its own pub time, so we need to get it from
         the opening post
         """
 
         return self.get_opening_post().pub_time

boards/static/css/md/base_page.css

@@ -1,358 +1,356 b''
 html {
     background: #555;
     color: #ffffff;
 }
 
 #admin_panel {
     background: #FF0000;
     color: #00FF00
 }
 
 .input_field {
 
 }
 
 .input_field_name {
 
 }
 
 .input_field_error {
     color: #FF0000;
 }
 
 .title {
     font-weight: bold;
     color: #ffcc00;
     font-size: 2ex;
 }
 
 .link, a {
     color: #afdcec;
 }
 
 .block {
     display: inline-block;
     vertical-align: top;
 }
 
 .tag {
     color: #b4cfec;
 }
 
 .post_id {
     color: #fff380;
 }
 
 .post, .dead_post, #posts-table {
     background: #333;
     margin: 5px;
     padding: 10px;
     border: solid 1px #888;
     clear: left;
     word-wrap: break-word;
 }
 
 .metadata {
     padding-top: 5px;
     margin-top: 10px;
     border-top: solid 1px #666;
     font-size: 0.9em;
     color: #ddd;
 }
 
 .navigation_panel, .tag_info {
     background: #444;
     margin: 5px;
     padding: 10px;
     border: solid 1px #888;
     color: #eee;
 }
 
 .navigation_panel .link {
     border-right: 1px solid #fff;
     font-weight: bold;
     margin-right: 1ex;
     padding-right: 1ex;
 }
 .navigation_panel .link:last-child {
     border-left: 1px solid #fff;
     border-right: none;
     float: right;
     margin-left: 1ex;
     margin-right: 0;
     padding-left: 1ex;
     padding-right: 0;
 }
 
 .navigation_panel::after, .post::after {
     clear: both;
     content: ".";
     display: block;
     height: 0;
     line-height: 0;
     visibility: hidden;
 }
 
 p {
     margin-top: .5em;
     margin-bottom: .5em;
 }
 
 .post-form-w {
     display: table;
     background: #333344;
     border: solid 1px #888;
     color: #fff;
     padding: 10px;
     margin: 5px;
 }
 
 .form-row {
     display: table-row;
 }
 
 .form-label, .form-input, .form-errors {
     display: table-cell;
 }
 
 .form-label {
     padding: .25em 1ex .25em 0;
     vertical-align: top;
 }
 
 .form-input {
     padding: .25em 0;
 }
 
 .form-errors {
     font-weight: bolder;
     vertical-align: middle;
 }
 
 .post-form input, .post-form textarea {
     background: #333;
     color: #fff;
     border: solid 1px;
     padding: 0;
     width: 100%;
     font: medium sans;
 }
 
 .form-submit {
     display: table;
     margin-bottom: 1ex;
 }
 
 .form-title {
     font-weight: bold;
     font-size: 2.5ex;
     text-decoration: underline;
 }
 
 input[type="submit"] {
     background: #222;
     border: solid 2px #fff;
     color: #fff;
     padding: 0.5ex;
 }
 
 input[type="submit"]:hover {
     background: #060;
 }
 
 blockquote {
     border-left: solid 2px;
     padding-left: 5px;
     color: #B1FB17;
     margin: 0;
 }
 
 .post > .image {
     float: left;
     margin: 0 1ex .5ex 0;
     min-width: 1px;
     text-align: center;
     display: table-row;
-
-    height: 150px;
 }
 
 .post > .metadata {
     clear: left;
 }
 
 .get {
     font-weight: bold;
     color: #d55;
 }
 
 * {
     text-decoration: none;
 }
 
 .dead_post {
     background-color: #442222;
 }
 
 .mark_btn {
     border: 1px solid;
     min-width: 2ex;
     padding: 2px 2ex;
 }
 
 .mark_btn:hover {
     background: #555;
 }
 
 .quote {
     color: #92cf38;
     font-style: italic;
 }
 
 .spoiler {
     background: white;
     color: white;
 }
 
 .spoiler:hover {
     color: black;
 }
 
 .comment {
     color: #eb2;
     font-style: italic;
 }
 
 a:hover {
     text-decoration: underline;
 }
 
 .last-replies {
     margin-left: 3ex;
 }
 
 .thread {
     margin-bottom: 3ex;
 }
 
 .post:target {
     border: solid 2px white;
 }
 
 pre{
     white-space:pre-wrap
 }
 
 li {
     list-style-position: inside;
 }
 
 .fancybox-skin {
     position: relative;
     background-color: #fff;
     color: #ddd;
     text-shadow: none;
 }
 
 .fancybox-image {
     border: 1px solid black;
 }
 
 .image-mode-tab {
     background: #444;
     color: #eee;
     display: table;
     margin: 5px;
     padding: 5px;
     border: 1px solid #888;
 }
 
 .image-mode-tab > label {
     margin: 0 1ex;
 }
 
 .image-mode-tab > label > input {
     margin-right: .5ex;
 }
 
 #posts-table {
     margin: 5px;
 }
 
 .tag_info {
     display: table;
 }
 
 .tag_info > h2 {
     margin: 0;
 }
 
 .post-info {
     color: #ddd;
 }
 
 .moderator_info {
     color: #e99d41;
     border: dashed 1px;
     padding: 3px;
 }
 
 .refmap {
     font-size: 0.9em;
     color: #ccc;
     margin-top: 1em;
 }
 
 .fav {
     color: yellow;
 }
 
 .not_fav {
     color: #ccc;
 }
 
 .role {
     text-decoration: underline;
 }
 
 .form-email {
     display: none;
 }
 
 .footer {
     margin: 5px;
 }
 
 .bar-value {
     background: rgba(50, 55, 164, 0.45);
     font-size: 0.9em;
     height: 1.5em;
 }
 
 .bar-bg {
     position: relative;
     border: solid 1px #888;
     margin: 5px;
     overflow: hidden;
 }
 
 .bar-text {
     padding: 2px;
     position: absolute;
     left: 0;
     top: 0;
 }
 
 .page_link {
     display: table;
     background: #444;
     margin: 5px;
     border: solid 1px #888;
     padding: 5px;
     font-weight: bolder;
     color: #eee;
 }
 
 .skipped_replies {
     margin: 5px;
 }

boards/static/css/pg/base_page.css

@@ -1,344 +1,342 b''
 html {
     background: rgb(238, 238, 238);
     color: rgb(51, 51, 51);
 }
 
 #admin_panel {
     background: #FF0000;
     color: #00FF00
 }
 
 .input_field {
 
 }
 
 .input_field_name {
 
 }
 
 .input_field_error {
     color: #FF0000;
 }
 
 
 .title {
     font-weight: bold;
     color: #333;
     font-size: 2ex;
 }
 
 .link, a {
     color: rgb(255, 102, 0);
 }
 
 .block {
     display: inline-block;
     vertical-align: top;
 }
 
 .tag {
     color: #222;
 }
 
 .post_id:hover {
     color: #11f;
 }
 
 .post_id {
     color: #444;
 }
 
 .post, .dead_post, #posts-table {
     margin: 5px;
     padding: 10px;
     background: rgb(221, 221, 221);
     border: 1px solid rgb(204, 204, 204);
     border-radius: 5px 5px 5px 5px;
     clear: left;
     word-wrap: break-word;
     display: table;
 }
 
 .metadata {
     padding: 5px;
     margin-top: 10px;
     border: solid 1px #666;
     font-size: 0.9em;
     display: table;
 }
 
 .navigation_panel, .tag_info, .page_link {
     margin: 5px;
     padding: 10px;
     border: 1px solid rgb(204, 204, 204);
     border-radius: 5px 5px 5px 5px;
 }
 
 .navigation_panel .link {
     border-right: 1px solid #000;
     font-weight: bold;
     margin-right: 1ex;
     padding-right: 1ex;
 }
 .navigation_panel .link:last-child {
     border-left: 1px solid #000;
     border-right: none;
     float: right;
     margin-left: 1ex;
     margin-right: 0;
     padding-left: 1ex;
     padding-right: 0;
 }
 
 .navigation_panel::after, .post::after {
     clear: both;
     content: ".";
     display: block;
     height: 0;
     line-height: 0;
     visibility: hidden;
 }
 
 p {
     margin-top: .5em;
     margin-bottom: .5em;
 }
 
 .post-form-w {
     display: table;
     padding: 10px;
     margin: 5px
 }
 
 .form-row {
     display: table-row;
 }
 
 .form-label, .form-input, .form-errors {
     display: table-cell;
 }
 
 .form-label {
     padding: .25em 1ex .25em 0;
     vertical-align: top;
 }
 
 .form-input {
     padding: .25em 0;
 }
 
 .form-errors {
     padding-left: 1ex;
     font-weight: bold;
     vertical-align: middle;
 }
 
 .post-form input, .post-form textarea {
     background: #fff;
     color: #000;
     border: solid 1px;
     padding: 0;
     width: 100%;
     font: medium sans;
 }
 
 .form-submit {
     border-bottom: 2px solid #ddd;
     margin-bottom: .5em;
     padding-bottom: .5em;
 }
 
 .form-title {
     font-weight: bold;
 }
 
 input[type="submit"] {
     background: #fff;
     border: solid 1px #000;
     color: #000;
 }
 
 blockquote {
     border-left: solid 2px;
     padding-left: 5px;
     color: #B1FB17;
     margin: 0;
 }
 
 .post > .image {
     float: left;
     margin: 0 1ex .5ex 0;
     min-width: 1px;
     text-align: center;
     display: table-row;
-
-    height: 150px;
 }
 
 .post > .metadata {
     clear: left;
 }
 
 .get {
     font-weight: bold;
     color: #d55;
 }
 
 * {
     text-decoration: none;
 }
 
 .dead_post {
     background-color: #ecc;
 }
 
 .quote {
     color: #080;
     font-style: italic;
 }
 
 .spoiler {
     background: white;
     color: white;
 }
 
 .spoiler:hover {
     color: black;
 }
 
 .comment {
     color: #8B6914;
     font-style: italic;
 }
 
 a:hover {
     text-decoration: underline;
 }
 
 .last-replies {
     margin-left: 3ex;
 }
 
 .thread {
     margin-bottom: 3ex;
 }
 
 .post:target {
     border: solid 2px black;
 }
 
 pre{
     white-space:pre-wrap
 }
 
 li {
     list-style-position: inside;
 }
 
 .fancybox-skin {
     position: relative;
     background-color: #fff;
     color: #ddd;
     text-shadow: none;
 }
 
 .fancybox-image {
     border: 1px solid black;
 }
 
 .image-mode-tab {
     display: table;
     margin: 5px;
     padding: 5px;
     background: rgb(221, 221, 221);
     border: 1px solid rgb(204, 204, 204);
     border-radius: 5px 5px 5px 5px;
 }
 
 .image-mode-tab > label {
     margin: 0 1ex;
 }
 
 .image-mode-tab > label > input {
     margin-right: .5ex;
 }
 
 #posts-table {
     margin: 5px;
 }
 
 .tag_info, .page_link {
     display: table;
 }
 
 .tag_info > h2 {
     margin: 0;
 }
 
 .moderator_info {
     color: #e99d41;
     border: dashed 1px;
     padding: 3px;
 }
 
 .refmap {
     font-size: 0.9em;
     color: #444;
     margin-top: 1em;
 }
 
 input[type="submit"]:hover {
         background: #ccc;
 }
 
 
 .fav {
     color: rgb(255, 102, 0);
 }
 
 .not_fav {
     color: #555;
 }
 
 .role {
     text-decoration: underline;
 }
 
 .form-email {
     display: none;
 }
 
 .mark_btn {
     padding: 2px 2ex;
     border: 1px solid;
 }
 
 .mark_btn:hover {
     background: #ccc;
 }
 
 .bar-value {
     background: rgba(251, 199, 16, 0.61);
     padding: 2px;
     font-size: 0.9em;
     height: 1.5em;
 }
 
 .bar-bg {
     position: relative;
     border: 1px solid rgb(204, 204, 204);
     border-radius: 5px 5px 5px 5px;
     margin: 5px;
     overflow: hidden;
 }
 
 .bar-text {
     padding: 2px;
     position: absolute;
     left: 0;
     top: 0;
 }
 
 .skipped_replies {
     margin: 5px;
 }

boards/templates/boards/posting_general.html

@@ -1,244 +1,248 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load cache %}
 {% load board %}
 {% load static %}
 
 {% block head %}
     {% if tag %}
         <title>Neboard - {{ tag.name }}</title>
     {% else %}
         <title>Neboard</title>
     {% endif %}
 
     {% if prev_page %}
         <link rel="next" href="
             {% if tag %}
                 {% url "tag" tag_name=tag page=prev_page %}
             {% else %}
                 {% url "index" page=prev_page %}
             {% endif %}
         " />
     {% endif %}
     {% if next_page %}
         <link rel="next" href="
             {% if tag %}
                 {% url "tag" tag_name=tag page=next_page %}
             {% else %}
                 {% url "index" page=next_page %}
             {% endif %}
         " />
     {% endif %}
 
 {% endblock %}
 
 {% block content %}
 
     {% get_current_language as LANGUAGE_CODE %}
 
 {% if tag %}
     <div class="tag_info">
         <h2>
             {% if tag in user.fav_tags.all %}
                 <a href="{% url 'tag_unsubscribe' tag.name %}?next={{ request.path }}"
                    class="fav">★</a>
             {% else %}
                 <a href="{% url 'tag_subscribe' tag.name %}?next={{ request.path }}"
                    class="not_fav">★</a>
             {% endif %}
             #{{ tag.name }}
         </h2>
     </div>
 {% endif %}
 
     {% if threads %}
         {% if prev_page %}
             <div class="page_link">
                 <a href="
             {% if tag %}
                 {% url "tag" tag_name=tag page=prev_page %}
             {% else %}
                 {% url "index" page=prev_page %}
             {% endif %}
                 ">{% trans "Previous page" %}</a>
             </div>
         {% endif %}
 
         {% for thread in threads %}
             {% cache 600 thread_short thread.id thread.thread.last_edit_time moderator LANGUAGE_CODE %}
             <div class="thread">
             {% if thread.bumpable %}
 		        <div class="post" id="{{ thread.op.id }}">
             {% else %}
 		        <div class="post dead_post" id="{{ thread.op.id }}">
             {% endif %}
             {% if thread.op.image %}
                 <div class="image">
                     <a class="thumb"
                        href="{{ thread.op.image.url }}"><img
                             src="{{ thread.op.image.url_200x150 }}"
                             alt="{{ thread.op.id }}"
+                            width="{{ thread.op.image_pre_width }}"
+                            height="{{ thread.op.image_pre_height }}"
                             data-width="{{ thread.op.image_width }}"
                             data-height="{{ thread.op.image_height }}"/>
                     </a>
                 </div>
             {% endif %}
             <div class="message">
                 <div class="post-info">
                     <span class="title">{{ thread.op.title }}</span>
                      <a class="post_id" href="{% url 'thread' thread.op.id %}"
                     >({{ thread.op.id }})</a>
                     [{{ thread.op.pub_time }}]
                     [<a class="link" href="
                     {% url 'thread' thread.op.id %}#form"
                         >{% trans "Reply" %}</a>]
 
                     {% if moderator %}
                         <span class="moderator_info">
                             [<a href="
                             {% url 'delete' post_id=thread.op.id %}?next={{ request.path }}"
                                 >{% trans 'Delete' %}</a>]
                             ({{ thread.thread.poster_ip }})
                             [<a href="
                             {% url 'ban' post_id=thread.op.id %}?next={{ request.path }}"
                                 >{% trans 'Ban IP' %}</a>]
                         </span>
                     {% endif %}
                 </div>
                 {% autoescape off %}
                     {{ thread.op.text.rendered|truncatewords_html:50 }}
                 {% endautoescape %}
 		{% if thread.op.is_referenced %}
 		    <div class="refmap">
 			{% trans "Replies" %}:
 			{% for ref_post in thread.op.get_sorted_referenced_posts %}
 			<a href="{% post_url ref_post.id %}">&gt;&gt;{{ ref_post.id }}</a
                     >{% if not forloop.last %},{% endif %}
 			{% endfor %}
 		    </div>
 		{% endif %}
             </div>
             <div class="metadata">
                 {{ thread.thread.get_images_count }} {% trans 'images' %}.
                 {% if thread.thread.tags %}
                     <span class="tags">
                         {% for tag in thread.thread.get_tags %}
                             <a class="tag" href="
                                     {% url 'tag' tag_name=tag.name %}">
                                 #{{ tag.name }}</a
                                     >{% if not forloop.last %},{% endif %}
                         {% endfor %}
                     </span>
                 {% endif %}
             </div>
             </div>
             {% if thread.last_replies.exists %}
                 {% if thread.skipped_replies %}
                     <div class="skipped_replies">
                         <a href="{% url 'thread' thread.op.id %}">
                         {% blocktrans with count=thread.skipped_replies %}Skipped {{ count }} replies. Open thread to see all replies.{% endblocktrans %}
                         </a>
                     </div>
                 {% endif %}
                 <div class="last-replies">
                     {% for post in thread.last_replies %}
                         {% if thread.bumpable %}
                             <div class="post" id="{{ post.id }}">
                         {% else %}
                             <div class="post dead_post" id="{{ post.id }}">
                         {% endif %}
                             {% if post.image %}
                                 <div class="image">
                                     <a class="thumb"
                                        href="{{ post.image.url }}"><img
                                             src=" {{ post.image.url_200x150 }}"
                                             alt="{{ post.id }}"
+                                            width="{{ post.image_pre_width }}"
+                                            height="{{ post.image_pre_height }}"
                                             data-width="{{ post.image_width }}"
                                             data-height="{{ post.image_height }}"/>
                                     </a>
                                 </div>
                             {% endif %}
                             <div class="message">
                                 <div class="post-info">
                                     <span class="title">{{ post.title }}</span>
                                     <a class="post_id" href="
                                 {% url 'thread' thread.op.id %}#{{ post.id }}">
                                         ({{ post.id }})</a>
                                     [{{ post.pub_time }}]
                                 </div>
                                 {% autoescape off %}
                                     {{ post.text.rendered|truncatewords_html:50 }}
                                 {% endautoescape %}
                         </div>
                     {% if post.is_referenced %}
                         <div class="refmap">
                             {% trans "Replies" %}:
                             {% for ref_post in post.get_sorted_referenced_posts %}
                                 <a href="{% post_url ref_post.id %}">&gt;&gt;{{ ref_post.id }}</a
                                         >{% if not forloop.last %},{% endif %}
                             {% endfor %}
                         </div>
                     {% endif %}
                         </div>
                     {% endfor %}
                 </div>
             {% endif %}
         </div>
         {% endcache %}
         {% endfor %}
 
         {% if next_page %}
             <div class="page_link">
                 <a href="
             {% if tag %}
                 {% url "tag" tag_name=tag page=next_page %}
             {% else %}
                 {% url "index" page=next_page %}
             {% endif %}
                 ">{% trans "Next page" %}</a>
             </div>
         {% endif %}
     {% else %}
         <div class="post">
             {% trans 'No threads exist. Create the first one!' %}</div>
     {% endif %}
 
     <div class="post-form-w">
         <script src="{% static 'js/panel.js' %}"></script>
         <div class="post-form">
             <div class="form-title">{% trans "Create new thread" %}</div>
             <form enctype="multipart/form-data" method="post">{% csrf_token %}
                 {{ form.as_div }}
                 <div class="form-submit">
                     <input type="submit" value="{% trans "Post" %}"/>
                 </div>
             </form>
             <div>
                 {% trans 'Tags must be delimited by spaces. Text or image is required.' %}
             </div>
             <div><a href="{% url "staticpage" name="help" %}">
                 {% trans 'Text syntax' %}</a></div>
         </div>
     </div>
 
 {% endblock %}
 
 {% block metapanel %}
 
     <span class="metapanel">
-        <b><a href="{% url "authors" %}">Neboard</a> 1.4.1</b>
+        <b><a href="{% url "authors" %}">Neboard</a> 1.5</b>
         {% trans "Pages:" %}
         {% for page in pages %}
             [<a href="
             {% if tag %}
                 {% url "tag" tag_name=tag page=page %}
             {% else %}
                 {% url "index" page=page %}
             {% endif %}
             ">{{ page }}</a>]
         {% endfor %}
         [<a href="rss/">RSS</a>]
     </span>
 
 {% endblock %}

boards/templates/boards/thread.html

@@ -1,128 +1,130 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load cache %}
 {% load static from staticfiles %}
 {% load board %}
 
 {% block head %}
     <title>Neboard - {{ thread.get_replies.0.get_title }}</title>
 {% endblock %}
 
 {% block content %}
     {% spaceless %}
     {% get_current_language as LANGUAGE_CODE %}
 
     <script src="{% static 'js/thread_update.js' %}"></script>
     <script src="{% static 'js/thread.js' %}"></script>
 
     {% cache 600 thread_view thread.id thread.last_edit_time moderator LANGUAGE_CODE %}
         {% if bumpable %}
             <div class="bar-bg">
                 <div class="bar-value" style="width:{{ bumplimit_progress }}%" id="bumplimit_progress">
                 </div>
                 <div class="bar-text">
                     <span id="left_to_limit">{{ posts_left }}</span> {% trans 'posts to bumplimit' %}
                 </div>
             </div>
         {% endif %}
     <div class="thread">
     {% for post in thread.get_replies %}
         {% if bumpable %}
             <div class="post" id="{{ post.id }}">
         {% else %}
             <div class="post dead_post" id="{{ post.id }}">
         {% endif %}
         {% if post.image %}
             <div class="image">
                 <a
                         class="thumb"
                         href="{{ post.image.url }}"><img
                         src="{{ post.image.url_200x150 }}"
                         alt="{{ post.id }}"
+                        width="{{ post.image_pre_width }}"
+                        height="{{ post.image_pre_height }}"
                         data-width="{{ post.image_width }}"
                         data-height="{{ post.image_height }}"/>
                 </a>
             </div>
         {% endif %}
         <div class="message">
             <div class="post-info">
                 <span class="title">{{ post.title }}</span>
                 <a class="post_id" href="#{{ post.id }}">
                     ({{ post.id }})</a>
                 [{{ post.pub_time }}]
             [<a href="#" onclick="javascript:addQuickReply('{{ post.id }}')
                 ; return false;">&gt;&gt;</a>]
 
                 {% if moderator %}
                     <span class="moderator_info">
                         [<a href="{% url 'delete' post_id=post.id %}"
                             >{% trans 'Delete' %}</a>]
                         ({{ post.poster_ip }})
                         [<a href="{% url 'ban' post_id=post.id %}?next={{ request.path }}"
                             >{% trans 'Ban IP' %}</a>]
                     </span>
                 {% endif %}
             </div>
             {% autoescape off %}
             {{ post.text.rendered }}
             {% endautoescape %}
     {% if post.is_referenced %}
         <div class="refmap">
         {% trans "Replies" %}:
         {% for ref_post in post.get_sorted_referenced_posts %}
         <a href="{% post_url ref_post.id %}">&gt;&gt;{{ ref_post.id }}</a
                 >{% if not forloop.last %},{% endif %}
         {% endfor %}
         </div>
     {% endif %}
         </div>
         {% if forloop.first %}
             <div class="metadata">
                 <span class="tags">
                     {% for tag in thread.get_tags %}
                         <a class="tag" href="{% url 'tag' tag.name %}">
                             #{{ tag.name }}</a
                                 >{% if not forloop.last %},{% endif %}
                     {% endfor %}
                 </span>
             </div>
         {% endif %}
         </div>
     {% endfor %}
     </div>
     {% endcache %}
 
     <div class="post-form-w">
         <script src="{% static 'js/panel.js' %}"></script>
         <div class="form-title">{% trans "Reply to thread" %} #{{ thread.get_opening_post.id }}</div>
         <div class="post-form">
             <form id="form" enctype="multipart/form-data" method="post"
                     >{% csrf_token %}
                 {{ form.as_div }}
                 <div class="form-submit">
                     <input type="submit" value="{% trans "Post" %}"/>
                 </div>
             </form>
             <div><a href="{% url "staticpage" name="help" %}">
                 {% trans 'Text syntax' %}</a></div>
         </div>
     </div>
 
     {% endspaceless %}
 {% endblock %}
 
 {% block metapanel %}
 
     {% get_current_language as LANGUAGE_CODE %}
 
     <span class="metapanel" data-last-update="{{ last_update }}">
         {% cache 600 thread_meta thread.last_edit_time moderator LANGUAGE_CODE %}
             <span id="reply-count">{{ thread.get_reply_count }}</span> {% trans 'replies' %},
             <span id="image-count">{{ thread.get_images_count }}</span> {% trans 'images' %}.
             {% trans 'Last update: ' %}{{ thread.last_edit_time }}
             [<a href="rss/">RSS</a>]
         {% endcache %}
     </span>
 
 {% endblock %}

boards/thumbs.py

@@ -1,173 +1,216 b''
 # -*- encoding: utf-8 -*-
 """
 django-thumbs by Antonio Melé
 http://django.es
 """
+from django.core.files.images import ImageFile
 from django.db.models import ImageField
 from django.db.models.fields.files import ImageFieldFile
 from PIL import Image
 from django.core.files.base import ContentFile
 import cStringIO
 
 
 def generate_thumb(img, thumb_size, format):
     """
     Generates a thumbnail image and returns a ContentFile object with the thumbnail
-    
+
     Parameters:
     ===========
     img         File object
-    
+
     thumb_size  desired thumbnail size, ie: (200,120)
-    
+
     format      format of the original image ('jpeg','gif','png',...)
                 (this format will be used for the generated thumbnail, too)
     """
 
     img.seek(0) # see http://code.djangoproject.com/ticket/8222 for details
     image = Image.open(img)
 
     # get size
     thumb_w, thumb_h = thumb_size
     # If you want to generate a square thumbnail
     if thumb_w == thumb_h:
         # quad
         xsize, ysize = image.size
         # get minimum size
         minsize = min(xsize, ysize)
         # largest square possible in the image
         xnewsize = (xsize - minsize) / 2
         ynewsize = (ysize - minsize) / 2
         # crop it
         image2 = image.crop(
             (xnewsize, ynewsize, xsize - xnewsize, ysize - ynewsize))
-        # load is necessary after crop                
+        # load is necessary after crop
         image2.load()
         # thumbnail of the cropped image (with ANTIALIAS to make it look better)
         image2.thumbnail(thumb_size, Image.ANTIALIAS)
     else:
         # not quad
         image2 = image
         image2.thumbnail(thumb_size, Image.ANTIALIAS)
 
     io = cStringIO.StringIO()
     # PNG and GIF are the same, JPG is JPEG
     if format.upper() == 'JPG':
         format = 'JPEG'
 
     image2.save(io, format)
     return ContentFile(io.getvalue())
 
 
 class ImageWithThumbsFieldFile(ImageFieldFile):
     """
     See ImageWithThumbsField for usage example
     """
 
     def __init__(self, *args, **kwargs):
         super(ImageWithThumbsFieldFile, self).__init__(*args, **kwargs)
         self.sizes = self.field.sizes
 
         if self.sizes:
             def get_size(self, size):
                 if not self:
                     return ''
                 else:
                     split = self.url.rsplit('.', 1)
                     thumb_url = '%s.%sx%s.%s' % (split[0], w, h, split[1])
                     return thumb_url
 
             for size in self.sizes:
                 (w, h) = size
                 setattr(self, 'url_%sx%s' % (w, h), get_size(self, size))
 
     def save(self, name, content, save=True):
         super(ImageWithThumbsFieldFile, self).save(name, content, save)
 
         if self.sizes:
             for size in self.sizes:
                 (w, h) = size
                 split = self.name.rsplit('.', 1)
                 thumb_name = '%s.%sx%s.%s' % (split[0], w, h, split[1])
 
                 # you can use another thumbnailing function if you like
                 thumb_content = generate_thumb(content, size, split[1])
 
                 thumb_name_ = self.storage.save(thumb_name, thumb_content)
 
                 if not thumb_name == thumb_name_:
                     raise ValueError(
                         'There is already a file named %s' % thumb_name)
 
     def delete(self, save=True):
         name = self.name
         super(ImageWithThumbsFieldFile, self).delete(save)
         if self.sizes:
             for size in self.sizes:
                 (w, h) = size
                 split = name.rsplit('.', 1)
                 thumb_name = '%s.%sx%s.%s' % (split[0], w, h, split[1])
                 try:
                     self.storage.delete(thumb_name)
                 except:
                     pass
 
 
 class ImageWithThumbsField(ImageField):
     attr_class = ImageWithThumbsFieldFile
     """
     Usage example:
     ==============
     photo = ImageWithThumbsField(upload_to='images', sizes=((125,125),(300,200),)
     
     To retrieve image URL, exactly the same way as with ImageField:
         my_object.photo.url
     To retrieve thumbnails URL's just add the size to it:
         my_object.photo.url_125x125
         my_object.photo.url_300x200
     
     Note: The 'sizes' attribute is not required. If you don't provide it, 
     ImageWithThumbsField will act as a normal ImageField
         
     How it works:
     =============
     For each size in the 'sizes' atribute of the field it generates a 
     thumbnail with that size and stores it following this format:
     
     available_filename.[width]x[height].extension
 
     Where 'available_filename' is the available filename returned by the storage
     backend for saving the original file.
     
     Following the usage example above: For storing a file called "photo.jpg" it saves:
     photo.jpg          (original file)
     photo.125x125.jpg  (first thumbnail)
     photo.300x200.jpg  (second thumbnail)
     
     With the default storage backend if photo.jpg already exists it will use these filenames:
     photo_.jpg
     photo_.125x125.jpg
     photo_.300x200.jpg
     
     Note: django-thumbs assumes that if filename "any_filename.jpg" is available 
     filenames with this format "any_filename.[widht]x[height].jpg" will be available, too.
     
     To do:
     ======
     Add method to regenerate thubmnails
 
     
     """
 
     def __init__(self, verbose_name=None, name=None, width_field=None,
-                 height_field=None, sizes=None, **kwargs):
+                 height_field=None, sizes=None,
+                 preview_width_field=None, preview_height_field=None,
+                 **kwargs):
         self.verbose_name = verbose_name
         self.name = name
         self.width_field = width_field
         self.height_field = height_field
         self.sizes = sizes
         super(ImageField, self).__init__(**kwargs)
 
+        if sizes is not None and len(sizes) == 1:
+            self.preview_width_field = preview_width_field
+            self.preview_height_field = preview_height_field
+
+    def update_dimension_fields(self, instance, force=False, *args, **kwargs):
+        """
+        Update original image dimension fields and thumb dimension fields
+        (only if 1 thumb size is defined)
+        """
+
+        super(ImageWithThumbsField, self).update_dimension_fields(instance,
+                                                                   force, *args,
+                                                                   **kwargs)
+        thumb_width_field = self.preview_width_field
+        thumb_height_field = self.preview_height_field
+
+        if thumb_width_field is None or thumb_height_field is None \
+                or len(self.sizes) != 1:
+            return
+
+        original_width = getattr(instance, self.width_field)
+        original_height = getattr(instance, self.height_field)
+
+        if original_width > 0 and original_height > 0:
+            thumb_width, thumb_height = self.sizes[0]
+
+            w_scale = float(thumb_width) / original_width
+            h_scale = float(thumb_height) / original_height
+            scale_ratio = min(w_scale, h_scale)
+
+            if scale_ratio >= 1:
+                thumb_width_ratio = original_width
+                thumb_height_ratio = original_height
+            else:
+                thumb_width_ratio = int(original_width * scale_ratio)
+                thumb_height_ratio = int(original_height * scale_ratio)
+
+            setattr(instance, thumb_width_field, thumb_width_ratio)
+            setattr(instance, thumb_height_field, thumb_height_ratio)
+
 
 from south.modelsinspector import add_introspection_rules
 add_introspection_rules([], ["^boards\.thumbs\.ImageWithThumbsField"])