Bunifu.UI.WinForms.BunifuGroupBox

Provides customizable group boxes for hosting and managing individual controls.

Initializes a new instance of the control.

Provides different line style options.

A solid line.

A dashed line.

A dotted line.

A dashed and dotted recursive line.

A dashed, dotted-dotted recursive line.

Gets or sets the border thickness.

Gets or sets the border radius.

Gets or sets the label indent size.

Gets or sets the label text.

Gets or sets the label font.

Gets or sets the label fore color.

Gets or sets the border color.

Gets or sets the label alignment.

Gets or sets the group box line style.

Required designer variable.

Clean up any resources being used.

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

Required method for Designer support.

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.

Provides graphics extension methods for drawing rectangles.

Generates a rounded rectangle.

The graphics object to use for drawing. The client rectangle. The rectangle radius.

Generates a rectangular graphics capsule.

The graphics object to use for drawing. The base client rectangle.

Draws a rounded rectangle specified by a pair of coordinates, a width, a height and the radius for the arcs that make the rounded edges.

A that determines the color, width and style of the rectangle. The x-coordinate of the upper-left corner of the rectangle to draw. The y-coordinate of the upper-left corner of the rectangle to draw. Width of the rectangle to draw. Height of the rectangle to draw. The radius of the arc used for the rounded edges.

Draws a rounded rectangle specified by a pair of coordinates, a width, a height and the radius for the arcs that make the rounded edges.

Provides a collection of methods that extend the .NET Color class.

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.