Skip to content
Snippets Groups Projects
Select Git revision
  • fe6c3701cf33026cde0bb56b9fe4f5d4163cfbd0
  • master default protected
  • release/202005
  • release/202001
  • release/201912
  • release/201911
  • release/201910
  • release/201908
  • release/201906
  • release/201905
  • release/201904
  • release/201903
  • release/201902
  • release/201901
  • release/201812
  • release/201811
  • release/201808
  • releases/beta1
  • packaging
  • native
  • release-0.2.x
  • 1.0.0
  • 0.2.0
  • 0.1.1
  • 0.1.0
25 results

main.cpp

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    pixbufmanipulator.cpp 5.24 KiB
    /***************************************************************************
     * Copyright (C) 2016 by Savoir-faire Linux                                *
     * Author: Edric Ladent Milaret <edric.ladent-milaret@savoirfairelinux.com>*
     *                                                                         *
     * This program is free software; you can redistribute it and/or modify    *
     * it under the terms of the GNU General Public License as published by    *
     * the Free Software Foundation; either version 3 of the License, or       *
     * (at your option) any later version.                                     *
     *                                                                         *
     * This program is distributed in the hope that it will be useful,         *
     * but WITHOUT ANY WARRANTY; without even the implied warranty of          *
     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           *
     * GNU General Public License for more details.                            *
     *                                                                         *
     * You should have received a copy of the GNU General Public License       *
     * along with this program.  If not, see <http://www.gnu.org/licenses/>.   *
     **************************************************************************/
    
    #include "pixbufmanipulator.h"
    
    #include <QtCore/QSize>
    #include <QtCore/QMetaType>
    
    #include <person.h>
    #include <memory>
    #include <call.h>
    #include <contactmethod.h>
    
    namespace Interfaces {
    
    PixbufManipulator::PixbufManipulator()
        : fallbackAvatar_(QImage(":/images/user/btn-default-userpic.svg"))
    {}
    
    QImage
    PixbufManipulator::scaleAndFrame(const QImage photo, const QSize& size)
    {
        return photo.scaled(size, Qt::KeepAspectRatio, Qt::SmoothTransformation);
    }
    
    QVariant
    PixbufManipulator::callPhoto(Call* c, const QSize& size, bool displayPresence)
    {
        if (!c || c->type() == Call::Type::CONFERENCE)
            return QVariant::fromValue(scaleAndFrame(fallbackAvatar_, size));
        return callPhoto(c->peerContactMethod(), size, displayPresence);
    }
    
    QVariant
    PixbufManipulator::callPhoto(const ContactMethod* n, const QSize& size, bool displayPresence)
    {
        if (n && n->contact()) {
            return contactPhoto(n->contact(), size, displayPresence);
        } else {
            return QVariant::fromValue(scaleAndFrame(fallbackAvatar_, size));
        }
    }
    
    QVariant
    PixbufManipulator::contactPhoto(Person* c, const QSize& size, bool displayPresence)
    {
        Q_UNUSED(displayPresence);
    
        /**
         * try to get the photo
         * otherwise use the fallback avatar
         */
    
        QImage photo;
    
        if (c->photo().isValid())
            photo = c->photo().value<QImage>();
        else
            photo = fallbackAvatar_;
    
        return QVariant::fromValue(scaleAndFrame(photo, size));
    }
    
    QVariant PixbufManipulator::personPhoto(const QByteArray& data, const QString& type)
    {
        Q_UNUSED(type);
        Q_UNUSED(data);
        return QVariant();
    }
    
    QVariant
    PixbufManipulator::numberCategoryIcon(const QVariant& p, const QSize& size, bool displayPresence, bool isPresent)
    {
        Q_UNUSED(p)
        Q_UNUSED(size)
        Q_UNUSED(displayPresence)
        Q_UNUSED(isPresent)
        return QVariant();
    }
    
    QVariant
    PixbufManipulator::securityIssueIcon(const QModelIndex& index)
    {
        Q_UNUSED(index)
        return QVariant();
    }
    
    QByteArray
    PixbufManipulator::toByteArray(const QVariant& pxm)
    {
        Q_UNUSED(pxm);
        return QByteArray();
    }
    
    QVariant
    PixbufManipulator::collectionIcon(const CollectionInterface* interface, PixmapManipulatorI::CollectionIconHint hint) const
    {
        Q_UNUSED(interface)
        Q_UNUSED(hint)
        return QVariant();
    }
    QVariant
    PixbufManipulator::securityLevelIcon(const SecurityEvaluationModel::SecurityLevel level) const
    {
        Q_UNUSED(level)
        return QVariant();
    }
    QVariant
    PixbufManipulator::historySortingCategoryIcon(const CategorizedHistoryModel::SortedProxy::Categories cat) const
    {
        Q_UNUSED(cat)
        return QVariant();
    }
    QVariant
    PixbufManipulator::contactSortingCategoryIcon(const CategorizedContactModel::SortedProxy::Categories cat) const
    {
        Q_UNUSED(cat)
        return QVariant();
    }
    QVariant
    PixbufManipulator::userActionIcon(const UserActionElement& state) const
    {
        Q_UNUSED(state)
        return QVariant();
    }
    
    QVariant PixbufManipulator::decorationRole(const QModelIndex& index)
    {
        Q_UNUSED(index)
        return QVariant();
    }
    
    QVariant PixbufManipulator::decorationRole(const Call* c)
    {
        QImage photo;
        if (c && c->peerContactMethod()
                && c->peerContactMethod()->contact()
                && c->peerContactMethod()->contact()->photo().isValid()) {
            photo =  c->peerContactMethod()->contact()->photo().value<QImage>();
        }
        else
            photo = fallbackAvatar_;
        return QVariant::fromValue(scaleAndFrame(photo, imgSize_));
    }
    
    QVariant PixbufManipulator::decorationRole(const ContactMethod* cm)
    {
        QImage photo;
        if (cm && cm->contact() && cm->contact()->photo().isValid())
            photo = cm->contact()->photo().value<QImage>();
        else
            photo = fallbackAvatar_;
        return QVariant::fromValue(scaleAndFrame(photo, imgSize_));
    }
    
    QVariant PixbufManipulator::decorationRole(const Person* p)
    {
        QImage photo;
        if (p && p->photo().isValid())
            photo = p->photo().value<QImage>();
        else
            photo = fallbackAvatar_;
        return QVariant::fromValue(scaleAndFrame(photo, imgSize_));
    }
    
    } // namespace Interfaces