@Override
  public boolean onTouch(View v, MotionEvent event) {
    float pos = event.getY();

    if (event.getAction() == 0) mLastYPos = pos;

    if (event.getAction() > 1) {
      int scrollThreshold = DisplayUtils.dpToPx(getActivity(), 2);
      if (((mLastYPos - pos) > scrollThreshold) || ((pos - mLastYPos) > scrollThreshold))
        mScrollDetected = true;
    }

    mLastYPos = pos;

    if (event.getAction() == MotionEvent.ACTION_UP) {
      ActionBar actionBar = getActionBar();
      if (actionBar != null && actionBar.isShowing()) {
        setContentEditingModeVisible(true);
        return false;
      }
    }

    if (event.getAction() == MotionEvent.ACTION_UP && !mScrollDetected) {
      Layout layout = ((TextView) v).getLayout();
      int x = (int) event.getX();
      int y = (int) event.getY();

      x += v.getScrollX();
      y += v.getScrollY();
      if (layout != null) {
        int line = layout.getLineForVertical(y);
        int charPosition = layout.getOffsetForHorizontal(line, x);

        Spannable spannable = mContentEditText.getText();
        if (spannable == null) {
          return false;
        }
        // check if image span was tapped
        WPImageSpan[] imageSpans =
            spannable.getSpans(charPosition, charPosition, WPImageSpan.class);

        if (imageSpans.length != 0) {
          final WPImageSpan imageSpan = imageSpans[0];
          MediaFile mediaFile = imageSpan.getMediaFile();
          if (mediaFile == null) return false;
          if (!mediaFile.isVideo()) {
            LayoutInflater factory = LayoutInflater.from(getActivity());
            final View alertView = factory.inflate(R.layout.alert_image_options, null);
            if (alertView == null) return false;
            final EditText imageWidthText = (EditText) alertView.findViewById(R.id.imageWidthText);
            final EditText titleText = (EditText) alertView.findViewById(R.id.title);
            final EditText caption = (EditText) alertView.findViewById(R.id.caption);
            final CheckBox featuredCheckBox = (CheckBox) alertView.findViewById(R.id.featuredImage);
            final CheckBox featuredInPostCheckBox =
                (CheckBox) alertView.findViewById(R.id.featuredInPost);

            // show featured image checkboxes if supported
            if (mFeaturedImageSupported) {
              featuredCheckBox.setVisibility(View.VISIBLE);
              featuredInPostCheckBox.setVisibility(View.VISIBLE);
            }

            featuredCheckBox.setOnCheckedChangeListener(
                new CompoundButton.OnCheckedChangeListener() {
                  @Override
                  public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                    if (isChecked) {
                      featuredInPostCheckBox.setVisibility(View.VISIBLE);
                    } else {
                      featuredInPostCheckBox.setVisibility(View.GONE);
                    }
                  }
                });

            final SeekBar seekBar = (SeekBar) alertView.findViewById(R.id.imageWidth);
            final Spinner alignmentSpinner =
                (Spinner) alertView.findViewById(R.id.alignment_spinner);
            ArrayAdapter<CharSequence> adapter =
                ArrayAdapter.createFromResource(
                    getActivity(), R.array.alignment_array, android.R.layout.simple_spinner_item);
            adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
            alignmentSpinner.setAdapter(adapter);

            imageWidthText.setText(String.valueOf(mediaFile.getWidth()) + "px");
            seekBar.setProgress(mediaFile.getWidth());
            titleText.setText(mediaFile.getTitle());
            caption.setText(mediaFile.getCaption());
            featuredCheckBox.setChecked(mediaFile.isFeatured());

            if (mediaFile.isFeatured()) {
              featuredInPostCheckBox.setVisibility(View.VISIBLE);
            } else {
              featuredInPostCheckBox.setVisibility(View.GONE);
            }

            featuredInPostCheckBox.setChecked(mediaFile.isFeaturedInPost());

            alignmentSpinner.setSelection(mediaFile.getHorizontalAlignment(), true);

            final int maxWidth =
                MediaUtils.getMinimumImageWidth(
                    getActivity(), imageSpan.getImageSource(), mBlogSettingMaxImageWidth);
            seekBar.setMax(maxWidth / 10);
            if (mediaFile.getWidth() != 0) {
              seekBar.setProgress(mediaFile.getWidth() / 10);
            }
            seekBar.setOnSeekBarChangeListener(
                new SeekBar.OnSeekBarChangeListener() {
                  @Override
                  public void onStopTrackingTouch(SeekBar seekBar) {}

                  @Override
                  public void onStartTrackingTouch(SeekBar seekBar) {}

                  @Override
                  public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
                    if (progress == 0) {
                      progress = 1;
                    }
                    imageWidthText.setText(progress * 10 + "px");
                  }
                });

            imageWidthText.setOnFocusChangeListener(
                new View.OnFocusChangeListener() {
                  @Override
                  public void onFocusChange(View v, boolean hasFocus) {
                    if (hasFocus) {
                      imageWidthText.setText("");
                    }
                  }
                });

            imageWidthText.setOnEditorActionListener(
                new TextView.OnEditorActionListener() {
                  @Override
                  public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
                    int width = getEditTextIntegerClamped(imageWidthText, 10, maxWidth);
                    seekBar.setProgress(width / 10);
                    imageWidthText.setSelection((String.valueOf(width).length()));

                    InputMethodManager imm =
                        (InputMethodManager)
                            getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
                    imm.hideSoftInputFromWindow(
                        imageWidthText.getWindowToken(), InputMethodManager.RESULT_UNCHANGED_SHOWN);

                    return true;
                  }
                });

            showImageSettings(
                alertView,
                titleText,
                caption,
                imageWidthText,
                featuredCheckBox,
                featuredInPostCheckBox,
                maxWidth,
                alignmentSpinner,
                imageSpan);
            mScrollDetected = false;
            return true;
          }

        } else {
          mContentEditText.setMovementMethod(ArrowKeyMovementMethod.getInstance());
          int selectionStart = mContentEditText.getSelectionStart();
          if (selectionStart >= 0 && mContentEditText.getSelectionEnd() >= selectionStart)
            mContentEditText.setSelection(selectionStart, mContentEditText.getSelectionEnd());
        }

        // get media gallery spans
        MediaGalleryImageSpan[] gallerySpans =
            spannable.getSpans(charPosition, charPosition, MediaGalleryImageSpan.class);
        if (gallerySpans.length > 0) {
          final MediaGalleryImageSpan gallerySpan = gallerySpans[0];
          Intent intent = new Intent(ACTION_MEDIA_GALLERY_TOUCHED);
          intent.putExtra(EXTRA_MEDIA_GALLERY, gallerySpan.getMediaGallery());
          getActivity().sendBroadcast(intent);
        }
      }
    } else if (event.getAction() == 1) {
      mScrollDetected = false;
    }
    return false;
  }
    private String uploadImage(MediaFile mediaFile) {
      AppLog.d(T.POSTS, "uploadImage: " + mediaFile.getFilePath());

      if (mediaFile.getFilePath() == null) {
        return null;
      }

      Uri imageUri = Uri.parse(mediaFile.getFilePath());
      File imageFile = null;
      String mimeType = "", path = "";

      if (imageUri.toString().contains("content:")) {
        String[] projection =
            new String[] {Images.Media._ID, Images.Media.DATA, Images.Media.MIME_TYPE};

        Cursor cur = mContext.getContentResolver().query(imageUri, projection, null, null, null);
        if (cur != null && cur.moveToFirst()) {
          int dataColumn = cur.getColumnIndex(Images.Media.DATA);
          int mimeTypeColumn = cur.getColumnIndex(Images.Media.MIME_TYPE);

          String thumbData = cur.getString(dataColumn);
          mimeType = cur.getString(mimeTypeColumn);
          imageFile = new File(thumbData);
          path = thumbData;
          mediaFile.setFilePath(imageFile.getPath());
        }
      } else { // file is not in media library
        path = imageUri.toString().replace("file://", "");
        imageFile = new File(path);
        mediaFile.setFilePath(path);
      }

      // check if the file exists
      if (imageFile == null) {
        mErrorMessage = mContext.getString(R.string.file_not_found);
        return null;
      }

      if (TextUtils.isEmpty(mimeType)) {
        mimeType = MediaUtils.getMediaFileMimeType(imageFile);
      }
      String fileName = MediaUtils.getMediaFileName(imageFile, mimeType);
      String fileExtension = MimeTypeMap.getFileExtensionFromUrl(fileName).toLowerCase();

      int orientation = ImageUtils.getImageOrientation(mContext, path);

      String resizedPictureURL = null;

      // We need to upload a resized version of the picture when the blog settings != original size,
      // or when
      // the user has selected a smaller size for the current picture in the picture settings screen
      // We won't resize gif images to keep them awesome.
      boolean shouldUploadResizedVersion = false;
      // If it's not a gif and blog don't keep original size, there is a chance we need to resize
      if (!mimeType.equals("image/gif") && !mBlog.getMaxImageWidth().equals("Original Size")) {
        // check the picture settings
        int pictureSettingWidth = mediaFile.getWidth();
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(path, options);
        int imageHeight = options.outHeight;
        int imageWidth = options.outWidth;
        int[] dimensions = {imageWidth, imageHeight};
        if (dimensions[0] != 0 && dimensions[0] != pictureSettingWidth) {
          shouldUploadResizedVersion = true;
        }
      }

      boolean shouldAddImageWidthCSS = false;

      if (shouldUploadResizedVersion) {
        MediaFile resizedMediaFile = new MediaFile(mediaFile);
        // Create resized image
        byte[] bytes =
            ImageUtils.createThumbnailFromUri(
                mContext, imageUri, resizedMediaFile.getWidth(), fileExtension, orientation);

        if (bytes == null) {
          // We weren't able to resize the image, so we will upload the full size image with css to
          // resize it
          shouldUploadResizedVersion = false;
          shouldAddImageWidthCSS = true;
        } else {
          // Save temp image
          String tempFilePath;
          File resizedImageFile;
          try {
            resizedImageFile = File.createTempFile("wp-image-", fileExtension);
            FileOutputStream out = new FileOutputStream(resizedImageFile);
            out.write(bytes);
            out.close();
            tempFilePath = resizedImageFile.getPath();
          } catch (IOException e) {
            AppLog.w(T.POSTS, "failed to create image temp file");
            mErrorMessage = mContext.getString(R.string.error_media_upload);
            return null;
          }

          // upload resized picture
          if (!TextUtils.isEmpty(tempFilePath)) {
            resizedMediaFile.setFilePath(tempFilePath);
            Map<String, Object> parameters = new HashMap<String, Object>();

            parameters.put("name", fileName);
            parameters.put("type", mimeType);
            parameters.put("bits", resizedMediaFile);
            parameters.put("overwrite", true);
            resizedPictureURL = uploadImageFile(parameters, resizedMediaFile, mBlog);
            if (resizedPictureURL == null) {
              AppLog.w(T.POSTS, "failed to upload resized picture");
              return null;
            } else if (resizedImageFile.exists()) {
              resizedImageFile.delete();
            }
          } else {
            AppLog.w(T.POSTS, "failed to create resized picture");
            mErrorMessage = mContext.getString(R.string.out_of_memory);
            return null;
          }
        }
      }

      String fullSizeUrl = null;
      // Upload the full size picture if "Original Size" is selected in settings,
      // or if 'link to full size' is checked.
      if (!shouldUploadResizedVersion || mBlog.isFullSizeImage()) {
        Map<String, Object> parameters = new HashMap<String, Object>();
        parameters.put("name", fileName);
        parameters.put("type", mimeType);
        parameters.put("bits", mediaFile);
        parameters.put("overwrite", true);

        fullSizeUrl = uploadImageFile(parameters, mediaFile, mBlog);
        if (fullSizeUrl == null) {
          mErrorMessage = mContext.getString(R.string.error_media_upload);
          return null;
        }
      }

      return mediaFile.getImageHtmlForUrls(fullSizeUrl, resizedPictureURL, shouldAddImageWidthCSS);
    }