/**
* @brief Rewind file and re-read it.
*/
void DotfileHandler::Read(FILE* file)
{
char buf[500];
rewind(file);
while (fgets(buf, sizeof(buf), file))
AppendLine(buf);
}
BOOL CCrystalTextBuffer::InternalDeleteText(CCrystalTextView *pSource, int nStartLine, int nStartChar, int nEndLine, int nEndChar)
{
ASSERT(m_bInit); // Text buffer not yet initialized.
// You must call InitNew() or LoadFromFile() first!
ASSERT(nStartLine >= 0 && nStartLine < m_aLines.GetSize());
ASSERT(nStartChar >= 0 && nStartChar <= m_aLines[nStartLine].m_nLength);
ASSERT(nEndLine >= 0 && nEndLine < m_aLines.GetSize());
ASSERT(nEndChar >= 0 && nEndChar <= m_aLines[nEndLine].m_nLength);
ASSERT(nStartLine < nEndLine || nStartLine == nEndLine && nStartChar < nEndChar);
if (m_bReadOnly)
return FALSE;
CDeleteContext context;
context.m_ptStart.y = nStartLine;
context.m_ptStart.x = nStartChar;
context.m_ptEnd.y = nEndLine;
context.m_ptEnd.x = nEndChar;
if (nStartLine == nEndLine)
{
SLineInfo &li = m_aLines[nStartLine];
if (nEndChar < li.m_nLength)
{
memcpy(li.m_pcLine + nStartChar, li.m_pcLine + nEndChar,
sizeof(TCHAR) * (li.m_nLength - nEndChar));
}
li.m_nLength -= (nEndChar - nStartChar);
UpdateViews(pSource, &context, UPDATE_SINGLELINE | UPDATE_HORZRANGE, nStartLine);
}
else
{
int nRestCount = m_aLines[nEndLine].m_nLength - nEndChar;
LPTSTR pszRestChars = NULL;
if (nRestCount > 0)
{
pszRestChars = new TCHAR[nRestCount];
memcpy(pszRestChars, m_aLines[nEndLine].m_pcLine + nEndChar, nRestCount * sizeof(TCHAR));
}
int nDelCount = nEndLine - nStartLine;
for (int L = nStartLine + 1; L <= nEndLine; L ++)
delete m_aLines[L].m_pcLine;
m_aLines.RemoveAt(nStartLine + 1, nDelCount);
// nEndLine is no more valid
m_aLines[nStartLine].m_nLength = nStartChar;
if (nRestCount > 0)
{
AppendLine(nStartLine, pszRestChars, nRestCount);
delete pszRestChars;
}
UpdateViews(pSource, &context, UPDATE_HORZRANGE | UPDATE_VERTRANGE, nStartLine);
}
if (! m_bModified)
SetModified(TRUE);
return TRUE;
}
void
CMsWin32Editbox::AppendLines( TStringVector& lines )
{GUCEF_TRACE;
TStringVector::iterator i = lines.begin();
while ( i != lines.end() )
{
AppendLine( (*i) );
++i;
}
}
void AsyncExeCmd::PrintOutput()
{
wxString data, errors;
m_proc->HasInput(data, errors);
if(!data.IsEmpty()){
wxStringTokenizer tt(data, wxT("\n"));
while(tt.HasMoreTokens()){
AppendLine(tt.NextToken() + wxT("\n"));
}
}
if(!errors.IsEmpty()){
wxStringTokenizer tt(errors, wxT("\n"));
while(tt.HasMoreTokens()){
AppendLine(tt.NextToken() + wxT("\n"));
}
}
data.Clear();
errors.Clear();
}
// static
void SkPDFUtils::EmitPath(const SkPath& path, SkWStream* content) {
SkPoint args[4];
SkPath::Iter iter(path, false);
for (SkPath::Verb verb = iter.next(args);
verb != SkPath::kDone_Verb;
verb = iter.next(args)) {
// args gets all the points, even the implicit first point.
switch (verb) {
case SkPath::kMove_Verb:
MoveTo(args[0].fX, args[0].fY, content);
break;
case SkPath::kLine_Verb:
AppendLine(args[1].fX, args[1].fY, content);
break;
case SkPath::kQuad_Verb: {
// Convert quad to cubic (degree elevation). http://goo.gl/vS4i
const SkScalar three = SkIntToScalar(3);
args[1].scale(SkIntToScalar(2));
SkScalar ctl1X = SkScalarDiv(args[0].fX + args[1].fX, three);
SkScalar ctl1Y = SkScalarDiv(args[0].fY + args[1].fY, three);
SkScalar ctl2X = SkScalarDiv(args[2].fX + args[1].fX, three);
SkScalar ctl2Y = SkScalarDiv(args[2].fY + args[1].fY, three);
AppendCubic(ctl1X, ctl1Y, ctl2X, ctl2Y, args[2].fX, args[2].fY,
content);
break;
}
case SkPath::kCubic_Verb:
AppendCubic(args[1].fX, args[1].fY, args[2].fX, args[2].fY,
args[3].fX, args[3].fY, content);
break;
case SkPath::kClose_Verb:
ClosePath(content);
break;
case SkPath::kDone_Verb:
break;
default:
SkASSERT(false);
break;
}
}
}
void CppCheckReportPage::PrintStatusMessage()
{
wxString statusLine;
sErrorCount = 0;
wxString text = m_stc->GetText();
wxArrayString lines = ::wxStringTokenize(text, "\n", wxTOKEN_RET_EMPTY_ALL);
static wxRegEx gccPattern(wxT("^([^ ][a-zA-Z:]{0,2}[ a-zA-Z\\.0-9_/\\+\\-]+ *)(:)([0-9]*)(:)([a-zA-Z ]*)"));
for(size_t i = 0; i < lines.GetCount(); ++i) {
if(gccPattern.Matches(lines.Item(i))) {
m_stc->MarkerAdd(i, CPPCHECK_ERROR_MARKER);
++sErrorCount;
}
}
statusLine << wxT("===== ");
statusLine << _("cppcheck analysis ended. Found ") << sErrorCount << _(" possible errors");
statusLine << wxT("=====");
AppendLine(statusLine);
SetMessage(_("Done"));
}
// do the actual cleanup
void CompileRequest::Process(IManager* manager)
{
wxString cmd;
wxString errMsg;
wxStringMap_t om;
BuildSettingsConfig* bsc(manager ? manager->GetBuildSettingsConfigManager() : BuildSettingsConfigST::Get());
BuildManager* bm(manager ? manager->GetBuildManager() : BuildManagerST::Get());
clCxxWorkspace* w(manager ? manager->GetWorkspace() : clCxxWorkspaceST::Get());
EnvironmentConfig* env(manager ? manager->GetEnv() : EnvironmentConfig::Instance());
ProjectPtr proj = w->FindProjectByName(m_info.GetProject(), errMsg);
if(!proj) {
AppendLine(_("Cant find project: ") + m_info.GetProject());
return;
}
wxString pname(proj->GetName());
// BuilderPtr builder = bm->GetBuilder(wxT("GNU makefile for g++/gcc"));
BuilderPtr builder = bm->GetSelectedBuilder();
if(m_fileName.IsEmpty() == false) {
// we got a complie request of a single file
cmd = m_preprocessOnly ?
builder->GetPreprocessFileCmd(m_info.GetProject(), m_info.GetConfiguration(), m_fileName, errMsg) :
builder->GetSingleFileCmd(m_info.GetProject(), m_info.GetConfiguration(), m_fileName);
} else if(m_info.GetProjectOnly()) {
switch(m_info.GetKind()) {
case QueueCommand::kRebuild:
cmd = builder->GetPORebuildCommand(m_info.GetProject(), m_info.GetConfiguration());
break;
default:
case QueueCommand::kBuild:
cmd = builder->GetPOBuildCommand(m_info.GetProject(), m_info.GetConfiguration());
break;
}
} else {
cmd = builder->GetBuildCommand(m_info.GetProject(), m_info.GetConfiguration());
}
// Notify plugins that a compile process is going to start
clBuildEvent event(wxEVT_BUILD_STARTING);
event.SetProjectName(pname);
event.SetConfigurationName(m_info.GetConfiguration());
if(EventNotifier::Get()->ProcessEvent(event)) {
// the build is being handled by some plugin, no need to build it
// using the standard way
return;
}
// Send the EVENT_STARTED : even if this event is sent, next event will
// be post, so no way to be sure the the build process has not started
SendStartMsg();
// if we require to run the makefile generation command only, replace the 'cmd' with the
// generation command line
BuildConfigPtr bldConf = w->GetProjBuildConf(m_info.GetProject(), m_info.GetConfiguration());
if(m_premakeOnly && bldConf) {
BuildConfigPtr bldConf = w->GetProjBuildConf(m_info.GetProject(), m_info.GetConfiguration());
if(bldConf) {
cmd = bldConf->GetMakeGenerationCommand();
}
}
if(bldConf) {
wxString cmpType = bldConf->GetCompilerType();
CompilerPtr cmp = bsc->GetCompiler(cmpType);
if(cmp) {
// Add the 'bin' folder of the compiler to the PATH environment variable
wxString scxx = cmp->GetTool("CXX");
scxx.Trim().Trim(false);
scxx.StartsWith("\"", &scxx);
scxx.EndsWith("\"", &scxx);
// Strip the double quotes
wxFileName cxx(scxx);
wxString pathvar;
pathvar << cxx.GetPath() << clPATH_SEPARATOR;
// If we have an additional path, add it as well
if(!cmp->GetPathVariable().IsEmpty()) {
pathvar << cmp->GetPathVariable() << clPATH_SEPARATOR;
}
pathvar << "$PATH";
om["PATH"] = pathvar;
}
}
if(cmd.IsEmpty()) {
// if we got an error string, use it
if(errMsg.IsEmpty() == false) {
AppendLine(errMsg);
} else {
AppendLine(_("Command line is empty. Build aborted."));
}
return;
}
WrapInShell(cmd);
DirSaver ds;
DoSetWorkingDirectory(proj, false, m_fileName.IsEmpty() == false);
// expand the variables of the command
cmd = ExpandAllVariables(cmd, w, m_info.GetProject(), m_info.GetConfiguration(), m_fileName);
// print the build command
AppendLine(cmd + wxT("\n"));
if(m_info.GetProjectOnly() || m_fileName.IsEmpty() == false) {
// set working directory
DoSetWorkingDirectory(proj, false, m_fileName.IsEmpty() == false);
}
// print the prefix message of the build start. This is important since the parser relies
// on this message
if(m_info.GetProjectOnly() || m_fileName.IsEmpty() == false) {
wxString configName(m_info.GetConfiguration());
// also, send another message to the main frame, indicating which project is being built
// and what configuration
wxString text;
text << wxGetTranslation(BUILD_PROJECT_PREFIX) << m_info.GetProject() << wxT(" - ") << configName << wxT(" ]");
if(m_fileName.IsEmpty()) {
text << wxT("----------\n");
} else if(m_preprocessOnly) {
text << wxT(" (Preprocess Single File)----------\n");
} else {
text << wxT(" (Single File Build)----------\n");
}
AppendLine(text);
}
EnvSetter envir(env, &om, proj->GetName());
m_proc = CreateAsyncProcess(this, cmd);
if(!m_proc) {
wxString message;
message << _("Failed to start build process, command: ") << cmd << _(", process terminated with exit code: 0");
AppendLine(message);
return;
}
}
BOOL CCrystalTextBuffer::InternalInsertText(CCrystalTextView *pSource, int nLine, int nPos, LPCTSTR pszText, int &nEndLine, int &nEndChar)
{
ASSERT(m_bInit); // Text buffer not yet initialized.
// You must call InitNew() or LoadFromFile() first!
// ASSERT(nLine >= 0 && nLine < m_aLines.GetSize());
// ASSERT(nPos >= 0 && nPos <= m_aLines[nLine].m_nLength);
if (m_bReadOnly)
return FALSE;
CInsertContext context;
context.m_ptStart.x = nPos;
context.m_ptStart.y = nLine;
int nRestCount = m_aLines[nLine].m_nLength - nPos;
LPTSTR pszRestChars = NULL;
if (nRestCount > 0)
{
pszRestChars = new TCHAR[nRestCount];
memcpy(pszRestChars, m_aLines[nLine].m_pcLine + nPos, nRestCount * sizeof(TCHAR));
m_aLines[nLine].m_nLength = nPos;
}
int nCurrentLine = nLine;
BOOL bNewLines = FALSE;
int nTextPos;
for (;;)
{
nTextPos = 0;
while (pszText[nTextPos] != 0 && pszText[nTextPos] != _T('\r'))
nTextPos ++;
if (nCurrentLine == nLine)
{
AppendLine(nLine, pszText, nTextPos);
}
else
{
InsertLine(pszText, nTextPos, nCurrentLine);
bNewLines = TRUE;
}
if (pszText[nTextPos] == 0)
{
nEndLine = nCurrentLine;
nEndChar = m_aLines[nCurrentLine].m_nLength;
AppendLine(nCurrentLine, pszRestChars, nRestCount);
break;
}
nCurrentLine ++;
nTextPos ++;
if (pszText[nTextPos] == _T('\n'))
{
nTextPos ++;
}
else
{
ASSERT(FALSE); // Invalid line-end format passed
}
pszText += nTextPos;
}
if (pszRestChars != NULL)
delete pszRestChars;
context.m_ptEnd.x = nEndChar;
context.m_ptEnd.y = nEndLine;
if (bNewLines)
UpdateViews(pSource, &context, UPDATE_HORZRANGE | UPDATE_VERTRANGE, nLine);
else
UpdateViews(pSource, &context, UPDATE_SINGLELINE | UPDATE_HORZRANGE, nLine);
if (! m_bModified)
SetModified(TRUE);
return TRUE;
}
//do the actual cleanup
void CleanRequest::Process(IManager *manager)
{
wxString cmd;
wxString errMsg;
wxStringMap_t om;
BuildSettingsConfig *bsc(manager ? manager->GetBuildSettingsConfigManager() : BuildSettingsConfigST::Get());
BuildManager * bm(manager ? manager->GetBuildManager() : BuildManagerST::Get());
Workspace * w(manager ? manager->GetWorkspace() : WorkspaceST::Get());
ProjectPtr proj = w->FindProjectByName(m_info.GetProject(), errMsg);
if (!proj) {
AppendLine(_("Cant find project: ") + m_info.GetProject());
return;
}
wxString pname (proj->GetName());
//BuilderPtr builder = bm->GetBuilder(wxT("GNU makefile for g++/gcc"));
BuilderPtr builder = bm->GetSelectedBuilder();
if (m_info.GetProjectOnly()) {
cmd = builder->GetPOCleanCommand(m_info.GetProject(), m_info.GetConfiguration());
} else {
cmd = builder->GetCleanCommand(m_info.GetProject(), m_info.GetConfiguration());
}
if ( cmd.IsEmpty() ) {
AppendLine(_("Sorry, there is no 'Clean' command available\n"));
return;
}
BuildConfigPtr bldConf = w->GetProjBuildConf(m_info.GetProject(), m_info.GetConfiguration());
if(bldConf) {
wxString cmpType = bldConf->GetCompilerType();
CompilerPtr cmp = bsc->GetCompiler(cmpType);
if(cmp) {
wxString value( cmp->GetPathVariable() );
if(value.Trim().Trim(false).IsEmpty() == false) {
wxLogMessage(wxString::Format(wxT("Setting PATH to '%s'"), value.c_str()));
om[wxT("PATH")] = value.Trim().Trim(false);
}
}
} else {
AppendLine(_("Sorry, couldn't find the Build configuration\n"));
return;
}
// Notify plugins that a compile process is going to start
clBuildEvent event(wxEVT_BUILD_STARTING);
event.SetProjectName( pname );
event.SetConfigurationName( m_info.GetConfiguration() );
if (EventNotifier::Get()->ProcessEvent(event)) {
// the build is being handled by some plugin, no need to build it
// using the standard way
return;
}
SendStartMsg();
// Expand the variables of the command
cmd = ExpandAllVariables(cmd, w, m_info.GetProject(), m_info.GetConfiguration(), wxEmptyString);
WrapInShell(cmd);
DirSaver ds;
DoSetWorkingDirectory(proj, false, false);
if (m_info.GetProjectOnly() ) {
//need to change directory to project dir
wxSetWorkingDirectory(proj->GetFileName().GetPath());
}
//print the build command
AppendLine(cmd + wxT("\n"));
// print the prefix message of the build start. This is important since the parser relies
// on this message
if(m_info.GetProjectOnly()) {
wxString configName(m_info.GetConfiguration());
//also, send another message to the main frame, indicating which project is being built
//and what configuration
wxString text;
text << wxGetTranslation(CLEAN_PROJECT_PREFIX) << m_info.GetProject() << wxT(" - ") << configName << wxT(" ]");
text << wxT("----------\n");
AppendLine(text);
}
//apply environment settings
EnvSetter env(NULL, &om, proj->GetName());
m_proc = CreateAsyncProcess(this, cmd);
if ( !m_proc ) {
//remove environment settings applied
wxString message;
message << _("Failed to start clean process, command: ") << cmd << _(", process terminated with exit code: 0");
AppendLine(message);
return;
}
}
void ConsoleLog::Print(int level, LPCSTR str) {
if (hConsole != nullptr) {
Print(level, str, strlen(str));
AppendLine();
}
}
void ConsoleLog::WriteLine(LPCSTR str) {
Write(str);
AppendLine();
}
void CustomBuildRequest::Process(IManager* manager)
{
wxString cmd;
wxString errMsg;
wxStringMap_t om;
clCxxWorkspace* w(manager->GetWorkspace());
EnvironmentConfig* env(manager->GetEnv());
ProjectPtr proj = w->FindProjectByName(m_info.GetProject(), errMsg);
if(!proj) {
AppendLine(_("Cant find project: ") + m_info.GetProject());
return;
}
// Notify plugins that a compile process is going to start
clBuildEvent event(wxEVT_BUILD_STARTING);
event.SetProjectName(proj->GetName());
event.SetConfigurationName(m_info.GetConfiguration());
if(EventNotifier::Get()->ProcessEvent(event)) {
// the build is being handled by some plugin, no need to build it
// using the standard way
return;
}
SendStartMsg();
BuildConfigPtr bldConf = w->GetProjBuildConf(m_info.GetProject(), m_info.GetConfiguration());
if(!bldConf) {
wxLogMessage(wxString::Format(wxT("Failed to find build configuration for project '%s' and configuration '%s'"),
m_info.GetProject().c_str(),
m_info.GetConfiguration().c_str()));
return;
}
// try the special targets first:
bool isClean(false);
if(m_info.GetCustomBuildTarget() == wxT("Build")) {
cmd = bldConf->GetCustomBuildCmd();
} else if(m_info.GetCustomBuildTarget() == wxT("Clean")) {
cmd = bldConf->GetCustomCleanCmd();
isClean = true;
} else if(m_info.GetCustomBuildTarget() == wxT("Rebuild")) {
cmd = bldConf->GetCustomRebuildCmd();
} else if(m_info.GetCustomBuildTarget() == wxT("Compile Single File")) {
cmd = bldConf->GetSingleFileBuildCommand();
} else if(m_info.GetCustomBuildTarget() == wxT("Preprocess File")) {
cmd = bldConf->GetPreprocessFileCommand();
}
// if still no luck, try with the other custom targets
if(cmd.IsEmpty()) {
std::map<wxString, wxString> targets = bldConf->GetCustomTargets();
std::map<wxString, wxString>::iterator iter = targets.find(m_info.GetCustomBuildTarget());
if(iter != targets.end()) {
cmd = iter->second;
}
}
if(cmd.IsEmpty()) {
// if we got an error string, use it
if(errMsg.IsEmpty() == false) {
AppendLine(errMsg);
} else {
AppendLine(_("Command line is empty. Build aborted."));
}
return;
}
// Working directory:
// By default we use the project path
//////////////////////////////////////////////////////
DirSaver ds;
// first set the path to the project working directory
::wxSetWorkingDirectory(proj->GetFileName().GetPath());
// If a working directory was specified, use it instead
wxString wd = bldConf->GetCustomBuildWorkingDir();
wd.Trim().Trim(false);
wxString filename;
if(manager->GetActiveEditor()) {
filename = manager->GetActiveEditor()->GetFileName().GetFullPath();
}
if(wd.IsEmpty()) {
// use the project path
wd = proj->GetFileName().GetPath();
} else {
// expand macros from the working directory
wd = ExpandAllVariables(wd, clCxxWorkspaceST::Get(), proj->GetName(), bldConf->GetName(), filename);
}
{
// Ensure that the path to the working directory exist
wxFileName fnwd(wd, "");
if(!fnwd.DirExists()) {
fnwd.Mkdir(wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL);
}
}
::wxSetWorkingDirectory(wd);
// Print message to the build tab
AppendLine(wxString::Format(_("MESSAGE: Entering directory `%s'\n"), wd.c_str()));
// Command handling:
//////////////////////////////////////////////////////
// expand the variables of the command
cmd = ExpandAllVariables(cmd, w, m_info.GetProject(), m_info.GetConfiguration(), filename);
// in case our configuration includes post/pre build commands
// we generate a makefile to include them as well and we update
// the build command
bool bCommandAltered = DoUpdateCommand(manager, cmd, proj, bldConf, isClean);
#ifdef __WXMSW__
// Windows CD command requires the paths to be backslashe
if(cmd.Find(wxT("cd ")) != wxNOT_FOUND) cmd.Replace(wxT("/"), wxT("\\"));
#endif
// Wrap the build command in the shell, so it will be able
// to perform 'chain' commands like
// cd SOMEWHERE && make && ...
// Dont wrap the command if it was altered previously
if(!bCommandAltered) {
WrapInShell(cmd);
}
// print the build command
AppendLine(cmd + wxT("\n"));
wxString configName(m_info.GetConfiguration());
// also, send another message to the main frame, indicating which project is being built
// and what configuration
wxString text;
if(isClean) {
text << wxGetTranslation(CLEAN_PROJECT_PREFIX);
} else {
text << wxGetTranslation(BUILD_PROJECT_PREFIX);
}
text << m_info.GetProject() << wxT(" - ") << configName << wxT(" ]----------\n");
AppendLine(text);
// Avoid Unicode chars coming from the compiler by setting LC_ALL to "C"
om["LC_ALL"] = "C";
EnvSetter environment(env, &om, proj->GetName());
m_proc = CreateAsyncProcess(this, cmd);
if(!m_proc) {
wxString message;
message << _("Failed to start build process, command: ") << cmd << _(", process terminated with exit code: 0");
AppendLine(message);
return;
}
}
// static
void SkPDFUtils::EmitPath(const SkPath& path, SkPaint::Style paintStyle,
SkWStream* content) {
// Filling a path with no area results in a drawing in PDF renderers but
// Chrome expects to be able to draw some such entities with no visible
// result, so we detect those cases and discard the drawing for them.
// Specifically: moveTo(X), lineTo(Y) and moveTo(X), lineTo(X), lineTo(Y).
enum SkipFillState {
kEmpty_SkipFillState = 0,
kSingleLine_SkipFillState = 1,
kNonSingleLine_SkipFillState = 2,
};
SkipFillState fillState = kEmpty_SkipFillState;
if (paintStyle != SkPaint::kFill_Style) {
fillState = kNonSingleLine_SkipFillState;
}
SkPoint lastMovePt = SkPoint::Make(0,0);
SkDynamicMemoryWStream currentSegment;
SkPoint args[4];
SkPath::Iter iter(path, false);
for (SkPath::Verb verb = iter.next(args);
verb != SkPath::kDone_Verb;
verb = iter.next(args)) {
// args gets all the points, even the implicit first point.
switch (verb) {
case SkPath::kMove_Verb:
MoveTo(args[0].fX, args[0].fY, ¤tSegment);
lastMovePt = args[0];
fillState = kEmpty_SkipFillState;
break;
case SkPath::kLine_Verb:
AppendLine(args[1].fX, args[1].fY, ¤tSegment);
if (fillState == kEmpty_SkipFillState) {
if (args[0] != lastMovePt) {
fillState = kSingleLine_SkipFillState;
}
} else if (fillState == kSingleLine_SkipFillState) {
fillState = kNonSingleLine_SkipFillState;
}
break;
case SkPath::kQuad_Verb: {
SkPoint cubic[4];
SkConvertQuadToCubic(args, cubic);
AppendCubic(cubic[1].fX, cubic[1].fY, cubic[2].fX, cubic[2].fY,
cubic[3].fX, cubic[3].fY, ¤tSegment);
fillState = kNonSingleLine_SkipFillState;
break;
}
case SkPath::kCubic_Verb:
AppendCubic(args[1].fX, args[1].fY, args[2].fX, args[2].fY,
args[3].fX, args[3].fY, ¤tSegment);
fillState = kNonSingleLine_SkipFillState;
break;
case SkPath::kClose_Verb:
if (fillState != kSingleLine_SkipFillState) {
ClosePath(¤tSegment);
SkData* data = currentSegment.copyToData();
content->write(data->data(), data->size());
data->unref();
}
currentSegment.reset();
break;
default:
SkASSERT(false);
break;
}
}
if (currentSegment.bytesWritten() > 0) {
SkData* data = currentSegment.copyToData();
content->write(data->data(), data->size());
data->unref();
}
}
void ShellCommand::DoPrintOutput(const wxString &out)
{
// Write the buffer as-is to the build tab !!
AppendLine(out);
}
void GPlainTextLogger::EventBucketUpdated()
{
if(m_ShouldLogOnUpdate)
AppendLine();
}
void GPlainTextLogger::EventTimerFired()
{
if(m_ShouldLogOnTimer) {
AppendLine();
}
}
