| #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); |