skia2/experimental/DrawingBoard/SampleDrawingClient.cpp
yangsu@google.com ef7bdfac61 Added Debugger to Sample App, off by default
Removed CocoaDebugger from experimental
Slight changes to SkOSMenu
Bug fixes for NetPipeReader and DrawingBoard


git-svn-id: http://skia.googlecode.com/svn/trunk@2102 2bbb7eff-a529-9590-31e7-b0007b416f81
2011-08-12 14:27:47 +00:00

280 lines
9.6 KiB
C++

#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 = SkFloatToScalar(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);