/**
* Mouse / Pen up / touch end
*/
void InputSequence::actionEnd(guint32 time)
{
XOJ_CHECK_TYPE(InputSequence);
if (!inputRunning)
{
return;
}
this->eventTime = time;
// Mouse button not pressed anymore
this->button = 0;
current_view = NULL;
GtkXournal* xournal = inputHandler->getXournal();
XournalppCursor* cursor = xournal->view->getCursor();
ToolHandler* h = inputHandler->getToolHandler();
if (xournal->view->getControl()->getWindow()->isGestureActive())
{
stopInput();
return;
}
cursor->setMouseDown(false);
inScrolling = false;
EditSelection* sel = xournal->view->getSelection();
if (sel)
{
sel->mouseUp();
}
if (currentInputPage)
{
PositionInputData pos = getInputDataRelativeToCurrentPage(currentInputPage);
currentInputPage->onButtonReleaseEvent(pos);
currentInputPage = NULL;
}
EditSelection* tmpSelection = xournal->selection;
xournal->selection = NULL;
h->restoreLastConfig();
// we need this workaround so it's possible to select something with the middle button
if (tmpSelection)
{
xournal->view->setSelection(tmpSelection);
}
stopInput();
}
void stop()
{
out.clear();
stopInput(input);
dataLinkStop();
iLoader.clear();
}
void doStopInput()
{
if (inputStopped)
return;
inputStopped = true;
stopInput(input);
}
void endProcess()
{
if (processed & THORDATALINK_STARTED)
{
stopInput(input);
processed |= THORDATALINK_STOPPED;
}
}
virtual void stop()
{
#if THOR_TRACE_LEVEL >= 5
ActPrintLog("CHOOSESETS: stop()");
#endif
stopInput(input);
dataLinkStop();
}
void stop()
{
if (global)
putNext(NULL);
stopInput(input);
input.clear();
dataLinkStop();
}
void CDiskWriteSlaveActivityBase::endProcess()
{
if (processed & THORDATALINK_STARTED)
{
stopInput(input);
processed |= THORDATALINK_STOPPED;
}
}
IRowStream * doLocalSelfJoin()
{
#if THOR_TRACE_LEVEL > 5
ActPrintLog("SELFJOIN: Performing local self-join");
#endif
Owned<IThorRowLoader> iLoader = createThorRowLoader(*this, ::queryRowInterfaces(input), compare, isUnstable() ? stableSort_none : stableSort_earlyAlloc, rc_mixed, SPILL_PRIORITY_SELFJOIN);
Owned<IRowStream> rs = iLoader->load(input, abortSoon);
stopInput(input);
input = NULL;
return rs.getClear();
}
IRowStream * doLocalSelfJoin()
{
#if THOR_TRACE_LEVEL > 5
ActPrintLog("SELFJOIN: Performing local self-join");
#endif
iloader.setown(createThorRowSortedLoader(rows));
bool isempty;
IRowStream *rs = iloader->load(input,::queryRowInterfaces(input), compare, false, abortSoon, isempty, "SELFJOIN", !isUnstable());
stopInput(input);
input = NULL;
return rs;
}
void stop()
{
out.clear();
stopInput(input);
dataLinkStop();
//Critical block
{
CriticalBlock block(statsCs);
mergeStats(spillStats, iLoader);
iLoader.clear();
}
}
InputSequence::~InputSequence()
{
XOJ_CHECK_TYPE(InputSequence);
if (inputRunning)
{
actionEnd(__UINT32_MAX__);
}
clearAxes();
// Make 100% sure there is no input running
stopInput();
XOJ_RELEASE_TYPE(InputSequence);
}
void stop()
{
if (output) {
output->stop();
output.clear();
}
ActPrintLog("SORT waiting barrier.2");
barrier->wait(false);
ActPrintLog("SORT barrier.2 raised");
if (input)
stopInput(input);
sorter->stopMerge();
ActPrintLog("SORT waiting for merge");
dataLinkStop();
}
IRowStream * doGlobalSelfJoin()
{
#if THOR_TRACE_LEVEL > 5
ActPrintLog("SELFJOIN: Performing global self-join");
#endif
sorter->Gather(::queryRowInterfaces(input), input, compare, NULL, NULL, keyserializer, NULL, false, isUnstable(), abortSoon, NULL);
stopInput(input);
input = NULL;
if(abortSoon)
{
barrier->cancel();
return NULL;
}
if (!barrier->wait(false)) {
Sleep(1000); // let original error through
throw MakeThorException(TE_BarrierAborted,"SELFJOIN: Barrier Aborted");
}
rowcount_t totalrows;
return sorter->startMerge(totalrows);
}
virtual void stop()
{
if (input)
{
stopInput(input);
input = NULL;
}
if(!isLocal)
{
barrier->wait(false);
sorter->stopMerge();
}
{
CriticalBlock b(joinHelperCrit);
joinhelper.clear();
}
strm->stop();
strm.clear();
dataLinkStop();
}
virtual void stop()
{
stopInput(input);
dataLinkStop();
}
status_t BnAudioPolicyService::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch (code) {
case SET_DEVICE_CONNECTION_STATE: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_devices_t device =
static_cast <audio_devices_t>(data.readInt32());
audio_policy_dev_state_t state =
static_cast <audio_policy_dev_state_t>(data.readInt32());
const char *device_address = data.readCString();
reply->writeInt32(static_cast<uint32_t> (setDeviceConnectionState(device,
state,
device_address)));
return NO_ERROR;
} break;
case GET_DEVICE_CONNECTION_STATE: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_devices_t device =
static_cast<audio_devices_t> (data.readInt32());
const char *device_address = data.readCString();
reply->writeInt32(static_cast<uint32_t> (getDeviceConnectionState(device,
device_address)));
return NO_ERROR;
} break;
case SET_PHONE_STATE: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
reply->writeInt32(static_cast <uint32_t>(setPhoneState(
(audio_mode_t) data.readInt32())));
return NO_ERROR;
} break;
case SET_FORCE_USE: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(
data.readInt32());
audio_policy_forced_cfg_t config =
static_cast <audio_policy_forced_cfg_t>(data.readInt32());
reply->writeInt32(static_cast <uint32_t>(setForceUse(usage, config)));
return NO_ERROR;
} break;
case GET_FORCE_USE: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(
data.readInt32());
reply->writeInt32(static_cast <uint32_t>(getForceUse(usage)));
return NO_ERROR;
} break;
case GET_OUTPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream =
static_cast <audio_stream_type_t>(data.readInt32());
uint32_t samplingRate = data.readInt32();
audio_format_t format = (audio_format_t) data.readInt32();
audio_channel_mask_t channelMask = data.readInt32();
audio_output_flags_t flags =
static_cast <audio_output_flags_t>(data.readInt32());
audio_io_handle_t output = getOutput(stream,
samplingRate,
format,
channelMask,
flags);
reply->writeInt32(static_cast <int>(output));
return NO_ERROR;
} break;
case START_OUTPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32());
uint32_t stream = data.readInt32();
int session = data.readInt32();
reply->writeInt32(static_cast <uint32_t>(startOutput(output,
(audio_stream_type_t)stream,
session)));
return NO_ERROR;
} break;
case STOP_OUTPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32());
uint32_t stream = data.readInt32();
int session = data.readInt32();
reply->writeInt32(static_cast <uint32_t>(stopOutput(output,
(audio_stream_type_t)stream,
session)));
return NO_ERROR;
} break;
case RELEASE_OUTPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32());
releaseOutput(output);
return NO_ERROR;
} break;
case GET_INPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_source_t inputSource = (audio_source_t) data.readInt32();
uint32_t samplingRate = data.readInt32();
audio_format_t format = (audio_format_t) data.readInt32();
audio_channel_mask_t channelMask = data.readInt32();
int audioSession = data.readInt32();
audio_io_handle_t input = getInput(inputSource,
samplingRate,
format,
channelMask,
audioSession);
reply->writeInt32(static_cast <int>(input));
return NO_ERROR;
} break;
case START_INPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32());
reply->writeInt32(static_cast <uint32_t>(startInput(input)));
return NO_ERROR;
} break;
case STOP_INPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32());
reply->writeInt32(static_cast <uint32_t>(stopInput(input)));
return NO_ERROR;
} break;
case RELEASE_INPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32());
releaseInput(input);
return NO_ERROR;
} break;
case INIT_STREAM_VOLUME: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream =
static_cast <audio_stream_type_t>(data.readInt32());
int indexMin = data.readInt32();
int indexMax = data.readInt32();
reply->writeInt32(static_cast <uint32_t>(initStreamVolume(stream, indexMin,indexMax)));
return NO_ERROR;
} break;
case SET_STREAM_VOLUME: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream =
static_cast <audio_stream_type_t>(data.readInt32());
int index = data.readInt32();
audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
reply->writeInt32(static_cast <uint32_t>(setStreamVolumeIndex(stream,
index,
device)));
return NO_ERROR;
} break;
case GET_STREAM_VOLUME: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream =
static_cast <audio_stream_type_t>(data.readInt32());
audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
int index;
status_t status = getStreamVolumeIndex(stream, &index, device);
reply->writeInt32(index);
reply->writeInt32(static_cast <uint32_t>(status));
return NO_ERROR;
} break;
case GET_STRATEGY_FOR_STREAM: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream =
static_cast <audio_stream_type_t>(data.readInt32());
reply->writeInt32(getStrategyForStream(stream));
return NO_ERROR;
} break;
case GET_DEVICES_FOR_STREAM: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream =
static_cast <audio_stream_type_t>(data.readInt32());
reply->writeInt32(static_cast <int>(getDevicesForStream(stream)));
return NO_ERROR;
} break;
case GET_OUTPUT_FOR_EFFECT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
effect_descriptor_t desc;
data.read(&desc, sizeof(effect_descriptor_t));
audio_io_handle_t output = getOutputForEffect(&desc);
reply->writeInt32(static_cast <int>(output));
return NO_ERROR;
} break;
case REGISTER_EFFECT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
effect_descriptor_t desc;
data.read(&desc, sizeof(effect_descriptor_t));
audio_io_handle_t io = data.readInt32();
uint32_t strategy = data.readInt32();
int session = data.readInt32();
int id = data.readInt32();
reply->writeInt32(static_cast <int32_t>(registerEffect(&desc,
io,
strategy,
session,
id)));
return NO_ERROR;
} break;
case UNREGISTER_EFFECT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
int id = data.readInt32();
reply->writeInt32(static_cast <int32_t>(unregisterEffect(id)));
return NO_ERROR;
} break;
case SET_EFFECT_ENABLED: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
int id = data.readInt32();
bool enabled = static_cast <bool>(data.readInt32());
reply->writeInt32(static_cast <int32_t>(setEffectEnabled(id, enabled)));
return NO_ERROR;
} break;
case IS_STREAM_ACTIVE: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream = (audio_stream_type_t) data.readInt32();
uint32_t inPastMs = (uint32_t)data.readInt32();
reply->writeInt32( isStreamActive((audio_stream_type_t) stream, inPastMs) );
return NO_ERROR;
} break;
case IS_STREAM_ACTIVE_REMOTELY: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream = (audio_stream_type_t) data.readInt32();
uint32_t inPastMs = (uint32_t)data.readInt32();
reply->writeInt32( isStreamActiveRemotely((audio_stream_type_t) stream, inPastMs) );
return NO_ERROR;
} break;
case IS_SOURCE_ACTIVE: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_source_t source = (audio_source_t) data.readInt32();
reply->writeInt32( isSourceActive(source));
return NO_ERROR;
}
case QUERY_DEFAULT_PRE_PROCESSING: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
int audioSession = data.readInt32();
uint32_t count = data.readInt32();
uint32_t retCount = count;
effect_descriptor_t *descriptors =
(effect_descriptor_t *)new char[count * sizeof(effect_descriptor_t)];
status_t status = queryDefaultPreProcessing(audioSession, descriptors, &retCount);
reply->writeInt32(status);
if (status != NO_ERROR && status != NO_MEMORY) {
retCount = 0;
}
reply->writeInt32(retCount);
if (retCount) {
if (retCount < count) {
count = retCount;
}
reply->write(descriptors, sizeof(effect_descriptor_t) * count);
}
delete[] descriptors;
return status;
}
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
virtual void stop() override
{
stopInput(getDataLinkCount());
}
void start()
{
ActivityTimer s(totalCycles, timeActivities);
input = inputs.item(0);
try
{
try {
startInput(input);
}
catch (IException *e)
{
fireException(e);
barrier->cancel();
throw;
}
catch (CATCHALL)
{
Owned<IException> e = MakeActivityException(this, 0, "Unknown exception starting sort input");
fireException(e);
barrier->cancel();
throw;
}
dataLinkStart();
Linked<IRowInterfaces> rowif = queryRowInterfaces(input);
Owned<IRowInterfaces> auxrowif = createRowInterfaces(helper->querySortedRecordSize(),queryActivityId(),queryCodeContext());
sorter->Gather(
rowif,
input,
helper->queryCompare(),
helper->queryCompareLeftRight(),
NULL,helper->querySerialize(),
NULL,
false,
isUnstable(),
abortSoon,
auxrowif);
stopInput(input);
input = NULL;
if (abortSoon)
{
ActPrintLogEx(&queryContainer(), thorlog_null, MCwarning, "MSortSlaveActivity::start aborting");
barrier->cancel();
return;
}
}
catch (IException *e)
{
fireException(e);
barrier->cancel();
throw;
}
catch (CATCHALL)
{
Owned<IException> e = MakeActivityException(this, 0, "Unknown exception gathering sort input");
fireException(e);
barrier->cancel();
throw;
}
ActPrintLog("SORT waiting barrier.1");
if (!barrier->wait(false)) {
Sleep(1000); // let original error through
throw MakeThorException(TE_BarrierAborted,"SORT: Barrier Aborted");
}
ActPrintLog("SORT barrier.1 raised");
output.setown(sorter->startMerge(totalrows));
}
virtual void process()
{
startInput(inputs.item(0));
stopInput(inputs.item(0));
}
virtual void stop()
{
stopInput(inputs.item(0));
dataLinkStop();
}
FCDInput::~FCDInput()
{
stopInput();
}
void stop()
{
stopInput(getDataLinkCount());
dataLinkStop();
}
void doStopInput()
{
stopInput(0);
abortSoon = true;
}
virtual void doStopInput()
{
stopInput(input);
}
void stop()
{
dataLinkStop();
stopInput(input);
}
