src/com/android/gallery3d/filtershow/PanelController.java

   1 /*
   2  * Copyright (C) 2012 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.gallery3d.filtershow;
  18
  19 import android.content.Context;
  20 import android.text.Html;
  21 import android.view.MenuItem;
  22 import android.view.View;
  23 import android.view.View.OnClickListener;
  24 import android.view.ViewPropertyAnimator;
  25 import android.widget.PopupMenu;
  26 import android.widget.TextView;
  27
  28 import com.android.gallery3d.R;
  29 import com.android.gallery3d.filtershow.filters.ImageFilter;
  30 import com.android.gallery3d.filtershow.filters.ImageFilterContrast;
  31 import com.android.gallery3d.filtershow.filters.ImageFilterCurves;
  32 import com.android.gallery3d.filtershow.filters.ImageFilterExposure;
  33 import com.android.gallery3d.filtershow.filters.ImageFilterHue;
  34 import com.android.gallery3d.filtershow.filters.ImageFilterRedEye;
  35 import com.android.gallery3d.filtershow.filters.ImageFilterSaturated;
  36 import com.android.gallery3d.filtershow.filters.ImageFilterShadows;
  37 import com.android.gallery3d.filtershow.filters.ImageFilterSharpen;
  38 import com.android.gallery3d.filtershow.filters.ImageFilterTinyPlanet;
  39 import com.android.gallery3d.filtershow.filters.ImageFilterVibrance;
  40 import com.android.gallery3d.filtershow.filters.ImageFilterVignette;
  41 import com.android.gallery3d.filtershow.filters.ImageFilterWBalance;
  42 import com.android.gallery3d.filtershow.imageshow.ImageCrop;
  43 import com.android.gallery3d.filtershow.imageshow.ImageShow;
  44 import com.android.gallery3d.filtershow.presets.ImagePreset;
  45 import com.android.gallery3d.filtershow.ui.FramedTextButton;
  46 import com.android.gallery3d.filtershow.ui.ImageButtonTitle;
  47 import com.android.gallery3d.filtershow.ui.ImageCurves;
  48
  49 import java.util.HashMap;
  50 import java.util.Vector;
  51
  52 public class PanelController implements OnClickListener {
  53     private static int PANEL = 0;
  54     private static int COMPONENT = 1;
  55     private static int VERTICAL_MOVE = 0;
  56     private static int HORIZONTAL_MOVE = 1;
  57     private static final int ANIM_DURATION = 200;
  58     private static final String LOGTAG = "PanelController";
  59
  60     class Panel {
  61         private final View mView;
  62         private final View mContainer;
  63         private int mPosition = 0;
  64         private final Vector<View> mSubviews = new Vector<View>();
  65
  66         public Panel(View view, View container, int position) {
  67             mView = view;
  68             mContainer = container;
  69             mPosition = position;
  70         }
  71
  72         public void addView(View view) {
  73             mSubviews.add(view);
  74         }
  75
  76         public int getPosition() {
  77             return mPosition;
  78         }
  79
  80         public ViewPropertyAnimator unselect(int newPos, int move) {
  81             ViewPropertyAnimator anim = mContainer.animate();
  82             mView.setSelected(false);
  83             mContainer.setX(0);
  84             mContainer.setY(0);
  85             int delta = 0;
  86             int w = mRowPanel.getWidth();
  87             int h = mRowPanel.getHeight();
  88             if (move == HORIZONTAL_MOVE) {
  89                 if (newPos > mPosition) {
  90                     delta = -w;
  91                 } else {
  92                     delta = w;
  93                 }
  94                 anim.x(delta);
  95             } else if (move == VERTICAL_MOVE) {
  96                 anim.y(h);
  97             }
  98             anim.setDuration(ANIM_DURATION).withLayer().withEndAction(new Runnable() {
  99                 @Override
 100                 public void run() {
 101                     mContainer.setVisibility(View.GONE);
 102                 }
 103             });
 104             return anim;
 105         }
 106
 107         public ViewPropertyAnimator select(int oldPos, int move) {
 108             mView.setSelected(true);
 109             mContainer.setVisibility(View.VISIBLE);
 110             mContainer.setX(0);
 111             mContainer.setY(0);
 112             ViewPropertyAnimator anim = mContainer.animate();
 113             int w = mRowPanel.getWidth();
 114             int h = mRowPanel.getHeight();
 115             if (move == HORIZONTAL_MOVE) {
 116                 if (oldPos < mPosition) {
 117                     mContainer.setX(w);
 118                 } else {
 119                     mContainer.setX(-w);
 120                 }
 121                 anim.x(0);
 122             } else if (move == VERTICAL_MOVE) {
 123                 mContainer.setY(h);
 124                 anim.y(0);
 125             }
 126             anim.setDuration(ANIM_DURATION).withLayer();
 127             return anim;
 128         }
 129     }
 130
 131     class UtilityPanel {
 132         private final Context mContext;
 133         private final View mView;
 134         private final TextView mTextView;
 135         private boolean mSelected = false;
 136         private String mEffectName = null;
 137         private int mParameterValue = 0;
 138         private boolean mShowParameterValue = false;
 139         private View mAspectButton = null;
 140         private View mCurvesButton = null;
 141         private int mCurrentAspectButton = 0;
 142         private static final int NUMBER_OF_ASPECT_BUTTONS = 6;
 143         private static final int ASPECT_NONE = 0;
 144         private static final int ASPECT_1TO1 = 1;
 145         private static final int ASPECT_5TO7 = 2;
 146         private static final int ASPECT_4TO6 = 3;
 147         private static final int ASPECT_16TO9 = 4;
 148         private static final int ASPECT_ORIG = 5;
 149
 150         public UtilityPanel(Context context, View view, View textView,
 151                 View aspectButton, View curvesButton) {
 152             mContext = context;
 153             mView = view;
 154             mTextView = (TextView) textView;
 155             mAspectButton = aspectButton;
 156             mCurvesButton = curvesButton;
 157         }
 158
 159         public boolean selected() {
 160             return mSelected;
 161         }
 162
 163         public void setAspectButton(FramedTextButton button, int itemId) {
 164             ImageCrop imageCrop = (ImageCrop) mCurrentImage;
 165             switch (itemId) {
 166                 case R.id.crop_menu_1to1: {
 167                     button.setText(mContext.getString(R.string.aspect1to1_effect));
 168                     imageCrop.apply(1, 1);
 169                     break;
 170                 }
 171                 case R.id.crop_menu_4to6: {
 172                     button.setText(mContext.getString(R.string.aspect4to6_effect));
 173                     imageCrop.apply(6, 4);
 174                     break;
 175                 }
 176                 case R.id.crop_menu_5to7: {
 177                     button.setText(mContext.getString(R.string.aspect5to7_effect));
 178                     imageCrop.apply(7, 5);
 179                     break;
 180                 }
 181                 case R.id.crop_menu_9to16: {
 182                     button.setText(mContext.getString(R.string.aspect9to16_effect));
 183                     imageCrop.apply(16, 9);
 184                     break;
 185                 }
 186                 case R.id.crop_menu_none: {
 187                     button.setText(mContext.getString(R.string.aspectNone_effect));
 188                     imageCrop.applyClear();
 189                     break;
 190                 }
 191                 case R.id.crop_menu_original: {
 192                     button.setText(mContext.getString(R.string.aspectOriginal_effect));
 193                     imageCrop.applyOriginal();
 194                     break;
 195                 }
 196             }
 197             imageCrop.invalidate();
 198         }
 199
 200         public void nextAspectButton() {
 201             if (mAspectButton instanceof ImageButtonTitle
 202                     && mCurrentImage instanceof ImageCrop) {
 203                 switch (mCurrentAspectButton) {
 204                     case ASPECT_NONE:
 205                         ((ImageButtonTitle) mAspectButton).setText(mContext
 206                                 .getString(R.string.aspect)
 207                                 + " "
 208                                 + mContext.getString(R.string.aspect1to1_effect));
 209                         ((ImageCrop) mCurrentImage).apply(1, 1);
 210                         break;
 211                     case ASPECT_1TO1:
 212                         ((ImageButtonTitle) mAspectButton).setText(mContext
 213                                 .getString(R.string.aspect)
 214                                 + " "
 215                                 + mContext.getString(R.string.aspect5to7_effect));
 216                         ((ImageCrop) mCurrentImage).apply(7, 5);
 217                         break;
 218                     case ASPECT_5TO7:
 219                         ((ImageButtonTitle) mAspectButton).setText(mContext
 220                                 .getString(R.string.aspect)
 221                                 + " "
 222                                 + mContext.getString(R.string.aspect4to6_effect));
 223                         ((ImageCrop) mCurrentImage).apply(6, 4);
 224                         break;
 225                     case ASPECT_4TO6:
 226                         ((ImageButtonTitle) mAspectButton).setText(mContext
 227                                 .getString(R.string.aspect)
 228                                 + " "
 229                                 + mContext.getString(R.string.aspect9to16_effect));
 230                         ((ImageCrop) mCurrentImage).apply(16, 9);
 231                         break;
 232                     case ASPECT_16TO9:
 233                         ((ImageButtonTitle) mAspectButton).setText(mContext
 234                                 .getString(R.string.aspect)
 235                                 + " "
 236                                 + mContext.getString(R.string.aspectOriginal_effect));
 237                         ((ImageCrop) mCurrentImage).applyOriginal();
 238                         break;
 239                     case ASPECT_ORIG:
 240                         ((ImageButtonTitle) mAspectButton).setText(mContext
 241                                 .getString(R.string.aspect)
 242                                 + " "
 243                                 + mContext.getString(R.string.aspectNone_effect));
 244                         ((ImageCrop) mCurrentImage).applyClear();
 245                         break;
 246                     default:
 247                         ((ImageButtonTitle) mAspectButton).setText(mContext
 248                                 .getString(R.string.aspect)
 249                                 + " "
 250                                 + mContext.getString(R.string.aspectNone_effect));
 251                         ((ImageCrop) mCurrentImage).applyClear();
 252                         mCurrentAspectButton = ASPECT_NONE;
 253                         break;
 254                 }
 255                 mCurrentAspectButton = (mCurrentAspectButton + 1) % NUMBER_OF_ASPECT_BUTTONS;
 256             }
 257         }
 258
 259         void setCurrentAspectButton(int n) {
 260             mCurrentAspectButton = n;
 261         }
 262
 263         public void showAspectButtons() {
 264             if (mAspectButton != null)
 265                 mAspectButton.setVisibility(View.VISIBLE);
 266         }
 267
 268         public void hideAspectButtons() {
 269             if (mAspectButton != null)
 270                 mAspectButton.setVisibility(View.GONE);
 271         }
 272
 273         public void showCurvesButtons() {
 274             if (mCurvesButton != null)
 275                 mCurvesButton.setVisibility(View.VISIBLE);
 276         }
 277
 278         public void hideCurvesButtons() {
 279             if (mCurvesButton != null)
 280                 mCurvesButton.setVisibility(View.GONE);
 281         }
 282
 283         public void onNewValue(int value) {
 284             mParameterValue = value;
 285             updateText();
 286         }
 287
 288         public void setEffectName(String effectName) {
 289             mEffectName = effectName;
 290             setShowParameter(true);
 291         }
 292
 293         public void setShowParameter(boolean s) {
 294             mShowParameterValue = s;
 295             updateText();
 296         }
 297
 298         public void updateText() {
 299             String apply = mContext.getString(R.string.apply_effect);
 300             if (mShowParameterValue) {
 301                 mTextView.setText(Html.fromHtml(apply + " " + mEffectName + " "
 302                         + mParameterValue));
 303             } else {
 304                 mTextView.setText(Html.fromHtml(apply + " " + mEffectName));
 305             }
 306         }
 307
 308         public ViewPropertyAnimator unselect() {
 309             ViewPropertyAnimator anim = mView.animate();
 310             mView.setX(0);
 311             mView.setY(0);
 312             int h = mRowPanel.getHeight();
 313             anim.y(-h);
 314             anim.setDuration(ANIM_DURATION).withLayer().withEndAction(new Runnable() {
 315                 @Override
 316                 public void run() {
 317                     mView.setVisibility(View.GONE);
 318                 }
 319             });
 320             mSelected = false;
 321             return anim;
 322         }
 323
 324         public ViewPropertyAnimator select() {
 325             mView.setVisibility(View.VISIBLE);
 326             int h = mRowPanel.getHeight();
 327             mView.setX(0);
 328             mView.setY(-h);
 329             updateText();
 330             ViewPropertyAnimator anim = mView.animate();
 331             anim.y(0);
 332             anim.setDuration(ANIM_DURATION).withLayer();
 333             mSelected = true;
 334             return anim;
 335         }
 336     }
 337
 338     class ViewType {
 339         private final int mType;
 340         private final View mView;
 341
 342         public ViewType(View view, int type) {
 343             mView = view;
 344             mType = type;
 345         }
 346
 347         public int type() {
 348             return mType;
 349         }
 350     }
 351
 352     private final HashMap<View, Panel> mPanels = new HashMap<View, Panel>();
 353     private final HashMap<View, ViewType> mViews = new HashMap<View, ViewType>();
 354     private final Vector<View> mImageViews = new Vector<View>();
 355     private View mCurrentPanel = null;
 356     private View mRowPanel = null;
 357     private UtilityPanel mUtilityPanel = null;
 358     private ImageShow mMasterImage = null;
 359     private ImageShow mCurrentImage = null;
 360
 361     public void addView(View view) {
 362         view.setOnClickListener(this);
 363         mViews.put(view, new ViewType(view, COMPONENT));
 364     }
 365
 366     public void addPanel(View view, View container, int position) {
 367         mPanels.put(view, new Panel(view, container, position));
 368         view.setOnClickListener(this);
 369         mViews.put(view, new ViewType(view, PANEL));
 370     }
 371
 372     public void addComponent(View aPanel, View component) {
 373         Panel panel = mPanels.get(aPanel);
 374         if (panel == null) {
 375             return;
 376         }
 377         panel.addView(component);
 378         component.setOnClickListener(this);
 379         mViews.put(component, new ViewType(component, COMPONENT));
 380     }
 381
 382     public void addImageView(View view) {
 383         mImageViews.add(view);
 384         ImageShow imageShow = (ImageShow) view;
 385         imageShow.setPanelController(this);
 386     }
 387
 388     public void resetParameters() {
 389         showPanel(mCurrentPanel);
 390         if (mCurrentImage != null) {
 391             mCurrentImage.resetParameter();
 392             mCurrentImage.select();
 393         }
 394     }
 395
 396     public boolean onBackPressed() {
 397         if (mUtilityPanel == null || !mUtilityPanel.selected()) {
 398             return true;
 399         }
 400         HistoryAdapter adapter = mMasterImage.getHistory();
 401         int position = adapter.undo();
 402         mMasterImage.onItemClick(position);
 403         showPanel(mCurrentPanel);
 404         mCurrentImage.select();
 405         return false;
 406     }
 407
 408     public void onNewValue(int value) {
 409         mUtilityPanel.onNewValue(value);
 410     }
 411
 412     public void showParameter(boolean s) {
 413         mUtilityPanel.setShowParameter(s);
 414     }
 415
 416     public void setCurrentPanel(View panel) {
 417         showPanel(panel);
 418     }
 419
 420     public void setRowPanel(View rowPanel) {
 421         mRowPanel = rowPanel;
 422     }
 423
 424     public void setUtilityPanel(Context context, View utilityPanel, View textView,
 425             View aspectButton, View curvesButton) {
 426         mUtilityPanel = new UtilityPanel(context, utilityPanel, textView,
 427                 aspectButton, curvesButton);
 428     }
 429
 430     public void setMasterImage(ImageShow imageShow) {
 431         mMasterImage = imageShow;
 432     }
 433
 434     @Override
 435     public void onClick(View view) {
 436         ViewType type = mViews.get(view);
 437         if (type.type() == PANEL) {
 438             showPanel(view);
 439         } else if (type.type() == COMPONENT) {
 440             showComponent(view);
 441         }
 442     }
 443
 444     public ImageShow showImageView(int id) {
 445         ImageShow image = null;
 446         for (View view : mImageViews) {
 447             if (view.getId() == id) {
 448                 view.setVisibility(View.VISIBLE);
 449                 image = (ImageShow) view;
 450             } else {
 451                 view.setVisibility(View.GONE);
 452             }
 453         }
 454         return image;
 455     }
 456
 457     public void showDefaultImageView() {
 458         showImageView(R.id.imageShow).setShowControls(false);
 459         mMasterImage.setCurrentFilter(null);
 460     }
 461
 462     public void showPanel(View view) {
 463         view.setVisibility(View.VISIBLE);
 464         boolean removedUtilityPanel = false;
 465         Panel current = mPanels.get(mCurrentPanel);
 466         if (mUtilityPanel != null && mUtilityPanel.selected()) {
 467             ViewPropertyAnimator anim1 = mUtilityPanel.unselect();
 468             removedUtilityPanel = true;
 469             anim1.start();
 470             if (mCurrentPanel == view) {
 471                 ViewPropertyAnimator anim2 = current.select(-1, VERTICAL_MOVE);
 472                 anim2.start();
 473                 showDefaultImageView();
 474             }
 475         }
 476
 477         if (mCurrentPanel == view) {
 478             return;
 479         }
 480
 481         Panel panel = mPanels.get(view);
 482         if (!removedUtilityPanel) {
 483             int currentPos = -1;
 484             if (current != null) {
 485                 currentPos = current.getPosition();
 486             }
 487             ViewPropertyAnimator anim1 = panel.select(currentPos, HORIZONTAL_MOVE);
 488             anim1.start();
 489             if (current != null) {
 490                 ViewPropertyAnimator anim2 = current.unselect(panel.getPosition(), HORIZONTAL_MOVE);
 491                 anim2.start();
 492             }
 493         } else {
 494             ViewPropertyAnimator anim = panel.select(-1, VERTICAL_MOVE);
 495             anim.start();
 496         }
 497         showDefaultImageView();
 498         mCurrentPanel = view;
 499     }
 500
 501     public ImagePreset getImagePreset() {
 502         return mMasterImage.getImagePreset();
 503     }
 504
 505     public ImageFilter setImagePreset(ImageFilter filter, String name) {
 506         ImagePreset copy = new ImagePreset(getImagePreset());
 507         copy.add(filter);
 508         copy.setHistoryName(name);
 509         copy.setIsFx(false);
 510         mMasterImage.setImagePreset(copy);
 511         return filter;
 512     }
 513
 514     public void ensureFilter(String name) {
 515         ImagePreset preset = getImagePreset();
 516         ImageFilter filter = preset.getFilter(name);
 517         if (filter != null) {
 518             // If we already have a filter, we might still want
 519             // to push it onto the history stack.
 520             ImagePreset copy = new ImagePreset(getImagePreset());
 521             copy.setHistoryName(name);
 522             mMasterImage.setImagePreset(copy);
 523             filter = copy.getFilter(name);
 524         }
 525
 526         if (filter == null && name.equalsIgnoreCase(
 527                 mCurrentImage.getContext().getString(R.string.curvesRGB))) {
 528             filter = setImagePreset(new ImageFilterCurves(), name);
 529         }
 530         if (filter == null && name.equalsIgnoreCase(
 531                 mCurrentImage.getContext().getString(R.string.tinyplanet))) {
 532             filter = setImagePreset(new ImageFilterTinyPlanet(), name);
 533         }
 534         if (filter == null
 535                 && name.equalsIgnoreCase(mCurrentImage.getContext().getString(R.string.vignette))) {
 536             filter = setImagePreset(new ImageFilterVignette(), name);
 537         }
 538         if (filter == null
 539                 && name.equalsIgnoreCase(mCurrentImage.getContext().getString(R.string.sharpness))) {
 540             filter = setImagePreset(new ImageFilterSharpen(), name);
 541         }
 542         if (filter == null
 543                 && name.equalsIgnoreCase(mCurrentImage.getContext().getString(R.string.contrast))) {
 544             filter = setImagePreset(new ImageFilterContrast(), name);
 545         }
 546         if (filter == null
 547                 && name.equalsIgnoreCase(mCurrentImage.getContext().getString(R.string.saturation))) {
 548             filter = setImagePreset(new ImageFilterSaturated(), name);
 549         }
 550         if (filter == null
 551                 && name.equalsIgnoreCase(mCurrentImage.getContext().getString(R.string.hue))) {
 552             filter = setImagePreset(new ImageFilterHue(), name);
 553         }
 554         if (filter == null
 555                 && name.equalsIgnoreCase(mCurrentImage.getContext().getString(R.string.exposure))) {
 556             filter = setImagePreset(new ImageFilterExposure(), name);
 557         }
 558         if (filter == null
 559                 && name.equalsIgnoreCase(mCurrentImage.getContext().getString(R.string.vibrance))) {
 560             filter = setImagePreset(new ImageFilterVibrance(), name);
 561         }
 562         if (filter == null
 563                 && name.equalsIgnoreCase(mCurrentImage.getContext().getString(
 564                         R.string.shadow_recovery))) {
 565             filter = setImagePreset(new ImageFilterShadows(), name);
 566         }
 567         if (filter == null
 568                 && name.equalsIgnoreCase(mCurrentImage.getContext().getString(R.string.redeye))) {
 569             filter = setImagePreset(new ImageFilterRedEye(), name);
 570         }
 571         if (filter == null
 572                 && name.equalsIgnoreCase(mCurrentImage.getContext().getString(R.string.wbalance))) {
 573             filter = setImagePreset(new ImageFilterWBalance(), name);
 574         }
 575         mMasterImage.setCurrentFilter(filter);
 576     }
 577
 578     private void showCurvesPopupMenu(final ImageCurves curves, final FramedTextButton anchor) {
 579         PopupMenu popupMenu = new PopupMenu(mCurrentImage.getContext(), anchor);
 580         popupMenu.getMenuInflater().inflate(R.menu.filtershow_menu_curves, popupMenu.getMenu());
 581         popupMenu.setOnMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() {
 582             @Override
 583             public boolean onMenuItemClick(MenuItem item) {
 584                 curves.setChannel(item.getItemId());
 585                 anchor.setTextFrom(item.getItemId());
 586                 return true;
 587             }
 588         });
 589         popupMenu.show();
 590     }
 591
 592     private void showCropPopupMenu(final FramedTextButton anchor) {
 593         PopupMenu popupMenu = new PopupMenu(mCurrentImage.getContext(), anchor);
 594         popupMenu.getMenuInflater().inflate(R.menu.filtershow_menu_crop, popupMenu.getMenu());
 595         popupMenu.setOnMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() {
 596             @Override
 597             public boolean onMenuItemClick(MenuItem item) {
 598                 mUtilityPanel.setAspectButton(anchor, item.getItemId());
 599                 return true;
 600             }
 601         });
 602         popupMenu.show();
 603     }
 604
 605     public void showComponent(View view) {
 606         if (mUtilityPanel != null && !mUtilityPanel.selected()) {
 607             Panel current = mPanels.get(mCurrentPanel);
 608             ViewPropertyAnimator anim1 = current.unselect(-1, VERTICAL_MOVE);
 609             anim1.start();
 610             if (mUtilityPanel != null) {
 611                 ViewPropertyAnimator anim2 = mUtilityPanel.select();
 612                 anim2.start();
 613             }
 614         }
 615
 616         if (view.getId() == R.id.pickCurvesChannel) {
 617             ImageCurves curves = (ImageCurves) showImageView(R.id.imageCurves);
 618             showCurvesPopupMenu(curves, (FramedTextButton) view);
 619             return;
 620         }
 621
 622         if (view.getId() == R.id.aspect) {
 623             showCropPopupMenu((FramedTextButton) view);
 624             return;
 625         }
 626
 627         if (mCurrentImage != null) {
 628             mCurrentImage.unselect();
 629         }
 630         mUtilityPanel.hideAspectButtons();
 631         mUtilityPanel.hideCurvesButtons();
 632         switch (view.getId()) {
 633             case R.id.tinyplanetButton: {
 634                 mCurrentImage = showImageView(R.id.imageShow).setShowControls(true);
 635                 String ename = mCurrentImage.getContext().getString(R.string.tinyplanet);
 636                 mUtilityPanel.setEffectName(ename);
 637                 ensureFilter(ename);
 638                 break;
 639             }
 640             case R.id.straightenButton: {
 641                 mCurrentImage = showImageView(R.id.imageStraighten);
 642                 String ename = mCurrentImage.getContext().getString(R.string.straighten);
 643                 mUtilityPanel.setEffectName(ename);
 644                 break;
 645             }
 646             case R.id.cropButton: {
 647                 mCurrentImage = showImageView(R.id.imageCrop);
 648                 String ename = mCurrentImage.getContext().getString(R.string.crop);
 649                 mUtilityPanel.setEffectName(ename);
 650                 mUtilityPanel.setShowParameter(false);
 651                 mUtilityPanel.setCurrentAspectButton(-1);
 652                 mUtilityPanel.nextAspectButton();
 653                 mUtilityPanel.showAspectButtons();
 654                 break;
 655             }
 656             case R.id.rotateButton: {
 657                 mCurrentImage = showImageView(R.id.imageRotate);
 658                 String ename = mCurrentImage.getContext().getString(R.string.rotate);
 659                 mUtilityPanel.setEffectName(ename);
 660                 break;
 661             }
 662             case R.id.flipButton: {
 663                 mCurrentImage = showImageView(R.id.imageFlip);
 664                 String ename = mCurrentImage.getContext().getString(R.string.mirror);
 665                 mUtilityPanel.setEffectName(ename);
 666                 mUtilityPanel.setShowParameter(false);
 667                 break;
 668             }
 669             case R.id.vignetteButton: {
 670                 mCurrentImage = showImageView(R.id.imageShow).setShowControls(true);
 671                 String ename = mCurrentImage.getContext().getString(R.string.vignette);
 672                 mUtilityPanel.setEffectName(ename);
 673                 ensureFilter(ename);
 674                 break;
 675             }
 676             case R.id.curvesButtonRGB: {
 677                 ImageCurves curves = (ImageCurves) showImageView(R.id.imageCurves);
 678                 String ename = curves.getContext().getString(R.string.curvesRGB);
 679                 mUtilityPanel.setEffectName(ename);
 680                 mUtilityPanel.setShowParameter(false);
 681                 mUtilityPanel.showCurvesButtons();
 682                 mCurrentImage = curves;
 683                 ensureFilter(ename);
 684                 break;
 685             }
 686             case R.id.sharpenButton: {
 687                 mCurrentImage = showImageView(R.id.imageZoom).setShowControls(true);
 688                 String ename = mCurrentImage.getContext().getString(R.string.sharpness);
 689                 mUtilityPanel.setEffectName(ename);
 690                 ensureFilter(ename);
 691                 break;
 692             }
 693             case R.id.contrastButton: {
 694                 mCurrentImage = showImageView(R.id.imageShow).setShowControls(true);
 695                 String ename = mCurrentImage.getContext().getString(R.string.contrast);
 696                 mUtilityPanel.setEffectName(ename);
 697                 ensureFilter(ename);
 698                 break;
 699             }
 700             case R.id.saturationButton: {
 701                 mCurrentImage = showImageView(R.id.imageShow).setShowControls(true);
 702                 String ename = mCurrentImage.getContext().getString(R.string.saturation);
 703                 mUtilityPanel.setEffectName(ename);
 704                 ensureFilter(ename);
 705                 break;
 706             }
 707             case R.id.wbalanceButton: {
 708                 mCurrentImage = showImageView(R.id.imageShow).setShowControls(false);
 709                 String ename = mCurrentImage.getContext().getString(R.string.wbalance);
 710                 mUtilityPanel.setEffectName(ename);
 711                 mUtilityPanel.setShowParameter(false);
 712                 ensureFilter(ename);
 713                 break;
 714             }
 715             case R.id.hueButton: {
 716                 mCurrentImage = showImageView(R.id.imageShow).setShowControls(true);
 717                 String ename = mCurrentImage.getContext().getString(R.string.hue);
 718                 mUtilityPanel.setEffectName(ename);
 719                 ensureFilter(ename);
 720                 break;
 721             }
 722             case R.id.exposureButton: {
 723                 mCurrentImage = showImageView(R.id.imageShow).setShowControls(true);
 724                 String ename = mCurrentImage.getContext().getString(R.string.exposure);
 725                 mUtilityPanel.setEffectName(ename);
 726                 ensureFilter(ename);
 727                 break;
 728             }
 729             case R.id.vibranceButton: {
 730                 mCurrentImage = showImageView(R.id.imageShow).setShowControls(true);
 731                 String ename = mCurrentImage.getContext().getString(R.string.vibrance);
 732                 mUtilityPanel.setEffectName(ename);
 733                 ensureFilter(ename);
 734                 break;
 735             }
 736             case R.id.shadowRecoveryButton: {
 737                 mCurrentImage = showImageView(R.id.imageShow).setShowControls(true);
 738                 String ename = mCurrentImage.getContext().getString(R.string.shadow_recovery);
 739                 mUtilityPanel.setEffectName(ename);
 740                 ensureFilter(ename);
 741                 break;
 742             }
 743             case R.id.redEyeButton: {
 744                 mCurrentImage = showImageView(R.id.imageShow).setShowControls(true);
 745                 String ename = mCurrentImage.getContext().getString(R.string.redeye);
 746                 mUtilityPanel.setEffectName(ename);
 747                 ensureFilter(ename);
 748                 break;
 749             }
 750             case R.id.aspect: {
 751                 mUtilityPanel.nextAspectButton();
 752                 mUtilityPanel.showAspectButtons();
 753                 break;
 754             }
 755             case R.id.applyEffect: {
 756                 showPanel(mCurrentPanel);
 757                 break;
 758             }
 759         }
 760         mCurrentImage.select();
 761     }
 762 }