static HRESULT WINAPI BPInternetProtocolSink_ReportResult(IInternetProtocolSink *iface,
HRESULT hrResult, DWORD dwError, LPCWSTR szResult)
{
BindProtocol *This = impl_from_IInternetProtocolSink(iface);
TRACE("(%p)->(%08x %d %s)\n", This, hrResult, dwError, debugstr_w(szResult));
if(!This->protocol_sink)
return E_FAIL;
This->reported_result = TRUE;
if(!do_direct_notif(This)) {
report_result_task_t *task;
task = heap_alloc(sizeof(report_result_task_t));
if(!task)
return E_OUTOFMEMORY;
task->hres = hrResult;
task->err = dwError;
task->str = heap_strdupW(szResult);
push_task(This, &task->header, report_result_proc);
return S_OK;
}
return IInternetProtocolSink_ReportResult(This->protocol_sink_handler, hrResult, dwError, szResult);
}
void set_ready_state(HTMLOuterWindow *window, READYSTATE readystate)
{
READYSTATE prev_state = window->readystate;
window->readystate = readystate;
if(window->readystate_locked) {
readystate_task_t *task;
HRESULT hres;
if(window->readystate_pending || prev_state == readystate)
return;
task = heap_alloc(sizeof(*task));
if(!task)
return;
IHTMLWindow2_AddRef(&window->base.IHTMLWindow2_iface);
task->window = window;
hres = push_task(&task->header, notif_readystate_proc, notif_readystate_destr, window->task_magic);
if(SUCCEEDED(hres))
window->readystate_pending = TRUE;
return;
}
notif_readystate(window);
}
void dispatch(threadpool from_me, dispatch_fn dispatch_to_here, void *arg) {
_threadpool *pool = (_threadpool *) from_me;
if (pool == NULL || dispatch_to_here == NULL) {
printf("Threadpool invalid");
}
struct task *mytask;
mytask = (struct task*) malloc(sizeof(struct task));
if (mytask == NULL) {
printf("No memory allocation");
}
mytask->func = (void*) dispatch_to_here;
mytask->arg = arg;
mypthread_mutex_lock(&(pool->mutex));
if (&(pool->no_of_threads) == &(pool->no_of_tasks_in_Q)) {
printf("threadpool_queue_full");
} else {
push_task(pool, mytask);
if (mypthread_cond_signal(&(pool->cond))) {
printf("threadpool_lock_failure");
}
mypthread_cond_signal(&(pool->cond));
}
if (mypthread_mutex_unlock(&(pool->mutex))) {
printf("not unlock");
}
mypthread_yield();
}
int main(){
int i,j;
task_t* task;
char name[10][10][10];
char sanity[10][10];
struct timespec tv1, tv2;
init_system(2,2);
clock_gettime(CLOCK_MONOTONIC_RAW, &tv1);
for ( i = 0 ; i < 1; i++){
sprintf(sanity[i],"Mytask%d",i);
for ( j = 0 ; j < 10; j++){
task = new_task(hello,"task arg",sizeof(char)*9, my_sanity,"sanity arg",11*sizeof(char),j%2,0);
push_task(task, "main_group");
}
}
// wait_group(char *group, int (*func) (void *), void * args ,
// unsigned int type, unsigned int time_ms, unsigned int
// time_us, float ratio, unsigned int redo);
wait_group("main_group" , big_sanity, sanity[0] , SYNC_RATIO, 0 , 0 , 0.8f, 0) ;
// monte_carlo_pi(1000000);
clock_gettime(CLOCK_MONOTONIC_RAW, &tv2);
printf ("Total time = %10g seconds\n",
(double) (tv2.tv_nsec - tv1.tv_nsec) / 1000000000.0 +
(double) (tv2.tv_sec - tv1.tv_sec));
return 1;
}
bool travel_branch_0_expand(Method_Instance* method, Planner_State& pstate, void* world)
{
p1_state* precondition = plnnr::precondition<p1_state>(method);
travel_args* method_args = plnnr::arguments<travel_args>(method);
Worldstate* wstate = static_cast<Worldstate*>(world);
PLNNR_COROUTINE_BEGIN(*method);
precondition = push_precondition<p1_state>(pstate, method);
precondition->_0 = method_args->_0;
precondition->_1 = method_args->_1;
while (next(*precondition, *wstate))
{
{
Task_Instance* t = push_task(pstate, task_ride_taxi, 0);
ride_taxi_args* a = push_arguments<ride_taxi_args>(pstate, t);
a->_0 = method_args->_0;
a->_1 = method_args->_1;
}
method->flags |= method_flags_expanded;
PLNNR_COROUTINE_YIELD(*method, 1);
}
return expand_next_branch(pstate, travel_branch_1_expand, world);
PLNNR_COROUTINE_END();
}
static HRESULT WINAPI BPInternetProtocolSink_ReportData(IInternetProtocolSink *iface,
DWORD grfBSCF, ULONG ulProgress, ULONG ulProgressMax)
{
BindProtocol *This = impl_from_IInternetProtocolSink(iface);
TRACE("(%p)->(%x %u %u)\n", This, grfBSCF, ulProgress, ulProgressMax);
if(!This->protocol_sink)
return S_OK;
if(!do_direct_notif(This)) {
report_data_task_t *task;
task = heap_alloc(sizeof(report_data_task_t));
if(!task)
return E_OUTOFMEMORY;
task->bscf = grfBSCF;
task->progress = ulProgress;
task->progress_max = ulProgressMax;
push_task(This, &task->header, report_data_proc);
return S_OK;
}
return IInternetProtocolSink_ReportData(This->protocol_sink_handler,
grfBSCF, ulProgress, ulProgressMax);
}
static HRESULT WINAPI BPInternetProtocolSink_Switch(IInternetProtocolSink *iface,
PROTOCOLDATA *pProtocolData)
{
BindProtocol *This = impl_from_IInternetProtocolSink(iface);
PROTOCOLDATA *data;
TRACE("(%p)->(%p)\n", This, pProtocolData);
TRACE("flags %x state %x data %p cb %u\n", pProtocolData->grfFlags, pProtocolData->dwState,
pProtocolData->pData, pProtocolData->cbData);
data = heap_alloc(sizeof(PROTOCOLDATA));
if(!data)
return E_OUTOFMEMORY;
memcpy(data, pProtocolData, sizeof(PROTOCOLDATA));
if((This->pi&PI_APARTMENTTHREADED && pProtocolData->grfFlags&PI_FORCE_ASYNC)
|| !do_direct_notif(This)) {
switch_task_t *task;
task = heap_alloc(sizeof(switch_task_t));
if(!task)
{
heap_free(data);
return E_OUTOFMEMORY;
}
task->data = data;
push_task(This, &task->header, switch_proc);
return S_OK;
}
return IInternetProtocolSink_Switch(This->protocol_sink_handler, data);
}
static nsresult NSAPI handle_load(nsIDOMEventListener *iface, nsIDOMEvent *event)
{
NSContainer *This = NSEVENTLIST_THIS(iface)->This;
nsIDOMHTMLDocument *nshtmldoc;
nsIDOMHTMLElement *nsbody = NULL;
nsIDOMDocument *nsdoc;
task_t *task;
TRACE("(%p)\n", This);
if(!This->doc)
return NS_OK;
connect_scripts(This->doc);
setup_nswindow(This->doc->window);
if(This->editor_controller) {
nsIController_Release(This->editor_controller);
This->editor_controller = NULL;
}
if(This->doc->usermode == EDITMODE)
handle_edit_load(This->doc);
task = heap_alloc(sizeof(task_t));
task->doc = This->doc;
task->task_id = TASK_PARSECOMPLETE;
task->next = NULL;
/*
* This should be done in the worker thread that parses HTML,
* but we don't have such thread (Gecko parses HTML for us).
*/
push_task(task);
nsIWebNavigation_GetDocument(This->navigation, &nsdoc);
nsIDOMDocument_QueryInterface(nsdoc, &IID_nsIDOMHTMLDocument, (void**)&nshtmldoc);
nsIDOMDocument_Release(nsdoc);
nsIDOMHTMLDocument_GetBody(nshtmldoc, &nsbody);
nsIDOMHTMLDocument_Release(nshtmldoc);
if(nsbody) {
fire_event(This->doc, EVENTID_LOAD, (nsIDOMNode*)nsbody);
nsIDOMHTMLElement_Release(nsbody);
}
return NS_OK;
}
bool travel_by_air_branch_0_expand(Method_Instance* method, Planner_State& pstate, void* world)
{
p3_state* precondition = plnnr::precondition<p3_state>(method);
travel_by_air_args* method_args = plnnr::arguments<travel_by_air_args>(method);
Worldstate* wstate = static_cast<Worldstate*>(world);
PLNNR_COROUTINE_BEGIN(*method);
precondition = push_precondition<p3_state>(pstate, method);
precondition->_0 = method_args->_0;
precondition->_2 = method_args->_1;
while (next(*precondition, *wstate))
{
{
Method_Instance* t = push_method(pstate, task_travel, travel_branch_0_expand);
travel_args* a = push_arguments<travel_args>(pstate, t);
a->_0 = method_args->_0;
a->_1 = precondition->_1;
}
PLNNR_COROUTINE_YIELD(*method, 1);
if (method->flags & method_flags_failed)
{
continue;
}
{
Task_Instance* t = push_task(pstate, task_fly, 0);
fly_args* a = push_arguments<fly_args>(pstate, t);
a->_0 = precondition->_1;
a->_1 = precondition->_3;
}
PLNNR_COROUTINE_YIELD(*method, 2);
{
Method_Instance* t = push_method(pstate, task_travel, travel_branch_0_expand);
travel_args* a = push_arguments<travel_args>(pstate, t);
a->_0 = precondition->_3;
a->_1 = method_args->_1;
}
method->flags |= method_flags_expanded;
PLNNR_COROUTINE_YIELD(*method, 3);
}
PLNNR_COROUTINE_END();
}
void handle_accept(
const tcp_connection_ptr& new_connection,
const boost::system::error_code& error)
{
push_task();
if (!error)
{
make_task_wrapped(boost::bind(func_, new_connection))
(); // Running the task
}
else
{
std::cerr << error << '\n';
}
}
void task_manage(void)
{
uint8_t task_index;
for(task_index = 0; task_index < TASK_END; task_index++)
{
if(task_tick[task_index] > 0)
{
task_tick[task_index]--;
if(task_tick[task_index] == 0)
{
push_task(task_index);
}
}
}
run_routine();
}
void gpu_worker(void *arg)
{
hs_worker *worker_arg = (hs_worker *) arg;
bind_to_cpu(worker_arg);
init_cuda(worker_arg->device_id);
// printf("GPU I am id:%d\n", worker_arg->worker_id);
pthread_mutex_lock(&worker_arg->mutex);
worker_arg->initialized = 1;
pthread_cond_signal(&worker_arg->ready);
pthread_mutex_unlock(&worker_arg->mutex);
_task_t task;
while (is_running())
{
lock_queue(worker_arg->task_queue);
task = pop_task(worker_arg->task_queue);
if (task == NULL)
{
if (is_running())
sleep_worker(worker_arg);
unlock_queue(worker_arg->task_queue);
continue;
}
unlock_queue(worker_arg->task_queue);
if ((task->task->arch_type & worker_arg->arch) != worker_arg->arch)
{
push_task(worker_arg->task_queue, task);
continue;
}
execute_task(worker_arg, task);
}
deinit_cuda();
pthread_exit((void*) 0);
}
void ff_distribute_task(Task *tasks, int task_cnt, Processor *processors, int processor_cnt){
Task maxPeriodTask = *(tasks + task_cnt - 1);
Task curTask;
// devide tasks for processors using FF algorithm
for (int i = 0; i < task_cnt; i++){
curTask = *(tasks + i);
//Find first non-empty processor and try to put curTask in it.
for (int j = 0; j < processor_cnt; j++){
Processor p = *(processors + j);
double new_usage = p.usage + (double)curTask.c / (double)curTask.t;
int count = p.task_cnt;
if (rm_schedulable_inner(new_usage, count+1)){
push_task(processors+j, tasks+i);
break;
}
}
}
}
bool vzsdk::VzTcpDeviceManage::Start()
{
// Init logging system
LogMessage::LogTimestamps(true);
LogMessage::LogContext(vzsdk::LS_INFO);
LogMessage::LogThreads(true);
queue_layer_.reset(new QueueLayer());
ASSERT(push_manager_task_ == NULL);
push_thread_.reset(new Thread());
push_manager_task_ = new PushManagerTask(queue_layer_.get(),
push_thread_.get());
// For push manager life live
Task::Ptr push_task(push_manager_task_);
if (queue_layer_->Start()) {
push_manager_task_->SyncProcessTask();
return true;
}
return false;
}
// taylor series for (x)^(-1) for a = 0
int simple_sum()
{
task_t *temp;
int *terms= (int *) calloc((NUM_TERMS+1),sizeof(int));
int i;
terms[0] = 1;
for (i=0; i<NUM_TERMS; ++(i))
{
temp = new_task(sum_elements,&terms[i],sizeof(int), NULL,NULL,0,1,0);
// define_in_dependencies(temp, 1, &terms[i] , sizeof(int));
// define_out_dependencies(temp, 1, &terms[i+1] , sizeof(int));
push_task(temp,"sum");
}
wait_group("sum", NULL, NULL, SYNC_ALL , 0, 0, 1.0, 0);
for (i=0; i<NUM_TERMS+1; ++i)
{
printf("%d \n",terms[i]);
}
return 0;
}
static HRESULT WINAPI BPInternetProtocolSink_ReportProgress(IInternetProtocolSink *iface,
ULONG ulStatusCode, LPCWSTR szStatusText)
{
BindProtocol *This = impl_from_IInternetProtocolSink(iface);
TRACE("(%p)->(%u %s)\n", This, ulStatusCode, debugstr_w(szStatusText));
if(do_direct_notif(This)) {
IInternetProtocolSink_ReportProgress(This->protocol_sink_handler, ulStatusCode, szStatusText);
}else {
on_progress_task_t *task;
task = heap_alloc(sizeof(on_progress_task_t));
task->status_code = ulStatusCode;
task->status_text = heap_strdupW(szStatusText);
push_task(This, &task->header, on_progress_proc);
}
return S_OK;
}
static HRESULT WINAPI BPInternetProtocolSink_Switch(IInternetProtocolSink *iface,
PROTOCOLDATA *pProtocolData)
{
BindProtocol *This = PROTSINK_THIS(iface);
PROTOCOLDATA *data;
TRACE("(%p)->(%p)\n", This, pProtocolData);
TRACE("flags %x state %x data %p cb %u\n", pProtocolData->grfFlags, pProtocolData->dwState,
pProtocolData->pData, pProtocolData->cbData);
data = heap_alloc(sizeof(PROTOCOLDATA));
if(!data)
return E_OUTOFMEMORY;
memcpy(data, pProtocolData, sizeof(PROTOCOLDATA));
if(!do_direct_notif(This)) {
switch_task_t *task;
task = heap_alloc(sizeof(switch_task_t));
if(!task)
return E_OUTOFMEMORY;
task->data = data;
push_task(This, &task->header, switch_proc);
return S_OK;
}
if(!This->protocol_sink) {
IInternetProtocol_Continue(This->protocol_handler, data);
return S_OK;
}
return IInternetProtocolSink_Switch(This->protocol_sink, data);
}
void
erts_port_task_free_port(Port *pp)
{
ErtsRunQueue *runq;
int port_is_dequeued = 0;
ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(pp));
ASSERT(!(pp->status & ERTS_PORT_SFLGS_DEAD));
runq = erts_port_runq(pp);
ASSERT(runq);
ERTS_PT_CHK_PRES_PORTQ(runq, pp);
if (pp->sched.exe_taskq) {
/* I (this thread) am currently executing this port, free it
when scheduled out... */
ErtsPortTask *ptp = port_task_alloc();
erts_smp_port_state_lock(pp);
pp->status &= ~ERTS_PORT_SFLG_CLOSING;
pp->status |= ERTS_PORT_SFLG_FREE_SCHEDULED;
erts_may_save_closed_port(pp);
erts_smp_port_state_unlock(pp);
ERTS_SMP_LC_ASSERT(erts_smp_atomic_read_nob(&pp->refc) > 1);
ptp->type = ERTS_PORT_TASK_FREE;
ptp->event = (ErlDrvEvent) -1;
ptp->event_data = NULL;
set_handle(ptp, NULL);
push_task(pp->sched.exe_taskq, ptp);
ERTS_PT_CHK_PRES_PORTQ(runq, pp);
erts_smp_runq_unlock(runq);
}
else {
ErtsPortTaskQueue *ptqp = pp->sched.taskq;
if (ptqp) {
dequeue_port(runq, pp);
ERTS_PORT_NOT_IN_RUNQ(pp);
port_is_dequeued = 1;
}
erts_smp_port_state_lock(pp);
pp->status &= ~ERTS_PORT_SFLG_CLOSING;
pp->status |= ERTS_PORT_SFLG_FREE_SCHEDULED;
erts_may_save_closed_port(pp);
erts_smp_port_state_unlock(pp);
#ifdef ERTS_SMP
erts_smp_atomic_dec_nob(&pp->refc); /* Not alive */
#endif
ERTS_SMP_LC_ASSERT(erts_smp_atomic_read_nob(&pp->refc) > 0); /* Lock */
handle_remaining_tasks(runq, pp); /* May release runq lock */
ASSERT(!pp->sched.exe_taskq && (!ptqp || !ptqp->first));
pp->sched.taskq = NULL;
ERTS_PT_CHK_PRES_PORTQ(runq, pp);
#ifndef ERTS_SMP
ASSERT(pp->status & ERTS_PORT_SFLG_PORT_DEBUG);
erts_port_status_set(pp, ERTS_PORT_SFLG_FREE);
#endif
erts_smp_runq_unlock(runq);
if (erts_system_profile_flags.runnable_ports && port_is_dequeued) {
profile_runnable_port(pp, am_inactive);
}
if (ptqp)
port_taskq_free(ptqp);
}
}
bool Move_Stack_branch_3_expand(Method_Instance* method, Planner_State& pstate, void* world)
{
p4_state* precondition = plnnr::precondition<p4_state>(method);
Move_Stack_args* method_args = plnnr::arguments<Move_Stack_args>(method);
Worldstate* wstate = static_cast<Worldstate*>(world);
PLNNR_COROUTINE_BEGIN(*method);
precondition = push_precondition<p4_state>(pstate, method);
precondition->_0 = method_args->_0;
precondition->_2 = method_args->_1;
precondition->_3 = method_args->_2;
precondition->_4 = method_args->_3;
while (next(*precondition, *wstate))
{
{
Task_Instance* t = push_task(pstate, task_move_single_to_top_op, 0);
move_single_to_top_op_args* a = push_arguments<move_single_to_top_op_args>(pstate, t);
a->_0 = method_args->_0;
a->_1 = precondition->_1;
a->_2 = method_args->_1;
a->_3 = method_args->_2;
for (top_tuple* tuple = tuple_list::head<top_tuple>(wstate->atoms[atom_top]); tuple != 0; tuple = tuple->next)
{
if (tuple->_0 != a->_1)
{
continue;
}
tuple_list::Handle* list = wstate->atoms[atom_top];
Operator_Effect* effect = push<Operator_Effect>(pstate.journal);
effect->tuple = tuple;
effect->list = list;
tuple_list::detach(list, tuple);
break;
}
for (at_tuple* tuple = tuple_list::head<at_tuple>(wstate->atoms[atom_at]); tuple != 0; tuple = tuple->next)
{
if (tuple->_0 != a->_0)
{
continue;
}
if (tuple->_1 != a->_2)
{
continue;
}
tuple_list::Handle* list = wstate->atoms[atom_at];
Operator_Effect* effect = push<Operator_Effect>(pstate.journal);
effect->tuple = tuple;
effect->list = list;
tuple_list::detach(list, tuple);
break;
}
for (on_table_tuple* tuple = tuple_list::head<on_table_tuple>(wstate->atoms[atom_on_table]); tuple != 0; tuple = tuple->next)
{
if (tuple->_0 != a->_0)
{
continue;
}
tuple_list::Handle* list = wstate->atoms[atom_on_table];
Operator_Effect* effect = push<Operator_Effect>(pstate.journal);
effect->tuple = tuple;
effect->list = list;
tuple_list::detach(list, tuple);
break;
}
{
tuple_list::Handle* list = wstate->atoms[atom_clear];
clear_tuple* tuple = tuple_list::append<clear_tuple>(list);
tuple->_0 = a->_2;
Operator_Effect* effect = push<Operator_Effect>(pstate.journal);
effect->tuple = tuple;
effect->list = list;
}
{
tuple_list::Handle* list = wstate->atoms[atom_at];
at_tuple* tuple = tuple_list::append<at_tuple>(list);
tuple->_0 = a->_0;
tuple->_1 = a->_3;
Operator_Effect* effect = push<Operator_Effect>(pstate.journal);
effect->tuple = tuple;
effect->list = list;
}
{
tuple_list::Handle* list = wstate->atoms[atom_on_other];
on_other_tuple* tuple = tuple_list::append<on_other_tuple>(list);
tuple->_0 = a->_0;
Operator_Effect* effect = push<Operator_Effect>(pstate.journal);
effect->tuple = tuple;
effect->list = list;
}
{
tuple_list::Handle* list = wstate->atoms[atom_on];
on_tuple* tuple = tuple_list::append<on_tuple>(list);
tuple->_0 = a->_0;
tuple->_1 = a->_1;
Operator_Effect* effect = push<Operator_Effect>(pstate.journal);
effect->tuple = tuple;
effect->list = list;
}
}
method->flags |= method_flags_expanded;
PLNNR_COROUTINE_YIELD(*method, 1);
}
return expand_next_branch(pstate, Move_Stack_branch_4_expand, world);
PLNNR_COROUTINE_END();
}
HRESULT set_moniker(HTMLOuterWindow *window, IMoniker *mon, IUri *nav_uri, IBindCtx *pibc, nsChannelBSC *async_bsc,
BOOL set_download)
{
download_proc_task_t *download_task;
HTMLDocumentObj *doc_obj = NULL;
nsChannelBSC *bscallback;
nsWineURI *nsuri;
LPOLESTR url;
IUri *uri;
HRESULT hres;
if(window->doc_obj && window->doc_obj->basedoc.window == window)
doc_obj = window->doc_obj;
hres = IMoniker_GetDisplayName(mon, pibc, NULL, &url);
if(FAILED(hres)) {
WARN("GetDiaplayName failed: %08x\n", hres);
return hres;
}
if(nav_uri) {
uri = nav_uri;
}else {
hres = create_uri(url, 0, &uri);
if(FAILED(hres)) {
CoTaskMemFree(url);
return hres;
}
}
TRACE("got url: %s\n", debugstr_w(url));
set_ready_state(window, READYSTATE_LOADING);
hres = create_doc_uri(window, uri, &nsuri);
if(!nav_uri)
IUri_Release(uri);
if(SUCCEEDED(hres)) {
if(async_bsc)
bscallback = async_bsc;
else
hres = create_channelbsc(mon, NULL, NULL, 0, TRUE, &bscallback);
}
if(SUCCEEDED(hres)) {
if(window->base.inner_window->doc)
remove_target_tasks(window->base.inner_window->task_magic);
abort_window_bindings(window->base.inner_window);
hres = load_nsuri(window, nsuri, bscallback, LOAD_FLAGS_BYPASS_CACHE);
nsISupports_Release((nsISupports*)nsuri); /* FIXME */
if(SUCCEEDED(hres)) {
hres = create_pending_window(window, bscallback);
TRACE("pending window for %p %p %p\n", window, bscallback, window->pending_window);
}
if(bscallback != async_bsc)
IBindStatusCallback_Release(&bscallback->bsc.IBindStatusCallback_iface);
}
if(FAILED(hres)) {
CoTaskMemFree(url);
return hres;
}
if(doc_obj) {
HTMLDocument_LockContainer(doc_obj, TRUE);
if(doc_obj->frame) {
docobj_task_t *task;
task = heap_alloc(sizeof(docobj_task_t));
task->doc = doc_obj;
hres = push_task(&task->header, set_progress_proc, NULL, doc_obj->basedoc.task_magic);
if(FAILED(hres)) {
CoTaskMemFree(url);
return hres;
}
}
download_task = heap_alloc(sizeof(download_proc_task_t));
download_task->doc = doc_obj;
download_task->set_download = set_download;
download_task->url = url;
return push_task(&download_task->header, set_downloading_proc, set_downloading_task_destr, doc_obj->basedoc.task_magic);
}
return S_OK;
}
HRESULT set_moniker(HTMLDocument *This, IMoniker *mon, IBindCtx *pibc, nsChannelBSC *async_bsc, BOOL set_download)
{
download_proc_task_t *download_task;
nsChannelBSC *bscallback;
nsWineURI *nsuri;
LPOLESTR url;
HRESULT hres;
hres = IMoniker_GetDisplayName(mon, pibc, NULL, &url);
if(FAILED(hres)) {
WARN("GetDiaplayName failed: %08x\n", hres);
return hres;
}
TRACE("got url: %s\n", debugstr_w(url));
set_ready_state(This->window, READYSTATE_LOADING);
hres = create_doc_uri(This->window, url, &nsuri);
if(SUCCEEDED(hres)) {
if(async_bsc)
bscallback = async_bsc;
else
hres = create_channelbsc(mon, NULL, NULL, 0, &bscallback);
}
if(SUCCEEDED(hres)) {
remove_target_tasks(This->task_magic);
abort_document_bindings(This->doc_node);
hres = load_nsuri(This->window, nsuri, bscallback, 0/*LOAD_INITIAL_DOCUMENT_URI*/);
nsISupports_Release((nsISupports*)nsuri); /* FIXME */
if(SUCCEEDED(hres))
set_window_bscallback(This->window, bscallback);
if(bscallback != async_bsc)
IUnknown_Release((IUnknown*)bscallback);
}
if(FAILED(hres)) {
CoTaskMemFree(url);
return hres;
}
HTMLDocument_LockContainer(This->doc_obj, TRUE);
if(This->doc_obj->frame) {
docobj_task_t *task;
task = heap_alloc(sizeof(docobj_task_t));
task->doc = This->doc_obj;
push_task(&task->header, set_progress_proc, NULL, This->doc_obj->basedoc.task_magic);
}
download_task = heap_alloc(sizeof(download_proc_task_t));
download_task->doc = This->doc_obj;
download_task->set_download = set_download;
download_task->url = url;
push_task(&download_task->header, set_downloading_proc, set_downloading_task_destr, This->doc_obj->basedoc.task_magic);
return S_OK;
}
active::active(boost::function<void(void) > fn){
task.fn = fn;
push_task(&task);
}
HRESULT set_moniker(HTMLDocument *This, IMoniker *mon, IBindCtx *pibc, nsChannelBSC *async_bsc, BOOL set_download)
{
nsChannelBSC *bscallback;
docobj_task_t *task;
download_proc_task_t *download_task;
nsWineURI *nsuri;
LPOLESTR url;
HRESULT hres;
hres = IMoniker_GetDisplayName(mon, pibc, NULL, &url);
if(FAILED(hres)) {
WARN("GetDiaplayName failed: %08x\n", hres);
return hres;
}
TRACE("got url: %s\n", debugstr_w(url));
if(This->doc_obj->client) {
VARIANT silent, offline;
hres = get_client_disp_property(This->doc_obj->client, DISPID_AMBIENT_SILENT, &silent);
if(SUCCEEDED(hres)) {
if(V_VT(&silent) != VT_BOOL)
WARN("V_VT(silent) = %d\n", V_VT(&silent));
else if(V_BOOL(&silent))
FIXME("silent == true\n");
}
hres = get_client_disp_property(This->doc_obj->client,
DISPID_AMBIENT_OFFLINEIFNOTCONNECTED, &offline);
if(SUCCEEDED(hres)) {
if(V_VT(&offline) != VT_BOOL)
WARN("V_VT(offline) = %d\n", V_VT(&offline));
else if(V_BOOL(&offline))
FIXME("offline == true\n");
}
}
if(This->window->mon) {
update_doc(This, UPDATE_TITLE|UPDATE_UI);
}else {
update_doc(This, UPDATE_TITLE);
set_current_mon(This->window, mon);
}
set_ready_state(This->window, READYSTATE_LOADING);
if(This->doc_obj->client) {
IOleCommandTarget *cmdtrg = NULL;
hres = IOleClientSite_QueryInterface(This->doc_obj->client, &IID_IOleCommandTarget,
(void**)&cmdtrg);
if(SUCCEEDED(hres)) {
VARIANT var, out;
if(!async_bsc) {
V_VT(&var) = VT_I4;
V_I4(&var) = 0;
IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 37, 0, &var, NULL);
}else {
V_VT(&var) = VT_UNKNOWN;
V_UNKNOWN(&var) = (IUnknown*)&This->window->IHTMLWindow2_iface;
V_VT(&out) = VT_EMPTY;
hres = IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 63, 0, &var, &out);
if(SUCCEEDED(hres))
VariantClear(&out);
}
IOleCommandTarget_Release(cmdtrg);
}
}
hres = create_doc_uri(This->window, url, &nsuri);
if(SUCCEEDED(hres))
{
if(async_bsc) {
bscallback = async_bsc;
}else {
hres = create_channelbsc(mon, NULL, NULL, 0, &bscallback);
}
}
if(SUCCEEDED(hres))
{
remove_target_tasks(This->task_magic);
abort_document_bindings(This->doc_node);
hres = load_nsuri(This->window, nsuri, bscallback, LOAD_INITIAL_DOCUMENT_URI);
nsISupports_Release((nsISupports*)nsuri); /* FIXME */
if(SUCCEEDED(hres))
set_window_bscallback(This->window, bscallback);
if(bscallback != async_bsc)
IUnknown_Release((IUnknown*)bscallback);
}
if(FAILED(hres))
{
CoTaskMemFree(url);
return hres;
}
HTMLDocument_LockContainer(This->doc_obj, TRUE);
if(This->doc_obj->frame) {
task = heap_alloc(sizeof(docobj_task_t));
task->doc = This->doc_obj;
push_task(&task->header, set_progress_proc, This->doc_obj->basedoc.task_magic);
}
download_task = heap_alloc(sizeof(download_proc_task_t));
download_task->doc = This->doc_obj;
download_task->set_download = set_download;
download_task->url = url;
push_task(&download_task->header, set_downloading_proc, This->doc_obj->basedoc.task_magic);
return S_OK;
}
