// Type definitions for imagemapster 1.2.10 // Project: http://www.outsharked.com/imagemapster/ // Definitions by: delphinus // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped import jQuery = require('jquery'); declare global { namespace ImageMapster { type Select = "select"; type Deselect = "deselect"; type Set = "set"; type Get = "get"; type Highlight = "highlight"; type Unbind = "unbind"; type Resize = "resize"; type Snapshot = "snapshot"; type Rebind = "rebind"; type Keys = "keys"; type SetOptions = "set_options"; type GetOptions = "get_options"; type Tooltip = "tooltip"; type ToolTipCloseEvent = "area-mouseout" | "area-click" | "tooltip-click" | "image-mouseout"; type State = "highlight" | "select"; interface RenderingOptions { /** * fade effect - can only be applied to "render_highlight". * * Use a fade effect when highlighting areas on mouseover. */ fade?: boolean; /** * The duration of the fade-in effect, in milliseconds. */ fadeDuration?: number; /** * highlight areas on mouseover. When null (default), the behavior is * disabled for mobile browsers. You can explicitly enable or disable * it by setting this option to a boolean value. */ highlight?: boolean; /** * the map or an area on the map can be selected (or deselected). * * When true, the image map will function like a multiple-select menu. * Users can click any area to select or deselect it. When applied to * the entire map, it determines whether or not the click-selection * functionality is enabled. When applied to an area, it determines * whether that individual area (or group) can be selected. By default, * the map and all areas are selectable. */ isSelectable?: boolean; /** * the map or area on the map can be deselected. * * Normally true, this option can be used to prevent users from * unselecting items once they have been selected. When combined with * singleSelect, the effect is that one and only one option can be * selected at any given time. Users cannot deselect the active option. * This provides a menu-like functionality. It is possible for zero * items to be selected if this is the default state (or the only * selected item is deselected programatically). */ isDeselectable?: boolean; /** * only one area can be selected at a time * * When true, only one or zero areas can be selected at any given time. * If an area is selected and the user selects another area, the * previously selected area will become deselected. Unlike * "staticState", this property cannot be overridden by setting areas * programatically, only one (or zero) areas can ever be selected when * this option is true. */ singleSelect?: boolean; /** * the map or area is permanently in a selected or deselected state. * * When true or false, the map or area to which this option applies * will be permanently selected or deselected. Typically this is more * useful applied to individual areas that you want to exclude from the * interactive part of the map. * * staticState forces an area to be always selected or deselected. If * set, this will supercede isSelectable. Something with a staticState * will always be in that state and it cannot be changed by the user. * Note that when setting states programatically, this option will not * be honored; it only affects user interaction. */ staticState?: boolean; /** * initial selection state of an area. * * The area in question is selected. To set default selections when * creating a new mapster, use this option for a specific area (see * above). */ selected?: boolean; /** * Use an alternate image of the same size as the imagemap as the * source for highlight or select effects. * * When specified, the mapster will highlight areas using the image * data obtained from the same area in an alternate image, instead of * using a fill effect to highlight or select the area. This feature is * currently available in browsers with HTML5 canvas support. In * practical terms, this means it will work in all commonly used * browsers except IE 8 or lower. * * If this feature is enabled when an unsupported browser is used, it * will fall back to the normal highlight method. * * The fill, stroke and opacity effects can be specified independently * from those used for the normal higlight effect. This ensures that * when your page is viewed with a non-supported browser, you can still * control the rendering as would be appropriate for a normal * fill/stroke effect, which may be different from when you're using an * alternate image. */ altImage?: string; altImageFill?: boolean; altImageStroke?: boolean; altImageOpacity?: number; /** * Areas should be flood-filled when moused over or highlighted. */ fill?: boolean; /** * The color used for flood fill. */ fillColor?: string; fillColorMask?: string; /** * The opacity of the fill. This is a number from 0 to 1. */ fillOpacity?: number; /** * Areas should be outlined when moused over or highlighted. */ stroke?: boolean; /** * The color of the outline. */ strokeColor?: string; /** * The opacity of the outline. */ strokeOpacity?: number; /** * The width of the outline. */ strokeWidth?: number; /** * The options below control the way highlighted areas are rendered. * Each can be applied globally to the map, or to each element, using * the areas option to pass area-specific options. These options apply * to either highlighted or selected areas. Highlighting occurs when * the mouse enters an area on the image map. Selection occurs when an * area is clicked, and selection is enabled. These options will be * applied to both situations if present in the root of the options * object. They can also be applied to one or the other situations * specifically using the render_highlight and render_select options. */ render_highlight?: string | RenderingOptions; render_select?: string | RenderingOptions; } interface AreaRenderingOptions extends RenderingOptions { key: string; /** * when rendering an area or area group, also render the areas in the * other group (or groups) specified * * This is an area-specific option that allows you to create * supergroups. A supergroup is a collection of groups that will all be * highlighted simultaneously, but only when the area that defines the * supergroup is moused over or activated through code. * * When the area for which this option has been set is activated, all * the areas specified in the includeKeys list will also be rendered. * This is a one-way relationship. Defining a supergroup in an area * causes all the other groups to be highlighted, but not the other way * around. * * A typical use of this is to define areas that you want to be * highlighted when the mouse enters some specific area, but that you * do not want to be highlighted on their own if the target area is * moused over. This could be a hidden menu, for example: you want the * menu to display when the hotspot is moused over, but when it's * hidden, mousing over the menu area itself should have no effect. */ includeKeys?: string; /** * the area is a mask rather than a highlighted area. * * Normally, every area in an imagemap is an active area, and would be * highlighted when moused over (unless its behavior was otherwise * specified with staticState). The isMask option allows you to * identify an area as being a mask. When a mask is part of an area * group, the masked area will be specifically excluded from the * rendering of a highlight or selected state. * * This is usually used in conjunction, or instead of, the nohref * attribute of the area tag. When nohref is specified on an area tag, * that area is specifically excluded from the hotspot of any area that * encompasses it. It will not respond to mouse events, and will not be * highlighted. This can be used to create "holes" in hotspots. By * default, ImageMapster will treat any area with nohref or no href tag * as masks, the same as if this option had been applied. * * Sometimes you won't be able to use nohref to identify something as a * mask, for example, if you intend to re-use an area has both a mask, * and an independent hotspot. This would be typical if you wanted to a * selectable area that was completely included within another * selectable area, but functioned independently, such as concentric * circles. In this case, you would need to identify the inner circle * as both a mask, and a hotspot. The nohref attribute would make it * not act as a hotspot, and only function as a mask. You couldn't also * select the inner area. You can solve this problem by including the * inner circle in two different groups - one group which is a mask for * the main area, and another which is an independent selectable area. * You can specify different options for each group, so even though * it's just one area, it can function as two completely independent * ones. * * There may also be situations where you do not want an area marked * with nohref to be treated as a mask. For example, given "area1" and * "area2," you may want to create a configuration where mousing over * "area1" causes both "area1" and "area2" to be highlighted, but * "area2" should not be highlighted on its own when it is moused over. * In this situation, you'll need to use "nohref" to prevent the hover * behavior for the area, but you still want it to be treated normally * when it's rendered as a result of mousing over "area1." You can * accomplish this using the noHrefIsMask global option, below. * * Generally, masked areas will appear as a window to the underlying * image. If stroke is in effect, the stroke will be rendered for the * mask as well as the areas, to create both inner and outer borders. * You can always specifically enable or disable this, or any other * effect, for any area as desired. * */ isMask?: boolean; /** * tool tip data for an area * * When this area-specific option is present and showToolTips = true, a * toolTipContainer will be created this will be inserted into it, * either as inner text (if only text as passed) or as HTML if a jQuery * object is passed. In order to pass anything other than plain text * using this option you must use a jQuery object. Any string will be * treated as plain text (and special characters rendered correctly). */ toolTip?: string; } interface OnClickData { /** * $(item) from boundList */ listTarget?: JQuery; /** * mapKey for this area */ key: string; e: JQueryEventObject; selected: boolean; } interface OnStateChangeData { /** * map key */ key: string; state: "highlight" | "select"; /** * indicating the current state (following the event) */ selected: boolean; } interface OnMouseData { /** * area key */ key: string; /** * true if area is currently selected */ selected: boolean; e: JQueryEventObject; options: AreaRenderingOptions; } interface OnGetListData { /** * primary mapKey for this area or area group */ key: string; /** * mapValue for this area or group */ value: string; /** * array of areas that make up this group */ area: any[]; options: AreaRenderingOptions; } interface OnShowToolTipData { /** * jQuery object of the tooltip container */ toolTip: JQuery; /** * map key for this area */ key: string; /** * current state of the area */ selected: boolean; areaOptions: AreaRenderingOptions; } interface Options extends RenderingOptions { /** * an attribute identifying each imagemap area. * * If specified, this refers to an attribute on the area tags that will * be used to group them logically. Any areas containing the same * mapKey will be considered part of a group, and rendered together * when any of these areas is activated. If you don't want this * functionality, ensure each key is unique. When mapKey is omitted, * then each area is considered to be independent from the other and no * grouping is applied. * * When mapKey is present, any area tags that are missing this * attribute will be excluded from the image map e ntirely. This is * functionally identical to setting staticState=false for these areas, * except they will be inaccessible through the API. * * ImageMapster will work with any attribute you identify as a key. If * you wish to maintain HTML compliance, it's recommeded that you use * attribute names starting with "data-", for example, data-mapkey. Any * such names are legal for the HTML5 document type. If you are using * older document types, the class attribute is part of the HTML spec * for area and will not cause any visual effects, so this is also a * good choice. It is not recommended to use id, since the values of * this attribute must be unique. title and alt also will cause * possibly undesired side effects. * * You can specify more than one value in the mapKey attribute, * separated by commas. This will cause an area to be a member of more * than one group. The area may have different options in the context * of each group. When the area is physically moused over, the first * key listed will identify the group that's effective for that action. */ mapKey?: string; /** * an attribute on each area tag containing additional descriptive * information about an area. * * This option is applicable only when using onGetList. When set, the * data provided to the callback function will include the value of * this attribute for each group. This can be used to simplify building * a list with associated information, without having to match against * another resource. It also ties this information to the image map * itself. It is not required to use this option when using onGetList. * * For example, you could set mapValue: 'data-statename' to an imagemap * of the united states, and add an attribute to your areas that * provided the full name of each state, e.g. data-statename="Alaska". * This text would be included in the onGetList callback, and so you * could use it to construct an external list of states. * * If there are grouped areas (areas with the same key), then the value * from the first area found with data in this attribute will be used. */ mapValue?: string; /** * Clicking on a link should cause the browser to navigate to the href * whenever it's not a hash sign (#). Version 1.2.4.050 and later * * By default, ImageMapster will prevent the default browser behavior * in image maps, and "select" areas when they are clicked. If you want * to navigate to the url for an area, use this option. When enabled, * all areas that have an href attribute, and its value is not empty or * "#" (just a hashtag). * * When area grouping is used, if an href is present for any area in * the primary group, this will be used as the navigation target. This * way you don't need to copy the url for every area in groups, rather, * you can include it on just one, and clicking any area will cause the * appropraite navigation. */ clickNavigate?: boolean; /** * an attribute on items in a boundList that corresponds to the value * of the mapKey attributes. * * This is used to synchronize the actions on the imagemap with the * actions on a boundList. Each value should match a value from the * imageMap mapKey tag. Any item in the boundList with missing or * mismatched data will be ignored. */ listKey?: string; /** * attribute to set or remove when an area is selected or deselected * * If boundList is present, when a map area is selected, set or remove * this attribute on the list element that matches that area based on * their respective keys. */ listSelectedAttribute?: string; /** * a class to add or remove when an area is selected or deselected * * If a boundList is present, when a map area is selected, this class * is added or removed from the corresponding list element. This can be * used to easily create any kind of associated action when areas on * the map are changed. */ listSelectedClass?: string; /** * * define area-specific options; each object in the array must contain * a "key" property identifying a valid mapKey, and additional * rendering options specific to that area or group */ areas?: AreaRenderingOptions[], /** * add "classname" class to the wrapper created around the image, or * copy classes from the image if "true" */ wrapClass?: string | boolean; /** * add CSS to the wrapper created around the image */ wrapCss?: string | boolean; /** * delay removing highlight when mouse exits an area (1.2.5b36) * * Normally, when the user's mouse pointer exits an area, the highlight * effect is removed immediately. This behavior can be changed with * this option. Setting it to a positive number causes a delay of n * milliseconds before the effect is removed. Setting to -1 causes the * effect to remain active until another hotspot is entered (e.g., it * will only be removed when superceded by a different area being * highlighted). * * When using mouseoutDelay, the onMouseover event will still be fired * at the time the user's mouse pointer leaves the area. However, the * onStateChange event will be delayed until the highlight is actually * removed. * * Whether or not you are using mouseoutDelay, only one area can be * highlighted at a time. That is, whenever the mouse pointer moves * onto a new active area, any previously highlighted area will become * un-highlighted, regardless of any delay in effect. Hovering over a * new area will always supercede any delay and cause the new area (and * only the new area) to be highlighted at that time. So, for dense * imagemaps where most areas adjoin one another, this option may not * have much effect within the boundaries of the imagemap. Rather, it * is intended to help keep the higlights active for imagemaps that are * sparse, or have very small areas. */ mouseoutDelay?: number; /** * sort the values before calling onGetList * * If a non-false value or "asc" is passed, the list will be sorted in * ascending order by the area value from mapValue. If "desc" is * passed, the list will be sorted in descending order. */ sortList?: boolean | "asc" | "desc"; /** * time (in milliseconds) to wait for images to load before giving up * * When first bound, ImageMapster has to wait for the source image,and * any altImage images to load before it can finish binding. This is * necessary because otherwise it's not alwasy possible to know the * native size of the images. After this period of time, ImageMapster * will give up. If you have particularly large pages or images, you * may want to increase this to account for long load times. */ configTimeout?: number; /** * Automatically scale imagemaps to match the size of a * dynamically-scaled image. * * When you render an image, you can optionally define a size through * CSS or using the "height" and "width" attributes. If omitted, the * image will be displayed in its native size. If included, browsers * will automatically resize the image to display in the dimensions you * have provided. * * Starting with 1.1.3, ImageMapster will automatically recalculate all * area data to match the effective size of the image. This means that * you can set the size of your image to anything you want and * ImageMapster will work with no changes at all needed to the "area" * data. * * If this behavior is not desired for some reason, this can be * disabled by setting this option to false. */ scaleMap?: boolean; /** * Treat areas containing the onhref attribute (or missing the href * attribute) as masks. This is true by default. * * Set this to "false" to disable automatic masking of these areas. You * can control them explicitly by creating independent groups for areas * you wish to mask and assigning the isMask area-specific option when * using this option. * * There are some things to be aware of when using nohref and masking: * * * You must put the area that include the nohref attribute before * other areas that overlap it, or it will be ignored. * * * You should also explicitly omit the href tag when using nohref. * * * Due to limitations in rendering with VML (e.g. Internet Explorer * 6-8), it is not possible to create a true mask, which would allow * the underlying image to show through the masked area. Instead, the * "masked" areas are rendered on top of the highlighted area in a * different color. This can be specified for each area (see the * fillColorMask option below) to create the best possible effect. */ noHrefIsMask?: boolean; /** * a jQuery object whose elements are bound to the map. * * boundList can be any list of objects. To be bound to the map, they * must contain an attribute whose name is identified by the option * listKey, and whose value matches the value in an area tag's mapKey * attribute. If more than one element in the list has the same value, * the action will affect all matching elements. */ boundList?: JQuery; /** * enable tooltips * * When showToolTip is true, mapster will look for a property called * toolTip in the areas option for a an area. If present, a tool tip * dialog will be shown on mouseover for that area. It will * automatically be closed according to the behavior specified by * toolTipClose. This option does not apply at the item level, but * rather enables tooltips for the entire map. At the item level, only * the presence of tooltip data is necessary for a tooltip to appear. */ showToolTip?: boolean; /** * HTML describing the popup that will be created for tooltips. * * A div with some simple styling is included as the default tooltip * container. This can be replaced with anything using this option. * * When tooltips are rendered, the code attempts to determine the best * place for it. It will try to position it in near the top-left part * of the area, and continue to try other corners in order to render it * within the confines of the container where the image map resides. If * it can't be placed within the image, it will be placed in the * lower-right corner and extend outside the image. */ toolTipContainer?: string | JQuery; /** * specify the behavior that causes a toolTip to close. * * This option should be passed an array of strings that define the * events that cause active tooltips to close. The array can include * one or more of the following stings: * * 'area-mouseout' - tooltips close when the mouse pointer leaves the * area that activated it. This is the default. * * 'area-click' - tooltips close when another area (or the same one) is * clicked * * 'tooltip-click' - tooltips close when the tooltip itself is clicked * anywhere * * 'image-mouseout' - tooltips close when the mouse pointer leaves the * image itself. * * Under any circumstances, active tooltip will disappear when a new * one is created. You don't have to define an automatic closing * behavior; setting this option to an empty array will result in * tooltips never closing, leaving it to you to close them manually * though the tooltip method. */ toolTipClose?: ToolTipCloseEvent[]; /** * callback when a hotspot area is clicked. Return false to cancel * default select action, or true to navigate to the 'href' */ /** * a callback when an area is clicked.:silent doautocmd FocusLost % * * This event occurs when the usual click event happens, but includes * data from the mapster about the area: * * This can be used to perform additional actions on a click without * binding another event and having to obtain information manually. */ onClick?: (data: OnClickData) => void; /** * callback when mouse enters a bound area. * * This function is called when the mouse enters a bound area. */ onMouseover?: (data: OnMouseData) => void; /** * callback when mouse leavesd a bound area. * * Callback when the mouse leaves a bound area. The data structure * passed to the callback is the same as onMouseover. */ onMouseout?: (data: OnMouseData) => void; /** * a callback on mapster initialization that provides summary data * about the image map, and expects a jQuery list to be returned. * * This callback allows you to dynamically provide a boundList based on * summary data from the imagemap itself, rather than providing the * list up front. The event passes an array of AreaData objects * * The client should return a jQuery object containing all the elements * that make up the bound list, the same as if it was assigned * manually. */ onGetList?: (data: OnGetListData) => JQuery; /** * a callback when the mapster has finished initial configuration * * This event is fired when the mapster configuration completes. When * control execution continues after a first-time bind operation, the * mapster is not guaranteed to be configured, because images are * loaded asynchronously by web browsers. If a mapster is bound to an * image that is not yet loaded, it will attempt to rebind every 200 * milliseconds. This event will be fired when it is eventually * successful, or the length of time specified by configTimeout is * exceeded (default of ten seconds). * * The altImage option will also increase the time needed to configure, * because the alternate image is loaded by the client at configure * time to ensure it is available immediately when needed. */ onConfigured?: (success: boolean) => void; /** * callback when area state is changed (either highlight or select). * * onStateChange can be used to get more specific information than the * mouseover or click events. */ onStateChange?: (data: OnStateChangeData) => void; /** * callback when a toolTip is created * * This can be used to control tooltip closing behavior directly, if * desired. */ onShowToolTip?: (data: OnShowToolTipData) => void; } } interface JQuery { /** * * All images in the jQuery object will be bound. The specific example * above will attempt to bind to all images present on the page. Each image * must be bound to an image map identified with the usemap attribute. If * there is no usemap attribute, or it does not refer to a valid map, then * the image will be ignored. Therefore you can use this syntax to activate * all imagemaps on a page. Because pages often contain many images, * though, it will be faster to select just the image you are targeting * using a more specific selector. * * Images are often not completely loaded when script execution begins. * ImageMapster will ensure that all images are loaded before it permits * interaction from the client. If an alternate image is specified, this * will also be preloaded. * * Because images are loaded asynchronously, code execution will often * return to your script before the ImageMapster is available. If you apply * other methods to it (such as selecting or deselecting areas), these * commands will be queued until the image has been loaded, and then * executed automatically. So you don't need to worry about using callbacks * for initial configuration. You can assign a function to a callback when * configuration is complete if needed to perform other setup activities on * the page. */ mapster(options?: ImageMapster.Options): JQuery; /** * select: Cause an area to become selected. This is similar to a user * click, but will not cause a click event to be fired. * * Programatically select elements from the image map. The programmatic * selection/deselection methods will not honor the staticState property. */ mapster(method: ImageMapster.Select): void; /** * deselect: Cause an area to become deselected * * The opposite of select, this causes an area to become deselected. If it * was not previously selected, nothing changes. */ mapster(method: ImageMapster.Deselect): void; /** * set: select or deselect an area * * Select or deselect elements from jQuery objects wrapping "area" tags on * the map based on truthiness of selected. If the area represents a bound * area on the imagemap, it will be selected or deselected. The method can * be called from an AREA, or from a bound image, passing a specific key as * a 2nd parameter * * If the selected parameter is omitted (or anything other than "true" or * "false") then the state of each area will be toggled. * * You can include an object containing rendering options as the last * parameter. When present, these will supercede the default and * area-specific rendering options. */ mapster(method: ImageMapster.Set, selected: boolean, options: ImageMapster.RenderingOptions): JQuery; mapster(method: ImageMapster.Set, options: ImageMapster.RenderingOptions): JQuery; /** * get: get keys for all selected areas * * When no "key" parameter is included, returns a comma-separated list of * keys representing the areas currently selected. If specified, returns * true or false indicating whether the area specified is selected. */ mapster(method: ImageMapster.Get, key?: string): string | boolean; /** * highlight: highlight, clear, or return highlight state * * This method is used to control or obtain the current highlight state. * Setting the highlight does not mimic a mouseover, rather, it only sets * the highlight. Events and tooltips will not be activated. Even using * these methods, it is not possible to highlight more than one area at a * time. If another area is highlighted programatically, any existing * highlight will be removed. * * Once set this way, the highlight will be removed when any user-event * that would normally cause a highlight to be removed occurs (e.g. moving * the mouse into any area), or it is removed programatically. */ mapster(method: ImageMapster.Highlight, flag?: string | boolean): void; /** * unbind: unbind ImageMapster from an image * * Removes the ImageMapster binding from an image and restores it to its * original state. All visible elements (selections, tooltips) will be * removed. * * If the optional "preserveState" parameter is true, the selection overlay * and any active tooltips will be preserved. Tooltips can still be * dismissed by a user click, but once unbound, the selection states can no * longer be controlled either by the user or programatically. To remove * them, the actual DOM elements must be removed. * * Notes: When a mapster is first bound, several things happen. A div * element is created which wraps the image. A copy is made of the original * image, and the original image is set be transparent. This allows * creating visible elements for the selections & highlights without * interfering with the image map. Additionally, canvas elements are * created (for HTML5 browsers), or a VML elements are created for Internet * Explorer, to render the effects. Profile information about each bound * image map is stored in memory, and finally, event handlers are bound to * the image map. * * The "unbind" method cleans up these resources: it removes the wrapper, * restores the image to its original visibility state, and releases * internal resources. When using 'preserveState', the internal resources * are cleaned up and event handling is disabled, but HTML elements are not * removed. Each element created by ImageMapster is assigned a class of * "mapster_el", which can be used to target them for later removal, though * it is not easy to complete this process manually because of the wrapper * and styles applied during configuration, which will be left intact when * using "preserveState." */ mapster(method: ImageMapster.Unbind, preserveState?: boolean): JQuery; /** * snapshot: take a "snapshot" of the current selection state, and reset * ImageMapster * * This option is similar to unbind with preserveState. After a snapshot, * any active selections will still appear as they did at the time of the * snapshot, but they are no longer part of the ImageMapster. This is * useful for configuring an initial state, or creating complex * representations that may not be easily accomplished with area * configuration options. * * For example, you could bind in image with a specific set of options; * programatically select some areas; and take a snapshot; then set new * options that cause a different rendering mode. This way you could have * certain areas appear differently from the selection highlight, but be * "highlighted again" using the new rendering options. Any effects in * place at the time of the snapshot essentially become part of the image * and are not affected by future operations. */ mapster(method: ImageMapster.Snapshot): JQuery; /** * rebind: rebind ImageMapster with new options * * This method is similar to set_options, in that its purpose is to change * options for an existing bound map. However, unlike set_options rebind * will immediately apply all the new options to the existing map. This * means that rendering options will change areas that are already selected * to be rendered with the new options. If you pass area-specific options, * these will also be applied, e.g. you could cause new areas to be * selected by passing selected: true in an area specific options. * * set_options, in contrast only changes the options, and does not apply * them to any existing data. When using set_options the new options only * apply to future actions. */ mapster(method: ImageMapster.Rebind, options: ImageMapster.Options): JQuery; /** * resize: change the size of the image and map * * This will resize the image map to the dimensions specified. Note that * either width or height should be passed, and the other will be * calculated in the same aspect ratio as the original image. If you pass * both, only the width will be used to calculate the new dimensions: the * proportions must remain the same as the original image. (Though I intend * to allow scaling without constraining proportions, it will be difficult * to make work for certain shapes -- e.g. circles, which would have to * become ovals). * * This method will recalculate and re-render the entire imagemap, so it * will work exactly the same under the new sizing scheme. When the image * is unbound, the imagemap will be restored to its original condition. * * When using HTML5 canvases, any existing selections, etc. will be * preserved during the animation. VML data cannot be resized dynamically, * however, so in IE<9 the selections will be erased, then redrawn when the * animation is complete. */ mapster(method: ImageMapster.Resize, width: number, height: number, duration?: number): JQuery; /** * keys: get the primary mapKey (or comma-separated list of keys) for an * area, set of areas, or key group. Version 1.2.4.050 * * This method allows you to obtain the primary mapKey (or keys) associated * with another key, or one or more areas. If the all parameter is true, * the method returns all keys or groups that include the area. * * When using area groups, it is possible for more than one key to be * associated with a map area. It's also possible for an area to be * highlighted from code as part of a group, but be inaccessible to the * end-user. This is because area groups are separate physical entities * from the areas defined by their primary key. They can have different * options, and are highlighted independently. Note: the way area groups * work is not well documented here yet. I am working on a more * comprehensive tutorial for the site. In the meantime please see this * example which describes area groups in detail, and shows how they work * through an active demonstration. * * There are reasons you may want to be able to access the primary keys * that make up an area group directly. Perhaps you want to select a group * of areas using the options from a group - but not as a separate group. * Perhaps you want to be able to compare the area clicked against a group * you have defined to take some action if the area is a member of a * certain group. This method provides access to that information. * * This method allows working with groups in a variety of ways by providing * access to a complete list of primary keys in any group, or all keys * which contain a given primary key. */ mapster(method: ImageMapster.Keys, key: string, all?: boolean): string | string[]; mapster(method: ImageMapster.Keys, all: boolean): string | string[]; /** * set_options: set active options * * When called without the "options" parameter, returns an object with all * active options. When the parameter is included, the active options are * updated for the imagemap, and any area options are merged with existing * area options. Unlike "rebind", this will not rebind or reapply any * options, but only update the state. This may affect future actions, but * it will not change any existing state information. */ mapster(method: ImageMapster.SetOptions, options?: ImageMapster.Options): JQuery; /** * get_options: get active options * * When called with no parameters, returns the options that the mapster was * configured using. When called with a single key it returns the * area-specific options assigned to that area. The final parameter * effective determines whether the actual options in effect for this area, * or the specific options assigned are returned. * * Areas inherit the global options assigned, but can be overridden by * area-specific options. The "effective" options contain all options * including those that are inherited, as well as any specifically assigned * to the area. */ mapster(method: ImageMapster.GetOptions, key?: string, effective?: boolean): ImageMapster.Options | ImageMapster.AreaRenderingOptions; /** * tooltip: show/hide tooltips from code * * See the tooltip options section below for options to control how * tooltips appear and are dismissed. * * This method can be used to manipulate tooltips from code. If the global * showToolTip option is false, these methods will still work, so you have * the ability to control tooltips bound to areas completely using your own * logic, if desired. These methods can also be used to have better control * over events needed to close the tooltip, e.g. you could have no tooltip * closing event, but add a "close" button to your contianer that will * cause the tooltip to close when clicked. */ mapster(method: ImageMapster.Tooltip, key?: string): JQuery; } }