I'm moving to WP8.1 and there are different resolutions to be supported so I need to create the correct resources for each scaling factor.
Following this guide I've found out that I can use a simple naming conventions and the appropriate image will be automatically loaded without having to manage it from code.
What the guide doesn't say, and I can't seem to find it anywhere, is what the original size should be.
I need to know which one is the resolution that corresponds to the 100 scaling factor so that I can calculate the size of the scaled images.
Do you have any idea on this?
There's a lot of documentation for Windows Store (I'm not using Silverlight) apps but everything seems always related to desktop/tablets even if there's the phone icon.
Please refer section "1.a.i" as guideline (http://msdn.microsoft.com/library/windows/apps/xaml/hh965325.aspx) mention by you.
You need to create image with 96 DPI, considering as 100% scale.
I also recommended refer guidelines provided in this link http://msdn.microsoft.com/en-US/library/windows/apps/xaml/hh465362.aspx. Refer below statement from provided link.
"Windows Runtime apps (that run on Windows, Windows Phone, or both)
are automatically scaled by the system to ensure consistent
readability and functionality regardless of a screen's pixel density."
And also below one.
"Windows determines which scaling plateau to use based on the physical
screen size, the screen resolution, the DPI of the screen, and form
factor."
Hope this helps.
Related
I'm making a website that needs to dynamically obtain the favicon of sites upon request. I've found a few api's that can accomplish this fairly well, and so far I'm liking http://www.fvicon.com/.
The final image for my website will be 64x64px, and some websites such as Google and Wordpress have nice images of this size that are easily retrieved via this api. Though, of course, most websites only have a 16x16 favicon image and scaling that image to 64x64 has very bad quality loss.
Examples:
(high res) http://a.fvicon.com/wordpress.com?format=png&width=64&height=64
(low res) http://a.fvicon.com/yahoo.com?format=png&width=64&height=64
Keeping this in mind, I'm planning on somehow determining whether a high-res image is available and, if so, the website will use this image. If not, I want to use a pre-made 64x64 icon with the smaller icon layered over it. What I'm having trouble with is determining if there is a high res favicon available or not.
Also, I'm curious if there's a better approach to this situation. I'd rather not use smaller images (64x64 works out really well for this project). The lowest res I'm willing to drop to is 48x48 but even then there will be a significant quality loss for scaling up 16x16 favicons.
Any ideas? If you need any more information I will gladly provide it.
Thank you!
Here's a link to a way of using favicons in different resolutions. Maybe it helps you to find out how to get them. You would have to search the website's code (don't know how to do this) for /<link.*rel="icon".*>/ and search in the root directory of the webserver for favicon.ico. (I hope the regex is correct)
Hope I can help you.
PHP has a native function called getimagesize. If you can retrieve the favicon, then you can run the function and determine if it's high res or not and act accordingly.
Just a thought.
This is late to the party, but grabicon.com works very similarly to fvicon, but returns the image size you want without quality degradation. It adds a matching border around the smaller image to give you the icon size you require, so the icons on your web page all "match". If a site doesn't have an icon, grabicon creates a unique one for it.
Full disclosure, I'm grabicon's creator, but it's free and gives you what you're asking for :)
I am preparing to configure our production Cloudbees instance, and would like some advice on app-cell sizing. We will be using multiple instances with auto scaling enabled, but need to choose the app-cell size. This is obviously a compromise between horizontal and vertical scaling and the best choice will be different for each app.
Our app is a shopping service written in GWT, so there is one JSP and an initial download of the application HTML, JS, CSS, and Image files. After that, everything runs in the clients' browser with only search calls hitting the server and returning plain JSON with no serialization. Also, we are not using sessions, and do not need any type of state on the server, so the memory footprint should be low.
Given all of this, my gut is to go with a more horizontally scaled deployment with a larger number of smaller instances. Any suggestions would be welcome.
There is no general answer to this question. Application design and internal processing comes in the equation and changes the result. Only load test can give you answer about the best sizing for your application.
Statelessness implies you can scale horizontally very easily - so this opens up both ways to scale.
My suggestion is to fine which "container size" works well enough for a single instance (usually a memory restriction) and once you are happy with that, you can then scale horizontally based on usage.
I want to develop a game but I'm not sure about the sizes of the pics.
I checked the app after I finished one animation on my phone and on my emulator; the pics changed their size by themselves. Then should i make the same pic with different size for each folder on one pic with the same size and put it in each of the folders.
thanks!
You don't have to, but it can be useful: sometimes it's better to use a simpler image at small resolutions, and that's where the different densities are helpful.
It also allows more fine-grained control of scaling: if you only provide a hdpi version, a lot of detail can be lost if it has to scale that image significantly. By providing a ldpi version, you can provide a clean base picture which won't need to be scaled as much; resulting in fewer potential scaling artifacts (but unless the other versions are cleaned up a bit, you probably won't see much of a difference in the end).
I am testing an application and need to test it with different screen resolutions with windows form applications.
What is the common resolution tested for now days?
That depends a great deal on your market/target audience.
I think your safe minimum 1024x768 for desktop apps but don't forget that mini PCs are taking off and they have smaller screens than traditional. If you're gonna run on one of these you need to consider "funkier" resolutions as well.
As far as maximum resolutions... the sky's the limit. Though i think if you look good in 1280x1024 you'll be fine in anything larger too.
This will depend on how the Windows forms is laid out, in relation to aspect size and resolution, the fonts used. Before when I developed WinForms applications, I used to rigidly stick to the minimum size of resolution 640 x 480, knowing and having the confidence that it will be fine in resolutions higher then that.
Sadly as it seems, it would make the form look a tad small when under a resolution such as 1,024 x 768!
This is something you need to be aware of.
Another angle of looking at is this - internationalization, yes that flaming international lingo for each label, this could disrupt the flow and layout of the winform itself, suppose you used a label that had a common word such as:
+-----------+
|First name |
+-----------+
Now, suppose this was translated to German (via babelfish.yahoo.com) for an example that label would be
+--------+
|Vorname |
+--------+
Wait! It gets smaller in Spanish (again via babelfish.yahoo.com)
+-------+
|Nombre |
+-------+
Yes, the label has shrunk and the end result, there could be potential gaps or labels flowing into one another because of the internationalization.
Sure, is'nt it great that we all have big fancy screens with resolutions up to 1,920 x 1,0768, on flat 24" screens, but even more so, the readability of the winforms can vary as well depending on whether ClearType is used or not! Even netbooks have a resolution of 1,024 x 600...
This is an interesting question that can underhandedly open up a can of worms as to BEWARE! Ok, I know I made it sound like as if internationalization was the big point behind it, you just do not know until you ask yourself and your superiors, who is the audience and what scope?
You will also earn bonus points if you target accessibility as well, big fonts, small fonts, how are the fields laid out, there is no hard or fast rules involved in this, it would be beneficial to do a small amount of research. Sure, it would be darn handy to drop on a component that will automatically resize the layout of the form scaling upwards for different resolutions, but what about the potential for internationalization...?
Good question worthy of a +1 from me!
That depends entirely on your application. For the last kiosk application I coded, the resolution was part of the specification, and was set to 1280x1024. If you're making a game, you'll need to support a wide range of resolutions, both fullscreen and windowed.
You will also want to take aspect ratio's into account (ie: wide vs. normal, etc.).
I usually design my windows forms, so that when you resize the form, everything resizes correctly. This usually means setting a reasonable minimum size for the form. I find that this works better than designing for 1 specific resolution.
Web users:
http://www.w3schools.com/browsers/browsers_display.asp
http://www.screen-resolution.com/common-screen-resolutions.php
See Google Browser Size.
Edited to add: That labs feature may be going away, to be added to Google Analytics.
The question
Is there a known benchmark or theoretical substantiation on the optimal (rendering speed wise) image size?
A little background
The problem is as follows: I have a collection of very large images, thousands of pixels wide in each dimension. These should be presented to the user and manipulated somehow. In order to improve performance of my web app, I need to slice them. And here is where my question arises: what should be the dimensions of these slices?
You can only find out by testing, every browser will have different performance parameters and your user base may have anything from a mobile phone to a 16-core Xeon desktop. The larger determining factor may actually be the network performance in loading new tiles which is completely dependent upon how you are hosting and who your users are.
As the others already said, you can save a lot of research by duplicating the sizes already used by similar projects: Google Maps, Bing Maps, any other mapping system, not forgetting some of the gigapixel projects like gigapan.
It's hard to give a definitive dimension, but I successfully used 256x256 tiles.
This is also the size used by Microsoft Deep Zoom technology.
In absence of any other suggestions, I'd just use whatever Google Maps is using. I'd imagine they would have done such tests.