Bunifu.UI.WinForms.BunifuImageButton

Provides button-like capabilities and image manipulation features when working with images/icons.

Creates a new control.

Provides flip-orientation options for images.

Flip image to normal view.

Flip image horizontally.

Flip image vertically.

Provides the various supported image-states generated from the applied Image.

Returns the normal image.

Returns a totally blurred image.

Returns a medially blurred image.

Returns a partially blurred image.

Provides a list of border-style options for use in Bunifu Image Buttons.

Specifies a less-curved edge design.

Specifies a flat edge design.

Specifies a rounded design.

When set to true, the image will be double-buffered to prevent flickering. However once enabled, the property will be set to false to allow for visibility whenever zooming occurs.

Gets or sets a value indicating whether the control will show cursor changes during mouse-hover events.

Sets a value indicating whether the 'ActiveImage' will be applied on mouse-hover.

Gets or sets a value indicating whether zooming is enabled.

Gets or sets a value indicating whether the image will be zoomed-in on focus.

Gets or sets a value indicating whether animations are enabled.

Automatically fades the image when inactive.

Gets or sets a value indicating whether the button will be automatically toggled to receive or release focus when clicked.

Gets or sets the distance between the container and the underlying image.

Gets or sets the distance between the container and the underlying image.

Gets or sets the angle of rotation for the image. Please provide a value between 0 and 360.

Gets or sets the time in milliseconds the zooming animation takes when active.

Allows you to easily get or set some ToolTip information to be displayed to the user on mouse-hovering over the control.

Gets or sets the image displayed in the image button.

(This property has been deprecated as of version 1.6.0.0. Please use the property 'ActiveImage' instead.) Gets or sets the image to be applied whenever the image button is active or hovered onto.

Gets or sets the image to be applied whenever the image button is active or hovered onto.

Gets or sets the default image size.

Gets or sets the maximum size of the image when hovered onto or active. This defaults to the standard set size of the control.

Flips the image to any given orientation. Supports both Vertical and Horizontal orientation-flipping options.

Gets or sets the border options to be used in the Image Button.

Gets or sets the returned by the Image Button.

Gets or sets a value indicating whether the size markers displayed at the control's top-area will be visible during design-time.

Gets or sets a value indicating whether borders will be viewed for the image applied during design-time.

Gets a value indicating whether the image button is currently zoomed-in.

Gets or sets a value indicating whether the Image button control is the default button.

Gets or sets the path or URL for the image to display in the Image Button.

Gets or sets a value indicating whether an image is loaded synchronously.

Gets or sets the image displayed in the Image Button when the main image is loading.

Gets or sets the image displayed in the Image Button when an error occurs during the image-loading process or if the image load is canceled.

Overrides the CreateParams method to stop flickering issues by setting the "WS_EX_COMPOSITED" (0x02000000) style.

Redraws the control's surface.

Notifies the iMAGE Button whether it is the default button so that it can adjust its appearance accordingly.

Raises the control's Click event.

Zooms in the image to the preset size.

Zooms out the image to its default size.

Rotates the image to a set angle of rotation.

Allow animation the rotation event? If yes, the rotation will be animated from one angle to another. The angle of rotation to apply. Please provide a value between 0 and 360. The rotating animation speed in milliseconds to apply. Default speed is 500(ms). Specify which action or method to execute once the rotation task is complete.

Sets the ImageLocation to the specified URL and displays the image indicated.

The path for the image to display in the Image Button. Exceptions: Thrown if url is null or an empty string. Thrown if url refers to an image on the Web that cannot be accessed. Thrown if url refers to a file that is not an image. Thrown if url refers to a file that does not exist.

Displays the image specified by the ImageLocation property of the Image Button.

Exceptions: Thrown if ImageLocation is null or an empty string.

Loads the image asynchronously.

Loads the image at the specified location, asynchronously.

The path for the image to display in the Image Button.

Cancels an asynchronous image load.

Calculates the correct image-size as per the applied state.

Renders the required image as per the applied state.

The image-state-type to be used.

Renders the required image as per the applied state.

The image-state to be used.

Draws a user-defined Graphics canvas.

The Graphics canvas. The canvas rectangle-bounds. The canvas corner-radius. The canvas border-thickness. The canvas border-color. The canvas border-style. Color of the fill.

Select the image displayed in the PictureBox.

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.

Provides a standard Rotation Dropdown UI Editor.

Provides a list of supported border options for use with Bunifu Image Buttons.

Creates a new property object.

Gets or sets the control's border-style option.

Gets or sets a radius for the control's edges.

Gets or sets the control's edge or border-thickness.

Gets or sets the control's background color.

Gets or sets the control's border color.

A strongly-typed resource class, for looking up localized strings, etc.

Returns the cached ResourceManager instance used by this class.

Overrides the current thread's CurrentUICulture property for all resource lookups using this strongly typed resource class.

Looks up a localized resource of type System.Drawing.Bitmap.

Looks up a localized resource of type System.Drawing.Bitmap.

Looks up a localized resource of type System.Drawing.Bitmap.

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.

Image-rendering extensions class for Bunifu Image Button.

Provides flip-orientation options for image containers.

Flip image to normal setting.

Flip image horizontally.

Flip image vertically.

Rotates an image container to a specified angle or degree.

The graphics object to be used. The angle of rotation. The final width of the image. The final height of the image.

Flips an image container to a specified position.

The graphics object to be used. The flip orientation. The final width of the image. The final height of the image.

Flips an image container to a specified position.

The graphics object to be used. The flip orientation.

Flips an image container to a specified position without an angle of rotation.

The flip orientation.

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.