mirror of
https://github.com/RetroShare/RetroShare.git
synced 2024-12-15 19:04:25 -05:00
604 lines
20 KiB
C++
604 lines
20 KiB
C++
/*******************************************************************************
|
|
* gui/settings/RSPermissionMatrixWidget.cpp *
|
|
* *
|
|
* Copyright (c) 2014 Retroshare Team <retroshare.project@gmail.com> *
|
|
* *
|
|
* This program is free software: you can redistribute it and/or modify *
|
|
* it under the terms of the GNU Affero 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 Affero General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Affero General Public License *
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>. *
|
|
* *
|
|
*******************************************************************************/
|
|
|
|
#ifndef WINDOWS_SYS
|
|
#include <sys/times.h>
|
|
#endif
|
|
|
|
#include <iostream>
|
|
#include <math.h>
|
|
#include <QtGlobal>
|
|
#include <QPainter>
|
|
#include <QDateTime>
|
|
#include <QTimer>
|
|
#include <QMouseEvent>
|
|
|
|
#include "RSPermissionMatrixWidget.h"
|
|
#include "gui/settings/ServicePermissionsPage.h"
|
|
#include <retroshare/rsstatus.h>
|
|
#include <retroshare/rspeers.h>
|
|
#include <retroshare/rsservicecontrol.h>
|
|
|
|
#define NOT_IMPLEMENTED std::cerr << __PRETTY_FUNCTION__ << ": not yet implemented." << std::endl;
|
|
|
|
// The behavior of the widget is the following:
|
|
// - when default is changed, switch all icons to the default position. Then every icon switch back by the user will be
|
|
// in the white list.
|
|
// - each peer/service slot has a switch. If the peer doesn't allow the service, the switch is shown with some
|
|
// indication. When both the current and adverse permissions are granted, the switch should show it as well.
|
|
// - we should use tooltips
|
|
|
|
const float RSPermissionMatrixWidget::fICON_SIZE_X = 40/16.0 ;
|
|
const float RSPermissionMatrixWidget::fICON_SIZE_Y = 40/16.0 ;
|
|
const float RSPermissionMatrixWidget::fROW_SIZE = 42/16.0 ;
|
|
const float RSPermissionMatrixWidget::fCOL_SIZE = 42/16.0 ;
|
|
const float RSPermissionMatrixWidget::fMATRIX_START_X = 5/16.0 ;
|
|
const float RSPermissionMatrixWidget::fMATRIX_START_Y =100/16.0 ;
|
|
|
|
/** Default contructor */
|
|
RSPermissionMatrixWidget::RSPermissionMatrixWidget(QWidget *parent)
|
|
:QFrame(parent)
|
|
{
|
|
_painter = new QPainter();
|
|
|
|
setMouseTracking(true) ;
|
|
|
|
_timer = new QTimer ;
|
|
QObject::connect(_timer,SIGNAL(timeout()),this,SLOT(updateDisplay())) ;
|
|
_timer->start(5000);
|
|
|
|
_max_width = 400 ;
|
|
_max_height = 0 ;
|
|
|
|
mHideOffline = false;
|
|
}
|
|
|
|
void RSPermissionMatrixWidget::setHideOffline(bool hide)
|
|
{
|
|
if (mHideOffline == hide) {
|
|
return;
|
|
}
|
|
|
|
mHideOffline = hide;
|
|
repaint();
|
|
}
|
|
|
|
void RSPermissionMatrixWidget::updateDisplay()
|
|
{
|
|
if(isHidden())
|
|
return ;
|
|
|
|
setMinimumWidth(_max_width) ;
|
|
setMinimumHeight(_max_height) ;
|
|
|
|
update() ;
|
|
}
|
|
|
|
void RSPermissionMatrixWidget::mousePressEvent(QMouseEvent *e)
|
|
{
|
|
std::cerr << "mouse pressed at x=" << e->x() << ", y=" << e->y() << std::endl;
|
|
|
|
uint32_t service_id ;
|
|
RsPeerId peer_id ;
|
|
|
|
if(computeServiceAndPeer(e->x(),e->y(),service_id,peer_id))
|
|
{
|
|
std::cerr << "Peer id: " << peer_id << ", service: " << service_id << std::endl;
|
|
|
|
// Make sure the service is not globally disabled
|
|
|
|
RsServicePermissions serv_perms;
|
|
rsServiceControl->getServicePermissions(service_id,serv_perms);
|
|
|
|
if (!serv_perms.mDefaultAllowed) return;
|
|
|
|
switchPermission(service_id,peer_id) ;
|
|
update() ;
|
|
}
|
|
else if(computeServiceGlobalSwitch(e->x(),e->y(),service_id))
|
|
{
|
|
switchPermission(service_id) ;
|
|
update();
|
|
}
|
|
else
|
|
QFrame::mousePressEvent(e) ;
|
|
}
|
|
|
|
void RSPermissionMatrixWidget::switchPermission(uint32_t service,const RsPeerId& pid)
|
|
{
|
|
RsServicePermissions serv_perms ;
|
|
|
|
if(!rsServiceControl->getServicePermissions(service,serv_perms))
|
|
return ;
|
|
|
|
if(serv_perms.peerHasPermission(pid))
|
|
serv_perms.resetPermission(pid) ;
|
|
else
|
|
serv_perms.setPermission(pid) ;
|
|
|
|
rsServiceControl->updateServicePermissions(service,serv_perms);
|
|
}
|
|
|
|
void RSPermissionMatrixWidget::switchPermission(uint32_t service)
|
|
{
|
|
RsServicePermissions serv_perms ;
|
|
|
|
if(!rsServiceControl->getServicePermissions(service,serv_perms))
|
|
return ;
|
|
|
|
if(serv_perms.mDefaultAllowed)
|
|
{
|
|
serv_perms.mPeersAllowed.clear() ;
|
|
serv_perms.mDefaultAllowed = false ;
|
|
}
|
|
else
|
|
{
|
|
serv_perms.mDefaultAllowed = true ;
|
|
serv_perms.mPeersDenied.clear() ;
|
|
}
|
|
|
|
rsServiceControl->updateServicePermissions(service,serv_perms);
|
|
}
|
|
|
|
void RSPermissionMatrixWidget::mouseMoveEvent(QMouseEvent *e)
|
|
{
|
|
uint32_t service_id ;
|
|
RsPeerId peer_id ;
|
|
|
|
if(computeServiceAndPeer(e->x(),e->y(),service_id,peer_id))
|
|
{
|
|
if(_current_service_id != service_id || _current_peer_id != peer_id)
|
|
{
|
|
_current_service_id = service_id ;
|
|
_current_peer_id = peer_id ;
|
|
|
|
// redraw!
|
|
update() ;
|
|
}
|
|
}
|
|
else if(computeServiceGlobalSwitch(e->x(),e->y(),service_id))
|
|
{
|
|
peer_id.clear() ;
|
|
|
|
if(_current_service_id != service_id || _current_peer_id != peer_id)
|
|
{
|
|
_current_service_id = service_id ;
|
|
_current_peer_id = peer_id ;
|
|
|
|
// redraw!
|
|
update() ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
service_id = ~0 ;
|
|
peer_id.clear() ;
|
|
}
|
|
}
|
|
|
|
/** Default destructor */
|
|
RSPermissionMatrixWidget::~RSPermissionMatrixWidget()
|
|
{
|
|
_timer->stop() ;
|
|
|
|
delete _timer ;
|
|
delete _painter;
|
|
}
|
|
|
|
bool sortRsPeerIdByNameLocation(const RsPeerId &a, const RsPeerId &b)
|
|
{
|
|
RsPeerDetails detailsA, detailsB;
|
|
rsPeers->getPeerDetails(a, detailsA);
|
|
rsPeers->getPeerDetails(b, detailsB);
|
|
QString stringA, stringB;
|
|
|
|
// name
|
|
stringA += QString::fromUtf8(detailsA.name.c_str());
|
|
stringB += QString::fromUtf8(detailsB.name.c_str());
|
|
|
|
// location
|
|
stringA += QString::fromUtf8(detailsA.location.c_str());
|
|
stringB += QString::fromUtf8(detailsB.location.c_str());
|
|
|
|
return stringA.toLower() < stringB.toLower();
|
|
}
|
|
|
|
/** Overloads default QWidget::paintEvent. Draws the actual
|
|
* bandwidth graph. */
|
|
void RSPermissionMatrixWidget::paintEvent(QPaintEvent *)
|
|
{
|
|
//std::cerr << "In paint event!" << std::endl;
|
|
|
|
int S = QFontMetricsF(font()).height();
|
|
|
|
/* Set current graph dimensions */
|
|
_rec = this->frameRect();
|
|
|
|
/* Start the painter */
|
|
_painter->begin(this);
|
|
|
|
/* We want antialiased lines and text */
|
|
_painter->setRenderHint(QPainter::Antialiasing);
|
|
_painter->setRenderHint(QPainter::TextAntialiasing);
|
|
|
|
/* Fill in the background */
|
|
_painter->fillRect(_rec, QBrush(BACK_COLOR));
|
|
_painter->drawRect(_rec);
|
|
|
|
// draw one line per friend.
|
|
std::list<RsPeerId> ssllist ;
|
|
rsPeers->getFriendList(ssllist) ;
|
|
|
|
// sort list
|
|
{
|
|
// sort out offline peers
|
|
if(mHideOffline) {
|
|
RsPeerDetails peerDetails;
|
|
for(std::list<RsPeerId>::iterator it = ssllist.begin(); it != ssllist.end();) {
|
|
rsPeers->getPeerDetails(*it, peerDetails);
|
|
|
|
switch (peerDetails.connectState) {
|
|
case RS_PEER_CONNECTSTATE_OFFLINE:
|
|
case RS_PEER_CONNECTSTATE_TRYING_TCP:
|
|
case RS_PEER_CONNECTSTATE_TRYING_UDP:
|
|
it = ssllist.erase(it);
|
|
break;
|
|
default:
|
|
it++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// sort by name
|
|
ssllist.sort(sortRsPeerIdByNameLocation);
|
|
}
|
|
|
|
RsPeerServiceInfo ownServices;
|
|
rsServiceControl->getOwnServices(ownServices);
|
|
|
|
// Display friend names at the beginning of each column
|
|
|
|
const QFont& font(_painter->font()) ;
|
|
QFontMetrics fm(font);
|
|
int peer_name_size = 0 ;
|
|
float line_height = 2 + fm.height() ;
|
|
|
|
std::vector<QString> names ;
|
|
|
|
for(std::list<RsPeerId>::const_iterator it(ssllist.begin());it!=ssllist.end();++it)
|
|
{
|
|
RsPeerDetails details ;
|
|
rsPeers->getPeerDetails(*it,details) ;
|
|
|
|
QString name = QString::fromUtf8(details.name.c_str()) + " (" + QString::fromUtf8(details.location.c_str()) + ")";
|
|
if(name.length() > 20)
|
|
name = name.left(20)+"..." ;
|
|
|
|
peer_name_size = std::max(peer_name_size, fm.width(name)) ;
|
|
names.push_back(name) ;
|
|
}
|
|
|
|
QPen pen ;
|
|
pen.setWidth(2) ;
|
|
pen.setBrush(Qt::black) ;
|
|
|
|
_painter->setPen(pen) ;
|
|
int i=0;
|
|
//int x=5/14.0*S ;
|
|
int y=S*fMATRIX_START_Y ;
|
|
|
|
for(std::list<RsPeerId>::const_iterator it(ssllist.begin());it!=ssllist.end();++it,++i)
|
|
{
|
|
float X = S*fMATRIX_START_X + peer_name_size - fm.width(names[i]) ;
|
|
float Y = S*fMATRIX_START_Y + (i+0.5)*S*fROW_SIZE + line_height/2.0f-2 ;
|
|
|
|
_painter->drawText(QPointF(X,Y),names[i]) ;
|
|
|
|
if(*it == _current_peer_id)
|
|
_painter->drawLine(QPointF(X,Y+3),QPointF(X+fm.width(names[i]),Y+3)) ;
|
|
|
|
y += line_height ;
|
|
}
|
|
|
|
matrix_start_x = S*5/14.0 + S*fMATRIX_START_X + peer_name_size ;
|
|
|
|
// now draw the service names
|
|
|
|
i=0 ;
|
|
std::vector<int> last_width(10,0) ;
|
|
|
|
for(std::map<uint32_t, RsServiceInfo>::const_iterator it(ownServices.mServiceList.begin());it!=ownServices.mServiceList.end();++it,++i)
|
|
{
|
|
QString name = QString::fromUtf8(it->second.mServiceName.c_str()) ;
|
|
int text_width = fm.width(name) ;
|
|
|
|
int X = matrix_start_x + S*fCOL_SIZE/2 - 2 + i*S*fCOL_SIZE - text_width/2;
|
|
|
|
int height_index = 0 ;
|
|
while(last_width[height_index] > X-5 && height_index < ((int)last_width.size()-1) )
|
|
++height_index ;
|
|
|
|
int Y = S*fMATRIX_START_Y - S*fICON_SIZE_Y - 2 - line_height * height_index;
|
|
|
|
last_width[height_index] = X + text_width ;
|
|
// draw a half-transparent rectangle
|
|
|
|
QBrush brush ;
|
|
brush.setColor(QColor::fromHsvF(0.0f,0.0f,1.0f,0.8f));
|
|
brush.setStyle(Qt::SolidPattern) ;
|
|
|
|
QPen pen ;
|
|
pen.setWidth(2) ;
|
|
|
|
if(_current_service_id == it->second.mServiceType)
|
|
pen.setBrush(Qt::black) ;
|
|
else
|
|
pen.setBrush(Qt::gray) ;
|
|
|
|
_painter->setPen(pen) ;
|
|
|
|
QRect info_pos( X-5,Y-line_height-2, text_width + 10, line_height + 5) ;
|
|
|
|
//_painter->fillRect(info_pos,brush) ;
|
|
//_painter->drawRect(info_pos) ;
|
|
|
|
_painter->drawLine(QPointF(X,Y+3),QPointF(X+text_width,Y+3)) ;
|
|
_painter->drawLine(QPointF(X+text_width/2, Y+3), QPointF(X+text_width/2,S*fMATRIX_START_Y+peer_ids.size()*S*fROW_SIZE - S*fROW_SIZE+5)) ;
|
|
|
|
pen.setBrush(Qt::black) ;
|
|
_painter->setPen(pen) ;
|
|
|
|
_painter->drawText(QPointF(X,Y),name);
|
|
}
|
|
|
|
// Now draw the global switches.
|
|
|
|
peer_ids.clear() ;
|
|
for(std::list<RsPeerId>::const_iterator it(ssllist.begin());it!=ssllist.end();++it)
|
|
peer_ids.push_back(*it) ;
|
|
service_ids.clear() ;
|
|
for(std::map<uint32_t, RsServiceInfo>::const_iterator sit(ownServices.mServiceList.begin());sit!=ownServices.mServiceList.end();++sit)
|
|
service_ids.push_back(sit->first) ;
|
|
|
|
static const std::string global_switch[2] = { ":/icons/global_switch_off_128.png",
|
|
":/icons/global_switch_on_128.png" } ;
|
|
|
|
for(uint32_t i=0;i<service_ids.size();++i)
|
|
{
|
|
RsServicePermissions serv_perm ;
|
|
rsServiceControl->getServicePermissions(service_ids[i],serv_perm) ;
|
|
|
|
QPixmap pix(global_switch[serv_perm.mDefaultAllowed].c_str()) ;
|
|
QRect position = computeNodePosition(0,i,false) ;
|
|
|
|
position.setY(position.y() - S*fICON_SIZE_Y + 8/14.0*S) ;
|
|
position.setX(position.x() + 3/14.0*S) ;
|
|
position.setHeight(30/14.0*S) ;
|
|
position.setWidth(30/14.0*S) ;
|
|
|
|
_painter->drawPixmap(position,pix.scaledToHeight(S*fICON_SIZE_Y*0.9,Qt::SmoothTransformation),QRect(0,0,S*fICON_SIZE_X,S*fICON_SIZE_Y)) ;
|
|
}
|
|
|
|
// We draw for each service.
|
|
|
|
static const std::string pixmap_names[4] = { ":/icons/switch00_128.png",
|
|
":/icons/switch01_128.png",
|
|
":/icons/switch10_128.png",
|
|
":/icons/switch11_128.png" } ;
|
|
|
|
int n_col = 0 ;
|
|
int n_col_selected = -1 ;
|
|
int n_row_selected = -1 ;
|
|
|
|
for(std::map<uint32_t, RsServiceInfo>::const_iterator sit(ownServices.mServiceList.begin());sit!=ownServices.mServiceList.end();++sit,++n_col)
|
|
{
|
|
RsServicePermissions service_perms ;
|
|
|
|
rsServiceControl->getServicePermissions(sit->first,service_perms) ;
|
|
|
|
// draw the default switch.
|
|
|
|
|
|
// draw one switch per friend.
|
|
|
|
int n_row = 0 ;
|
|
|
|
for(std::list<RsPeerId>::const_iterator it(ssllist.begin());it!=ssllist.end();++it,++n_row)
|
|
{
|
|
RsPeerServiceInfo local_service_perms ;
|
|
RsPeerServiceInfo remote_service_perms ;
|
|
|
|
rsServiceControl->getServicesAllowed (*it, local_service_perms) ;
|
|
rsServiceControl->getServicesProvided(*it,remote_service_perms) ;
|
|
|
|
bool local_allowed = local_service_perms.mServiceList.find(sit->first) != local_service_perms.mServiceList.end() ;
|
|
bool remote_allowed = remote_service_perms.mServiceList.find(sit->first) != remote_service_perms.mServiceList.end() ;
|
|
|
|
QPixmap pix(pixmap_names[(local_allowed << 1) + remote_allowed].c_str()) ;
|
|
|
|
bool selected = (sit->first == _current_service_id && *it == _current_peer_id) ;
|
|
QRect position = computeNodePosition(n_row,n_col,selected) ;
|
|
|
|
if(selected)
|
|
{
|
|
n_row_selected = n_row ;
|
|
n_col_selected = n_col ;
|
|
}
|
|
_painter->drawPixmap(position,pix.scaledToHeight(S*fICON_SIZE_X,Qt::SmoothTransformation),QRect(0,0,S*fICON_SIZE_X,S*fICON_SIZE_Y)) ;
|
|
}
|
|
}
|
|
|
|
// now display some info about current node.
|
|
|
|
if(n_row_selected >= 0 && n_col_selected >= 0 && n_row_selected < (int)peer_ids.size() && n_col_selected < (int)service_ids.size())
|
|
{
|
|
QRect position = computeNodePosition(n_row_selected,n_col_selected,false) ;
|
|
|
|
// draw text info
|
|
|
|
RsServicePermissions service_perms ;
|
|
|
|
rsServiceControl->getServicePermissions(service_ids[n_col_selected],service_perms) ;
|
|
|
|
QString service_name = tr("Service name:")+" "+QString::fromUtf8(service_perms.mServiceName.c_str()) ;
|
|
QString service_default = service_perms.mDefaultAllowed?tr("Allowed by default"):tr("Denied by default");
|
|
QString peer_name = tr("Peer name:")+" " + names[n_row_selected] ;
|
|
QString peer_id = tr("Peer Id:")+" "+QString::fromStdString(_current_peer_id.toStdString()) ;
|
|
|
|
RsPeerServiceInfo pserv_info ;
|
|
rsServiceControl->getServicesAllowed(_current_peer_id,pserv_info) ;
|
|
|
|
bool locally_allowed = pserv_info.mServiceList.find(_current_service_id) != pserv_info.mServiceList.end();
|
|
bool remotely_allowed = false ; // default, if the peer is offline
|
|
|
|
if(rsServiceControl->getServicesProvided(_current_peer_id,pserv_info))
|
|
remotely_allowed = pserv_info.mServiceList.find(_current_service_id) != pserv_info.mServiceList.end();
|
|
|
|
QString local_status = locally_allowed ?tr("Enabled for this peer") :tr("Disabled for this peer") ;
|
|
QString remote_status = remotely_allowed?tr("Enabled by remote peer"):tr("Disabled by remote peer") ;
|
|
|
|
if(!service_perms.mDefaultAllowed)
|
|
local_status = tr("Globally switched Off") ;
|
|
|
|
const QFont& font(_painter->font()) ;
|
|
QFontMetrics fm(font);
|
|
|
|
int text_size_x = 0 ;
|
|
text_size_x = std::max(text_size_x,fm.width(service_name));
|
|
text_size_x = std::max(text_size_x,fm.width(peer_name));
|
|
text_size_x = std::max(text_size_x,fm.width(peer_id));
|
|
text_size_x = std::max(text_size_x,fm.width(local_status));
|
|
text_size_x = std::max(text_size_x,fm.width(remote_status));
|
|
|
|
// draw a half-transparent rectangle
|
|
|
|
QBrush brush ;
|
|
brush.setColor(QColor::fromHsvF(0.0f,0.0f,1.0f,0.8f));
|
|
brush.setStyle(Qt::SolidPattern) ;
|
|
|
|
QPen pen ;
|
|
pen.setWidth(2) ;
|
|
pen.setBrush(Qt::black) ;
|
|
|
|
_painter->setPen(pen) ;
|
|
|
|
QRect info_pos( position.x() + 50*S/14.0, position.y() - 10*S/14.0, text_size_x + 10*S/14.0, line_height * 5 + 5*S/14.0) ;
|
|
|
|
_painter->fillRect(info_pos,brush) ;
|
|
_painter->drawRect(info_pos) ;
|
|
|
|
// draw the text
|
|
|
|
float x = info_pos.x() + 5*S/14.0 ;
|
|
float y = info_pos.y() + line_height + 1*S/14.0 ;
|
|
|
|
_painter->drawText(QPointF(x,y), service_name) ; y += line_height ;
|
|
_painter->drawText(QPointF(x,y), peer_name) ; y += line_height ;
|
|
_painter->drawText(QPointF(x,y), peer_id) ; y += line_height ;
|
|
_painter->drawText(QPointF(x,y), remote_status) ; y += line_height ;
|
|
_painter->drawText(QPointF(x,y), local_status) ; y += line_height ;
|
|
}
|
|
|
|
_max_height = S*fMATRIX_START_Y + (peer_ids.size()+3) * S*fROW_SIZE ;
|
|
_max_width = matrix_start_x + (service_ids.size()+3) * S*fCOL_SIZE ;
|
|
|
|
/* Stop the painter */
|
|
_painter->end();
|
|
}
|
|
|
|
QRect RSPermissionMatrixWidget::computeNodePosition(int n_row,int n_col,bool selected) const
|
|
{
|
|
float fact = selected?1.2f:1.0f;
|
|
|
|
float S = QFontMetricsF(font()).height();
|
|
|
|
return QRect(matrix_start_x + n_col * S*fCOL_SIZE + (S*fCOL_SIZE-S*fICON_SIZE_X*fact)/2,
|
|
S*fMATRIX_START_Y + n_row * S*fROW_SIZE + (S*fROW_SIZE-S*fICON_SIZE_Y*fact)/2,
|
|
S*fICON_SIZE_X*fact,
|
|
S*fICON_SIZE_Y*fact) ;
|
|
}
|
|
|
|
// This function is the inverse of the previous function. Given a mouse position, it
|
|
// computes the peer/service switch that is under the mouse. The zoom factor is not
|
|
// accounted for, on purpose.
|
|
|
|
bool RSPermissionMatrixWidget::computeServiceAndPeer(int x,int y,uint32_t& service_id,RsPeerId& peer_id) const
|
|
{
|
|
// 1 - make sure that x and y are on a widget
|
|
|
|
float S = QFontMetricsF(font()).height();
|
|
|
|
x -= matrix_start_x ;
|
|
y -= S*fMATRIX_START_Y ;
|
|
|
|
if(x < 0 || x >= service_ids.size() * S*fCOL_SIZE) return false ;
|
|
if(y < 0 || y >= peer_ids.size() * S*fROW_SIZE) return false ;
|
|
|
|
if( (x % (int)(S*fCOL_SIZE)) < (S*fCOL_SIZE - S*fICON_SIZE_X)/2) return false ;
|
|
if( (x % (int)(S*fCOL_SIZE)) > (S*fCOL_SIZE + S*fICON_SIZE_X)/2) return false ;
|
|
|
|
if( (y % (int)(S*fROW_SIZE)) < (S*fROW_SIZE - S*fICON_SIZE_Y)/2) return false ;
|
|
if( (y % (int)(S*fROW_SIZE)) > (S*fROW_SIZE + S*fICON_SIZE_Y)/2) return false ;
|
|
|
|
// 2 - find which widget, by looking into the service perm matrix
|
|
|
|
service_id = service_ids[x / (int)(S*fCOL_SIZE)] ;
|
|
peer_id = peer_ids[y / (int)(S*fCOL_SIZE)] ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
bool RSPermissionMatrixWidget::computeServiceGlobalSwitch(int x,int y,uint32_t& service_id) const
|
|
{
|
|
// 1 - make sure that x and y are on a widget
|
|
|
|
float S = QFontMetricsF(font()).height();
|
|
|
|
x -= matrix_start_x ;
|
|
y -= S*fMATRIX_START_Y ;
|
|
|
|
if(x < 0 || x >= service_ids.size() * S*fCOL_SIZE) return false ;
|
|
|
|
if( (x % (int)(S*fCOL_SIZE)) < (S*fCOL_SIZE - S*fICON_SIZE_X)/2) return false ;
|
|
if( (x % (int)(S*fCOL_SIZE)) > (S*fCOL_SIZE + S*fICON_SIZE_X)/2) return false ;
|
|
|
|
if( y < -S*fROW_SIZE ) return false ;
|
|
if( y > 0 ) return false ;
|
|
|
|
// 2 - find which widget, by looking into the service perm matrix
|
|
|
|
service_id = service_ids[x / (int)(S*fCOL_SIZE)] ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
void RSPermissionMatrixWidget::defaultPermissionSwitched(uint32_t /* ServiceId */,bool /* b */)
|
|
{
|
|
NOT_IMPLEMENTED ;
|
|
}
|
|
|
|
void RSPermissionMatrixWidget::userPermissionSwitched(uint32_t /* ServiceId */,const RsPeerId& /* friend_id */,bool /* b */)
|
|
{
|
|
NOT_IMPLEMENTED ;
|
|
}
|
|
|
|
|