experimental/DrawingBoard/SampleDrawingClient.cpp

#include "SampleCode.h"
#include "SkView.h"
#include "SkCanvas.h"
#include "SkGPipe.h"
#include "SkSockets.h"
#include "SkNetPipeController.h"
#include "SkCornerPathEffect.h"
#include "SkColorPalette.h"
#include "SkOSMenu.h"


/**
 * Drawing Client
 *
 * A drawing client that allows a user to perform simple brush stokes with
 * a selected color and brush size. The drawing client communicates with a
 * drawing server to send/receive data to/from other clients connected to the
 * same server. The drawing client stores data in fData and fBuffer depending on
 * the data type. Append type means that the drawing data is a completed stroke
 * and Replace type means that the drawing data is in progress and will be
 * replaced by subsequent data. fData and fBuffer are read by a pipe reader and
 * reproduce the drawing. When the client is in a normal state, the data stored
 * on the client and the server should be identical.
 * The drawing client is also able to switch between vector and bitmap drawing.
 * The drawing client also renders the latest drawing stroke locally in order to
 * produce better reponses. This can be disabled by calling
 * controller.disablePlayBack(), which will introduce a lag between the input
 * and the drawing.
 * Note: in order to keep up with the drawing data, the client will try to read
 * a few times each frame in case more than one frame worth of data has been
 * received and render them together. This behavior can be adjusted by tweaking
 * MAX_READ_PER_FRAME or disabled by turning fSync to false
 */

#define MAX_READ_PER_FRAME 5

class DrawingClientView : public SampleView {
public:
    DrawingClientView() {
        fSocket = NULL;
        fTotalBytesRead = 0;
        fPalette = new SkColorPalette;
        fPalette->setSize(100, 300);
        fPalette->setVisibleP(true);
        this->attachChildToFront(fPalette);
        fPalette->unref();
        fBrushSize = 2.5;
        fAA = false;
        fPaletteVisible = true;
        fSync = true;
        fVector = true;
    }
    ~DrawingClientView() {
        if (fSocket) {
            delete fSocket;
        }
        fData.reset();
        fBuffer.reset();
    }

    virtual void requestMenu(SkOSMenu* menu) {
        menu->setTitle("Drawing Client");
        menu->appendTextField("Server IP", "Server IP", this->getSinkID(),
                              "IP address or hostname");
        menu->appendSwitch("Vector", "Vector", this->getSinkID(), fVector);
        menu->appendSlider("Brush Size", "Brush Size", this->getSinkID(), 1.0,
                           100.0, fBrushSize);
        menu->appendSwitch("Anti-Aliasing", "AA", this->getSinkID(), fAA);
        menu->appendSwitch("Show Color Palette", "Palette", this->getSinkID(),
                           fPaletteVisible);
        menu->appendSwitch("Sync", "Sync", this->getSinkID(), fSync);
        menu->appendAction("Clear", this->getSinkID());
    }

protected:

    static void readData(int cid, const void* data, size_t size,
                         SkSocket::DataType type, void* context) {
        DrawingClientView* view = (DrawingClientView*)context;
        view->onRead(cid, data, size, type);
    }

    void onRead(int cid, const void* data, size_t size, SkSocket::DataType type) {
        if (size > 0) {
            fBuffer.reset();
            if (type == SkSocket::kPipeReplace_type)
                fBuffer.append(size, (const char*)data);
            else if (type == SkSocket::kPipeAppend_type)
                fData.append(size, (const char*)data);
            else {
                //other types of data
            }
        }
    }

    bool onQuery(SkEvent* evt) {
        if (SampleCode::TitleQ(*evt)) {
            SampleCode::TitleR(evt, "Drawing Client");
            return true;
        }

        return this->INHERITED::onQuery(evt);
    }

    bool onEvent(const SkEvent& evt) {;
        if (SkOSMenu::FindSliderValue(evt, "Brush Size", &fBrushSize))
            return true;

        SkString s;
        if (SkOSMenu::FindText(evt, "Server IP", &s)) {
            if (NULL != fSocket) {
                delete fSocket;
            }
            fSocket = new SkTCPClient(s.c_str(), 40000);
            fSocket->connectToServer();
            fSocket->suspendWrite();
            SkDebugf("Connecting to %s\n", s.c_str());
            fData.reset();
            fBuffer.reset();
            this->inval(NULL);
            return true;
        }
        if (SkOSMenu::FindSwitchState(evt, "AA", &fAA) ||
            SkOSMenu::FindSwitchState(evt, "Sync", &fSync))
            return true;
        if (SkOSMenu::FindSwitchState(evt, "Vector", &fVector)) {
            this->clearBitmap();
            return true;
        }
        if (SkOSMenu::FindAction(evt, "Clear")) {
            this->clear();
            return true;
        }
        if (SkOSMenu::FindSwitchState(evt, "Palette", &fPaletteVisible)) {
            fPalette->setVisibleP(fPaletteVisible);
            return true;
        }
        return this->INHERITED::onEvent(evt);
    }

    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
        return new Click(this);
    }

    virtual bool onClick(SkView::Click* click) {
        switch (click->fState) {
            case SkView::Click::kDown_State:
                fCurrLine.moveTo(click->fCurr);
                fType = SkSocket::kPipeReplace_type;
                if (fSocket)
                    fSocket->resumeWrite();
                break;
            case SkView::Click::kMoved_State:
                fCurrLine.lineTo(click->fCurr);
                break;
            case SkView::Click::kUp_State:
                fType = SkSocket::kPipeAppend_type;
                break;
            default:
                break;
        }
        return true;
    }

    virtual void onDrawContent(SkCanvas* canvas) {
        if (fSocket) {
            if (fSocket->isConnected()) {
                if (fSync) {
                    int count = 0;
                    while (fSocket->readPacket(readData, this) > 0 &&
                           count < MAX_READ_PER_FRAME)
                        ++count;
                }
                else
                    fSocket->readPacket(readData, this);
            }
            else
                fSocket->connectToServer();
        }
        size_t bytesRead = 0;
        SkGPipeReader::Status status;
        SkCanvas bufferCanvas(fBase);
        SkCanvas* tempCanvas;
        while (fTotalBytesRead < fData.count()) {
            if (fVector)
                tempCanvas = canvas;
            else
                tempCanvas = &bufferCanvas;
            SkGPipeReader reader(tempCanvas);
            status = reader.playback(fData.begin() + fTotalBytesRead,
                                     fData.count() - fTotalBytesRead,
                                     &bytesRead);
            SkASSERT(SkGPipeReader::kError_Status != status);
            fTotalBytesRead += bytesRead;
        }
        if (fVector)
            fTotalBytesRead = 0;
        else
            canvas->drawBitmap(fBase, 0, 0, NULL);

        size_t totalBytesRead = 0;
        while (totalBytesRead < fBuffer.count()) {
            SkGPipeReader reader(canvas);
            status = reader.playback(fBuffer.begin() + totalBytesRead,
                                     fBuffer.count() - totalBytesRead,
                                     &bytesRead);
            SkASSERT(SkGPipeReader::kError_Status != status);
            totalBytesRead += bytesRead;
        }

        SkNetPipeController controller(canvas);
        SkGPipeWriter writer;
        SkCanvas* writerCanvas = writer.startRecording(&controller,
                                                       SkGPipeWriter::kCrossProcess_Flag);

        //controller.disablePlayback();
        SkPaint p;
        p.setColor(fPalette->getColor());
        p.setStyle(SkPaint::kStroke_Style);
        p.setStrokeWidth(fBrushSize);
        p.setStrokeCap(SkPaint::kRound_Cap);
        p.setStrokeJoin(SkPaint::kRound_Join);
        p.setAntiAlias(fAA);
        p.setPathEffect(new SkCornerPathEffect(55))->unref();
        writerCanvas->drawPath(fCurrLine, p);
        writer.endRecording();

        controller.writeToSocket(fSocket, fType);
        if (fType == SkSocket::kPipeAppend_type && fSocket) {
            fSocket->suspendWrite();
            fCurrLine.reset();
        }

        this->inval(NULL);
    }

    virtual void onSizeChange() {
        this->INHERITED::onSizeChange();
        fPalette->setLoc(this->width()-100, 0);
        fBase.setConfig(SkBitmap::kARGB_8888_Config, this->width(), this->height());
        fBase.allocPixels(NULL);
        this->clearBitmap();
    }

private:
    void clear() {
        fData.reset();
        fBuffer.reset();
        fCurrLine.reset();
        fTotalBytesRead = 0;
        this->clearBitmap();
    }
    void clearBitmap() {
        fTotalBytesRead = 0;
        fBase.eraseColor(fBGColor);
    }
    SkTDArray<char>     fData;
    SkTDArray<char>     fBuffer;
    SkBitmap            fBase;
    SkPath              fCurrLine;
    SkTCPClient*        fSocket;
    SkSocket::DataType  fType;
    SkColorPalette*     fPalette;
    bool                fPaletteVisible;
    size_t              fTotalBytesRead;
    SkScalar            fBrushSize;
    bool                fAA;
    bool                fSync;
    bool                fVector;

    typedef SampleView INHERITED;
};


///////////////////////////////////////////////////////////////////////////////

static SkView* MyFactory() { return new DrawingClientView; }
static SkViewRegister reg(MyFactory);