Tuesday, December 28, 2010

Cheat Engine, Poptropica Credits

Text over an image. Shadow with Gimp

Before making this image I exercised Memhet tutorial is here. Then I did this work has some small variations.

1.Open the image. This is called "background layer."

2.Type
text on the image (with the text tool) Choose size and font. Then make smaller "spacing" and "spacing" between characters.

The following image shows the values \u200b\u200bthat worked.
3-We add a new layer and painted white.

4-place layers in the following order:
5-Now go to Layers dialog and make click with right button, in the text layer and click on "Text Selection.

6-then go to menu "Select" and click on Invert. (Selection / Invert or Ctrl + I).

7-Go back to the Layers dialog and click on the white layer we created. Then do Ctrl + C and Ctrl + V.

8-Then it creates a floating selection in the Layers dialog. We click on the icon "New Layer". Shows the layer called "layer punch.
9-Finally
keep selected the "layer punch and tool" Ellipse Select "delimit the area to clear. The suppress pressing "Del" on your keyboard.
Note: background photo is adapted from this: Cerro Tonador (Bariloche - Patagonia Argentina)

This work is not only a new exercise with our valued Gimp, but also intended as a message to all they enjoy and / or enjoy a well deserved holiday soon.

Greetings, good rest for all, and until learning.

Tuesday, December 21, 2010

Diagram Of Tongue Kissing

How to develop for Android? - Part II

In the previous release as explained install the development environment to work with Android. Now I will explain some basics needed to get warm.

We can say that Android is composed of several layers (much like the OSI model ).
the

These layers can be differentiated into 5 groups:

  • Layer 1 - Kernel: Android base is solid as a rock. Of course, this base is the Linux kernel. Android uses Linux to handle everything related to the hardware (drivers), memory management, processes and many other operational tasks. However, our application will never touch the kernel. Layer 2
  • - Native Libraries: The next layer that sits above the kernel is the native libraries. Here we have a number of tools that come prebuilt by the manufacturer and allow us to manage from rendering web databases.
  • Layer 3 - Nucleo: Over this layer we have the core of Android. Therein lies the Dalvik virtual machine and libraries to the platform.
  • Layer 4 - Framework for Applications: Above is the toolset that lets you create and manage applications, notices, resources and many other things.
  • Layer 5 - Applications: And finally we application layer is where are the widgets and all applications that come in contact with the user.

already know a little better the architecture of Android, let's see how we develop. Part of the application framework are components. Estuadiaremos the most important at the moment, they are:

  • Activities: The Activities (or activities) are interfaces that allow users to interact with the application. Usually an application is composed of many activities. An activity may be to show the contact list and another might be to send text messages
  • Intents: A Intent (Or as we say in English, an "intent") is nothing but an action. In Android all actions are handled with intentions)
  • Services: is a task that runs in the background, no graphical interface and without any direct user interaction. We can think of a typical example: a music player. We all like to keep the music playing even if we see the reprouctor to spend the web browser. It is a service
  • Content Providers: is a container that allows grouping a set of application data and make them available to other applications. We see it as a way to share information between applications
global
Finally we mention the life cycle phases of an application.

first thing to understand is that (unlike a desktop operating system) in Android application is not married to a process. Android there is one application that gets the focus and is presented to the user. While this application is in the front, other applications come in states of pause, stop or even, if memory is scarce, Android can get close to free resources and not be mediating many words.

But do not panic, if the application is "killed" by Android their state is stored for can be recovered when the user running again. It is in this interim to close and open applications that are released in the process. We see a simple process as a disposable container for applications, not more. Always keep in mind this behavior when designing your applications.

The life cycle of an application can be seen in the picture below.


then briefly describe each of its phases:

  • onCreate (): runs the first time the application is shown. Here you can conduct any static initialization (database connections data, building interfaces, etc). Get a parameter that can contain the state of the application (if stored correctly)
  • OnStart (): runs just before the application is visible to the user
  • onRestart (): Called just after the application has been arrested. Just before starting again
  • onResume (): be called when the application is ready to interact with the user. Here you can reset things like music and animation
  • OnPause (): be executed just before the application goes into the background because another application has been executed. This method may be the last thing you see before you die your application because an application can kill Android slow without notice. That's why this is a good place to store the status of your application.
  • onStop (): is called when the application is no longer visible to the user and not need it for a while. As noted in the previous point, this method may not even run
  • OnDestroy (): is called just after the application is destroyed. Here you have to do the funeral and stuff. As noted in the previous point, this method may not even run

With all this theoretical basis we can say that we are ready to start writing the code for our first application. That will be the subject of the next installment.

For more information on this topic please consult the official documentation Android

How to develop for Android? - Part I

Wednesday, November 24, 2010

Should Benign Bladder Polyps Removed Or Not

Python For Android - Myth or Reality

few hours I was researching the possibility of developing with Python on Android and then give you a summary of the results and conclusions that I got.

Here I give you the script I used to try some of the widgets available in the API if they want to try and have a look (I do not stop to explain much because the code is virtually self-explanatory). Also suppose that followed in the footsteps of my tutorial on How to develop for Android? and have configured your development environment and know how to use the emulator.

droid = android.Android ()

time = droid.dialogGetInput ("Enter the amount of time you want to demo (10-100)", "Time:") print

time
time = int ( time [1]) if time
< 10: tiempo = 10elif tiempo > 100: time = 100


droid.dialogCreateHorizontalProgress ('Bar Progress ',' Hello, I'm making progress ...', time)
droid.dialogShow ()
for i in range (time):
time.sleep (0.5)
droid.dialogSetCurrentProgress (i)
droid.dialogDismiss ( )

droid.dialogCreateSpinnerProgress ('Spinner of progress',' Look, look ... I'm spinning ')
droid.dialogShow ()
time.sleep (time)
droid.dialogDismiss ()

droid.notify (' Python Test ',' Oh, I can also report ')

droid.dialogCreateAlert (title, message)
droid.dialogSetPositiveButtonText (' Yes')
droid.dialogSetNegativeButtonText ('No')
droid.dialogSetNeutralButtonText ('Cancel')
droid.dialogShow ()
droid.dialogGetResponse response = ().
result
droid.makeToast response print ('The result of the execution of the button is:% s "% response [' Which '])

droid.dialogCreateAlert ('Select a color')
colors = ('yellow', 'blue', 'red')
droid.dialogSetItems (colors)
droid.dialogShow ()
droid.dialogGetResponse response = ().
reply result print
droid.makeToast ('The selected color is% s'% color [response ['item']])

droid.makeToast ('Well, bye')


To run must install some packages in the cel. They can do this with SDK command:

$ adb install / path / to / archivo.apk

with QR are the project page SL4A or the method they see fit.

Ok, things to install are:


After the install go to device / emulator and look for the icon For Android Python, tap and install . That will take a few minutes while you download some stuff. After then send the test script at cell, we can use the command:

$ adb push / path / to / script.py / sdcard/sl4a/scripts /

This will copy the folder SL4A. Now when you run the Python For Android will see in the list of our infamous creation scripts, tap on the script and run. The rest is to enjoy the windows and controls: P

Conclusions


    SL4A
  1. The API is small, ie is well underway although there are still many things / features to be implemented. Python For Android
  2. unlike what I thought graphics do not support Android widgets, but notifications, toast and basic things such text entry, selection, etc.. So forget about image-rich graphical interfaces and stuff.
  3. Yes there are some performance Issues, actually a buddy who is working hard with Android developers tells me every day are killed for trying to improve performance in itself because it is a little slow (I mean native apps). However, the version of Python is cross-compiled and run even faster than Jython
  4. There are ways to package scripts. Apk and although something a little experimental work quite well (they are, say, "tweaks" construction method Java packages)
  5. As there are no major Issues stability can be used for production applications


Finally I can say (much to my regret) we can not have this alternative for developing rich GUI applications, but it is an interesting option to consider when it matures a little more. Personally I will watch and wait ninja forward in the future we can create applications as good as with Java.

More information: *
http://code.google.com/p/android-scripting/
http://code.google.com/p/android-scripting/wiki/FAQ
* http://code.google.com/p/android-scripting/wiki/Tutorials
* *
http://code.google.com/p/android-scripting/wiki/ApiReference

Saturday, November 20, 2010

Can I Get A Brazilian Wax If I Have Pcos

How to develop for Android? - Part I



Nowadays I have seen the need to create applications for Android and as there had dabbled in that world, I decided to make a series of articles to document the entire process.

In this first post I'll explain the steps I followed to bring about the development environment. I might mention that the recipes are made for Debian GNU / Linux, yet you can adapt it to your favorite distro with some minor adjustments.

For those not familiar with my tutorials I remind you that all instructions start with the $ character as the user running normal and starting with # are run as superuser (root), eg

$ ls-l (command run as user)
# aptitude update (command run as root) That said


started. Install dependencies


The first thing to do is install the packages needed for development, which basically are: Java Virtual Machine (JRE) and the development environment (JDK). On a Debian GNU / Linux suffice:


# aptitude update # aptitude install sun-java6-jdk sun-java6-jre
# aptitude remove gcj-jdk


If they realize SUN implementations use and removed any possible installation of GNU Java compiler (gcj) as the official documentation tell us that gcj is NOT compatible with Android.

For more information about system requirements visit: http://developer.android.com/sdk/requirements.html

Then install the packages that we ensure that the system select the correct options for each default executable, stop it use:

# update-alternatives - config javac
# update-alternatives - config java


And in both cases, we select the options SUN. Install Ant


Ant is a tool that allows us to build Java applications. In our case, we will compile and build files. Apk (the installable Android) from our source code.

We go to the download page Ant, download one of the archives found in the "Current Release of Ant" and unzip it in a folder of our choice. In my case I did it in / opt and I had the folder: / opt/apache-ant-1.8.1 .

Install the Android SDK
Well, having the tools and units ready, we will install the Android development environment. We go to the page Android SDK and download the appropriate version for your platform. As with Ant, unzip the file in the folder of our choice. This time also unzipped into / opt, staying in the folder: / opt/android-sdk-linux_x86 .

Now edit the file ~ /. Bashrc to add the path of the binaries to the PATH system and set the environment variables ANT_HOME and JAVA_HOME. We achieve this by adding the following lines:

export PATH = $ {PATH}: / opt/android-sdk-linux_x86/tools
export PATH = $ {PATH}: / opt/apache-ant-1.8.1/bin
export ANT_HOME = / opt/apache-ant-1.8.1
export JAVA_HOME = / usr/lib/jvm/java-6-sun/jre


Remember to change the paths of these variables on routes where your binaries. If you do not know where to point JAVA_HOME did you run the command:

# find /-name "tools.jar" 2.2) and need at least one
to compile the application and configure a Virtual Android Device (AVD) for testing.

This is very simple, just open a terminal and run: $
android

will appear a application (AVD Manager) as shown below and there we go to the Available Packages section


, update the repository and select the (s) platform (s) you wish to install.



Finally we created a new virtual device Virtual Device section. We click the button
New. ..
, We assign a name, select a platform and click on Create AVD.


To test our brand new device is selected and click on Start ... . Then click Launch and after a few seconds we will have the emulator running an instance of Android:)


Now comes the fun part, create the application. In the next installment will be speaking on the development, for now can play creating a Hello World and can read about how
and develop with Eclipse how to develop with other IDEs
Compile and build the executable

After we have our application ready to create the installer. That's as simple as navigating to the root folder of the project (source code) and run: $ ant


debug If our project is called "HelloAndroid" will generate a file-debug.apk HelloAndroid and that is our installer . Test in the emulator

Finally, one of the most expected. How will our application on a device? For easy, on a console, run: $

android


E

begin our virtual device. After the device is working on another console run:

$ adb install / path / to / your / installer / HelloAndroid-debug.apk

And with that, send the application to the device. We looked at the menu and voila! A play: D


I hope you have this tutorial useful. Soon I will continue documenting my journeys in the world of Android. Over and out.




Thursday, October 28, 2010

How To Build A Model Of The Globe Theater



To make a shadow of a figure given should follow the following steps:

a) Important: You must have the figure without the environment, or without any funding.
b) First duplicate the layer in Fig.

c) Then select the tool "color selection (Shift + O) region of the layer transparent. (In the example, I put color on the bottom layer so you could see better. After the take away)
d) After reverse the selection (Ctrl + I)

e) Then we fill the figure with black. Then we control we have selected as your foreground color to black and press Ctrl +, (Control over comma).

f) then take the perspective tool (Shift + P) and recline in the shade by placing it in the position we want ..
g) Then go to Filters / Blur / Gaussian Blur and apply the filter. Then down a little the opacity of the layer.
h) After you choose a background and apply it. I worked with the blend tool and choose a gradient.

i) Finally crop the image as we wish.
I hope you like the work done.

Greetings to all.

Sunday, October 17, 2010

Rimmel Blushe Swatches

Working with "grid" tool

I
to leave more proportionate hub would be better to work with a grid.

grid To appear in the image window, I went to "Edit / Preferences."

is
opens the dialog window "Preferences" and you have to click on the left that says "Windows image" and then "Appearances"
then enable "Show Grid."
Then look to the left where it says, "Default grid" and click. Select the "Line Style desired"
OK and restart Gimp to display the changes.
Here you can see some screenshots working with the grid and finally the completed work without it.
































Then if To disassemble the grid "Destic" "Show Grid" and restart the program to view the changes.
Interesting work with grids.
Greetings
who visit this entry.

Saturday, October 9, 2010

Where Can I Get Old School Roller Skates

routes - Gimp: Draw a cube. Metro


actions to undertake are as follows:

1 - Get background.
2 - Create new layer. (Not necessary, but I always choose separate works if I change something I need to start from scratch).





3 - Trace the route starting with one side of the cube.









4 - To complete the front to Ctrl + click paragraph 4 and 1 and bind the ends.










5 - Then select the path: Click on "Create selection from of a path "









6 - Then click the blend tool and paint the selected area with a gradient.





















7 - Then the selection rule: Go to "Select / None"










8 - Then go to the tab and return routes to choose the route.









9 - Mark the left edge (bottom and top) with the Shift key pressed and move the top spot to the right. You will see the path of the second side.







10 - Select the new face drawn: To do this go to "Create selection from path"








11 - Then go to the tool mix and apply a gradient in the selected face.
















12 - The following selection rule: Go to "Select / None"









13 - Again, go to the tab and return routes to choose the route.










14-Mark the bottom edge of the last face drawn, with the Shift key pressed and move the lower point straight up (Go dragging).









Now you should see the path to the upper face of the cube (above).











15-Select the third face drawn: To do this go to "Create selection from path"









16 - Then go to the Blend Tool and apply a gradient in the face selected, preferably darker.






17 - Finally the selection rule: Go to "Select / None".






Finally you can see the cube formed.

With a little practice will most likely provided the cube.

With this work I have known other applications or uses of the Path tool.

Greetings to anyone reading this post. Ah ... I like to hear your comments!

We exercising.