Bunifu.UI.WinForms.BunifuCheckBox

Provides enhanced visual support for on and off states when supporting feature selections.m

Creates a new BunifuCheckBox control.

Sets the CheckBox check-state to true or false.

Creates a new BunifuCheckBox control.

Sets the CheckBox check-state to true or false. Sets the control to bind directly with the CheckBox; this in most cases is a Label.

Creates a new BunifuCheckBox control.

Sets the CheckBox check-state to true or false. Sets the control to bind directly with the CheckBox; this in most cases is a Label. Sets the location of the CheckBox within the Form. [Example: New Point(12, 12)]

Specifies the available styles applicable to Bunifu CheckBoxes.

Renders Bunifu's standard CheckBox.

Renders a standard flat designed CheckBox.

Renders a smooth round designed CheckBox.

Specifies the CheckBox check-state.

The checked state.

The unchecked state.

The indeterminate state.

Specifies the bound control's position in relation to the CheckBox attached to it.

Positions the control to the left of the CheckBox.

Positions the control to the right of the CheckBox.

Represents the normal or default state of the control.

Represents the hovered state of the control, that is, when the control gets mouse-focus.

Represents the checked state of the control.

Represents the disabled or inactive state of the control.

Gets or sets the control's overral border radius.

Causes the Checkbox to automatically change state when clicked.

Gets or sets the CheckBox check-state.

CheckState

Gets or sets the CheckBox check-state.

CheckState

Gets or sets a value indicating whether the CheckBox will allow three states, that is, the \"Checked\", \"Unchecked\" and \"Indeterminate\" states rather than \"Checked\" and \"Unchecked\" only.

ThreeState

Gets or sets a value indicating whether the Checkmark will allow check-state-change animations/transitions at runtime.

Gets or sets a value indicating whether the CheckBox will allow standard animations at runtime.

Gets or sets a value indicating whether the CheckBox animation will be applied to the bound control.

Gets or sets a value indicating whether the CheckBox will colorize the bound control. This is especially applicable where the bound control is a .

Gets a value indicating whether the CheckBox will allow the \"OnHoverChecked\" and \"OnHoverUnchecked\" states to be active at runtime.

Gets or sets a value indicating whether the CheckBox will allow the bound control's location to be positioned based on it's own location.

Gets or sets the control to bind directly with the CheckBox; this in most cases is a Label. This setting also binds the most appropriate events of the CheckBox to the control selected.

BindingControl

Gets or sets the position of the bound control in relation to the CheckBox.

BindingControlPosition

Gets or sets the control's ToolTip Text.

ToolTipText

[Deprecated] Gets or sets the standard CheckBox style to be applied.

Gets or sets a custom checkmark image.

Gets the Checkmark's rectangle.

Allows you to easily create a new binding control and automatically adds and binds it to the CheckBox.

The control to create and bind, together with its properties. Note: You can create a label, a button or any other control you'd prefer to bind with. Bound Control.

Allows you to easily create a new Label that will automatically be bound with the CheckBox.

The label's Text property value. The label's Font property value. The label's ForeColor property value. Bound Label.

Forces the control to invalidate its client area and immediately redraw itself and any child controls.

Draws a user-defined Graphics canvas.

The Graphics canvas. The canvas rectangle-bounds. The canvas corner-radius. The pen used to draw objects inside the canvas. Color of the fill. The state to manipulate/render.

Draws the Checkmark bitmap.

The Graphics to reference. The checkmark pen. The current/active CheckBox state. The start point. The left point. The right point. The checkmark width. The checkmark height.

Renders the control region.

Specify the state to be applied to the control.

Invokes the event.

The valid name of the property changed.

Performs a check-state-changed color transition within the CheckBox region.

Displays the checkmark allowing transitioning from the current size to the standard size.

Set to true if in render mode; otherwise set to false.

Hide the checkmark allowing transitioning from the current size to the standard size.

Set to if in render mode; otherwise set to .

This event is called once the transitions have completed.

[Reserved] This event is called once the transitions have completed.

Handles binding and moving of the internally bound/set control with the CheckBox.

Is the current call to this method within a property? If so, use the "value" parameter in the setter to pass the control. The selected user control to be bound with the CheckBox.

Determines whether the hosting process is in design-mode.

Determines whether the hosting process is in design-mode as per the LicenseManager module.

Occurs whenever the Checked property has been changed.

Occurs whenever the CheckState property has been changed.

Occurs whenever the active CheckBox state's properties have been changed.

Occurs whenever the CheckBox Style property has been changed.

Occurs whenever the bound control has been changed.

Occurs whenever the bound control's position in relation to the CheckBox has been changed.

Provides data for the and events.

Provide the state to be passed-in. Set the Checked value to true/false.

Gets a value indicating whether the CheckBox is checked or not.

Gets a value indicating whether the CheckBox check-state is set to true or false

Provides data for the event.

The currently active CheckBox state.

Provides access to the available state properties in the CheckBox.

Gets the checkbox inner fill color.

Gets the checkbox's border radius.

Gets the checkbox border thickness.

Gets the checkbox border color.

Gets the checkmark thickness.

Gets a value indicating whether the property UseBorderThicknessForCheckmark has been allowed.

Provides data for the event.

The currently applied CheckBox style.

Gets the Style applied to the CheckBox.

Provides data for the event.

The currently bound control.

Gets the control that is currently bound-up with the CheckBox.

Provides data for the event.

The currently set control's position.

Gets the current position of the bound control in relation to the CheckBox.

Initializes a new instance of the class.

Implementation of this abstract method creates Smart Tag items, associates their targets, and collects them into a list.

Required designer variable.

Clean up any resources being used.

true if managed resources should be disposed; otherwise, false.

Required method for Designer support - do not modify the contents of this method with the code editor.

An abstract class used to define various states within Bunifu CheckBox.

Creates a new Bunifu CheckBox state.

Provide a name for the state. This can be used to track the state once initialized.

Gets the current CheckBox size.

Occurs when a property value changes.

Notifies the property changed event.

Gets the name applied to the state.

Gets or sets the CheckBox inner color.

CheckBoxColor.

Gets or sets the CheckBox border radius. The higher the value, the more curved the edges appear.

BorderRadius

Gets or sets the CheckBox border thickness.

BorderThickness

Gets or sets the CheckBox border color.

BorderColor

Gets or sets the CheckBox checkmark color.

CheckmarkColor

Gets or sets the CheckBox checkmark thickness.

CheckmarkThickness

Gets or sets a value indicating whether to use the border thickness of the CheckBox as the border thickness of the checkmark.

UseBorderThicknessForCheckmark

Returns a containing the values passed to the state separated by semi-colons. The order of appearance is: , , , , , , .

String

Interface for all types we can perform transitions on. Each type (e.g. int, double, Color) that we can perform a transition on needs to have its own class that implements this interface. These classes tell the transition system how to act on objects of that type.

Returns the Type that the instance is managing.

Returns a deep copy of the object passed in. (In particular this is needed for types that are objects.)

Returns an object holding the value between the start and end corresponding to the percentage passed in. (Note: the percentage can be less than 0% or greater than 100%.)

Called by the Transition framework when its timer ticks to pass in the time (in ms) since the transition started. You should return (in an out parameter) the percentage movement towards the destination value for the time passed in. Note: this does not need to be a smooth transition from 0% to 100%. You can overshoot with values greater than 100% or undershoot if you need to (for example, to have some form of "elasticity"). The percentage should be returned as (for example) 0.1 for 10%. You should return (in an out parameter) whether the transition has completed. (This may not be at the same time as the percentage has moved to 100%.)

Class that manages transitions for Color properties. For these we need to transition the R, G, B and A sub-properties independently.

Returns the type we are managing.

Returns a copy of the color object passed in.

Creates an intermediate value for the colors depending on the percentage passed in.

Manages transitions for double properties.

Returns the type managed by this class.

Returns a copy of the double passed in.

Returns the value between start and end for the percentage passed in.

Returns the type we're managing.

Returns a copy of the float passed in.

Returns the interpolated value for the percentage passed in.

Manages transitions for int properties.

Returns the type we are managing.

Returns a copy of the int passed in.

Returns the value between the start and end for the percentage passed in.

Manages transitions for strings. This doesn't make as much sense as transitions on other types, but I like the way it looks!

Returns the type we're managing.

Returns a copy of the string passed in.

Returns an "interpolated" string.

Lets you perform animated transitions of properties on arbitrary objects. These will often be transitions of UI properties, for example an animated fade-in of a UI object, or an animated move of a UI object from one position to another. Each transition can simulataneously change multiple properties, including properties across multiple objects. Example transition ------------------ a. Transition t = new Transition(new TransitionMethod_Linear(500)); b. t.add(form1, "Width", 500); c. t.add(form1, "BackColor", Color.Red); d. t.run(); Line a: Creates a new transition. You specify the transition method. Lines b. and c: Set the destination values of the properties you are animating. Line d: Starts the transition. Transition methods ------------------ TransitionMethod objects specify how the transition is made. Examples include linear transition, ease-in-ease-out and so on. Different transition methods may need different parameters.

You should register all managed-types here.

Args passed with the TransitionCompletedEvent.

Event raised when the transition hass completed.

Creates and immediately runs a transition on the property passed in.

Sets the property passed in to the initial value passed in, then creates and immediately runs a transition on it.

Creates a TransitionChain and runs it.

Constructor. You pass in the object that holds the properties that you are performing transitions on.

Adds a property that should be animated as part of this transition.

Starts the transition.

Property that returns a list of information about each property managed by this transition.

We remove the property with the info passed in from the transition.

Called when the transition timer ticks.

Sets a property on the object passed in to the value passed in. This method invokes itself on the GUI thread if the property is being invoked on a GUI object.

Returns true if the object passed in is a Control and is disposed or in the process of disposing. (If this is the case, we don't want to make any changes to its properties.)

Registers a transition-type. We hold them in a map.

Runs the next transition in the list.

Called when the transition we have just run has completed.

Constructor.

The percentage of elapsed time, expressed as (for example) 75 for 75%.

The value of the animated properties at the EndTime. This is the percentage movement of the properties between their start and end values. This should be expressed as (for example) 75 for 75%.

The interpolation method to use when moving between the previous value and the current one.

This class is responsible for running transitions. It holds the timer that triggers transaction animation.

This class is a singleton. We manage the transaction timer here so that we can have a single timer across all transactions. If each transaction has its own timer, this creates one thread for each transaction, and this can lead to too many threads in an application. This class essentially just manages the timer for the transitions. It calls back into the running transitions, which do the actual work of the transition.

Singleton's getInstance method.

You register a transition with the manager here. This will start to run the transition as the manager's timer ticks.

Checks if any existing transitions are acting on the same properties as the transition passed in. If so, we remove the duplicated properties from the older transitions.

Finds any properties in the old-transition that are also in the new one, and removes them from the old one.

Private constructor (for singleton).

Called when the timer ticks.

Called when a transition has completed.

Manages transitions under constant acceleration from a standing start.

Constructor. You pass in the time that the transition will take (in milliseconds).

Works out the percentage completed given the time passed in. This uses the formula: s = ut + 1/2at^2 The initial velocity is 0, and the acceleration to get to 1.0 at t=1.0 is 2, so the formula just becomes: s = t^2

This transition bounces the property to a destination value and back to the original value. It is accelerated to the destination and then decelerated back as if being dropped with gravity and bouncing back against gravity.

Constructor. You pass in the total time taken for the bounce.

This transition animates with an exponential decay. This has a damping effect similar to the motion of a needle on an electomagnetically controlled dial.

Constructor. You pass in the time that the transition will take (in milliseconds).

Manages a transition starting from a high speed and decelerating to zero by the end of the transition.

Constructor. You pass in the time that the transition will take (in milliseconds).

Works out the percentage completed given the time passed in. This uses the formula: s = ut + 1/2at^2 The initial velocity is 2, and the acceleration to get to 1.0 at t=1.0 is -2, so the formula becomes: s = t(2-t)

Manages an ease-in-ease-out transition. This accelerates during the first half of the transition, and then decelerates during the second half.

Constructor. You pass in the time that the transition will take (in milliseconds).

Works out the percentage completed given the time passed in. This uses the formula: s = ut + 1/2at^2 We accelerate as at the rate needed (a=4) to get to 0.5 at t=0.5, and then decelerate at the same rate to end up at 1.0 at t=1.0.

This transition type 'flashes' the properties a specified number of times, ending up by reverting them to their initial values. You specify the number of bounces and the length of each bounce.

You specify the number of bounces and the time taken for each bounce.

This class manages a linear transition. The percentage complete for the transition increases linearly with time.

Constructor. You pass in the time (in milliseconds) that the transition will take.

We return the percentage completed.

This transition bounces the property to a destination value and back to the original value. It is decelerated to the destination and then acclerated back as if being thrown against gravity and then descending back with gravity.

Constructor. You pass in the total time taken for the bounce.

This class allows you to create user-defined transition types. You specify these as a list of TransitionElements. Each of these defines: End time , End value, Interpolation method For example, say you want to make a bouncing effect with a decay: EndTime% EndValue% Interpolation -------- --------- ------------- 50 100 Acceleration 75 50 Deceleration 85 100 Acceleration 91 75 Deceleration 95 100 Acceleration 98 90 Deceleration 100 100 Acceleration The time values are expressed as a percentage of the overall transition time. This means that you can create a user-defined transition-type and then use it for transitions of different lengths. The values are percentages of the values between the start and end values of the properties being animated in the transitions. 0% is the start value and 100% is the end value. The interpolation is one of the values from the InterpolationMethod enum. So the example above accelerates to the destination (as if under gravity) by t=50%, then bounces back up to half the initial height by t=75%, slowing down (as if against gravity) before falling down again and bouncing to decreasing heights each time.

Constructor.

Constructor. You pass in the list of TransitionElements and the total time (in milliseconds) for the transition.

Sets up the transitions.

Called to find the value for the movement of properties for the time passed in.

Returns the element info for the time-fraction passed in.

A class holding static utility functions.

Returns the value of the property passed in.

Sets the value of the property passed in.

Returns a value between d1 and d2 for the percentage passed in.

Returns a value betweeen i1 and i2 for the percentage passed in.

Returns a value betweeen f1 and f2 for the percentage passed in.

Converts a fraction representing linear time to a fraction representing the distance traveled under an ease-in-ease-out transition.

Converts a fraction representing linear time to a fraction representing the distance traveled under a constant acceleration transition.

Converts a fraction representing linear time to a fraction representing the distance traveled under a constant deceleration transition.

Fires the event passed in in a thread-safe way.

This method loops through the targets of the event and invokes each in turn. If the target supports ISychronizeInvoke (such as forms or controls) and is set to run on a different thread, then we call BeginInvoke to marshal the event to the target thread. If the target does not support this interface (such as most non-form classes) or we are on the same thread as the target, then the event is fired on the same thread as this is called from.