Contact Me


Recent Posts


Categories


Archives


Tags

3d actionscript Actionscript 2 Actionscript 3 api APIs as2 as3 brand caching carousel channel code compress contest contract CSS Flash flv fp10 free freelance gadget gadgets gdata google JavaScript jquery mvc papervision papervision3d PHP player playlist puremvc pv3d search tube tutorial twitter video widget XML you youtube

Recent Comments

  • Ahmed: Can you put up an example?
  • Ahmed: Hmmm sorry this is a tough one but I don’t work with ASP.NET! Sorry!
  • Michael: Good example but one question… in all the slider skinning I see with Flex the thumb overruns the left...
  • venkata: Hi I am using OAuth to connect to youtube api. I got accessToken and TokenSecret for a particular user. Now...
  • Ahmed: Good old flexlib, what component are you using?

Links


Help end world hunger

Don’t Misuse Fullscreen

Since Adobe introduce the fullscreen Flash Player mode in Flash Player 9, it’s come as a relief to many designers, developers and UX architects as now they didn’t have to cheat the browser to make their creating go “fullscreen” so to speak.

However, when should you use fullscreen? There’s lots of sites out there that have a fullscreen button but why? What’s the need in seeing a web site in fullscreen? It’s understandable having something like a presentation or a video go fullscreen, but when it comes to web sites, I think there’s no need really.

Firstly, most of the time people have their windows maximised across their screen, so going fullscreen will allow them to gain about 40px left and right and maybe 100px or so top and bottom.

For those people who don’t maximise their windows, like me, I think that the designers and developers need to be slick enough to understand why I don’t want a web site to fill up all 1920×1600px of my display.

This isn’t meant to be a rant, more of a point that you should think about next time you’re going fullscreen, make sure…

  • There’s a purpose to go fullscreen
  • That the UI acknowledges it’s now fullscreen and does some more magic
  • That you’re not just scaling the UI
  • That it doesn’t take too long for your application to adjust

I’ve come to this, well, post by looking at what’s going to change when the video player I’m creating for 1Click2Fame.com goes live. It’s got a fullscreen button, and for a good purpose, because people may want to see the video fullscreen.

The player does have a complex UI, as it allows for voting, authentication and so on, and it also has a frame around the video, but this is where one should think about what can be lost when going fullscreen. For example, the frame isn’t needed when the player has expanded to your monitor as it serves no purpose – why keep a big prominent frame there when the user has expressed that they want the video bigger?

Nevertheless, I then think it’s important to adopt a resizing strategy whereby your application keeps tabs on whether it’s fullscreen or not and adjusts itself accordingly, here’s some example code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
package
{
    import flash.display.Sprite;
   
    public class FullscreenTest extends Sprite
    {
        private var isFullscreen:Boolean                        = false;
       
        public function FullscreenTest()
        {
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;
           
            stage.addEventListener( Event.RESIZE, handleResize );
        }
       
        private function handleFullscreenToggle(e:*):void
        {
            if ( !stage.hasEventListener( FullScreenEvent.FULL_SCREEN ) )
            {
                stage.addEventListener( FullScreenEvent.FULL_SCREEN, handleFullscreen );
            }
           
            if ( stage.displayState === StageDisplayState.NORMAL )
            {
                stage.displayState = StageDisplayState.FULL_SCREEN;
            }
            else
            {
                stage.displayState = StageDisplayState.NORMAL;
            }
        }
       
        private function handleFullscreen(e:FullScreenEvent):void
        {
            if ( e.fullScreen )
            {
                isFullscreen = true;
            }
            else
            {
                isFullscreen = false;
            }
           
            stage.dispatchEvent( new Event( Event.RESIZE ) );
        }
       
        private function handleResize(e:Event):void
        {
            // use the 'isFullscreen' to determine what to show and how to resize
        }
    }
}

With this sample code, sort of a mini framework, you can see how the private var “isFullscreen” allows your functions to test the state of the player and do something useful, by that I mean adjust accordingly to the current view.

Just making your application go fullscreen without thinking about the UI is, I think, just a bit lazy. Think about what special stuff you can do, at the end of the day it’s a user interaction and if you don’t make the most of it, they why should the user do it in the first place? Tell me what you think!


Leave a Reply

Your comment:

Allowed tags: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>
Fork me on GitHub