Розробка системи автоматизованого мережевого розподілення навчального матеріалу

        items.push_back( new ModelFileSystemItem(filemodel->fileIcon(ItemIndex).pixmap(QSize(16, 16)).toImage(),filemodel->fileName(ItemIndex),size));

    }

    return items;

}

QStringList ModelFileSystem::getDrivesList()

{  QStringList drives;

    foreach(QFileInfo drive, QDir::drives())

    {  drives.push_back(drive.absolutePath());

    }

    return drives;

}

QString ModelFileSystem::getCurrentPath()

{  return path;

}

void ModelFileSystem::setCurrentPath(QString p)

{path=p;

}

bool ModelFileSystem::goTo(QString p)

{  bool res=true;

    QModelIndex ItemIndex = filemodel->index(QDir(path+p+"/").absolutePath());

    if(filemodel->fileInfo(ItemIndex).isDir())

    {for(int i=pathHistory.size()-1;i>0;i--)

            if(pathHistory[i].compare(path)==0)

                break;

            else

                pathHistory.remove(i);

        path+=p+"/";

        pathHistory.push_back(path);

 

        pathHistoryIndex=pathHistory.size()-1;

    }

    else

        res=false;

    updateAvalibility();

    return res;

}

void ModelFileSystem::updateAvalibility()

{ if(pathHistory.size()>1 && pathHistoryIndex>0)

       isAvalibleBack=true;

    else

       isAvalibleBack=false;

   if(pathHistoryIndex<pathHistory.size()-1)

       isAvalibleForward=true;

    else

       isAvalibleForward=false;

}

void ModelFileSystem::goBack()

{ pathHistoryIndex--;

    if(pathHistoryIndex<=0)

        pathHistoryIndex=0;

    path=pathHistory[pathHistoryIndex];

    updateAvalibility();

}

void ModelFileSystem::goForward()

{ pathHistoryIndex++;

    if(pathHistoryIndex>=pathHistory.size())

        pathHistoryIndex=pathHistory.size()-1;

    path=pathHistory[pathHistoryIndex];

    updateAvalibility();

}

void ModelFileSystem::goHome()

{ path=root;

    pathHistory.clear();

    pathHistory.push_back(path);

    pathHistoryIndex=0;

    updateAvalibility();

}

bool ModelFileSystem::isBackAvalible(){return isAvalibleBack;}

bool ModelFileSystem::isForwardAvalible(){return isAvalibleForward;}

void ModelFileSystem::changeDrive(QString d)

{ path = d;

    root = d;

    filemodel->setRootPath(d);

    pathHistory.clear();

    pathHistory.push_back(path);

    pathHistoryIndex=0;

    updateAvalibility();

} 

Додаток Б

Лістинг ModelClient

#include "ModelClient.h"

ModelClient::ModelClient(QObject *parent): QObject(parent)

{  socket = new QTcpSocket(this);

    modelFileSystem = new ModelFileSystem(parent,"/");

    connect(socket, SIGNAL(readyRead()), this, SLOT(readyRead()));

    connect(socket, SIGNAL(connected()), this, SLOT(connected()));

    socket->connectToHost("127.0.0.1", 4200);

}

void ModelClient::readyRead()

{  QDataStream in(socket);

    in.setVersion(QDataStream::Qt_4_2);

    QByteArray block;

    QDataStream out(&block, QIODevice::WriteOnly);

    QString ip;

    QString path;

    QString drive;

    quint8 count;

    quint8 rowCount;

    quint8 command;

    for (;;)

    {  m_nNextBlockSize=0;

        {     if (socket->bytesAvailable() < sizeof(quint64)) {

                   break;

               }

               in >> m_nNextBlockSize;

           }

           if (socket->bytesAvailable() < m_nNextBlockSize) {

               break;

           }

    in >> command;

    qDebug() << "Received command " << command;

    switch(command)

    {   case 12:

             in >>ip;

             out << quint64(0);

             out << quint8(22);

             out << quint8(modelFileSystem->getDrivesList().size());

             for(int i=0;i<modelFileSystem->getDrivesList().size();i++)

             {   out << modelFileSystem->getDrivesList()[i];

             }

             out.device()->seek(0);

             out << quint64(block.size() - sizeof(quint64));

             socket->write(block);

             qDebug() << "Sending drive list ";

       break;

       case 13:

            in >>ip;

            in >> drive;

            block.clear();

            modelFileSystem->changeDrive(drive);

            out << quint64(0);

            out << (quint8)23;

            out <<  ip;

            out.device()->seek(0);

            out << quint64(block.size() - sizeof(quint64));

            socket->write(block);

            qDebug() << "Changed drive to "<<drive;

       break;

       case 14:

            in >>ip; 

            fileList = modelFileSystem->getCurrentItems();

            block.clear();

            out << quint64(0);

            out << (quint8)24;

            out << ip;

            rowCount = modelFileSystem->getCurrentItems().size();

            out << (quint8)rowCount;

            out << modelFileSystem->getCurrentPath();

            if(modelFileSystem->isBackAvalible())

               out << (quint8)1;

            else

               out << (quint8)0;

            if(modelFileSystem->isForwardAvalible())

               out << (quint8)1;

            else

               out << (quint8)0;

            out.device()->seek(0);

            out << quint64(block.size() - sizeof(quint64));

            socket->write(block);

            qDebug() << "Initiate all files";

       break;

       case 15:

            in >> ip;

            in >> rowCount;

            in >> count;

            if(count<rowCount)

            {block.clear();

                out << quint64(0);

                out << (quint8)25;

                out << ip;

                out << quint8(rowCount);

                out << quint8(count);

                out << fileList[count]->getIcon();

                out <<  fileList[count]->getCaption();

                out <<  fileList[count]->getSize();

                out.device()->seek(0);

                out << quint64(block.size() - sizeof(quint64));

                socket->write(block);

            }

            qDebug() << "Sending file";

       break;

       case 16:

            in >>ip;

            in >> path;

            block.clear();

            modelFileSystem->goTo(path);

            out << quint64(0);

            out << (quint8)23;

            out <<  ip;

            out.device()->seek(0);

            out << quint64(block.size() - sizeof(quint64));

            socket->write(block);

            qDebug() << "Go To "<<path;

       break;

       case 17:

            in >>ip;

            block.clear();

            modelFileSystem->goBack();;

            out << quint64(0);

            out << (quint8)23;

            out <<  ip;

            out.device()->seek(0);

 

            out << quint64(block.size() - sizeof(quint64));

            socket->write(block);

            qDebug() << "Go Back";

       break;

       case 18:

            in >>ip;

            block.clear();

            modelFileSystem->goForward();

            out << quint64(0);

            out << (quint8)23;

            out <<  ip;

            out.device()->seek(0);

            out << quint64(block.size() - sizeof(quint64));

            socket->write(block);

            qDebug() << "Go Forward";

       break;

       case 19:

            in >>ip;

            block.clear();

            modelFileSystem->goHome();

            out << quint64(0);

            out << (quint8)23;

            out <<  ip;

            out.device()->seek(0);

            out << quint64(block.size() - sizeof(quint64));

            socket->write(block);

            qDebug() << "Go Home";

        break;

        default: block.clear();

                 in.setDevice(socket);

                 break;

    }

  }

}

void ModelClient::connected()

{  QByteArray block;

    QDataStream out(&block, QIODevice::WriteOnly);

    out.setVersion(QDataStream::Qt_4_2);

    out << quint64(0);

    out << (quint8)7;

    out << QString("default");

    out.device()->seek(0);

    out << quint64(block.size() - sizeof(quint64));

    socket->write(block);

}

 

Лістинг ModelFileSystem

#include "ModelFileSystem.h"

ModelFileSystem::ModelFileSystem(QObject *obj,QString rp)

{ filemodel = new QFileSystemModel(obj);

    changeDrive(rp);

}

QVector<ModelFileSystemItem*> ModelFileSystem::getCurrentItems()

{  QVector<ModelFileSystemItem*> items;

    QDir di(path);

    QStringList qsl = di.entryList(QDir::NoDotAndDotDot | QDir::Dirs | QDir::Files);

    for(int i=0;i<qsl.size();i++)

    {  QModelIndex ItemIndex = filemodel->index(QDir(path+qsl[i]).absolutePath());

        QString size;

        if(filemodel->fileInfo(ItemIndex).isDir())

            size="folder";

        else

 

            size= QString::number(filemodel->fileInfo(ItemIndex).size()/1024.0);

        items.push_back( new ModelFileSystemItem(filemodel->fileIcon(ItemIndex).pixmap(QSize(16, 16)).toImage(),filemodel->fileName(ItemIndex),size));

    }

    return items;

}

QStringList ModelFileSystem::getDrivesList()

{  QStringList drives;

    foreach(QFileInfo drive, QDir::drives())

    {  drives.push_back(drive.absolutePath());

    }

    return drives;

}

QString ModelFileSystem::getCurrentPath()

{  return path;

}

void ModelFileSystem::setCurrentPath(QString p)

{path=p;

}

bool ModelFileSystem::goTo(QString p)

{  bool res=true;

    QModelIndex ItemIndex = filemodel->index(QDir(path+p+"/").absolutePath());

    if(filemodel->fileInfo(ItemIndex).isDir())

    {for(int i=pathHistory.size()-1;i>0;i--)

            if(pathHistory[i].compare(path)==0)

                break;

            else

                pathHistory.remove(i);

        path+=p+"/";

        pathHistory.push_back(path);

        pathHistoryIndex=pathHistory.size()-1;

    }

    else

        res=false;

    updateAvalibility();

    return res;

}

void ModelFileSystem::updateAvalibility()

{ if(pathHistory.size()>1 && pathHistoryIndex>0)

       isAvalibleBack=true;

    else

       isAvalibleBack=false;

   if(pathHistoryIndex<pathHistory.size()-1)

       isAvalibleForward=true;

    else

       isAvalibleForward=false;

}

void ModelFileSystem::goBack()

{ pathHistoryIndex--;

    if(pathHistoryIndex<=0)

        pathHistoryIndex=0;

    path=pathHistory[pathHistoryIndex];

    updateAvalibility();

}

void ModelFileSystem::goForward()

{ pathHistoryIndex++;

    if(pathHistoryIndex>=pathHistory.size())

        pathHistoryIndex=pathHistory.size()-1;

    path=pathHistory[pathHistoryIndex];

    updateAvalibility();

}

 

void ModelFileSystem::goHome()

{ path=root;

    pathHistory.clear();

    pathHistory.push_back(path);

    pathHistoryIndex=0;

    updateAvalibility();

}

bool ModelFileSystem::isBackAvalible(){return isAvalibleBack;}

bool ModelFileSystem::isForwardAvalible(){return isAvalibleForward;}

void ModelFileSystem::changeDrive(QString d)

{ path = d;

    root = d;

    filemodel->setRootPath(d);

    pathHistory.clear();

    pathHistory.push_back(path);

    pathHistoryIndex=0;

    updateAvalibility();

 

Лістинг ModelFileSystemItem

#include "ModelFileSystemItem.h"

ModelFileSystemItem::ModelFileSystemItem(QImage i, QString c, QString s)

{icon=i;

    caption=c;

    size=s;

}

QImage ModelFileSystemItem::getIcon()

{  return icon;

}

QString ModelFileSystemItem::getCaption()

{  return caption;

}

QString ModelFileSystemItem::getSize()

{  return size;

} 

Додаток В

Лістинг ModelServer

#include "ModelServer.h"

ModelServer::ModelServer(QObject *parent): QTcpServer(parent)

{  mainWindow = new MainWindow();

    mainWindow->show();

    QString sPath = "/";

    QDir dir("F:/L2");

    dir.setPath(QString("F:/L2"));

    filemodel = new QFileSystemModel(this);

    filemodel->setRootPath(dir.rootPath());

    QModelIndex parentIndex = filemodel->index(QDir("F:/L2/LabsFramework/FirstApp/FirstApp.sln").absolutePath());

    int numRows = filemodel->rowCount(parentIndex);

    qDebug() << filemodel->fileInfo(parentIndex).fileName();

    QDir di("C:/");

    QStringList qsl = di.entryList(QDir::NoDotAndDotDot | QDir::Dirs | QDir::Files);

    for(int i=0;i<qsl.size();i++)

        qDebug() << "Count:" << qsl[i];

    foreach( QFileInfo drive, QDir::drives() )

     {  qDebug() << "Drive: " << drive.absolutePath();

     }

}

void ModelServer::incomingConnection(int socketfd)

{  QTcpSocket *client = new QTcpSocket(this);

    client->setSocketDescriptor(socketfd);

    clients.push_back(client);

    //QListWidgetItem *item1=new QListWidgetItem(client->peerAddress().toString());

    //mainWindow->clientList->insertItem(0,item1);

    qDebug() << "New client from:" << client->peerAddress().toString();

    connect(client, SIGNAL(readyRead()), this, SLOT(readyRead()));

    connect(client, SIGNAL(disconnected()), this, SLOT(disconnected()));

}

void ModelServer::readyRead()

{

    QTcpSocket *client = (QTcpSocket*)sender();

    QDataStream in(client);

    quint8 command;

    in >> command;

    qDebug() << "Received command " << command;

         if(command==7)

         {

             QString name;

             QByteArray block;

             in >> block;

             name = QString::fromUtf8( block.data(), block.size() );

             qDebug() << "Message " << name;