let me start off by showing that I have this UIImageView set up in my ViewController:
Each one of the lines contains a UIButton for a body part. If I select a particular button, it will segue me appropriately.
What'd I like to do is, when the user taps (but doesn't release) the button, I'd like the appropriate body part to show like this:
I can achieve this using 2 options:
UIBuzierPath class to draw, but would take a lot of trial and error and many overlapping shapes per body part to get fitting nicely as similiar in a previous question: Create clickable body diagram with Swift (iOS)
Crop out the highlighted body parts from the original image and position it over the UIImageView depending on which UIButton selected. However there would only be one image per body part, but still less cumbersome then option 1.
Now, my question is not HOW to do it, but which would be a BETTER option for achieving this in terms of cpu processing and memory allocation?
In other words, I'm just concerned about my app lagging as well as taking up app size storage. I'm not concerned about how much time it takes to do it, I want to just make sure my app doesn't stutter when it tries to draw all the shapes.
Thanks.
It is very very very unlikely that either of those approaches would have any significant impact on CPU or memory. Particularly if in option 2, you just use the alpha channels of the cutout images and make them semitransparent tinted overlays. CPU/GPU-wise, neither of the approaches would drop you below the max screen refresh rate of 60fps (which is how users would notice a performance problem). Memory-wise, loading a dozen bezier paths or single-channel images into RAM should be a drop in the bucket compared to what you have available, particularly on any iOS device released in the last 5 years unless it's the Apple Watch.
Keep in mind that "premature optimization is the root of all evil". Unless you have seen performance issues or have good reason to believe they would exist, your time is probably better spent on other concerns like making the code more readable, concise, reusable, etc. See this brief section in Wikipedia on "When to Optimize": https://en.wikipedia.org/wiki/Program_optimization#When_to_optimize
Xcode have tests functionality built in(and performance tests too), so the best way is to try both methods for one body part and compare the results.
You may find the second method to be a bit slower, but not enough to be noticed by the user and at the same time a lot more easier to implement.
For quick start on tests here.
Performance tests here.
In CSS Sprites you will often find padding between each image. I believe the idea is so that if the page is resized then one image won't bleed into another.
I think this depends on the different types of browser zoom (best explained by Jeff).
However, I haven't been able to see this behaviour in my tests. Is this only a problem with older browsers? (I havent been able to test with IE6 at the current time so I'm counting that as 'old').
Should I still worry about leaving space? Its kind of a pain.
For instance :
A CSS Sprite I found for AOL has
padding between each image : VIEW
but The Daily Show decided not to
bother : VIEW
It shouldn't need to be padded, but when zoomed, especially in IE8 (betas more than the RC), there is image bleeding if there is no padding.
Best example is to go to Google.com -> Search, and zoom... you'll start to see "underlines" at the bottom right of the image as the zooming rounds up/down.
In theory, a 1px padding on all sides of a sprite should be fine.
Here's the sprite from Google (images)...
But when zoomed, the +,-,x icons bleed into the main Google logo.
Basically the answer is yes. Two years to the day after I asked this question will see the release of IE9. IE9 has this problem just as much - if not more than any other browser...
It's pretty infuriating because it's such a simple thing to fix.
With iPads increasing in marketshare - its's pretty essential to at least have a half decent experience with zooming un-uniform amounts.
I am going to have to put a single pixel border around every image to match the background color of the adjacent element (potentially different on each side). Fortunately I auto-generate all my csssprites based on an .xml file - so I can do this programatically without too much hastle. It's still a huge pain though...
Simon - My experience is that this is certainly still a problem.
In response to your second question, why not use transparent padding? (Perhaps you are still supporting ie6 and this is non-trivial, in which case, I'm really sorry).
Speaking of the older browsers (those using text zoom), you don't always need padding.
The main difference between your two examples is that the Daily Show sprite already includes the menu item's text in the image itself.
When using text zoom, the AOL menu items could stretch out vertically due to the larger font size, and the menu text might even wrap to two lines. To accommodate for such eventualities, those icons need a little padding to ensure they don't bleed. Typically, you'd just try to make sure it doesn't bleed on any of IE6's five text sizes.
Since The Daily Show's menu doesn't contain any (visible) HTML text its size won't be affected by text zoom (though you might need a line-height: 0; or so to be sure), so it doesn't need any padding.
As scunliffe already showed, browsers using page zoom may need sprites to have a little padding due to rounding errors.
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 9 years ago.
In the very near future my development setup will be upgraded and part of the deal will be dual monitors (yay!)
At least one of the monitors, possibly both, will be widescreen.
I've heard of developers using a second monitor, especially a widescreen monitor, in portrait mode. It allows for many more lines on the screen (albeit narrower) and runs a bit like having a long page of code.
Does anyone out there use this and think it's more effective?
I actually have 3 widescreen monitors in portrait mode and yes, it's a fantastic way to work. There's so much less scrolling around and you can fit all your debug / output / reference windows on screen at once.
The problem with using two monitors is that you'll generally be working on one main one and have output (or whatever on another). If you do have two, set it up so that your primary monitor is directly in front of you and the other (less frequently used) one is off to one side. I find that to be the best way to use a dual-monitor set up as it reduces RSI from being permanently twisted to look at a particular screen.
Additionally, there are some programs available to provide virtual screen splits which I've fund very useful for large/widescreen monitor setups.
[edit] ..and yes, you should write functions short enough to fit on a single page, but being able to see more functions at any one time can often make development easier in my experience :-)
[edit2] Running Visual-Studio-esque IDEs in portrait on a widescreen monitor is fantastic when it comes to debugging compile errors as you have more useable space to see code and errors at the same time. I suppose you could argue that if you compile regularly enough though, you shouldn't see that many errors at one time? ...but who codes like that? ;-)
Since you shouldn't write functions that are longer than a screen, making the screen much longer is a little bit of cheating, isn't it? ;)
Anyway, I found portrait mode not really better when coding, and only with my old 17" widescreen in portrait mode was viewing / editing documents better. With two large screens in landscape mode, You can put two pages on a screen when viewing documents, and have many tool windows open at both sides of the IDE's text editor. So no, portrait mode is not better, unless you have four of them to make up a really large screen (there was a photo of such a setup on a Microsoft blog, but I don't remember where).
There are some applications where portrait is still better, though, e.g. if you have to show a document in large resolution, or if you have some monitor (as in network monitor) running and want to see more lines at once.
I can't imagine how that would speed up productivity. In my opinion, it is always easier to scroll up/down than left/right.
It depends on which IDE you use, if any.
Microsoft Visual Studio likes to take up a lot of the width of the monitor with its “Toolbox” and “Solution Explorer”, so I find it works better on a landscape monitor. As it will not let you undock an editor window, you could not even drag a code editor to a second monitor that was in portrait mode.
Also consider how your customers are most likely to have their monitors set up. You may wish to write any UI code with the same setup, so you get a feel for what the application will be like to use.
Depends how big your monitor is. We have 1 28" monitor in landscape and 2 24" monitors in portrait which flank the big monitor.
Works great for pair-programming!
At work, I run my primary monitor (secondary is the laptop screen), in portrait mode. I really like it. I've become spoiled to seeing more code at once. I don't find that it encourages longer methods at all. Occasionally, I run across code that is a bit too wide since the IDE sidebars cramp it a bit, but I largely use Eclipse (Rational Application Developer, but Eclipse-based), so s quick double-click maximizes the code window, and it's very useful. Another double-click and I have my sidebars back.
I also find it a very useful orientation for my email.
I recommend it highly.
Portrait mode widescreen monitors work very nicely for edting code, thank you. However, some monitors have poor viewing angles on one dimension, which would usually be vertical but becomes horizontal in portrait mode. This can make the colours bad or unusable if everything isn't aligned correctly.
I have never given it a try but I would imagine it would work pretty well. I personally like to keep my lines fairly short, and wide screens tend to give me fewer lines of code, so I would give it a try.
It all comes down to personal preference however, what ever allows you to be the most productive and works best for you is the way to go.
For me it's not effective at all. I use IDEs, so in landscape mode I have sidebars to navigate code, navigate project etc.
It's not silly but a matter of opinion. A widescreen in portrait is very nice for writing code, code width has never really been an issue, and being able to see more line of code on the screen is always nice.
The other reason to put a widescreen in portrait is so it matches the height of your other monitor, for example a 30" widescreen next to a 22" widescreen in portrait have close to the same height.
It all comes down to your preference.
I just have one big monitor at my home office.
I tried it once. I didn't like it. I usually have an IDE and IDEs are perfect for widescreen. It's faster to jump around if you can see your function list on the right, file list on the left, etc.
Also, I try to keep my functions small so this usually isn't a problem (I have dual 24"). If your functions are reasonably small, and you have widescreen, you can show two files side by side which is often more useful. Some editors allow you to split the window and scroll to two different parts of the same file. This is also very useful is far better than having 100+ lines on the screen. With my settings, I have 60 lines per screen on an editor. If I split the editor, I can see 120. If I do it again on the other monitor, I can see 240. That's quite a bit of code and generally only useful for very different parts of it.
If you're working mostly with text (as most programmers or other technical folks do), or even documents, then portait mode is much more valuable. In fact, the general trend in displays is all the wrong direction: aspect ratios are squishing landscape displays to a mail slot to better fit the format of movies. Personally, I have never watched a movie on my computers (laptop or desktop), and I'm not about to start now - that's what I have a TV for!
In reality, vertical pixels are the most valuable asset in computing - do whatever you can to get more of them - you won't be sorry you spent the money! I won't even buy a laptop with less than 1024-1080 vertical pixels, since that's the minumum required to display a full page PDF at a readable resolution, and (much) more is better. (Since PDFs make up a large portion of today's online documentation/manuals, that's a very big concern.) You should only think about width after you've got enough vertical pixels.
What I really want is a 15.4" or 16" laptop with a portrait screen - these should still be wide enough to package a full-size keyboard into the base - a FlyBook-style pivot arm would be nice, but isn't required.
I found understanding the intent of related functions are easier when you print them first on paper than understanding them directly from screen, never fails, why? Because you can easily review many lines of code at one glance, no need for incessant scrolling.
The same thing with monitor oriented in portrait mode, you can easily understand the intent of multiple related functions, re-factored or otherwise. But don't let having portrait screen be an excuse to write a function with many lines.
Writing this on stackoverflow using portrait screen :-)
I can easily see many posts at one glance :-)
If you are working with print material, yes, as for source, why not full screen your IDE and close the task panes you do not need?
I find portrait is only useful to me if I'm working on a web site, being able to see the entire page at once helps.
I would say if the monitor is large enough you don't need portrait mode (24" and higher) for writing code.
If the monitor is smaller than that, then portrait mode is preferable.
Ideally what you would have is a single 30" (2560 x 1600) as widescreen to work on your code along with utilities comfortably open nearby and a second smaller monitor nearby to preview the results (I am speaking about web coding specifically here but it would probably apply to most other coding as well - a screen the size of your target audience's screens).
The 30" screens have really come down in price now so it's probably worth the jump up. A 24" screen does have the advantage of significantly larger text at default font sizes. The text on 30" monitors can get to be a bit of grind unless you move up to 14pt.
Good luck.
I have 2 19" monitors currently. One I keep in landscape and one I keep in portrait mode. I find that working on documentation or reading long web pages is easier on the portrait screen. I have used this setup for coding also and find that it does help, however it was a learned habit. lol
I use a non-default Windows colour scheme on most of my machines, and have a laptop with a 124 DPI screen, which Windows is set to.
A lot of programs I tested or even use daily seem to have problems with that, showing for example non-standard sizes of controls, cut-off UI elements, unreadable text and so on. There is the whole range from slightly annoying to (nearly) unusable.
Now I feel that a lot of these issues are unnecessary. A simple test run on a high-resolution screen in a few colour schemes would show them, some of them are even very easy to correct (like always using clWindow, clWindowText and clBtnFace instead of clWhite, clBlack and clSilver). Some of them are harder, like proper control sizing.
So my question is: Do you try to follow the recommendations in the UI guidelines regarding system colours, sizing and spacing of UI elements, and font sizes and faces? Is testing for compliance to them part of your QA process? Do you even try to lay out your forms in dialog units instead of pixels, even though most of the IDEs (Delphi in my case) have pixel-oriented designers?
[EDIT]: On re-reading this after sleeping I notice that this question may look like an invitation for fruitless discussion. It is not meant that way, I'd definitely be interested in tools to help me create applications that conform to the UI interface guidelines, an area where I feel Delphi is letting me down a little. See also my own answer.
I definitely don't. It costs time that I prefer spending on improving the experience of many rather than the few who use non-standard windows settings. A few things I usually do, which should still fix some of these issues:
use clWindows etc. because that's the standard for Delphi controls anyway, so why change it?
place labels above entry fields rather than to the left, which should solve many size problems
make sure the forms resize properly, by setting the anchors
make sure the tab order is correct (which can become a major annoyance if not done)
But I certainly don't take the time to set up test computers with odd resolutions and colors, or even worse, change my development box to use them (which will screw lots of things that again take time to reset properly).
If a paying customer reports problems with non-standard settings, it depends on the customer whether they will be addressed. If he orders 100 licenses, his chances are good. If he uses these settings because he is visually impaired, his chances are good. If he makes it part of the requirement, I will do it, but charge for the additional work.
Today, so much software doesn't work properly at a non-standard DPI that I don't think it's worth trying to fix it. The trouble-shooting FAQs for many applications just instruct users to switch to a normal font size for related problems. Microsoft acknowledged lack of proper DPI support in 3rd-party software and redesigned the display scaling methods in Windows Vista, where all GDI operations are scaled on a low level instead of relying on applications being aware of the DPI setting.
Final answer: it depends on your software's audience. If your software is likely to be used by disabled users, it might be worth the effort.
Apart from using the proper colour constants for standard colours I invest some extra effort for applications that we need to use internally on high DPI screens, or where customers may need this.
I have a unit with helper functions for determining proper sizes and placement margins, which compute these from the default GUI font and the standard values in dialog units as given in the UI guidelines, and with helper functions to compute the maximum width / height of an array of controls, place controls, things like that. For fixed size forms and dialogs I calculate the placement of controls once after translating their text with GNU gettext, for resizable forms I do this in an OnResize handler.
This gives good results, is however time-consuming. I would like to have something like the wxWidgets sizer functionality, which automates resizing once the minimum size of a control is set. I have never seen something similar for Delphi, though.
I occasionally test it myself for large fonts, because my Vista laptop is set to Large Fonts. Colors, not so much, but I rarely specify colors on controls.
However, proper resizing is pretty hard. I usually set Forms scale to false, so as that they won't resize wrong.
There are a few tools for auto-resizing forms. I did look into them, but never got around to testing them properly:
TFormResizer
ElasticForm - ironically (given the component's area) most of the text in this page won't show up in Chrome...
JVAutoFormSize (in JVCL - doesn't seem to be very useful from what I read)