Exemple #1
0
static int slider_msg_proc (skin_item_t* item, int message, WPARAM wparam, LPARAM lparam)
{
	int pos = 0;
	
	if ( item->style & SI_NRMSLIDER_STATIC )
		return 0;
	
    /* assert (item != NULL) */
	switch (message) {
//	case SKIN_MSG_CLICK:     /* SLIDER_CHANGED event */
    case SKIN_MSG_LBUTTONDOWN:
	case SKIN_MSG_MOUSEDRAG:     /* SLIDER_CHANGED event */
		pos = get_changed_pos (item, (int)wparam, (int)lparam);
		/* default operation */
        if (skin_get_thumb_pos (item->hostskin, item->id) != pos) {
            skin_set_thumb_pos ( item->hostskin, item->id, pos);
            RAISE_EVENT ( SIE_SLIDER_CHANGED, (void *)pos );
        }
		break;
	case SKIN_MSG_SETFOCUS:
		RAISE_EVENT ( SIE_GAIN_FOCUS, NULL );
		break;
	case SKIN_MSG_KILLFOCUS:
		RAISE_EVENT ( SIE_LOST_FOCUS, NULL );
		break;
	}
	return 1;
}
bool USB_GetDescriptor(const uint16_t wValue, const uint8_t wIndex,
                       void** const DescriptorAddress, uint16_t* const DescriptorSize)
{
	RAISE_EVENT(USB_DeviceError, DEVICE_ERROR_GetDescriptorNotHooked);

	return false;
};
bool CPMTraceEraserAppLayer::objects_register()
{
    try
    {
        //***************************************
        // Register objects with ORB                                            // <--
        //ObjToRegister<CPMObjDummy_i> obj(cpm_obj_dummy_,
        //                                    "CPMObjDummy",
        //                                    "CPMObjDummy_in_AOT");
        //obj.register_with_ior_table(objects_ids_);

        //ObjToRegister<CPMObjDummy_i> obj2(cpm_obj_dummy2_,
        //                                    "CPMObjDummy2",
        //                                    "CPMObjDummy2_in_AOT");
        //obj2.register_with_ior_table(objects_ids_);
        //***************************************
    }
    catch(...)
    {
        RAISE_EVENT(CPMTraceEraserEvents::ev_object_registration_with_ior_table_failure2,
                    LM_ERROR);
        return false;
    }

    return true;
}
bool CPMTraceEraserAppLayer::init_corba_objects()
{
    try
    {
        tao_layer_->register_with_ior_table<
                                CPMO_i,
                                ::ICPM_module::ICPMProcess>
                            (
                                &obj_impl_,
                                (cpmo_id_ + "_in_AOT").c_str(),
                                cpmo_id_.c_str()
                            );
    }
    catch(...)
    {
        RAISE_EVENT(CPMTraceEraserEvents::ev_object_registration_with_ior_table_failure,
                    LM_ERROR,
                    cpmo_id_.c_str());
        return false;
    }

    if (!objects_init())
    {
        return false;
    }

    if (!objects_register())
    {
        return false;
    }

    return true;
}
Exemple #5
0
static int button_msg_proc (skin_item_t* item, int message, WPARAM wparam, LPARAM lparam)
{
	/* assert (item != NULL) */
	switch (message) {
	case SKIN_MSG_LBUTTONDOWN:	/* click-down event */
		//RAISE_EVENT ( SIE_LBUTTONDOWN, NULL ); /*item msg not defined*/
		/* default operation */
		skin_set_check_status ( item->hostskin, item->id, TRUE );	/*button down*/
		break;
	case SKIN_MSG_LBUTTONUP:	/* click-up event */
		//RAISE_EVENT ( SIE_LBUTTONUP, NULL ); /*item msg not defined*/
		/* default operation */
		skin_set_check_status ( item->hostskin, item->id, FALSE );	/*button up*/
		break;
	case SKIN_MSG_CLICK:		/* CLICK event */
		RAISE_EVENT ( SIE_BUTTON_CLICKED, NULL );
		/* default operation */
		skin_set_check_status ( item->hostskin, item->id, FALSE );	/* button up */
		break;
	case SKIN_MSG_MOUSEDRAG:
		//RAISE_EVENT ( SIE_MOUSEDRAG, NULL );
		/* default operation */
		if ( PtInRegion (&item->region, (int)wparam, (int)lparam) ){
        	/* if mouse moves in, click-down item */
            if (!skin_get_check_status(item->hostskin, item->id))
                skin_set_check_status ( item->hostskin, item->id, TRUE);	/*button down*/
		}
		else{
        	/* if mouse moves out, click-up item */
            if (skin_get_check_status(item->hostskin, item->id))
                skin_set_check_status ( item->hostskin, item->id, FALSE);	/*button up*/
		}
		break;
	case SKIN_MSG_SETFOCUS:
		RAISE_EVENT ( SIE_GAIN_FOCUS, NULL );
		break;
	case SKIN_MSG_KILLFOCUS:
		RAISE_EVENT ( SIE_LOST_FOCUS, NULL );
		break;
	}
	return 1;
}
bool CPMTraceEraserAppLayer::objects_init()
{
    try
    {
        if (!cpm_trace_eraser_obj_.init())
        {
            RAISE_EVENT(CPMTraceEraserEvents::ev_object_init_failure,
                        LM_ERROR);
            return false;
        }
    }
    catch(...)
    {
        RAISE_EVENT(CPMTraceEraserEvents::ev_object_init_failure,
                    LM_ERROR);
        return false;
    }

    return true;
}
Exemple #7
0
bool XyzAppLayer::objects_init()
{
    try
    {
        if (!cpm_obj_dummy_.init_i())
        {
            RAISE_EVENT(XyzEvents::ev_object_init_failure,
                        LM_ERROR);
            return false;
        }
    }
    catch(...)
    {
        RAISE_EVENT(XyzEvents::ev_object_init_failure,
                    LM_ERROR);
        return false;
    }

    return true;
}
Exemple #8
0
void read_packet_from_socket(options_t* opts, int raw_socket)
{
    u8_t buffer[65536];
    int datasize;

    datasize = recvfrom(raw_socket, buffer, sizeof(buffer), 0, NULL, NULL);

    struct packet_data data;
    data.chrs = malloc(datasize);
    memcpy(data.chrs, buffer, datasize);
    data.sz = datasize;

    RAISE_EVENT(packet_event, new_packet_event(&data, ID_PACKET_RECIEVED));
}
Exemple #9
0
void USB_ShutDown(void)
{
	if (USB_IsConnected)
	  RAISE_EVENT(USB_Disconnect);

	USB_INT_DisableAllInterrupts();
	USB_INT_ClearAllInterrupts();

	USB_IsConnected         = false;
	USB_IsInitialized       = false;

	#if defined(USB_CAN_BE_HOST)
	USB_HostState           = HOST_STATE_Unattached;
	#endif

	#if defined(USB_CAN_BE_DEVICE)
	USB_ConfigurationNumber = 0;
	#endif

	#if (!defined(USB_HOST_ONLY) && !defined(USB_DEVICE_ONLY))
	USB_CurrentMode = USB_MODE_NONE;
	#endif
	
	#if !defined(USE_STATIC_OPTIONS)
	USB_Options     = 0;
	#endif

	USB_Interface_Disable();
	USB_PLL_Off();
	
	#if defined(USB_FULL_CONTROLLER) || defined(USB_MODIFIED_FULL_CONTROLLER)
	USB_OTGPAD_Off();
	#endif

	#if defined(USB_CAN_BE_BOTH)
	UHWCON &= ~(1 << UIDE);
	#endif
}
Exemple #10
0
ISR(USB_GEN_vect, ISR_BLOCK)
{
	#if defined(USB_CAN_BE_DEVICE)
	#if defined(USB_FULL_CONTROLLER) || defined(USB_MODIFIED_FULL_CONTROLLER)
	if (USB_INT_HasOccurred(USB_INT_VBUS) && USB_INT_IsEnabled(USB_INT_VBUS))
	{
		USB_INT_Clear(USB_INT_VBUS);

		RAISE_EVENT(USB_VBUSChange);

		if (USB_VBUS_GetStatus())
		{
			RAISE_EVENT(USB_VBUSConnect);
			
			if (USB_IsConnected)
			  RAISE_EVENT(USB_Disconnect);
				
			USB_ResetInterface();
				
			USB_IsConnected = true;

			RAISE_EVENT(USB_Connect);
		}
		else
		{
			RAISE_EVENT(USB_Disconnect);
		
			USB_Detach();
			USB_CLK_Freeze();
			USB_PLL_Off();
			USB_REG_Off();

			USB_IsConnected = false;

			RAISE_EVENT(USB_VBUSDisconnect);
			
			USB_INT_Clear(USB_INT_VBUS);
		}
	}
	#endif

	if (USB_INT_HasOccurred(USB_INT_SUSPEND) && USB_INT_IsEnabled(USB_INT_SUSPEND))
	{
		USB_INT_Clear(USB_INT_SUSPEND);

		USB_INT_Disable(USB_INT_SUSPEND);
		USB_INT_Enable(USB_INT_WAKEUP);
		
		USB_CLK_Freeze();
		
		if (!(USB_Options & USB_OPT_MANUAL_PLL))
		  USB_PLL_Off();

		USB_IsSuspended = true;

		RAISE_EVENT(USB_Suspend);

		#if defined(USB_LIMITED_CONTROLLER) && !defined(NO_LIMITED_CONTROLLER_CONNECT)
		if (USB_IsConnected)
		{
			USB_IsConnected = false;
			RAISE_EVENT(USB_Disconnect);
		}
		#endif
	}

	if (USB_INT_HasOccurred(USB_INT_WAKEUP) && USB_INT_IsEnabled(USB_INT_WAKEUP))
	{
		if (!(USB_Options & USB_OPT_MANUAL_PLL))
		{
			USB_PLL_On();
			while (!(USB_PLL_IsReady()));
		}

		USB_CLK_Unfreeze();

		USB_INT_Clear(USB_INT_WAKEUP);

		USB_INT_Disable(USB_INT_WAKEUP);
		USB_INT_Enable(USB_INT_SUSPEND);
		
		#if defined(USB_LIMITED_CONTROLLER) && !defined(NO_LIMITED_CONTROLLER_CONNECT)
		if (!(USB_IsConnected))
		{
			USB_IsConnected = true;
			RAISE_EVENT(USB_Connect);
		}
		#endif

		USB_IsSuspended = false;

		RAISE_EVENT(USB_WakeUp);
	}
   
	if (USB_INT_HasOccurred(USB_INT_EORSTI) && USB_INT_IsEnabled(USB_INT_EORSTI))
	{
		USB_INT_Clear(USB_INT_EORSTI);

		USB_ConfigurationNumber = 0;

		USB_INT_Clear(USB_INT_SUSPEND);
		USB_INT_Disable(USB_INT_SUSPEND);
		USB_INT_Enable(USB_INT_WAKEUP);

		Endpoint_ClearEndpoints();

		Endpoint_ConfigureEndpoint(ENDPOINT_CONTROLEP, EP_TYPE_CONTROL,
		                           ENDPOINT_DIR_OUT, USB_ControlEndpointSize,
		                           ENDPOINT_BANK_SINGLE);

		RAISE_EVENT(USB_Reset);
	}
	#endif
	
	#if defined(USB_CAN_BE_HOST)
	if (USB_INT_HasOccurred(USB_INT_DDISCI) && USB_INT_IsEnabled(USB_INT_DDISCI))
	{
		USB_INT_Clear(USB_INT_DDISCI);
		USB_INT_Clear(USB_INT_DCONNI);
		USB_INT_Disable(USB_INT_DDISCI);
			
		RAISE_EVENT(USB_DeviceUnattached);
		RAISE_EVENT(USB_Disconnect);

		USB_ResetInterface();
	}
	
	if (USB_INT_HasOccurred(USB_INT_VBERRI) && USB_INT_IsEnabled(USB_INT_VBERRI))
	{
		USB_INT_Clear(USB_INT_VBERRI);

		USB_Host_VBUS_Manual_Off();
		USB_Host_VBUS_Auto_Off();

		RAISE_EVENT(USB_HostError, HOST_ERROR_VBusVoltageDip);
		RAISE_EVENT(USB_DeviceUnattached);

		USB_HostState = HOST_STATE_Unattached;
	}

	if (USB_INT_HasOccurred(USB_INT_SRPI) && USB_INT_IsEnabled(USB_INT_SRPI))
	{
		USB_INT_Clear(USB_INT_SRPI);
		USB_INT_Disable(USB_INT_SRPI);
	
		RAISE_EVENT(USB_DeviceAttached);

		USB_INT_Enable(USB_INT_DDISCI);
		
		USB_HostState = HOST_STATE_Attached;
	}

	if (USB_INT_HasOccurred(USB_INT_BCERRI) && USB_INT_IsEnabled(USB_INT_BCERRI))
	{
		USB_INT_Clear(USB_INT_BCERRI);
		
		RAISE_EVENT(USB_DeviceEnumerationFailed, HOST_ENUMERROR_NoDeviceDetected, 0);
		RAISE_EVENT(USB_DeviceUnattached);
		
		if (USB_IsConnected)
		  RAISE_EVENT(USB_Disconnect);

		USB_ResetInterface();
	}
	#endif

	#if defined(USB_CAN_BE_BOTH)
	if (USB_INT_HasOccurred(USB_INT_IDTI) && USB_INT_IsEnabled(USB_INT_IDTI))
	{		
		USB_INT_Clear(USB_INT_IDTI);

		if (USB_IsConnected)
		{
			if (USB_CurrentMode == USB_MODE_HOST)
			  RAISE_EVENT(USB_DeviceUnattached);
			else
			  RAISE_EVENT(USB_Disconnect);
		}

		RAISE_EVENT(USB_UIDChange);
		
		USB_ResetInterface();
	}
	#endif
}
Exemple #11
0
void USB_Init(
               #if defined(USB_CAN_BE_BOTH)
               const uint8_t Mode
               #endif

               #if (defined(USB_CAN_BE_BOTH) && !defined(USE_STATIC_OPTIONS))
               ,
               #elif (!defined(USB_CAN_BE_BOTH) && defined(USE_STATIC_OPTIONS))
               void
               #endif
			   
               #if !defined(USE_STATIC_OPTIONS)
               const uint8_t Options
               #endif
               )
{
	if (USB_IsInitialized)
	  USB_ShutDown();

	#if (!defined(USB_HOST_ONLY) && !defined(USB_DEVICE_ONLY))
	USB_CurrentMode = Mode;
	#endif
	
	#if defined(USB_DEVICE_ONLY)
		#if defined(USB_FULL_CONTROLLER)
		UHWCON |= (1 << UIMOD);
		#endif
	#elif defined(USB_HOST_ONLY)
	UHWCON &= ~(1 << UIMOD);
	#else
	if (Mode == USB_MODE_NONE)
	{
		RAISE_EVENT(USB_PowerOnFail, POWERON_ERROR_NoUSBModeSpecified);
		return;
	}
	else if (Mode == USB_MODE_UID)
	{
		UHWCON |=  (1 << UIDE);

		USB_INT_Clear(USB_INT_IDTI);
		USB_INT_Enable(USB_INT_IDTI);
		
		USB_CurrentMode = USB_GetUSBModeFromUID();
	}
	else if (Mode == USB_MODE_DEVICE)
	{
		UHWCON |=  (1 << UIMOD);
	}
	else if (Mode == USB_MODE_HOST)			
	{
		UHWCON &= ~(1 << UIMOD);
	}
	#endif

	#if defined(USB_CAN_BE_BOTH)
	USB_InitTaskPointer();
	#else
	USB_IsInitialized = true;
	#endif

	#if defined(USB_CAN_BE_HOST)
	USB_ControlPipeSize = PIPE_CONTROLPIPE_DEFAULT_SIZE;
	#endif
	
	#if defined(USB_FULL_CONTROLLER) || defined(USB_MODIFIED_FULL_CONTROLLER)
	USB_OTGPAD_On();
	#endif
	
	#if !defined(USE_STATIC_OPTIONS)
	USB_Options = Options;
	#endif

	#if defined(USB_DEVICE_ONLY)
		#if defined(USB_FULL_CONTROLLER) || defined(USB_MODIFIED_FULL_CONTROLLER)
		USB_INT_Enable(USB_INT_VBUS);
		#else
		USB_SetupInterface();
		#endif
	#elif defined(USB_HOST_ONLY)
	USB_SetupInterface();
	#else
	if (USB_CurrentMode == USB_MODE_DEVICE)
	  USB_INT_Enable(USB_INT_VBUS);
	else
	  USB_SetupInterface();
	#endif
	
	sei();
}
Exemple #12
0
bool CPMMAppLayer::run()
{
    INIT_RAISER_RETURN(false);

    //CPMTRACER->trace("%s - cpmm_obj_impl_.init_i...", _SRC);
    if (!cpmm_obj_impl_.init_i(overwrite_autostart_to_false_))
    {
        RAISE_EVENT(CPMMEvents::ev_cpmm_object_init_failure,
                    LM_ERROR);
        return false;
    }

    //CPMTRACER->trace("%s - tao_layer_->register_with_ior_table<%s>", _SRC, cpmo_id_.c_str());
    //ACE_DEBUG((LM_DEBUG, "CPMMAppLayer::run() - cpmo_id_ = %s\n", cpmo_id_.c_str()));
    try
    {
        tao_layer_->register_with_ior_table<
                                CPMO_i,
                                ::ICPM_module::ICPMProcess>
                            (
                                &obj_impl_,
                                (cpmo_id_ + "_in_AOT").c_str(),
                                cpmo_id_.c_str()
                            );
    }
    catch(...)
    {
        RAISE_EVENT(CPMMEvents::ev_object_registration_with_ior_table_failure,
                    LM_ERROR,
                    cpmo_id_.c_str());
        return false;
    }

    std::string cpmm_object_id("CPMMObj");
    //CPMTRACER->trace("%s - tao_layer_->register_with_ior_table<%s>", _SRC, cpmm_object_id.c_str());
    //ACE_DEBUG((LM_DEBUG, "CPMMAppLayer::run() - object_id = %s\n", object_id.c_str()));
    try
    {
        tao_layer_->register_with_ior_table<
                                CPMMObj_i,
                                ::ICPM_module::ICPMM>
                            (
                                &cpmm_obj_impl_,
                                "CPMMObj_in_AOT",
                                cpmm_object_id.c_str()
                            );
    }
    catch(...)
    {
        RAISE_EVENT(CPMMEvents::ev_object_registration_with_ior_table_failure,
                    LM_ERROR,
                    cpmm_object_id.c_str());
        return false;
    }

    // Since ev_server_stopped event is generated at the main() level and that it is
    // as a system log event, we generate ev_server_started as a system log too.
    EVENT_HANDLER_SYSTEMLOG->handle_event(
        _SRC,
        CPMMEvents::ev_server_started,
        LM_INFO,
        cpmo_id_.c_str());

    if (int rc = cpmm_obj_impl_.activate() != 0)
    {
        EVENT_HANDLER_SYSTEMLOG->handle_event(
            _SRC,
            CPMMEvents::ev_task_activation_failure,
            LM_ERROR,
            rc);
        return false;
    }

    ACE_DEBUG((LM_INFO, "%s server started, waiting for requests...\n\n", cpmo_id_.c_str()));
    try
    {
        tao_layer_->orb()->run();
    }
    catch(...)
    {
        return false;
    }

    //CPMTRACER->trace("%s - return true.", _SRC);
    return true;
}