create new git

Edmur LOPES
Showing 329 changed files with 6653 additions and 0 deletions Show diff stats
.gitignore
.idea/compiler.xml
.idea/copyright/profiles_settings.xml
.idea/gradle.xml
.idea/markdown-navigator/profiles_settings.xml
.idea/misc.xml
.idea/modules.xml
.idea/runConfigurations.xml
acrylic/.gitignore
acrylic/build.gradle
acrylic/proguard-rules.pro
acrylic/src/androidTest/java/anupam/acrylic/ExampleInstrumentedTest.java
acrylic/src/main/AndroidManifest.xml
acrylic/src/main/java/anupam/acrylic/AboutActivity.java
acrylic/src/main/java/anupam/acrylic/ColorPickerDialog.java
acrylic/src/main/java/anupam/acrylic/EasyPaint.java
acrylic/src/main/java/anupam/acrylic/GraphicsActivity.java
acrylic/src/main/java/anupam/acrylic/MainActivity.java
acrylic/src/main/java/anupam/acrylic/PictureLayout.java
acrylic/src/main/java/anupam/acrylic/Places.java
+++ a/.gitignore
@@ -0,0 +1,9 @@
+*.iml
+.gradle
+/local.properties
+/.idea/workspace.xml
+/.idea/libraries
+.DS_Store
+/build
+/captures
+.externalNativeBuild
+++ a/.idea/compiler.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="CompilerConfiguration">
+    <resourceExtensions />
+    <wildcardResourcePatterns>
+      <entry name="!?*.java" />
+      <entry name="!?*.form" />
+      <entry name="!?*.class" />
+      <entry name="!?*.groovy" />
+      <entry name="!?*.scala" />
+      <entry name="!?*.flex" />
+      <entry name="!?*.kt" />
+      <entry name="!?*.clj" />
+      <entry name="!?*.aj" />
+    </wildcardResourcePatterns>
+    <annotationProcessing>
+      <profile default="true" name="Default" enabled="false">
+        <processorPath useClasspath="true" />
+      </profile>
+    </annotationProcessing>
+  </component>
+</project>
 \ No newline at end of file
+++ a/.idea/copyright/profiles_settings.xml
@@ -0,0 +1,3 @@
+<component name="CopyrightManager">
+  <settings default="" />
+</component>
 \ No newline at end of file
+++ a/.idea/gradle.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GradleSettings">
+    <option name="linkedExternalProjectsSettings">
+      <GradleProjectSettings>
+        <option name="distributionType" value="DEFAULT_WRAPPED" />
+        <option name="externalProjectPath" value="$PROJECT_DIR$" />
+        <option name="modules">
+          <set>
+            <option value="$PROJECT_DIR$" />
+            <option value="$PROJECT_DIR$/app" />
+          </set>
+        </option>
+        <option name="resolveModulePerSourceSet" value="false" />
+      </GradleProjectSettings>
+    </option>
+  </component>
+</project>
 \ No newline at end of file
+++ a/.idea/markdown-navigator/profiles_settings.xml
@@ -0,0 +1,3 @@
+<component name="MarkdownNavigator.ProfileManager">
+  <settings default="" pdf-export="" />
+</component>
 \ No newline at end of file
+++ a/.idea/misc.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="EntryPointsManager">
+    <entry_points version="2.0" />
+  </component>
+  <component name="NullableNotNullManager">
+    <option name="myDefaultNullable" value="android.support.annotation.Nullable" />
+    <option name="myDefaultNotNull" value="android.support.annotation.NonNull" />
+    <option name="myNullables">
+      <value>
+        <list size="4">
+          <item index="0" class="java.lang.String" itemvalue="org.jetbrains.annotations.Nullable" />
+          <item index="1" class="java.lang.String" itemvalue="javax.annotation.Nullable" />
+          <item index="2" class="java.lang.String" itemvalue="edu.umd.cs.findbugs.annotations.Nullable" />
+          <item index="3" class="java.lang.String" itemvalue="android.support.annotation.Nullable" />
+        </list>
+      </value>
+    </option>
+    <option name="myNotNulls">
+      <value>
+        <list size="4">
+          <item index="0" class="java.lang.String" itemvalue="org.jetbrains.annotations.NotNull" />
+          <item index="1" class="java.lang.String" itemvalue="javax.annotation.Nonnull" />
+          <item index="2" class="java.lang.String" itemvalue="edu.umd.cs.findbugs.annotations.NonNull" />
+          <item index="3" class="java.lang.String" itemvalue="android.support.annotation.NonNull" />
+        </list>
+      </value>
+    </option>
+  </component>
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_7" assert-keyword="true" jdk-15="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/build/classes" />
+  </component>
+  <component name="ProjectType">
+    <option name="id" value="Android" />
+  </component>
+</project>
 \ No newline at end of file
+++ a/.idea/modules.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/AUTRE.iml" filepath="$PROJECT_DIR$/AUTRE.iml" />
+      <module fileurl="file://$PROJECT_DIR$/app/app.iml" filepath="$PROJECT_DIR$/app/app.iml" />
+    </modules>
+  </component>
+</project>
 \ No newline at end of file
+++ a/.idea/runConfigurations.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="RunConfigurationProducerService">
+    <option name="ignoredProducers">
+      <set>
+        <option value="org.jetbrains.plugins.gradle.execution.test.runner.AllInPackageGradleConfigurationProducer" />
+        <option value="org.jetbrains.plugins.gradle.execution.test.runner.TestClassGradleConfigurationProducer" />
+        <option value="org.jetbrains.plugins.gradle.execution.test.runner.TestMethodGradleConfigurationProducer" />
+      </set>
+    </option>
+  </component>
+</project>
 \ No newline at end of file
+++ a/acrylic/.gitignore
@@ -0,0 +1 @@
+/build
+++ a/acrylic/build.gradle
@@ -0,0 +1,32 @@
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion 25
+    buildToolsVersion "25.0.2"
+
+    defaultConfig {
+        applicationId "anupam.acrylic"
+        minSdkVersion 15
+        targetSdkVersion 25
+        versionCode 1
+        versionName "1.0"
+
+        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+}
+
+dependencies {
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+    androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
+        exclude group: 'com.android.support', module: 'support-annotations'
+    })
+    compile 'com.android.support:appcompat-v7:25.1.1'
+    testCompile 'junit:junit:4.12'
+}
+++ a/acrylic/proguard-rules.pro
@@ -0,0 +1,17 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in C:\Users\Edmur\AppData\Local\Android\Sdk/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+++ a/acrylic/src/androidTest/java/anupam/acrylic/ExampleInstrumentedTest.java
@@ -0,0 +1,26 @@
+package anupam.acrylic;
+
+import android.content.Context;
+import android.support.test.InstrumentationRegistry;
+import android.support.test.runner.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.*;
+
+/**
+ * Instrumentation test, which will execute on an Android device.
+ *
+ * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
+ */
+@RunWith(AndroidJUnit4.class)
+public class ExampleInstrumentedTest {
+    @Test
+    public void useAppContext() throws Exception {
+        // Context of the app under test.
+        Context appContext = InstrumentationRegistry.getTargetContext();
+
+        assertEquals("anupam.acrylic", appContext.getPackageName());
+    }
+}
+++ a/acrylic/src/main/AndroidManifest.xml
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="anupam.acrylic"
+    android:versionCode="15"
+    android:versionName="2.2.0" >
+
+    <supports-screens
+        android:anyDensity="true"
+        android:largeScreens="true"
+        android:normalScreens="true"
+        android:resizeable="true"
+        android:smallScreens="true" />
+
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+
+    <application
+        android:allowBackup="true"
+        android:icon="@drawable/ic_launcher"
+        android:label="@string/app_name"
+        android:theme="@style/Theme" >
+        <activity
+            android:name=".Splash"
+            android:configChanges="keyboard|keyboardHidden|orientation"
+            android:theme="@android:style/Theme.DeviceDefault.Light.NoActionBar.Fullscreen" >
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+        <activity
+            android:name=".EasyPaint"
+            android:launchMode="singleTop" >
+            <intent-filter>
+                <action android:name="android.intent.action.SEND" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <data android:mimeType="image/*" />
+            </intent-filter>
+        </activity>
+        <activity
+            android:name=".AboutActivity"
+            android:label="@string/title_activity_about"
+            android:parentActivityName=".EasyPaint" >
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value=".EasyPaint" />
+        </activity>
+    </application>
+
+</manifest>
+++ a/acrylic/src/main/java/anupam/acrylic/AboutActivity.java
@@ -0,0 +1,21 @@
+package anupam.acrylic;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.text.Html;
+import android.text.Spanned;
+import android.text.method.LinkMovementMethod;
+import android.widget.TextView;
+
+public class AboutActivity extends Activity {
+
+	@Override
+	protected void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+		setContentView(R.layout.activity_about);
+		Spanned htmlText = Html.fromHtml(getResources().getString(R.string.about_description));
+		TextView aboutTextView = (TextView) findViewById(R.id.aboutTextView);
+		aboutTextView.setText(htmlText);
+		aboutTextView.setMovementMethod(LinkMovementMethod.getInstance());
+	}
+}
+++ a/acrylic/src/main/java/anupam/acrylic/ColorPickerDialog.java
@@ -0,0 +1,242 @@
+/*
+ * Copyright (C) 2014 Valerio Bozzolan
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package anupam.acrylic;
+
+import android.annotation.SuppressLint;
+import android.app.Dialog;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.ColorMatrix;
+import android.graphics.Paint;
+import android.graphics.RectF;
+import android.graphics.Shader;
+import android.graphics.SweepGradient;
+import android.os.Bundle;
+import android.view.MotionEvent;
+import android.view.View;
+
+@SuppressLint("ClickableViewAccessibility")
+public class ColorPickerDialog extends Dialog {
+
+    private OnColorChangedListener mListener;
+    private int mInitialColor;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        OnColorChangedListener l = new OnColorChangedListener() {
+            public void colorChanged(int color) {
+                mListener.colorChanged(color);
+                dismiss();
+            }
+        };
+
+        setContentView(new ColorPickerView(getContext(), l, mInitialColor));
+        setTitle(R.string.pick_color);
+    }
+
+    public interface OnColorChangedListener {
+        void colorChanged(int color);
+    }
+
+    private static class ColorPickerView extends View {
+        private static final int CENTER_X = 230;
+        private static final int CENTER_Y = 230;
+        private static final int CENTER_RADIUS = 100;
+        private Paint mPaint;
+        private Paint mCenterPaint;
+        private final int[] mColors;
+        private OnColorChangedListener mListener;
+        private boolean mTrackingCenter;
+        private boolean mHighlightCenter;
+
+        ColorPickerView(Context c, OnColorChangedListener l, int color) {
+            super(c);
+            mListener = l;
+            mColors = new int[] {
+                0xFFFF0000, 0xFFFF00FF, 0xFF0000FF, 0xFF00FFFF, 0xFF00FF00,
+                0xFFFFFF00, 0xFFFF0000
+            };
+            Shader s = new SweepGradient(0, 0, mColors, null);
+
+            mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
+            mPaint.setShader(s);
+            mPaint.setStyle(Paint.Style.STROKE);
+            mPaint.setStrokeWidth(32);
+
+            mCenterPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
+            mCenterPaint.setColor(color);
+            mCenterPaint.setStrokeWidth(EasyPaint.DEFAULT_BRUSH_SIZE);
+        }
+
+        @Override
+        protected void onDraw(Canvas canvas) {
+
+            float r = CENTER_X - mPaint.getStrokeWidth()*0.5f - 30;
+
+            canvas.translate(CENTER_X, CENTER_X);
+
+            canvas.drawOval(new RectF(-r, -r, r, r), mPaint);
+            canvas.drawCircle(0, 0, CENTER_RADIUS, mCenterPaint);
+
+            if (mTrackingCenter) {
+                int c = mCenterPaint.getColor();
+                mCenterPaint.setStyle(Paint.Style.STROKE);
+
+                if (mHighlightCenter) {
+                    mCenterPaint.setAlpha(0xFF);
+                } else {
+                    mCenterPaint.setAlpha(0x80);
+                }
+                canvas.drawCircle(0, 0,
+                                  CENTER_RADIUS + mCenterPaint.getStrokeWidth(),
+                                  mCenterPaint);
+
+                mCenterPaint.setStyle(Paint.Style.FILL);
+                mCenterPaint.setColor(c);
+            }
+        }
+
+        @Override
+        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+            setMeasuredDimension(CENTER_X*2, CENTER_Y*2);
+        }
+
+        private int floatToByte(float x) {
+            int n = java.lang.Math.round(x);
+            return n;
+        }
+        private int pinToByte(int n) {
+            if (n < 0) {
+                n = 0;
+            } else if (n > 255) {
+                n = 255;
+            }
+            return n;
+        }
+
+        private int ave(int s, int d, float p) {
+            return s + java.lang.Math.round(p * (d - s));
+        }
+
+        private int interpColor(int colors[], float unit) {
+            if (unit <= 0) {
+                return colors[0];
+            }
+            if (unit >= 1) {
+                return colors[colors.length - 1];
+            }
+
+            float p = unit * (colors.length - 1);
+            int i = (int)p;
+            p -= i;
+
+            // now p is just the fractional part [0...1) and i is the index
+            int c0 = colors[i];
+            int c1 = colors[i+1];
+            int a = ave(Color.alpha(c0), Color.alpha(c1), p);
+            int r = ave(Color.red(c0), Color.red(c1), p);
+            int g = ave(Color.green(c0), Color.green(c1), p);
+            int b = ave(Color.blue(c0), Color.blue(c1), p);
+
+            return Color.argb(a, r, g, b);
+        }
+
+        @SuppressWarnings("unused")
+		private int rotateColor(int color, float rad) {
+            float deg = rad * 180 / 3.1415927f;
+            int r = Color.red(color);
+            int g = Color.green(color);
+            int b = Color.blue(color);
+
+            ColorMatrix cm = new ColorMatrix();
+            ColorMatrix tmp = new ColorMatrix();
+
+            cm.setRGB2YUV();
+            tmp.setRotate(0, deg);
+            cm.postConcat(tmp);
+            tmp.setYUV2RGB();
+            cm.postConcat(tmp);
+
+            final float[] a = cm.getArray();
+
+            int ir = floatToByte(a[0] * r +  a[1] * g +  a[2] * b);
+            int ig = floatToByte(a[5] * r +  a[6] * g +  a[7] * b);
+            int ib = floatToByte(a[10] * r + a[11] * g + a[12] * b);
+
+            return Color.argb(Color.alpha(color), pinToByte(ir),
+                              pinToByte(ig), pinToByte(ib));
+        }
+
+        private static final float PI = 3.1415926f;
+
+        @Override
+        public boolean onTouchEvent(MotionEvent event) {
+            float x = event.getX() - CENTER_X;
+            float y = event.getY() - CENTER_Y;
+            boolean inCenter = java.lang.Math.sqrt(x*x + y*y) <= CENTER_RADIUS;
+
+            switch (event.getAction()) {
+                case MotionEvent.ACTION_DOWN:
+                    mTrackingCenter = inCenter;
+                    if (inCenter) {
+                        mHighlightCenter = true;
+                        invalidate();
+                        break;
+                    }
+                case MotionEvent.ACTION_MOVE:
+                    if (mTrackingCenter) {
+                        if (mHighlightCenter != inCenter) {
+                            mHighlightCenter = inCenter;
+                            invalidate();
+                        }
+                    } else {
+                        float angle = (float)java.lang.Math.atan2(y, x);
+                        // need to turn angle [-PI ... PI] into unit [0....1]
+                        float unit = angle/(2*PI);
+                        if (unit < 0) {
+                            unit += 1;
+                        }
+                        mCenterPaint.setColor(interpColor(mColors, unit));
+                        invalidate();
+                    }
+                    break;
+                case MotionEvent.ACTION_UP:
+                    if (mTrackingCenter) {
+                        if (inCenter) {
+                            mListener.colorChanged(mCenterPaint.getColor());
+                        }
+                        mTrackingCenter = false;    // so we draw w/o halo
+                        invalidate();
+                    }
+                    break;
+            }
+            return true;
+        }
+    }
+
+    public ColorPickerDialog(Context context,
+                             OnColorChangedListener listener,
+                             int initialColor) {
+        super(context);
+
+        mListener = listener;
+        mInitialColor = initialColor;
+    }
+}
+++ a/acrylic/src/main/java/anupam/acrylic/EasyPaint.java
@@ -0,0 +1,593 @@
+/*
+ * Copyright (C) 2014, 2016 Valerio Bozzolan & James Dearing (TheOpenSourceNinja)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package anupam.acrylic;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.Calendar;
+import android.annotation.SuppressLint;
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.pm.ActivityInfo;
+import android.graphics.Bitmap;
+import android.graphics.Bitmap.CompressFormat;
+import android.graphics.BitmapShader;
+import android.graphics.BlurMaskFilter;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.EmbossMaskFilter;
+import android.graphics.MaskFilter;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.Point;
+import android.graphics.PorterDuff.Mode;
+import android.graphics.PorterDuffXfermode;
+import android.graphics.PorterDuffColorFilter;
+import android.graphics.Shader;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.provider.MediaStore;
+import android.renderscript.Allocation;
+import android.renderscript.Element;
+import android.renderscript.RenderScript;
+import android.renderscript.ScriptIntrinsicBlur;
+import android.util.Log;
+import android.view.Display;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.SeekBar;
+import android.widget.TextView;
+import android.widget.Toast;
+
+@SuppressLint("ClickableViewAccessibility")
+public class EasyPaint extends GraphicsActivity implements
+		ColorPickerDialog.OnColorChangedListener {
+
+	public static int DEFAULT_BRUSH_SIZE = 10;
+	private static int MAX_POINTERS = 10;
+	private static final float TOUCH_TOLERANCE = 4;
+
+	private Paint mPaint;
+	private MaskFilter mEmboss;
+	private MaskFilter mBlur;
+	private static final int CHOOSE_IMAGE = 0;
+	private MyView contentView;
+
+	private boolean waitingForBackgroundColor = false; //If true and colorChanged() is called, fill the background, else mPaint.setColor()
+	private boolean extractingColor = false; //If this is true, the next touch event should extract a color rather than drawing a line.
+
+	@Override
+	protected void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		// it removes the title from the actionbar(more space for icons?)
+		this.getActionBar().setDisplayShowTitleEnabled(false);
+
+		setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
+		contentView = new MyView( this );
+		setContentView( contentView );
+
+		mPaint = new Paint();
+		mPaint.setAntiAlias(true);
+		mPaint.setDither(true);
+		mPaint.setColor(Color.GREEN);
+		mPaint.setStyle(Paint.Style.STROKE);
+		mPaint.setStrokeJoin(Paint.Join.ROUND);
+		mPaint.setStrokeCap(Paint.Cap.ROUND);
+		mPaint.setStrokeWidth(DEFAULT_BRUSH_SIZE);
+
+		// Where did these magic numbers come from? What do they mean? Can I change them? ~TheOpenSourceNinja
+		// Absolutely random numbers in order to see the emboss. asd! ~Valerio
+		mEmboss = new EmbossMaskFilter(new float[] { 1, 1, 1 }, 0.4f, 6, 3.5f);
+
+		mBlur = new BlurMaskFilter(5, BlurMaskFilter.Blur.NORMAL);
+
+		if (isFirstTime()) {
+			AlertDialog.Builder alert = new AlertDialog.Builder(this);
+
+			alert.setTitle(R.string.app_name);
+			alert.setMessage(R.string.app_description);
+			alert.setNegativeButton(R.string.continue_fuck,
+					new DialogInterface.OnClickListener() {
+						public void onClick(DialogInterface dialog,
+								int whichButton) {
+							Toast.makeText(getApplicationContext(),
+									R.string.here_is_your_canvas,
+									Toast.LENGTH_SHORT).show();
+						}
+					});
+
+			alert.show();
+		} else {
+			Toast.makeText(getApplicationContext(),
+					R.string.here_is_your_canvas, Toast.LENGTH_SHORT).show();
+		}
+
+		loadFromIntents();
+	}
+
+	@Override
+	public void onBackPressed() {
+
+			super.onBackPressed();
+			return;
+	}
+	public void colorChanged(int color) {
+		if( waitingForBackgroundColor ) {
+			waitingForBackgroundColor = false;
+			contentView.mBitmapBackground.eraseColor( color );
+			//int[] colors = new int[ 1 ];
+			//colors[ 0 ] = color;
+			//contentView.mBitmapBackground = Bitmap.createBitmap( colors, contentView.mBitmapBackground.getWidth(), contentView.mBitmapBackground.getHeight(), contentView.mBitmapBackground.getConfig() );
+		} else {
+			mPaint.setColor( color );
+		}
+	}
+
+	public class MyView extends View {
+
+		public Bitmap mBitmap;
+		private Bitmap mBitmapBackground;
+		private Canvas mCanvas;
+		private Paint mBitmapPaint;
+		private MultiLinePathManager multiLinePathManager;
+
+		private class LinePath extends Path {
+			private Integer idPointer;
+			private float lastX;
+			private float lastY;
+
+			LinePath() {
+				this.idPointer = null;
+			}
+
+			public float getLastX() {
+				return lastX;
+			}
+
+			public float getLastY() {
+				return lastY;
+			}
+
+			public void touchStart(float x, float y) {
+				this.reset();
+				this.moveTo(x, y);
+				this.lastX = x;
+				this.lastY = y;
+			}
+
+			public void touchMove(float x, float y) {
+				float dx = Math.abs(x - lastX);
+				float dy = Math.abs(y - lastY);
+				if (dx >= TOUCH_TOLERANCE || dy >= TOUCH_TOLERANCE) {
+					this.quadTo(lastX, lastY, (x + lastX) / 2, (y + lastY) / 2);
+					lastX = x;
+					lastY = y;
+				}
+			}
+
+			public boolean isDisassociatedFromPointer() {
+				return idPointer == null;
+			}
+
+			public boolean isAssociatedToPointer(int idPointer) {
+				return this.idPointer != null
+						&& (int) this.idPointer == idPointer;
+			}
+
+			public void disassociateFromPointer() {
+				idPointer = null;
+			}
+
+			public void associateToPointer(int idPointer) {
+				this.idPointer = idPointer;
+			}
+		}
+
+		private class MultiLinePathManager {
+			public LinePath[] superMultiPaths;
+
+			MultiLinePathManager(int maxPointers) {
+				superMultiPaths = new LinePath[maxPointers];
+				for (int i = 0; i < maxPointers; i++) {
+					superMultiPaths[i] = new LinePath();
+				}
+			}
+
+			public LinePath findLinePathFromPointer(int idPointer) {
+				for (LinePath superMultiPath : superMultiPaths) {
+					if (superMultiPath.isAssociatedToPointer(idPointer)) {
+						return superMultiPath;
+					}
+				}
+				return null;
+			}
+
+			public LinePath addLinePathWithPointer(int idPointer) {
+				for (LinePath superMultiPath : superMultiPaths) {
+					if (superMultiPath.isDisassociatedFromPointer()) {
+						superMultiPath.associateToPointer(idPointer);
+						return superMultiPath;
+					}
+				}
+				return null;
+			}
+		}
+
+		public MyView(Context c) {
+			super(c);
+
+			setId(R.id.CanvasId);
+			Display display = getWindowManager().getDefaultDisplay();
+			Point size = new Point();
+			display.getSize(size);
+			mBitmapBackground = Bitmap.createBitmap(size.x, size.y,  Bitmap.Config.ARGB_8888);
+			mBitmap = Bitmap.createBitmap(size.x, size.y,
+					Bitmap.Config.ARGB_8888);
+			mCanvas = new Canvas(mBitmap);
+			mBitmapPaint = new Paint(Paint.DITHER_FLAG);
+			multiLinePathManager = new MultiLinePathManager(MAX_POINTERS);
+		}
+
+		@Override
+		protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+			super.onSizeChanged(w, h, oldw, oldh);
+		}
+
+		@Override
+		protected void onDraw(Canvas canvas) {
+			canvas.drawColor(0xFFFFFFFF);
+			canvas.drawBitmap( mBitmapBackground, 0, 0, new Paint() );
+			canvas.drawBitmap( mBitmap, 0, 0, mBitmapPaint );
+			for (int i = 0; i < multiLinePathManager.superMultiPaths.length; i++) {
+				canvas.drawPath(multiLinePathManager.superMultiPaths[i], mPaint);
+			}
+		}
+
+		@Override
+		public boolean onTouchEvent(MotionEvent event) {
+			LinePath linePath;
+			int index;
+			int id;
+			int eventMasked = event.getActionMasked();
+			switch (eventMasked) {
+				case MotionEvent.ACTION_DOWN:
+				case MotionEvent.ACTION_POINTER_DOWN: {
+					index = event.getActionIndex( );
+					id = event.getPointerId( index );
+					
+					if( extractingColor ) { //If the user chose the 'extract color' menu option, the touch event indicates where they want to extract the color from.
+						extractingColor = false;
+						
+						View v = findViewById(R.id.CanvasId);
+						v.setDrawingCacheEnabled(true);
+						Bitmap cachedBitmap = v.getDrawingCache();
+						
+						int newColor = cachedBitmap.getPixel( Math.round( event.getX( index ) ), Math.round( event.getY( index ) ) );
+						
+						v.destroyDrawingCache();
+						colorChanged( newColor );
+						
+						Toast.makeText(getApplicationContext(),
+									   R.string.color_extracted,
+									   Toast.LENGTH_SHORT).show();
+					} else {
+						
+						linePath = multiLinePathManager.addLinePathWithPointer( id );
+						if( linePath != null ) {
+							linePath.touchStart( event.getX( index ), event.getY( index ) );
+						} else {
+							Log.e( "anupam", "Too many fingers!" );
+						}
+					}
+					
+					break;
+				}
+				case MotionEvent.ACTION_MOVE:
+					for (int i = 0; i < event.getPointerCount(); i++) {
+						id = event.getPointerId(i);
+						index = event.findPointerIndex(id);
+						linePath = multiLinePathManager.findLinePathFromPointer(id);
+						if (linePath != null) {
+							linePath.touchMove(event.getX(index), event.getY(index));
+						}
+					}
+					break;
+				case MotionEvent.ACTION_UP:
+				case MotionEvent.ACTION_POINTER_UP:
+				case MotionEvent.ACTION_CANCEL:
+					index = event.getActionIndex();
+					id = event.getPointerId(index);
+					linePath = multiLinePathManager.findLinePathFromPointer(id);
+					if (linePath != null) {
+						linePath.lineTo(linePath.getLastX(), linePath.getLastY());
+	
+						// Commit the path to our offscreen
+						mCanvas.drawPath(linePath, mPaint);
+	
+						// Kill this so we don't double draw
+						linePath.reset();
+	
+						// Allow this LinePath to be associated to another idPointer
+						linePath.disassociateFromPointer();
+					}
+					break;
+			}
+			invalidate();
+			return true;
+		}
+	}
+
+	@Override
+	public boolean onCreateOptionsMenu(Menu menu) {
+		// Inflate the menu; this adds items to the action bar if it is present.
+		getMenuInflater().inflate(R.menu.main, menu);
+		return true;
+	}
+
+	@Override
+	public boolean onPrepareOptionsMenu(Menu menu) {
+		super.onPrepareOptionsMenu(menu);
+		return true;
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(MenuItem item) {
+		mPaint.setXfermode(null);
+		mPaint.setAlpha(0xFF);
+
+		switch (item.getItemId()) {
+			case R.id.normal_brush_menu:
+				mPaint.setShader( null );
+				mPaint.setMaskFilter(null);
+				return true;
+			case R.id.color_menu:
+				new ColorPickerDialog(this, this, mPaint.getColor()).show();
+				return true;
+			case R.id.emboss_menu:
+				mPaint.setShader( null );
+				mPaint.setMaskFilter(mEmboss);
+				return true;
+
+			case R.id.blur_menu:
+				mPaint.setShader( null );
+				mPaint.setMaskFilter(mBlur);
+				return true;
+			case R.id.size_menu: {
+				LayoutInflater inflater = ( LayoutInflater ) getSystemService( Context.LAYOUT_INFLATER_SERVICE );
+				View layout = inflater.inflate( R.layout.brush,
+												( ViewGroup ) findViewById( R.id.root ) );
+				AlertDialog.Builder builder = new AlertDialog.Builder( this )
+						.setView( layout );
+				builder.setTitle( R.string.choose_width );
+				final AlertDialog alertDialog = builder.create( );
+				alertDialog.show( );
+				SeekBar sb = ( SeekBar ) layout.findViewById( R.id.brushSizeSeekBar );
+				sb.setProgress( getStrokeSize( ) );
+				final TextView txt = ( TextView ) layout
+						.findViewById( R.id.sizeValueTextView );
+				txt.setText( String.format(
+						getResources( ).getString( R.string.your_selected_size_is ),
+						getStrokeSize( ) + 1 ) );
+				sb.setOnSeekBarChangeListener( new SeekBar.OnSeekBarChangeListener( ) {
+					public void onProgressChanged( SeekBar seekBar,
+												   final int progress, boolean fromUser ) {
+						// Do something here with new value
+						mPaint.setStrokeWidth( progress );
+						txt.setText( String.format(
+								getResources( ).getString(
+										R.string.your_selected_size_is ), progress + 1 ) );
+					}
+	
+					@Override
+					public void onStartTrackingTouch( SeekBar seekBar ) {
+						// TODO Auto-generated method stub
+					}
+	
+					@Override
+					public void onStopTrackingTouch( SeekBar seekBar ) {
+						// TODO Auto-generated method stub
+					}
+				} );
+				return true;
+			}
+			case R.id.erase_menu: {
+				LayoutInflater inflater_e = ( LayoutInflater ) getSystemService( Context.LAYOUT_INFLATER_SERVICE );
+				View layout_e = inflater_e.inflate( R.layout.brush,
+													( ViewGroup ) findViewById( R.id.root ) );
+				AlertDialog.Builder builder_e = new AlertDialog.Builder( this )
+						.setView( layout_e );
+				builder_e.setTitle( R.string.choose_width );
+				final AlertDialog alertDialog_e = builder_e.create( );
+				alertDialog_e.show( );
+				SeekBar sb_e = ( SeekBar ) layout_e.findViewById( R.id.brushSizeSeekBar );
+				sb_e.setProgress( getStrokeSize( ) );
+				final TextView txt_e = ( TextView ) layout_e
+						.findViewById( R.id.sizeValueTextView );
+				txt_e.setText( String.format(
+						getResources( ).getString( R.string.your_selected_size_is ),
+						getStrokeSize( ) + 1 ) );
+				sb_e.setOnSeekBarChangeListener( new SeekBar.OnSeekBarChangeListener( ) {
+					public void onProgressChanged( SeekBar seekBar,
+												   final int progress, boolean fromUser ) {
+						// Do something here with new value
+						mPaint.setStrokeWidth( progress );
+						txt_e.setText( String.format(
+								getResources( ).getString(
+										R.string.your_selected_size_is ), progress + 1 ) );
+					}
+	
+					public void onStartTrackingTouch( SeekBar seekBar ) {
+						// TODO Auto-generated method stub
+					}
+	
+					public void onStopTrackingTouch( SeekBar seekBar ) {
+						// TODO Auto-generated method stub
+					}
+				} );
+				mPaint.setShader( null );
+				mPaint.setXfermode( new PorterDuffXfermode( Mode.CLEAR ) );
+				return true;
+			}
+			case R.id.clear_all_menu: {
+				contentView.mBitmap.eraseColor( Color.TRANSPARENT );
+				return true;
+			}
+			case R.id.save_menu:
+				takeScreenshot(true);
+				break;
+			case R.id.fill_background_with_color: {
+				waitingForBackgroundColor = true;
+				new ColorPickerDialog( this, this, contentView.mBitmapBackground.getPixel( 0, 0 ) ).show();
+				return true;
+			}
+			case R.id.about_menu:
+				startActivity(new Intent(this, AboutActivity.class));
+				break;
+		}
+		return super.onOptionsItemSelected(item);
+	}
+
+	/**
+	 * This takes the screenshot of the whole screen. Is this a good thing?
+	 */
+	private File takeScreenshot(boolean showToast) {
+		View v = findViewById(R.id.CanvasId);
+		v.setDrawingCacheEnabled(true);
+		Bitmap cachedBitmap = v.getDrawingCache();
+		Bitmap copyBitmap = cachedBitmap.copy(Bitmap.Config.RGB_565, true);
+		v.destroyDrawingCache();
+		FileOutputStream output = null;
+		File file = null;
+		try {
+			File path = Places.getScreenshotFolder();
+			Calendar cal = Calendar.getInstance();
+
+			file = new File(path,
+
+			cal.get(Calendar.YEAR) + "_" + (1 + cal.get(Calendar.MONTH)) + "_"
+					+ cal.get(Calendar.DAY_OF_MONTH) + "_"
+					+ cal.get(Calendar.HOUR_OF_DAY) + "_"
+					+ cal.get(Calendar.MINUTE) + "_" + cal.get(Calendar.SECOND)
+					+ ".png");
+			output = new FileOutputStream(file);
+			copyBitmap.compress(CompressFormat.PNG, 100, output);
+		} catch (FileNotFoundException e) {
+			file = null;
+			e.printStackTrace();
+		} finally {
+			if (output != null) {
+				try {
+					output.close();
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+
+		}
+
+		if (file != null) {
+			if (showToast)
+				Toast.makeText(
+						getApplicationContext(),
+						String.format(
+								getResources().getString(
+										R.string.saved_your_location_to),
+								file.getAbsolutePath()), Toast.LENGTH_LONG)
+						.show();
+			// sending a broadcast to the media scanner so it will scan the new
+			// screenshot.
+			Intent requestScan = new Intent(
+					Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
+			requestScan.setData(Uri.fromFile(file));
+			sendBroadcast(requestScan);
+
+			return file;
+		} else {
+			return null;
+		}
+	}
+
+	private boolean isFirstTime() {
+		SharedPreferences preferences = getPreferences(MODE_PRIVATE);
+		boolean ranBefore = preferences.getBoolean("RanBefore", false);
+		if (!ranBefore) {
+			// first time
+			SharedPreferences.Editor editor = preferences.edit();
+			editor.putBoolean("RanBefore", true);
+			editor.commit();
+		}
+		return !ranBefore;
+	}
+
+	private int getStrokeSize() {
+		return (int) mPaint.getStrokeWidth();
+	}
+
+	public void onActivityResult( int requestCode, int resultCode, Intent data ) {
+		super.onActivityResult( requestCode, resultCode, data );
+
+		if( resultCode != RESULT_CANCELED ) { //"The resultCode will be RESULT_CANCELED if the activity explicitly returned that, didn't return any result, or crashed during its operation." (quote from https://developer.android.com/reference/android/app/Activity.html#onActivityResult(int,%20int,%20android.content.Intent) )
+			switch( requestCode ) {
+				case CHOOSE_IMAGE: {
+					setBackgroundUri( data.getData() );
+				}
+			}
+		}
+	}
+
+	public void setBackgroundUri(Uri uri) {
+		if (uri == null) {
+			return;
+		}
+
+		try {
+			//I don't like loading both full-sized and reduced-size copies of the image (the larger copy can use a lot of memory), but I couldn't find any other way to do this.
+			Bitmap fullsize = MediaStore.Images.Media.getBitmap(this.getContentResolver(), uri);
+			Bitmap resized = Bitmap.createScaledBitmap(fullsize, contentView.mBitmap.getWidth(), contentView.mBitmap.getHeight(), true);
+			contentView.mBitmapBackground = resized;
+			//contentView.mCanvas = new Canvas( contentView.mBitmapBackground );
+		} catch (IOException exception) {
+			//TODO: How should we handle this exception?
+		}
+	}
+
+	public void loadFromIntents() {
+		Intent intent = getIntent();
+		String action = intent.getAction();
+		String type = intent.getType();
+		System.out.println("Intentoso " + action + " type " + type);
+		if(Intent.ACTION_SEND.equals(action) && type != null) {
+			if( type.startsWith("image/") ) {
+				setBackgroundUri( (Uri) intent.getParcelableExtra(Intent.EXTRA_STREAM) );
+			}
+
+		}
+	}
+}
+++ a/acrylic/src/main/java/anupam/acrylic/GraphicsActivity.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2014 Valerio Bozzolan
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package anupam.acrylic;
+
+import android.app.Activity;
+import android.content.pm.ActivityInfo;
+import android.os.Bundle;
+import android.view.View;
+import android.view.ViewGroup;
+
+class GraphicsActivity extends Activity {
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        this.setRequestedOrientation(
+    			ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
+    }
+
+    @SuppressWarnings("unused")
+	@Override
+    public void setContentView(View view) {
+        if (false) { // set to true to test Picture
+            ViewGroup vg = new PictureLayout(this);
+            vg.addView(view);
+            view = vg;
+        }
+        super.setContentView(view);
+    }
+}
+
+++ a/acrylic/src/main/java/anupam/acrylic/MainActivity.java
@@ -0,0 +1,13 @@
+package anupam.acrylic;
+
+import android.support.v7.app.AppCompatActivity;
+import android.os.Bundle;
+
+public class MainActivity extends AppCompatActivity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_main);
+    }
+}
+++ a/acrylic/src/main/java/anupam/acrylic/PictureLayout.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright (C) 2014 Valerio Bozzolan
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package anupam.acrylic;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Picture;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.util.AttributeSet;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewParent;
+
+
+public class PictureLayout extends ViewGroup {
+	private static String error = "PictureLayout can host only one direct child";
+    private final Picture mPicture = new Picture();
+
+    public PictureLayout(Context context) {
+        super(context);
+    }
+
+    public PictureLayout(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    @Override
+    public void addView(View child) {
+        if (getChildCount() > 1) {
+            throw new IllegalStateException(error);
+        }
+
+        super.addView(child);
+    }
+
+    @Override
+    public void addView(View child, int index) {
+        if (getChildCount() > 1) {
+            throw new IllegalStateException(error);
+        }
+
+        super.addView(child, index);
+    }
+
+    @Override
+    public void addView(View child, LayoutParams params) {
+        if (getChildCount() > 1) {
+            throw new IllegalStateException(error);
+        }
+
+        super.addView(child, params);
+    }
+
+    @Override
+    public void addView(View child, int index, LayoutParams params) {
+        if (getChildCount() > 1) {
+            throw new IllegalStateException(error);
+        }
+
+        super.addView(child, index, params);
+    }
+
+    @Override
+    protected LayoutParams generateDefaultLayoutParams() {
+        return new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        final int count = getChildCount();
+
+        int maxHeight = 0;
+        int maxWidth = 0;
+
+        for (int i = 0; i < count; i++) {
+            final View child = getChildAt(i);
+            if (child.getVisibility() != GONE) {
+                measureChild(child, widthMeasureSpec, heightMeasureSpec);
+            }
+        }
+
+        maxWidth += getPaddingLeft() + getPaddingRight();
+        maxHeight += getPaddingTop() + getPaddingBottom();
+
+        Drawable drawable = getBackground();
+        if (drawable != null) {
+            maxHeight = Math.max(maxHeight, drawable.getMinimumHeight());
+            maxWidth = Math.max(maxWidth, drawable.getMinimumWidth());
+        }
+
+        setMeasuredDimension(resolveSize(maxWidth, widthMeasureSpec),
+                resolveSize(maxHeight, heightMeasureSpec));
+    }
+
+    private void drawPict(Canvas canvas, int x, int y, int w, int h,
+                          float sx, float sy) {
+        canvas.save();
+        canvas.translate(x, y);
+        canvas.clipRect(0, 0, w, h);
+        canvas.scale(0.5f, 0.5f);
+        canvas.scale(sx, sy, w, h);
+        canvas.drawPicture(mPicture);
+        canvas.restore();
+    }
+
+    @SuppressWarnings("unused")
+	@Override
+    protected void dispatchDraw(Canvas canvas) {
+        super.dispatchDraw(mPicture.beginRecording(getWidth(), getHeight()));
+        mPicture.endRecording();
+
+        int x = getWidth()/2;
+        int y = getHeight()/2;
+
+        if (false) {
+            canvas.drawPicture(mPicture);
+        } else {
+            drawPict(canvas, 0, 0, x, y,  1,  1);
+            drawPict(canvas, x, 0, x, y, -1,  1);
+            drawPict(canvas, 0, y, x, y,  1, -1);
+            drawPict(canvas, x, y, x, y, -1, -1);
+        }
+    }
+
+    @Override
+    public ViewParent invalidateChildInParent(int[] location, Rect dirty) {
+        location[0] = getLeft();
+        location[1] = getTop();
+        dirty.set(0, 0, getWidth(), getHeight());
+        return getParent();
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int l, int t, int r, int b) {
+        final int count = super.getChildCount();
+
+        for (int i = 0; i < count; i++) {
+            final View child = getChildAt(i);
+            if (child.getVisibility() != GONE) {
+                final int childLeft = getPaddingLeft();
+                final int childTop = getPaddingTop();
+                child.layout(childLeft, childTop,
+                        childLeft + child.getMeasuredWidth(),
+                        childTop + child.getMeasuredHeight());
+
+            }
+        }
+    }
+}
+++ a/acrylic/src/main/java/anupam/acrylic/Places.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2014 Valerio Bozzolan
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package anupam.acrylic;
+
+import java.io.File;
+import java.io.IOException;
+
+import android.os.Environment;
+
+public class Places {
+	public static File getScreenshotFolder() {
+		File path = new File(Environment.getExternalStorageDirectory(),
+				"/Acrylic Paint/");
+		path.mkdirs();
+
+		return path;
+	}
+
+	public static File getCameraTempFolder() {
+		File path = new File(Environment.getExternalStorageDirectory(),
+				"/Acrylic Paint/Temp/");
+		path.mkdirs();
+		// this folder should not be scanned
+		File noScanning = new File(path, ".nomedia");
+		if (!noScanning.exists())
+			try {
+				noScanning.createNewFile();
+			} catch (IOException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+		return path;
+	}
+
+	public static File getCameraTempFile() {
+		return new File(getCameraTempFolder(), "temp.jpg");
+	}
+}
+++ a/acrylic/src/main/java/anupam/acrylic/Splash.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2014 Valerio Bozzolan
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package anupam.acrylic;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.os.Bundle;
+import anupam.acrylic.R;
+
+public class Splash extends Activity {
+
+	@Override
+	protected void onCreate(Bundle savedInstanceState) {
+		// TODO Auto-generated method stub
+		super.onCreate(savedInstanceState);
+		setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
+		setContentView(R.layout.main);
+
+		Thread t = new Thread() {
+
+			public void run() {
+				try {
+					Thread.sleep(1000);
+
+					startActivity(new Intent().setClassName("anupam.acrylic",
+							"anupam.acrylic.EasyPaint"));
+					finish();
+				} catch (Exception e) {
+					e.printStackTrace();
+				}
+			}
+		};
+		t.start();
+	}
+}
+++ a/acrylic/src/main/res/layout/activity_about.xml
@@ -0,0 +1,20 @@
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:paddingBottom="@dimen/activity_vertical_margin"
+    android:paddingLeft="@dimen/activity_horizontal_margin"
+    android:paddingRight="@dimen/activity_horizontal_margin"
+    android:paddingTop="@dimen/activity_vertical_margin"
+    tools:context="anupam.acrylic.AboutActivity" >
+
+    <TextView
+        android:id="@+id/aboutTextView"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_alignParentBottom="true"
+        android:layout_alignParentLeft="true"
+        android:layout_alignParentRight="true"
+        android:layout_alignParentTop="true" />
+
+</RelativeLayout>
 \ No newline at end of file
+++ a/acrylic/src/main/res/layout/activity_main.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools" android:id="@+id/activity_main"
+    android:layout_width="match_parent" android:layout_height="match_parent"
+    android:paddingBottom="@dimen/activity_vertical_margin"
+    android:paddingLeft="@dimen/activity_horizontal_margin"
+    android:paddingRight="@dimen/activity_horizontal_margin"
+    android:paddingTop="@dimen/activity_vertical_margin"
+    tools:context="anupam.acrylic.MainActivity">
+
+    <TextView android:layout_width="wrap_content" android:layout_height="wrap_content"
+        android:text="Hello World!" />
+</RelativeLayout>
+++ a/acrylic/src/main/res/layout/brush.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/root"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent"
+    android:orientation="vertical" >
+
+    <SeekBar
+        android:id="@+id/brushSizeSeekBar"
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content"
+        android:layout_alignParentLeft="true"
+        android:layout_alignParentTop="true"
+        android:layout_marginTop="20dp"
+        android:max="99"
+        android:paddingLeft="30dp"
+        android:paddingRight="30dp" >
+    </SeekBar>
+
+    <TextView
+        android:id="@+id/sizeValueTextView"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_alignParentLeft="true"
+        android:layout_alignParentRight="true"
+        android:layout_below="@+id/brushSizeSeekBar"
+        android:layout_marginTop="5dp"
+        android:layout_marginBottom="10dp"
+        android:gravity="center_horizontal" />
+
+</RelativeLayout>
 \ No newline at end of file
+++ a/acrylic/src/main/res/layout/main.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent"
+    android:background="@drawable/splash"
+    android:orientation="vertical" >
+
+</LinearLayout>
 \ No newline at end of file
+++ a/acrylic/src/main/res/menu/main.xml
@@ -0,0 +1,64 @@
+<?xml version="1.0" encoding="utf-8"?>
+<menu xmlns:android="http://schemas.android.com/apk/res/android" >
+
+    <item
+        android:id="@+id/color_menu"
+        android:icon="@drawable/color"
+        android:showAsAction="ifRoom"
+        android:title="@string/color"/>
+    <item
+        android:id="@+id/size_menu"
+        android:icon="@drawable/size"
+        android:showAsAction="ifRoom"
+        android:title="@string/brush_size">
+    </item>
+    <item
+        android:id="@+id/erase_menu"
+        android:icon="@drawable/erase"
+        android:showAsAction="ifRoom"
+        android:title="@string/erase">
+    </item>
+    <item
+        android:id="@+id/clear_all_menu"
+        android:icon="@drawable/clear_all"
+        android:showAsAction="ifRoom"
+        android:title="@string/clear_all">
+    </item>
+    <item
+        android:id="@+id/normal_brush_menu"
+        android:icon="@drawable/size"
+        android:showAsAction="ifRoom"
+        android:title="@string/normal">
+    </item>
+    <item
+        android:id="@+id/emboss_menu"
+        android:icon="@drawable/emboss"
+        android:showAsAction="ifRoom"
+        android:title="@string/emboss">
+    </item>
+    <item
+        android:id="@+id/blur_menu"
+        android:icon="@drawable/blur"
+        android:showAsAction="ifRoom"
+        android:title="@string/blur">
+    </item>
+    <item
+        android:id="@+id/save_menu"
+        android:icon="@drawable/save"
+        android:showAsAction="ifRoom"
+        android:title="@string/save">
+    </item>
+    <item
+        android:id="@+id/fill_background_with_color"
+        android:icon="@drawable/fill_background_with_color"
+        android:showAsAction="ifRoom"
+        android:title="@string/fill_background_with_color">
+    </item>
+    <item
+        android:id="@+id/about_menu"
+        android:icon="@drawable/about"
+        android:showAsAction="ifRoom"
+        android:title="@string/about">
+    </item>
+
+</menu>