|
|
| FlashStudio PRO | Wed 8 Jan 2003
 | FlashStudioPRO Review

- Introduction
- General Overview
- FSCommands
- Awkward things
- Conclusion
1 - Introduction
FlashStudioPRO is a tool created by MultiDimensionalMedia. It converts SWF's into exe's, but adds a lot of extra power/possibilities to the exe's (projectors) that are simply not possible using the publish to exe option inside Flash. There are many tools around that also do this, 2 of the most well-known are NorthCode's SWF Studio and FlashJester's Jugglor. These tools also add extra functionality to the published exe's. So obviously, the question needs to be asked if FlashStudioPRO deserves a place among the rest of the tools and if so, what extra's does it have to offer and where does it stand among the other tools.
Like most of the tools out there, FSP is Windows-only.
2 - General Overview
FlashStudioPRO looks and feels very similar to most of its competitors. It offers a small but clean GUI which doesn't look too attractive, but it doesn't have to be, it has to deliver, right?
FSP uses 3 pull-down menu's and 8 tabbed pages. Here's a short overview of each of these elements:
The pull-down menu's:
- File:
Here the user can save and load the settings for all the tabs of FSP. This is very useful when for instance an application has to be tested many times over a period of time, so that the person responsible for creating the exe doesn't have to redo all the settings on the tabs every time he/she opens up FSP. There's also an option to quit FSP here.
- View:
This brings up a pulldown with shortcuts to the 8 tabs.
- Help:
A pulldown with shortcuts to the fscommand reference (more about fscommands in part 3), the online examples & source code files, a 'show tips at startup' toggle, a shortcut to check for updates and an 'About Flash Studio' shortcut.
The different tabs of the program:
- Input File:
Here the user can tell FSP what SWF to use and whether or not a preview of the SWF should be shown (this does not show the results of any of the new fscommands however). Even tho the width & height fields are selectable and display a blinking cursor when the textfield is selected, they are *not* editable. So the resulting exe cannot be given a different dimension in this screen. This can be achieved under the 'Size/Position' tab.
- Style:
Here the user can decide how the exe will be shown, from the standard Windows app-window to a borderless (chromeless) window, 6 options in total. The user can also select a custom icon for the exe. Apart from the borderless option, a caption (app-title) can be set. The user can also select if the exe will be shown in the tray or not, if it will be shown in the taksbar or not (and yes, the exe can be both shown in the taskbar and the tray or in neither) and if the caption (title-bar) needs to be shown or not. And for Win2K and XP users, the exe can fade in and/or out to a designated alpha-value, so the exe will fade in to for instance a half-transparent state and once the exe is closed it will fade out again. The alpha needs to be set in the 0-255 range, where 0 if fully transparent and 255 is fully opaque. However it always fades in using a black backgroundcolor. No matter what I tried with the different settings, I couldn't get it to use the backgroundcolor I supplied for either the movie or the application. Fading out works perfectly however. It is also possible to achieve this effect using a new fscommand, 'flashstudio.alpha', more about this in the fscommands section.
- Size/Position:
This tab allows the user to specify the size of the application, whether it should be opened maximized (fullscreen), using the movie's internal size (which is read incorrectly when the movie is compressed when published for the Flash6 player) or using user-specified sizes (which include the borders and/or caption/title-bar if set so the movie's size will be smaller and possible not have the correct aspect-ratio anymore, so be aware of this!). Also the scaling settings can be changed for both the aspect-ratio (this means that the movie will or will not be distorted when the height and width ratio inside the exe is different than that inside the original movie) and for when the app is resized (if this is possible, this depends on the Window Style set inside the 'Style'-tab). The starting position of the app can be set at a specific coordinate (negative coordinates or coordinates that fall outside of the screen-resolution are possible and will work, so be aware here) or it can be centered on the screen. The application's backgroundcolor can also be set here. The movie's backgroundcolor however can be set on the 'Flash'-tab.
- Mouse/Keyboard:
The user can assign certain actions to the mouse-buttons here. The left mouse-button can be set to drag the window or to just send its state to the movie so it can be captured and used inside the movie. These options are also available for the right mouse-button, which can also be set to be ignored by the app, which in effect means that there's no right-click menu. Beware tho that this does not work on the parts of the app in which a browser-instance or a Media Player-instance are created or on the app's borders, their own default right-click menu still gets triggered. If you want to create a custom right-click menu, you can do this thru the new fscommands, see chapter 3 for an example. The user can specify whether or not the app will respond to Escape and/or Alt-F4 (these options should obviously be used with caution), and if the movie will be able to receive keyboard-input or not.
- Flash:
Here the user can toggle the content of the right-click menu (if available), whether it shows all the options or only the 'Settings...' and 'About...' options. This is similar to how fscommand("showmenu",true/false) works inside normal Flash-movies. It's also possible to toggle the movie's loop settings, whether it should loop or not. The quality of the movie can be set to either 'low' or 'high', it's not possible to set the quality to 'medium' or 'best', but the quality can still be set from within the movie thru normal ActionScript.
- Files:
This is a very special feature of FSP. It's possible to make a 'package' of files on this screen. These additional files all get a unique id-name (you can change these, FSP doesn't ensure they are all different tho) and are included in the exe. They are not directly accessible from within the application to interact with tho, but instead they can be 'extracted' from the exe thru the new fscommand's that come with FSP, 'flashstudio.extract' and 'flashstudio.extract_abs'. This means that these files (whichever ones you want, you can specify which one by using the unique id-name you have given it) can be extracted from the exe and saved locally on the user's comp. This can be useful for when you want to create a small installer or when you want to make sure the user has a certain file, etc. A maximum of 20 files is allowed.
- Output File:
In this screen the user can specify if the app will expire or not, and if so, for how many days the app will work. The user also needs to provide a 12-digit code, which is used within the exe and is not used as a sort of registration code for when the exe expires. The documentation mentions it should be a 12-digit code, but it seems to accept any code which has 12 alpha-numerical characters (letters and numbers). In this tab it is also possible to specify that instead of an exe a screensaver (.scr) should be made. However, even with this option selected, the output-file will still have the .exe extension. This can be changed by the user ofcourse, but does seem a bit odd. The user can also select the kind of compression that should be used on an exe, the choices being 'Fast', 'Normal' and 'Best'. They add about 990KB, 720KB and 710KB (respectively) to the resulting exe. It is also possible to include the FlashOCX (Flash plugin for IE) with the exe, which adds an extra 510KB or so. There is also a possibility to create an autorun.inf file, which is used to autostart CD's. On this screen the user can also specify the name of the file that will be published and in which directory it will be saved to. There's also a progress-bar and the option to be prompted after the app has been created.
- Batch:
Like the name says, this tab offers the possibility to specify a batch of swf's to be converted into exe's (which all have the same name as their respective swf's) which are all converted using the settings of the other tabs. It's not possible to manually select the files that should be included in the batch, the user can only specify the directory in which *all* found swf's will be converted. Still a very useful feature that, combined with the ability to save & load the FSP settings, can take away a lot of repetitive, manual work in a large project for instance.
These menu's and tab's form the GUI of FSP. Most of the features here are easy to understand and useful, esp the batch-option, the expiration-option and the ability to pack additional files into the exe and save them on the user's drive at will are great and useful.
But there's a different area in which FSP really shines, and that is the extra fscommands it adds to the exe. The next chapter will be about them.
3 - FSCommands
One of the most interesting features of FlashStudioPRO, esp for developers, is the addition of several new fscommands for use in any exe created using this tool, over 150 new ones in fact. The existing fscommands such as 'allowscale' and 'quit' do *NOT* work in exe's created using FlashStudioPRO... But using the settings provided with the tool and the new fscommands, the built-in fscommands in Flash can usually be replicated. There is also a difference in how the fscommands are called. All the fscommands available are preceded by a 'flashstudio.', so for instance the replacement for the built-in fscommand("exec",...) is now called fscommand("flashstudio.exec",...). Since there are well over 150 new fscommands, this review would turn out to be insanely long if I were to give you a review of all of them. So I have decided to give you a rundown of some of the most interesting ones and other noteworthy things I have found while playing around with the various fscommands.
One thing to take notice of is the way the new fscommands work. If any arguments needs to be sent to the fscommand, they need to be put inside one long string in which the arguments are comma-separated if there is more than 1 argument, which then gets sent to the fscommand. Also take notice that any values put straight into the argument-string (so strings and numbers) need to be put in as strings, so they need to be enclosed by quotes, only variables don't need to be surrounded by quotes. Using single quotes for the argument-string and double-quotes for a string-variable does work as well tho, so you don't need to escape the string/number/values.
Examples of how this works:
ActionScript:
// using a variable as argument
theMsg = "FlashDevils roxxx!!!";
fscommand("flashstudio.prompt","theMsg");
// using a value as argument
fscommand("flashstudio.prompt","\"FlashDevils roxxx!!!\"");
// this works as well (double quotes surrounded by single quotes)
fscommand("flashstudio.prompt",'"FlashDevils roxxx!!!"');
// several arguments, mix between variables & values
posX = posY = 0;
theURL = "http://www.flashdevils.com/";
fscommand("flashstudio.browserload",'posX,posY,"400","300",theUrl');
// 'flashstudio.prompt' brings up a Windows message-box with the message specified
// 'flashstudio.browserload' opens an instance of IE inside the app, more about this later
//
// some examples of incorrect uses:
// the argument-string *always* had to be surrounded by quotes
theMsg = "FlashDevils roxxx!!!";
fscommand("flashstudio.prompt",theMsg); // doesn't work
// numbers inside the argument-string *always* have to be surrounded by quotes
fscommand("flashstudio.browserload",'posX,posY,400,300,theUrl'); // doesn't work
|
This also clearly shows how all FSP fscommands are preceded by 'flashstudio.'.
Another thing to take note of is that some of the new fscommands will return a value. This value will always be a string, even when its value is for instance 'true'. The way to catch this return-value is to tell the fscommand in which variable to put the return-value, this is typically the last argument inside the argument-string. Usually these return-values will be available one frame after the fscommand is issued, but in some cases where for instance an outside connection is involved this can take a bit longer.
Some highlights:
flashstudio.browserload : this can be used to open an instance of Internet Explorer *inside* the app to open the page specified as an argument, the position and dimensions of the instance also need to be supplied as arguments. This instance is loaded in *on top* of all the exe's content. After issueing this fscommand, it's possible to load in the HTML-source of the page into a variable using the 'flashstudio.getbrowserdata' command. In an early version of FSP 1.7 (my original test-version) the HTML-source that was being put in a variable was not a literal copy of the HTML-source but had a few strange anomalies. Fortunately this has been fixed, now a literal copy of the source is put into the assigned variable. All in all, the possibility to open an instance of IE (which needs to be pre-installed onto the user's computer obviously) is very very nice.
There is also an accompanying fscommand to close the browser-instance.
Apart from this feature, it is also possible to browse within the IE-instance, and even use new fscommands to open new pages inside the instance and use IE's back & forward functionality. With a little bit of imagination, it's not hard to imagine and build a small custom browser being built using FSP and its fscommands.
Here's a short example on how to open up an instance of IE inside an exe, display a page inside it and display the source of that page as well:
ActionScript:
// set the positioning variables for the browser-instance
posX = posY = 0;
w = 400;
h = 200;
theUrl = "http://www.flashdevils.com/";
fscommand("flashstudio.browserload","posX,posY,w,h,theUrl");
// now we try to get the page's source-code
theHTML = "";
createTextField("theText",1,0,200,400,200);
theText.wordWrap = true;
// make a setInterval
intID = setInterval(function () {
// try to get the source
fscommand("flashstudio.getbrowserdata","theHTML");
// if anything is returned, display it
if (theHTML!="") {
theText.text = theHTML;
clearInterval(intID);
}
},3000);
|
One thing to note here is that I used setInterval to wait for a bit while the IE-instance gets fired up and has time to load in the URL before I try to access the source-code. Otherwise every time I request the source-code while it is not yet available, an error-message gets shown. Since 'browserload' does not return a value after the page has loaded in, it is quite a challenge to determine exactly when to make the source-code request without running the risk of the user seeing an error-message.
In a smiliar fashion to the previous example, it is also possible to load in an instance of Windows Media Player (if pre-installed on the user's system ofcourse) on top of the exe to show movies in. The shown movie can be controlled via play & stop functionality thru fscommands. The shown movie always maintains its internal aspect-ratio, the rest of the allocated space for the Media Player instance ends up as a black rectangle.
Since this feature uses the installed Windows Media Player, any file that can be played inside the installed Windows Media Player, will also play in the Media Player instance created inside the exe.
There is also an accompanying fscommand to close the Media Player instance.
Here's a short example of how to load in and control an mpeg-movie:
ActionScript:
// set the positioning variables for the Media Player-instance
posX = posY = 0;
w = 320;
h = 240;
theUrl = "testMPEG.mpg";
fscommand("flashstudio.mpload","posX,posY,w,h,theUrl");
// stop-play functionality
isPlaying = true; // the movie auto-starts, so is playing
this.onMouseDown = function () {
// toggle state of movie
(isPlaying)?(fscommand("flashstudio.mpstop"):(fscommand("flashstudio.mpplay"));
isPlaying = !isPlaying;
}
|
From the limited amount of testing I have done, it seems that the browser-instance always lies on top of the SWF-movie, and the Media Player-instance lies on top of the browser-instance, so above anything else.
FSP also allows the user to interact with an Access or MySQL database. There are fscommands to open and close a connection to the DB, perform an SQL-query, get the results, close the connection, etc. The fscommands to access and control a MySQL database and an Access database differ tho, altho as far as functionality go, there's not a lot of difference. The fscommands for a MySQL database all start with 'mysql' while those for an Access database are unfortunately not named with such a prefix, so they are a little harder to spot/recognize at first.
When using a connection to a MySQL database, the result-set (for instance of a SELECT-statement) will be returned as one long string with different delimiters for rows and columns. These delimiters can be set by the user, they default to , for columns and ; for rows. However, a result-set when using an Access database can be returned as either an HTML1.0 table or as XML. Another difference is that there's 1 fscommand to perform a query on a MySQL db, 'flashstudio.mysqlquery', while there are 2 different ones to perform a query on an Access db, 'flashstudio.selectfromdb' to perform a SELECT-query and 'flashstudio.rundbquery' for all other query's (INSERT, DELETE, UPDATE).
Since I don't have access to an Access database here, I focused on the possibilities with connecting to and using a MySQL database directly thru the exe. It is surprisingly easy to connect to my local MySQL database and perform query's on it, retrieving data, even changing data, etc.
Here's a short example of how to start a connection to a MySQL db, check its status and make a query:
ActionScript:
// we will attempt to open the MySQL db and access data from it
// all results will be sent to 'retVar'
retVar = "";
s = 0;
host = "127.0.0.1"; // location of DB
port = ""; // port number
comp = true; // toggles transfer compression
un = pwd = ""; // username & password
db = "FlashDevilsDatabase"; // database name
fscommand("flashstudio.mysqlconnect","host,port,comp,un,pwd,db,retVar");
// make a textfield
createTextField("theText",1,0,0,550,400);
theText.wordWrap = true;
// place text in it continually
this.onEnterFrame = function () {
theText.text = retVar;
}
//
this.onMouseDown = function () {
switch (s) {
case 0: // let's get the status of the MySQL connection
fscommand("flashstudio.mysqlgetstat","retVar");
break;
case 1: // let's try a query
fscommand("flashstudio.mysqlquery",'"SELECT * FROM a_table",retVar');
break;
case 2: // get results of query using default delimiters
fscommand("flashstudio.mysqlgetresults",'"","",retVar');
break;
}
if (++s>2) s = 0;
}
|
I have no idea if there will be fscommands for more databases (PostgreSQL, Informix, Sybase, etc) in future versions of FSP, but MySQL and Access are 2 fairly common and often-used databases, so it's great to see that support for these 2 have been included. This is definitely an amazing feature!
Another feature is that it's possible to control the transparency (alpha) of the entire app, altho this only works for Win2K & XP users. This allows the user to fade in & out the app like possible using the 'Style' tab inside the GUI as mentioned above, but without the black background problem. Similar to the settings in the 'Style' tab for the alpha, the alpha needs to be specified inbetween 0 (transparent) and 255 (opaque). However, right as the app starts up it flickers at full opaqueness for a few milliseconds or so, and then the transparency is set to whatever is used for the first encountered 'flashstudio.alpha' fscommand. This can be avoided by enabling an alpha fade-in thru the 'Style'-tab inside FSP and setting the alpha-value it should fade-in to to 0. This way the app starts at 0 alpha cuz of the 'Style'-settings and then fades in correctly cuz of the script.
Using the literal method of setting the alpha (supplying a value directly rather than using a variable), you need to be aware that you need to supply the value as a string, not a number. This is why I prefer to use variables, as you don't need to escape them and it's much more readable.
Here's an example of a fade-in and of how to enter values/variables:
ActionScript:
// fade in from 0 to 255
alpha = 0;
// remember that arguments for the new fscommands
// *ALWAYS* need to be enclosed by quotes
// so this throws an error:
//fscommand("flashstudio.alpha",0);
// this also throws an error cuz the value is a number
// so it should be enclosed by quotes inside the argument
//fscommand("flashstudio.alpha,"0");
// this works correctly cuz the value is a string
// and the value is surrounded by quotes again
// cuz it is the argument:
fscommand("flashstudio.alpha",'"0"');
//
this.onEnterFrame = function () {
// set the alpha
fscommand("flashstudio.alpha","alpha");
// update alpha
if ((alpha+=10)>=255) {
// set end-alpha and delete this onEnterFrame
fscommand("flashstudio.alpha",'"255"');
delete this.onEnterFrame;
}
}
|
One thing for which tools like SWF Studio and Jugglor and such are commonly used is to get rid of the right-click contextmenu. In some of these tools it can even be replaced by a custom menu. But few allow the flexibility that FSP provides. FSP gives the user the opportunity to build a custom menu from scratch, even to add items at any point during the exe's playback. When such an item inside the menu is selected, the movie will jump to the keyframe on the main timeline of the movie whose framelabel is equal to the menu-item. The documentation incorrrectly specifies this is case-sensitive, however it is always good practice to make sure you are writing a variable-name/framelabel/etc the same throughout a movie.
Here's an example of a custom-made right-click context-menu:
ActionScript:
// build the fist item
theItem = "Item 1";
fscommand("flashstudio.insertcontextmenuitem","theItem");
s=0;
this.onMouseDown = function () {
switch (s) { // be sure to check the menu after each left-click
case 0: // add a new item
theItem = "Item 2";
fscommand("flashstudio.insertcontextmenuitem","theItem");
break;
case 1: // disable right-click menu
fscommand("flashstudio.disablecontextmenu");
break;
case 2: // add a new item to the old menu
theItem = "Item 3";
fscommand("flashstudio.insertcontextmenuitem","theItem");
break;
}
if (++s>2) s = 0;
}
|
In a similar fashion you can build a custom-made menu for the tray-icon as well as create custom-made Windows menu's (like the 'File' and 'Help' menu's inside Flash etc). Again, these items point to keyframes with corresponding framelabels inside your movie. These fscommands allow for a very professional and familiar look&feel to your app and are a great and useful addition to the fscommands.
Another amazing feature is the ability to control the app thru a remote application on a network, this can be another FSP-built Flash-projector or even a browser or another application. FSP gives the exe the ability to listen to a (user-specified) specific port on the network and retrieve and send info thru that port, start a fileserver, etc. This allows for a truly 'remote control' of the app.
Here's an example of controlling the exe thru a browser:
ActionScript:
// 'theText' is the var-name of a manually placed dynamic textfield on the stage
theText = "nothing yet";
// start listening for remote calls
fscommand("flashstudio.starthttp",'""');
this.onMouseDown = function () {
// stop listening to remote calls
fscommand("flashstudio.stophttp");
// reset text
theText = "back to normal";
}
//
// after starting up the exe, open this URL in the browser
// to change the shown text in the app
http://127.0.0.1?set&theText&FlashDevils%20Forever
|
For some of the aforementioned more advanced 'remote' applications FSP uses 'sockets' which use a different set of fscommands, but in essence it works just as easily. A truly amazing feature and I'm sure this will be one of the areas where FSP can really make a big name for itself. Again, these features allow for amazing and mind-blowing applications. It is even possible to fetch a file from an FTP-server or thru HTTP in the background and keep track of the download-progression, etc. I have been unable to test all of these fscommands to their full extent, but with a bit of imagination I can see countless of possibilities that would be relatively easy to achieve using FSP's new fscommands.
Some of the other features:
There is the ability to check whether or not the computer on which the exe is running is connected to the Internet or not. This is done using the fscommand 'flashstudio.checkconnection' which returns a string containing either 'true' or 'false'. So the app can be programmed in a such a way that for instance on start-up the app checks if there is an internet-connection, if so, it downloads its menu-settings from a central server, if not, it uses the built-in (or locally saved) back-up menu-settings, for example.
It is possible to take a screenshot of the screen and save it as a BMP-file anywhere you want on the user's comp. You can determine the position and size of the area you want to take a screenshot of, and this area can be anywhere on the monitor-screen, not just the app. After this you can use another fscommand to convert this screenshot (or any BMP-file) into a JPEG-file or a (transparent if necessary) PNG-file.
Give the app the power to logoff the user or restart and even shutdown the user's comp. This can be done with but also without prompting the user about this. Together with all the other nifty OS-like features (browse folders, create folders, drag a file onto the app and get the full path to the file, save/load to the registry, save/load files, send email without bringing up OE, etc) it would be fairly straight-forward to create your own custom Flash-based 'OS-shell' to run on top of Windows.
There are possibilities to allow a joystick to control the app and also to enable a fullscreen DirectX view of the app (change screen resolution and color-depth while the app is running), which could be used for for instance more Windows-like games.
It is also possible to run JavaScript and VBscript from within the app. Unfortunately the site & promotional emails mentions JavaScript but the help-files that come with FSP mentions JScript (Microsoft's implementation of JavaScript/ECMA-262) and even a link to Microsoft's JScript pages. I think JScript seems to be the supported language here, for instance JavaScript's Regular Expressions support doesn't seem to work, at least not for me. Given my lack of knowledge of JScript the few simple functions I tried did work perfectly however. Anyways, especially the ability to run VBscript from the app can be very handy since VBscript allows pretty easy access to the user's computer. Another very interesting feature!!
I would highly recommend checking out some of the excellent (downloadable) examples that you can find on the Multidmedia site , cuz there are *sooo* many possibilities with this tool, it would take me forever to go through them all, also cuz new versions of FSP keep coming out on a regular basis so by the time you read this there might be even more exciting new features and fscommands added to FSP.
MDM has already released version 1.8 of FlashStudio PRO with even more features then we were able to review. Check them out here.
4 - Awkward things
Some things that seem awkward/can cause surprises:
- FSP has problems reading in the correct width & height of an SWF if the SWF is compressed (this is an option only available for SWF's published for Flash6 players). Unfortunately this option is by default checked in the publish settings inside Flash, so beware of this, cuz the incorrectly read-in width & height of the SWF will be used for the exe unless specified differently inside the 'Size/Position'-tab, so this might give very funny but unexpected results. Fortunately FSP recognizes a compressed SWF and displays a message about this.
- When not having selected a movie to transfer into an exe and the user clicks 'Go' inside the 'Output File' tab, the progress-bar will still start to run and finish like it normally would. A warning message does pop up stating there's no input-file selected. No harm is being done here, it's just odd.
- Fading in an app on start-up always happens with a black backgroundcolor which changes to the movie's backgroundcolor once the fade in is done. Changing the background color and/or Flash movie color settings from within FSP doesn't change this behavior. I provided a small workaround in the FSCommands section.
- When the user tries to publish an exe and the filename & dir of the exe that should be created already exists and is running, FSP displays an error-message but will not be able to publish anymore, not even when the output-file's name has been changed or the opened exe has been closed. I could only get it back to work by restarting FSP.
5 - Conclusion
After having played around with FlashStudioPRO and having tried and tested its features and fscommands and comparing them to other similar products, I have to say FlashStudioPRO is more, much more, than just another tool out there. What makes FlashStudioPRO stand out from the crowd, is its vast array of fscommands, whick keeps on growin with every new release of FSP. They make the most incredible and powerful app's possible, and really can challenge the boundaries of your imagination. I can think of dozens of exciting applications for for instance Intranets where this tool would be invaluable in bringing together Flash and networking abilities.
Truly a magnificent & awesome tool... I can definitely recommend FSP to anybody who wants to create innovative standalone applications in Flash but who is limited by Flash's limited capabilities in that area.
Additions on version 1.8:
The biggest feature added is full ActiveX support and functionality. You can now insert custom or standard ActiveX/OLE objects directly into your Projector during runtime!
As always, Registered users can Update to 1.8 for completely FREE!
http://www.multidmedia.com for more details!
List of fixed bugs in version 1.8:
Databases empty spaces
Compressed Movies returning wrong sizes
Full list of new commands below:
flashstudio.browsersize
flashstudio.browsersize_per
flashstudio.browserload_per
flashstudio.browserrefresh
flashstudio.browserstop
flashstudio.browsergoto_target
flashstudio.browserisbusy
flashstudio.browserfavorites
flashstudio.browseraddfavorite
flashstudio.browseraddress
flashstudio.browsertitle
flashstudio.mpload_per
flashstudio.mpsize
flashstudio.mpsize_per
flashstudio.mpFastForward
flashstudio.mpFastReverse
flashstudio.mpduration
flashstudio.mpsetposition
flashstudio.mpgetposition
flashstudio.mpnomenu
flashstudio.mpmute
flashstudio.pause
flashstudio.settransparency
flashstudio.settransparentcolor
flashstudio.makeshortcut
flashstudio.setwallpaper
flashstudio.activexinsert
flashstudio.activexinsert_per
flashstudio.activexsize
flashstudio.activexsize_per
flashstudio.activex_doverb_primary
flashstudio.activex_doverb_show
flashstudio.activex_doverb_open
flashstudio.activex_doverb_hide
flashstudio.activex_doverb_InPlaceActivate
flashstudio.activex_doverb_DiscardUndoState
flashstudio.activex_doverb_custom
flashstudio.activex_close
flashstudio.activex_save
flashstudio.activex_load
flashstudio.activex_savedoc
flashstudio.activex_setproperty
flashstudio.activex_getproperty
flashstudio.activex_addmethodparam
flashstudio.activex_runmethod
flashstudio.activex_runmethod_ret
flashstudio.getftpfilelist
flashstudio.ftpmakedir
flashstudio.ftpremovedir
flashstudio.ftprenamefile
flashstudio.ftpfilesize
flashstudio.loadfromreg_int
flashstudio.loadfromreg_str
flashstudio.loadfromreg_bool
Flash Studio PRO |
| Total views: 31241 times |
Posted by: XemonerdX |
|
|
|